gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.58d3d4d6c

package/src/resources/extensions/gsd/tests/google-search-stub.test.ts

@@ -0,0 +1,131 @@
+// GSD-2 — Tests for google-search deprecation stub (STUB-01, STUB-02)
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+test("google-search stub: default export is a function", async (_t) => {
+  // STUB-01: stub has a default export function accepting ExtensionAPI
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+  assert.equal(typeof stubFn, "function");
+});
+
+test("google-search stub: registers session_start handler", async (_t) => {
+  // STUB-01: stub calls pi.on("session_start", ...)
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let capturedEvent: string | undefined;
+  let capturedHandler: unknown;
+
+  const mockPi = {
+    on(event: string, handler: unknown) {
+      capturedEvent = event;
+      capturedHandler = handler;
+    },
+    registerTool: () => {},
+  };
+
+  stubFn(mockPi as never);
+
+  assert.equal(capturedEvent, "session_start");
+  assert.equal(typeof capturedHandler, "function");
+});
+
+test("google-search stub: does NOT call registerTool", async (_t) => {
+  // STUB-02: stub is a no-op for tools
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let registerToolCalled = false;
+
+  const mockPi = {
+    on: (_event: string, _handler: unknown) => {},
+    registerTool: () => { registerToolCalled = true; },
+  };
+
+  stubFn(mockPi as never);
+
+  assert.equal(registerToolCalled, false);
+});
+
+test("google-search stub: session_start warning contains package name", async (_t) => {
+  // STUB-01: warning includes @gsd-extensions/google-search
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let capturedHandler: ((event: unknown, ctx: unknown) => Promise<void>) | undefined;
+
+  const mockPi = {
+    on(_event: string, handler: (event: unknown, ctx: unknown) => Promise<void>) {
+      capturedHandler = handler;
+    },
+    registerTool: () => {},
+  };
+
+  stubFn(mockPi as never);
+
+  assert.ok(capturedHandler, "session_start handler should have been registered");
+
+  let capturedMessage: string | undefined;
+  const mockCtx = {
+    ui: {
+      notify(message: string, _level: string) {
+        capturedMessage = message;
+      },
+    },
+  };
+
+  await capturedHandler!({}, mockCtx);
+
+  assert.ok(
+    capturedMessage?.includes("@gsd-extensions/google-search"),
+    `Expected message to include "@gsd-extensions/google-search", got: "${capturedMessage}"`,
+  );
+});
+
+test("google-search stub: session_start warning explains package is not yet published", async (_t) => {
+  // STUB-01: stub must NOT advise `gsd extensions install` — the replacement
+  // package is not yet on npm, so that command would 404. The message must
+  // explain the extraction is in progress and no user action is required.
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let capturedHandler: ((event: unknown, ctx: unknown) => Promise<void>) | undefined;
+
+  const mockPi = {
+    on(_event: string, handler: (event: unknown, ctx: unknown) => Promise<void>) {
+      capturedHandler = handler;
+    },
+    registerTool: () => {},
+  };
+
+  stubFn(mockPi as never);
+
+  assert.ok(capturedHandler, "session_start handler should have been registered");
+
+  let capturedMessage: string | undefined;
+  const mockCtx = {
+    ui: {
+      notify(message: string, _level: string) {
+        capturedMessage = message;
+      },
+    },
+  };
+
+  await capturedHandler!({}, mockCtx);
+
+  assert.ok(
+    !capturedMessage?.includes("gsd extensions install"),
+    `Expected message NOT to include unpublished install command, got: "${capturedMessage}"`,
+  );
+  assert.ok(
+    capturedMessage?.includes("not yet published"),
+    `Expected message to include "not yet published", got: "${capturedMessage}"`,
+  );
+  assert.ok(
+    capturedMessage?.includes("No action needed"),
+    `Expected message to include "No action needed", got: "${capturedMessage}"`,
+  );
+});

