chore(sync): snapshot local changes

Author: Aitomates

src/GsdOrchestrator.Tests/GsdStateMachineTests.cs

@@ -40,7 +40,7 @@ private static IWorkflowState MakeState(WorkflowState from, WorkflowState to)
         var state = Substitute.For<IWorkflowState>();
         state.State.Returns(from);
         state.ExecuteAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
-            .Returns(ci => Task.FromResult(ci.Arg<GsdWorkflowContext>() with { CurrentState = to }));
+            .Returns(ci => Task.FromResult(ci.Arg<GsdWorkflowContext>().Transition(to)));
         return state;
     }
 
@@ -84,15 +84,17 @@ public async Task RunAsync_StateThrowsException_ContextTransitionsToFailed()
     }
 
     [Fact]
-    public async Task RunAsync_NoHandlerForState_ThrowsInvalidOperationException()
+    public async Task RunAsync_NoHandlerForState_ReturnsFailedContext()
     {
         var checkpoints = Substitute.For<ICheckpointStore>();
 
         // No states registered — Idle has no handler, throws before SaveAsync
         var sut = BuildSut(checkpoints, []);
 
-        await Assert.ThrowsAsync<InvalidOperationException>(
-            () => sut.RunAsync("owner", "repo", 1, triageModeOnly: false, CancellationToken.None));
+        var ctx = await sut.RunAsync("owner", "repo", 1, triageModeOnly: false, CancellationToken.None);
+
+        Assert.Equal(WorkflowState.Failed, ctx.CurrentState);
+        Assert.Equal(TerminalStopReason.Unknown, ctx.StopReason);
     }
 
     [Fact]
@@ -116,6 +118,197 @@ await checkpoints.Received(3).SaveAsync(
             Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>());
     }
 
