gsd-pi 2.80.0-dev.c5f2443b3 → 2.80.0-dev.d4fc28e6b

package/src/resources/extensions/gsd/tests/safety-harness-false-positives.test.ts

@@ -144,6 +144,18 @@ test("safety-harness-bug2-race: bash evidence survives mid-unit reset between to
   assert.ok(bash[0].outputSnippet.includes("found"), "output snippet captured");
 });
 
+test("safety-harness: gsd_exec counts as execution evidence", () => {
+  resetEvidence();
+
+  recordToolCall("tc-exec-1", "gsd_exec", { command: "grep -n render index.html" });
+  recordToolResult("tc-exec-1", "gsd_exec", "Command exited with code 0\n1:render\n", false);
+
+  const bash = getEvidence().filter((e): e is BashEvidence => e.kind === "bash");
+  assert.equal(bash.length, 1, "gsd_exec must be tracked as execution evidence");
+  assert.equal(bash[0].command, "grep -n render index.html");
+  assert.equal(bash[0].exitCode, 0);
+});
+
 // ─── Bug 3: git diff HEAD~1 scope check ─────────────────────────────────────
 
 test("safety-harness-bug3: validateFileChanges works on initial commit (no HEAD~1)", (t) => {
@@ -237,3 +249,20 @@ test("safety-harness-bug3: validateFileChanges works on merge commit", (t) => {
   // Must produce a valid result without throwing
   assert.ok(audit !== null, "audit must be produced for merge commit repo");
 });
+
+test("safety-harness: planned changed file avoids unexpected-file warning", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-planned-file-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  execFileSync("git", ["init"], { cwd: base });
+  execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: base });
+  execFileSync("git", ["config", "user.name", "Test User"], { cwd: base });
+  writeFileSync(join(base, "index.html"), "<main></main>\n");
+  execFileSync("git", ["add", "index.html"], { cwd: base });
+  execFileSync("git", ["commit", "-m", "add static app"], { cwd: base });
+
+  const audit = validateFileChanges(base, [], ["index.html"]);
+  assert.ok(audit !== null, "audit must be produced");
+  assert.deepEqual(audit!.unexpectedFiles, [], "planned index.html must not be unexpected");
+  assert.deepEqual(audit!.missingFiles, [], "planned index.html must not be missing");
+});

package/src/resources/extensions/gsd/tests/schema-v27-v28-sequence.test.ts

