@opengsd/gsd-pi 1.0.2-dev.867e002 → 1.0.2-dev.a271e2d

package/src/resources/extensions/gsd/auto/phases.ts

@@ -19,6 +19,7 @@ import {
   type PostUnitContext,
   type PreVerificationOpts,
 } from "../auto-post-unit.js";
+import { lastAssistantText } from "../user-input-boundary.js";
 import type { Phase } from "../types.js";
 import {
   MAX_RECOVERY_CHARS,
@@ -93,9 +94,24 @@ import {
   detectRootWriteLeak,
   formatRootWriteLeakMessage,
 } from "../root-write-leak-guard.js";
+import { classifyError, isTransient } from "../error-classifier.js";
 
 export const STUCK_WINDOW_SIZE = 6;
 const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
+const ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE =
+  /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) hit your limit\b|usage limit\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
+const ZERO_TOOL_PROVIDER_ERROR_SIGNAL_RE =
+  /(?:\b(?:http|status(?: code)?|code|error:)\s*(?:429|500|502|503)\b|\b(?:api|provider) error\s*[:(]?\s*(?:429|500|502|503)\b|\b(?:typeerror|error):\s*(?:fetch failed\b|socket hang up\b|terminated(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|(?:network|connection|server) error(?::|$)|stream idle timeout\b|partial response received\b|unexpected eof\b)|\b(?:server_error|api_error|stream_exhausted(?:_without_result)?)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|context (?:window|length) exceed|context window exceed)/i;
+
+function classifyZeroToolProviderMessage(message: string): ReturnType<typeof classifyError> | null {
+  const firstLine = message.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
+  if (
+    !firstLine ||
+    (!ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE.test(firstLine) &&
+      !ZERO_TOOL_PROVIDER_ERROR_SIGNAL_RE.test(firstLine))
+  ) return null;
+  return classifyError(firstLine);
+}
 
 export function resolveDispatchRecoveryAttempts(
   unitRecoveryCount: Map<string, number>,
@@ -2637,6 +2653,36 @@ export async function runUnitPhase(
         (u: { type: string; id: string; startedAt: number; toolCalls: number }) => u.type === unitType && u.id === unitId && u.startedAt === _resolveCurrentUnitStartedAtForTest(s.currentUnit),
       );
       if (lastUnit && lastUnit.toolCalls === 0) {
+        const lastAssistantMessage = lastAssistantText(s.lastUnitAgentEndMessages);
+        const providerMessageClass = classifyZeroToolProviderMessage(lastAssistantMessage);
+        if (providerMessageClass && isTransient(providerMessageClass)) {
+          const retryAfterMs = "retryAfterMs" in providerMessageClass ? providerMessageClass.retryAfterMs : 15_000;
+          await pauseAutoForProviderError(
+            ctx.ui,
+            ` for ${unitType} ${unitId}`,
+            () => deps.pauseAuto(ctx, pi),
+            {
+              isRateLimit: providerMessageClass.kind === "rate-limit",
+              isTransient: true,
+              retryAfterMs,
+              resume: () => {
+                void resumeAutoAfterProviderDelay(pi, ctx).catch((err) => {
+                  logWarning("engine", `Provider error auto-resume failed: ${err instanceof Error ? err.message : String(err)}`);
+                });
+              },
+            },
+          );
+          await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, {
+            message: lastAssistantMessage.slice(0, 200),
+            category: "provider",
+            isTransient: true,
+            retryAfterMs,
+          });
+          return {
+            action: "break",
+            reason: providerMessageClass.kind === "rate-limit" ? "rate-limit" : "api-timeout",
+          };
+        }
         if (USER_DRIVEN_DEEP_UNITS.has(unitType) && isAwaitingUserInput(s.lastUnitAgentEndMessages ?? undefined)) {
           debugLog("runUnitPhase", {
             phase: "zero-tool-calls-awaiting-user-input",

package/src/resources/extensions/gsd/auto/run-unit.ts

@@ -27,6 +27,7 @@ import { logWarning, logError } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
 import { readUnitRuntimeRecord, type AutoUnitRuntimeRecord } from "../unit-runtime.js";
 import { consumeAutoWakeup } from "./schedule-wakeup.js";
+import { applyUnitSkillVisibility } from "../skill-scope.js";
 
 const UNIT_FAILSAFE_BUFFER_MS = 30_000;
 const UNIT_FAILSAFE_RECHECK_MS = 30_000;
@@ -165,6 +166,12 @@ export async function runUnit(
     }
   }
 
+  const setVisibleSkills =
+    typeof pi.setVisibleSkills === "function" ? pi.setVisibleSkills.bind(pi) : undefined;
+  if (setVisibleSkills) {
+    applyUnitSkillVisibility({ setVisibleSkills }, unitType);
+  }
+
   // ── Create the agent_end promise (per-unit one-shot) ──
   // This happens after newSession completes so session-switch agent_end events
   // from the previous session cannot resolve the new unit.
@@ -176,6 +183,7 @@ export async function runUnit(
   const pendingSwitchCancellation = _consumePendingSwitchCancellation();
   if (pendingSwitchCancellation) {
     _clearCurrentResolve();
+    setVisibleSkills?.(undefined);
     return {
       status: "cancelled",
       ...(pendingSwitchCancellation.errorContext ? { errorContext: pendingSwitchCancellation.errorContext } : {}),
@@ -200,6 +208,7 @@ export async function runUnit(
 
       if (!ready) {
         _clearCurrentResolve();
+        setVisibleSkills?.(undefined);
         return {
           status: "cancelled",
           errorContext: {
@@ -351,6 +360,7 @@ export async function runUnit(
   } finally {
     if (unitTimeoutHandle) clearTimeout(unitTimeoutHandle);
     ctx.ui.setWorkingMessage?.(undefined);
+    setVisibleSkills?.(undefined);
   }
   debugLog("runUnit", {
     phase: "agent-end-received",

package/src/resources/extensions/gsd/auto/session.ts

@@ -218,6 +218,8 @@ export class AutoSession {
   // ── Isolation degradation ────────────────────────────────────────────
   /** Set to true when worktree creation fails; prevents merge of nonexistent branch. */
   isolationDegraded = false;
+  /** Temporary recovery mode for stranded work adopted from physical git evidence. */
+  strandedRecoveryIsolationMode: "worktree" | "branch" | null = null;
   /** Project-root dirty snapshot captured before an isolated worktree unit runs. */
   rootWriteBaseline: RootDirtySnapshot | null = null;
 
@@ -382,6 +384,7 @@ export class AutoSession {
     this.lastGitActionFailure = null;
     this.lastGitActionStatus = null;
     this.isolationDegraded = false;
+    this.strandedRecoveryIsolationMode = null;
     this.rootWriteBaseline = null;
     this.milestoneMergedInPhases = false;
     this.milestoneStartShas = new Map();

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -94,6 +94,7 @@ import { resolveWorktreeProjectRoot } from "./worktree-root.js";
 import { probeGitConflictState } from "./git-conflict-state.js";
 import { runTurnGitAction } from "./git-service.js";
 import { parseUnitId } from "./unit-id.js";
+import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────
 
@@ -132,6 +133,15 @@ export interface DispatchContext {
   sessionProvider?: string;
 }
 
+function resolveExistingExpectedArtifact(
+  unitType: string,
+  unitId: string,
+  basePath: string,
+): string | null {
+  const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
+  return artifactPath && existsSync(artifactPath) ? artifactPath : null;
+}
+
 type ReassessmentChecker = typeof checkNeedsReassessment;
 type ResearchProjectPromptBuilder = typeof buildResearchProjectPrompt;
 
@@ -971,13 +981,17 @@ export const DISPATCH_RULES: DispatchRule[] = [
       if (await getMilestonePipelineVariant(mid) === "trivial") return null;
 
       // Load roadmap to find all slices
-      const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
+      const roadmapFile =
+        resolveExistingExpectedArtifact("plan-milestone", mid, basePath) ??
+        resolveMilestoneFile(basePath, mid, "ROADMAP");
       const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
       if (!roadmapContent) return null;
       const roadmap = parseRoadmap(roadmapContent);
 
       // Find slices that need research (no RESEARCH file, dependencies done)
-      const milestoneResearchFile = resolveMilestoneFile(basePath, mid, "RESEARCH");
+      const milestoneResearchFile =
+        resolveExistingExpectedArtifact("research-milestone", mid, basePath) ??
+        resolveMilestoneFile(basePath, mid, "RESEARCH");
       const researchReadySlices: Array<{ id: string; title: string }> = [];
 
       for (const slice of roadmap.slices) {
@@ -985,10 +999,10 @@ export const DISPATCH_RULES: DispatchRule[] = [
         // Skip S01 when milestone research exists
         if (milestoneResearchFile && slice.id === "S01") continue;
         // Skip if already has research
-        if (resolveSliceFile(basePath, mid, slice.id, "RESEARCH")) continue;
+        if (resolveExistingExpectedArtifact("research-slice", `${mid}/${slice.id}`, basePath)) continue;
         // Skip if dependencies aren't done (check for SUMMARY files)
         const depsComplete = (slice.depends ?? []).every((depId) =>
-          !!resolveSliceFile(basePath, mid, depId, "SUMMARY"),
+          !!resolveExistingExpectedArtifact("complete-slice", `${mid}/${depId}`, basePath),
         );
         if (!depsComplete) continue;
 
@@ -1001,7 +1015,9 @@ export const DISPATCH_RULES: DispatchRule[] = [
       // #4414: If a previous parallel-research attempt escalated to a blocker
       // placeholder, skip this rule and fall through to per-slice research
       // (or other rules) rather than re-dispatching the same failing unit.
-      const parallelBlocker = resolveMilestoneFile(basePath, mid, "PARALLEL-BLOCKER");
+      const parallelBlocker =
+        resolveExistingExpectedArtifact("research-slice", `${mid}/parallel-research`, basePath) ??
+        resolveMilestoneFile(basePath, mid, "PARALLEL-BLOCKER");
       if (parallelBlocker) return null;
 
       return {
@@ -1030,15 +1046,19 @@ export const DISPATCH_RULES: DispatchRule[] = [
       if (!state.activeSlice) return missingSliceStop(mid, state.phase);
       const sid = state.activeSlice!.id;
       const sTitle = state.activeSlice!.title;
-      const researchFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
+      const researchFile =
+        resolveExistingExpectedArtifact("research-slice", `${mid}/${sid}`, basePath) ??
+        resolveSliceFile(basePath, mid, sid, "RESEARCH");
       if (researchFile) return null; // has research, fall through
       // Skip slice research for S01 when milestone research already exists —
       // the milestone research already covers the same ground for the first slice.
-      const milestoneResearchFile = resolveMilestoneFile(
-        basePath,
-        mid,
-        "RESEARCH",
-      );
+      const milestoneResearchFile =
+        resolveExistingExpectedArtifact("research-milestone", mid, basePath) ??
+        resolveMilestoneFile(
+          basePath,
+          mid,
+          "RESEARCH",
+        );
       if (milestoneResearchFile && sid === "S01") return null; // fall through to plan-slice
       return {
         action: "dispatch",

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

@@ -68,7 +68,7 @@ import {
   runMilestoneCloseoutGitHub,
 } from "./milestone-closeout.js";
 import type { AutoSession, SidecarItem } from "./auto/session.js";
-import { getEvidence, clearEvidenceFromDisk } from "./safety/evidence-collector.js";
+import { getEvidence, clearEvidenceFromDisk, isExecutionToolName } from "./safety/evidence-collector.js";
 import { validateFileChanges } from "./safety/file-change-validator.js";
 import { crossReferenceEvidence, type ClaimedEvidence } from "./safety/evidence-cross-ref.js";
 import { validateContent } from "./safety/content-validator.js";
@@ -112,6 +112,27 @@ const MAX_VERIFICATION_RETRIES = 3;
 const MAX_NOTIFICATION_DETAILS = 3;
 const NOTIFICATION_BULLET = "•";
 
+function isParallelResearchUnit(unitType: string, unitId: string): boolean {
+  return unitType === "research-slice" && unitId.endsWith("/parallel-research");
+}
+
+export function maybeWriteParallelResearchCostSpikeBlocker(
+  unitType: string,
+  unitId: string,
+  basePath: string,
+  unitCostUsd: number,
+  rollingAvgUsd: number,
+): string | null {
+  if (!isParallelResearchUnit(unitType, unitId)) return null;
+  return writeBlockerPlaceholder(
+    unitType,
+    unitId,
+    basePath,
+    `Parallel slice research cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}). ` +
+      "Skipping the aggregate sentinel so dispatch can fall back to per-slice research.",
+  );
+}
+
 export function resolveCloseoutGitAction(
   uokFlags: ReturnType<typeof resolveUokFlags>,
 ): TurnGitActionMode | null {
@@ -469,12 +490,6 @@ export function _shouldDispatchQuickTaskForTest(
     state.currentUnit.type !== "quick-task";
 }
 
-function isExecutionToolName(name: unknown): boolean {
-  if (typeof name !== "string") return false;
-  const normalized = name.trim().toLowerCase();
-  return normalized === "bash" || normalized === "gsd_exec";
-}
-
 export function _hasExecutionToolCallsInSessionForTest(entries: readonly unknown[]): boolean {
   for (const entry of entries) {
     const e = entry as any;
@@ -1449,11 +1464,11 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
                       suppressedWarning: "evidence-empty-but-session-has-exec-calls",
                     });
                   } else {
-                    logWarning("safety", `evidence mismatch: ${missingCommandMismatches.length} claimed command(s) not found in bash calls`);
-                  ctx.ui.notify(
-                    `Safety: task ${sTid} claimed ${missingCommandMismatches.length} command(s) not found in recorded bash calls`,
-                    "warning",
-                  );
+                    logWarning("safety", `evidence mismatch: ${missingCommandMismatches.length} claimed command(s) not found in recorded execution calls`);
+                    ctx.ui.notify(
+                      `Safety: task ${sTid} claimed ${missingCommandMismatches.length} command(s) not found in recorded execution calls`,
+                      "warning",
+                    );
                   }
                 }
 
@@ -1591,7 +1606,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
       if (!triggerArtifactVerified) {
         try {
           const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
-          if (mid && sid) {
+          if (mid && sid && !isParallelResearchUnit(s.currentUnit.type, s.currentUnit.id)) {
             // Phase C: write to the canonical project root (#5236 scope)
             // so non-symlinked worktrees no longer maintain a separate
             // local .gsd/ projection. copyPlanningArtifacts has been
@@ -1860,8 +1875,17 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
               );
               return "continue";
             }
+            const parallelBlocker = maybeWriteParallelResearchCostSpikeBlocker(
+              s.currentUnit.type,
+              s.currentUnit.id,
+              verificationBasePath,
+              unitCostUsd,
+              rollingAvgUsd,
+            );
             ctx.ui.notify(
-              `Unit ${s.currentUnit.id} cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}) — pausing auto-mode.`,
+              parallelBlocker
+                ? `Unit ${s.currentUnit.id} cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}) — wrote parallel blocker and pausing auto-mode.`
+                : `Unit ${s.currentUnit.id} cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}) — pausing auto-mode.`,
               "error",
             );
             await pauseAuto(ctx, pi);
@@ -2031,6 +2055,11 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
           "info",
         );
 
+        await s.orchestration?.retryActiveUnit({
+          unitType: trigger.unitType,
+          unitId: trigger.unitId,
+        });
+
         // ── State reset: undo the completion so deriveState re-derives the unit ──
         try {
           const { milestone: mid, slice: sid, task: tid } = parseUnitId(trigger.unitId);

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -19,12 +19,11 @@ import {
   relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath,
   resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile,
 } from "./paths.js";
-import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
+import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
 import { isContextModeEnabled } from "./preferences-types.js";
 import { parseRoadmap } from "./parsers-legacy.js";
 import type { GSDState, InlineLevel } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
-import { getLoadedSkills, type Skill } from "@gsd/pi-coding-agent";
 import { join, basename } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary, type MinimalModelRegistry } from "./context-budget.js";
@@ -42,10 +41,12 @@ import { readCompactionSnapshot } from "./compaction-snapshot.js";
 import { logWarning } from "./workflow-logger.js";
 import { inlineGraphSubgraph } from "./graph-context.js";
 import { buildExtractionStepsBlock } from "./commands-extract-learnings.js";
-import { resolveSkillManifest, warnIfManifestHasMissingSkills } from "./skill-manifest.js";
 import { classifyProject, type ProjectClassification } from "./detection.js";
 import { hasBrowserRequiredText } from "./browser-evidence.js";
 import { debugLog } from "./debug-logger.js";
+import { buildSkillActivationBlock, buildSkillDiscoveryVars } from "./skill-activation.js";
+
+export { buildSkillActivationBlock, buildSkillDiscoveryVars };
 
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 
@@ -1172,287 +1173,6 @@ export async function inlineRoadmapExcerpt(
   return `### Milestone Roadmap (excerpt)\nSource: \`${roadmapRel}\`\n\n${excerpt}`;
 }
 
-// ─── Skill Activation & Discovery ─────────────────────────────────────────
-
-function normalizeSkillReference(ref: string): string {
-  const normalized = ref.replace(/\\/g, "/").trim();
-  const base = basename(normalized).replace(/\.md$/i, "");
-  const name = /^SKILL$/i.test(base)
-    ? basename(normalized.replace(/\/SKILL(?:\.md)?$/i, ""))
-    : base;
-  return name.trim().toLowerCase();
-}
-
-function tokenizeSkillContext(...parts: Array<string | null | undefined>): Set<string> {
-  const tokens = new Set<string>();
-  const addVariants = (raw: string) => {
-    const value = raw.trim().toLowerCase();
-    if (!value || value.length < 2) return;
-    tokens.add(value);
-    tokens.add(value.replace(/[-_]+/g, " "));
-    tokens.add(value.replace(/\s+/g, "-"));
-    tokens.add(value.replace(/\s+/g, ""));
-  };
-
-  for (const part of parts) {
-    if (!part) continue;
-    const text = part.toLowerCase();
-    const phraseMatches = text.match(/[a-z0-9][a-z0-9+.#/_-]{1,}/g) ?? [];
-    for (const match of phraseMatches) {
-      addVariants(match);
-      for (const piece of match.split(/[^a-z0-9+.#]+/g)) {
-        if (piece.length >= 3) addVariants(piece);
-      }
-    }
-  }
-
-  return tokens;
-}
-
-function skillMatchesContext(skill: Skill, contextTokens: Set<string>): boolean {
-  const haystacks = [
-    skill.name.toLowerCase(),
-    skill.name.toLowerCase().replace(/[-_]+/g, " "),
-    skill.description.toLowerCase(),
-  ];
-
-  return [...contextTokens].some(token =>
-    token.length >= 3 && haystacks.some(haystack => haystack.includes(token)),
-  );
-}
-
-function resolvePreferenceSkillNames(refs: string[], base: string): string[] {
-  if (refs.length === 0) return [];
-  const prefs: GSDPreferences = { always_use_skills: refs };
-  const report = resolveAllSkillReferences(prefs, base);
-  return refs.map(ref => {
-    const resolution = report.resolutions.get(ref);
-    return normalizeSkillReference(resolution?.resolvedPath ?? ref);
-  }).filter(Boolean);
-}
-
-function ruleMatchesContext(when: string, contextTokens: Set<string>): boolean {
-  const whenTokens = tokenizeSkillContext(when);
-  return [...whenTokens].some(token =>
-    contextTokens.has(token) || [...contextTokens].some(ctx => ctx.includes(token) || token.includes(ctx)),
-  );
-}
-
-function resolveSkillRuleMatches(
-  prefs: GSDPreferences | undefined,
-  contextTokens: Set<string>,
-  base: string,
-): { include: string[]; avoid: string[] } {
-  if (!prefs?.skill_rules?.length) return { include: [], avoid: [] };
-
-  const include: string[] = [];
-  const avoid: string[] = [];
-  for (const rule of prefs.skill_rules) {
-    if (!ruleMatchesContext(rule.when, contextTokens)) continue;
-    include.push(...resolvePreferenceSkillNames([...(rule.use ?? []), ...(rule.prefer ?? [])], base));
-    avoid.push(...resolvePreferenceSkillNames(rule.avoid ?? [], base));
-  }
-  return { include, avoid };
-}
-
-function resolvePreferredSkillNames(
-  prefs: GSDPreferences | undefined,
-  visibleSkills: Skill[],
-  contextTokens: Set<string>,
-  base: string,
-): string[] {
-  if (!prefs?.prefer_skills?.length) return [];
-  const preferred = new Set(resolvePreferenceSkillNames(prefs.prefer_skills, base));
-  return visibleSkills
-    .filter(skill => preferred.has(normalizeSkillReference(skill.name)) && skillMatchesContext(skill, contextTokens))
-    .map(skill => normalizeSkillReference(skill.name));
-}
-
-/** Skill names must be lowercase alphanumeric with hyphens — reject anything else
- *  to prevent prompt injection via crafted directory names. */
-const SAFE_SKILL_NAME = /^[a-z0-9][a-z0-9-]*$/;
-
-function formatSkillActivationBlock(skillNames: string[]): string {
-  const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
-  if (safe.length === 0) return "";
-  // Use explicit parameter syntax so LLMs pass { skill: "..." } instead of { name: "..." }.
-  // The function-call-like syntax `Skill('name')` led LLMs to infer a positional
-  // parameter name, causing tool validation failures — see #2224.
-  const calls = safe.map(name => `Call Skill({ skill: '${name}' })`).join('. ');
-  return `<skill_activation>${calls}.</skill_activation>`;
-}
-
-/**
- * Manifest-driven recommendations block — informational only, does NOT
- * auto-invoke. Lists per-unit-type skills that are installed but not already
- * activated by explicit user intent (always_use_skills / prefer_skills /
- * skill_rules / task-plan skills_used). Surfaces relevant skills to the
- * model so they can be invoked when the model judges them useful.
- *
- * This is the additive complement to the existing activation directive:
- * activation force-invokes (explicit intent), recommendations remind
- * (manifest defaults). User intent is preserved as the stronger signal
- * (RFC #4779 design principle); this block only adds visibility.
- */
-function formatSkillRecommendationsBlock(unitType: string | undefined, skillNames: string[]): string {
-  if (!unitType) return "";
-  const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
-  if (safe.length === 0) return "";
-  return `<skill_recommendations unit="${unitType}">For this unit type, also consider invoking: ${safe.join(", ")}. Use Skill({ skill: 'name' }) when relevant — these are recommendations, not requirements.</skill_recommendations>`;
-}
-
-export function buildSkillActivationBlock(params: {
-  base: string;
-  milestoneId: string;
-  milestoneTitle?: string;
-  sliceId?: string;
-  sliceTitle?: string;
-  taskId?: string;
-  taskTitle?: string;
-  extraContext?: string[];
-  taskPlanContent?: string | null;
-  preferences?: GSDPreferences;
-  /**
-   * Unit type dispatching this prompt. When provided, skills are filtered
-   * through the per-unit-type manifest (see `skill-manifest.ts`). Unknown
-   * or omitted values retain the pre-manifest behavior (all skills eligible).
-   */
-  unitType?: string;
-}): string {
-  const prefs = params.preferences ?? loadEffectiveGSDPreferences(params.base)?.preferences;
-  const contextTokens = tokenizeSkillContext(
-    params.milestoneId,
-    params.milestoneTitle,
-    params.sliceId,
-    params.sliceTitle,
-    params.taskId,
-    params.taskTitle,
-  );
-
-  const loaded = (typeof getLoadedSkills === 'function' ? getLoadedSkills() : []).filter(skill => !skill.disableModelInvocation);
-
-  // Skill activation here is driven entirely by explicit sources
-  // (always_use_skills, prefer_skills, skill_rules, task-plan skills_used).
-  // Every match is an explicit user/project intent and must not be dropped
-  // by the unit-type manifest — user intent is stronger signal than
-  // defaults. The manifest's real home is the skill catalog rendering
-  // layer (pi-coding-agent `formatSkillsForPrompt`); that wiring is tracked
-  // as the "load-time short-circuit" follow-up to RFC #4779.
-  //
-  // `unitType` stays plumbed so the strict-mode warning can surface
-  // manifest entries that reference uninstalled skills, and so the
-  // activation-block site is ready to opt in once PR B lands.
-  const visibleSkills = loaded;
-  const installedNames = new Set(visibleSkills.map(skill => normalizeSkillReference(skill.name)));
-  warnIfManifestHasMissingSkills(params.unitType, installedNames);
-  const avoided = new Set(resolvePreferenceSkillNames(prefs?.avoid_skills ?? [], params.base));
-  const matched = new Set<string>();
-
-  for (const name of resolvePreferenceSkillNames(prefs?.always_use_skills ?? [], params.base)) {
-    matched.add(name);
-  }
-
-  const ruleMatches = resolveSkillRuleMatches(prefs, contextTokens, params.base);
-  for (const name of ruleMatches.include) matched.add(name);
-  for (const name of ruleMatches.avoid) avoided.add(name);
-
-  for (const name of resolvePreferredSkillNames(prefs, visibleSkills, contextTokens, params.base)) {
-    matched.add(name);
-  }
-
-  if (params.taskPlanContent) {
-    try {
-      const taskPlan = parseTaskPlanFile(params.taskPlanContent);
-      for (const skillName of taskPlan.frontmatter.skills_used) {
-        matched.add(normalizeSkillReference(skillName));
-      }
-    } catch (err) {
-      logWarning("prompt", `parseTaskPlanFile failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-
-  // Heuristic auto-match (gated on skill_discovery: "auto").
-  // For each installed skill, check if its name or description appears in the
-  // unit's context tokens (milestone/slice/task titles). Only consider skills
-  // already on the unit-type manifest allowlist — this keeps the heuristic
-  // narrow and avoids wildly off-topic activations.
-  // Users who set `skill_discovery: "off"` or "suggest" do not get
-  // auto-matched skills (the recommendations block still surfaces manifest
-  // skills passively); only "auto" actually adds them to the activation
-  // directive set. Default `skill_discovery` is "suggest", so this is opt-in.
-  if ((prefs?.skill_discovery ?? "suggest") === "auto") {
-    const manifestAllow = resolveSkillManifest(params.unitType);
-    const allowSet = manifestAllow ? new Set(manifestAllow) : null;
-    for (const skill of visibleSkills) {
-      const normalized = normalizeSkillReference(skill.name);
-      if (matched.has(normalized) || avoided.has(normalized)) continue;
-      // Respect the manifest allowlist when present; wildcard (null) lets all
-      // installed skills compete for keyword match.
-      if (allowSet && !allowSet.has(normalized)) continue;
-      if (skillMatchesContext(skill, contextTokens)) {
-        matched.add(normalized);
-      }
-    }
-  }
-
-  const ordered = [...matched]
-    .filter(name => installedNames.has(name) && !avoided.has(name))
-    .sort();
-  const activationBlock = formatSkillActivationBlock(ordered);
-
-  // Manifest-driven recommendations (additive, does not override explicit intent).
-  // Only surface skills the manifest declares for this unit type that are
-  // installed and not already in matched/avoided.
-  const matchedSet = new Set(ordered);
-  const manifestList = resolveSkillManifest(params.unitType);
-  const recommendations = (manifestList ?? [])
-    .filter(name => installedNames.has(name) && !avoided.has(name) && !matchedSet.has(name))
-    .sort();
-  const recommendationsBlock = formatSkillRecommendationsBlock(params.unitType, recommendations);
-
-  if (!activationBlock && !recommendationsBlock) return "";
-  if (!activationBlock) return recommendationsBlock;
-  if (!recommendationsBlock) return activationBlock;
-  return `${activationBlock}\n${recommendationsBlock}`;
-}
-
-/**
- * Build the skill discovery template variables for research prompts.
- * Returns { skillDiscoveryMode, skillDiscoveryInstructions } for template substitution.
- */
-export function buildSkillDiscoveryVars(): { skillDiscoveryMode: string; skillDiscoveryInstructions: string } {
-  const mode = resolveSkillDiscoveryMode();
-
-  if (mode === "off") {
-    return {
-      skillDiscoveryMode: "off",
-      skillDiscoveryInstructions: " Skill discovery is disabled. Skip this step.",
-    };
-  }
-
-  const autoInstall = mode === "auto";
-  const instructions = `
-   Identify the key technologies, frameworks, and services this work depends on (e.g. Stripe, Clerk, Supabase, JUCE, SwiftUI).
-   For each, check if a professional agent skill already exists:
-   - First check \`<available_skills>\` in your system prompt — a skill may already be installed.
-   - For technologies without an installed skill, run: \`npx skills find "<technology>"\`
-   - Only consider skills that are **directly relevant** to core technologies — not tangentially related.
-   - Evaluate results by install count and relevance to the actual work.${autoInstall
-    ? `
-   - Install relevant skills: \`npx skills add <owner/repo@skill> -g -y\`
-   - Record installed skills in the "Skills Discovered" section of your research output.
-   - Installed skills will automatically appear in subsequent units' system prompts — no manual steps needed.`
-    : `
-   - Note promising skills in your research output with their install commands, but do NOT install them.
-   - The user will decide which to install.`
-  }`;
-
-  return {
-    skillDiscoveryMode: mode,
-    skillDiscoveryInstructions: instructions,
-  };
-}
-
 // ─── Text Helpers ──────────────────────────────────────────────────────────
 
 export function extractMarkdownSection(content: string, heading: string): string | null {