gsd-pi 2.76.0 → 2.77.0-dev.1d17f366c

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,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\(\)/);
+});

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();

package/src/resources/extensions/gsd/tests/memory-pressure-stuck-state.test.ts

@@ -51,4 +51,16 @@ describe("stuck detection persistence (#3704)", () => {
   test("stuck state file path uses runtime directory", () => {
     assert.match(loopSource, /stuck-state\.json/);
   });
+
+  test("saveStuckState called in standard dev path as well as custom engine path (#4382)", () => {
+    // Count all call-sites of saveStuckState (excluding the function definition itself).
+    // After the fix, both the custom-engine path and the standard dev path must each
+    // call saveStuckState so stuckRecoveryAttempts survives session restarts.
+    const callMatches = loopSource.match(/saveStuckState\(s\.basePath,\s*loopState\)/g) ?? [];
+    assert.ok(
+      callMatches.length >= 2,
+      `saveStuckState must be called in both the custom-engine path and the standard dev path ` +
+      `(found ${callMatches.length} call(s) — standard path is missing its call, #4382)`,
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -323,9 +323,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 20 (memory Phase 4 relations included)
+  // Verify schema version is 22 (v22 quality_gates DDL fix included)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.['v'], 20, 'schema version should be 20');
+  assert.deepStrictEqual(version?.["v"], 22, 'schema version should be 22');
 
   closeDatabase();
 });

package/src/resources/extensions/gsd/tests/milestone-status-authoritative.test.ts

@@ -75,7 +75,7 @@ test("getMilestoneStatus returns 'pending' for authoritative 'pending' even when
   assert.equal(getMilestoneStatus(milestone, {}), "pending");
 });
 
-test("getMilestoneStatus maps 'parked' to 'pending' item status", () => {
+test("getMilestoneStatus preserves authoritative 'parked' item status", () => {
   const milestone = makeMilestone({
     id: "M004",
     status: "parked",
@@ -83,8 +83,8 @@ test("getMilestoneStatus maps 'parked' to 'pending' item status", () => {
       { id: "S01", title: "Slice 1", done: true, tasks: [] },
     ],
   });
-  // Parked milestones should render as pending in the UI
-  assert.equal(getMilestoneStatus(milestone, {}), "pending");
+  // Parked milestones should retain a distinct parked status in the UI
+  assert.equal(getMilestoneStatus(milestone, {}), "parked");
 });
 
 test("getMilestoneStatus falls back to heuristic when no authoritative status", () => {

package/src/resources/extensions/gsd/tests/milestone-summary-classifier.test.ts

@@ -0,0 +1,30 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { classifyMilestoneSummaryContent } from "../milestone-summary-classifier.ts";
+
+test("milestone SUMMARY classifier treats explicit failed status as failure", () => {
+  assert.equal(
+    classifyMilestoneSummaryContent([
+      "---",
+      "status: failed",
+      "---",
+      "",
+      "# M001 Summary",
+      "Recovery stopped.",
+    ].join("\n")),
+    "failure",
+  );
+});
+
+test("milestone SUMMARY classifier does not treat historical not-complete prose as failure", () => {
+  assert.equal(
+    classifyMilestoneSummaryContent([
+      "# M001 Summary",
+      "",
+      "This milestone was previously not complete, now resolved.",
+    ].join("\n")),
+    "unknown",
+  );
+});
+

package/src/resources/extensions/gsd/tests/milestone-transition-state-rebuild.test.ts

@@ -85,8 +85,10 @@ test("auto.ts buildLoopDeps wires rebuildState", () => {
     "utf-8",
   );
 
-  // rebuildState should be in the LoopDeps object literal
-  const buildLoopDepsIdx = autoSrc.indexOf("function buildLoopDeps()");
+  // rebuildState should be in the LoopDeps object literal.
+  // Match the signature prefix so the test survives future param changes
+  // (e.g. the DECOUPLE-02 change from `()` to `(pi: ExtensionAPI)`).
+  const buildLoopDepsIdx = autoSrc.indexOf("function buildLoopDeps(");
   assert.ok(buildLoopDepsIdx > 0, "buildLoopDeps function should exist");
 
   const afterBuild = autoSrc.slice(buildLoopDepsIdx);

package/src/resources/extensions/gsd/tests/parallel-commit-scope.test.ts

@@ -45,6 +45,11 @@ function initTempRepo(): string {
   gitRun(["init", "-b", "main"], dir);
   gitRun(["config", "user.name", "Test"], dir);
   gitRun(["config", "user.email", "test@test.com"], dir);
+  // Disable commit/tag signing so the test is hermetic in environments where
+  // the user's global git config enables GPG/SSH signing (e.g. Claude Code
+  // sandboxes that proxy signing through an external service).
+  gitRun(["config", "commit.gpgsign", "false"], dir);
+  gitRun(["config", "tag.gpgsign", "false"], dir);
   createFile(dir, ".gitkeep", "");
   gitRun(["add", "-A"], dir);
   gitRun(["commit", "-m", "init"], dir);

package/src/resources/extensions/gsd/tests/parallel-research-dispatch.test.ts

@@ -110,6 +110,25 @@ test("template: parallel-research-slices.md has required variables", () => {
   assert.ok(templateSrc.includes("{{subagentPrompts}}"), "template should use subagentPrompts");
 });
 
+test("#4068: template: parallel-research-slices retry cap prevents infinite subagent loop", () => {
+  // The template must cap retries at 1 ("retry it once") and instruct the
+  // agent to write a BLOCKER note on the second failure rather than looping.
+  // Without this, a timing-out subagent causes the orchestrating agent to
+  // retry indefinitely (issue #4068 / #4355).
+  assert.ok(
+    templateSrc.includes("once") || templateSrc.includes("one retry") || templateSrc.match(/retry.{0,20}once/),
+    "template should cap subagent retries at one",
+  );
+  assert.ok(
+    templateSrc.toLowerCase().includes("blocker"),
+    "template should instruct writing a BLOCKER note instead of infinite retries",
+  );
+  assert.ok(
+    !templateSrc.match(/re-run it individually\s*\n/),
+    "template must not have unbounded re-run instruction without a retry cap",
+  );
+});
+
 // ─── Validate milestone prompt ────────────────────────────────────────────
 
 test("template: validate-milestone uses parallel reviewers", () => {

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Worker × Skill × Subagent — prompt composition integration test.
+ *
+ * Covers two previously-untested seams:
+ *
+ *  P1. Worker × Skill — when a parallel worker's auto loop reaches a
+ *      research/plan/execute unit, the prompt it receives must include the
+ *      `<skill_activation>` block derived from the project's PREFERENCES.md.
+ *      `buildSkillActivationBlock` is unit-tested in isolation; here we
+ *      verify a dispatch-level builder actually plumbs it through.
+ *
+ *  P2. Subagent × Skill — when `buildParallelResearchSlicesPrompt` composes
+ *      per-slice subagent prompts, each embedded prompt must also carry the
+ *      `<skill_activation>` block so the dispatched subagent inherits it.
+ */
+
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { loadSkills } from "@gsd/pi-coding-agent";
+import {
+  buildResearchSlicePrompt,
+  buildParallelResearchSlicesPrompt,
+} from "../auto-prompts.ts";
+
+const SKILL_NAME = "testskill";
+const SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${SKILL_NAME}' })`;
+
+const tmpDirs: string[] = [];
+let savedCwd: string | undefined;
+
+function setupProjectWithSkill(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-worker-skill-int-"));
+  tmpDirs.push(base);
+
+  // Milestone roadmap — buildResearchSlicePrompt inlines the roadmap excerpt.
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(join(milestoneDir, "slices", "S01"), { recursive: true });
+  mkdirSync(join(milestoneDir, "slices", "S02"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Test Milestone",
+      "",
+      "**Vision:** Verify worker × skill prompt plumbing.",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: Alpha** `risk:low` `depends:[]`",
+      "- [ ] **S02: Beta** `risk:low` `depends:[]`",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Project preferences — buildSkillActivationBlock picks these up via
+  // loadEffectiveGSDPreferences(), which reads from `${cwd}/.gsd/PREFERENCES.md`.
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    ["---", `always_use_skills:`, `  - ${SKILL_NAME}`, "---", ""].join("\n"),
+    "utf-8",
+  );
+
+  // Project-scoped skill — resolveSkillReference scans `${cwd}/.agents/skills/`.
+  const skillDir = join(base, ".agents", "skills", SKILL_NAME);
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(
+    join(skillDir, "SKILL.md"),
+    [
+      "---",
+      `name: ${SKILL_NAME}`,
+      `description: Integration-test skill for worker × skill prompt plumbing.`,
+      "---",
+      "",
+      `# ${SKILL_NAME}`,
+      "",
+      "Test skill body.",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Load this skill into the in-process skill registry so
+  // buildSkillActivationBlock treats it as "installed".
+  loadSkills({
+    cwd: base,
+    includeDefaults: false,
+    skillPaths: [join(base, ".agents", "skills")],
+  });
+
+  return base;
+}
+
+afterEach(() => {
+  if (savedCwd !== undefined) {
+    try { process.chdir(savedCwd); } catch { /* best-effort */ }
+    savedCwd = undefined;
+  }
+  for (const dir of tmpDirs) {
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  }
+  tmpDirs.length = 0;
+});
+
+test("worker prompt (buildResearchSlicePrompt) includes <skill_activation> from PREFERENCES.md", async () => {
+  const base = setupProjectWithSkill();
+  savedCwd = process.cwd();
+  process.chdir(base);
+
+  const prompt = await buildResearchSlicePrompt("M001", "Test Milestone", "S01", "Alpha", base);
+
+  assert.ok(
+    prompt.includes("<skill_activation>"),
+    "research-slice prompt should contain a <skill_activation> block",
+  );
+  assert.ok(
+    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    `research-slice prompt should reference the always-used skill '${SKILL_NAME}'`,
+  );
+});
+
+test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skill_activation> into each embedded per-slice section", async () => {
+  const base = setupProjectWithSkill();
+  savedCwd = process.cwd();
+  process.chdir(base);
+
+  const prompt = await buildParallelResearchSlicesPrompt(
+    "M001",
+    "Test Milestone",
+    [
+      { id: "S01", title: "Alpha" },
+      { id: "S02", title: "Beta" },
+    ],
+    base,
+  );
+
+  // The parallel dispatch prompt concatenates per-slice subagent prompts inside
+  // fenced code blocks. Each block should carry the same skill activation.
+  const blockCount = (prompt.match(/<skill_activation>/g) ?? []).length;
+  assert.ok(
+    blockCount >= 2,
+    `expected at least 2 <skill_activation> blocks (one per slice), got ${blockCount}`,
+  );
+  assert.ok(
+    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    `parallel-research-slices prompt should reference the always-used skill '${SKILL_NAME}'`,
+  );
+});

package/src/resources/extensions/gsd/tests/plan-gate-failed-doctor-heal-hint.test.ts

@@ -0,0 +1,37 @@
+/**
+ * Regression test for #4620.
+ *
+ * Ensures plan gate failed-closed errors include a self-heal hint
+ * directing users to /gsd doctor heal.
+ */
+
+import test 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 gsdDir = join(__dirname, "..");
+
+function readSrc(file: string): string {
+  return readFileSync(join(gsdDir, file), "utf-8");
+}
+
+test("#4620: auto/phases plan gate failed message includes doctor heal hint", () => {
+  const src = readSrc("auto/phases.ts");
+  assert.match(
+    src,
+    /Plan gate failed-closed:[\s\S]*\/gsd doctor heal/,
+    "auto/phases.ts should include /gsd doctor heal in plan gate failed notification",
+  );
+});
+
+test("#4620: guided-flow plan gate failed message includes doctor heal hint", () => {
+  const src = readSrc("guided-flow.ts");
+  assert.match(
+    src,
+    /Plan gate failed-closed:[\s\S]*\/gsd doctor heal/,
+    "guided-flow.ts should include /gsd doctor heal in plan gate failed notification",
+  );
+});

package/src/resources/extensions/gsd/tests/pre-exec-backtick-strip.test.ts

@@ -30,6 +30,20 @@ describe('normalizeFilePath backtick stripping (#3649)', () => {
     assert.equal(normalizeFilePath('``src/foo.ts`` (current state)'), 'src/foo.ts')
   })
 
+  it('strips stray backticks from dash-annotated bare paths (#4550)', () => {
+    assert.equal(
+      normalizeFilePath('.gsd/KNOWLEDGE.md` — append-only S05 lessons section'),
+      '.gsd/KNOWLEDGE.md',
+    )
+  })
+
+  it('prefers a backticked path inside a dash-annotated prefix (#4550)', () => {
+    assert.equal(
+      normalizeFilePath('Input `src/foo.ts` — current state'),
+      'src/foo.ts',
+    )
+  })
+
   it('strips backticks even when mixed with other normalization', () => {
     assert.equal(normalizeFilePath('`./src//bar.ts`'), 'src/bar.ts')
   })