@opengsd/gsd-pi 1.1.1-dev.74e8dd1 → 1.1.1-dev.9bb7453

package/src/resources/extensions/gsd/guided-flow.ts

@@ -227,21 +227,22 @@ async function dispatchDiscussForNextMilestoneWithBacklog(
   nextId: string,
 ): Promise<void> {
   const backlogContext = buildRequirementsBacklogDiscussContext(nextId);
-  const discussMilestoneTemplates = inlineTemplate("context", "Context");
   const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-  const basePrompt = loadPrompt("guided-discuss-milestone", {
-    workingDirectory: basePath,
-    milestoneId: nextId,
-    milestoneTitle: `New milestone ${nextId}`,
-    inlinedTemplates: discussMilestoneTemplates,
+  const basePrompt = await buildDiscussMilestonePrompt(
+    nextId,
+    `New milestone ${nextId}`,
+    basePath,
     structuredQuestionsAvailable,
-    commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
-    fastPathInstruction: [
-      "> **Requirements backlog active.**",
-      "> Map unmapped active requirements to this milestone before finalizing context.",
-      "> Confirm ownership with the user when scope is ambiguous.",
-    ].join("\n"),
-  });
+    {
+      commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
+      includeContextMode: false,
+      fastPathInstruction: [
+        "> **Requirements backlog active.**",
+        "> Map unmapped active requirements to this milestone before finalizing context.",
+        "> Confirm ownership with the user when scope is ambiguous.",
+      ].join("\n"),
+    },
+  );
   const prompt = backlogContext ? `${basePrompt}\n\n${backlogContext}` : basePrompt;
   await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
 }
@@ -1371,6 +1372,7 @@ async function buildDiscussPreparationContext(
   ctx: ExtensionCommandContext,
   basePath: string,
   mode: "greenfield" | "milestone" = "greenfield",
+  skipPriorContext = false,
 ): Promise<string> {
   const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
   if (prefs.discuss_preparation === false) return "";
@@ -1388,7 +1390,7 @@ async function buildDiscussPreparationContext(
     const priorContextBrief = prepResult.priorContextBrief || formatPriorContextBrief(prepResult.priorContext);
     const parts: string[] = [];
     if (codebaseBrief) parts.push(`### Codebase Brief\n\n${codebaseBrief}`);
-    if (priorContextBrief) parts.push(`### Prior Context Brief\n\n${priorContextBrief}`);
+    if (priorContextBrief && !skipPriorContext) parts.push(`### Prior Context Brief\n\n${priorContextBrief}`);
     if (parts.length === 0) return "";
 
     const guidance = mode === "milestone"
@@ -1441,18 +1443,18 @@ async function dispatchNewMilestoneDiscuss(
     return;
   }
 
-  const preparationContext = await buildDiscussPreparationContext(ctx, basePath, "milestone");
-  const discussMilestoneTemplates = inlineTemplate("context", "Context");
+  const preparationContext = await buildDiscussPreparationContext(ctx, basePath, "milestone", true);
   const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-  let prompt = loadPrompt("guided-discuss-milestone", {
-    workingDirectory: basePath,
-    milestoneId: nextId,
-    milestoneTitle: `New milestone ${nextId}`,
-    inlinedTemplates: discussMilestoneTemplates,
+  let prompt = await buildDiscussMilestonePrompt(
+    nextId,
+    `New milestone ${nextId}`,
+    basePath,
     structuredQuestionsAvailable,
-    commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
-    fastPathInstruction: "",
-  });
+    {
+      commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
+      includeContextMode: false,
+    },
+  );
   if (preparationContext) prompt += preparationContext;
   await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
 }
@@ -1759,9 +1761,6 @@ export async function showDiscuss(
   // Special case: milestone is in needs-discussion phase (has CONTEXT-DRAFT.md but no roadmap yet).
   // Route to the draft discussion flow instead of erroring — the discussion IS how the roadmap gets created.
   if (state.phase === "needs-discussion") {
-    const draftFile = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
-    const draftContent = draftFile ? await loadFile(draftFile) : null;
-
     const choice = await showNextAction(ctx, {
       title: `GSD — ${mid}: ${milestoneTitle}`,
       summary: ["This milestone has a draft context from a prior discussion.", "It needs a dedicated discussion before auto-planning can begin."],
@@ -1787,29 +1786,34 @@ export async function showDiscuss(
     });
 
     if (choice === "discuss_draft") {
-      const discussMilestoneTemplates = inlineTemplate("context", "Context");
       const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-      const basePrompt = loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
-        commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-        fastPathInstruction: "",
-      });
-      const seed = draftContent
-        ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-        : basePrompt;
+      const seed = await buildDiscussMilestonePrompt(
+        mid,
+        milestoneTitle,
+        basePath,
+        structuredQuestionsAvailable,
+        {
+          commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
+          includeContextMode: false,
+        },
+      );
       setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
       await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone", { basePath });
     } else if (choice === "discuss_fresh") {
-      const discussMilestoneTemplates = inlineTemplate("context", "Context");
       const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
+      const prompt = await buildDiscussMilestonePrompt(
+        mid,
+        milestoneTitle,
+        basePath,
+        structuredQuestionsAvailable,
+        {
+          commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
+          includeContextMode: false,
+          includeDraftSeed: false,
+        },
+      );
       setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
-      await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
-        commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-        fastPathInstruction: "",
-      }), "gsd-discuss", ctx, "discuss-milestone", { basePath });
+      await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
     } else if (choice === "skip_milestone") {
       const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
       await ensureDbOpen(basePath);
@@ -2068,20 +2072,18 @@ async function dispatchDiscussForMilestone(
         "> Ask only questions where the answer would materially change scope.",
       ].join("\n")
     : "";
-  const discussMilestoneTemplates = inlineTemplate("context", "Context");
   const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-  const basePrompt = loadPrompt("guided-discuss-milestone", {
-    workingDirectory: basePath,
-    milestoneId: mid,
+  const prompt = await buildDiscussMilestonePrompt(
+    mid,
     milestoneTitle,
-    inlinedTemplates: discussMilestoneTemplates,
+    basePath,
     structuredQuestionsAvailable,
-    commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-    fastPathInstruction,
-  });
-  const prompt = draftContent
-    ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-    : basePrompt;
+    {
+      commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
+      includeContextMode: false,
+      fastPathInstruction,
+    },
+  );
   await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
 }
 
