gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.2d3fd6e71

package/src/resources/extensions/gsd/tests/auto-discuss-milestone-deadlock-4973.test.ts

@@ -35,7 +35,7 @@ import { _setAutoActiveForTest } from '../auto.ts';
 // Reset all relevant state before and after each test.
 function resetState(): void {
   _setAutoActiveForTest(false);
-  clearDiscussionFlowState();
+  clearDiscussionFlowState(process.cwd());
 }
 
 describe('auto-discuss-milestone-deadlock-4973', () => {
@@ -51,7 +51,7 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
     _setAutoActiveForTest(true);
 
     // Before mark: blocked
-    const snapshotBefore = loadWriteGateSnapshot();
+    const snapshotBefore = loadWriteGateSnapshot(process.cwd());
     const beforeResult = shouldBlockContextArtifactSaveInSnapshot(
       snapshotBefore,
       'CONTEXT',
@@ -61,10 +61,10 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
     assert.strictEqual(beforeResult.block, true, 'should block before markDepthVerified');
 
     // Simulate what the dispatch rule now does in auto-mode
-    markDepthVerified('M001');
+    markDepthVerified('M001', process.cwd());
 
     // After mark: unblocked
-    const snapshotAfter = loadWriteGateSnapshot();
+    const snapshotAfter = loadWriteGateSnapshot(process.cwd());
     const afterResult = shouldBlockContextArtifactSaveInSnapshot(
       snapshotAfter,
       'CONTEXT',
@@ -87,7 +87,7 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
     assert.strictEqual(beforeResult.block, true, 'write should be blocked before markDepthVerified');
 
     // Simulate dispatch rule auto-mark
-    markDepthVerified('M001');
+    markDepthVerified('M001', process.cwd());
 
     // After mark: unblocked
     const afterResult = shouldBlockContextWrite('write', contextPath, 'M001');
@@ -109,8 +109,8 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
   // the dispatch-site call site is safe regardless of prior session state.
   test('Test 3: session_switch ordering — clearDiscussionFlowState clears mark; dispatch-site call re-establishes it', () => {
     // Simulate a mark from a prior session
-    markDepthVerified('M001');
-    let snapshot = loadWriteGateSnapshot();
+    markDepthVerified('M001', process.cwd());
+    let snapshot = loadWriteGateSnapshot(process.cwd());
     assert.strictEqual(
       isMilestoneDepthVerifiedInSnapshot(snapshot, 'M001'),
       true,
@@ -119,8 +119,8 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
 
     // session_switch fires clearDiscussionFlowState() — this is exactly what
     // register-hooks.ts:106 does
-    clearDiscussionFlowState();
-    snapshot = loadWriteGateSnapshot();
+    clearDiscussionFlowState(process.cwd());
+    snapshot = loadWriteGateSnapshot(process.cwd());
     assert.strictEqual(
       isMilestoneDepthVerifiedInSnapshot(snapshot, 'M001'),
       false,
@@ -130,9 +130,9 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
     // Now the dispatch rule fires (after session_switch cleared state)
     // and re-establishes the mark for the new session
     _setAutoActiveForTest(true);
-    markDepthVerified('M001'); // this is what the dispatch rule does
+    markDepthVerified('M001', process.cwd()); // this is what the dispatch rule does
 
-    snapshot = loadWriteGateSnapshot();
+    snapshot = loadWriteGateSnapshot(process.cwd());
     assert.strictEqual(
       isMilestoneDepthVerifiedInSnapshot(snapshot, 'M001'),
       true,
@@ -158,7 +158,7 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
 
     // CONTEXT artifact save is still blocked
     const snapshotResult = shouldBlockContextArtifactSaveInSnapshot(
-      loadWriteGateSnapshot(),
+      loadWriteGateSnapshot(process.cwd()),
       'CONTEXT',
       'M002',
       null,
@@ -186,8 +186,9 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
   // The actual fix lives inside the discuss-milestone dispatch rules at
   // auto-dispatch.ts:280-291, :423-432, :449-458. This test invokes the
   // "needs-discussion → discuss-milestone" rule directly and asserts that
-  // (a) the rule auto-marks depth-verified when isAutoActive() is true, and
-  // (b) it does NOT mark when isAutoActive() is false.
+  // (a) the rule auto-marks depth-verified when non-deep auto-mode is active,
+  // (b) it does NOT mark when deep planning is active, and
+  // (c) it does NOT mark when isAutoActive() is false.
   //
   // This is the test codex flagged as missing: Tests 1-4 above only exercise
   // the markDepthVerified primitive — they pass on origin/main. This Test 5
@@ -214,7 +215,7 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
         structuredQuestionsAvailable: 'false',
       } as unknown as DispatchContext;
 
-      // ── Auto-mode case: the rule must call markDepthVerified ──
+      // ── Non-deep auto-mode case: the rule must call markDepthVerified ──
       _setAutoActiveForTest(true);
       let snap = loadWriteGateSnapshot(tempBase);
       assert.strictEqual(
@@ -233,13 +234,37 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
       assert.strictEqual(
         isMilestoneDepthVerifiedInSnapshot(snap, 'M005'),
         true,
-        'auto-mode: dispatch rule must call markDepthVerified(mid) — this fails on origin/main without the H6 fix',
+        'non-deep auto-mode: dispatch rule must call markDepthVerified(mid) — this fails on origin/main without the H6 fix',
+      );
+
+      // ── Deep auto-mode case: the user-facing approval gate must stay closed ──
+      clearDiscussionFlowState(process.cwd());
+      if (existsSync(snapshotFile)) unlinkSync(snapshotFile);
+      _setAutoActiveForTest(true);
+      const deepCtx = {
+        ...baseCtx,
+        prefs: { planning_depth: 'deep' },
+      } as unknown as DispatchContext;
+      snap = loadWriteGateSnapshot(tempBase);
+      assert.strictEqual(
+        isMilestoneDepthVerifiedInSnapshot(snap, 'M005'),
+        false,
+        'precondition: state cleared before deep-mode dispatch',
+      );
+
+      try { await rule!.match(deepCtx); } catch { /* prompt build may fail */ }
+
+      snap = loadWriteGateSnapshot(tempBase);
+      assert.strictEqual(
+        isMilestoneDepthVerifiedInSnapshot(snap, 'M005'),
+        false,
+        'deep auto-mode: dispatch rule must not pre-verify a user-facing milestone gate',
       );
 
       // ── Interactive case: the rule must NOT call markDepthVerified ──
       // clearDiscussionFlowState() only deletes the snapshot at process.cwd(),
       // so we must explicitly remove the snapshot under our tempBase too.
-      clearDiscussionFlowState();
+      clearDiscussionFlowState(process.cwd());
       if (existsSync(snapshotFile)) unlinkSync(snapshotFile);
       _setAutoActiveForTest(false);
       snap = loadWriteGateSnapshot(tempBase);

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

@@ -7,17 +7,16 @@ import { join } from "node:path";
 import {
   resolveAgentEnd,
   resolveAgentEndCancelled,
-  runUnit,
-  autoLoop,
-  detectStuck,
   _resetPendingResolve,
   _hasPendingResolveForTest,
   _setActiveSession,
   isSessionSwitchInFlight,
-  type UnitResult,
-  type AgentEndEvent,
-  type LoopDeps,
-} from "../auto-loop.js";
+} from "../auto/resolve.js";
+import { runUnit } from "../auto/run-unit.js";
+import { autoLoop } from "../auto/loop.js";
+import { detectStuck } from "../auto/detect-stuck.js";
+import type { UnitResult, AgentEndEvent } from "../auto/types.js";
+import type { LoopDeps } from "../auto/loop-deps.js";
 import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import type { SessionLockStatus } from "../session-lock.js";
 
@@ -556,27 +555,6 @@ test("late-resolving newSession() after timeout receives aborted signal so tool
   }
 });
 
-// ─── Structural assertions ───────────────────────────────────────────────────
-
-test("auto-loop.ts exports autoLoop, runUnit, resolveAgentEnd", async () => {
-  const mod = await import("../auto-loop.js");
-  assert.equal(
-    typeof mod.autoLoop,
-    "function",
-    "autoLoop should be exported as a function",
-  );
-  assert.equal(
-    typeof mod.runUnit,
-    "function",
-    "runUnit should be exported as a function",
-  );
-  assert.equal(
-    typeof mod.resolveAgentEnd,
-    "function",
-    "resolveAgentEnd should be exported as a function",
-  );
-});
-
 // NOTE: the "while keyword", "one-shot null-before-resolve", and
 // "selectAndApplyModel before updateProgressWidget" source-grep tests
 // previously here were deleted as tautological (readFileSync + substring
@@ -629,7 +607,11 @@ function makeMockDeps(
         blockers: [],
       } as any;
     },
-    loadEffectiveGSDPreferences: () => ({ preferences: {} }),
+    loadEffectiveGSDPreferences: () => ({
+      // These loop-mechanics tests mock executing state without plan-v2 artifacts.
+      // Plan-v2 default-on coverage lives in uok-plan-v2-wiring.test.ts.
+      preferences: { uok: { plan_v2: { enabled: false } } },
+    }),
     preDispatchHealthGate: async () => ({ proceed: true, fixesApplied: [] }),
     syncProjectRootToWorktree: () => {},
     checkResourcesStale: () => null,
@@ -2179,6 +2161,87 @@ test("autoLoop rejects execute-task with 0 tool calls as hallucinated (#1833)",
   );
 });
 
+test("autoLoop pauses user-driven deep question instead of flagging 0 tool calls", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
+  const pi = makeMockPi();
+
+  const notifications: string[] = [];
+  ctx.ui.notify = (msg: string) => { notifications.push(msg); };
+
+  const s = makeLoopSession();
+  const mockLedger = {
+    version: 1,
+    projectStartedAt: Date.now(),
+    units: [] as any[],
+  };
+
+  const deps = makeMockDeps({
+    deriveState: async () => {
+      deps.callLog.push("deriveState");
+      return {
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Bootstrap", status: "active" },
+        activeSlice: null,
+        activeTask: null,
+        registry: [{ id: "M001", status: "active" }],
+        blockers: [],
+      } as any;
+    },
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      return {
+        action: "dispatch" as const,
+        unitType: "discuss-project",
+        unitId: "PROJECT",
+        prompt: "ask what to build",
+      };
+    },
+    closeoutUnit: async () => {
+      mockLedger.units.push({
+        type: "discuss-project",
+        id: "PROJECT",
+        startedAt: s.currentUnit?.startedAt ?? Date.now(),
+        toolCalls: 0,
+        assistantMessages: 1,
+        tokens: { input: 100, output: 20, total: 120, cacheRead: 0, cacheWrite: 0 },
+        cost: 0.01,
+      });
+    },
+    getLedger: () => mockLedger,
+    postUnitPreVerification: async () => {
+      deps.callLog.push("postUnitPreVerification");
+      return "dispatched" as const;
+    },
+  });
+
+  const loopPromise = autoLoop(ctx, pi, s, deps);
+
+  await new Promise((r) => setTimeout(r, 50));
+  resolveAgentEnd(makeEvent([
+    {
+      role: "assistant",
+      content: [
+        { type: "text", text: "What do you want to build?" },
+      ],
+    },
+  ]));
+
+  await loopPromise;
+
+  assert.ok(
+    deps.callLog.includes("postUnitPreVerification"),
+    "questioning units should reach post-unit verification so the pause path can run",
+  );
+  assert.ok(
+    !notifications.some((n) => n.includes("context exhaustion")),
+    "questioning units should not show the context-exhaustion warning",
+  );
+});
+
 test("autoLoop rejects complete-slice with 0 tool calls as context-exhausted (#2653)", async () => {
   _resetPendingResolve();
 
@@ -2408,7 +2471,10 @@ test("autoLoop enforces min_request_interval_ms delay between LLM dispatches (#2
 
     const deps = makeMockDeps({
       loadEffectiveGSDPreferences: () => ({
-        preferences: { min_request_interval_ms: 300 },
+        preferences: {
+          min_request_interval_ms: 300,
+          uok: { plan_v2: { enabled: false } },
+        },
       }),
       deriveState: async () => {
         iterCount++;
@@ -2493,7 +2559,7 @@ test("autoLoop skips rate-limit delay when min_request_interval_ms is 0 (default
 
     const deps = makeMockDeps({
       loadEffectiveGSDPreferences: () => ({
-        preferences: {},
+        preferences: { uok: { plan_v2: { enabled: false } } },
       }),
       deriveState: async () => {
         iterCount++;

package/src/resources/extensions/gsd/tests/auto-paused-session-validation.test.ts

@@ -40,6 +40,12 @@ test("auto.ts validates milestone before restoring paused session (#1664)", () =
     "auto.ts must check for SUMMARY file to detect completed milestones",
   );
 
+  assert.ok(
+    source.includes("await ensureDbOpen(base)") &&
+      source.indexOf("await ensureDbOpen(base)") < source.indexOf('resolveMilestoneFile(base, meta.milestoneId, "SUMMARY")'),
+    "auto.ts must open the canonical DB before using SUMMARY as a paused-session fallback",
+  );
+
   // Resume path must sanitize paused session file metadata before unlink/recovery.
   assert.ok(
     source.includes("normalizeSessionFilePath(meta.sessionFile ?? null)"),

package/src/resources/extensions/gsd/tests/auto-remediate-slice-status.test.ts

@@ -1,13 +1,12 @@
 /**
- * Regression test for #3673 — auto-remediate stale slice DB status
+ * Regression test for DB-authoritative rogue detection.
  *
- * When complete-slice fails after writing SUMMARY.md but before calling
- * updateSliceStatus(), the DB stays stale and the post-unit check
- * previously reported this as a "rogue" artifact, causing infinite
- * re-dispatch. The fix calls updateSliceStatus() to sync the DB.
+ * A SUMMARY.md on disk is a projection/diagnostic. Runtime post-unit checks
+ * must not use it to mark the DB slice complete; explicit import/recovery
+ * commands own markdown-to-DB behavior.
  *
- * This structural test verifies updateSliceStatus is imported and called
- * in the complete-slice branch of auto-post-unit.ts.
+ * This structural test verifies the complete-slice rogue branch reports the
+ * stale projection without calling updateSliceStatus().
  */
 
 import { describe, test } from 'node:test';
@@ -22,38 +21,26 @@ const __dirname = dirname(__filename);
 
 const source = readFileSync(join(__dirname, '..', 'auto-post-unit.ts'), 'utf-8');
 
-describe('auto-remediate stale slice status (#3673)', () => {
-  test('updateSliceStatus is imported from gsd-db', () => {
-    assert.match(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from\s*["']\.\/gsd-db/,
-      'updateSliceStatus should be imported from gsd-db');
+describe('DB-authoritative slice rogue detection', () => {
+  test('updateSliceStatus is not imported for post-unit rogue reconciliation', () => {
+    assert.doesNotMatch(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from\s*["']\.\/gsd-db/,
+      'auto-post-unit must not import updateSliceStatus for disk-to-DB reconciliation');
   });
 
-  test('updateSliceStatus is called with "complete" status', () => {
-    assert.match(source, /updateSliceStatus\(mid,\s*sid,\s*["']complete["']/,
-      'updateSliceStatus should be called with "complete" status');
+  test('complete-slice rogue branch does not mark DB complete from disk', () => {
+    assert.doesNotMatch(source, /updateSliceStatus\(mid,\s*sid,\s*["']complete["']/,
+      'SUMMARY.md on disk must not mark slice complete in DB');
   });
 
-  test('remediation is wrapped in try-catch for fallback to rogue detection', () => {
-    // The updateSliceStatus call should be in a try block with a catch
-    // that falls back to rogues.push
-    const updateIdx = source.indexOf('updateSliceStatus(mid, sid');
-    assert.ok(updateIdx > 0, 'updateSliceStatus call should exist');
-
-    // Find surrounding try-catch
-    const before = source.slice(Math.max(0, updateIdx - 200), updateIdx);
-    assert.match(before, /try\s*\{/,
-      'updateSliceStatus should be inside a try block');
-
-    // Bound the region to stop before the rogue fallback so /catch/ only
-    // matches this try block's catch, not an unrelated later one.
-    const after = extractSourceRegion(source, 'updateSliceStatus(mid, sid', 'rogues.push({');
-    assert.match(after, /catch/,
-      'try block should have a catch for fallback');
+  test('explicit rogue diagnostic reports stale slice summary projection', () => {
+    const branch = extractSourceRegion(source, 'unitType === "complete-slice"', 'unitType === "plan-milestone"');
+    assert.match(branch, /rogues\.push\(\{\s*path:\s*summaryPath,\s*unitType,\s*unitId\s*\}\)/,
+      'complete-slice branch should report stale SUMMARY.md as rogue');
   });
 
-  test('rogue detection still exists as fallback', () => {
-    // rogues.push should appear in the catch block
-    assert.match(source, /rogues\.push\(\{.*path:\s*summaryPath/,
-      'rogues.push fallback should still exist');
+  test('post-unit runtime does not call rogue diagnostics automatically', () => {
+    const postUnit = extractSourceRegion(source, 'export async function postUnitPostVerification');
+    assert.doesNotMatch(postUnit, /detectRogueFileWrites\(/,
+      'runtime post-unit path must not scan disk projections for rogue files');
   });
 });