gsd-pi 2.79.0 → 2.80.0-dev.4ea7d80e7

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

@@ -0,0 +1,51 @@
+// Project/App: GSD-2
+// File Purpose: Tests for canonical process recommendations by task size.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  formatRecommendedProcessPaths,
+  listRecommendedProcessPaths,
+  recommendProcessPath,
+  type ProcessTaskSize,
+} from "../process-task-path.ts";
+
+test("process task paths cover every Phase 7 task size with one command", () => {
+  const expected: ProcessTaskSize[] = [
+    "hotfix",
+    "bugfix",
+    "small-feature",
+    "large-feature",
+    "architecture-change",
+  ];
+
+  const paths = listRecommendedProcessPaths();
+  assert.deepEqual(paths.map((path) => path.taskSize), expected);
+
+  for (const taskSize of expected) {
+    const path = recommendProcessPath(taskSize);
+    assert.equal(path.taskSize, taskSize);
+    assert.ok(path.templateId.length > 0);
+    assert.match(path.command, /^\/gsd /);
+    assert.ok(path.phases.length > 0);
+    assert.ok(path.guidance.length > 0);
+  }
+});
+
+test("process task paths route large work to the DB-backed milestone flow", () => {
+  const largeFeature = recommendProcessPath("large-feature");
+  assert.equal(largeFeature.templateId, "full-project");
+  assert.match(largeFeature.command, /\/gsd discuss/);
+  assert.match(largeFeature.command, /\/gsd auto/);
+  assert.match(largeFeature.guidance, /DB-backed milestone flow/);
+});
+
+test("formatted process paths are stable for command help", () => {
+  const formatted = formatRecommendedProcessPaths();
+  assert.match(formatted, /hotfix\s+\/gsd start hotfix/);
+  assert.match(formatted, /bugfix\s+\/gsd start bugfix/);
+  assert.match(formatted, /small-feature\s+\/gsd start small-feature/);
+  assert.match(formatted, /large-feature\s+\/gsd discuss/);
+  assert.match(formatted, /architecture-change\s+\/gsd start refactor/);
+});

package/src/resources/extensions/gsd/tests/prompt-step-ordering.test.ts

@@ -2,7 +2,7 @@
  * Regression test for #3696 — prompt step ordering and runtime fixes
  *
  * 1. complete-milestone.md: gsd_requirement_update (step 9) before
- *    gsd_complete_milestone (step 10)
+ *    gsd_complete_milestone, and completion remains the final durable write
  * 2. complete-slice.md: uses gsd_requirement_update
  * 3. register-extension.ts: _gsdEpipeGuard logs instead of re-throwing
  * 4. register-hooks.ts: session_before_compact only checks isAutoActive
@@ -50,6 +50,21 @@ describe('prompt step ordering (#3696)', () => {
     );
   });
 
+  test('project and learnings writes appear before gsd_complete_milestone', () => {
+    const projectMatch = completeMilestoneMd.match(/^\d+\.\s.*PROJECT\.md/m);
+    const learningsMatch = completeMilestoneMd.match(/^\d+\.\s.*Extract structured learnings/m);
+    const completeMilestoneMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_complete_milestone/m);
+    assert.ok(projectMatch, 'PROJECT.md update should appear in a numbered step');
+    assert.ok(learningsMatch, 'learnings extraction should appear in a numbered step');
+    assert.ok(completeMilestoneMatch, 'gsd_complete_milestone should appear in a numbered step');
+
+    const projectIdx = completeMilestoneMd.indexOf(projectMatch![0]);
+    const learningsIdx = completeMilestoneMd.indexOf(learningsMatch![0]);
+    const completeMilestoneIdx = completeMilestoneMd.indexOf(completeMilestoneMatch![0]);
+    assert.ok(projectIdx < completeMilestoneIdx, 'PROJECT.md update must happen before gsd_complete_milestone');
+    assert.ok(learningsIdx < completeMilestoneIdx, 'learnings extraction must happen before gsd_complete_milestone');
+  });
+
   test('complete-slice.md uses gsd_requirement_update', () => {
     assert.match(completeSliceMd, /gsd_requirement_update/,
       'complete-slice.md should reference gsd_requirement_update');

package/src/resources/extensions/gsd/tests/queue-prompt-rendering.test.ts

@@ -0,0 +1,37 @@
+// Project/App: GSD-2
+// File Purpose: Verifies the queue prompt renders compact discussion and write-gate guidance.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("queue prompt renders compact draft, verification, and persistence guidance", async (t) => {
+  const previousGsdHome = process.env.GSD_HOME;
+  const providedGsdHome = process.env.GSD_TEST_HOME;
+  const isolatedHome = providedGsdHome ?? mkdtempSync(join(tmpdir(), "gsd-queue-render-"));
+  process.env.GSD_HOME = isolatedHome;
+  t.after(() => {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    if (!providedGsdHome) rmSync(isolatedHome, { recursive: true, force: true });
+  });
+
+  const { loadPrompt } = await import(`../prompt-loader.ts?test=${Date.now()}`);
+  const prompt = loadPrompt("queue", {
+    preamble: "Queue preamble.",
+    existingMilestonesContext: "No existing milestones.",
+    commitInstruction: "Commit queued milestone artifacts.",
+    inlinedTemplates: "## Context Template\n\nUse standard GSD context.",
+  });
+
+  assert.match(prompt, /Draft Awareness/);
+  assert.match(prompt, /What do you want to add\?/);
+  assert.match(prompt, /Investigate between question rounds/);
+  assert.match(prompt, /Pre-Write Verification/);
+  assert.match(prompt, /depth_verification/);
+  assert.match(prompt, /gsd_milestone_generate_id/);
+  assert.match(prompt, /gsd_summary_save/);
+  assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
+});

