gsd-pi 2.78.1-dev.b0759e59b → 2.78.1-dev.d8826a445

package/src/resources/extensions/gsd/templates/project.md

@@ -11,6 +11,16 @@
 
 {{theOneThingThatMustWorkEvenIfEverythingElseIsCut}}
 
+## Project Shape
+
+<!-- Drives questioning depth in downstream stages. `simple` → short plain-text
+     rounds, fast PROJECT/CONTEXT/REQUIREMENTS writes. `complex` → researched
+     3–4-option questions with an "Other — let me discuss" hatch.
+     Default to `complex` when uncertain. -->
+
+- **Complexity:** {{simple | complex}}
+- **Why:** {{one-line rationale citing the signals that decided it}}
+
 ## Current State
 
 {{whatHasBeenBuiltSoFar — what works, what exists, what's deployed}}

package/src/resources/extensions/gsd/tests/artifact-corruption-2630.test.ts

@@ -107,6 +107,7 @@ function makeMilestoneRow(overrides?: Partial<MilestoneRow>): MilestoneRow {
     definition_of_done: [],
     requirement_coverage: '',
     boundary_map_markdown: '',
+    sequence: 0,
     ...overrides,
   };
 }

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,
@@ -238,7 +238,7 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
       );
 
       // ── Deep auto-mode case: the user-facing approval gate must stay closed ──
-      clearDiscussionFlowState();
+      clearDiscussionFlowState(process.cwd());
       if (existsSync(snapshotFile)) unlinkSync(snapshotFile);
       _setAutoActiveForTest(true);
       const deepCtx = {
@@ -264,7 +264,7 @@ describe('auto-discuss-milestone-deadlock-4973', () => {
       // ── 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-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');
   });
 });

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

