gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.fd2382b9f

package/src/resources/extensions/gsd/tests/commands-do.test.ts

@@ -40,6 +40,8 @@ const ROUTES: Route[] = [
   { keywords: ["backlog", "parking lot", "later", "someday"], command: "backlog" },
   { keywords: ["add tests", "write tests", "generate tests", "test coverage"], command: "add-tests" },
   { keywords: ["next", "step", "next step", "what's next"], command: "next" },
+  { keywords: ["logs", "debug logs", "log files"], command: "logs" },
+  { keywords: ["debug", "debug session", "investigate", "troubleshoot", "diagnose issue"], command: "debug" },
 ];
 
 interface MatchResult {
@@ -120,8 +122,54 @@ test("/gsd do: prefers longer keyword match", () => {
   assert.ok(match.score >= 12);
 });
 
+test("/gsd do: routes debug troubleshooting intent to debug", () => {
+  const match = matchRoute("debug this flaky oauth callback");
+  assert.ok(match);
+  assert.equal(match.command, "debug");
+});
+
+test("/gsd do: keeps 'debug logs' routed to logs (longer keyword wins)", () => {
+  const match = matchRoute("show me debug logs for today");
+  assert.ok(match);
+  assert.equal(match.command, "logs");
+});
+
 test("/gsd do: routes 'session report' to session-report", () => {
   const match = matchRoute("show me the session report");
   assert.ok(match);
   assert.equal(match.command, "session-report");
 });
+
+test("/gsd do: routes 'diagnose issue' to debug (not doctor)", () => {
+  // 'diagnose issue' is an explicit keyword on the debug route to distinguish
+  // session-level issue diagnosis from /gsd doctor health checks.
+  const match = matchRoute("diagnose issue with oauth callback");
+  assert.ok(match);
+  assert.equal(match.command, "debug");
+});
+
+test("/gsd do: routes 'investigate flaky test' to debug", () => {
+  const match = matchRoute("investigate flaky test in CI");
+  assert.ok(match);
+  assert.equal(match.command, "debug");
+});
+
+test("/gsd do: 'debug logs' keyword wins over bare 'debug' (longer keyword precedence)", () => {
+  // 'debug logs' (10 chars) > 'debug' (5 chars)
+  const logsMatch = matchRoute("debug logs for the last run");
+  assert.ok(logsMatch);
+  assert.equal(logsMatch.command, "logs");
+  assert.ok(logsMatch.score >= 10, `expected score >= 10, got ${logsMatch.score}`);
+
+  // Bare 'debug' without 'logs' should still route to debug.
+  const debugMatch = matchRoute("debug the payment timeout issue");
+  assert.ok(debugMatch);
+  assert.equal(debugMatch.command, "debug");
+});
+
+test("/gsd do: 'diagnose' alone routes to doctor (health check), not debug", () => {
+  // 'diagnose' maps to the doctor route; 'diagnose issue' maps to debug.
+  const match = matchRoute("diagnose my project");
+  assert.ok(match);
+  assert.equal(match.command, "doctor");
+});

package/src/resources/extensions/gsd/tests/commands-scan.test.ts

@@ -0,0 +1,351 @@
+/**
+ * Tests for /gsd scan command — pure functions + handler integration
+ */
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  parseScanArgs,
+  resolveScanDocuments,
+  buildScanOutputPaths,
+  checkExistingDocuments,
+  handleScan,
+  VALID_FOCUS_AREAS,
+  DEFAULT_FOCUS,
+} from "../commands-scan.js";
+
+// ─── Test fixtures ────────────────────────────────────────────────────────────
+
+const tmpDirs: string[] = [];
+
+function makeTmpDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-scan-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tmpDirs) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // best-effort cleanup
+    }
+  }
+  tmpDirs.length = 0;
+});
+
+// ─── parseScanArgs ────────────────────────────────────────────────────────────
+
+describe("parseScanArgs", () => {
+  test("returns default focus when no args provided", () => {
+    const result = parseScanArgs("");
+    assert.equal(result.focus, DEFAULT_FOCUS);
+  });
+
+  test("returns default focus for whitespace-only args", () => {
+    const result = parseScanArgs("   ");
+    assert.equal(result.focus, DEFAULT_FOCUS);
+  });
+
+  test("parses --focus tech", () => {
+    const result = parseScanArgs("--focus tech");
+    assert.equal(result.focus, "tech");
+  });
+
+  test("parses --focus arch", () => {
+    const result = parseScanArgs("--focus arch");
+    assert.equal(result.focus, "arch");
+  });
+
+  test("parses --focus quality", () => {
+    const result = parseScanArgs("--focus quality");
+    assert.equal(result.focus, "quality");
+  });
+
+  test("parses --focus concerns", () => {
+    const result = parseScanArgs("--focus concerns");
+    assert.equal(result.focus, "concerns");
+  });
+
+  test("parses --focus tech+arch", () => {
+    const result = parseScanArgs("--focus tech+arch");
+    assert.equal(result.focus, "tech+arch");
+  });
+
+  test("is case-insensitive for focus value", () => {
+    const result = parseScanArgs("--focus TECH");
+    assert.equal(result.focus, "tech");
+  });
+
+  test("returns default for unknown focus value", () => {
+    const result = parseScanArgs("--focus unknown");
+    assert.equal(result.focus, DEFAULT_FOCUS);
+  });
+
+  test("ignores extra whitespace around flag value", () => {
+    const result = parseScanArgs("  --focus   arch  ");
+    assert.equal(result.focus, "arch");
+  });
+
+  test("rejects shell injection attempts — uses default", () => {
+    const result = parseScanArgs("--focus tech; rm -rf /");
+    assert.equal(result.focus, DEFAULT_FOCUS);
+  });
+});
+
+// ─── resolveScanDocuments ────────────────────────────────────────────────────
+
+describe("resolveScanDocuments", () => {
+  test("tech focus returns STACK and INTEGRATIONS", () => {
+    const docs = resolveScanDocuments("tech");
+    assert.deepEqual(docs, ["STACK", "INTEGRATIONS"]);
+  });
+
+  test("arch focus returns ARCHITECTURE and STRUCTURE", () => {
+    const docs = resolveScanDocuments("arch");
+    assert.deepEqual(docs, ["ARCHITECTURE", "STRUCTURE"]);
+  });
+
+  test("quality focus returns CONVENTIONS and TESTING", () => {
+    const docs = resolveScanDocuments("quality");
+    assert.deepEqual(docs, ["CONVENTIONS", "TESTING"]);
+  });
+
+  test("concerns focus returns CONCERNS only", () => {
+    const docs = resolveScanDocuments("concerns");
+    assert.deepEqual(docs, ["CONCERNS"]);
+  });
+
+  test("tech+arch (default) returns all four tech and arch docs", () => {
+    const docs = resolveScanDocuments("tech+arch");
+    assert.deepEqual(docs, ["STACK", "INTEGRATIONS", "ARCHITECTURE", "STRUCTURE"]);
+  });
+
+  test("unknown focus falls back to default documents", () => {
+    const docs = resolveScanDocuments("unknown-area");
+    assert.deepEqual(docs, resolveScanDocuments(DEFAULT_FOCUS));
+  });
+
+  test("each valid focus area returns at least one document", () => {
+    for (const area of VALID_FOCUS_AREAS) {
+      const docs = resolveScanDocuments(area);
+      assert.ok(docs.length > 0, `focus "${area}" should return at least one document`);
+    }
+  });
+});
+
+// ─── buildScanOutputPaths ────────────────────────────────────────────────────
+
+describe("buildScanOutputPaths", () => {
+  test("returns paths under .gsd/codebase/ relative to basePath", () => {
+    const base = "/some/project";
+    const paths = buildScanOutputPaths("tech", base);
+    assert.ok(paths.every((p) => p.startsWith(join(base, ".gsd", "codebase"))));
+  });
+
+  test("each path ends with .md extension", () => {
+    const base = "/some/project";
+    const paths = buildScanOutputPaths("arch", base);
+    assert.ok(paths.every((p) => p.endsWith(".md")));
+  });
+
+  test("number of paths matches number of documents for focus", () => {
+    const base = "/some/project";
+    const docs = resolveScanDocuments("quality");
+    const paths = buildScanOutputPaths("quality", base);
+    assert.equal(paths.length, docs.length);
+  });
+
+  test("document names are uppercased in filenames", () => {
+    const base = "/some/project";
+    const paths = buildScanOutputPaths("tech", base);
+    assert.ok(paths.some((p) => p.includes("STACK.md")));
+    assert.ok(paths.some((p) => p.includes("INTEGRATIONS.md")));
+  });
+
+  test("falls back to default focus documents for unknown focus", () => {
+    const base = "/some/project";
+    const paths = buildScanOutputPaths("nonexistent-area", base);
+    const expected = buildScanOutputPaths(DEFAULT_FOCUS, base);
+    assert.deepEqual(paths, expected);
+  });
+});
+
+// ─── checkExistingDocuments ──────────────────────────────────────────────────
+
+describe("checkExistingDocuments", () => {
+  test("returns empty array when no documents exist", () => {
+    const tmpDir = makeTmpDir();
+    const paths = [join(tmpDir, "STACK.md"), join(tmpDir, "INTEGRATIONS.md")];
+    const existing = checkExistingDocuments(paths);
+    assert.deepEqual(existing, []);
+  });
+
+  test("returns only the paths that exist on disk", () => {
+    const tmpDir = makeTmpDir();
+    const stackPath = join(tmpDir, "STACK.md");
+    const intPath = join(tmpDir, "INTEGRATIONS.md");
+
+    writeFileSync(stackPath, "# Stack");
+
+    const existing = checkExistingDocuments([stackPath, intPath]);
+    assert.deepEqual(existing, [stackPath]);
+  });
+
+  test("returns all paths when all documents exist", () => {
+    const tmpDir = makeTmpDir();
+    const paths = [
+      join(tmpDir, "STACK.md"),
+      join(tmpDir, "INTEGRATIONS.md"),
+    ];
+
+    for (const p of paths) writeFileSync(p, "content");
+
+    const existing = checkExistingDocuments(paths);
+    assert.deepEqual(existing, paths);
+  });
+
+  test("returns empty array for empty input", () => {
+    const existing = checkExistingDocuments([]);
+    assert.deepEqual(existing, []);
+  });
+});
+
+// ─── handleScan integration ───────────────────────────────────────────────────
+// Verifies the handler creates the output directory and dispatches the correct
+// prompt without running a real AI turn.
+
+function makeMockPi() {
+  const calls: Array<{ msg: unknown; opts: unknown }> = [];
+  return {
+    sendMessage: (msg: unknown, opts: unknown) => { calls.push({ msg, opts }); },
+    calls,
+  };
+}
+
+function makeMockCtx() {
+  const notifications: Array<{ text: string; level: string }> = [];
+  return {
+    ui: {
+      notify: (text: string, level: string) => { notifications.push({ text, level }); },
+    },
+    notifications,
+  };
+}
+
+describe("handleScan — handler integration", () => {
+  test("creates .gsd/codebase/ directory", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("", ctx as never, pi as never);
+
+    assert.ok(existsSync(join(tmpDir, ".gsd", "codebase")));
+  });
+
+  test("calls pi.sendMessage with triggerTurn: true", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("", ctx as never, pi as never);
+
+    assert.equal(pi.calls.length, 1);
+    const opts = pi.calls[0].opts as { triggerTurn: boolean };
+    assert.equal(opts.triggerTurn, true);
+  });
+
+  test("default focus dispatches tech+arch documents", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("", ctx as never, pi as never);
+
+    const msg = pi.calls[0].msg as { content: string };
+    // The "Documents to produce" line lists exactly the active documents
+    assert.ok(
+      msg.content.includes("Documents to produce:** STACK, INTEGRATIONS, ARCHITECTURE, STRUCTURE"),
+      "prompt documents line should list tech+arch docs",
+    );
+  });
+
+  test("--focus quality dispatches only CONVENTIONS and TESTING", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("--focus quality", ctx as never, pi as never);
+
+    const msg = pi.calls[0].msg as { content: string };
+    // The "Documents to produce" line must list exactly CONVENTIONS and TESTING
+    assert.ok(
+      msg.content.includes("Documents to produce:** CONVENTIONS, TESTING"),
+      "prompt documents line should list only quality docs",
+    );
+    // The focus reinforcement line must also reflect quality
+    assert.ok(
+      msg.content.includes("relevant: **CONVENTIONS, TESTING**"),
+      "focus reinforcement line should name only quality docs",
+    );
+  });
+
+  test("notifies user with the active focus before dispatch", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("--focus concerns", ctx as never, pi as never);
+
+    const infoNote = ctx.notifications.find((n) => n.level === "info");
+    assert.ok(infoNote, "should emit an info notification");
+    assert.ok(infoNote.text.includes("concerns"), "notification should mention the active focus");
+  });
+
+  test("warns when documents already exist", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    // Pre-create one of the output documents
+    const codesbaseDir = join(tmpDir, ".gsd", "codebase");
+    mkdirSync(codesbaseDir, { recursive: true });
+    writeFileSync(join(codesbaseDir, "STACK.md"), "# existing");
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("--focus tech", ctx as never, pi as never);
+
+    const warning = ctx.notifications.find((n) => n.level === "warning");
+    assert.ok(warning, "should warn about existing documents");
+    assert.ok(warning.text.includes("STACK.md"), "warning should name the existing file");
+  });
+});

