gsd-pi 2.46.1-dev.9d471d1 → 2.46.1-dev.eee1457

package/src/resources/extensions/gsd/state.ts

@@ -49,6 +49,7 @@ import {
   getReplanHistory,
   getSlice,
   insertMilestone,
+  updateTaskStatus,
   type MilestoneRow,
   type SliceRow,
   type TaskRow,
@@ -629,7 +630,38 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   // ── Get tasks from DB ────────────────────────────────────────────────
-  const tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
+  let tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
+
+  // ── Reconcile stale task status (#2514) ──────────────────────────────
+  // When a session disconnects after the agent writes SUMMARY + VERIFY
+  // artifacts but before postUnitPostVerification updates the DB, tasks
+  // remain "pending" in the DB despite being complete on disk. Without
+  // reconciliation, deriveState keeps returning the stale task as active,
+  // causing the dispatcher to re-dispatch the same completed task forever.
+  let reconciled = false;
+  for (const t of tasks) {
+    if (isStatusDone(t.status)) continue;
+    const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
+    if (summaryPath && existsSync(summaryPath)) {
+      try {
+        updateTaskStatus(activeMilestone.id, activeSlice.id, t.id, "complete");
+        process.stderr.write(
+          `gsd-reconcile: task ${activeMilestone.id}/${activeSlice.id}/${t.id} had SUMMARY on disk but DB status was "${t.status}" — updated to "complete" (#2514)\n`,
+        );
+        reconciled = true;
+      } catch (e) {
+        // DB write failed — continue with stale status rather than crash
+        process.stderr.write(
+          `gsd-reconcile: failed to update task ${t.id}: ${(e as Error).message}\n`,
+        );
+      }
+    }
+  }
+  // Re-fetch tasks if any were reconciled so downstream logic sees fresh status
+  if (reconciled) {
+    tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
+  }
+
   const taskProgress = {
     done: tasks.filter(t => isStatusDone(t.status)).length,
     total: tasks.length,

package/src/resources/extensions/gsd/tests/inherited-repo-home-dir.test.ts

@@ -119,3 +119,73 @@ describe("isInheritedRepo when git root is HOME (#2393)", () => {
     );
   });
 });
+
+describe("isInheritedRepo with stale .gsd at parent git root", () => {
+  let parentRepo: string;
+
+  beforeEach(() => {
+    parentRepo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-stale-parent-")));
+    run("git", ["init", "-b", "main"], parentRepo);
+    run("git", ["config", "user.name", "Test"], parentRepo);
+    run("git", ["config", "user.email", "test@example.com"], parentRepo);
+    writeFileSync(join(parentRepo, "README.md"), "# Parent\n", "utf-8");
+    run("git", ["add", "README.md"], parentRepo);
+    run("git", ["commit", "-m", "init"], parentRepo);
+  });
+
+  afterEach(() => {
+    rmSync(parentRepo, { recursive: true, force: true });
+  });
+
+  test("stale .gsd dir at parent git root does not suppress inherited detection", () => {
+    // Simulate a stale .gsd directory at the parent git root (e.g. from a
+    // prior doctor run or accidental init). This is a real directory, NOT
+    // a symlink, and NOT the global GSD home.
+    mkdirSync(join(parentRepo, ".gsd"), { recursive: true });
+
+    const projectDir = join(parentRepo, "my-project");
+    mkdirSync(projectDir, { recursive: true });
+
+    // Without fix: isProjectGsd(join(root, ".gsd")) returns true because
+    // the stale .gsd is a real directory that isn't the global GSD home,
+    // causing isInheritedRepo to return false (false negative).
+    //
+    // The stale .gsd at parent is still treated as a "project .gsd" by
+    // isProjectGsd(), so the git root check at line 128 returns false.
+    // This is the expected behavior for that check — the defense-in-depth
+    // fix in auto-start.ts handles this case by checking for local .git.
+    //
+    // Verify the function behavior is consistent:
+    assert.strictEqual(
+      isInheritedRepo(projectDir),
+      false,
+      "stale .gsd dir at git root still causes isInheritedRepo to return false " +
+      "(defense-in-depth in auto-start.ts handles this case)",
+    );
+  });
+
+  test("basePath's own .gsd symlink does not suppress inherited detection", () => {
+    // Create a project subdir with its own .gsd symlink (set up during
+    // the discuss phase, before auto-mode bootstrap runs).
+    const projectDir = join(parentRepo, "my-project");
+    mkdirSync(projectDir, { recursive: true });
+
+    const externalState = mkdtempSync(join(tmpdir(), "gsd-ext-state-"));
+    symlinkSync(externalState, join(projectDir, ".gsd"));
+
+    // Before fix: the walk-up loop started at normalizedBase (projectDir),
+    // found .gsd at projectDir, and returned false — even though projectDir
+    // has no .git of its own. The .gsd at basePath is irrelevant to whether
+    // the git repo is inherited from a parent.
+    //
+    // After fix: the walk-up starts at dirname(normalizedBase), skipping
+    // basePath's own .gsd.
+    assert.strictEqual(
+      isInheritedRepo(projectDir),
+      true,
+      "project's own .gsd symlink must not suppress inherited repo detection",
+    );
+
+    rmSync(externalState, { recursive: true, force: true });
+  });
+});