+    [Fact]
+    public async Task RunAsync_FailedState_RecordsRollbackOriginAndReason()
+    {
+        var checkpoints = Substitute.For<ICheckpointStore>();
+        checkpoints.SaveAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
+            .Returns(Task.CompletedTask);
+
+        var idleState = Substitute.For<IWorkflowState>();
+        idleState.State.Returns(WorkflowState.Idle);
+        idleState.ExecuteAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
+            .ThrowsAsync(new InvalidOperationException("simulated failure"));
+
+        var sut = BuildSut(checkpoints, [idleState]);
+
+        var ctx = await sut.RunAsync("owner", "repo", 1, triageModeOnly: false, CancellationToken.None);
+
+        Assert.Equal(WorkflowState.Failed, ctx.CurrentState);
+        Assert.NotNull(ctx.SdlcRun);
+        Assert.Equal("simulated failure", ctx.SdlcRun!.RollbackReason);
+        Assert.Equal("understand", ctx.SdlcRun.RollbackOrigin);
+        Assert.Equal(1, ctx.SdlcRun.NoProgressCount);
+    }
+
+    [Fact]
+    public async Task RunAsync_AdvancesSdlcBudgets_DuringExecution()
+    {
+        var checkpoints = Substitute.For<ICheckpointStore>();
+        checkpoints.SaveAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
+            .Returns(Task.CompletedTask);
+        checkpoints.ArchiveAsync(Arg.Any<string>(), Arg.Any<CancellationToken>())
+            .Returns(Task.CompletedTask);
+
+        var idleState = MakeState(WorkflowState.Idle, WorkflowState.Done);
+        var sut = BuildSut(checkpoints, [idleState]);
+
+        var ctx = await sut.RunAsync("owner", "repo", 11, triageModeOnly: false, CancellationToken.None);
+
+        Assert.Equal(WorkflowState.Done, ctx.CurrentState);
+        Assert.NotNull(ctx.SdlcRun);
+        Assert.Equal(1, ctx.SdlcRun!.AttemptCount);
+        Assert.Equal(1, ctx.SdlcRun.IterationCount);
+        Assert.Equal(1, ctx.SdlcRun.ModelCallCount);
+    }
+
+    [Fact]
+    public async Task ResumeAsync_FailedState_RequestsRollbackAndResumes()
+    {
+        var checkpoints = Substitute.For<ICheckpointStore>();
+        var savedCtx = new GsdWorkflowContext
+        {
+            WorkflowId = "rollback-wf",
+            CurrentState = WorkflowState.Analyzing,
+            Issue = new IssueContext(7, "Test issue", "", [], "owner", "repo", "main")
+        }.WithSdlcRun("Rollback test");
+        checkpoints.LoadAsync("rollback-wf", Arg.Any<CancellationToken>())
+            .Returns(savedCtx);
+        checkpoints.SaveAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
+            .Returns(Task.CompletedTask);
+        checkpoints.ArchiveAsync(Arg.Any<string>(), Arg.Any<CancellationToken>())
+            .Returns(Task.CompletedTask);
+
+        var analyzingState = Substitute.For<IWorkflowState>();
+        analyzingState.State.Returns(WorkflowState.Analyzing);
+        analyzingState.ExecuteAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
+            .ThrowsAsync(new InvalidOperationException("verify failed"));
+
+        var idleState = MakeState(WorkflowState.Idle, WorkflowState.Done);
+        var sut = BuildSut(checkpoints, [idleState, analyzingState]);
+
+        var ctx = await sut.ResumeAsync("rollback-wf", CancellationToken.None);
+
+        Assert.Equal(WorkflowState.Done, ctx.CurrentState);
+        Assert.NotNull(ctx.SdlcRun);
+        Assert.Equal("understand", ctx.SdlcRun!.RollbackOrigin);
+        Assert.Equal("verify failed", ctx.SdlcRun.RollbackReason);
+        Assert.Null(ctx.PendingRollback);
+    }
+
+    [Fact]
+    public async Task RunAsync_DoneState_RecordsMemoryCandidateAndTerminalOutcome()
+    {
+        var checkpoints = Substitute.For<ICheckpointStore>();
+        checkpoints.SaveAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
+            .Returns(Task.CompletedTask);
+        checkpoints.ArchiveAsync(Arg.Any<string>(), Arg.Any<CancellationToken>())
+            .Returns(Task.CompletedTask);
+
+        var idleState = MakeState(WorkflowState.Idle, WorkflowState.Done);
+        var sut = BuildSut(checkpoints, [idleState]);
+
+        var ctx = await sut.RunAsync("owner", "repo", 12, triageModeOnly: false, CancellationToken.None);
+
+        Assert.Equal(WorkflowState.Done, ctx.CurrentState);
+        Assert.NotNull(ctx.SdlcRun);
+        Assert.Equal("passed", ctx.SdlcRun!.TerminalOutcome);
+        Assert.NotNull(ctx.SdlcRun.MemoryCandidateRecords);
+        Assert.NotEmpty(ctx.SdlcRun.MemoryCandidateRecords!);
+        Assert.Equal("update-memory", ctx.SdlcRun.MemoryCandidateRecords![0].PhaseId);
+    }
+
+    [Fact]
+    public async Task RunAsync_GoalAttemptBudgetExceeded_SetsTypedStopReason()
+    {
+        var checkpoints = Substitute.For<ICheckpointStore>();
+        var savedCtx = new GsdWorkflowContext
+        {
+            WorkflowId = "wf-budget",
+            CurrentState = WorkflowState.Idle,
+            Issue = new IssueContext(1, "Budget", "", [], "owner", "repo", "main"),
+            SdlcRun = SdlcRunRecord.Create("wf-budget", "Budget", SdlcProfile.CasSdlcV1) with
+            {
+                AttemptCount = SdlcProfile.CasSdlcV1.GoalAttempts + 1
+            }
+        };
+        checkpoints.LoadAsync("wf-budget", Arg.Any<CancellationToken>())
+            .Returns(savedCtx);
+        checkpoints.SaveAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
+            .Returns(Task.CompletedTask);
+
+        var idleState = Substitute.For<IWorkflowState>();
+        idleState.State.Returns(WorkflowState.Idle);
+        idleState.ExecuteAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
+            .Returns(ci => Task.FromResult(ci.Arg<GsdWorkflowContext>().Transition(WorkflowState.Done)));
+
+        var sut = BuildSut(checkpoints, [idleState]);
+
+        var ctx = await sut.ResumeAsync("wf-budget", CancellationToken.None);
+
+        Assert.Equal(WorkflowState.Failed, ctx.CurrentState);
+        Assert.Equal(TerminalStopReason.BudgetExhausted, ctx.StopReason);
+    }
+
+    [Fact]
+    public async Task RunAsync_RuntimeMinuteBudgetExceeded_SetsTypedStopReason()
+    {
+        var checkpoints = Substitute.For<ICheckpointStore>();
+        var savedCtx = new GsdWorkflowContext
+        {
+            WorkflowId = "wf-runtime",
+            CurrentState = WorkflowState.Idle,
+            Issue = new IssueContext(1, "Runtime", "", [], "owner", "repo", "main"),
+            SdlcRun = SdlcRunRecord.Create("wf-runtime", "Runtime", SdlcProfile.CasSdlcV1) with
+            {
+                StartedAt = DateTimeOffset.UtcNow.AddMinutes(-(SdlcProfile.CasSdlcV1.RuntimeMinutes + 1))
+            }
+        };
+        checkpoints.LoadAsync("wf-runtime", Arg.Any<CancellationToken>())
+            .Returns(savedCtx);
+        checkpoints.SaveAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
+            .Returns(Task.CompletedTask);
+
+        var idleState = Substitute.For<IWorkflowState>();
+        idleState.State.Returns(WorkflowState.Idle);
+        idleState.ExecuteAsync(Arg.Any<GsdWorkflowContext>(), Arg.Any<CancellationToken>())
+            .Returns(ci => Task.FromResult(ci.Arg<GsdWorkflowContext>().Transition(WorkflowState.Done)));
+
+        var sut = BuildSut(checkpoints, [idleState]);
+
+        var ctx = await sut.ResumeAsync("wf-runtime", CancellationToken.None);
+
+        Assert.Equal(WorkflowState.Failed, ctx.CurrentState);
+        Assert.Equal(TerminalStopReason.RuntimeExceeded, ctx.StopReason);
+    }
+
+    [Fact]
+    public void RecordTerminalOutcome_IsIdempotent()
+    {
+        var run = SdlcRunRecord.Create("wf-terminal", "Terminal", SdlcProfile.CasSdlcV1);
+
+        var once = run.RecordTerminalOutcome("passed");
+        var twice = once.RecordTerminalOutcome("failed");
+
+        Assert.Equal("passed", once.TerminalOutcome);
+        Assert.Equal("passed", twice.TerminalOutcome);
+    }
+
+    [Fact]
+    public void RecordVerification_PersistsInvalidatedPhases()
+    {
+        var run = SdlcRunRecord.Create("wf-invalidated", "Invalidated", SdlcProfile.CasSdlcV1);
+        var updated = run.RecordVerification(new SdlcVerificationRecord(
+            "research",
+            "repo-verifier",
+            Passed: false,
+            InvalidatedPhaseIds: ["understand", "research"],
+            Reason: "missing evidence"));
+
+        Assert.Equal(["understand", "research"], updated.InvalidatedPhaseIds);
+        Assert.Single(updated.Verifications!);
+    }
+
     [Fact]
     public async Task ResumeAsync_CheckpointExists_ResumesFromSavedState()
     {
@@ -175,4 +368,5 @@ public async Task RunAsync_CancellationRequested_ThrowsOperationCanceledExceptio
         await Assert.ThrowsAsync<OperationCanceledException>(
             () => sut.RunAsync("owner", "repo", 1, triageModeOnly: false, cts.Token));
     }
