@opengsd/gsd-pi 1.0.2-dev.e9a1b49 → 1.0.2-dev.fb7ddf1

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 {
@@ -202,13 +223,45 @@ function completeSliceReopenReplanHandoffDetected(
     agentEndMessagesIncludeToolCall(agentEndMessages, "gsd_task_reopen") ||
     agentEndMessagesMentionTool(agentEndMessages, "gsd_task_reopen") ||
     unitActivityMentionsTool(s.basePath, unitType, unitId, "gsd_task_reopen") ||
-    unitActivityMentionsTool(s.canonicalProjectRoot, unitType, unitId, "gsd_task_reopen") ||
+    unitActivityMentionsTool(s.canonicalProjectRoot, unitType, unitId, "gsd_task_reopen")
+  );
+}
+
+function completeSliceReplanSignalDetected(
+  s: AutoSession,
+  agentEndMessages: unknown[] | undefined,
+): boolean {
+  if (s.currentUnit?.type !== "complete-slice") return false;
+  return (
     agentEndMessagesIncludeSuccessfulToolResult(agentEndMessages, "gsd_replan_slice") ||
     agentEndMessagesIncludeToolCall(agentEndMessages, "gsd_replan_slice") ||
     agentEndMessagesMentionTool(agentEndMessages, "gsd_replan_slice") ||
-    unitActivityMentionsTool(s.basePath, unitType, unitId, "gsd_replan_slice") ||
-    unitActivityMentionsTool(s.canonicalProjectRoot, unitType, unitId, "gsd_replan_slice")
+    unitActivityMentionsTool(s.basePath, s.currentUnit.type, s.currentUnit.id, "gsd_replan_slice") ||
+    unitActivityMentionsTool(s.canonicalProjectRoot, s.currentUnit.type, s.currentUnit.id, "gsd_replan_slice")
+  );
+}
+
+function completeSliceValidReplanOutcomeDetected(
+  s: AutoSession,
+  agentEndMessages: unknown[] | undefined,
+): boolean {
+  if (s.currentUnit?.type !== "complete-slice") return false;
+  const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
+  if (!mid || !sid) return false;
+
+  if (!completeSliceReplanSignalDetected(s, agentEndMessages)) return false;
+
+  const replanPath = resolveSliceFile(s.basePath, mid, sid, "REPLAN");
+  const canonicalReplanPath = resolveSliceFile(s.canonicalProjectRoot, mid, sid, "REPLAN");
+  const hasReplanArtifact = (
+    Boolean(replanPath && existsSync(replanPath)) ||
+    Boolean(canonicalReplanPath && existsSync(canonicalReplanPath))
   );
+  if (!hasReplanArtifact) return false;
+
+  if (!isDbAvailable()) return true;
+  const slice = getSlice(mid, sid);
+  return Boolean(slice && !isClosedStatus(slice.status));
 }
 
 function formatPreExecutionCheckDetail(check: PreExecutionCheckJSON): string {
@@ -469,12 +522,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 +1496,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 +1638,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
@@ -1777,7 +1824,29 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
           "warning",
         );
         return "continue";
-      } else if (!triggerArtifactVerified && !isDbAvailable()) {
+      } else if (
+        !triggerArtifactVerified &&
+        completeSliceValidReplanOutcomeDetected(s, opts?.agentEndMessages)
+      ) {
+        const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
+        s.pendingVerificationRetry = null;
+        s.verificationRetryCount.delete(retryKey);
+        s.verificationRetryFailureHashes.delete(retryKey);
+        debugLog("postUnit", {
+          phase: "artifact-verify-complete-slice-replan-outcome",
+          unitType: s.currentUnit.type,
+          unitId: s.currentUnit.id,
+        });
+        ctx.ui.notify(
+          `complete-slice ${s.currentUnit.id} produced a valid replan outcome; continuing orchestration instead of retrying closeout.`,
+          "warning",
+        );
+        return "continue";
+      } else if (
+        !triggerArtifactVerified &&
+        !isDbAvailable() &&
+        !completeSliceReplanSignalDetected(s, opts?.agentEndMessages)
+      ) {
         debugLog("postUnit", { phase: "artifact-verify-skip-db-unavailable", unitType: s.currentUnit.type, unitId: s.currentUnit.id });
         const dbSkipDiag = diagnoseExpectedArtifact(s.currentUnit.type, s.currentUnit.id, verificationBasePath);
         ctx.ui.notify(
@@ -1860,8 +1929,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 +2109,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 {

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

@@ -413,22 +413,25 @@ export function verifyExpectedArtifact(
       return true;
     }
 
-    const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
+    const roadmapFile = resolveExpectedArtifactPath("plan-milestone", mid, base);
     if (!roadmapFile || !existsSync(roadmapFile)) {
       logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap missing`);
       return false;
     }
     try {
       const roadmap = parseLegacyRoadmap(readFileSync(roadmapFile, "utf-8"));
-      const milestoneResearchFile = resolveMilestoneFile(base, mid, "RESEARCH");
+      const milestoneResearchFile = resolveExpectedArtifactPath("research-milestone", mid, base);
+      const hasMilestoneResearch = !!milestoneResearchFile && existsSync(milestoneResearchFile);
       for (const slice of roadmap.slices) {
         if (slice.done) continue;
-        if (milestoneResearchFile && slice.id === "S01") continue;
-        const depsComplete = (slice.depends ?? []).every((depId) =>
-          !!resolveSliceFile(base, mid, depId, "SUMMARY"),
-        );
+        if (hasMilestoneResearch && slice.id === "S01") continue;
+        const depsComplete = (slice.depends ?? []).every((depId) => {
+          const summaryPath = resolveExpectedArtifactPath("complete-slice", `${mid}/${depId}`, base);
+          return !!summaryPath && existsSync(summaryPath);
+        });
         if (!depsComplete) continue;
-        if (!resolveSliceFile(base, mid, slice.id, "RESEARCH")) {
+        const researchPath = resolveExpectedArtifactPath("research-slice", `${mid}/${slice.id}`, base);
+        if (!researchPath || !existsSync(researchPath)) {
           logWarning("recovery", `verify-fail ${unitType} ${unitId}: slice ${slice.id} missing RESEARCH`);
           return false;
         }