npm - @opengsd/gsd-pi - Versions diffs - 1.1.1-dev.b2556262 → 1.2.0-dev.4813ead6 - Mend

@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.4813ead6

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 (500) hide show

package/src/resources/extensions/gsd/tests/research-milestone-composer.test.ts CHANGED Viewed

@@ -130,3 +130,68 @@ test("buildResearchMilestonePrompt keeps broad project docs on-demand", async (t
   assert.match(prompt, /`\.gsd\/REQUIREMENTS\.md`/);
   assert.match(prompt, /`\.gsd\/DECISIONS\.md`/);
 });
+// ─── ADR-029: preload-authoritative research grounding ────────────────
+test("ADR-029: research-milestone inlines project classification + codebase snapshot", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+  seed(base, "M001");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001 Context\n");
+  // Give the codebase scan something real to sample.
+  writeFileSync(join(base, "index.html"), "<!doctype html><html><body><h1>hi</h1></body></html>\n");
+  writeFileSync(join(base, "script.js"), "const x = 1;\nasync function go() { await x; }\n");
+  const prompt = await buildResearchMilestonePrompt("M001", "Research Test", base);
+  // Project-size signal (same block plan-milestone gets).
+  assert.match(prompt, /### Project Classification/);
+  assert.match(prompt, /Workflow sizing:/);
+  // Bounded codebase snapshot grounds research in current code reality.
+  assert.match(prompt, /### Codebase Snapshot \(current code reality\)/);
+  assert.match(prompt, /do NOT re-survey the tree/);
+});
+test("ADR-029: codebase snapshot is suppressed when discuss_preparation is false", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+  seed(base, "M001");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001 Context\n");
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\ndiscuss_preparation: false\n---\n");
+  invalidateAllCaches();
+  const prompt = await buildResearchMilestonePrompt("M001", "Research Test", base);
+  // Snapshot opt-out honored; classification (unconditional) still present.
+  assert.doesNotMatch(prompt, /### Codebase Snapshot/);
+  assert.match(prompt, /### Project Classification/);
+});
+test("ADR-029: prior partial RESEARCH is inlined as a resume block; absent otherwise", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+  seed(base, "M001");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001 Context\n");
+  // No prior research yet → no resume block. (Match the rendered block heading,
+  // not the bare phrase — step 8 of the template references the phrase by name.)
+  const before = await buildResearchMilestonePrompt("M001", "Research Test", base);
+  assert.doesNotMatch(before, /### Resume — Prior Partial Research \(continue, do not redo\)/);
+  // A partial RESEARCH draft from a prior (interrupted) attempt.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-RESEARCH.md"),
+    "# Research\n\n## Findings\n\nPartial finding: the app is a static site.\n",
+  );
+  invalidateAllCaches();
+  const after = await buildResearchMilestonePrompt("M001", "Research Test", base);
+  assert.match(after, /Resume — Prior Partial Research \(continue, do not redo\)/);
+  assert.match(after, /Partial finding: the app is a static site/);
+});

package/src/resources/extensions/gsd/tests/roadmap-parse-regression.test.ts CHANGED Viewed

@@ -396,4 +396,44 @@ test('T. #1736: Checkbox format unchanged', () => {
     assert.deepStrictEqual(slices[1].done, false, '#1736 checkbox compat: S02 not done');
 });
+// ═══════════════════════════════════════════════════════════════════════
+// U. Regression #566: double-bracket depends serialization recovery
+// ═══════════════════════════════════════════════════════════════════════
+test('U. #566: double-bracket depends:[[S01]] recovers to ["S01"]', () => {
+    // Simulates a roadmap written by markdown-renderer when the DB had
+    // depends=["[S01]"] — produces `depends:[[S01]]` on disk.
+    const content = [
+      '# M020: Corrupted Depends',
+      '',
+      '## Slices',
+      '',
+      '- [ ] **S01: Foundation** `risk:low` `depends:[]`',
+      '- [ ] **S02: Build** `risk:medium` `depends:[[S01]]`',
+      '- [ ] **S03: Ship** `risk:high` `depends:[[S01, S02]]`',
+      '',
+    ].join('\n');
+    const slices = parseRoadmapSlices(content);
+    assert.deepStrictEqual(slices.length, 3, '#566 double-bracket: 3 slices');
+    assert.deepStrictEqual(slices[1].depends, ['S01'], '#566: S02 depends recovered to ["S01"]');
+    assert.deepStrictEqual(slices[2].depends, ['S01', 'S02'], '#566: S03 depends recovered to ["S01","S02"]');
+});
+test('U. #566: bracket-wrapped single element depends:[[S01]] recovers to ["S01"]', () => {
+    // Simulates the exact DB corruption seen in the forensic evidence: depends=["[S01]"]
+    const content = [
+      '# M020: Single Bracket Corruption',
+      '',
+      '## Slices',
+      '',
+      '- [ ] **S01: First** `risk:low` `depends:[]`',
+      '- [ ] **S02: Second** `risk:medium` `depends:[[S01]]`',
+      '',
+    ].join('\n');
+    const slices = parseRoadmapSlices(content);
+    assert.deepStrictEqual(slices[1].depends.length, 1, '#566 single: S02 has exactly 1 dep');
+    assert.deepStrictEqual(slices[1].depends[0], 'S01', '#566 single: dep is "S01" not "[S01]"');
+});
 });

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

