gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

package/src/resources/extensions/gsd/tests/issue-4540-regressions.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Regression tests for issue #4540:
+ *   Bug 1 — Invalid quality_gates migration bricks gsd.db
+ *   Bug 2 — Artifact retries emit no journal event, look like stuck loops
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createRequire } from "node:module";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertGateRow,
+  getPendingGates,
+  _getAdapter,
+} from "../gsd-db.ts";
+
+import { emitJournalEvent, queryJournal } from "../journal.ts";
+
+const _require = createRequire(import.meta.url);
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function tmpDb(): { dir: string; dbPath: string } {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-4540-"));
+  return { dir, dbPath: join(dir, "gsd.db") };
+}
+
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+/**
+ * Builds a v12 database with the broken quality_gates DDL:
+ * task_id is nullable and there is no proper multi-column PK.
+ * This simulates a DB that was created before the v12 fix was applied.
+ */
+function createBrokenV12Db(dbPath: string): void {
+  const sqlite = _require("node:sqlite");
+  const db = new sqlite.DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode=WAL");
+
+  db.exec(`CREATE TABLE schema_version (version INTEGER NOT NULL, applied_at TEXT NOT NULL)`);
+  db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(12, "2025-01-01T00:00:00.000Z");
+
+  db.exec(`
+    CREATE TABLE decisions (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE,
+      when_context TEXT NOT NULL DEFAULT '', scope TEXT NOT NULL DEFAULT '',
+      decision TEXT NOT NULL DEFAULT '', choice TEXT NOT NULL DEFAULT '',
+      rationale TEXT NOT NULL DEFAULT '', revisable TEXT NOT NULL DEFAULT '',
+      made_by TEXT NOT NULL DEFAULT 'agent', superseded_by TEXT DEFAULT NULL
+    );
+    CREATE VIEW active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL;
+    CREATE TABLE requirements (
+      id TEXT PRIMARY KEY, class TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT '',
+      description TEXT NOT NULL DEFAULT '', why TEXT NOT NULL DEFAULT '',
+      source TEXT NOT NULL DEFAULT '', primary_owner TEXT NOT NULL DEFAULT '',
+      supporting_slices TEXT NOT NULL DEFAULT '', validation TEXT NOT NULL DEFAULT '',
+      notes TEXT NOT NULL DEFAULT '', full_content TEXT NOT NULL DEFAULT '',
+      superseded_by TEXT DEFAULT NULL
+    );
+    CREATE TABLE artifacts (
+      path TEXT PRIMARY KEY, artifact_type TEXT NOT NULL DEFAULT '',
+      milestone_id TEXT DEFAULT NULL, slice_id TEXT DEFAULT NULL, task_id TEXT DEFAULT NULL,
+      full_content TEXT NOT NULL DEFAULT '', imported_at TEXT NOT NULL DEFAULT ''
+    );
+    CREATE TABLE memories (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE,
+      category TEXT NOT NULL, content TEXT NOT NULL, confidence REAL NOT NULL DEFAULT 0.8,
+      source_unit_type TEXT, source_unit_id TEXT, created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL, superseded_by TEXT DEFAULT NULL,
+      hit_count INTEGER NOT NULL DEFAULT 0,
+      scope TEXT NOT NULL DEFAULT 'project', tags TEXT NOT NULL DEFAULT '[]',
+      structured_fields TEXT DEFAULT NULL
+    );
+    CREATE TABLE memory_sources (
+      id TEXT PRIMARY KEY, kind TEXT NOT NULL DEFAULT '', path TEXT DEFAULT NULL,
+      imported_at TEXT NOT NULL DEFAULT '',
+      scope TEXT NOT NULL DEFAULT 'project', tags TEXT NOT NULL DEFAULT '[]'
+    );
+    CREATE TABLE memory_relations (
+      from_id TEXT NOT NULL, to_id TEXT NOT NULL, relation TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (from_id, to_id)
+    );
+    CREATE TABLE memory_processed_units (
+      unit_key TEXT PRIMARY KEY, activity_file TEXT, processed_at TEXT NOT NULL
+    );
+    CREATE TABLE milestones (
+      id TEXT PRIMARY KEY, title TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT 'active',
+      depends_on TEXT NOT NULL DEFAULT '[]', created_at TEXT NOT NULL DEFAULT '',
+      completed_at TEXT DEFAULT NULL, vision TEXT NOT NULL DEFAULT '',
+      success_criteria TEXT NOT NULL DEFAULT '[]', key_risks TEXT NOT NULL DEFAULT '[]',
+      proof_strategy TEXT NOT NULL DEFAULT '[]', verification_contract TEXT NOT NULL DEFAULT '',
+      verification_integration TEXT NOT NULL DEFAULT '',
+      verification_operational TEXT NOT NULL DEFAULT '', verification_uat TEXT NOT NULL DEFAULT '',
+      definition_of_done TEXT NOT NULL DEFAULT '[]', requirement_coverage TEXT NOT NULL DEFAULT '',
+      boundary_map_markdown TEXT NOT NULL DEFAULT ''
+    );
+    CREATE TABLE slices (
+      milestone_id TEXT NOT NULL, id TEXT NOT NULL, title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'pending', risk TEXT NOT NULL DEFAULT 'medium',
+      depends TEXT NOT NULL DEFAULT '[]', demo TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT '', completed_at TEXT DEFAULT NULL,
+      full_summary_md TEXT NOT NULL DEFAULT '', full_uat_md TEXT NOT NULL DEFAULT '',
+      goal TEXT NOT NULL DEFAULT '', success_criteria TEXT NOT NULL DEFAULT '',
+      proof_level TEXT NOT NULL DEFAULT '', integration_closure TEXT NOT NULL DEFAULT '',
+      observability_impact TEXT NOT NULL DEFAULT '', sequence INTEGER DEFAULT 0,
+      replan_triggered_at TEXT DEFAULT NULL,
+      is_sketch INTEGER NOT NULL DEFAULT 0, sketch_scope TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (milestone_id, id), FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+    );
+    CREATE TABLE tasks (
+      milestone_id TEXT NOT NULL, slice_id TEXT NOT NULL, id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT 'pending',
+      one_liner TEXT NOT NULL DEFAULT '', narrative TEXT NOT NULL DEFAULT '',
+      verification_result TEXT NOT NULL DEFAULT '',
+      escalation_pending INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (milestone_id, slice_id, id),
+      FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+    );
+    CREATE TABLE assessments (
+      path TEXT PRIMARY KEY, milestone_id TEXT NOT NULL DEFAULT '',
+      slice_id TEXT DEFAULT NULL, task_id TEXT DEFAULT NULL,
+      status TEXT NOT NULL DEFAULT '', scope TEXT NOT NULL DEFAULT '',
+      full_content TEXT NOT NULL DEFAULT '', created_at TEXT NOT NULL DEFAULT '',
+      FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+    );
+    CREATE TABLE replan_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, milestone_id TEXT NOT NULL,
+      slice_id TEXT DEFAULT NULL, task_id TEXT DEFAULT NULL,
+      reason TEXT NOT NULL DEFAULT '', created_at TEXT NOT NULL DEFAULT ''
+    );
+    CREATE TABLE verification_evidence (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, milestone_id TEXT NOT NULL DEFAULT '',
+      slice_id TEXT NOT NULL DEFAULT '', task_id TEXT NOT NULL DEFAULT '',
+      unit_type TEXT NOT NULL DEFAULT '', unit_id TEXT NOT NULL DEFAULT '',
+      evidence_type TEXT NOT NULL DEFAULT '', content TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT '',
+      command TEXT NOT NULL DEFAULT '', verdict TEXT NOT NULL DEFAULT ''
+    );
+  `);
+
+  // Broken quality_gates: task_id nullable, no multi-column PK
+  db.exec(`
+    CREATE TABLE quality_gates (
+      milestone_id TEXT NOT NULL, slice_id TEXT NOT NULL, gate_id TEXT NOT NULL,
+      scope TEXT NOT NULL DEFAULT 'slice', task_id TEXT DEFAULT NULL,
+      status TEXT NOT NULL DEFAULT 'pending', verdict TEXT NOT NULL DEFAULT '',
+      rationale TEXT NOT NULL DEFAULT '', findings TEXT NOT NULL DEFAULT '',
+      evaluated_at TEXT DEFAULT NULL,
+      FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+    )
+  `);
+
+  // Parent rows + gate row with NULL task_id
+  db.prepare("INSERT INTO milestones (id, title, status) VALUES (?, ?, ?)").run("M001", "Milestone 1", "active");
+  db.prepare("INSERT INTO slices (milestone_id, id, title, status, risk, depends) VALUES (?, ?, ?, ?, ?, ?)").run("M001", "S01", "Slice 1", "pending", "medium", "[]");
+  db.prepare("INSERT INTO quality_gates (milestone_id, slice_id, gate_id, scope, task_id, status) VALUES (?, ?, ?, ?, ?, ?)").run("M001", "S01", "Q3", "slice", null, "pending");
+
+  db.close();
+}
+
+// ─── Bug 1 tests ─────────────────────────────────────────────────────────────
+
+describe("Bug 1 — quality_gates migration repair (#4540)", () => {
+  let dir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    ({ dir, dbPath } = tmpDb());
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    cleanup(dir);
+  });
+
+  test("fresh DB: quality_gates task_id is NOT NULL with empty-string default", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(quality_gates)").all() as Array<Record<string, unknown>>;
+    const col = cols.find((c) => c["name"] === "task_id");
+    assert.ok(col, "task_id column must exist");
+    assert.equal(col["notnull"], 1, "task_id must be NOT NULL");
+    assert.equal(col["dflt_value"], "''", "task_id default must be ''");
+  });
+
+  test("fresh DB: insertGateRow with no taskId stores '' and is idempotent", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    adapter.prepare("INSERT OR IGNORE INTO milestones (id, title, status) VALUES (?, ?, ?)").run("M001", "Test", "active");
+    adapter.prepare("INSERT OR IGNORE INTO slices (milestone_id, id, title, status, risk, depends) VALUES (?, ?, ?, ?, ?, ?)").run("M001", "S01", "Slice", "pending", "medium", "[]");
+
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    const rows = getPendingGates("M001", "S01");
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].task_id, "");
+  });
+
+  test("v22 repair: broken v12 DB opens without error", () => {
+    createBrokenV12Db(dbPath);
+    assert.doesNotThrow(() => openDatabase(dbPath));
+  });
+
+  test("v22 repair: task_id becomes NOT NULL after healing broken v12 DB", () => {
+    createBrokenV12Db(dbPath);
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(quality_gates)").all() as Array<Record<string, unknown>>;
+    const col = cols.find((c) => c["name"] === "task_id");
+    assert.ok(col, "task_id column must exist after repair");
+    assert.equal(col["notnull"], 1, "task_id must be NOT NULL after repair");
+  });
+
+  test("v22 repair: existing NULL task_id row is COALESCE'd to '' during repair", () => {
+    createBrokenV12Db(dbPath);
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      "SELECT task_id FROM quality_gates WHERE milestone_id = 'M001' AND slice_id = 'S01' AND gate_id = 'Q3'"
+    ).get() as Record<string, unknown> | undefined;
+    assert.ok(row, "original gate row must survive the repair migration");
+    assert.equal(row["task_id"], "", "NULL task_id must be repaired to ''");
+  });
+
+  test("v22 repair: scope column present on quality_gates after open", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(quality_gates)").all() as Array<Record<string, unknown>>;
+    assert.ok(cols.some((c) => c["name"] === "scope"), "quality_gates.scope must exist");
+  });
+
+  test("v22 repair: scope column present on assessments after open", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(assessments)").all() as Array<Record<string, unknown>>;
+    assert.ok(cols.some((c) => c["name"] === "scope"), "assessments.scope must exist");
+  });
+});
+
+// ─── Bug 2 tests ─────────────────────────────────────────────────────────────
+
+describe("Bug 2 — artifact-verification-retry journal event (#4540)", () => {
+  test("emitJournalEvent accepts artifact-verification-retry event type", () => {
+    const basePath = mkdtempSync(join(tmpdir(), "gsd-journal-4540-"));
+    try {
+      mkdirSync(join(basePath, ".gsd"), { recursive: true });
+      emitJournalEvent(basePath, {
+        ts: new Date().toISOString(),
+        flowId: "flow-4540",
+        seq: 1,
+        eventType: "artifact-verification-retry",
+        data: { unitType: "plan-slice", unitId: "M001/S01", attempt: 1 },
+      });
+      const entries = queryJournal(basePath, { flowId: "flow-4540" });
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].eventType, "artifact-verification-retry");
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("artifact-verification-retry event carries attempt count", () => {
+    const basePath = mkdtempSync(join(tmpdir(), "gsd-journal-4540b-"));
+    try {
+      mkdirSync(join(basePath, ".gsd"), { recursive: true });
+      emitJournalEvent(basePath, {
+        ts: new Date().toISOString(),
+        flowId: "flow-4540b",
+        seq: 1,
+        eventType: "artifact-verification-retry",
+        data: { unitType: "exec-slice", unitId: "M002/S02", attempt: 2 },
+      });
+      const entries = queryJournal(basePath, { flowId: "flow-4540b", eventType: "artifact-verification-retry" });
+      assert.equal(entries.length, 1);
+      const payload = entries[0].data as Record<string, unknown>;
+      assert.equal(payload["attempt"], 2);
+      assert.equal(payload["unitId"], "M002/S02");
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+});

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 ─────────────────────────────────────────────────────────────────
 
@@ -77,6 +84,8 @@ function makeMockDeps(
     autoWorktreeBranch: () => "auto/M001",
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
+    preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
+    postflightPopStash: () => {},
     getLedger: () => ({ units: [] }),
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,
@@ -642,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, {
@@ -837,3 +903,38 @@ test("runFinalize pauses and emits unit-end when pre-verification times out", as
   assert.equal((endEvents[0].data as any).artifactVerified, false);
   assert.equal((endEvents[0].data as any).finalizeStage, "pre");
 });
+
+test("transient session-failed cancellations pause instead of hard-stopping", async () => {
+  const capture = createEventCapture();
+  const { resolveAgentEndCancelled, _resetPendingResolve } = await import("../auto-loop.js");
+  _resetPendingResolve();
+
+  const deps = makeMockDeps(capture);
+  const ic = makeIC(deps);
+  const iterData: IterationData = {
+    unitType: "execute-task",
+    unitId: "M001/S01/T02",
+    prompt: "do more stuff",
+    finalPrompt: "do more stuff",
+    pauseAfterUatDispatch: false,
+    state: { phase: "executing", activeMilestone: { id: "M001" }, activeSlice: { id: "S01" }, registry: [], blockers: [] } as any,
+    mid: "M001",
+    midTitle: "Test",
+    isRetry: false,
+    previousTier: undefined,
+  };
+  const loopState: LoopState = { recentUnits: [{ key: "execute-task/M001/S01/T02" }], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
+
+  const unitPromise = runUnitPhase(ic, iterData, loopState);
+  await new Promise(r => setTimeout(r, 50));
+
+  resolveAgentEndCancelled({ message: "Session creation failed: temporary bootstrap overload", category: "session-failed", isTransient: true });
+
+  const result = await unitPromise;
+  assert.equal(result.action, "break");
+  assert.equal((result as any).reason, "session-timeout");
+
+  const entry = loopState.recentUnits[loopState.recentUnits.length - 1];
+  assert.ok(entry.error, "window entry must have error set");
+  assert.ok(entry.error!.startsWith("session-failed:"), "error must preserve the session-failed category");
+});

package/src/resources/extensions/gsd/tests/key-manager.test.ts

@@ -141,6 +141,15 @@ test("PROVIDER_REGISTRY includes all major LLM providers", () => {
   assert.ok(ids.includes("openai"));
   assert.ok(ids.includes("google"));
   assert.ok(ids.includes("groq"));
+  assert.ok(ids.includes("minimax"));
+  assert.ok(ids.includes("minimax-cn"));
+});
+
+test("PROVIDER_REGISTRY includes claude-code as a first-class LLM provider (#4541)", () => {
+  const entry = PROVIDER_REGISTRY.find((p) => p.id === "claude-code");
+  assert.ok(entry, "claude-code must be in PROVIDER_REGISTRY");
+  assert.equal(entry!.category, "llm");
+  assert.ok(entry!.hasOAuth, "claude-code uses OAuth (CLI auth)");
 });
 
 test("PROVIDER_REGISTRY includes all tool/search providers", () => {

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/load-memory-block.test.ts

@@ -0,0 +1,36 @@
+// GSD-2 — loadMemoryBlock tests (ADR-013 step 4 auto-injection parity)
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { closeDatabase, openDatabase } from '../gsd-db.ts';
+import { createMemory } from '../memory-store.ts';
+import { loadMemoryBlock } from '../bootstrap/system-context.ts';
+
+// ─── Success path: critical memories surface in the labeled block ──────────
+
+test('loadMemoryBlock: renders MEMORY block when critical memories exist', async () => {
+  openDatabase(':memory:');
+  try {
+    const id = createMemory({
+      category: 'architecture',
+      content: 'Use the memories table as the single source of truth for decisions.',
+      confidence: 0.95,
+    });
+    assert.ok(id, 'createMemory should seed a memory');
+
+    const block = await loadMemoryBlock('');
+    assert.ok(block.length > 0, 'block should be non-empty when critical memories exist');
+    assert.match(block, /\[MEMORY — Critical and prompt-relevant memories/);
+    assert.match(block, /memories table as the single source of truth/);
+  } finally {
+    closeDatabase();
+  }
+});
+
+// ─── Failure / degraded path: no DB → returns "" without throwing ───────────
+
+test('loadMemoryBlock: returns empty string when no DB is available', async () => {
+  closeDatabase();
+  const block = await loadMemoryBlock('anything');
+  assert.equal(block, '', 'no DB → empty block (graceful degradation)');
+});

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

@@ -0,0 +1,47 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  _buildMcpChildEnvForTest,
+  _buildMcpTrustConfirmOptionsForTest,
+} from "../../mcp-client/index.ts";
+
+// Note: four source-grep tests that scanned `mcp-client/index.ts` for
+// Map<> shapes, catch-block structure, and closeAll body were removed
+// under #4827. They encoded implementation shape rather than behaviour —
+// any refactor (extracted helper, different Map key type, rearranged
+// cleanup order) broke the greps without a real regression. Runtime
+// coverage of connectServer/closeAll with a mocked failing transport
+// is tracked as a follow-up.
+
+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);
+});

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -363,7 +363,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 20, 'new DB should be at schema version 20');
+  assert.deepStrictEqual(version?.v, 22, 'new DB should be at schema version 22');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();