package/src/resources/extensions/gsd/tests/commands-workflow-custom.test.ts

@@ -119,13 +119,15 @@ describe("workflow catalog registration", () => {
     assert.ok(entry!.desc.includes("run"), "description should mention run");
   });
 
-  it("getGsdArgumentCompletions('workflow ') returns six subcommands", () => {
+  it("getGsdArgumentCompletions('workflow ') returns the full subcommand set", () => {
     const completions = getGsdArgumentCompletions("workflow ");
     const labels = completions.map((c: any) => c.label);
-    for (const sub of ["new", "run", "list", "validate", "pause", "resume"]) {
+    for (const sub of [
+      "new", "run", "list", "info", "install", "uninstall", "validate", "pause", "resume",
+    ]) {
       assert.ok(labels.includes(sub), `missing completion: ${sub}`);
     }
-    assert.equal(labels.length, 6, "should have exactly 6 subcommands");
+    assert.equal(labels.length, 9, "should have exactly 9 subcommands");
   });
 
   it("getGsdArgumentCompletions('workflow r') filters to run and resume", () => {
@@ -190,12 +192,12 @@ describe("workflow command handler", () => {
     return { handled, notifications: ctx.notifications };
   }
 
-  it("bare '/gsd workflow' shows usage", async () => {
+  it("bare '/gsd workflow' lists plugins grouped by mode", async () => {
     const { handled, notifications } = await callHandler("workflow");
     assert.ok(handled, "should be handled");
     assert.ok(
-      notifications.some((n) => n.message.includes("Usage: /gsd workflow")),
-      "should show usage",
+      notifications.some((n) => n.message.includes("Workflow Plugins")),
+      "should list plugins",
     );
   });
 

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

@@ -125,9 +125,9 @@ console.log('\n=== complete-slice: schema v6 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v15 with UOK projection tables)
+  // Verify schema version is current (v17 with ADR-011 P2 escalation columns)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 15, 'schema version should be 15');
+  assertEq(versionRow?.['v'], 17, 'schema version should be 17');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();

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

@@ -109,9 +109,9 @@ console.log('\n=== complete-task: schema v5 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v15 with UOK projection tables)
+  // Verify schema version is current (v17 with ADR-011 P2 escalation columns)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 15, 'schema version should be 15');
+  assertEq(versionRow?.['v'], 17, 'schema version should be 17');
 
   // Verify all 4 new tables exist
   const tables = adapter.prepare(

package/src/resources/extensions/gsd/tests/custom-workflow-engine.test.ts

@@ -139,6 +139,44 @@ describe("CustomWorkflowEngine.resolveDispatch", () => {
     }
   });
 
+  it("persists the dispatched step as active in GRAPH.yaml before returning", async () => {
+    const { engine, runDir } = setupEngine([
+      makeStep({ id: "step-1", prompt: "Do the first thing" }),
+      makeStep({ id: "step-2", dependsOn: ["step-1"] }),
+    ], "my-workflow");
+
+    const state = await engine.deriveState("/unused");
+    const dispatch = await engine.resolveDispatch(state, { basePath: "/unused" });
+
+    assert.equal(dispatch.action, "dispatch");
+    const graph = readGraph(runDir);
+    assert.equal(graph.steps[0].status, "active");
+    assert.ok(graph.steps[0].startedAt, "startedAt should be persisted before dispatch returns");
+    assert.equal(graph.steps[1].status, "pending");
+  });
+
+  it("reuses an already active step on a subsequent dispatch before reconcile", async () => {
+    const { engine } = setupEngine([
+      makeStep({ id: "step-1", prompt: "Do the first thing" }),
+      makeStep({ id: "step-2", dependsOn: ["step-1"] }),
+    ], "my-workflow");
+
+    let state = await engine.deriveState("/unused");
+    const firstDispatch = await engine.resolveDispatch(state, { basePath: "/unused" });
+    assert.equal(firstDispatch.action, "dispatch");
+    if (firstDispatch.action === "dispatch") {
+      assert.equal(firstDispatch.step.unitId, "my-workflow/step-1");
+    }
+
+    state = await engine.deriveState("/unused");
+    const secondDispatch = await engine.resolveDispatch(state, { basePath: "/unused" });
+    assert.equal(secondDispatch.action, "dispatch");
+    if (secondDispatch.action === "dispatch") {
+      assert.equal(secondDispatch.step.unitId, "my-workflow/step-1");
+      assert.equal(secondDispatch.step.prompt, "Do the first thing");
+    }
+  });
+
   it("returns stop when all steps are complete", async () => {
     const { engine } = setupEngine([
       makeStep({ id: "a", status: "complete" }),
@@ -280,6 +318,31 @@ describe("CustomWorkflowEngine.reconcile", () => {
     assert.equal(graph.steps[1].status, "pending");
     assert.equal(graph.steps[2].status, "pending");
   });
+
+  it("reconcile completes a step that was previously persisted as active", async () => {
+    const { engine, runDir } = setupEngine([
+      makeStep({ id: "step-1", prompt: "Do the first thing" }),
+      makeStep({ id: "step-2", dependsOn: ["step-1"] }),
+    ], "wf");
+
+    const state = await engine.deriveState("/unused");
+    const dispatch = await engine.resolveDispatch(state, { basePath: "/unused" });
+    assert.equal(dispatch.action, "dispatch");
+
+    const activeState = await engine.deriveState("/unused");
+    const result = await engine.reconcile(activeState, {
+      unitType: "custom-step",
+      unitId: "wf/step-1",
+      startedAt: Date.now() - 1000,
+      finishedAt: Date.now(),
+    });
+
+    assert.equal(result.outcome, "continue");
+    const graph = readGraph(runDir);
+    assert.equal(graph.steps[0].status, "complete");
+    assert.ok(graph.steps[0].startedAt, "startedAt should survive reconcile");
+    assert.ok(graph.steps[0].finishedAt, "finishedAt should be persisted on completion");
+  });
 });
 
 // ─── getDisplayMetadata ──────────────────────────────────────────────────