@@ -6,7 +6,7 @@ import assert from "node:assert/strict";
 import { classifyFailure } from "../recovery-classification.js";
 import { reconcileBeforeDispatch } from "../state-reconciliation.js";
-import { compileUnitToolContract } from "../tool-contract.js";
+import { compileUnitContextContract, compileUnitToolContract } from "../tool-contract.js";
 import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import type { GSDState } from "../types.js";
@@ -68,6 +68,16 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
   assert.ok(result.ok && result.contract.validationRules.includes("closeout-tool-present"));
   assert.ok(result.ok && result.contract.validationRules.includes("source-observation-contract-present"));
+  assert.deepEqual(result.ok && result.contract.promptContext.artifacts.inline, [
+    "task-plan",
+    "slice-plan",
+    "prior-task-summaries",
+    "templates",
+  ]);
+  assert.deepEqual(result.ok && result.contract.promptContext.artifacts.onDemand, ["slice-research"]);
+  assert.ok(result.ok && result.contract.promptObligations.includes("context-inline:task-plan,slice-plan,prior-task-summaries,templates"));
+  assert.ok(result.ok && result.contract.promptObligations.includes("context-on-demand:slice-research"));
+  assert.ok(result.ok && result.contract.promptObligations.includes("source-observations:whole-file-active-unit"));
   assert.deepEqual(result.ok && result.contract.sourceObservations, {
     mode: "whole-file-active-unit",
     seedFields: ["task.files", "task.inputs"],
@@ -77,6 +87,20 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   });
 });
+test("Unit Context Contract exposes prompt context without workflow tool surface", () => {
+  const result = compileUnitContextContract("execute-task");
+  assert.equal(result.ok, true);
+  assert.equal(result.ok && result.contract.unitType, "execute-task");
+  assert.equal(result.ok && result.contract.contextMode, "execution");
+  assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
+  assert.deepEqual(result.ok && result.contract.artifacts.excerpt, []);
+  assert.deepEqual(result.ok && result.contract.artifacts.computed, []);
+  assert.deepEqual(result.ok && result.contract.artifacts.prepend, []);
+  assert.equal(result.ok && result.contract.maxSystemPromptChars, 1_500_000);
+  assert.equal(result.ok && result.contract.sourceObservations.mode, "whole-file-active-unit");
+});
 test("Tool Contract records high-risk cross-phase tool boundaries without single-owning every tool", () => {
   const completeSlice = compileUnitToolContract("complete-slice");
   const runUat = compileUnitToolContract("run-uat");

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts CHANGED Viewed

@@ -24,6 +24,7 @@ import { fileURLToPath } from "node:url";
 import { autoSession } from "../auto-runtime-state.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { _resetPreferenceDiagnosticNotificationsForTests } from "../preferences-diagnostics.ts";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const HOOKS_SOURCE = readFileSync(
@@ -485,3 +486,82 @@ test("session_start and session_switch apply disabled model provider policy from
     "session_switch should re-read preferences for the switched project/session context",
   );
 });