@@ -0,0 +1,156 @@
+// gsd-2 / V27 + V28 schema migration regression tests
+//
+// Same bug class as #4591 (schema-v21-sequence): a migration block can be
+// added but the SCHEMA_VERSION constant left unchanged, causing fresh-install
+// + upgrade paths to silently skip the column add. This file pins both V27
+// (artifacts.content_hash) and V28 (memories.last_hit_at) at the schema and
+// write-path level on fresh-install DBs.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  _getAdapter,
+  insertArtifact,
+  insertMemoryRow,
+  incrementMemoryHitCount,
+  SCHEMA_VERSION,
+} from "../gsd-db.ts";
+
+function makeTmp(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "gsd-v27v28-"));
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { fs.rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("SCHEMA_VERSION constant is at least 28 (V28 migration committed)", () => {
+  assert.ok(
+    SCHEMA_VERSION >= 28,
+    `SCHEMA_VERSION must be ≥ 28 after V28 migration; got ${SCHEMA_VERSION}`,
+  );
+});
+
+test("fresh-install DB has artifacts.content_hash column (V27)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const cols = db.prepare("PRAGMA table_info(artifacts)").all() as Array<Record<string, unknown>>;
+    const colNames = new Set(cols.map((c) => c["name"] as string));
+    assert.ok(
+      colNames.has("content_hash"),
+      "V27 must add content_hash column to artifacts on fresh install",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("fresh-install DB has memories.last_hit_at column (V28)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const cols = db.prepare("PRAGMA table_info(memories)").all() as Array<Record<string, unknown>>;
+    const colNames = new Set(cols.map((c) => c["name"] as string));
+    assert.ok(
+      colNames.has("last_hit_at"),
+      "V28 must add last_hit_at column to memories on fresh install",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("fresh-install DB stamps SCHEMA_VERSION (≥28) in schema_version table", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get() as Record<string, unknown> | undefined;
+    const max = (row?.["v"] as number) ?? 0;
+    assert.ok(max >= 28, `fresh install must record schema_version ≥ 28; got ${max}`);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("insertArtifact populates content_hash with SHA-256 of full_content (V27 write-path)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    insertArtifact({
+      path: "M001/PROJECT.md",
+      artifact_type: "PROJECT",
+      milestone_id: "M001",
+      slice_id: null,
+      task_id: null,
+      full_content: "hello world",
+    });
+
+    const db = _getAdapter()!;
+    const row = db
+      .prepare("SELECT content_hash FROM artifacts WHERE path = :p")
+      .get({ ":p": "M001/PROJECT.md" }) as Record<string, unknown> | undefined;
+    const hash = row?.["content_hash"] as string | null | undefined;
+
+    // SHA-256 of "hello world" hex-encoded:
+    const expected = "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9";
+    assert.equal(hash, expected, "content_hash must be SHA-256 hex of full_content");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("incrementMemoryHitCount sets last_hit_at alongside hit_count (V28 write-path)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+
+    const created = "2026-01-01T00:00:00.000Z";
+    insertMemoryRow({
+      id: "MEM001",
+      category: "gotcha",
+      content: "test memory",
+      confidence: 0.9,
+      sourceUnitType: null,
+      sourceUnitId: null,
+      createdAt: created,
+      updatedAt: created,
+      scope: "project",
+      tags: [],
+      structuredFields: null,
+    });
+
+    // Before increment: last_hit_at should be NULL
+    const db = _getAdapter()!;
+    const before = db
+      .prepare("SELECT last_hit_at FROM memories WHERE id = :id")
+      .get({ ":id": "MEM001" }) as Record<string, unknown>;
+    assert.equal(before["last_hit_at"], null, "last_hit_at starts NULL on fresh insert");
+
+    const hitTime = "2026-02-01T00:00:00.000Z";
+    incrementMemoryHitCount("MEM001", hitTime);
+
+    const after = db
+      .prepare("SELECT hit_count, last_hit_at FROM memories WHERE id = :id")
+      .get({ ":id": "MEM001" }) as Record<string, unknown>;
+    assert.equal(after["hit_count"], 1, "hit_count increments");
+    assert.equal(after["last_hit_at"], hitTime, "last_hit_at set to provided timestamp");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/select-resumable-milestone.test.ts

@@ -0,0 +1,96 @@
+// GSD-2 + src/resources/extensions/gsd/tests/select-resumable-milestone.test.ts
+// Regression: bootstrap must rederive `currentMilestoneId` from an unmerged
+// completed milestone branch when in-memory state was lost across a process
+// restart (#5538-followup).
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { _selectResumableMilestone } from "../auto-start.js";
+
+const ALL_COMPLETE = (_id: string) => true;
+const NEVER_COMPLETE = (_id: string) => false;
+const HAS_COMMITS = (_branch: string) => 1;
+const NO_COMMITS = (_branch: string) => 0;
+
+test("returns null when no branches exist", () => {
+  const result = _selectResumableMilestone([], new Set(), ALL_COMPLETE, HAS_COMMITS);
+  assert.equal(result, null);
+});
+
+test("returns null when every milestone branch is already merged", () => {
+  const branches = ["milestone/M001", "milestone/M002"];
+  const merged = new Set(branches);
+  const result = _selectResumableMilestone(branches, merged, ALL_COMPLETE, HAS_COMMITS);
+  assert.equal(result, null);
+});
+
+test("returns null when no candidate milestones are complete", () => {
+  const branches = ["milestone/M002"];
+  const result = _selectResumableMilestone(branches, new Set(), NEVER_COMPLETE, HAS_COMMITS);
+  assert.equal(result, null);
+});
+
+test("returns null when no branch has commits ahead", () => {
+  const branches = ["milestone/M002"];
+  const result = _selectResumableMilestone(branches, new Set(), ALL_COMPLETE, NO_COMMITS);
+  assert.equal(result, null);
+});
+
+test("returns the unmerged completed milestone (regression: M002 stranded after restart)", () => {
+  // Repro of test12345 state: M001 ✅ merged, M002 ✅ unmerged, M003 🔄.
+  // Bootstrap must seed currentMilestoneId = "M002" so the loop's transition
+  // guard fires when the next iteration sees mid="M003".
+  const branches = ["milestone/M002", "milestone/M003"];
+  const merged = new Set<string>(); // none merged from this list
+  const isComplete = (id: string) => id === "M002"; // M003 still in progress
+  const result = _selectResumableMilestone(branches, merged, isComplete, HAS_COMMITS);
+  assert.equal(result, "M002");
+});
+
+test("picks the lex-greatest milestone when multiple candidates exist", () => {
+  // M001, M002 both unmerged complete -> pick M002 (the most recent).
+  const branches = ["milestone/M001", "milestone/M002"];
+  const result = _selectResumableMilestone(
+    branches,
+    new Set(),
+    ALL_COMPLETE,
+    HAS_COMMITS,
+  );
+  assert.equal(result, "M002");
+});
+
+test("ignores branch names that don't follow the milestone/ prefix", () => {
+  const branches = ["feature/something", "milestone/M002", "fix/bug-1"];
+  const result = _selectResumableMilestone(
+    branches,
+    new Set(),
+    ALL_COMPLETE,
+    HAS_COMMITS,
+  );
+  assert.equal(result, "M002");
+});
+
+test("isComplete callback throwing skips that milestone but does not crash", () => {
+  const branches = ["milestone/M001", "milestone/M002"];
+  const isComplete = (id: string) => {
+    if (id === "M001") throw new Error("db unavailable for M001");
+    return true;
+  };
+  // Implementation choice: a thrown isComplete is propagated. Wrapping in
+  // try/catch happens at the production wrapper level (findUnmergedCompletedMilestone).
+  // Verify the helper itself surfaces the error so callers see real failures.
+  assert.throws(() => _selectResumableMilestone(branches, new Set(), isComplete, HAS_COMMITS));
+});
+
+test("commitsAhead callback throwing for one branch falls through to others", () => {
+  // Production wrapper: commits-ahead failures should not abort the search.
+  // The helper catches throws from commitsAhead per-branch and treats as 0.
+  const branches = ["milestone/M001", "milestone/M002"];
+  const commitsAhead = (branch: string) => {
+    if (branch === "milestone/M001") throw new Error("rev-walk failed");
+    return 5;
+  };
+  const result = _selectResumableMilestone(branches, new Set(), ALL_COMPLETE, commitsAhead);
+  assert.equal(result, "M002");
+});

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts

@@ -206,6 +206,83 @@ test("session_start does NOT call setFooter or suppress gsd-health when isAutoAc
   assert.equal(healthWidgetHideCount, 0, "gsd-health must NOT be hidden when isAutoActive() is false");
 });
 
+test("session_start installs the welcome screen as the TUI header", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-welcome-header-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(dir, "bin"), { recursive: true });
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  writeFileSync(join(dir, "bin", "welcome-screen.js"), "export const stale = true;\n", "utf-8");
+  writeFileSync(
+    join(dir, "dist", "welcome-screen.js"),
+    [
+      "export function buildWelcomeScreenLines(opts) {",
+      "  return [`welcome ${opts.version} ${opts.remoteChannel ?? 'none'} ${opts.width}`];",
+      "}",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const originalCwd = process.cwd();
+  const originalGsdPkgRoot = process.env.GSD_PKG_ROOT;
+  const originalGsdBinPath = process.env.GSD_BIN_PATH;
+  const originalGsdVersion = process.env.GSD_VERSION;
+  const originalFirstRunBanner = process.env.GSD_FIRST_RUN_BANNER;
+  process.chdir(dir);
+  process.env.GSD_PKG_ROOT = dir;
+  process.env.GSD_BIN_PATH = join(dir, "bin", "loader.js");
+  process.env.GSD_VERSION = "9.9.9-test";
+  delete process.env.GSD_FIRST_RUN_BANNER;
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdPkgRoot === undefined) delete process.env.GSD_PKG_ROOT;
+    else process.env.GSD_PKG_ROOT = originalGsdPkgRoot;
+    if (originalGsdBinPath === undefined) delete process.env.GSD_BIN_PATH;
+    else process.env.GSD_BIN_PATH = originalGsdBinPath;
+    if (originalGsdVersion === undefined) delete process.env.GSD_VERSION;
+    else process.env.GSD_VERSION = originalGsdVersion;
+    if (originalFirstRunBanner === undefined) delete process.env.GSD_FIRST_RUN_BANNER;
+    else process.env.GSD_FIRST_RUN_BANNER = originalFirstRunBanner;
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
+
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const sessionStart = handlers.get("session_start");
+  assert.ok(sessionStart, "session_start handler must be registered");
+
+  let headerFactory: ((tui: unknown, theme: unknown) => { render(width: number): string[] }) | undefined;
+  await sessionStart!({}, {
+    hasUI: true,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setFooter: () => {},
+      setHeader: (factory: typeof headerFactory) => {
+        headerFactory = factory;
+      },
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: () => {},
+    },
+    sessionManager: { getSessionId: () => null },
+    model: null,
+  } as any);
+
+  assert.equal(typeof headerFactory, "function", "session_start should install a header factory");
+  const header = headerFactory!({}, {});
+  assert.deepEqual(header.render(123), ["welcome 9.9.9-test none 123"]);
+});
+
 test("session_start and session_switch apply disabled model provider policy from current preferences", async (t) => {
   const dir = join(
     tmpdir(),

package/src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts

@@ -0,0 +1,166 @@
+// GSD-2 + src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts
+// Regression: session-transition aborts must not be classified as user cancellations.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  _handleSessionSwitchAgentEnd,
+  isClaudeCodeSessionSwitchAbortMessage,
+} from "../bootstrap/agent-end-recovery.js";
+import type { ErrorContext } from "../auto/types.js";
+
+test("user-abort message during session-switch is dropped (not propagated as cancellation)", () => {
+  // The Anthropic SDK emits this exact string when newSession() aborts an
+  // in-flight stream during a unit-to-unit session transition. Before the fix
+  // this was misclassified as a user cancellation and killed auto-mode with
+  // "Auto-mode stopped — Unit aborted: Claude Code process aborted by user".
+  let cancelledWith: ErrorContext | null = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "error", errorMessage: "Claude Code process aborted by user" },
+    resolveCancelled,
+  );
+  assert.equal(cancelledWith, null, "SDK user-abort during session-switch must not propagate cancellation");
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "error", errorMessage: "Request aborted by user" },
+    resolveCancelled,
+  );
+  assert.equal(cancelledWith, null, "proxy user-abort during session-switch must not propagate cancellation");
+});
+
+test("genuine stopReason='aborted' with errorMessage during session-switch still propagates", () => {
+  // Regression guard for prior behavior: genuine aborts with diagnostic content
+  // continue to surface as cancellations so transient-pause recovery can run.
+  let cancelledWith: { message: string; category: string; isTransient?: boolean } | null = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    {
+      stopReason: "aborted",
+      errorMessage: "stream torn down mid-flight",
+      content: [{ type: "text", text: "partial output" }],
+    },
+    resolveCancelled,
+  );
+
+  assert.deepEqual(cancelledWith, {
+    message: "stream torn down mid-flight",
+    category: "aborted",
+    isTransient: true,
+  });
+});
+
+test("Claude Code stream-aborted placeholder during session-switch is dropped", () => {
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    {
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Claude Code stream aborted by caller" }],
+    },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
+test("Claude Code session-switch abort detection is narrow", () => {
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "error",
+      content: [{ type: "text", text: "Claude Code error: Claude Code process aborted by user" }],
+    }),
+    false,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Claude Code stream aborted by caller" }],
+    }),
+    true,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "partial output before network failure" }],
+    }),
+    false,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Request aborted by user\nAPI Error: 529 overloaded" }],
+    }),
+    false,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "error",
+      errorMessage: "Request aborted by user",
+      content: [{ type: "text", text: "Claude Code process aborted by user" }],
+    }),
+    true,
+  );
+});
+
+test("empty-content aborted during session-switch is silently ignored", () => {
+  // Empty-content aborted is a non-fatal LLM stop; we must not pause/cancel.
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "aborted", content: [] },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
+test("non-abort errors during session-switch are not propagated through this helper", () => {
+  // Real provider errors (rate-limit, network, unsupported-model) are handled
+  // by the post-switch retry pipeline — not by the in-flight switch handler.
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "error", errorMessage: "rate limit exceeded" },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
+test("malformed lastMsg is rejected gracefully", () => {
+  let calls = 0;
+  const resolveCancelled = (_ctx: unknown) => {
+    calls += 1;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(undefined, resolveCancelled as never);
+  _handleSessionSwitchAgentEnd(null, resolveCancelled as never);
+  _handleSessionSwitchAgentEnd("not an object", resolveCancelled as never);
+  _handleSessionSwitchAgentEnd({}, resolveCancelled as never);
+  _handleSessionSwitchAgentEnd({ stopReason: "completed" }, resolveCancelled as never);
+
+  assert.equal(calls, 0, "malformed or non-abort lastMsg must not invoke cancellation");
+});

package/src/resources/extensions/gsd/tests/signal-handlers.test.ts

@@ -101,3 +101,30 @@ test("registerSigtermHandler deregisters previous handler from all signals", ()
   // Clean up
   deregisterSigtermHandler(handler2);
 });
+
+test("registered signal handler runs best-effort cleanup before exiting", () => {
+  let cleanupCalled = false;
+  let exitCode: number | string | null | undefined;
+  const originalExit = process.exit;
+  const handler = registerSigtermHandler(
+    "/tmp/test-signal-cleanup",
+    null,
+    () => {
+      cleanupCalled = true;
+    },
+  );
+
+  (process as any).exit = ((code?: number | string | null) => {
+    exitCode = code;
+    throw new Error("process.exit intercepted");
+  }) as never;
+
+  try {
+    assert.throws(() => handler(), /process\.exit intercepted/);
+    assert.equal(cleanupCalled, true);
+    assert.equal(exitCode, 0);
+  } finally {
+    (process as any).exit = originalExit;
+    deregisterSigtermHandler(handler);
+  }
+});

package/src/resources/extensions/gsd/tests/smart-entry-complete.test.ts

@@ -47,6 +47,9 @@ test("guided-flow complete branch offers a chooser for next milestone or status"
   const branchChunk = guidedFlowSource.slice(branchIdx, nextBranchIdx === -1 ? branchIdx + 1600 : nextBranchIdx);
 
   assert.match(branchChunk, /showNextAction\(/, "complete branch should present a chooser");
+  assert.match(branchChunk, /id:\s*"quick_task"/, "complete branch should offer quick task before milestone planning");
+  assert.match(branchChunk, /Do a small bounded task without opening a milestone/, "quick task action should explain that it avoids milestones");
+  assert.match(branchChunk, /recommended:\s*true/, "quick task action should be the recommended complete-state action");
   assert.match(branchChunk, /findMilestoneIds\(basePath\)/, "complete branch should compute the next milestone id");
   assert.match(
     branchChunk,
@@ -56,6 +59,41 @@ test("guided-flow complete branch offers a chooser for next milestone or status"
   assert.match(branchChunk, /dispatchWorkflow\(pi, await prepareAndBuildDiscussPrompt\(/, "complete branch should dispatch the prepared discuss prompt");
 });
 
+test("guided-flow quick task choices prompt for text and route through /gsd quick", () => {
+  const guidedFlowSource = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
+
+  assert.match(
+    guidedFlowSource,
+    /async function runQuickTaskChoice\([\s\S]*ctx\.ui\.input\("Quick task"[\s\S]*await import\("\.\/quick\.js"\)[\s\S]*await handleQuick\(task,\s*ctx,\s*pi\)/,
+    "quick task chooser should prompt for task text and route through handleQuick",
+  );
+
+  const notifyOnlyPattern = /if \(choice === "quick_task"\) \{\s*ctx\.ui\.notify\("Run \/gsd quick <task>/;
+  assert.doesNotMatch(
+    guidedFlowSource,
+    notifyOnlyPattern,
+    "quick task chooser must not merely print instructions after selection",
+  );
+
+  const quickChoiceCalls = guidedFlowSource.match(/if \(choice === "quick_task"\) \{\s*await runQuickTaskChoice\(ctx,\s*pi\);/g) ?? [];
+  assert.equal(quickChoiceCalls.length, 3, "all guided-flow quick task choices should dispatch the helper");
+});
+
+test("dispatcher routes multi-word freeform /gsd input through /gsd do", () => {
+  const dispatcherSource = readFileSync(join(import.meta.dirname, "..", "commands", "dispatcher.ts"), "utf-8");
+
+  assert.match(
+    dispatcherSource,
+    /if\s*\(trimmed\.includes\(" "\)\)\s*\{[\s\S]*handleDo\(trimmed,\s*ctx,\s*pi\)/,
+    "dispatcher should treat multi-word unknown input as natural-language /gsd do work",
+  );
+  assert.match(
+    dispatcherSource,
+    /Unknown: \/gsd/,
+    "single-token unknown commands should still report the normal unknown-command warning",
+  );
+});
+
 test("guided-flow needs-discussion skip branch opens the project DB before reserving a new milestone", () => {
   const guidedFlowSource = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
   const laterDbOpenIdx = guidedFlowSource.indexOf("// Ensure DB is open before querying slices (#2560).");