gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tool-contract.ts

@@ -0,0 +1,82 @@
+// Project/App: GSD-2
+// File Purpose: ADR-015 Tool Contract module for Unit prompt, policy, and tool parity.
+
+import {
+  resolveManifest,
+  type ArtifactKey,
+  type ContextModePolicy,
+  type ToolsPolicy,
+} from "./unit-context-manifest.js";
+import { getRequiredWorkflowToolsForAutoUnit } from "./workflow-mcp.js";
+
+export interface UnitToolContract {
+  unitType: string;
+  contextMode: ContextModePolicy;
+  toolsPolicy: ToolsPolicy;
+  requiredWorkflowTools: readonly string[];
+  promptObligations: readonly string[];
+  validationRules: readonly string[];
+  closeoutTools: readonly string[];
+  artifacts: {
+    inline: readonly ArtifactKey[];
+    excerpt: readonly ArtifactKey[];
+    onDemand: readonly ArtifactKey[];
+  };
+}
+
+export type ToolContractResult =
+  | { ok: true; contract: UnitToolContract }
+  | { ok: false; reason: "unknown-unit-type" | "missing-closeout-tool"; detail: string };
+
+export function compileUnitToolContract(unitType: string): ToolContractResult {
+  const manifest = resolveManifest(unitType);
+  if (!manifest) {
+    return {
+      ok: false,
+      reason: "unknown-unit-type",
+      detail: `No Unit manifest is registered for ${unitType}`,
+    };
+  }
+
+  const requiredWorkflowTools = getRequiredWorkflowToolsForAutoUnit(unitType);
+  const closeoutTools = requiredWorkflowTools.filter((tool) =>
+    /^gsd_(?:task|slice|milestone|complete|validate|save|summary)/.test(tool),
+  );
+
+  if (requiresCloseoutTool(unitType) && closeoutTools.length === 0) {
+    return {
+      ok: false,
+      reason: "missing-closeout-tool",
+      detail: `${unitType} has no closeout workflow tool`,
+    };
+  }
+
+  return {
+    ok: true,
+    contract: {
+      unitType,
+      contextMode: manifest.contextMode,
+      toolsPolicy: manifest.tools,
+      requiredWorkflowTools,
+      promptObligations: [
+        `context-mode:${manifest.contextMode}`,
+        `tools-policy:${manifest.tools.mode}`,
+      ],
+      validationRules: [
+        "unit-manifest-present",
+        "workflow-tool-surface-present",
+        ...(requiresCloseoutTool(unitType) ? ["closeout-tool-present"] : []),
+      ],
+      closeoutTools,
+      artifacts: {
+        inline: manifest.artifacts.inline,
+        excerpt: manifest.artifacts.excerpt,
+        onDemand: manifest.artifacts.onDemand,
+      },
+    },
+  };
+}
+
+function requiresCloseoutTool(unitType: string): boolean {
+  return /^(execute-task|reactive-execute|complete-slice|validate-milestone|complete-milestone|run-uat|gate-evaluate)$/.test(unitType);
+}

package/src/resources/extensions/gsd/tools/complete-milestone.ts

@@ -1,3 +1,4 @@
+// GSD2 complete-milestone tool handler
 /**
  * complete-milestone handler — the core operation behind gsd_complete_milestone.
  *
@@ -31,21 +32,21 @@ export interface CompleteMilestoneParams {
   oneLiner: string;
   narrative: string;
   verificationPassed: boolean;
-  /** @optional — defaults to "Not provided." when omitted by models with limited tool-calling */
+  /** @optional — empty/omitted renders as "Not provided." */
   successCriteriaResults?: string;
-  /** @optional — defaults to "Not provided." when omitted */
+  /** @optional — empty/omitted renders as "Not provided." */
   definitionOfDoneResults?: string;
-  /** @optional — defaults to "Not provided." when omitted */
+  /** @optional — empty/omitted renders as "Not provided." */
   requirementOutcomes?: string;
-  /** @optional — defaults to [] when omitted */
+  /** @optional — empty/omitted renders as "(none)" */
   keyDecisions?: string[];
-  /** @optional — defaults to [] when omitted */
+  /** @optional — empty/omitted renders as "(none)" */
   keyFiles?: string[];