+test("session_start surfaces malformed preference diagnostics through visible notifications", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-session-pref-diagnostics-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  const tempGsdHome = join(dir, "home");
+  mkdirSync(tempGsdHome, { recursive: true });
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(dir);
+  _resetPreferenceDiagnosticNotificationsForTests();
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    _resetPreferenceDiagnosticNotificationsForTests();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
+  writeFileSync(
+    join(dir, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "version: 1",
+      "models:",
+      "  validation:",
+      "    openrouter/deepseek/deepseek-v4-pro",
+      "    thinking: high",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  const notifications: Array<{ message: string; level?: string }> = [];
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+  const ctx = {
+    hasUI: true,
+    ui: {
+      notify: (message: string, level?: string) => notifications.push({ message, level }),
+      setStatus: () => {},
+      setFooter: () => {},
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: () => {},
+    },
+    sessionManager: { getSessionId: () => null },
+    model: null,
+    setCompactionThresholdOverride: () => {},
+    modelRegistry: {
+      setDisabledModelProviders: () => {},
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => false,
+    },
+  };
+  registerHooks(pi, []);
+  const sessionStart = handlers.get("session_start");
+  assert.ok(sessionStart, "session_start handler must be registered");
+  await sessionStart!({}, ctx);
+  const diagnostic = notifications.find((notification) =>
+    notification.message.includes("GSD project preferences error"),
+  );
+  assert.equal(diagnostic?.level, "error");
+  assert.match(diagnostic?.message ?? "", /could not be parsed/);
+  assert.match(diagnostic?.message ?? "", /line 5, column 5/);
+  assert.match(diagnostic?.message ?? "", /Preferences from this file were ignored/);
+});

package/src/resources/extensions/gsd/tests/single-writer-invariant.test.ts CHANGED Viewed

@@ -74,6 +74,29 @@ const PREPARE_WRITE_RE = /\.prepare\s*\(\s*[`'"][^`'"]*\b(INSERT|UPDATE|DELETE|R
 // Match .exec("... INSERT|UPDATE|DELETE|REPLACE ...") or raw BEGIN/COMMIT/ROLLBACK.
 const EXEC_WRITE_RE = /\.exec\s*\(\s*[`'"][^`'"]*\b(INSERT|UPDATE|DELETE|REPLACE|BEGIN|COMMIT|ROLLBACK)\b/i;
+const DB_WORKSPACE_MECHANICS = new Set([
+  "backupDatabaseSnapshot",
+  "checkpointDatabase",
+  "closeAllDatabases",
+  "closeDatabase",
+  "closeDatabaseByWorkspace",
+  "getDbPath",
+  "getDbProvider",
+  "getDbStatus",
+  "openDatabase",
+  "openDatabaseByScope",
+  "openDatabaseByWorkspace",
+  "refreshOpenDatabaseFromDisk",
+  "vacuumDatabase",
+  "wasDbOpenAttempted",
+]);
+function importNames(specifierBlock: string): string[] {
+  return specifierBlock
+    .split(",")
+    .map((name) => name.trim().replace(/^type\s+/, "").split(/\s+as\s+/)[0]?.trim() ?? "")
+    .filter(Boolean);
+}
 test("no module outside gsd-db.ts issues raw write SQL against the engine DB", () => {
   const files = walkTsFiles(gsdDir);
@@ -166,6 +189,84 @@ test("gsd-db.ts exports the expected single-writer wrappers", async () => {
   }
 });
+test("DB Workspace Interface owns database open-state and maintenance calls", async () => {
+  const workspaceDb = await import("../db-workspace.js");
+  const expected = [
+    "backupWorkflowDatabaseSnapshot",
+    "checkpointWorkflowDatabase",
+    "closeAllWorkflowDatabases",
+    "closeWorkflowDatabase",
+    "closeWorkflowDatabaseByWorkspace",
+    "getWorkflowDatabasePath",
+    "getWorkflowDatabaseProvider",
+    "getWorkflowDatabaseStatus",
+    "isWorkflowDatabaseOpen",
+    "openExistingWorkflowDatabase",
+    "openWorkflowDatabase",
+    "openWorkflowDatabaseByScope",
+    "openWorkflowDatabaseByWorkspace",
+    "openWorkflowDatabasePath",
+    "refreshWorkflowDatabaseFromDisk",
+    "resolveProjectRootDbPath",
+    "resolveWorkflowDatabaseLocation",
+    "vacuumWorkflowDatabase",
+    "wasWorkflowDatabaseOpenAttempted",
+  ];
+  for (const name of expected) {
+    assert.ok(
+      typeof (workspaceDb as Record<string, unknown>)[name] === "function",
+      `db-workspace.ts must export ${name} as a function`,
+    );
+  }
+});
+test("production modules do not import DB open-state mechanics from gsd-db.ts", () => {
+  const files = walkTsFiles(gsdDir);
+  const violations: Violation[] = [];
+  const staticImportRe = /import\s*\{([\s\S]*?)\}\s*from\s*["'][^"']*gsd-db\.(?:js|ts)["']/g;
+  const dynamicImportRe = /(?:const|let)\s*\{([\s\S]*?)\}\s*=\s*await\s+import\(["'][^"']*gsd-db\.(?:js|ts)["']\)/g;
+  for (const abs of files) {
+    const rel = relative(gsdDir, abs);
+    if (rel === "gsd-db.ts" || rel === "db-workspace.ts") continue;
+    let content: string;
+    try {
+      content = readFileSync(abs, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const re of [staticImportRe, dynamicImportRe]) {
+      re.lastIndex = 0;
+      let match: RegExpExecArray | null;
+      while ((match = re.exec(content)) !== null) {
+        const leaked = importNames(match[1] ?? "").filter((name) => DB_WORKSPACE_MECHANICS.has(name));
+        if (leaked.length === 0) continue;
+        violations.push({
+          file: rel,
+          line: content.slice(0, match.index).split("\n").length,
+          snippet: leaked.join(", "),
+          kind: "db-workspace-leak",
+        });
+      }
+    }
+  }
+  if (violations.length > 0) {
+    const lines = violations.map(
+      (v) => `  ${v.file}:${v.line} [${v.kind}] — ${v.snippet}`,
+    );
+    assert.fail(
+      `Found ${violations.length} DB open-state import(s) from gsd-db.ts:\n` +
+        lines.join("\n") +
+        "\n\nImport these through db-workspace.ts so gsd-db.ts stays the single-writer implementation, not the caller-facing DB Workspace Interface.",
+    );
+  }
+});
 test("the invariant test touches every .ts module under gsd/ (sanity check)", () => {
   const files = walkTsFiles(gsdDir);
   // Rough sanity: ensure we're not accidentally walking an empty tree
@@ -177,4 +278,3 @@ test("the invariant test touches every .ts module under gsd/ (sanity check)", ()
   assert.ok(rels.includes("memory-store.ts"), "walker must include memory-store.ts");
   assert.ok(rels.includes("workflow-manifest.ts"), "walker must include workflow-manifest.ts");
 });

package/src/resources/extensions/gsd/tests/stale-queued-milestone.test.ts CHANGED Viewed

@@ -74,6 +74,33 @@ describe("stale queued milestone selection (#3470)", () => {
     assert.equal(m070Entry!.status, "active", "M070 should be active in registry");
   });
+  test("queued milestone with roadmap projection but no DB slices stays deferred", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+    // M068: queued shell with a stale ROADMAP projection, but no CONTEXT and no DB slices.
+    insertMilestone({ id: "M068", title: "Queued Roadmap Projection", status: "queued" });
+    writeFile(base, "milestones/M068/M068-ROADMAP.md", "# M068\n\n## Slices\n\n- [ ] **S99: Stale Slice**");
+    // M070: real active milestone — context, roadmap, slices, tasks
+    insertMilestone({ id: "M070", title: "Real Active", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M070", title: "Slice One", status: "active", risk: "low", depends: [] });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M070", title: "Task One", status: "pending" });
+    writeFile(base, "milestones/M070/M070-CONTEXT.md", "# M070: Real Active\n\nThis is the real milestone.");
+    writeFile(base, "milestones/M070/M070-ROADMAP.md", "# M070: Real Active\n\n## Slices\n\n- [ ] **S01: Slice One**");
+    writeFile(base, "milestones/M070/slices/S01/S01-PLAN.md", "# S01: Slice One\n\n## Tasks\n\n- [ ] **T01: Task One**");
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+    assert.equal(state.activeMilestone?.id, "M070", "ROADMAP-only queued milestone must not block active M070");
+    const m068Entry = state.registry.find((e: any) => e.id === "M068");
+    assert.ok(m068Entry, "M068 should still appear in registry");
+    assert.equal(m068Entry!.status, "pending", "M068 should stay pending without CONTEXT or DB slices");
+  });
   test("queued milestone WITH context file can still be selected as active", async () => {
     base = createFixtureBase();
     openDatabase(":memory:");

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

@@ -3,7 +3,10 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { _withDetachedAutoKeepaliveForTest } from "../auto.ts";
+import {
+  _resolveEffectiveUnitIsolationModeForTest,
+  _withDetachedAutoKeepaliveForTest,
+} from "../auto.ts";
 import {
   _scheduleAutoStartAfterIdleForTest,
   resolveGuidedExecuteLaunchMode,
@@ -337,19 +340,31 @@ test("resume path only hard-exits on blocked stop, not blocked pause (#6154)", (
 });
 test("prepareForUnit skips worktree safety when isolation is not worktree (#6154)", () => {
-  const autoSrc = readGsdFile("auto.ts");
-  const prepareForUnitIdx = autoSrc.indexOf("async prepareForUnit(unitType, unitId) {");
-  const prepareForUnitBody = autoSrc.slice(prepareForUnitIdx, autoSrc.indexOf("async syncAfterUnit() {}", prepareForUnitIdx));
+  const orchSrc = readGsdFile("auto/orchestrator.ts");
+  const prepareForUnitIdx = orchSrc.indexOf("private async prepareWorktreeForUnit(");
+  const prepareForUnitBody = orchSrc.slice(prepareForUnitIdx, orchSrc.indexOf("private classifyAndRecover(", prepareForUnitIdx));
   assert.ok(prepareForUnitIdx > -1, "prepareForUnit should exist");
   assert.ok(
-    prepareForUnitBody.includes('if (getIsolationMode(runtimeBasePath) !== "worktree")'),
+    prepareForUnitBody.includes("const isolationMode = this.getEffectiveUnitIsolationMode(this.runtimeBasePath);"),
+    "prepareForUnit should resolve the effective isolation mode once",
+  );
+  assert.ok(
+    prepareForUnitBody.includes('if (isolationMode !== "worktree")'),
     "prepareForUnit should bypass worktree safety validation outside worktree isolation mode",
   );
 });
+test("effective unit isolation follows degraded branch fallback", () => {
+  assert.equal(_resolveEffectiveUnitIsolationModeForTest("worktree", true), "branch");
+  assert.equal(_resolveEffectiveUnitIsolationModeForTest("worktree", false), "worktree");
+  assert.equal(_resolveEffectiveUnitIsolationModeForTest("branch", true), "branch");
+  assert.equal(_resolveEffectiveUnitIsolationModeForTest("none", true), "none");
+});
 test("discuss-to-auto handoff defaults to step mode unless explicitly disabled", () => {
   const guidedFlowSrc = readGsdFile("guided-flow.ts");
+  const discussionHandoffSrc = readGsdFile("discussion-handoff.ts");
   const workflowSrc = readGsdFile("commands/handlers/workflow.ts");
   assert.ok(
@@ -357,7 +372,7 @@ test("discuss-to-auto handoff defaults to step mode unless explicitly disabled",
     "guided-flow must not hardcode step: false on pending auto-start entries",
   );
   assert.match(
-    guidedFlowSrc,
+    discussionHandoffSrc,
     /scheduleAutoStartAfterIdle\(ctx, pi, basePath, false, \{ step: step \?\? true \}\)/,
     "checkAutoStartAfterDiscuss should default missing step flags to step mode",
   );

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts CHANGED Viewed

@@ -24,7 +24,9 @@ test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surf
     "gsd_milestone_status",
     "gsd_checkpoint_db",
     "memory_query",
+    "gsd_memory_query",
     "capture_thought",
+    "gsd_capture_thought",
     "gsd_graph",
   ]);
@@ -575,6 +577,42 @@ test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visib
   assert.equal(calls.filter((call) => call.kind === "skills").length, 2);
 });
+// ── Regression #534: auto-mode subprocess cannot call gsd_memory_query / gsd_capture_thought ──
+// MCP-workflow subprocesses register the gsd_-prefixed variants, not the pi-native names.
+// MINIMAL_GSD_TOOL_NAMES must include both so resolveScopedToolNames exposes them.
+test("MINIMAL_GSD_TOOL_NAMES includes gsd_memory_query and gsd_capture_thought (regression #534)", () => {
+  assert.ok(
+    (MINIMAL_GSD_TOOL_NAMES as readonly string[]).includes("gsd_memory_query"),
+    "MINIMAL_GSD_TOOL_NAMES must include gsd_memory_query for MCP-workflow surface parity",
+  );
+  assert.ok(
+    (MINIMAL_GSD_TOOL_NAMES as readonly string[]).includes("gsd_capture_thought"),
+    "MINIMAL_GSD_TOOL_NAMES must include gsd_capture_thought for MCP-workflow surface parity",
+  );
+});
+test("buildMinimalAutoGsdToolSet resolves MCP-scoped gsd_memory_query and gsd_capture_thought when subprocess only registers gsd_-prefixed variants (regression #534)", () => {
+  // Simulate a subprocess that only exposes gsd_-prefixed MCP tool names,
+  // not the pi-native memory_query / capture_thought variants.
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "mcp__gsd-workflow__gsd_exec",
+    "mcp__gsd-workflow__gsd_memory_query",
+    "mcp__gsd-workflow__gsd_capture_thought",
+  ], "execute-task");
+  assert.ok(
+    result.includes("mcp__gsd-workflow__gsd_memory_query"),
+    "mcp__gsd-workflow__gsd_memory_query must be included when only the gsd_-prefixed variant is available",
+  );
+  assert.ok(
+    result.includes("mcp__gsd-workflow__gsd_capture_thought"),
+    "mcp__gsd-workflow__gsd_capture_thought must be included when only the gsd_-prefixed variant is available",
+  );
+});
 test("applyUnitSkillVisibility sets manifest or clears for wildcard", () => {
   const calls: Array<string[] | undefined> = [];
   applyUnitSkillVisibility({

package/src/resources/extensions/gsd/tests/tool-availability-audit.test.ts CHANGED Viewed

@@ -141,6 +141,41 @@ for (const customType of ["gsd-discuss", "gsd-run"] as const) {
   });
 }
+for (const unitType of ["execute-task", "execute-task-simple", "reactive-execute"] as const) {
+  test(`${unitType}: resolves gsd_task_complete via alias gsd_complete_task when only alias is registered`, () => {
+    // Simulates the MCP transport registering gsd_complete_task (alias) instead of gsd_task_complete.
+    // adjust_tool_set strips aliases from providerCompatible, so gsd_complete_task is only present
+    // in registeredToolNames. resolveScopedToolNames must still surface it so the agent can complete tasks.
+    const base: string[] = [...FULL_REGISTERED_TOOLS];
+    const aliasOnlyRegistered = base
+      .filter((name) => name !== "gsd_task_complete")
+      .concat("gsd_complete_task");
+    const aliasStrippedActive = aliasOnlyRegistered.filter((name) => name !== "gsd_complete_task");
+    const result = buildMinimalAutoGsdToolSet(aliasStrippedActive, unitType, aliasOnlyRegistered);
+    assert.ok(
+      result.includes("gsd_task_complete") || result.includes("gsd_complete_task"),
+      `${unitType} missing gsd_task_complete / gsd_complete_task — agent cannot complete tasks`,
+    );
+  });
+  test(`${unitType}: alias does not duplicate canonical when both are in the active set`, () => {
+    // When both canonical and alias are registered/active, only the canonical should be surfaced.
+    const bothPresent: string[] = [...FULL_REGISTERED_TOOLS, "gsd_complete_task"];
+    const result = buildMinimalAutoGsdToolSet(bothPresent, unitType, bothPresent);
+    const hasCanonical = result.includes("gsd_task_complete");
+    const hasAlias = result.includes("gsd_complete_task");
+    assert.ok(hasCanonical || hasAlias, `${unitType} missing completion tool`);
+    assert.ok(
+      !(hasCanonical && hasAlias),
+      `${unitType} surfaces both gsd_task_complete and gsd_complete_task — alias should not duplicate canonical`,
+    );
+  });
+}
 test("discuss-milestone two-stage scoping matches adjust_tool_set request scope", () => {
   const activeTools = simulateDiscussAllowlistFilter(FULL_REGISTERED_TOOLS);
   const dispatchScoped = buildMinimalAutoGsdToolSet(