npm - gsd-pi - Versions diffs - 2.79.0 → 2.80.0-dev.0aaa4fc17 - Mend

gsd-pi 2.79.0 → 2.80.0-dev.0aaa4fc17

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (866) hide show

package/src/resources/extensions/gsd/tests/right-sized-workflow-prompts.test.ts ADDED Viewed

@@ -0,0 +1,192 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { buildCompleteMilestonePrompt, buildPlanMilestonePrompt } from "../auto-prompts.ts";
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: { ...process.env, GIT_AUTHOR_NAME: "Test User", GIT_AUTHOR_EMAIL: "test@example.com", GIT_COMMITTER_NAME: "Test User", GIT_COMMITTER_EMAIL: "test@example.com" },
+  }).trim();
+}
+function makeRepo(files: Record<string, string>): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-right-size-"));
+  git(base, ["init", "-b", "main"]);
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# Context\n\nTest milestone.");
+  for (const [path, content] of Object.entries(files)) {
+    const abs = join(base, path);
+    mkdirSync(join(abs, ".."), { recursive: true });
+    writeFileSync(abs, content);
+  }
+  git(base, ["add", "."]);
+  git(base, ["commit", "-m", "init"]);
+  return base;
+}
+function writeCompleteMilestoneFiles(base: string, validation: string): void {
+  const dir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(join(dir, "slices", "S01"), { recursive: true });
+  writeFileSync(join(dir, "M001-ROADMAP.md"), "# M001\n\n## Slices\n- [x] **S01: One** `risk:low` `depends:[]`\n  > Done\n");
+  writeFileSync(join(dir, "M001-VALIDATION.md"), validation);
+  writeFileSync(join(dir, "slices", "S01", "S01-SUMMARY.md"), "# S01 Summary\n\n**Verification:** passed\n");
+}
+function validationMetadata(): string {
+  return [
+    "validation_metadata:",
+    "  covered_artifacts:",
+    "    - `.gsd/milestones/M001/M001-VALIDATION.md`",
+    "    - `.gsd/milestones/M001/M001-ROADMAP.md`",
+    "    - `.gsd/milestones/M001/slices/S01/S01-SUMMARY.md`",
+  ].join("\n");
+}
+test("plan-milestone prompt includes tiny untyped project classification and one-slice guidance", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    const prompt = await buildPlanMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /\*\*Kind:\*\* untyped-existing/);
+    assert.match(prompt, /\*\*Content files:\*\* 1/);
+    assert.match(prompt, /`index\.html`/);
+    assert.match(prompt, /Prefer exactly one slice/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+test("plan-milestone prompt includes small untyped project 1-2 slice guidance", async () => {
+  const base = makeRepo({
+    "index.html": "html",
+    "README.md": "readme",
+    "styles.css": "body {}",
+  });
+  try {
+    const prompt = await buildPlanMilestonePrompt("M001", "Polish static files", base, "minimal");
+    assert.match(prompt, /\*\*Kind:\*\* untyped-existing/);
+    assert.match(prompt, /\*\*Content files:\*\* 3/);
+    assert.match(prompt, /Prefer 1-2 slices/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+test("plan-milestone prompt keeps normal guidance for typed projects", async () => {
+  const base = makeRepo({
+    "package.json": "{\"scripts\":{\"test\":\"node --test\"}}\n",
+    "src/index.js": "console.log('ok');\n",
+  });
+  try {
+    const prompt = await buildPlanMilestonePrompt("M001", "Update app", base, "minimal");
+    assert.match(prompt, /\*\*Kind:\*\* typed-existing/);
+    assert.match(prompt, /Use normal ecosystem-aware planning guidance/);
+    assert.doesNotMatch(prompt, /Prefer exactly one slice/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+test("workflow docs no longer contain blanket 4-10 slice guidance", () => {
+  const docs = readFileSync(join(process.cwd(), "src", "resources", "GSD-WORKFLOW.md"), "utf-8");
+  assert.doesNotMatch(docs, /4-10 slices/);
+  assert.match(docs, /1-10 slices/);
+  assert.match(docs, /single-file/);
+});
+test("prompt templates carry right-sized planning and closeout mode guidance", () => {
+  const planTemplate = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "prompts", "plan-milestone.md"), "utf-8");
+  const completeTemplate = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "prompts", "complete-milestone.md"), "utf-8");
+  assert.match(planTemplate, /Use 1-10 slices, sized to the work/);
+  assert.match(planTemplate, /tiny\/single-file\/static work should usually be one slice/);
+  assert.match(planTemplate, /untyped-existing/);
+  assert.match(completeTemplate, /Closeout Review Mode/);
+  assert.match(completeTemplate, /passing validation artifact is present/);
+  assert.doesNotMatch(completeTemplate, /^### Delegate Review Work/m);
+});
+test("complete-milestone prompt trusts passing validation artifact", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, `---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\n${validationMetadata()}\n\nAll checks passed.`);
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Passing Validation Artifact/);
+    assert.match(prompt, /Treat it as authoritative/);
+    assert.match(prompt, /Do not delegate fresh reviewer\/security\/tester audits/);
+    assert.match(prompt, /All checks passed/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+test("complete-milestone prompt trusts centralized markdown body pass verdict", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, `# Validation\n\n**Verdict:** PASS\n\n${validationMetadata()}\n\nAll checks passed.`);
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Passing Validation Artifact/);
+    assert.match(prompt, /Treat it as authoritative/);
+    assert.match(prompt, /Do not delegate fresh reviewer\/security\/tester audits/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+test("complete-milestone prompt does not trust stale pass validation without metadata", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nAll checks passed.");
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Validation Requires Attention/);
+    assert.match(prompt, /missing freshness metadata/);
+    assert.doesNotMatch(prompt, /Passing Validation Artifact/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+test("complete-milestone prompt does not trust pass validation missing current summary coverage", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, [
+      "---",
+      "verdict: pass",
+      "remediation_round: 0",
+      "---",
+      "",
+      "# Validation",
+      "validation_metadata:",
+      "  covered_artifacts:",
+      "    - `.gsd/milestones/M001/M001-VALIDATION.md`",
+      "    - `.gsd/milestones/M001/M001-ROADMAP.md`",
+      "",
+      "All checks passed.",
+    ].join("\n"));
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Validation Requires Attention/);
+    assert.match(prompt, /does not cover current milestone artifacts/);
+    assert.doesNotMatch(prompt, /Passing Validation Artifact/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+test("complete-milestone prompt keeps deeper review path without passing validation", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nFix gaps.");
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Validation Requires Attention/);
+    assert.match(prompt, /verdict `needs-attention`/);
+    assert.match(prompt, /Use `subagent` for review work needing fresh context/i);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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

@@ -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/safety-harness-false-positives.test.ts CHANGED Viewed

@@ -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/smart-entry-complete.test.ts CHANGED Viewed

@@ -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).");

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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;

package/src/resources/extensions/gsd/tests/unit-runtime.test.ts CHANGED Viewed

@@ -5,6 +5,7 @@ import {
   clearUnitRuntimeRecord,
   formatExecuteTaskRecoveryStatus,
   inspectExecuteTaskDurability,
+  isInFlightRuntimePhase,
   readUnitRuntimeRecord,
   writeUnitRuntimeRecord,
 } from "../unit-runtime.ts";
@@ -22,6 +23,12 @@ writeFileSync(
   "utf-8",
 );
+console.log("\n=== in-flight runtime phases ===");
+{
+  assert.equal(isInFlightRuntimePhase("crashed"), true, "crashed records remain recoverable");
+  assert.equal(isInFlightRuntimePhase("finalized"), false, "finalized records are terminal");
+}
 console.log("\n=== runtime record write/read/update ===");
 {
   const first = writeUnitRuntimeRecord(base, "execute-task", "M100/S02/T09", 1000, { phase: "dispatched" });