package/src/resources/extensions/gsd/tests/headless-milestone-parity.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Regression tests for the headless vs interactive milestone-bootstrap divergence.
+ *
+ * Two defects were covered here:
+ *   1. `showHeadlessMilestoneCreation` dispatched with `unitType: "plan-milestone"`
+ *      instead of `"discuss-milestone"`. The `discuss-` prefix drives tool
+ *      scoping (`guided-flow.ts:583`) and enables the `checkAutoStartAfterDiscuss`
+ *      guardrails — routing through `plan-milestone` bypassed them even
+ *      though headless is semantically a discuss flow.
+ *   2. The `discuss-headless.md` ready-phrase pre-condition was a prose
+ *      sentence, so models that treated it as advisory could skip ahead to
+ *      the ready phrase without actually writing the artifacts. The checkbox
+ *      format from `discuss.md` has lower abstraction cost and is harder to
+ *      rationalize past.
+ */
+
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const GUIDED_FLOW_PATH = join(__dirname, "..", "guided-flow.ts");
+const DISCUSS_HEADLESS_PATH = join(__dirname, "..", "prompts", "discuss-headless.md");
+
+function getGuidedFlowSource(): string {
+  return readFileSync(GUIDED_FLOW_PATH, "utf-8");
+}
+
+function getHeadlessPromptSource(): string {
+  return readFileSync(DISCUSS_HEADLESS_PATH, "utf-8");
+}
+
+describe("headless milestone bootstrap — parity with interactive flow", () => {
+  test("showHeadlessMilestoneCreation dispatches as discuss-milestone, not plan-milestone", () => {
+    const source = getGuidedFlowSource();
+    const fnStart = source.indexOf("export async function showHeadlessMilestoneCreation");
+    assert.ok(fnStart > -1, "showHeadlessMilestoneCreation must exist");
+
+    // Scope: from the function start to the next top-level export (or EOF).
+    const nextExport = source.indexOf("\nexport ", fnStart + 1);
+    const fnBody = source.slice(fnStart, nextExport === -1 ? source.length : nextExport);
+
+    // Match only the actual dispatchWorkflow call — comments in the body
+    // may mention "plan-milestone" as part of the fix rationale.
+    const dispatchMatches = [...fnBody.matchAll(/dispatchWorkflow\([^)]*,\s*"([^"]+)"\s*\)/g)];
+    assert.strictEqual(
+      dispatchMatches.length,
+      1,
+      `expected exactly one dispatchWorkflow call, found ${dispatchMatches.length}`,
+    );
+    assert.strictEqual(
+      dispatchMatches[0][1],
+      "discuss-milestone",
+      `showHeadlessMilestoneCreation must dispatch as "discuss-milestone" so tool scoping and discuss-flow guardrails apply; got "${dispatchMatches[0][1]}"`,
+    );
+  });
+
+  test("discuss-headless single-milestone pre-condition uses the non-bypassable checkbox format", () => {
+    const source = getHeadlessPromptSource();
+    const section = source.split("### Multi-Milestone")[0];
+    assert.ok(
+      /### Ready-phrase pre-condition \(NON-BYPASSABLE\)/.test(section),
+      "single-milestone ready-phrase section must be present",
+    );
+    // All four required artifacts must appear as checkboxes, not a prose list.
+    for (const artifact of [
+      "`.gsd/PROJECT.md`",
+      "`.gsd/REQUIREMENTS.md`",
+      "`{{contextPath}}`",
+      "`gsd_plan_milestone`",
+    ]) {
+      assert.ok(
+        new RegExp(`- \\[ \\] [A-Za-z]+ ${artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(section),
+        `single-milestone pre-condition must include a checkbox for ${artifact}`,
+      );
+    }
+    assert.ok(
+      /If ANY box is unchecked, \*\*STOP\*\*/.test(section),
+      "single-milestone pre-condition must include the 'If ANY box is unchecked, STOP' sentinel",
+    );
+    assert.ok(
+      /Do not announce the ready phrase as something you are "about to" do/.test(section),
+      "single-milestone pre-condition must include the 'do not announce intent' guard",
+    );
+  });
+
+  test("discuss-headless multi-milestone pre-condition uses the non-bypassable checkbox format", () => {
+    const source = getHeadlessPromptSource();
+    const multiIdx = source.indexOf("### Multi-Milestone");
+    assert.ok(multiIdx > -1, "multi-milestone section must be present");
+    const multiSection = source.slice(multiIdx);
+
+    assert.ok(
+      /### Ready-phrase pre-condition \(NON-BYPASSABLE\)/.test(multiSection),
+      "multi-milestone ready-phrase section must be present",
+    );
+    for (const artifact of [
+      "`.gsd/PROJECT.md`",
+      "`.gsd/REQUIREMENTS.md`",
+      "`gsd_plan_milestone`",
+      "`.gsd/DISCUSSION-MANIFEST.json`",
+    ]) {
+      const escaped = artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      assert.ok(
+        new RegExp(`- \\[ \\] [\\s\\S]*?${escaped}`).test(multiSection),
+        `multi-milestone pre-condition must include a checkbox referencing ${artifact}`,
+      );
+    }
+    assert.ok(
+      /gates_completed === total/.test(multiSection),
+      "multi-milestone pre-condition must still enforce gates_completed === total",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/idle-watchdog-stall-override.test.ts

@@ -18,6 +18,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { test, describe } from "node:test";
 import assert from "node:assert/strict";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const TIMERS_SRC = readFileSync(
   join(import.meta.dirname, "..", "auto-timers.ts"),
@@ -97,7 +98,11 @@ describe("#2527 Bug 2: null guard after async recovery prevents crash", () => {
 
     // The null guard must appear between the recovery call and the next
     // writeUnitRuntimeRecord that accesses s.currentUnit.startedAt
-    const afterRecovery = TIMERS_SRC.slice(idleRecovery, idleRecovery + 400);
+    const afterRecovery = extractSourceRegion(
+      TIMERS_SRC,
+      'recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle"',
+      { fromIdx: idleRecovery },
+    );
     assert.ok(
       afterRecovery.includes("if (!s.currentUnit) return"),
       "null guard for s.currentUnit must exist after idle recoverTimedOutUnit",

package/src/resources/extensions/gsd/tests/import-done-milestones.test.ts

@@ -10,6 +10,7 @@ import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -30,7 +31,7 @@ describe('import done milestones as complete (#3699)', () => {
     // Find the all-done guard and verify it sets 'complete'
     const everyIdx = importerSrc.indexOf('roadmap.slices.every(s => s.done)');
     assert.ok(everyIdx > -1, 'all-slices-done check should exist');
-    const afterCheck = importerSrc.slice(everyIdx, everyIdx + 200);
+    const afterCheck = extractSourceRegion(importerSrc, 'roadmap.slices.every(s => s.done)');
     assert.match(afterCheck, /milestoneStatus\s*=\s*'complete'/,
       'should set milestoneStatus to complete when all slices are done');
   });

package/src/resources/extensions/gsd/tests/integration/all-milestones-complete-merge.test.ts

@@ -12,6 +12,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { extractSourceRegion } from "../test-helpers.ts";
 import {
   mkdtempSync,
   mkdirSync,
@@ -115,7 +116,7 @@ test("auto-loop 'all milestones complete' path merges before stopping (#962)", (
     helperIdx > -1,
     "WorktreeResolver.mergeAndExit helper should exist",
   );
-  const helperBlock = resolverSrc.slice(helperIdx, helperIdx + 2600);
+  const helperBlock = extractSourceRegion(resolverSrc, "mergeAndExit(milestoneId");
   assert.ok(
     helperBlock.includes('mode === "worktree"') ||
       helperBlock.includes('mode: "worktree"'),

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -854,4 +854,34 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       "#1906: codeFilesChanged must be true when real code files were merged");
     assert.ok(existsSync(join(repo, "real-code.ts")), "real-code.ts merged to main");
   });
+
+  // #2505 regression: when a per-entry restore of the milestone shelter fails,
+  // the shelter must be retained so the queued milestone files (whose sources
+  // were deleted during the shelter step) remain recoverable. Deleting the
+  // shelter unconditionally would permanently lose that data.
+  test("#2505: shelter retained when restore fails; cleaned up on success", () => {
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M200");
+
+    addSliceToMilestone(repo, wtPath, "M200", "S01", "Feature", [
+      { file: "feature.ts", content: "export const f = 1;\n", message: "add feature" },
+    ]);
+
+    // Seed a queued (non-target) milestone in .gsd/milestones/ that will be
+    // sheltered during the merge and restored afterwards.
+    const queuedDir = join(repo, ".gsd", "milestones", "M201");
+    mkdirSync(queuedDir, { recursive: true });
+    writeFileSync(join(queuedDir, "CONTEXT.md"), "# queued\n");
+
+    const roadmap = makeRoadmap("M200", "Milestone w/ queued sibling", [
+      { id: "S01", title: "Feature" },
+    ]);
+
+    const result = mergeMilestoneToMain(repo, "M200", roadmap);
+
+    // Normal success path: queued milestone restored, shelter cleaned up.
+    assert.ok(existsSync(join(queuedDir, "CONTEXT.md")), "queued milestone restored from shelter");
+    assert.ok(!existsSync(join(repo, ".gsd", ".milestone-shelter")), "shelter removed on successful restore");
+    assert.ok(result.commitMessage.length > 0, "merge completed");
+  });
 });

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -248,12 +248,13 @@ describe('git-service', async () => {
 
   assert.deepStrictEqual(
     RUNTIME_EXCLUSION_PATHS.length,
-    15,
-    "exactly 15 runtime exclusion paths"
+    16,
+    "exactly 16 runtime exclusion paths"
   );
 
   const expectedPaths = [
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",

package/src/resources/extensions/gsd/tests/interactive-routing-bypass.test.ts

@@ -8,6 +8,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -62,7 +63,7 @@ describe("interactive routing bypass (#3962)", () => {
     );
     // The function should check isAutoMode before routing synthesis
     const fnIdx = modelSelectionSrc.indexOf("function resolvePreferredModelConfig");
-    const fnBody = modelSelectionSrc.slice(fnIdx, fnIdx + 900);
+    const fnBody = extractSourceRegion(modelSelectionSrc, "function resolvePreferredModelConfig");
     assert.ok(
       fnBody.includes("isAutoMode"),
       "resolvePreferredModelConfig should accept isAutoMode parameter",
@@ -137,8 +138,13 @@ describe("model downgrade notifications always visible (#3962)", () => {
     const escalatedIdx = modelSelectionSrc.indexOf("if (escalated)");
     assert.ok(escalatedIdx > 0, "escalation block should exist");
 
-    // Get the block from "if (escalated)" to the next closing brace pattern
-    const block = modelSelectionSrc.slice(escalatedIdx, escalatedIdx + 400);
+    // Get the block from "if (escalated)" to the next distinctive marker
+    // (the capability-override loading that immediately follows).
+    const block = extractSourceRegion(
+      modelSelectionSrc,
+      "if (escalated)",
+      "// Load user capability overrides",
+    );
     assert.ok(
       block.includes("Tier escalation:"),
       "escalation block should contain the notification",

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -21,6 +21,13 @@ import type { IterationContext, LoopState, PreDispatchData, IterationData } from
 import type { SessionLockStatus } from "../session-lock.js";
 import { runDispatch, runUnitPhase, runPreDispatch, runFinalize } from "../auto/phases.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -644,6 +651,63 @@ test("terminal event is emitted on blocked state", async () => {
   assert.deepEqual((terminalEvents[0].data as any).blockers, ["Missing API key"]);
 });
 
+test("#4671: plan-v2 missing CONTEXT.md reaches dispatch recovery instead of pausing", async () => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-4671-predispatch-"));
+  mkdirSync(join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  openDatabase(join(basePath, ".gsd", "gsd.db"));
+  try {
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice 1",
+      status: "in_progress",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      milestoneId: "M001",
+      sliceId: "S01",
+      title: "Task 1",
+      status: "pending",
+      keyFiles: ["src/task.ts"],
+      sequence: 1,
+    });
+
+    let pauseCalls = 0;
+    const capture = createEventCapture();
+    const deps = makeMockDeps(capture, {
+      pauseAuto: async () => { pauseCalls++; },
+      deriveState: async () => ({
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Test", status: "active" },
+        activeSlice: { id: "S01", title: "Slice 1" },
+        activeTask: { id: "T01", title: "Task 1" },
+        registry: [{ id: "M001", status: "active" }],
+        blockers: [],
+        recentDecisions: [],
+        nextAction: "dispatch",
+      }) as any,
+    });
+    const ic = makeIC(deps, {
+      prefs: { uok: { plan_v2: { enabled: true } } } as any,
+    });
+    ic.s.basePath = basePath;
+
+    const result = await runPreDispatch(ic, {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    });
+
+    assert.equal(result.action, "next");
+    assert.equal(pauseCalls, 0, "missing CONTEXT.md should be handled by dispatch recovery, not plan gate pause");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
 test("milestone-transition event is emitted when milestone changes", async () => {
   const capture = createEventCapture();
   const deps = makeMockDeps(capture, {

package/src/resources/extensions/gsd/tests/knowledge.test.ts

@@ -15,7 +15,7 @@ import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, realpathSy
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { GSD_ROOT_FILES, resolveGsdRootFile } from '../paths.ts';
-import { inlineGsdRootFile } from '../auto-prompts.ts';
+import { inlineGsdRootFile, inlineKnowledgeBudgeted } from '../auto-prompts.ts';
 import { appendKnowledge } from '../files.ts';
 import { loadKnowledgeBlock } from '../bootstrap/system-context.ts';
 
@@ -248,3 +248,95 @@ test('loadKnowledgeBlock: reports globalSizeKb above 4KB threshold', () => {
 
   rmSync(tmp, { recursive: true, force: true });
 });
+
+// ─── inlineKnowledgeBudgeted — issue #4719 ─────────────────────────────────
+// Milestone-phase prompts must not inject the full KNOWLEDGE.md. The budgeted
+// helper scopes by milestone-level keywords and caps the injected size.
+
+test('inlineKnowledgeBudgeted: returns scoped H3 entries for single-H2 file', async () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  const content = `# Project Knowledge
+
+## Patterns
+
+### Database: prepared statements
+Always use prepared statements with SQLite.
+
+### API: versioned paths
+Use /v1/resource style versioning.
+
+### Testing: node:test
+Prefer node:test over external frameworks.
+`;
+  writeFileSync(join(gsdDir, 'KNOWLEDGE.md'), content);
+
+  const result = await inlineKnowledgeBudgeted(tmp, ['database']);
+  assert.ok(result !== null, 'should return content');
+  assert.ok(result!.includes('Database: prepared statements'), 'includes matching H3');
+  assert.ok(!result!.includes('API: versioned paths'), 'excludes non-matching H3');
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+test('inlineKnowledgeBudgeted: caps payload below budget for large files', async () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Build a 200KB KNOWLEDGE with 500 H3 entries all matching 'shared'
+  const entries = Array.from({ length: 500 }, (_, i) =>
+    `### Entry ${i}: shared topic\n${'filler text '.repeat(30)}\n`,
+  ).join('\n');
+  const content = `# Project Knowledge\n\n## Patterns\n\n${entries}`;
+  writeFileSync(join(gsdDir, 'KNOWLEDGE.md'), content);
+
+  const BUDGET_CHARS = 30_000;
+  const result = await inlineKnowledgeBudgeted(tmp, ['shared'], { maxChars: BUDGET_CHARS });
+  assert.ok(result !== null, 'should return content');
+  // Allow some overhead for header formatting, but must stay close to budget
+  assert.ok(
+    result!.length <= BUDGET_CHARS + 500,
+    `payload ${result!.length} chars should be <= budget ${BUDGET_CHARS} (+overhead)`,
+  );
+  // Far smaller than the raw file
+  assert.ok(
+    result!.length < content.length / 4,
+    `payload should be much smaller than full content (${content.length} chars)`,
+  );
+  assert.match(
+    result!,
+    /\[\.\.\.truncated \d+ chars; rerun with narrower scope if needed\]/,
+    'should include truncation note when budget is exceeded',
+  );
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+test('inlineKnowledgeBudgeted: returns null when no KNOWLEDGE.md exists', async () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  const result = await inlineKnowledgeBudgeted(tmp, ['database']);
+  assert.strictEqual(result, null);
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+test('inlineKnowledgeBudgeted: returns null when no entries match', async () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+  writeFileSync(
+    join(gsdDir, 'KNOWLEDGE.md'),
+    '# Project Knowledge\n\n## Patterns\n\n### Database\nuse it\n',
+  );
+
+  const result = await inlineKnowledgeBudgeted(tmp, ['nonexistent']);
+  assert.strictEqual(result, null);
+
+  rmSync(tmp, { recursive: true, force: true });
+});

package/src/resources/extensions/gsd/tests/mcp-client-security.test.ts

@@ -0,0 +1,76 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+
+import {
+  _buildMcpChildEnvForTest,
+  _buildMcpTrustConfirmOptionsForTest,
+} from "../../mcp-client/index.ts";
+
+test("MCP stdio child env only includes safe inherited keys plus explicit config env", () => {
+  const previousSecret = process.env.SECRET_MCP_TEST_TOKEN;
+  const previousPath = process.env.PATH;
+  try {
+    process.env.SECRET_MCP_TEST_TOKEN = "should-not-leak";
+    process.env.PATH = "/usr/bin";
+
+    const env = _buildMcpChildEnvForTest({
+      EXPLICIT_TOKEN: "${SECRET_MCP_TEST_TOKEN}",
+      PLAIN_VALUE: "ok",
+    });
+
+    assert.equal(env.PATH, "/usr/bin");
+    assert.equal(env.SECRET_MCP_TEST_TOKEN, undefined);
+    assert.equal(env.EXPLICIT_TOKEN, "should-not-leak");
+    assert.equal(env.PLAIN_VALUE, "ok");
+  } finally {
+    if (previousSecret === undefined) delete process.env.SECRET_MCP_TEST_TOKEN;
+    else process.env.SECRET_MCP_TEST_TOKEN = previousSecret;
+    if (previousPath === undefined) delete process.env.PATH;
+    else process.env.PATH = previousPath;
+  }
+});
+
+test("MCP stdio trust confirmation is abort-aware", () => {
+  const controller = new AbortController();
+  const options = _buildMcpTrustConfirmOptionsForTest(controller.signal);
+
+  assert.equal(options.timeout, 120_000);
+  assert.equal(options.signal, controller.signal);
+});
+
+test("MCP client uses a single in-flight connection per canonical server", () => {
+  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
+
+  assert.match(source, /const pendingConnections = new Map<string, Promise<Client>>\(\)/);
+  assert.match(source, /const pending = pendingConnections\.get\(config\.name\)/);
+  assert.match(source, /pendingConnections\.set\(config\.name, connectionPromise\)/);
+  assert.match(source, /pendingConnections\.delete\(config\.name\)/);
+  assert.match(source, /env: config\.env \?\? \{\}/);
+});
+
+test("MCP stdio trust is persisted only after a successful connection", () => {
+  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
+  const connectIndex = source.indexOf("await client.connect(transport");
+  const trustIndex = source.indexOf("trustedStdioServers.add(approvedTrustKey)");
+
+  assert.ok(connectIndex > -1, "connectServer should await client.connect");
+  assert.ok(trustIndex > connectIndex, "trust should be recorded after client.connect succeeds");
+  assert.doesNotMatch(source, /assertTrustedStdioServer[\s\S]*trustedStdioServers\.add\(trustKey\)/);
+});
+
+test("MCP client closes transports after failed connection attempts", () => {
+  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
+
+  assert.match(source, /catch \(err\) \{[\s\S]*await transport\.close\(\)/);
+  assert.match(source, /catch \(err\) \{[\s\S]*await client\.close\(\)/);
+  assert.match(source, /catch \(err\) \{[\s\S]*throw err/);
+});
+
+test("MCP client clears process-local trust and closes transports on session cleanup", () => {
+  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
+
+  assert.match(source, /async function closeAll\(\)[\s\S]*await conn\.transport\.close\(\)/);
+  assert.match(source, /async function closeAll\(\)[\s\S]*pendingConnections\.clear\(\)/);
+  assert.match(source, /async function closeAll\(\)[\s\S]*trustedStdioServers\.clear\(\)/);
+});