-  /** @optional — defaults to [] when omitted */
+  /** @optional — empty/omitted renders as "(none)" */
   lessonsLearned?: string[];
-  /** @optional — defaults to "None." when omitted */
+  /** @optional — empty/omitted renders as "None." */
   followUps?: string;
-  /** @optional — defaults to "None." when omitted */
+  /** @optional — empty/omitted renders as "None." */
   deviations?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
@@ -57,10 +58,10 @@ export interface CompleteMilestoneResult {
   milestoneId: string;
   summaryPath: string;
   stale?: boolean;
+  alreadyComplete?: boolean;
 }
 
-function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams): string {
-  const now = new Date().toISOString();
+function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams, completedAt: string): string {
   const displayTitle = stripIdPrefix(params.title, params.milestoneId);
 
   // Apply defaults for optional enrichment fields (#2771)
@@ -84,7 +85,7 @@ function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams): string
 id: ${params.milestoneId}
 title: "${displayTitle}"
 status: complete
-completed_at: ${now}
+completed_at: ${completedAt}
 key_decisions:
 ${keyDecisionsYaml}
 key_files:
@@ -103,15 +104,15 @@ ${params.narrative}
 
 ## Success Criteria Results
 
-${params.successCriteriaResults ?? "Not provided."}
+${params.successCriteriaResults || "Not provided."}
 
 ## Definition of Done Results
 
-${params.definitionOfDoneResults ?? "Not provided."}
+${params.definitionOfDoneResults || "Not provided."}
 
 ## Requirement Outcomes
 
-${params.requirementOutcomes ?? "Not provided."}
+${params.requirementOutcomes || "Not provided."}
 
 ## Deviations
 