package/src/resources/extensions/gsd/tests/plan-slice-prompt.test.ts

@@ -61,6 +61,18 @@ test("plan-slice prompt: DB-backed tool names survive template substitution", ()
   assert.ok(result.includes("canonical write path"), "canonical write path language should survive substitution");
 });
 
+test("plan-slice prompt: footer references gsd_plan_slice tool, not direct write", () => {
+  const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit." });
+  assert.ok(
+    result.includes("MUST call `gsd_plan_slice`"),
+    "footer should instruct calling gsd_plan_slice tool",
+  );
+  assert.ok(
+    !result.includes("MUST write the file"),
+    "footer should not instruct direct file write",
+  );
+});
+
 test("domain-work prompts use skillActivation placeholder", () => {
   const prompts = [
     "research-milestone",
@@ -174,6 +186,34 @@ test("research-milestone prompt substitutes skillActivation", () => {
   assert.ok(!result.includes("{{skillActivation}}"));
 });
 
+test("research-milestone prompt references gsd_summary_save, not direct write", () => {
+  const result = loadPrompt("research-milestone", {
+    workingDirectory: "/tmp/test-project",
+    milestoneId: "M001",
+    milestoneTitle: "Test Milestone",
+    milestonePath: ".gsd/milestones/M001",
+    contextPath: ".gsd/milestones/M001/M001-CONTEXT.md",
+    outputPath: "/tmp/test-project/.gsd/milestones/M001/M001-RESEARCH.md",
+    inlinedContext: "Context",
+    skillDiscoveryMode: "manual",
+    skillDiscoveryInstructions: " Discover skills manually.",
+    skillActivation: "Load research skills first.",
+  });
+
+  assert.ok(
+    result.includes("gsd_summary_save"),
+    "research-milestone should reference gsd_summary_save tool",
+  );
+  assert.ok(
+    result.includes('artifact_type: "RESEARCH"'),
+    "research-milestone should specify RESEARCH artifact type",
+  );
+  assert.ok(
+    !result.includes("MUST write the file"),
+    "research-milestone should not instruct direct file write",
+  );
+});
+
 test("research-slice prompt substitutes skillActivation", () => {
   const result = loadPrompt("research-slice", {
     workingDirectory: "/tmp/test-project",

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -228,6 +228,31 @@ test('(k) run-uat prompt template', () => {
   );
 });
 
+test('(k2) run-uat prompt references gsd_summary_save, not direct write', () => {
+  const promptResult = loadPromptFromWorktree('run-uat', {
+    workingDirectory: '/tmp/test-project',
+    milestoneId: 'M001',
+    sliceId: 'S01',
+    uatPath: '.gsd/milestones/M001/slices/S01/S01-UAT.md',
+    uatResultPath: '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md',
+    uatType: 'artifact-driven',
+    inlinedContext: '<!-- no context -->',
+  });
+
+  assert.ok(
+    promptResult.includes('gsd_summary_save'),
+    'run-uat prompt should reference gsd_summary_save tool',
+  );
+  assert.ok(
+    promptResult.includes('artifact_type: "ASSESSMENT"'),
+    'run-uat prompt should specify ASSESSMENT artifact type',
+  );
+  assert.ok(
+    !promptResult.includes('MUST write'),
+    'run-uat prompt should not instruct direct file write in footer',
+  );
+});
+
 test('(l) dispatch preconditions via resolveSliceFile', () => {
     const base = createFixtureBase();
     const uatContent = makeUatContent('artifact-driven');

package/src/resources/extensions/gsd/workflow-events.ts

@@ -40,7 +40,7 @@ export function appendEvent(
   event: Omit<WorkflowEvent, "hash" | "session_id"> & { actor_name?: string; trigger_reason?: string },
 ): void {
   const hash = createHash("sha256")
-    .update(JSON.stringify({ cmd: event.cmd, params: event.params, ts: event.ts }))
+    .update(JSON.stringify({ cmd: event.cmd, params: event.params }))
     .digest("hex")
     .slice(0, 16);