gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.4ea7d80e7

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

@@ -2064,8 +2064,8 @@ export async function showSmartEntry(
   // standard wizard below.
   {
     const prefs = loadEffectiveGSDPreferences(basePath)?.preferences;
-    const { hasPendingDeepStage } = await import("./auto-dispatch.js");
-    if (hasPendingDeepStage(prefs, basePath)) {
+    const { shouldRunDeepProjectSetup } = await import("./auto-dispatch.js");
+    if (shouldRunDeepProjectSetup(state, prefs, basePath)) {
       await startDeepProjectSetupForeground(ctx, pi, basePath, stepMode);
       return;
     }

package/src/resources/extensions/gsd/interrupted-session.ts

@@ -37,6 +37,7 @@ export interface PausedSessionMetadata {
   activeRunDir?: string | null;
   autoStartTime?: number;
   milestoneLock?: string | null;
+  pauseReason?: string;
 }
 
 export interface InterruptedSessionAssessment {

package/src/resources/extensions/gsd/legacy-telemetry.ts

@@ -0,0 +1,99 @@
+// Project/App: GSD-2
+// File Purpose: Runtime counters for telemetry-gated legacy compatibility paths.
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+import { logWarning } from "./workflow-logger.js";
+
+export type LegacyTelemetryCounter =
+  | "legacy.markdownFallbackUsed"
+  | "legacy.workflowEngineUsed"
+  | "legacy.uokFallbackUsed"
+  | "legacy.mcpAliasUsed"
+  | "legacy.componentFormatUsed"
+  | "legacy.providerDefaultUsed";
+
+export type LegacyTelemetrySnapshot = Record<LegacyTelemetryCounter, number>;
+
+export interface LegacyTelemetryReport {
+  ts: string;
+  counters: LegacyTelemetrySnapshot;
+}
+
+const COUNTERS: LegacyTelemetryCounter[] = [
+  "legacy.markdownFallbackUsed",
+  "legacy.workflowEngineUsed",
+  "legacy.uokFallbackUsed",
+  "legacy.mcpAliasUsed",
+  "legacy.componentFormatUsed",
+  "legacy.providerDefaultUsed",
+];
+
+const values: LegacyTelemetrySnapshot = Object.fromEntries(
+  COUNTERS.map((counter) => [counter, 0]),
+) as LegacyTelemetrySnapshot;
+
+const warnedCounters = new Set<LegacyTelemetryCounter>();
+
+const DIAGNOSTICS: Record<LegacyTelemetryCounter, string> = {
+  "legacy.markdownFallbackUsed": "Deprecated markdown state fallback used; migrate projects to DB-authoritative state before removing markdown derivation.",
+  "legacy.workflowEngineUsed": "Deprecated workflow engine path used; prefer auto-milestone workflow templates before removing legacy engines.",
+  "legacy.uokFallbackUsed": "Deprecated UOK fallback path used; resolve UOK kernel blockers before removing parity fallback wrappers.",
+  "legacy.mcpAliasUsed": "Deprecated MCP alias tool used; update callers to the canonical gsd_* tool name before alias removal.",
+  "legacy.componentFormatUsed": "Deprecated component format loaded; migrate skills/agents to component.yaml before removing legacy loaders.",
+  "legacy.providerDefaultUsed": "Provider-specific default fallback used without an explicit available model; configure provider-aware model preferences before removing defaults.",
+};
+
+process.once("beforeExit", persistLegacyTelemetry);
+
+export function incrementLegacyTelemetry(counter: LegacyTelemetryCounter, amount = 1): void {
+  if (!Number.isFinite(amount) || amount <= 0) return;
+  values[counter] += amount;
+  emitLegacyDiagnostic(counter);
+  persistLegacyTelemetry();
+}
+
+export function getLegacyTelemetry(): LegacyTelemetrySnapshot {
+  return { ...values };
+}
+
+export function resetLegacyTelemetry(): void {
+  for (const counter of COUNTERS) {
+    values[counter] = 0;
+  }
+  warnedCounters.clear();
+}
+
+export function listLegacyTelemetryCounters(): LegacyTelemetryCounter[] {
+  return [...COUNTERS];
+}
+
+export function getLegacyTelemetryReport(): LegacyTelemetryReport {
+  return {
+    ts: new Date().toISOString(),
+    counters: getLegacyTelemetry(),
+  };
+}
+
+export function persistLegacyTelemetrySnapshot(): void {
+  persistLegacyTelemetry();
+}
+
+function emitLegacyDiagnostic(counter: LegacyTelemetryCounter): void {
+  if (warnedCounters.has(counter)) return;
+  warnedCounters.add(counter);
+  logWarning("migration", DIAGNOSTICS[counter], { counter });
+}
+
+function persistLegacyTelemetry(): void {
+  const outputPath = process.env.GSD_LEGACY_TELEMETRY_FILE?.trim();
+  if (!outputPath) return;
+
+  try {
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, `${JSON.stringify(getLegacyTelemetryReport(), null, 2)}\n`, "utf-8");
+  } catch {
+    // Legacy cleanup telemetry must never block runtime paths.
+  }
+}

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Markdown projection renderer for GSD workflow database rows.
 // GSD Markdown Renderer — DB → Markdown file generation
 //
 // Transforms DB state into correct markdown files on disk.
@@ -23,7 +25,8 @@ import {
   insertArtifact,
   getGateResults,
 } from "./gsd-db.js";
-import type { MilestoneRow, SliceRow, TaskRow, ArtifactRow } from "./gsd-db.js";
+import type { MilestoneRow, ArtifactRow } from "./db-milestone-artifact-rows.js";
+import type { SliceRow, TaskRow } from "./db-task-slice-rows.js";
 import type { GateRow } from "./types.js";
 import {
   resolveMilestoneFile,

package/src/resources/extensions/gsd/model-router.ts

@@ -1,6 +1,5 @@
-// GSD Extension — Dynamic Model Router
-// Maps complexity tiers to models, enforcing downgrade-only semantics.
-// The user's configured model is always the ceiling.
+// Project/App: GSD-2
+// File Purpose: Routes work to appropriate models while preserving configured ceilings.
 
 import type { ComplexityTier, ClassificationResult, TaskMetadata } from "./complexity-classifier.js";
 import { tierOrdinal } from "./complexity-classifier.js";
@@ -8,6 +7,7 @@ import type { ResolvedModelConfig } from "./preferences.js";
 import { getProviderCapabilities, type ProviderCapabilities } from "@gsd/pi-ai";
 import { getToolCompatibility, getAllToolCompatibility } from "@gsd/pi-coding-agent";
 import type { ToolCompatibility } from "@gsd/pi-coding-agent";
+import { incrementLegacyTelemetry } from "./legacy-telemetry.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -641,14 +641,18 @@ export function resolveModelForTier(
 
   // No available models known — return canonical fallback
   if (availableModelIds.length === 0) {
+    incrementLegacyTelemetry("legacy.providerDefaultUsed");
     return canonicalModelForTier(tier);
   }
 
   // Cross-provider tier search
   const resolved = findModelForTier(tier, routingConfig, availableModelIds, allowCrossProvider);
-  return resolved
-    ? normalizeResolvedTierModelId(resolved, tier, routingConfig)
-    : canonicalModelForTier(tier);
+  if (resolved) {
+    return normalizeResolvedTierModelId(resolved, tier, routingConfig);
+  }
+
+  incrementLegacyTelemetry("legacy.providerDefaultUsed");
+  return canonicalModelForTier(tier);
 }
 
 // ─── Internal ────────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/notification-widget.ts

@@ -27,9 +27,13 @@ export function buildNotificationWidgetLines(): string[] {
 }
 
 const REFRESH_INTERVAL_MS = 30_000;
+let notificationWidgetCleanup: (() => void) | undefined;
 
-export function initNotificationWidget(ctx: ExtensionContext): void {
-  if (!ctx.hasUI) return;
+export function initNotificationWidget(ctx: ExtensionContext): () => void {
+  notificationWidgetCleanup?.();
+  notificationWidgetCleanup = undefined;
+
+  if (!ctx.hasUI) return () => {};
 
   const push = () => {
     const chip = buildNotificationChip();
@@ -37,6 +41,23 @@ export function initNotificationWidget(ctx: ExtensionContext): void {
   };
   push();
 
-  onNotificationStoreChange(push);
-  setInterval(push, REFRESH_INTERVAL_MS).unref?.();
+  const unsubscribe = onNotificationStoreChange(push);
+  const interval = setInterval(push, REFRESH_INTERVAL_MS);
+  interval.unref?.();
+
+  const cleanup = () => {
+    unsubscribe();
+    clearInterval(interval);
+    if (notificationWidgetCleanup === cleanup) {
+      ctx.ui.setStatus(STATUS_KEY, undefined);
+      notificationWidgetCleanup = undefined;
+    }
+  };
+  notificationWidgetCleanup = cleanup;
+  return cleanup;
+}
+
+export function _resetNotificationWidgetForTests(): void {
+  notificationWidgetCleanup?.();
+  notificationWidgetCleanup = undefined;
 }

package/src/resources/extensions/gsd/post-execution-checks.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Post-execution validation checks for completed GSD task output.
+
 /**
  * Post-Execution Checks — Validate task output after execution completes.
  *
@@ -15,7 +18,7 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { resolve, dirname, join, extname } from "node:path";
-import type { TaskRow } from "./gsd-db.ts";
+import type { TaskRow } from "./db-task-slice-rows.js";
 
 // ─── Result Types ────────────────────────────────────────────────────────────
 
@@ -144,12 +147,30 @@ export function resolveImportPath(
     if (existsSync(directPath)) {
       return { exists: true, resolvedPath: directPath };
     }
-    // Only .js/.jsx/.mjs/.cjs imports legitimately fall through for the TS
-    // ESM convention (.js → .ts). Any other explicit extension (.css, .json,
-    // .svg, images, fonts, .ts, .tsx, …) must stay unresolved when the direct
-    // path is missing — otherwise a stray `./missing.css.ts` could shadow a
-    // genuinely missing `./missing.css` import.
-    if (![".js", ".jsx", ".mjs", ".cjs"].includes(explicitExt)) {
+
+    // Known concrete extensions that should NOT fall through to code-shadow
+    // probing when missing. This preserves the "missing.css must stay missing"
+    // guarantee while still allowing dotted module stems like ./route.server
+    // to resolve as ./route.server.ts.
+    const nonFallbackExtensions = new Set([
+      ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+      ".json", ".css", ".scss", ".sass", ".less", ".styl",
+      ".svg", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".ico", ".bmp",
+      ".woff", ".woff2", ".ttf", ".otf", ".eot",
+    ]);
+    const runtimeFallbackExtensions = new Set([".js", ".jsx", ".mjs", ".cjs"]);
+    const dottedStemFallbackExtensions = new Set([".server", ".client", ".webhook"]);
+
+    if (
+      explicitExt !== "" &&
+      !runtimeFallbackExtensions.has(explicitExt) &&
+      !nonFallbackExtensions.has(explicitExt) &&
+      !dottedStemFallbackExtensions.has(explicitExt)
+    ) {
+      return { exists: false, resolvedPath: null };
+    }
+
+    if (nonFallbackExtensions.has(explicitExt) && !runtimeFallbackExtensions.has(explicitExt)) {
       return { exists: false, resolvedPath: null };
     }
   }
@@ -222,6 +243,13 @@ export function checkImportResolution(
     const imports = extractRelativeImports(source);
 
     for (const { importPath, lineNum } of imports) {
+      // React Router generated +types modules may not exist on disk during
+      // post-exec checks (generated during framework build). Don't block task
+      // completion on these imports.
+      if (/^\.{1,2}\/\+types\//.test(importPath)) {
+        continue;
+      }
+
       const resolution = resolveImportPath(importPath, file, basePath);
 
       if (!resolution.exists) {

package/src/resources/extensions/gsd/pr-evidence.ts

@@ -0,0 +1,182 @@
+// Project/App: GSD-2
+// File Purpose: Shared pull request evidence generator for GSD shipping paths.
+
+export type PrChangeType = "feat" | "fix" | "refactor" | "test" | "docs" | "chore";
+
+export interface PrEvidenceInput {
+  milestoneId: string;
+  subjectId?: string;
+  subjectKind?: "milestone" | "slice" | "workflow";
+  milestoneTitle?: string;
+  changeType?: PrChangeType;
+  linkedIssue?: string;
+  summaries?: string[];
+  blockers?: string[];
+  roadmapItems?: string[];
+  metrics?: string[];
+  testsRun?: string[];
+  why?: string;
+  how?: string;
+  rollbackNotes?: string[];
+  aiAssisted?: boolean;
+}
+
+export interface PrEvidence {
+  title: string;
+  body: string;
+}
+
+const CHANGE_TYPE_LABELS: Record<PrChangeType, string> = {
+  feat: "New feature or capability",
+  fix: "Bug fix",
+  refactor: "Code restructuring",
+  test: "Adding or updating tests",
+  docs: "Documentation only",
+  chore: "Build, CI, or tooling changes",
+};
+
+// Per-item cap for user-supplied content. 2 KB gives slice titles plus
+// descriptions room while still bounding malicious DoS-via-PR-body input.
+const USER_CONTENT_CAP_BYTES = 2048;
+const TRUNCATION_SUFFIX = " … [truncated]";
+
+// Strips HTML comments, fake commit trailers (Co-Authored-By, Signed-off-by —
+// case-insensitive on the trailer name), and caps total length. Designed to
+// be a no-op for well-formed input; golden fixtures must remain byte-stable.
+// Trailer lines are removed (not rejected) so that a single bad line in an
+// otherwise legitimate description does not block the entire PR.
+function sanitizeUserContent(s: string): string {
+  if (!s) return s;
+  // Strip HTML comments greedily across newlines.
+  let out = s.replace(/<!--[\s\S]*?-->/g, "");
+  // Drop lines that look like commit trailers we do not want forged.
+  out = out
+    .split("\n")
+    .filter((line) => !/^\s*(co-authored-by|signed-off-by)\s*:/i.test(line))
+    .join("\n");
+  if (Buffer.byteLength(out, "utf8") > USER_CONTENT_CAP_BYTES) {
+    const budget = USER_CONTENT_CAP_BYTES - Buffer.byteLength(TRUNCATION_SUFFIX, "utf8");
+    // Truncate by code units to stay safely under the byte budget for ASCII;
+    // for multibyte content we conservatively walk back until under budget.
+    let sliced = out.slice(0, Math.max(0, budget));
+    while (Buffer.byteLength(sliced, "utf8") > budget && sliced.length > 0) {
+      sliced = sliced.slice(0, -1);
+    }
+    out = sliced + TRUNCATION_SUFFIX;
+  }
+  return out;
+}
+
+// Strips HTML comments and fake trailers without applying the length cap.
+// Used for short fields like linkedIssue where truncation would be confusing.
+function sanitizeIssueRef(s: string): string {
+  if (!s) return s;
+  let out = s.replace(/<!--[\s\S]*?-->/g, "");
+  out = out
+    .split("\n")
+    .filter((line) => !/^\s*(co-authored-by|signed-off-by)\s*:/i.test(line))
+    .join("\n");
+  return out;
+}
+
+function normalizeList(values: readonly string[] | undefined): string[] {
+  return (values ?? [])
+    .map((value) => sanitizeUserContent(value).trim())
+    .filter(Boolean);
+}
+
+function changeTypeChecklist(selected: PrChangeType): string[] {
+  return (Object.keys(CHANGE_TYPE_LABELS) as PrChangeType[]).map((type) => {
+    const checked = type === selected ? "x" : " ";
+    return `- [${checked}] \`${type}\` - ${CHANGE_TYPE_LABELS[type]}`;
+  });
+}
+
+function bulletList(values: readonly string[], fallback: string): string {
+  if (values.length === 0) return `- ${fallback}`;
+  return values.map((value) => `- ${value}`).join("\n");
+}
+
+export function buildPrEvidence(input: PrEvidenceInput): PrEvidence {
+  const subjectId = input.subjectId?.trim() || input.milestoneId;
+  const subjectKind = input.subjectKind ?? "milestone";
+  const subjectTitle = input.milestoneTitle?.trim() || subjectId;
+  const changeType = input.changeType ?? "feat";
+  const summaries = normalizeList(input.summaries);
+  const blockers = normalizeList(input.blockers);
+  const roadmapItems = normalizeList(input.roadmapItems);
+  const metrics = normalizeList(input.metrics);
+  const testsRun = normalizeList(input.testsRun);
+  const rollbackNotes = normalizeList(input.rollbackNotes);
+  // linkedIssue is sanitized but not length-capped: legitimate issue refs
+  // are short by nature, and truncating "Closes #123" would be unhelpful.
+  const linkedIssueRaw = input.linkedIssue ? sanitizeIssueRef(input.linkedIssue).trim() : "";
+  const linkedIssue = linkedIssueRaw || "Not specified. Add an issue link before marking this PR ready if CONTRIBUTING.md requires one.";
+  const why = (input.why ? sanitizeUserContent(input.why).trim() : "") || `${capitalize(subjectKind)} work is complete and ready for review.`;
+  const how = (input.how ? sanitizeUserContent(input.how).trim() : "") || "Generated from GSD evidence and local workflow artifacts.";
+  const title = `${changeType}: ${subjectTitle}`;
+
+  const sections: string[] = [
+    "## TL;DR",
+    "",
+    `**What:** Ship ${subjectKind} ${subjectId} - ${subjectTitle}`,
+    `**Why:** ${why}`,
+    `**How:** ${how}`,
+    "",
+    "## What",
+    "",
+    summaries.length > 0 ? summaries.join("\n\n") : `${capitalize(subjectKind)} ${subjectId} completed.`,
+  ];
+
+  if (blockers.length > 0) {
+    sections.push("", "## Blockers", "", blockers.map((blocker) => `- ${blocker}`).join("\n"));
+  }
+
+  sections.push(
+    "",
+    "## Why",
+    "",
+    why,
+    "",
+    "## How",
+    "",
+    how,
+    "",
+    "## Linked Issue",
+    "",
+    linkedIssue,
+  );
+
+  if (roadmapItems.length > 0) {
+    sections.push("", "## Roadmap", "", roadmapItems.join("\n"));
+  }
+
+  if (metrics.length > 0) {
+    sections.push("", "## Metrics", "", bulletList(metrics, "No metrics recorded."));
+  }
+
+  sections.push(
+    "",
+    "## Tests Run",
+    "",
+    bulletList(testsRun, "Not specified. Add exact verification commands before requesting review."),
+    "",
+    "## Change Type",
+    "",
+    ...changeTypeChecklist(changeType),
+    "",
+    "## Rollback And Compatibility",
+    "",
+    bulletList(rollbackNotes, "No behavior-changing rollback notes recorded."),
+  );
+
+  if (input.aiAssisted !== false) {
+    sections.push("", "## AI Assistance Disclosure", "", "This PR was prepared with AI assistance.");
+  }
+
+  return { title, body: sections.join("\n") };
+}
+
+function capitalize(value: string): string {
+  return value.slice(0, 1).toUpperCase() + value.slice(1);
+}

package/src/resources/extensions/gsd/pre-execution-checks.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Pre-execution validation checks for GSD task plans.
+
 /**
  * Pre-Execution Checks — Validate task plans before execution begins.
  *
@@ -18,7 +21,7 @@ import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
-import type { TaskRow } from "./gsd-db.ts";
+import type { TaskRow } from "./db-task-slice-rows.js";
 import type { PreExecutionCheckJSON } from "./verification-evidence.ts";
 
 const NPM_COMMAND = process.platform === "win32" ? "npm.cmd" : "npm";

package/src/resources/extensions/gsd/process-task-path.ts

@@ -0,0 +1,81 @@
+// Project/App: GSD-2
+// File Purpose: Canonical process recommendations for routing work by task size.
+
+export type ProcessTaskSize =
+  | "hotfix"
+  | "bugfix"
+  | "small-feature"
+  | "large-feature"
+  | "architecture-change";
+
+export interface ProcessTaskPath {
+  taskSize: ProcessTaskSize;
+  label: string;
+  templateId: string;
+  command: string;
+  phases: string[];
+  guidance: string;
+}
+
+const TASK_PATHS: Record<ProcessTaskSize, ProcessTaskPath> = {
+  hotfix: {
+    taskSize: "hotfix",
+    label: "Hotfix",
+    templateId: "hotfix",
+    command: "/gsd start hotfix <description>",
+    phases: ["fix", "ship"],
+    guidance: "Use for urgent production fixes that need minimal ceremony and fast verification.",
+  },
+  bugfix: {
+    taskSize: "bugfix",
+    label: "Bugfix",
+    templateId: "bugfix",
+    command: "/gsd start bugfix <description> --issue <ref>",
+    phases: ["triage", "fix", "verify", "ship"],
+    guidance: "Use for reproducible defects where a linked issue and regression test are expected.",
+  },
+  "small-feature": {
+    taskSize: "small-feature",
+    label: "Small Feature",
+    templateId: "small-feature",
+    command: "/gsd start small-feature <description>",
+    phases: ["scope", "plan", "implement", "verify"],
+    guidance: "Use for contained feature work that does not need the full milestone machinery.",
+  },
+  "large-feature": {
+    taskSize: "large-feature",
+    label: "Large Feature",
+    templateId: "full-project",
+    command: "/gsd discuss <description>, then /gsd auto",
+    phases: ["discuss", "plan", "execute", "verify"],
+    guidance: "Use for multi-slice work that should run through the DB-backed milestone flow.",
+  },
+  "architecture-change": {
+    taskSize: "architecture-change",
+    label: "Architecture Change",
+    templateId: "refactor",
+    command: "/gsd start refactor <description>",
+    phases: ["inventory", "plan", "migrate", "verify"],
+    guidance: "Use for structural changes that require inventory, compatibility notes, and staged verification.",
+  },
+};
+
+export function recommendProcessPath(taskSize: ProcessTaskSize): ProcessTaskPath {
+  return TASK_PATHS[taskSize];
+}
+
+export function listRecommendedProcessPaths(): ProcessTaskPath[] {
+  return [
+    TASK_PATHS.hotfix,
+    TASK_PATHS.bugfix,
+    TASK_PATHS["small-feature"],
+    TASK_PATHS["large-feature"],
+    TASK_PATHS["architecture-change"],
+  ];
+}
+
+export function formatRecommendedProcessPaths(): string {
+  return listRecommendedProcessPaths()
+    .map((path) => `  ${path.taskSize.padEnd(19)} ${path.command}`)
+    .join("\n");
+}

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

@@ -10,7 +10,7 @@
  * Templates are snapshotted shortly after module init via warmCache().
  * This keeps import/extension-registration fast while still preventing a
  * running session from being invalidated when another `gsd` launch overwrites
- * ~/.gsd/agent/ with newer templates via initResources(). Without caching, the
+ * the user-local agent tree with newer templates via initResources(). Without caching, the
  * in-memory extension code (which knows variable set A) can read a newer
  * template from disk (which expects variable set B), causing a
  * "template declares {{X}} but no value was provided" crash mid-session.
@@ -57,9 +57,9 @@ export function resolveExtensionDirFromCandidates(
  *
  * `import.meta.url` resolves to whichever copy of this module is executing.
  * On Windows (npm global install via MSYS2 / Git Bash) this can resolve to
- * the npm-global `AppData/Roaming/npm/…` path, which does NOT contain the
- * prompts/ and templates/ subtrees that initResources() copies to
- * `~/.gsd/agent/extensions/gsd/`. Detect the mismatch and fall back to
+ * the npm-global package path, which does NOT contain the prompts/ and
+ * templates/ subtrees that initResources() copies to the user-local agent
+ * extension directory. Detect the mismatch and fall back to
  * the user-local agent directory.
  */
 function resolveExtensionDir(): string {
@@ -74,7 +74,7 @@ const templatesDir = join(__extensionDir, "templates");
 
 /**
  * Return the resolved templates directory path for use in prompts.
- * Avoids hardcoding `~/.gsd/agent/extensions/gsd/templates/` in templates. (#3575)
+ * Avoids hardcoding the user-local templates directory in templates. (#3575)
  */
 export function getTemplatesDir(): string {
   return templatesDir;
@@ -155,6 +155,10 @@ export function loadPrompt(name: string, vars: Record<string, string> = {}): str
   }
 
   const effectiveVars = {
+    templatesDir: getTemplatesDir(),
+    planTemplatePath: join(getTemplatesDir(), "plan.md"),
+    taskPlanTemplatePath: join(getTemplatesDir(), "task-plan.md"),
+    taskSummaryTemplatePath: join(getTemplatesDir(), "task-summary.md"),
     skillActivation: "If a `GSD Skill Preferences` block is present in system context, use it and the `<available_skills>` catalog in your system prompt to decide which skills to load and follow for this unit, without relaxing required verification or artifact rules.",
     ...vars,
   };