+
 }

src/GsdOrchestrator.Tests/States/CheckpointStoreTests.cs

@@ -88,7 +88,8 @@ public async Task SaveAsync_ThenLoadAsync_RoundTripsContext()
         {
             WorkflowId = "wf-roundtrip",
             Issue = new IssueContext(7, "Round trip", "body", [], "owner", "repo", "main"),
-            CurrentState = WorkflowState.Branching
+            CurrentState = WorkflowState.Branching,
+            SdlcRun = SdlcRunRecord.Create("wf-roundtrip", "Round trip", SdlcProfile.CasSdlcV1)
         };
         await _store.SaveAsync(ctx);
 
@@ -97,6 +98,34 @@ public async Task SaveAsync_ThenLoadAsync_RoundTripsContext()
         Assert.NotNull(loaded);
         Assert.Equal(WorkflowState.Branching, loaded!.CurrentState);
         Assert.Equal(7, loaded.Issue!.Number);
+        Assert.NotNull(loaded.SdlcRun);
+        Assert.Equal("wf-roundtrip", loaded.SdlcRun!.RunId);
+        Assert.Equal("understand", loaded.SdlcRun.CurrentPhaseId);
+    }
+
+    [Fact]
+    public async Task SaveAsync_ThenLoadAsync_PreservesVerificationOutcome()
+    {
+        var ctx = new GsdWorkflowContext
+        {
+            WorkflowId = "wf-verification",
+            Issue = new IssueContext(7, "Verification", "body", [], "owner", "repo", "main"),
+            SdlcRun = SdlcRunRecord.Create("wf-verification", "Verification", SdlcProfile.CasSdlcV1)
+        }.WithSdlcVerification(new SdlcVerificationOutcome(
+            "research",
+            "repo-verifier",
+            Passed: false,
+            InvalidatedPhaseIds: ["understand"],
+            Reason: "research evidence missing"));
+
+        await _store.SaveAsync(ctx);
+        var loaded = await _store.LoadAsync("wf-verification");
+
+        Assert.NotNull(loaded);
+        Assert.NotNull(loaded!.SdlcRun);
+        Assert.Equal("understand", loaded.SdlcRun!.RollbackOrigin);
+        Assert.Equal("research evidence missing", loaded.SdlcRun.RollbackReason);
+        Assert.Equal(1, loaded.SdlcRun.NoProgressCount);
     }
 
     // CHECKPOINT-02: missing checkpoint returns null

