@opengsd/gsd-pi 1.8.1 → 1.9.0

package/src/resources/extensions/gsd/state-reconciliation/drift/external-planning-edit.ts

@@ -3,7 +3,8 @@
 // Parallel to external-markdown-edit.ts. Detects sha drift between the compat
 // marker's planning.projections/passthrough and current .planning/ files.
 //
-// Modeled files (projections): re-imported via parsePlanningDirectory → DB.
+// Modeled files (projections): re-imported via parsePlanningDirectory → DB,
+// with markdown status authority scoped to their marker entity milestone ids.
 // Passthrough files (un-modeled docs): sha refreshed, content untouched.
 
 import { existsSync, readFileSync } from "node:fs";
@@ -148,13 +149,25 @@ async function repairExternalPlanningEdit(
     const { parsePlanningDirectory } = await import("../../migrate/parser.js");
     const { transformToGSD } = await import("../../migrate/transformer.js");
     const { writeGSDDirectory } = await import("../../migrate/writer.js");
-    const { migrateHierarchyToDb } = await import("../../md-importer.js");
+    const { migrateHierarchyToDb, milestoneIdsFromEntities } = await import("../../md-importer.js");
     const { invalidateStateCache } = await import("../../state.js");
 
     const parsed = await parsePlanningDirectory(join(ctx.basePath, ".planning"));
     const gsdProject = transformToGSD(parsed);
     await writeGSDDirectory(gsdProject, ctx.basePath);
-    migrateHierarchyToDb(ctx.basePath);
+    // #027: scope status authority to the milestone(s) this drifted .planning/
+    // file projects (first `/`-segment of its DB entity ids), so a stale
+    // checkbox in an unrelated projection can't revert a reopened slice/milestone
+    // in the DB. Unseeded files carry no entities → empty set → preserve DB
+    // status everywhere (fail toward the DB, log the breadcrumb).
+    const statusAuthoritativeMilestones = milestoneIdsFromEntities(record.entities);
+    if (statusAuthoritativeMilestones.size === 0) {
+      logWarning(
+        "reconcile",
+        `external-planning-edit: no milestone scope resolved for ${record.projectionPath}; preserving DB status for all milestones`,
+      );
+    }
+    migrateHierarchyToDb(ctx.basePath, { statusAuthoritativeMilestones });
     invalidateStateCache();
   } catch (err) {
     logWarning(

package/src/resources/extensions/gsd/state-reconciliation/types.ts

@@ -49,14 +49,14 @@ export type DriftRecord =
       projectionPath: string;       // relative to basePath, e.g. "m1/plan.md"
       expectedSha: string;          // sha recorded in .compat.json
       actualSha: string;            // freshly computed from disk
-      entities: string[];           // DB entity ids to re-import
+      entities: string[];           // DB entity ids used to scope status authority
     }
   | {
       kind: "external-planning-edit";
       projectionPath: string;       // relative to .planning/, e.g. "phases/01-foo/01-01-PLAN.md"
       expectedSha: string;
       actualSha: string;
-      entities: string[];
+      entities: string[];           // DB entity ids used to scope status authority
       passthrough: boolean;         // true = content-only, no re-import, just refresh sha
     };
 

package/src/resources/extensions/gsd/stop-notice.ts

@@ -66,10 +66,27 @@ export function isNonBlockingPauseNotice(message: string): boolean {
   return message.includes("idempotent advance: unit already active");
 }
 
+/**
+ * A picker / next-action menu that could not render in a non-interactive
+ * (headless / RPC) session. Both wordings originate from the menu-unavailable
+ * helpers (`notifyCommandMenuUnavailable` and `notifyPickerCommandNeedsInteractiveMenu`
+ * in next-action-ui.ts / command-feedback.ts). Headless `auto`/`next` cannot
+ * answer such a menu, so the run has dead-ended and needs operator intervention.
+ * Classify it as blocked so the headless host exits 10 instead of idling
+ * forever waiting for a completion signal that never comes. (#1294)
+ */
+export function isInteractiveMenuUnavailableNotice(message: string): boolean {
+  return (
+    message.includes("menu could not be shown in this session") ||
+    message.includes("did not start:")
+  );
+}
+
 export function isBlockedNoticeMessage(message: string): boolean {
   return (
     message.includes("blocked:") ||
     (isPauseNotice(message) && !isNonBlockingPauseNotice(message)) ||
-    isManualResolutionNotice(message)
+    isManualResolutionNotice(message) ||
+    isInteractiveMenuUnavailableNotice(message)
   );
 }

package/src/resources/extensions/gsd/sync-lock.ts

@@ -9,8 +9,10 @@ import { dirname, join } from "node:path";
 const STALE_THRESHOLD_MS = 60_000; // 60 seconds
 const DEFAULT_TIMEOUT_MS = 0;      // fail fast; sync waits block the JS event loop
 
-function lockFilePath(basePath: string): string {
-  return join(basePath, ".gsd", "sync.lock");
+const DEFAULT_LOCK_NAME = "sync.lock";
+
+function lockFilePath(basePath: string, lockName: string = DEFAULT_LOCK_NAME): string {
+  return join(basePath, ".gsd", lockName);
 }
 
 /** True if the given PID is alive in the current process namespace. */
@@ -74,8 +76,9 @@ function tryCreateLockFile(lp: string, payload: string): boolean {
 export function acquireSyncLock(
   basePath: string,
   _timeoutMs: number = DEFAULT_TIMEOUT_MS,
+  lockName: string = DEFAULT_LOCK_NAME,
 ): { acquired: boolean } {
-  const lp = lockFilePath(basePath);
+  const lp = lockFilePath(basePath, lockName);
   const lockData = JSON.stringify(
     { pid: process.pid, acquired_at: new Date().toISOString() },
     null,
@@ -89,7 +92,12 @@ export function acquireSyncLock(
         return { acquired: true };
       }
     } catch {
-      /* unexpected — fall through to retry */
+      // tryCreateLockFile only throws for non-EEXIST errors — a persistently
+      // uncreatable lock path (dangling-symlink parent, ENOTDIR, read-only FS).
+      // Retrying would spin the loop forever with no progress condition,
+      // blocking the JS event loop. Fail open like a contended lock so callers
+      // proceed (racy but functional) instead of hanging.
+      return { acquired: false };
     }
 
     // File exists. Decide whether to steal (stale + owner dead) or skip.
@@ -131,8 +139,8 @@ export function acquireSyncLock(
 /**
  * Release the advisory sync lock. No-op if lock file does not exist.
  */
-export function releaseSyncLock(basePath: string): void {
-  const lp = lockFilePath(basePath);
+export function releaseSyncLock(basePath: string, lockName: string = DEFAULT_LOCK_NAME): void {
+  const lp = lockFilePath(basePath, lockName);
   try {
     if (existsSync(lp)) {
       unlinkSync(lp);

package/src/resources/extensions/gsd/tests/closeout-git-deferral.test.ts

@@ -3,8 +3,14 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
 
-import { shouldDeferCloseoutGitAction } from "../auto-post-unit.ts";
+import { postUnitPreVerification, shouldDeferCloseoutGitAction, type PostUnitContext } from "../auto-post-unit.ts";
+import { AutoSession } from "../auto/session.ts";
+import { closeDatabase, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, openDatabase } from "../gsd-db.ts";
+import { recordToolCall, recordToolResult, resetEvidence } from "../safety/evidence-collector.ts";
+import { cleanup, git, makeTempRepo } from "./test-utils.ts";
 
 test("execute-task defers closeout git action until verification passes", () => {
   assert.equal(shouldDeferCloseoutGitAction("execute-task"), true);
@@ -14,3 +20,92 @@ test("non execute-task units keep pre-verification closeout git action", () => {
   assert.equal(shouldDeferCloseoutGitAction("plan-slice"), false);
   assert.equal(shouldDeferCloseoutGitAction("complete-slice"), false);
 });
+
+test("blocking evidence-xref commits deferred execute-task work before pausing", async () => {
+  const base = makeTempRepo("gsd-evidence-xref-commit-before-pause-");
+
+  try {
+    writeFileSync(join(base, ".gitignore"), ".gsd/\n");
+    git(base, "add", ".gitignore");
+    git(base, "commit", "-m", "chore: ignore gsd runtime");
+
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active" });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Add app entrypoint",
+      status: "complete",
+      oneLiner: "Added app entrypoint",
+      keyFiles: ["app.js"],
+      planning: {
+        description: "Create app entrypoint",
+        estimate: "small",
+        files: ["app.js"],
+        verify: "npm test",
+        inputs: [],
+        expectedOutput: ["app.js"],
+        observabilityImpact: "none",
+      },
+    });
+    insertVerificationEvidence({
+      taskId: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      command: "npm test",
+      exitCode: 0,
+      verdict: "passed",
+      durationMs: 10,
+    });
+
+    writeFileSync(join(base, "app.js"), "console.log('ready');\n");
+    resetEvidence();
+    recordToolCall("call-1", "bash", { command: "npm test" });
+    recordToolResult("call-1", "bash", "Command exited with code 1\nfailed\n", true);
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.currentUnit = { type: "execute-task", id: "M001/S01/T01", startedAt: Date.now() };
+
+    let pauseCalled = false;
+    const notifications: string[] = [];
+    const pctx: PostUnitContext = {
+      s,
+      ctx: {
+        ui: { notify: (message: string) => notifications.push(message) },
+      } as unknown as PostUnitContext["ctx"],
+      pi: {} as PostUnitContext["pi"],
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => {
+        pauseCalled = true;
+        assert.equal(git(base, "status", "--short"), "", "task work must be committed before pauseAuto runs");
+      },
+      updateProgressWidget: () => {},
+    };
+
+    const result = await postUnitPreVerification(pctx, {
+      skipSettleDelay: true,
+      skipWorktreeSync: true,
+    });
+
+    assert.equal(result, "dispatched");
+    assert.equal(pauseCalled, true);
+    assert.ok(
+      notifications.some((message) => message.includes("claimed passing verification")),
+      `expected evidence-xref notification, got: ${notifications.join("\n")}`,
+    );
+
+    const commitMessage = git(base, "log", "-1", "--pretty=%B");
+    assert.match(commitMessage, /^feat: Added app entrypoint/m);
+    assert.match(commitMessage, /GSD-Task: S01\/T01/);
+  } finally {
+    resetEvidence();
+    closeDatabase();
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/command-feedback.test.ts

@@ -11,6 +11,7 @@ import {
   notifySmartEntryNeedsInteractiveMenu,
   requiresInteractiveMenu,
 } from "../command-feedback.js";
+import { isBlockedNoticeMessage, isInteractiveMenuUnavailableNotice } from "../stop-notice.js";
 import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
 
 function makeCtx(overrides: {
@@ -87,6 +88,17 @@ describe("notifyQueueHubNeedsInteractiveMenu", () => {
     assert.match(notes[0]!.message, /\/gsd queue/);
     assert.match(notes[0]!.message, /reorder/i);
   });
+
+  // /gsd queue continues headless with the add-work flow after this notice, so
+  // it must NOT be classified as a blocked dead-end (would exit 10 early). (#1294)
+  it("emits a notice the headless host does not treat as a dead-end", () => {
+    const ctx = makeCtx({ hasUI: false });
+    notifyQueueHubNeedsInteractiveMenu(ctx, "this session has no interactive menu");
+    const notes = (ctx as typeof ctx & { _notifications: Array<{ message: string }> })._notifications;
+    const message = notes[0]!.message.toLowerCase();
+    assert.equal(isInteractiveMenuUnavailableNotice(message), false);
+    assert.equal(isBlockedNoticeMessage(message), false);
+  });
 });
 
 describe("notifyInitNeedsInteractiveMenu", () => {

package/src/resources/extensions/gsd/tests/compat-marker.test.ts

@@ -16,6 +16,9 @@ import {
   EMPTY_MARKER,
   compatMarkerPath,
 } from "../compat/compat-marker.ts";
+import { externalMarkdownEditHandler } from "../state-reconciliation/drift/external-markdown-edit.ts";
+import type { DriftContext } from "../state-reconciliation/types.ts";
+import type { GSDState } from "../types.ts";
 
 const tmpDirs: string[] = [];
 
@@ -188,3 +191,104 @@ test("pruneOrphanedProjectionEntries returns 0 and writes nothing when marker is
   const files = readdirSync(join(base, ".gsd"));
   assert.ok(!files.includes(".compat.json"), "must not create a marker where none existed");
 });
+
+// --- Path-traversal containment (plan 029) ---------------------------------
+//
+// The marker is repo-controlled content whose projection-map keys are joined
+// with basePath and readFileSync'd by the drift detectors. A key that escapes
+// .gsd/ must invalidate the whole marker so readCompatMarker fails safe to the
+// empty marker (detectors see no entries → nothing outside the repo is read).
+
+for (const badKey of ["../outside.md", "/etc/hosts", "C:/x.md", "..\\x.md"]) {
+  test(`readCompatMarker rejects a projection key that escapes the root: ${JSON.stringify(badKey)}`, () => {
+    const base = makeTmpBase();
+    // Write the hostile marker directly (writeCompatMarker does not validate).
+    writeCompatMarker(base, {
+      schema: 2,
+      lastWriter: "gsd-pi",
+      lastProjectedAt: "2026-07-07T00:00:00.000Z",
+      projections: { [badKey]: { sha: "deadbeefdeadbeef", entities: ["m1"] } },
+      piVersion: "1.8.1",
+    });
+
+    const marker = readCompatMarker(base);
+    assert.equal(
+      Object.keys(marker.projections).length,
+      0,
+      "a marker with an escaping key must fall back to the empty marker",
+    );
+  });
+}
+
+test("readCompatMarker preserves legitimate nested projection keys", () => {
+  const base = makeTmpBase();
+  const roadmap = "milestones/M001/M001-ROADMAP.md";
+  const context = "phases/01-foo/01-CONTEXT.md";
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-07-07T00:00:00.000Z",
+    projections: {
+      [roadmap]: { sha: "aaaaaaaaaaaaaaaa", entities: ["M001"] },
+      [context]: { sha: "bbbbbbbbbbbbbbbb", entities: ["P01"] },
+    },
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: "1.8.1",
+  });
+
+  const marker = readCompatMarker(base);
+  assert.ok(marker.projections[roadmap], "roadmap key must round-trip");
+  assert.ok(marker.projections[context], "nested phase key must round-trip");
+  assert.equal(Object.keys(marker.projections).length, 2);
+});
+
+test("an escaping key in planning.passthrough also invalidates the whole marker", () => {
+  const base = makeTmpBase();
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-07-07T00:00:00.000Z",
+    projections: {},
+    planning: {
+      active: true,
+      layout: "flat-phases",
+      projections: {},
+      passthrough: { "../../secret.md": { sha: "cccccccccccccccc", entities: [] } },
+    },
+    piVersion: "1.8.1",
+  });
+
+  const marker = readCompatMarker(base);
+  assert.equal(Object.keys(marker.projections).length, 0);
+  assert.equal(marker.planning!.active, false, "planning falls back to inactive default");
+});
+
+test("hostile marker makes the drift detector read nothing outside the project", async () => {
+  const base = makeTmpBase();
+  // Sentinel lives OUTSIDE the project dir; a `../` traversal from .gsd/ would
+  // reach it if the key were trusted.
+  const sentinelDir = mkdtempSync(join(tmpdir(), `gsd-sentinel-${randomUUID()}`));
+  tmpDirs.push(sentinelDir);
+  const sentinelName = "known_hosts";
+  writeFileSync(join(sentinelDir, sentinelName), "SECRET\n", "utf-8");
+  const escapeKey = `../../${sentinelName}`; // e.g. ../../known_hosts
+
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-07-07T00:00:00.000Z",
+    projections: { [escapeKey]: { sha: "0000000000000000", entities: ["m1"] } },
+    piVersion: "1.8.1",
+  });
+
+  const stubState = { phase: "idle" } as unknown as GSDState;
+  const ctx: DriftContext = { basePath: base, state: stubState };
+
+  // Must not throw and must not emit a record referencing the sentinel.
+  const drift = await externalMarkdownEditHandler.detect(stubState, ctx);
+  assert.equal(drift.length, 0, "no drift record from a rejected hostile marker");
+  assert.ok(
+    !drift.some((d) => d.projectionPath.includes(sentinelName)),
+    "detector must not reference the out-of-project sentinel",
+  );
+});