@@ -143,6 +144,7 @@ export async function handleCompleteMilestone(
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   const completedAt = new Date().toISOString();
   let guardError: string | null = null;
+  let alreadyComplete = false;
 
   transaction(() => {
     // State machine preconditions (inside txn for atomicity)
@@ -152,7 +154,7 @@ export async function handleCompleteMilestone(
       return;
     }
     if (isClosedStatus(milestone.status)) {
-      guardError = `milestone ${params.milestoneId} is already complete`;
+      alreadyComplete = true;
       return;
     }
 
@@ -190,7 +192,7 @@ export async function handleCompleteMilestone(
   }
 
   // ── Filesystem operations (outside transaction) ─────────────────────────
-  const summaryMd = renderMilestoneSummaryMarkdown(params);
+  const summaryMd = renderMilestoneSummaryMarkdown(params, completedAt);
 
   let summaryPath: string;
   const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
@@ -238,14 +240,16 @@ export async function handleCompleteMilestone(
     logWarning("tool", `complete-milestone manifest warning: ${(mfErr as Error).message}`);
   }
   try {
-    appendEvent(basePath, {
-      cmd: "complete-milestone",
-      params: { milestoneId: params.milestoneId },
-      ts: new Date().toISOString(),
-      actor: "agent",
-      actor_name: params.actorName,
-      trigger_reason: params.triggerReason,
-    });
+    if (!alreadyComplete) {
+      appendEvent(basePath, {
+        cmd: "complete-milestone",
+        params: { milestoneId: params.milestoneId },
+        ts: new Date().toISOString(),
+        actor: "agent",
+        actor_name: params.actorName,
+        trigger_reason: params.triggerReason,
+      });
+    }
   } catch (eventErr) {
     logError("tool", `complete-milestone event log FAILED — completion invisible to reconciliation`, { error: (eventErr as Error).message });
   }
@@ -254,5 +258,6 @@ export async function handleCompleteMilestone(
     milestoneId: params.milestoneId,
     summaryPath,
     ...(projectionStale ? { stale: true } : {}),
+    ...(alreadyComplete ? { alreadyComplete: true } : {}),
   };
 }

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Complete-task tool handler for GSD workflow state and summaries.
+
 /**
  * complete-task handler — the core operation behind gsd_complete_task.
  *
@@ -55,7 +58,7 @@ export interface CompleteTaskResult {
   stale?: boolean;
 }
 
-import type { TaskRow } from "../gsd-db.js";
+import type { TaskRow } from "../db-task-slice-rows.js";
 
 /**
  * Map an execute-task-owned gate id to the CompleteTaskParams field whose
@@ -82,7 +85,7 @@ function taskGateFieldForId(
  * Normalize a list parameter that may arrive as a string (newline-delimited
  * bullet list from the LLM) into a string array (#3361).
  */
-function normalizeListParam(value: unknown): string[] {
+export function normalizeListParam(value: unknown): string[] {
   if (Array.isArray(value)) return value.map(String);
   if (typeof value === "string" && value.trim()) {
     return value.split(/\n/).map(s => s.replace(/^[\s\-*•]+/, "").trim()).filter(Boolean);

package/src/resources/extensions/gsd/tools/context-mode-tool-result.ts

@@ -0,0 +1,25 @@
+// Project/App: GSD-2
+// File Purpose: Shared Context Mode tool result helpers.
+
+export interface ToolExecutionResult {
+  content: Array<{ type: "text"; text: string }>;
+  details: Record<string, unknown>;
+  isError?: boolean;
+}
+
+export type ContextModeToolName = "gsd_exec" | "gsd_exec_search" | "gsd_resume";
+
+export function contextModeDisabledResult(operation: ContextModeToolName): ToolExecutionResult {
+  return {
+    content: [
+      {
+        type: "text",
+        text:
+          `${operation} is disabled by \`context_mode.enabled: false\` in preferences. ` +
+          "Remove that override or set it to true to re-enable Context Mode tools.",
+      },
+    ],
+    details: { operation, error: "context_mode_disabled" },
+    isError: true,
+  };
+}

package/src/resources/extensions/gsd/tools/exec-search-tool.ts

@@ -4,6 +4,8 @@
 // re-discover past runs without re-executing. Read-only; no DB writes.
 
 import { searchExecHistory, type ExecSearchOptions } from "../exec-history.js";
+import { isContextModeEnabled, type ContextModeConfig } from "../preferences-types.js";
+import { contextModeDisabledResult, type ToolExecutionResult } from "./context-mode-tool-result.js";
 
 export interface ExecSearchToolParams {
   query?: string;
@@ -12,16 +14,14 @@ export interface ExecSearchToolParams {
   limit?: number;
 }
 
-export interface ToolExecutionResult {
-  content: Array<{ type: "text"; text: string }>;
-  details: Record<string, unknown>;
-  isError?: boolean;
-}
-
 export function executeExecSearch(
   params: ExecSearchToolParams,
-  opts: { baseDir: string },
+  opts: { baseDir: string; preferences?: { context_mode?: ContextModeConfig } | null },
 ): ToolExecutionResult {
+  if (!isContextModeEnabled(opts.preferences)) {
+    return contextModeDisabledResult("gsd_exec_search");
+  }
+
   const searchOpts: ExecSearchOptions = {
     query: typeof params.query === "string" ? params.query : undefined,
     runtime: params.runtime,

package/src/resources/extensions/gsd/tools/exec-tool.ts

@@ -12,6 +12,7 @@ import {
   type ExecSandboxResult,
 } from "../exec-sandbox.js";
 import { isContextModeEnabled, type ContextModeConfig } from "../preferences-types.js";
+import { contextModeDisabledResult, type ToolExecutionResult } from "./context-mode-tool-result.js";
 
 export interface ExecToolParams {
   runtime: ExecSandboxRequest["runtime"];
@@ -20,17 +21,12 @@ export interface ExecToolParams {
   timeout_ms?: number;
 }
 
-export interface ToolExecutionResult {
-  content: Array<{ type: "text"; text: string }>;
-  details: Record<string, unknown>;
-  isError?: boolean;
-}
-
 export interface ExecToolDeps {
   baseDir: string;
   preferences: { context_mode?: ContextModeConfig } | null;
   /** Optional override for testing. */
   run?: (req: ExecSandboxRequest, opts: ExecSandboxOptions) => Promise<ExecSandboxResult>;
+  env?: NodeJS.ProcessEnv;
   now?: () => Date;
   generateId?: () => string;
 }
@@ -77,21 +73,6 @@ function isEnabled(prefs: ExecToolDeps["preferences"]): boolean {
   return isContextModeEnabled(prefs);
 }
 
-function disabledResult(): ToolExecutionResult {
-  return {
-    content: [
-      {
-        type: "text",
-        text:
-          "gsd_exec is disabled by `context_mode.enabled: false` in preferences. Remove that " +
-          "override (or set it to true) to re-enable sandboxed tool-output execution.",
-      },
-    ],
-    details: { operation: "gsd_exec", error: "context_mode_disabled" },
-    isError: true,
-  };
-}
-
 function paramError(message: string): ToolExecutionResult {
   return {
     content: [{ type: "text", text: `Error: ${message}` }],
@@ -104,7 +85,7 @@ export async function executeGsdExec(
   params: ExecToolParams,
   deps: ExecToolDeps,
 ): Promise<ToolExecutionResult> {
-  if (!isEnabled(deps.preferences)) return disabledResult();
+  if (!isEnabled(deps.preferences)) return contextModeDisabledResult("gsd_exec");
 
   const runtime = params.runtime;
   if (runtime !== "bash" && runtime !== "node" && runtime !== "python") {
@@ -121,7 +102,7 @@ export async function executeGsdExec(
   const opts = buildExecOptions(
     deps.baseDir,
     deps.preferences?.context_mode,
-    { now: deps.now, generateId: deps.generateId },
+    { env: deps.env, now: deps.now, generateId: deps.generateId },
   );
   const run = deps.run ?? runExecSandbox;
 

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

@@ -308,6 +308,7 @@ function includeSupersededMemories(rankedActive: Memory[]): Memory[] {
         scope: (row["scope"] as string) ?? "project",
         tags,
         structured_fields: structuredFields,
+        last_hit_at: (row["last_hit_at"] as string | null) ?? null,
       };
     });
   } catch {

package/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -18,6 +18,7 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { validatePlanningPathScope } from "../planning-path-scope.js";
 
 export interface PlanSliceTaskInput {
   taskId: string;
@@ -141,6 +142,18 @@ export async function handlePlanSlice(
     return { error: `validation failed: ${(err as Error).message}` };
   }
 
+  const pathScopeError = validatePlanningPathScope(
+    basePath,
+    params.tasks.flatMap((task, index) => [
+      { field: `tasks[${index}].files`, values: task.files },
+      { field: `tasks[${index}].inputs`, values: task.inputs },
+      { field: `tasks[${index}].expectedOutput`, values: task.expectedOutput },
+    ]),
+  );
+  if (pathScopeError) {
+    return { error: `validation failed: ${pathScopeError}` };
+  }
+
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   // Guards must be inside the transaction so the state they check cannot
   // change between the read and the write (#2723).

package/src/resources/extensions/gsd/tools/plan-task.ts

@@ -8,6 +8,7 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { validatePlanningPathScope } from "../planning-path-scope.js";
 
 export interface PlanTaskParams {
   milestoneId: string;
@@ -66,6 +67,15 @@ export async function handlePlanTask(
     return { error: `validation failed: ${(err as Error).message}` };
   }
 
+  const pathScopeError = validatePlanningPathScope(basePath, [
+    { field: "files", values: params.files },
+    { field: "inputs", values: params.inputs },
+    { field: "expectedOutput", values: params.expectedOutput },
+  ]);
+  if (pathScopeError) {
+    return { error: `validation failed: ${pathScopeError}` };
+  }
+
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   // Guards must be inside the transaction so the state they check cannot
   // change between the read and the write (#2723).

package/src/resources/extensions/gsd/tools/resume-tool.ts

@@ -3,22 +3,22 @@
 // re-deriving project memory state.
 
 import { readCompactionSnapshot } from "../compaction-snapshot.js";
+import { isContextModeEnabled, type ContextModeConfig } from "../preferences-types.js";
+import { contextModeDisabledResult, type ToolExecutionResult } from "./context-mode-tool-result.js";
 
 export interface ResumeToolParams {
   /** Ignored — reserved for future variant (e.g. dated snapshots). */
   _variant?: string;
 }
 
-export interface ToolExecutionResult {
-  content: Array<{ type: "text"; text: string }>;
-  details: Record<string, unknown>;
-  isError?: boolean;
-}
-
 export function executeResume(
   _params: ResumeToolParams,
-  opts: { baseDir: string },
+  opts: { baseDir: string; preferences?: { context_mode?: ContextModeConfig } | null },
 ): ToolExecutionResult {
+  if (!isContextModeEnabled(opts.preferences)) {
+    return contextModeDisabledResult("gsd_resume");
+  }
+
   const snapshot = readCompactionSnapshot(opts.baseDir);
   if (snapshot == null) {
     return {

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -477,12 +477,17 @@ export async function executeCompleteMilestone(
       isError: true,
       };
     }
+    const message = result.alreadyComplete
+      ? `Milestone ${result.milestoneId} is already complete. Summary available at ${result.summaryPath}`
+      : `Completed milestone ${result.milestoneId}. Summary written to ${result.summaryPath}`;
     return {
-      content: [{ type: "text", text: `Completed milestone ${result.milestoneId}. Summary written to ${result.summaryPath}` }],
+      content: [{ type: "text", text: message }],
       details: {
         operation: "complete_milestone",
         milestoneId: result.milestoneId,
         summaryPath: result.summaryPath,
+        ...(result.alreadyComplete ? { alreadyComplete: true } : {}),
+        ...(result.stale ? { stale: true } : {}),
       },
     };
   } catch (err) {
@@ -808,7 +813,7 @@ export async function executeMilestoneStatus(
 
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length },
+        details: { operation: "milestone_status", ...result },
       };
     });
   } catch (err) {

package/src/resources/extensions/gsd/tui/render-kit.ts

@@ -0,0 +1,109 @@
+// Project/App: GSD-2
+// File Purpose: Shared terminal rendering helpers for GSD extension TUI surfaces.
+
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+
+export interface ThemeLike {
+  fg(color: string, text: string): string;
+  bold(text: string): string;
+}
+
+export function safeLine(text: string, width: number, ellipsis = "…"): string {
+  if (width <= 0) return "";
+  return truncateToWidth(text, width, ellipsis);
+}
+
+export function padRightVisible(text: string, width: number): string {
+  if (width <= 0) return "";
+  const truncated = safeLine(text, width);
+  const pad = Math.max(0, width - visibleWidth(truncated));
+  return truncated + " ".repeat(pad);
+}
+
+export function rightAlign(left: string, right: string, width: number): string {
+  if (width <= 0) return "";
+  if (!right) return safeLine(left, width);
+  if (!left) return safeLine(" ".repeat(Math.max(0, width - visibleWidth(right))) + right, width);
+  const gap = Math.max(1, width - visibleWidth(left) - visibleWidth(right));
+  return safeLine(left + " ".repeat(gap) + right, width);
+}
+
+export function wrapVisibleText(text: string, width: number): string[] {
+  if (width <= 0) return [text];
+  return wrapTextWithAnsi(text, width).map((line) =>
+    visibleWidth(line) > width ? truncateToWidth(line, width, "…") : line,
+  );
+}
+
+export function renderBar(theme: ThemeLike, width: number, color = "muted"): string {
+  return safeLine(theme.fg(color, "─".repeat(Math.max(0, width))), width, "");
+}
+
+export function renderKeyHints(theme: ThemeLike, hints: string[], width: number): string {
+  return safeLine(theme.fg("dim", hints.filter(Boolean).join("  │  ")), width);
+}
+
+export function renderProgressBar(
+  theme: ThemeLike,
+  done: number,
+  total: number,
+  width: number,
+  options: {
+    filledColor?: string;
+    emptyColor?: string;
+    filledChar?: string;
+    emptyChar?: string;
+  } = {},
+): string {
+  const barWidth = Math.max(0, width);
+  const pct = total > 0 ? Math.max(0, Math.min(1, done / total)) : 0;
+  const filled = Math.round(pct * barWidth);
+  const filledChar = options.filledChar ?? "█";
+  const emptyChar = options.emptyChar ?? "░";
+  return (
+    theme.fg(options.filledColor ?? "success", filledChar.repeat(filled)) +
+    theme.fg(options.emptyColor ?? "dim", emptyChar.repeat(barWidth - filled))
+  );
+}
+
+export function statusGlyph(
+  theme: ThemeLike,
+  level: "active" | "idle" | "warning" | "error" | "success",
+): string {
+  switch (level) {
+    case "active": return theme.fg("success", "●");
+    case "success": return theme.fg("success", "✓");
+    case "warning": return theme.fg("warning", "!");
+    case "error": return theme.fg("error", "x");
+    case "idle":
+    default: return theme.fg("dim", "○");
+  }
+}
+
+export function renderFrame(
+  theme: ThemeLike,
+  inner: string[],
+  width: number,
+  options: { borderColor?: string; paddingX?: number } = {},
+): string[] {
+  if (width < 4) return inner.map((line) => safeLine(line, width));
+
+  const borderColor = options.borderColor ?? "borderAccent";
+  const paddingX = Math.max(0, options.paddingX ?? 1);
+  const contentWidth = Math.max(0, width - 2 - paddingX * 2);
+  const border = (text: string) => theme.fg(borderColor, text);
+  const pad = " ".repeat(paddingX);
+
+  const lines = [border("╭" + "─".repeat(width - 2) + "╮")];
+  for (const line of inner) {
+    lines.push(
+      border("│") +
+      pad +
+      padRightVisible(line, contentWidth) +
+      pad +
+      border("│"),
+    );
+  }
+  lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
+  return lines.map((line) => safeLine(line, width, ""));
+}

package/src/resources/extensions/gsd/unit-context-composer.ts

@@ -112,8 +112,22 @@ const CONTEXT_MODE_LANE_LABELS: Record<Exclude<ContextModePolicy, "none">, strin
   docs: "documentation",
 };
 
-const CONTEXT_MODE_GUIDANCE =
-  "Use `gsd_exec` for noisy scans, builds, and tests so full output stays out of prompt context; call `gsd_exec_search` before repeating prior runs; call `gsd_resume` after compaction or resume to recover stored execution context.";
+const CONTEXT_MODE_GUIDANCE_BY_LANE: Record<Exclude<ContextModePolicy, "none">, string> = {
+  interview:
+    "Use `gsd_resume` to restore prior discussion, `gsd_exec` for noisy discovery, and `gsd_exec_search` before repeating scans.",
+  research:
+    "Use `gsd_exec` for noisy research scans, `gsd_exec_search` before reruns, and `gsd_resume` to restore prior findings.",
+  planning:
+    "Use `gsd_resume` for planning continuity, `gsd_exec` for noisy checks, and `gsd_exec_search` before rerunning diagnostics.",
+  execution:
+    "Use `gsd_exec` for builds, tests, and diagnostics, `gsd_exec_search` before reruns, and `gsd_resume` after compaction or resume.",
+  verification:
+    "Use `gsd_exec` for verification commands, `gsd_exec_search` to reuse prior evidence, and `gsd_resume` after compaction or resume.",
+  orchestration:
+    "Use `gsd_resume` before resuming orchestration, `gsd_exec_search` to reuse prior runs, and `gsd_exec` for noisy coordination checks.",
+  docs:
+    "Use `gsd_resume` for prior context, `gsd_exec_search` for saved evidence, and `gsd_exec` for noisy doc validation commands.",
+};
 
 /**
  * Render the Context Mode instruction lane for a unit type. Unknown unit
@@ -129,15 +143,16 @@ export function composeContextModeInstructions(
   if (!manifest || manifest.contextMode === "none") return "";
 
   const lane = CONTEXT_MODE_LANE_LABELS[manifest.contextMode];
+  const guidance = CONTEXT_MODE_GUIDANCE_BY_LANE[manifest.contextMode];
   if (opts.renderMode === "nested") {
-    return `Context Mode (${lane} lane): ${CONTEXT_MODE_GUIDANCE}`;
+    return `Context Mode (${lane} lane): ${guidance}`;
   }
 
   return [
     "## Context Mode",
     "",
     `Lane: **${lane} lane**.`,
-    CONTEXT_MODE_GUIDANCE,
+    guidance,
   ].join("\n");
 }