@@ -2612,9 +2614,6 @@ export async function showSmartEntry(
 
   // ── Draft milestone — needs discussion before planning ────────────────
   if (state.phase === "needs-discussion") {
-    const draftFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT-DRAFT");
-    const draftContent = draftFile ? await loadFile(draftFile) : null;
-
     const choice = await showNextAction(ctx, {
       title: `GSD — ${milestoneId}: ${milestoneTitle}`,
       summary: ["This milestone has a draft context from a prior discussion.", "It needs a dedicated discussion before auto-planning can begin."],
@@ -2640,29 +2639,34 @@ export async function showSmartEntry(
     });
 
     if (choice === "discuss_draft") {
-      const discussMilestoneTemplates = inlineTemplate("context", "Context");
       const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-      const basePrompt = loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
-        commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-        fastPathInstruction: "",
-      });
-      const seed = draftContent
-        ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-        : basePrompt;
+      const seed = await buildDiscussMilestonePrompt(
+        milestoneId,
+        milestoneTitle,
+        basePath,
+        structuredQuestionsAvailable,
+        {
+          commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
+          includeContextMode: false,
+        },
+      );
       setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
       await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone", { basePath });
     } else if (choice === "discuss_fresh") {
-      const discussMilestoneTemplates = inlineTemplate("context", "Context");
       const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
+      const prompt = await buildDiscussMilestonePrompt(
+        milestoneId,
+        milestoneTitle,
+        basePath,
+        structuredQuestionsAvailable,
+        {
+          commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
+          includeContextMode: false,
+          includeDraftSeed: false,
+        },
+      );
       setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
-      await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
-        commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-        fastPathInstruction: "",
-      }), "gsd-discuss", ctx, "discuss-milestone", { basePath });
+      await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
     } else if (choice === "skip_milestone") {
       const milestoneIds = findMilestoneIds(basePath);
       const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
@@ -2783,14 +2787,18 @@ export async function showSmartEntry(
           { basePath },
         );
       } else if (choice === "discuss") {
-        const discussMilestoneTemplates = inlineTemplate("context", "Context");
         const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-        await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-          workingDirectory: basePath,
-          milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
-          commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-          fastPathInstruction: "",
-        }), "gsd-run", ctx, "discuss-milestone", { basePath });
+        const prompt = await buildDiscussMilestonePrompt(
+          milestoneId,
+          milestoneTitle,
+          basePath,
+          structuredQuestionsAvailable,
+          {
+            commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
+            includeContextMode: false,
+          },
+        );
+        await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "discuss-milestone", { basePath });
       } else if (choice === "skip_milestone") {
         const milestoneIds = findMilestoneIds(basePath);
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;

package/src/resources/extensions/gsd/mcp-project-config.ts

@@ -1,14 +1,17 @@
-import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { basename, resolve } from "node:path";
+import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import {
+  GSD_BROWSER_MCP_SERVER_NAME,
+  resolveBundledGsdBrowserCliPath,
+  resolveGsdBrowserMcpLaunchConfig,
+} from "../shared/gsd-browser-cli.js";
 import { assertSafeDirectory } from "./validate-directory.js";
 import { detectWorkflowMcpLaunchConfig } from "./workflow-mcp.js";
 
 export const GSD_WORKFLOW_MCP_SERVER_NAME = "gsd-workflow";
-export const GSD_BROWSER_MCP_SERVER_NAME = "gsd-browser";
+export { GSD_BROWSER_MCP_SERVER_NAME, resolveBundledGsdBrowserCliPath };
 
 export interface ProjectMcpServerConfig {
   command?: string;
@@ -59,31 +62,6 @@ export function resolveBundledGsdCliPath(env: NodeJS.ProcessEnv = process.env):
   return null;
 }
 
-export function resolveBundledGsdBrowserCliPath(env: NodeJS.ProcessEnv = process.env): string | null {
-  const explicit = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
-  if (explicit) return explicit;
-
-  try {
-    const requireFromHere = createRequire(import.meta.url);
-    const packageJsonPath = requireFromHere.resolve("@opengsd/gsd-browser/package.json");
-    const candidate = resolve(packageJsonPath, "..", "bin", "gsd-browser");
-    if (existsSync(candidate)) return candidate;
-  } catch {
-    // Fall through to path candidates for source/dist layouts.
-  }
-
-  const candidates = [
-    resolve(fileURLToPath(new URL("../../../../node_modules/@opengsd/gsd-browser/bin/gsd-browser", import.meta.url))),
-    resolve(fileURLToPath(new URL("../../../../node_modules/.bin/gsd-browser", import.meta.url))),
-  ];
-
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) return candidate;
-  }
-
-  return null;
-}
-
 export function buildProjectWorkflowMcpServerConfig(
   projectRoot: string,
   env: NodeJS.ProcessEnv = process.env,
@@ -119,31 +97,12 @@ function buildProjectWorkflowMcpServerSpec(
   };
 }
 