package/src/resources/extensions/gsd/tests/register-hooks-compaction-checkpoint.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { autoSession } from "../auto-runtime-state.ts";
 import { parseContinue } from "../files.ts";
 import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { deriveState, invalidateStateCache } from "../state.ts";
@@ -96,3 +97,87 @@ test("register-hooks writes CONTINUE checkpoint during planning phase without ac
   assert.match(parsed.completedWork, /planning phase/i, "completed-work should capture non-executing phase context");
   assert.match(parsed.nextAction, /slice S01/i, "next action should route resume to the active slice");
 });
+
+test("register-hooks writes Context Mode snapshot before active auto cancels compaction", async (t) => {
+  const base = createPlanningFixtureBase();
+  const originalCwd = process.cwd();
+  process.chdir(base);
+  invalidateStateCache();
+  closeDatabase();
+  autoSession.reset();
+  autoSession.active = true;
+
+  t.after(() => {
+    autoSession.reset();
+    invalidateStateCache();
+    closeDatabase();
+    process.chdir(originalCwd);
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const compactHandlers = handlers.get("session_before_compact");
+  assert.ok(compactHandlers && compactHandlers.length > 0, "session_before_compact handler should be registered");
+
+  const result = await compactHandlers![0]({});
+
+  assert.deepEqual(result, { cancel: true }, "active auto should still cancel compaction");
+  const snapshotPath = join(base, ".gsd", "last-snapshot.md");
+  assert.ok(existsSync(snapshotPath), "active auto cancel should still leave a Context Mode snapshot");
+  assert.match(readFileSync(snapshotPath, "utf-8"), /GSD context snapshot/);
+});
+
+test("register-hooks does not write Context Mode snapshot when disabled", async (t) => {
+  const base = createPlanningFixtureBase();
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ncontext_mode:\n  enabled: false\n---\n",
+    "utf-8",
+  );
+  const originalCwd = process.cwd();
+  process.chdir(base);
+  invalidateStateCache();
+  closeDatabase();
+  autoSession.reset();
+
+  t.after(() => {
+    autoSession.reset();
+    invalidateStateCache();
+    closeDatabase();
+    process.chdir(originalCwd);
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const compactHandlers = handlers.get("session_before_compact");
+  assert.ok(compactHandlers && compactHandlers.length > 0, "session_before_compact handler should be registered");
+
+  for (const handler of compactHandlers ?? []) {
+    await handler({});
+  }
+
+  assert.ok(
+    !existsSync(join(base, ".gsd", "last-snapshot.md")),
+    "disabled Context Mode should not write a snapshot",
+  );
+});

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

@@ -95,6 +95,8 @@ test("#4782 phase 3: buildRunUatPrompt inlines slice UAT, slice summary, project
 
   // Context wrapper present
   assert.match(prompt, /## Inlined Context \(preloaded — do not re-read these files\)/);
+  assert.match(prompt, /## Context Mode/);
+  assert.match(prompt, /verification lane/);
 
   // Artifacts from the manifest inline list, in declared order:
   // slice-uat → slice-summary → project (#4925 review).

package/src/resources/extensions/gsd/tests/start-auto-detached.test.ts

@@ -3,6 +3,8 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
+import { _withDetachedAutoKeepaliveForTest } from "../auto.ts";
+
 const gsdDir = resolve(import.meta.dirname, "..");
 
 function readGsdFile(relativePath: string): string {
@@ -102,8 +104,8 @@ test("startAutoDetached reports failures asynchronously (#3733)", () => {
     "auto.ts should export startAutoDetached",
   );
   assert.ok(
-    autoSrc.includes("void startAuto(ctx, pi, base, verboseMode, options).catch"),
-    "startAutoDetached should launch startAuto without awaiting it",
+    autoSrc.includes("void withDetachedAutoKeepalive(startAuto(ctx, pi, base, verboseMode, options)).catch"),
+    "startAutoDetached should launch startAuto without awaiting it and keep the process alive",
   );
   assert.ok(
     autoSrc.includes("ctx.ui.notify(`Auto-start failed: ${message}`, \"error\")"),
@@ -111,6 +113,48 @@ test("startAutoDetached reports failures asynchronously (#3733)", () => {
   );
 });
 
+test("detached auto-start keeps a ref'ed handle until the run settles", async () => {
+  const originalSetInterval = globalThis.setInterval;
+  const originalClearInterval = globalThis.clearInterval;
+  let intervalCreated = false;
+  let intervalCleared = false;
+  let createdHandle: NodeJS.Timeout | undefined;
+  let resolveRun!: () => void;
+  const run = new Promise<void>((resolve) => {
+    resolveRun = resolve;
+  });
+
+  globalThis.setInterval = ((handler: TimerHandler, timeout?: number, ...args: unknown[]) => {
+    intervalCreated = true;
+    assert.equal(timeout, 30_000);
+    void handler;
+    void args;
+    createdHandle = originalSetInterval(() => {}, 1_000_000);
+    assert.equal(createdHandle.hasRef(), true, "detached auto keepalive must be ref'ed");
+    return createdHandle;
+  }) as unknown as typeof setInterval;
+
+  globalThis.clearInterval = ((handle?: NodeJS.Timeout | number | string) => {
+    if (handle === createdHandle) intervalCleared = true;
+    return originalClearInterval(handle);
+  }) as unknown as typeof clearInterval;
+
+  try {
+    const heldRun = _withDetachedAutoKeepaliveForTest(run);
+    assert.equal(intervalCreated, true, "keepalive interval should start immediately");
+    assert.equal(intervalCleared, false, "keepalive should remain active while auto-mode is running");
+
+    resolveRun();
+    await heldRun;
+
+    assert.equal(intervalCleared, true, "keepalive interval should clear when auto-mode settles");
+  } finally {
+    if (createdHandle) originalClearInterval(createdHandle);
+    globalThis.setInterval = originalSetInterval;
+    globalThis.clearInterval = originalClearInterval;
+  }
+});
+
 test("detached auto-start preserves milestone lock across pause/stop cleanup (#3733)", () => {
   const autoSrc = readGsdFile("auto.ts");
   const sessionSrc = readGsdFile("auto/session.ts");

package/src/resources/extensions/gsd/tests/subagent-model-dispatch.test.ts

@@ -211,6 +211,14 @@ test("buildReactiveExecutePrompt: output contains model string when subagentMode
     prompt.includes('model: "claude-opus-4-6"'),
     `Prompt should contain model instruction. Got:\n${prompt.slice(0, 500)}`,
   );
+  assert.ok(
+    prompt.includes("Context Mode (execution lane):"),
+    "embedded reactive-execute task prompt should use nested Context Mode guidance",
+  );
+  assert.ok(
+    prompt.includes("## Context Mode"),
+    "reactive-execute parent prompt should include standalone Context Mode guidance",
+  );
 });
 
 test("buildReactiveExecutePrompt: no model instruction when subagentModel omitted", async (t) => {
@@ -266,3 +274,54 @@ test("buildReactiveExecutePrompt: no model instruction when subagentModel omitte
     "Prompt should not contain model instruction when subagentModel is omitted",
   );
 });
+
+test("buildGateEvaluatePrompt: embedded gate prompts use nested Context Mode guidance", async (t) => {
+  const { buildGateEvaluatePrompt } = await import("../auto-prompts.ts");
+  const { closeDatabase, insertGateRow, insertMilestone, insertSlice, openDatabase } = await import("../gsd-db.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-gate-"));
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(repo, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01 Plan\n\n## Verification\n- Run checks.\n");
+  openDatabase(join(repo, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test Milestone", status: "active", depends_on: [] });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Test Slice",
+    status: "planned",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  insertGateRow({
+    milestoneId: "M001",
+    sliceId: "S01",
+    gateId: "Q3",
+    scope: "slice",
+  });
+
+  const prompt = await buildGateEvaluatePrompt(
+    "M001",
+    "Test Milestone",
+    "S01",
+    "Test Slice",
+    repo,
+    "claude-opus-4-6",
+  );
+
+  assert.ok(
+    prompt.includes("Context Mode (verification lane):"),
+    "embedded gate-evaluate prompt should use nested Context Mode guidance",
+  );
+  assert.ok(
+    prompt.includes("## Context Mode"),
+    "gate-evaluate parent prompt should include standalone Context Mode guidance",
+  );
+  assert.ok(prompt.includes('model: "claude-opus-4-6"'), "gate subagent prompt should preserve model instruction");
+});

package/src/resources/extensions/gsd/tests/tool-naming.test.ts

@@ -1,12 +1,10 @@
-// tool-naming — Verifies canonical + alias tool registration for GSD DB tools.
-//
-// Each DB tool must register under its canonical gsd_concept_action name
-// AND under a backward-compatible alias name.
-// The alias must share the exact same execute function reference as the canonical tool.
+// Project/App: GSD-2
+// File Purpose: Verifies canonical and alias DB tool registration plus legacy alias telemetry.
 
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { registerDbTools } from '../bootstrap/db-tools.ts';
+import { getLegacyTelemetry, resetLegacyTelemetry } from '../legacy-telemetry.ts';
 
 
 // ─── Mock PI ──────────────────────────────────────────────────────────────────
@@ -66,9 +64,9 @@ for (const { canonical, alias } of RENAME_MAP) {
   assert.ok(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
 }
 
-// ─── Execute function identity ───────────────────────────────────────────────
+// ─── Execute function wrapping ───────────────────────────────────────────────
 
-console.log('\n── Tool naming: execute function identity (===) ──');
+console.log('\n── Tool naming: alias execute wrapper ──');
 
 for (const { canonical, alias } of RENAME_MAP) {
   const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
@@ -76,12 +74,37 @@ for (const { canonical, alias } of RENAME_MAP) {
 
   if (canonicalTool && aliasTool) {
     assert.ok(
-      canonicalTool.execute === aliasTool.execute,
-      `"${canonical}" and "${alias}" should share the same execute function reference`,
+      canonicalTool.execute !== aliasTool.execute,
+      `"${alias}" should wrap "${canonical}" so alias usage can be counted`,
     );
   }
 }
 
+test("alias execute increments legacy MCP alias telemetry before delegating", async () => {
+  const canonicalTool = pi.tools.find((t: any) => t.name === "gsd_decision_save");
+  const aliasTool = pi.tools.find((t: any) => t.name === "gsd_save_decision");
+  assert.ok(canonicalTool);
+  assert.ok(aliasTool);
+
+  const originalCanonicalExecute = canonicalTool.execute;
+  try {
+    resetLegacyTelemetry();
+    let delegated = false;
+    canonicalTool.execute = async () => {
+      delegated = true;
+      return { content: [{ type: "text", text: "ok" }], details: { ok: true } };
+    };
+
+    await aliasTool.execute("call-1", {}, undefined, undefined, undefined);
+
+    assert.equal(delegated, true);
+    assert.equal(getLegacyTelemetry()["legacy.mcpAliasUsed"], 1);
+  } finally {
+    canonicalTool.execute = originalCanonicalExecute;
+    resetLegacyTelemetry();
+  }
+});
+
 // ─── Alias descriptions include "(alias for ...)" ───────────────────────────
 
 console.log('\n── Tool naming: alias descriptions ──');

package/src/resources/extensions/gsd/tests/unit-context-composer.test.ts

@@ -1,6 +1,5 @@
-// GSD-2 — #4782 phase 2 composer tests. Pure-function tests using mock
-// resolvers plus an integration check that reassess-roadmap's migrated
-// builder produces a prompt matching expectations.
+// Project/App: GSD-2
+// File Purpose: Tests unit context composer rendering, budgets, and reassess-roadmap prompt integration.
 
 import test from "node:test";
 import assert from "node:assert/strict";
@@ -9,6 +8,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import {
+  composeContextModeInstructions,
   composeInlinedContext,
   composeUnitContext,
   manifestBudgetChars,
@@ -101,6 +101,44 @@ test("#4782 composer: manifestBudgetChars returns declared budget", () => {
   assert.strictEqual(manifestBudgetChars("never-dispatched"), null);
 });
 
+test("Context Mode composer: disabled, unknown, and none modes return empty string", () => {
+  assert.strictEqual(
+    composeContextModeInstructions("execute-task", { enabled: false, renderMode: "standalone" }),
+    "",
+  );
+  assert.strictEqual(
+    composeContextModeInstructions("never-dispatched", { enabled: true, renderMode: "standalone" }),
+    "",
+  );
+  assert.strictEqual(
+    composeContextModeInstructions("workflow-preferences", { enabled: true, renderMode: "standalone" }),
+    "",
+  );
+});
+
+test("Context Mode composer: standalone output starts with heading and includes required tools", () => {
+  const out = composeContextModeInstructions("execute-task", { enabled: true, renderMode: "standalone" });
+  assert.ok(out.startsWith("## Context Mode"));
+  assert.match(out, /execution lane/i);
+  assert.match(out, /`gsd_exec`/);
+  assert.match(out, /noisy commands/);
+  assert.match(out, /`gsd_exec_search`/);
+  assert.match(out, /before reruns/);
+  assert.match(out, /`gsd_resume`/);
+  assert.match(out, /after compaction or resume/);
+});
+
+test("Context Mode composer: nested output is compact single sentence", () => {
+  const out = composeContextModeInstructions("gate-evaluate", { enabled: true, renderMode: "nested" });
+  assert.ok(!out.startsWith("## Context Mode"));
+  assert.match(out, /^Context Mode \(verification lane\): /);
+  assert.strictEqual(out.split(/\n/).length, 1);
+  assert.match(out, /`gsd_exec`/);
+  assert.match(out, /`gsd_exec_search`/);
+  assert.match(out, /`gsd_resume`/);
+  assert.ok(out.length < 180, `nested guidance should stay compact, got ${out.length} chars`);
+});
+
 // ─── Integration: migrated buildReassessRoadmapPrompt ─────────────────────
 
 function makeFixtureBase(): string {
@@ -186,7 +224,7 @@ test("#4782 phase 2: buildReassessRoadmapPrompt emits composer-shaped context wi
 
 const fakeBase: BaseResolverContext = {
   unitType: "reassess-roadmap",
-  basePath: "/tmp/fake",
+  basePath: process.env.GSD_TEST_WORKSPACE_ROOT ?? process.cwd(),
   milestoneId: "M001",
   sliceId: "S01",
 };

package/src/resources/extensions/gsd/tests/unit-context-manifest.test.ts

@@ -12,6 +12,7 @@ import {
   UNIT_MANIFESTS,
   resolveManifest,
   type ArtifactKey,
+  type ContextModePolicy,
   type SkillsPolicy,
   type UnitContextManifest,
 } from "../unit-context-manifest.ts";
@@ -105,6 +106,37 @@ test("#4782 phase 1: every manifest has a positive maxSystemPromptChars", () =>
   }
 });
 
+test("Context Mode: every manifest declares the expected contextMode lane", () => {
+  const expected: Record<string, ContextModePolicy> = {
+    "workflow-preferences": "none",
+    "research-decision": "none",
+    "discuss-project": "interview",
+    "discuss-requirements": "interview",
+    "discuss-milestone": "interview",
+    "research-project": "research",
+    "research-milestone": "research",
+    "research-slice": "research",
+    "plan-milestone": "planning",
+    "plan-slice": "planning",
+    "refine-slice": "planning",
+    "replan-slice": "planning",
+    "reassess-roadmap": "planning",
+    "execute-task": "execution",
+    "reactive-execute": "execution",
+    "run-uat": "verification",
+    "gate-evaluate": "verification",
+    "validate-milestone": "verification",
+    "complete-slice": "verification",
+    "complete-milestone": "verification",
+    "rewrite-docs": "docs",
+  };
+
+  assert.deepEqual(Object.keys(expected).sort(), [...KNOWN_UNIT_TYPES].sort());
+  for (const unitType of KNOWN_UNIT_TYPES) {
+    assert.strictEqual(UNIT_MANIFESTS[unitType].contextMode, expected[unitType]);
+  }
+});
+
 test("#4782 phase 1: skills policy shapes are valid discriminated-union members", () => {
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const p = manifest.skills as SkillsPolicy;