@@ -0,0 +1,331 @@
+// GSD-2 + Tests for MilestoneScope threading through AutoSession state (C2)
+//
+// Strategy: construct AutoSession directly + call createWorkspace/scopeMilestone
+// to mirror the rebuildScope() helper in auto.ts — avoids importing the full
+// auto.ts module (too many .js resolved imports).
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { AutoSession } from "../auto/session.ts";
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+import type { MilestoneScope } from "../workspace.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-scope-test-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+function makeWorktreeDir(projectDir: string, milestoneId: string): string {
+  const wt = join(projectDir, ".gsd", "worktrees", milestoneId);
+  mkdirSync(wt, { recursive: true });
+  return wt;
+}
+
+/**
+ * Mirror the rebuildScope() helper from auto.ts — computes s.scope from the
+ * same inputs so tests can verify the behaviour without importing auto.ts.
+ */
+function applyRebuildScope(
+  s: AutoSession,
+  rawPath: string,
+  milestoneId: string | null,
+): void {
+  if (!milestoneId) {
+    s.scope = null;
+    return;
+  }
+  try {
+    const workspace = createWorkspace(rawPath);
+    s.scope = scopeMilestone(workspace, milestoneId);
+  } catch {
+    s.scope = null;
+  }
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("AutoSession.scope — project mode (basePath equals originalBasePath)", () => {
+  let s: AutoSession;
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope is null when milestoneId is null", () => {
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = null;
+
+    applyRebuildScope(s, projectDir, null);
+
+    assert.equal(s.scope, null);
+  });
+
+  test("scope mode is 'project' when basePath equals originalBasePath", () => {
+    const mid = "M001";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.mode, "project");
+    assert.equal(s.scope.milestoneId, mid);
+  });
+
+  test("scope projectRoot matches realpath of projectDir", () => {
+    const mid = "M001";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+  });
+
+  test("scope worktreeRoot is null in project mode", () => {
+    const mid = "M001";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.worktreeRoot, null);
+  });
+
+  test("scope path methods resolve under the .gsd directory", () => {
+    const mid = "M002";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    const gsd = join(projectDir, ".gsd");
+    assert.equal(s.scope.contextFile(), join(gsd, "milestones", mid, `${mid}-CONTEXT.md`));
+    assert.equal(s.scope.roadmapFile(), join(gsd, "milestones", mid, `${mid}-ROADMAP.md`));
+    assert.equal(s.scope.stateFile(), join(gsd, "STATE.md"));
+  });
+});
+
+describe("AutoSession.scope — worktree mode (basePath differs from originalBasePath)", () => {
+  let s: AutoSession;
+  let projectDir: string;
+  let worktreeDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    worktreeDir = makeWorktreeDir(projectDir, "M001");
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope mode is 'worktree' when basePath is the worktree path", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.mode, "worktree");
+  });
+
+  test("scope worktreeRoot matches realpath of worktreeDir", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.worktreeRoot, realpathSync(worktreeDir));
+  });
+
+  test("scope projectRoot resolves to project root (not worktree)", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+  });
+
+  test("scope milestoneId matches the milestone being tracked", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.milestoneId, mid);
+  });
+});
+
+describe("AutoSession.scope — milestoneId change rebuilds scope", () => {
+  let s: AutoSession;
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope reflects the new milestoneId after rebuild", () => {
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = "M001";
+    applyRebuildScope(s, projectDir, "M001");
+
+    assert.ok(s.scope, "initial scope should be set");
+    assert.equal(s.scope.milestoneId, "M001");
+
+    // Simulate milestone transition mid-session
+    s.currentMilestoneId = "M002";
+    applyRebuildScope(s, projectDir, "M002");
+
+    assert.ok(s.scope, "scope should be set after transition");
+    assert.equal(s.scope.milestoneId, "M002");
+  });
+
+  test("scope contextFile changes when milestoneId changes", () => {
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+
+    s.currentMilestoneId = "M001";
+    applyRebuildScope(s, projectDir, "M001");
+    const ctxM001 = s.scope?.contextFile();
+
+    s.currentMilestoneId = "M002";
+    applyRebuildScope(s, projectDir, "M002");
+    const ctxM002 = s.scope?.contextFile();
+
+    assert.ok(ctxM001, "M001 contextFile should be set");
+    assert.ok(ctxM002, "M002 contextFile should be set");
+    assert.notEqual(ctxM001, ctxM002, "contextFile must differ between milestone IDs");
+    assert.ok(ctxM001.includes("M001"), "M001 path should contain M001");
+    assert.ok(ctxM002.includes("M002"), "M002 path should contain M002");
+  });
+});
+
+describe("AutoSession.scope — resume from persisted state", () => {
+  let s: AutoSession;
+  let projectDir: string;
+  let worktreeDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    worktreeDir = makeWorktreeDir(projectDir, "M003");
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("resume without worktree: scope mode is project, projectRoot is base", () => {
+    // Mirror the paused-session resume path:
+    //   s.currentMilestoneId = meta.milestoneId
+    //   s.originalBasePath   = meta.originalBasePath || base
+    //   rawPath              = originalBasePath (no worktreePath present)
+    const mid = "M003";
+    s.currentMilestoneId = mid;
+    s.originalBasePath = projectDir;
+    s.basePath = projectDir;
+
+    applyRebuildScope(s, s.originalBasePath, s.currentMilestoneId);
+
+    assert.ok(s.scope, "scope should be reconstructed");
+    assert.equal(s.scope.milestoneId, mid);
+    assert.equal(s.scope.workspace.mode, "project");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+    assert.equal(s.scope.workspace.worktreeRoot, null);
+  });
+
+  test("resume with valid worktree path: scope mode is worktree", () => {
+    // Mirror the paused-session resume path where worktreePath exists on disk:
+    //   rawPath = worktreePath (existsSync true)
+    const mid = "M003";
+    s.currentMilestoneId = mid;
+    s.originalBasePath = projectDir;
+    s.basePath = worktreeDir;
+
+    assert.ok(existsSync(worktreeDir), "worktreeDir must exist for this test");
+
+    applyRebuildScope(s, worktreeDir, s.currentMilestoneId);
+
+    assert.ok(s.scope, "scope should be reconstructed");
+    assert.equal(s.scope.milestoneId, mid);
+    assert.equal(s.scope.workspace.mode, "worktree");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+    assert.equal(s.scope.workspace.worktreeRoot, realpathSync(worktreeDir));
+  });
+
+  test("scope is consistent with direct createWorkspace + scopeMilestone for same inputs", () => {
+    const mid = "M003";
+    s.currentMilestoneId = mid;
+    s.originalBasePath = projectDir;
+    s.basePath = projectDir;
+
+    applyRebuildScope(s, projectDir, mid);
+    assert.ok(s.scope, "scope should be set");
+
+    // Build expected scope via lower-level API to verify equivalence
+    const ws = createWorkspace(projectDir);
+    const expected = scopeMilestone(ws, mid);
+
+    assert.equal(s.scope.milestoneId, expected.milestoneId);
+    assert.equal(s.scope.contextFile(), expected.contextFile());
+    assert.equal(s.scope.roadmapFile(), expected.roadmapFile());
+    assert.equal(s.scope.stateFile(), expected.stateFile());
+    assert.equal(s.scope.dbPath(), expected.dbPath());
+    assert.equal(s.scope.milestoneDir(), expected.milestoneDir());
+    assert.equal(s.scope.metaJson(), expected.metaJson());
+  });
+
+  test("reset() clears scope", () => {
+    const mid = "M003";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+    assert.ok(s.scope, "scope should be set before reset");
+
+    s.reset();
+    assert.equal(s.scope, null, "scope must be null after reset()");
+  });
+});