-function parseJsonEnv<T>(env: NodeJS.ProcessEnv, name: string): T | undefined {
-  const raw = env[name];
-  if (!raw) return undefined;
-  try {
-    return JSON.parse(raw) as T;
-  } catch {
-    throw new Error(`Invalid JSON in ${name}`);
-  }
-}
-
 function isEnvDisabled(value: string | undefined): boolean {
   if (!value) return false;
   const normalized = value.trim().toLowerCase();
   return normalized === "0" || normalized === "false" || normalized === "off";
 }
 
-function buildBrowserSessionName(projectRoot: string): string {
-  const resolvedProjectRoot = resolve(projectRoot);
-  const base = basename(resolvedProjectRoot)
-    .replace(/[^a-zA-Z0-9._-]+/g, "-")
-    .replace(/^-+|-+$/g, "") || "project";
-  const hash = createHash("sha1").update(resolvedProjectRoot).digest("hex").slice(0, 8);
-  return `gsd-${base}-${hash}`;
-}
-
 export function buildProjectBrowserMcpServerConfig(
   projectRoot: string,
   env: NodeJS.ProcessEnv = process.env,
@@ -157,39 +116,15 @@ function buildProjectBrowserMcpServerSpec(
 ): ProjectMcpServerSpec | null {
   if (isEnvDisabled(env.GSD_BROWSER_MCP_ENABLED)) return null;
 
-  const resolvedProjectRoot = resolve(projectRoot);
-  const serverName = env.GSD_BROWSER_MCP_NAME?.trim() || GSD_BROWSER_MCP_SERVER_NAME;
-  const explicitArgs = parseJsonEnv<unknown>(env, "GSD_BROWSER_MCP_ARGS");
-  const explicitEnv = parseJsonEnv<Record<string, string>>(env, "GSD_BROWSER_MCP_ENV");
-  const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.trim();
-  const explicitCliPath = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
-  const bundledCliPath = !explicitCommand && !explicitCliPath ? resolveBundledGsdBrowserCliPath(env) : null;
-  const command =
-    explicitCommand
-    || explicitCliPath
-    || (bundledCliPath ? process.execPath : undefined)
-    || "gsd-browser";
-  const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
-    ? explicitArgs.map(String)
-    : [
-        ...(bundledCliPath ? [bundledCliPath] : []),
-        "mcp",
-        "--session",
-        buildBrowserSessionName(resolvedProjectRoot),
-        "--identity-scope",
-        "project",
-        "--identity-project",
-        resolvedProjectRoot,
-      ];
-  const cwd = env.GSD_BROWSER_MCP_CWD?.trim() || resolvedProjectRoot;
+  const launch = resolveGsdBrowserMcpLaunchConfig(projectRoot, env);
 
   return {
-    serverName,
+    serverName: launch.serverName,
     server: {
-      command,
-      args,
-      cwd,
-      ...(explicitEnv ? { env: explicitEnv } : {}),
+      command: launch.command,
+      args: launch.args,
+      cwd: launch.cwd,
+      ...(launch.env ? { env: launch.env } : {}),
     },
   };
 }

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

@@ -777,7 +777,10 @@ export function decayStaleMemories(thresholdUnits = 20): string[] {
     const cutoff = row['processed_at'] as string;
     const affected = adapter.prepare(
       `SELECT id FROM memories
-       WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`,
+       WHERE superseded_by IS NULL
+         AND updated_at < :cutoff
+         AND confidence > 0.1
+         AND (structured_fields IS NULL OR structured_fields NOT LIKE '%"sourceDecisionId"%')`,
     ).all({ ':cutoff': cutoff }).map((r) => r['id'] as string);
 
     decayMemoriesBefore(cutoff, new Date().toISOString());

package/src/resources/extensions/gsd/post-unit-hooks.ts

@@ -9,6 +9,7 @@ import type {
   HookDispatchResult,
   PreDispatchResult,
   HookStatusEntry,
+  PostUnitGateBlock,
 } from "./types.js";
 import { getOrCreateRegistry, resolveHookArtifactPath } from "./rule-registry.js";
 
@@ -33,10 +34,22 @@ export function isRetryPending(): boolean {
   return getOrCreateRegistry().isRetryPending();
 }
 
-export function consumeRetryTrigger(): { unitType: string; unitId: string; retryArtifact: string } | null {
+export function consumeRetryTrigger(): { unitType: string; unitId: string; retryArtifact?: string } | null {
   return getOrCreateRegistry().consumeRetryTrigger();
 }
 
+export function consumeHookFailure(): { hookName: string; unitType: string; unitId: string; reason: string } | null {
+  return getOrCreateRegistry().consumeHookFailure();
+}
+
+export function isGateBlockPending(): boolean {
+  return getOrCreateRegistry().isGateBlockPending();
+}
+
+export function consumeGateBlock(): PostUnitGateBlock | null {
+  return getOrCreateRegistry().consumeGateBlock();
+}
+
 export function resetHookState(): void {
   getOrCreateRegistry().resetState();
 }

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -29,6 +29,14 @@ const VALID_UOK_TURN_ACTIONS = new Set<"commit" | "snapshot" | "status-only">([
   "snapshot",
   "status-only",
 ]);
+const VALID_POST_UNIT_HOOK_CRITICALITIES = new Set(["advisory", "blocking"]);
+const VALID_POST_UNIT_HOOK_ON_BLOCK_ACTIONS = new Set([
+  "retry-unit",
+  "retry-task",
+  "queue-task",
+  "queue-slice",
+  "pause",
+]);
 
 export function validatePreferences(preferences: GSDPreferences): {
   preferences: GSDPreferences;
@@ -486,9 +494,37 @@ export function validatePreferences(preferences: GSDPreferences): {
       if (typeof hook.artifact === "string" && hook.artifact.trim()) {
         validHook.artifact = hook.artifact.trim();
       }
+      if (hook.criticality !== undefined) {
+        const criticality = typeof hook.criticality === "string" ? hook.criticality.trim() : "";
+        if (VALID_POST_UNIT_HOOK_CRITICALITIES.has(criticality)) {
+          validHook.criticality = criticality as PostUnitHookConfig["criticality"];
+        } else {
+          errors.push(`post_unit_hooks "${name}" invalid criticality: ${String(hook.criticality)}`);
+        }
+      }
       if (typeof hook.retry_on === "string" && hook.retry_on.trim()) {
         validHook.retry_on = hook.retry_on.trim();
       }
+      if (hook.on_block !== undefined) {
+        if (!hook.on_block || typeof hook.on_block !== "object") {
+          errors.push(`post_unit_hooks "${name}" on_block must be an object`);
+        } else {
+          const onBlock = hook.on_block as unknown as Record<string, unknown>;
+          const action = typeof onBlock.action === "string" ? onBlock.action.trim() : "";
+          if (!VALID_POST_UNIT_HOOK_ON_BLOCK_ACTIONS.has(action)) {
+            errors.push(`post_unit_hooks "${name}" invalid on_block action: ${String(onBlock.action)}`);
+          } else {
+            validHook.on_block = { action: action as NonNullable<PostUnitHookConfig["on_block"]>["action"] };
+            if (typeof onBlock.artifact === "string" && onBlock.artifact.trim()) {
+              validHook.on_block.artifact = onBlock.artifact.trim();
+            }
+          }
+        }
+      }
+      if (validHook.criticality === "blocking" && !validHook.artifact) {
+        errors.push(`post_unit_hooks "${name}" criticality blocking requires artifact`);
+        continue;
+      }
       if (typeof hook.agent === "string" && hook.agent.trim()) {
         validHook.agent = hook.agent.trim();
       }

package/src/resources/extensions/gsd/prompt-loader.ts

@@ -33,6 +33,10 @@ function hasRequiredExtensionAssets(rootDir: string, exists: ExistsFn = existsSy
   );
 }
 
+function isSourceExtensionDir(moduleDir: string): boolean {
+  return moduleDir.replaceAll("\\", "/").endsWith("/src/resources/extensions/gsd");
+}
+
 export function resolveExtensionDirFromCandidates(
   moduleDir: string,
   agentGsdDir: string,
@@ -41,6 +45,10 @@ export function resolveExtensionDirFromCandidates(
   const moduleUsable = hasRequiredExtensionAssets(moduleDir, exists);
   const agentUsable = hasRequiredExtensionAssets(agentGsdDir, exists);
 
+  // Source checkouts must use their own prompt tree. Otherwise local tests and
+  // dev runs can silently render stale prompts from ~/.gsd/agent/extensions/gsd.
+  if (moduleUsable && isSourceExtensionDir(moduleDir)) return moduleDir;
+
   // Prefer the user-local extension tree when both are valid. This avoids
   // leaking npm/global-install paths into prompts on Windows.
   if (agentUsable) return agentGsdDir;

package/src/resources/extensions/gsd/prompts/forensics.md

@@ -12,6 +12,8 @@ Debug GSD itself. Trace the symptom to root cause in current source and produce
 
 GSD extension source: `{{gsdSourceDir}}`
 
+{{toolingSection}}
+
 ### Source Map by Domain
 
 | Domain | Files |
@@ -101,7 +103,7 @@ Then **offer GitHub issue creation**: "Would you like me to create a GitHub issu
 
 **CRITICAL:** The `github_issues` tool targets only the current user's repository and has no `repo` parameter. Use `gh issue create --repo open-gsd/gsd-pi` via `bash`. Do NOT use the `github_issues` tool.
 
-If yes, create using the `bash` tool:
+If yes and `bash` is available, create using the `bash` tool:
 
 ```bash
 ISSUE_BODY_FILE="${TMPDIR:-${TEMP:-${TMP:-.}}}/gsd-forensic-issue.md"
@@ -142,6 +144,64 @@ TYPE_ID=$(gh api graphql -f query='{ repository(owner:"open-gsd",name:"gsd-pi")
 gh api graphql -f query='mutation { updateIssue(input:{id:"'"$ISSUE_ID"'",issueTypeId:"'"$TYPE_ID"'"}) { issue { number } } }'
 ```
 
+If `bash` is unavailable, do not attempt `bash`, `write`, or `github_issues` tool calls. Instead, provide exactly one paste-once shell script for the user to run locally and say that the live duplicate check / issue creation must be run by the user:
+
+```bash
+KEYWORDS="..."
+echo "Searching closed issues for possible duplicates..."
+gh issue list --repo open-gsd/gsd-pi --state closed --search "$KEYWORDS" --limit 20
+
+echo "Searching open PRs for possible fixes..."
+gh pr list --repo open-gsd/gsd-pi --state open --search "$KEYWORDS" --limit 10
+
+echo "Searching merged PRs for possible fixes..."
+gh pr list --repo open-gsd/gsd-pi --state merged --search "$KEYWORDS" --limit 10
+
+read -r -p "Review the duplicate search above. Continue filing a new issue? [y/N] " SHOULD_FILE
+case "$SHOULD_FILE" in
+  y|Y|yes|YES) ;;
+  *) echo "Issue filing aborted."; exit 0 ;;
+esac
+
+ISSUE_BODY_FILE="${TMPDIR:-${TEMP:-${TMP:-.}}}/gsd-forensic-issue.md"
+cat > "$ISSUE_BODY_FILE" << 'GSD_ISSUE_BODY'
+## Problem
+[1-2 sentence summary]
+
+## Root Cause
+[Specific file:line in GSD source, with code snippet showing the bug]
+
+## Expected Behavior
+[What the code should do instead — concrete fix suggestion]
+
+## Environment
+- GSD version: [from report]
+- Model: [from report]
+- Unit: [type/id that failed]
+
+## Reproduction Context
+[Phase, milestone, slice, what was happening when it failed]
+
+## Forensic Evidence
+[Key anomalies, error traces, relevant tool call sequences from the report]
+
+---
+*Auto-generated by `/gsd forensics`*
+GSD_ISSUE_BODY
+
+ISSUE_URL=$(gh issue create --repo open-gsd/gsd-pi \
+  --title "..." \
+  --label "auto-generated" \
+  --body-file "$ISSUE_BODY_FILE")
+rm -f "$ISSUE_BODY_FILE"
+
+ISSUE_NUM=$(echo "$ISSUE_URL" | grep -oE '[0-9]+$')
+ISSUE_ID=$(gh api graphql -f query='{ repository(owner:"open-gsd",name:"gsd-pi") { issue(number:'"$ISSUE_NUM"') { id } } }' --jq '.data.repository.issue.id')
+TYPE_ID=$(gh api graphql -f query='{ repository(owner:"open-gsd",name:"gsd-pi") { issueTypes(first:20) { nodes { id name } } } }' --jq '.data.repository.issueTypes.nodes[] | select(.name=="Bug") | .id')
+gh api graphql -f query='mutation { updateIssue(input:{id:"'"$ISSUE_ID"'",issueTypeId:"'"$TYPE_ID"'"}) { issue { number } } }'
+echo "$ISSUE_URL"
+```
+
 ### Redaction Rules (CRITICAL)
 
 Before creating the issue, you MUST:

package/src/resources/extensions/gsd/prompts/gate-evaluate.md

@@ -8,6 +8,8 @@
 
 You are evaluating **quality gates in parallel** for this slice. Each gate is an independent question that must be answered before task execution begins. Use the `subagent` tool to dispatch all gate evaluations simultaneously.
 
+**Tool call format:** Call `subagent` with `tasks: [...]` as a **native JSON array** — one object per gate. Do NOT JSON.stringify the array into a string; the tool validates that `tasks` is an array, and a serialized string will be rejected with "must be array".
+
 ## Slice Plan Context
 
 {{slicePlanContent}}
@@ -20,7 +22,7 @@ You are evaluating **quality gates in parallel** for this slice. Each gate is an
 
 ## Execution Protocol
 
-1. **Dispatch all gates** using `subagent` in parallel mode. Each subagent prompt is provided below.
+1. **Dispatch all gates** using `subagent` in parallel mode. Call `subagent` with `tasks: [{ agent: "tester", task: "<prompt>" }, ...]` — one object per gate. Each subagent prompt is provided below.
    Pass `tasks` as a **JSON array**, not a string. Example shape:
 
    ```json

package/src/resources/extensions/gsd/prompts/parallel-research-slices.md

@@ -12,9 +12,11 @@ You are dispatching parallel research agents for **{{sliceCount}} slices** in mi
 
 Dispatch ALL slices simultaneously using the `subagent` tool in **parallel mode**. Each subagent will independently research its slice and write a RESEARCH file.
 
+**Tool call format:** Call `subagent` with `tasks: [...]` as a **native JSON array** — one object per slice. Do NOT JSON.stringify the array into a string; the tool validates that `tasks` is an array, and a serialized string will be rejected with "must be array".
+
 ## Execution Protocol
 
-1. Call `subagent` with `tasks: [...]` containing one entry per slice below
+1. Call `subagent` with `tasks: [{ agent: "scout", task: "<prompt>" }, ...]` containing one entry per slice below
 2. Wait for ALL subagents to complete
 3. Verify each slice's RESEARCH file was written (check `.gsd/milestones/{{mid}}/slices/<slice-id>/`)
 4. If a subagent failed to write its RESEARCH file, retry it **once** individually

package/src/resources/extensions/gsd/prompts/plan-slice.md

@@ -43,7 +43,7 @@ If slice research is inlined, trust its architectural findings, but verify every
 5. Define slice verification before tasks. Non-trivial slices need real tests or executable assertions; boundary contracts need contract-exercising checks. Tests must not read .gitignore/gitignored paths such as `.gsd/`, `.planning/`, or `.audits/`.
 6. Include Threat Surface (Q3), Requirement Impact (Q4), proof level, observability, integration closure, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) only where applicable.
 7. Right-size tasks. Simple slices can be one task; split only when context, ownership, or verification boundaries justify it.
-8. Task `verify` commands must be safe, simple commands. Do not use shell pipes, redirects, semicolons, backticks, command substitution, output trimming, or grep regex alternation with `|`. If multiple checks are needed, create a small test file and run it with `node --test` or a package test script, or use separate simple commands joined only with `&&`.
+8. Task `verify` commands must be safe, simple commands. Do not use shell pipes, redirects, semicolons, backticks, command substitution, output trimming, or grep regex alternation with `|`. If multiple checks are needed, create a small test file and run it with `node --test` or a package test script, or use separate simple commands joined only with `&&`. For absence checks, verify a pattern does not exist with `! grep -q 'pattern' file` or `! rg -q 'pattern' file`; do not use `grep -c` or `rg -c` to assert zero matches because count commands exit 1 when they find zero matches, and the verification gate treats that as failure.
 9. Each task needs the exact `gsd_plan_slice.tasks[]` shape: `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. `description` should contain the Why / Do / Done-when narrative. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even when there is only one path (for example, `"inputs": ["src/index.ts"]`, never `"inputs": "src/index.ts"`). Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expectedOutput` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, or tests — those belong only in `inputs`. If a task is a pure verification or test task that produces no new files, `expectedOutput` may be `[]` or limited to test-result artifacts (e.g. a log or assertion output). A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expectedOutput` — if no prior task creates it, add a task before this one that does.
 10. Persist with `gsd_plan_slice` using `milestoneId`, `sliceId`, `goal`, optional `successCriteria`/`proofLevel`/`integrationClosure`/`observabilityImpact`, and `tasks`. `gsd_plan_slice` handles task persistence transactionally and renders `{{outputPath}}` plus task plans; do not call `gsd_plan_task`. The DB-backed tool is the canonical write path. Do **not** rely on direct `PLAN.md` writes as the source of truth.
 11. Self-audit before finishing: goal/demo closure, requirement coverage, deliverable coverage audit (cross-check every file listed in CONTEXT.md `## Scope` / `### In Scope` against task `files` or `expectedOutput`), locked decisions, concrete paths, dependency order, wiring, scope size, proof truthfulness, feature completeness, and quality gates. Quality gates: non-trivial slices/tasks include specific Q3-Q7 coverage where applicable.