gsd-pi 2.41.0 → 2.42.0-dev.1df898f

package/src/resources/extensions/gsd/tests/auto-loop.test.ts

@@ -337,7 +337,7 @@ function makeMockDeps(
     pruneQueueOrder: () => {},
     isInAutoWorktree: () => false,
     shouldUseWorktreeIsolation: () => false,
-    mergeMilestoneToMain: () => ({ pushed: false }),
+    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
     teardownAutoWorktree: () => {},
     createAutoWorktree: () => "/tmp/wt",
     captureIntegrationBranch: () => {},
@@ -416,6 +416,7 @@ function makeMockDeps(
     getSessionFile: () => "/tmp/session.json",
     rebuildState: async () => {},
     resolveModelId: (id: string, models: any[]) => models.find((m: any) => m.id === id),
+    emitJournalEvent: () => {},
   };
 
   const merged = { ...baseDeps, ...overrides, callLog };
@@ -594,7 +595,6 @@ test("autoLoop calls deriveState → resolveDispatch → runUnit in sequence", a
   ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
   const pi = makeMockPi();
 
-  let loopCount = 0;
   const s = makeLoopSession();
 
   const deps = makeMockDeps({
@@ -620,11 +620,8 @@ test("autoLoop calls deriveState → resolveDispatch → runUnit in sequence", a
     },
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
-      loopCount++;
-      // After first iteration, deactivate to exit the loop
-      if (loopCount >= 1) {
-        s.active = false;
-      }
+      // Deactivate after first iteration to exit the loop
+      s.active = false;
       return "continue" as const;
     },
   });
@@ -682,7 +679,6 @@ test("crash lock records session file from AFTER newSession, not before (#1710)"
   };
   const pi = makeMockPi();
 
-  let loopCount = 0;
   const s = makeLoopSession({
     cmdCtx: {
       newSession: () => {
@@ -730,10 +726,8 @@ test("crash lock records session file from AFTER newSession, not before (#1710)"
     },
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
-      loopCount++;
-      if (loopCount >= 1) {
-        s.active = false;
-      }
+      // Deactivate after first iteration to exit the loop
+      s.active = false;
       return "continue" as const;
     },
   });
@@ -790,6 +784,23 @@ test("autoLoop handles verification retry by continuing loop", async (t) => {
   let deriveCallCount = 0;
   const s = makeLoopSession();
 
+  // Pre-queued verification actions: each entry provides a side-effect + return value
+  type VerifyAction = { sideEffect?: () => void; response: "retry" | "continue" };
+  const verificationActions: VerifyAction[] = [
+    {
+      sideEffect: () => {
+        // Simulate retry — set pendingVerificationRetry on session
+        s.pendingVerificationRetry = {
+          unitId: "M001/S01/T01",
+          failureContext: "test failed: expected X got Y",
+          attempt: 1,
+        };
+      },
+      response: "retry",
+    },
+    { response: "continue" },
+  ];
+
   const deps = makeMockDeps({
     deriveState: async () => {
       deriveCallCount++;
@@ -804,19 +815,11 @@ test("autoLoop handles verification retry by continuing loop", async (t) => {
       } as any;
     },
     runPostUnitVerification: async () => {
+      const action = verificationActions[verifyCallCount] ?? { response: "continue" as const };
       verifyCallCount++;
       deps.callLog.push("runPostUnitVerification");
-      if (verifyCallCount === 1) {
-        // First call: simulate retry — set pendingVerificationRetry on session
-        s.pendingVerificationRetry = {
-          unitId: "M001/S01/T01",
-          failureContext: "test failed: expected X got Y",
-          attempt: 1,
-        };
-        return "retry" as const;
-      }
-      // Second call: pass
-      return "continue" as const;
+      action.sideEffect?.();
+      return action.response;
     },
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
@@ -893,19 +896,17 @@ test("autoLoop handles dispatch skip action by continuing", async (t) => {
   const s = makeLoopSession();
 
   let dispatchCallCount = 0;
+  // Pre-queued dispatch responses: first call returns "skip", second returns "stop"
+  const dispatchResponses = [
+    { action: "skip" as const },
+    { action: "stop" as const, reason: "done", level: "info" as const },
+  ];
   const deps = makeMockDeps({
     resolveDispatch: async () => {
+      const response = dispatchResponses[dispatchCallCount] ?? dispatchResponses[dispatchResponses.length - 1];
       dispatchCallCount++;
       deps.callLog.push("resolveDispatch");
-      if (dispatchCallCount === 1) {
-        return { action: "skip" as const };
-      }
-      // Second time: stop to exit the loop
-      return {
-        action: "stop" as const,
-        reason: "done",
-        level: "info" as const,
-      };
+      return response;
     },
   });
 
@@ -935,22 +936,26 @@ test("autoLoop drains sidecar queue after postUnitPostVerification enqueues item
   const s = makeLoopSession();
 
   let postVerCallCount = 0;
+  const postVerActions: Array<() => void> = [
+    () => {
+      // First call (main unit): enqueue a sidecar item
+      s.sidecarQueue.push({
+        kind: "hook" as const,
+        unitType: "hook/review",
+        unitId: "M001/S01/T01/review",
+        prompt: "review the code",
+      });
+    },
+    () => {
+      // Second call (sidecar unit completed): deactivate
+      s.active = false;
+    },
+  ];
   const deps = makeMockDeps({
     postUnitPostVerification: async () => {
+      postVerActions[postVerCallCount]?.();
       postVerCallCount++;
       deps.callLog.push("postUnitPostVerification");
-      if (postVerCallCount === 1) {
-        // First call (main unit): enqueue a sidecar item
-        s.sidecarQueue.push({
-          kind: "hook" as const,
-          unitType: "hook/review",
-          unitId: "M001/S01/T01/review",
-          prompt: "review the code",
-        });
-        return "continue" as const;
-      }
-      // Second call (sidecar unit completed): done
-      s.active = false;
       return "continue" as const;
     },
   });
@@ -1118,13 +1123,13 @@ test("startAuto calls selfHealRuntimeRecords before autoLoop (#1727)", () => {
   assert.ok(healIdx > -1, "startAuto must call selfHealRuntimeRecords");
   assert.ok(healIdx < loopIdx, "selfHealRuntimeRecords must be called before autoLoop");
 
-  // Verify the second autoLoop call site also has selfHeal before it
+  // Verify the second autoLoop call site also has selfHeal before it (if present)
   const secondLoopIdx = fnBlock.indexOf("autoLoop(", loopIdx + 1);
-  if (secondLoopIdx > -1) {
-    const secondHealIdx = fnBlock.indexOf("selfHealRuntimeRecords", healIdx + 1);
-    assert.ok(secondHealIdx > -1, "second autoLoop call must also have selfHealRuntimeRecords");
-    assert.ok(secondHealIdx < secondLoopIdx, "second selfHealRuntimeRecords must precede second autoLoop");
-  }
+  const secondHealIdx = fnBlock.indexOf("selfHealRuntimeRecords", healIdx + 1);
+  assert.ok(
+    secondLoopIdx === -1 || (secondHealIdx > -1 && secondHealIdx < secondLoopIdx),
+    "if a second autoLoop call exists, it must also be preceded by selfHealRuntimeRecords",
+  );
 });
 
 test("agent_end handler calls resolveAgentEnd (not handleAgentEnd)", () => {
@@ -1286,25 +1291,29 @@ test("stuck detection: window resets recovery when deriveState returns a differe
   const s = makeLoopSession();
 
   let deriveCallCount = 0;
+  let postVerCallCount = 0;
   let stopCalled = false;
 
+  // First 3 derives return T01, 4th returns T02; dispatch follows the derived task
+  const derivedTaskIds = ["T01", "T01", "T01", "T02"];
+
   const deps = makeMockDeps({
     deriveState: async () => {
+      const taskId = derivedTaskIds[Math.min(deriveCallCount, derivedTaskIds.length - 1)];
       deriveCallCount++;
       deps.callLog.push("deriveState");
       return {
         phase: "executing",
         activeMilestone: { id: "M001", title: "Test", status: "active" },
         activeSlice: { id: "S01", title: "Slice 1" },
-        activeTask: { id: deriveCallCount <= 3 ? "T01" : "T02" },
+        activeTask: { id: taskId },
         registry: [{ id: "M001", status: "active" }],
         blockers: [],
       } as any;
     },
     resolveDispatch: async () => {
+      const taskId = derivedTaskIds[Math.min(deriveCallCount - 1, derivedTaskIds.length - 1)];
       deps.callLog.push("resolveDispatch");
-      // Return dispatch matching the task from deriveState
-      const taskId = deriveCallCount <= 3 ? "T01" : "T02";
       return {
         action: "dispatch" as const,
         unitType: "execute-task",
@@ -1318,11 +1327,11 @@ test("stuck detection: window resets recovery when deriveState returns a differe
       s.active = false;
     },
     postUnitPostVerification: async () => {
+      postVerCallCount++;
       deps.callLog.push("postUnitPostVerification");
-      // After 4th iteration (unit changed on iter 4), exit
-      if (deriveCallCount >= 4) {
-        s.active = false;
-      }
+      // Exit on the 4th call (after T02 unit completes)
+      const shouldExit = postVerCallCount >= 4;
+      s.active = !shouldExit;
       return "continue" as const;
     },
   });
@@ -1361,6 +1370,14 @@ test("stuck detection: does not push to window during verification retry", async
   let verifyCallCount = 0;
   let stopReason = "";
 
+  // Pre-queued responses: 3 retries then a continue (exit)
+  const verifyActions: Array<() => "retry" | "continue"> = [
+    () => { s.pendingVerificationRetry = { unitId: "M001/S01/T01", failureContext: "test failed", attempt: 1 }; return "retry"; },
+    () => { s.pendingVerificationRetry = { unitId: "M001/S01/T01", failureContext: "test failed", attempt: 2 }; return "retry"; },
+    () => { s.pendingVerificationRetry = { unitId: "M001/S01/T01", failureContext: "test failed", attempt: 3 }; return "retry"; },
+    () => { s.active = false; return "continue"; },
+  ];
+
   const deps = makeMockDeps({
     deriveState: async () =>
       ({
@@ -1378,20 +1395,10 @@ test("stuck detection: does not push to window during verification retry", async
       prompt: "do the thing",
     }),
     runPostUnitVerification: async () => {
+      const action = verifyActions[verifyCallCount] ?? (() => { s.active = false; return "continue" as const; });
       verifyCallCount++;
       deps.callLog.push("runPostUnitVerification");
-      if (verifyCallCount <= 3) {
-        // Set pendingVerificationRetry — should prevent stuck counter increment
-        s.pendingVerificationRetry = {
-          unitId: "M001/S01/T01",
-          failureContext: "test failed",
-          attempt: verifyCallCount,
-        };
-        return "retry" as const;
-      }
-      // After 3 retries, exit gracefully
-      s.active = false;
-      return "continue" as const;
+      return action();
     },
     stopAuto: async (_ctx?: any, _pi?: any, reason?: string) => {
       deps.callLog.push("stopAuto");
@@ -1543,7 +1550,7 @@ test("autoLoop lifecycle: advances through research → plan → execute → ver
   const dispatchedUnitTypes: string[] = [];
 
   // Phase sequence: each deriveState call returns a different phase.
-  // On the 6th call (start of iteration 6), we deactivate to exit.
+  // The 6th entry (index 5) is the terminal "complete" phase that stops the loop.
   const phases = [
     // Call 1: researching → dispatches research-slice
     {
@@ -1575,6 +1582,12 @@ test("autoLoop lifecycle: advances through research → plan → execute → ver
       activeSlice: { id: "S01", title: "Complete Slice" },
       activeTask: null,
     },
+    // Call 6: terminal — deactivate to exit the loop
+    {
+      phase: "complete",
+      activeSlice: null,
+      activeTask: null,
+    },
   ];
 
   const dispatches = [
@@ -1587,46 +1600,26 @@ test("autoLoop lifecycle: advances through research → plan → execute → ver
 
   const deps = makeMockDeps({
     deriveState: async () => {
+      const p = phases[Math.min(deriveCallCount, phases.length - 1)];
       deriveCallCount++;
       deps.callLog.push("deriveState");
 
-      if (deriveCallCount > phases.length) {
-        // 6th+ call: deactivate to exit the loop
-        s.active = false;
-        return {
-          phase: "complete",
-          activeMilestone: { id: "M001", title: "Test", status: "complete" },
-          activeSlice: null,
-          activeTask: null,
-          registry: [{ id: "M001", status: "complete" }],
-          blockers: [],
-        } as any;
-      }
-
-      const p = phases[deriveCallCount - 1];
+      const terminalPhases: Record<string, string> = { complete: "complete" };
+      s.active = p.phase !== "complete";
+      const milestoneStatus = terminalPhases[p.phase] ?? "active";
       return {
         phase: p.phase,
-        activeMilestone: { id: "M001", title: "Test", status: "active" },
-        activeSlice: p.activeSlice,
-        activeTask: p.activeTask,
-        registry: [{ id: "M001", status: "active" }],
+        activeMilestone: { id: "M001", title: "Test", status: milestoneStatus },
+        activeSlice: p.activeSlice ?? null,
+        activeTask: p.activeTask ?? null,
+        registry: [{ id: "M001", status: milestoneStatus }],
         blockers: [],
       } as any;
     },
     resolveDispatch: async () => {
+      const d = dispatches[Math.min(dispatchCallCount, dispatches.length - 1)];
       dispatchCallCount++;
       deps.callLog.push("resolveDispatch");
-
-      if (dispatchCallCount > dispatches.length) {
-        // Safety: shouldn't reach here, but stop if it does
-        return {
-          action: "stop" as const,
-          reason: "done",
-          level: "info" as const,
-        };
-      }
-
-      const d = dispatches[dispatchCallCount - 1];
       dispatchedUnitTypes.push(d.unitType);
       return {
         action: "dispatch" as const,
@@ -1691,18 +1684,11 @@ test("autoLoop lifecycle: advances through research → plan → execute → ver
     `callLog should have at least 5 resolveDispatch entries (got ${dispatchEntries.length})`,
   );
 
-  // Verify interleaving: each resolveDispatch should follow a deriveState
-  let dispatchSeen = 0;
-  for (const entry of deps.callLog) {
-    if (entry === "resolveDispatch") {
-      dispatchSeen++;
-    }
-    if (entry === "deriveState" && dispatchSeen > 0) {
-      // A deriveState after a resolveDispatch confirms the loop advanced
-      break;
-    }
-  }
-  assert.ok(dispatchSeen > 0, "resolveDispatch should appear in callLog");
+  // Verify interleaving: a deriveState must follow a resolveDispatch (confirms loop advanced)
+  const firstDispatchIdx = deps.callLog.indexOf("resolveDispatch");
+  const firstDeriveAfterDispatch = deps.callLog.indexOf("deriveState", firstDispatchIdx + 1);
+  assert.ok(firstDispatchIdx >= 0, "resolveDispatch should appear in callLog");
+  assert.ok(firstDeriveAfterDispatch > firstDispatchIdx, "deriveState should follow resolveDispatch to confirm loop advanced");
 
   // Assert the exact sequence of dispatched unit types
   assert.deepEqual(
@@ -1775,6 +1761,8 @@ test("autoLoop re-iterates when postUnitPreVerification returns retry (#1571)",
   const s = makeLoopSession();
 
   let preVerifyCallCount = 0;
+  // Pre-queued responses: first call returns "retry", second returns "continue"
+  const preVerifyResponses = ["retry", "continue"] as const;
 
   const deps = makeMockDeps({
     deriveState: async () => {
@@ -1790,11 +1778,7 @@ test("autoLoop re-iterates when postUnitPreVerification returns retry (#1571)",
     },
     postUnitPreVerification: async () => {
       deps.callLog.push("postUnitPreVerification");
-      preVerifyCallCount++;
-      if (preVerifyCallCount === 1) {
-        return "retry" as const;
-      }
-      return "continue" as const;
+      return preVerifyResponses[preVerifyCallCount++] ?? "continue";
     },
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
@@ -1907,9 +1891,8 @@ test("autoLoop rejects execute-task with 0 tool calls as hallucinated (#1833)",
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
       iterationCount++;
-      if (iterationCount >= 2) {
-        s.active = false;
-      }
+      // Deactivate after 2nd iteration
+      s.active = iterationCount < 2;
       return "continue" as const;
     },
   });
@@ -2122,7 +2105,7 @@ test("autoLoop stops when worktree has no project files for execute-task (#1833)
     "should stop auto-mode when worktree has no project files",
   );
   const healthNotification = notifications.find(
-    (n) => n.includes("Worktree health check failed") && n.includes("no package.json or src/"),
+    (n) => n.includes("Worktree health check failed") && n.includes("no recognized project files"),
   );
   assert.ok(
     healthNotification,

package/src/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -386,6 +386,91 @@ test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", ()
   }
 });
 
+// ─── verifyExpectedArtifact: heading-style plan tasks (#1691) ─────────────
+
+test("verifyExpectedArtifact accepts plan-slice with heading-style tasks (### T01 --)", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01 -- Implement feature",
+      "",
+      "Feature description.",
+      "",
+      "### T02 -- Write tests",
+      "",
+      "Test description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+    writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Heading-style plan with task entries should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact accepts plan-slice with colon-style heading tasks (### T01:)", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01: Implement feature",
+      "",
+      "Feature description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Colon heading-style plan should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact execute-task passes for heading-style plan entry (#1691)", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01 -- Implement feature",
+      "",
+      "Feature description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone.");
+    assert.strictEqual(
+      verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+      true,
+      "execute-task should pass for heading-style plan entry when summary exists",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── selfHealRuntimeRecords — worktree base path (#769) ──────────────────
 
 test("selfHealRuntimeRecords clears stale dispatched records (#769)", async () => {

package/src/resources/extensions/gsd/tests/auto-secrets-gate.test.ts

@@ -101,8 +101,8 @@ test('secrets gate: pending keys exist — gate triggers collection, manifest up
     const status = await getManifestStatus(tmp, 'M001');
     assert.notStrictEqual(status, null, 'manifest should exist');
     assert.ok(status!.pending.length > 0, 'should have pending keys');
-    assert.deepStrictEqual(status!.pending, ['GSD_GATE_TEST_PEND_A', 'GSD_GATE_TEST_PEND_B']);
-    assert.deepStrictEqual(status!.existing, ['GSD_GATE_TEST_EXISTING']);
+    assert.deepStrictEqual(status!.pending, ['GSD_GATE_TEST_PEND_A', 'GSD_GATE_TEST_PEND_B'], 'pending keys');
+    assert.deepStrictEqual(status!.existing, ['GSD_GATE_TEST_EXISTING'], 'existing keys');
 
     // (b) Call collectSecretsFromManifest with no-UI context
     // With hasUI: false, collectOneSecret returns null → pending keys become "skipped"