src/GsdOrchestrator.Tests/States/SdlcProfileTests.cs

@@ -0,0 +1,82 @@
+using GsdOrchestrator.Workflows.Models;
+using Xunit;
+
+namespace GsdOrchestrator.Tests.States;
+
+public class SdlcProfileTests
+{
+    [Fact]
+    public void CasSdlcV1_ContainsTwelvePhases_InFiveBatches()
+    {
+        var profile = SdlcProfile.CasSdlcV1;
+
+        Assert.Equal("cas-sdlc-v1", profile.ProfileId);
+        Assert.Equal("v1.1", profile.ProfileVersion);
+        Assert.Equal(12, profile.Phases.Count);
+        Assert.Contains(profile.Phases, phase => phase.Id == "understand" && phase.Batch == SdlcBatch.Discovery);
+        Assert.Contains(profile.Phases, phase => phase.Id == "risk-assessment" && phase.Batch == SdlcBatch.Design);
+        Assert.Contains(profile.Phases, phase => phase.Id == "implement" && phase.Batch == SdlcBatch.Change);
+        Assert.Contains(profile.Phases, phase => phase.Id == "review" && phase.Batch == SdlcBatch.Assurance);
+        Assert.Contains(profile.Phases, phase => phase.Id == "finished" && phase.Batch == SdlcBatch.Closure);
+    }
+
+    [Fact]
+    public void GsdWorkflowContext_DefaultsToCasSdlcProfile()
+    {
+        var ctx = new GsdWorkflowContext();
+
+        Assert.Equal("1.0", ctx.SchemaVersion);
+        Assert.Equal(SdlcProfile.CasSdlcV1, ctx.SdlcProfile);
+    }
+
+    [Fact]
+    public void Transition_KeepsPhaseIdentityButResetsWorkflowState()
+    {
+        var ctx = new GsdWorkflowContext().WithSdlcRun("Improve the loop");
+
+        var next = ctx.Transition(WorkflowState.Branching);
+
+        Assert.NotNull(next.SdlcRun);
+        Assert.Equal("understand", next.SdlcRun!.CurrentPhaseId);
+        Assert.Equal("repo-verifier", next.SdlcRun.CurrentVerifier);
+        Assert.Equal(WorkflowState.Branching, next.CurrentState);
+    }
+
+    [Fact]
+    public void WithSdlcVerification_UpdatesPhaseAndRollbackMetadata()
+    {
+        var ctx = new GsdWorkflowContext().WithSdlcRun("Improve the loop");
+        var next = ctx.WithSdlcVerification(new SdlcVerificationOutcome(
+            "research",
+            "repo-verifier",
+            Passed: false,
+            InvalidatedPhaseIds: ["understand"],
+            Reason: "evidence missing"));
+
+        Assert.NotNull(next.SdlcRun);
+        Assert.Equal("research", next.SdlcRun!.CurrentPhaseId);
+        Assert.Equal(SdlcPhaseStatus.Failed, next.SdlcRun.CurrentPhaseStatus);
+        Assert.Equal("understand", next.SdlcRun.RollbackOrigin);
+        Assert.Equal("evidence missing", next.SdlcRun.RollbackReason);
+    }
+
+    [Fact]
+    public void ResolveRollbackOrigin_UsesInvalidatedPhaseWhenProvided()
+    {
+        var profile = SdlcProfile.CasSdlcV1;
+
+        var rollbackOrigin = profile.ResolveRollbackOrigin("verify", ["research", "analyze"]);
+
+        Assert.Equal("research", rollbackOrigin);
+    }
+
+    [Fact]
+    public void NextPhaseId_ReturnsNextSequentialPhase()
+    {
+        var profile = SdlcProfile.CasSdlcV1;
+
+        Assert.Equal("research", profile.NextPhaseId("understand"));
+        Assert.Equal("finished", profile.NextPhaseId("update-memory"));
+        Assert.Null(profile.NextPhaseId("finished"));
+    }
+}