@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.97ef11e3

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/commands-verdict.test.ts

@@ -201,6 +201,7 @@ test("handleVerdict rejects missing verdict", async () => {
   const { ctx, calls } = makeMockCtx();
   await handleVerdict("", ctx, "/tmp/unused");
   assert.equal(calls.length, 1);
+  assert.match(calls[0].message, /^Verdict rejected:/);
   assert.match(calls[0].message, /Usage: \/gsd verdict/);
   assert.equal(calls[0].kind, "warning");
 });
@@ -209,6 +210,7 @@ test("handleVerdict rejects invalid verdict", async () => {
   const { ctx, calls } = makeMockCtx();
   await handleVerdict("yolo", ctx, "/tmp/unused");
   assert.equal(calls.length, 1);
+  assert.match(calls[0].message, /^Verdict rejected:/);
   assert.match(calls[0].message, /Invalid verdict "yolo"/);
   assert.equal(calls[0].kind, "warning");
 });
@@ -250,6 +252,10 @@ test("handleVerdict rejects when milestone validation is missing", async () => {
       calls.some((c) => /No milestone validation found/.test(c.message)),
       `expected missing-validation warning, got: ${JSON.stringify(calls)}`,
     );
+    assert.ok(
+      calls.some((c) => /^Verdict rejected:/.test(c.message)),
+      `expected terminal rejection prefix, got: ${JSON.stringify(calls)}`,
+    );
   } finally {
     closeDatabase();
     invalidateStateCache();
@@ -280,6 +286,10 @@ test("handleVerdict pass override flips verdict and preserves sections", async (
       calls.some((c) => c.kind === "success" && /needs-attention.*->.*pass/.test(c.message)),
       `expected success notification, got: ${JSON.stringify(calls)}`,
     );
+    assert.ok(
+      calls.some((c) => c.kind === "success" && /^Verdict recorded:/.test(c.message)),
+      `expected terminal recorded prefix, got: ${JSON.stringify(calls)}`,
+    );
   } finally {
     closeDatabase();
     invalidateStateCache();

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,129 @@ 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("readCompatMarker heals invalid keys that canonicalize back under .gsd", () => {
+  const base = makeTmpBase();
+  const safeKey = "m1/roadmap.md";
+  mkdirSync(join(base, ".gsd", "m1"), { recursive: true });
+  writeFileSync(join(base, ".gsd", safeKey), "# Roadmap\n", "utf-8");
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-07-07T00:00:00.000Z",
+    projections: {
+      [`../.gsd/${safeKey}`]: { sha: "aaaaaaaaaaaaaaaa", entities: ["M001"] },
+    },
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: "1.8.1",
+  });
+
+  const marker = readCompatMarker(base);
+  assert.ok(marker.projections[safeKey], "derivable traversal-form key must be rewritten");
+  assert.equal(marker.projections[`../.gsd/${safeKey}`], undefined);
+  assert.ok(
+    !readdirSync(join(base, ".gsd")).some((f: string) => f.startsWith(".compat.json.bad-")),
+    "healed marker must not be quarantined",
+  );
+});
+
+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",
+  );
+});