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

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -7,6 +7,7 @@ import { logWarning } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
 import { readUnitRuntimeRecord } 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;
 const WAKEUP_SLEEP_CHUNK_MS = 1_000;
@@ -123,6 +124,10 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
             };
         }
     }
+    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.
@@ -134,6 +139,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const pendingSwitchCancellation = _consumePendingSwitchCancellation();
     if (pendingSwitchCancellation) {
         _clearCurrentResolve();
+        setVisibleSkills?.(undefined);
         return {
             status: "cancelled",
             ...(pendingSwitchCancellation.errorContext ? { errorContext: pendingSwitchCancellation.errorContext } : {}),
@@ -156,6 +162,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
             }
             if (!ready) {
                 _clearCurrentResolve();
+                setVisibleSkills?.(undefined);
                 return {
                     status: "cancelled",
                     errorContext: {
@@ -290,6 +297,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
         if (unitTimeoutHandle)
             clearTimeout(unitTimeoutHandle);
         ctx.ui.setWorkingMessage?.(undefined);
+        setVisibleSkills?.(undefined);
     }
     debugLog("runUnit", {
         phase: "agent-end-received",

package/dist/resources/extensions/gsd/auto/session.js

@@ -132,6 +132,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 = null;
     /** Project-root dirty snapshot captured before an isolated worktree unit runs. */
     rootWriteBaseline = null;
     // ── Merge guard ──────────────────────────────────────────────────────
@@ -285,6 +287,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/dist/resources/extensions/gsd/auto-dispatch.js

@@ -33,6 +33,11 @@ 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";
+function resolveExistingExpectedArtifact(unitType, unitId, basePath) {
+    const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
+    return artifactPath && existsSync(artifactPath) ? artifactPath : null;
+}
 let reassessmentChecker = checkNeedsReassessment;
 let researchProjectPromptBuilder = buildResearchProjectPrompt;
 function shouldBypassMilestoneDepthGateInAuto(prefs) {
@@ -808,13 +813,15 @@ export const DISPATCH_RULES = [
             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 = [];
             for (const slice of roadmap.slices) {
                 if (slice.done)
@@ -823,10 +830,10 @@ export const DISPATCH_RULES = [
                 if (milestoneResearchFile && slice.id === "S01")
                     continue;
                 // Skip if already has research
-                if (resolveSliceFile(basePath, mid, slice.id, "RESEARCH"))
+                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"));
+                const depsComplete = (slice.depends ?? []).every((depId) => !!resolveExistingExpectedArtifact("complete-slice", `${mid}/${depId}`, basePath));
                 if (!depsComplete)
                     continue;
                 researchReadySlices.push({ id: slice.id, title: slice.title });
@@ -837,7 +844,8 @@ export const DISPATCH_RULES = [
             // #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 {
@@ -863,12 +871,14 @@ export const DISPATCH_RULES = [
                 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 {

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -74,6 +74,15 @@ const MAX_VERIFICATION_RETRIES = 3;
 /** Keep failure toasts short while still showing concrete examples. */
 const MAX_NOTIFICATION_DETAILS = 3;
 const NOTIFICATION_BULLET = "•";
+function isParallelResearchUnit(unitType, unitId) {
+    return unitType === "research-slice" && unitId.endsWith("/parallel-research");
+}
+export function maybeWriteParallelResearchCostSpikeBlocker(unitType, unitId, basePath, unitCostUsd, rollingAvgUsd) {
+    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) {
     return uokFlags.gitops ? uokFlags.gitopsTurnAction : null;
 }
@@ -1360,7 +1369,7 @@ export async function postUnitPreVerification(pctx, opts) {
             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
@@ -1582,7 +1591,10 @@ export async function postUnitPreVerification(pctx, opts) {
                             ctx.ui.notify(`Unit ${s.currentUnit.id} cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}) after state advanced; continuing closeout.`, "warning");
                             return "continue";
                         }
-                        ctx.ui.notify(`Unit ${s.currentUnit.id} cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}) — pausing auto-mode.`, "error");
+                        const parallelBlocker = maybeWriteParallelResearchCostSpikeBlocker(s.currentUnit.type, s.currentUnit.id, verificationBasePath, unitCostUsd, rollingAvgUsd);
+                        ctx.ui.notify(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);
                         return "dispatched";
                     }
@@ -1712,6 +1724,10 @@ export async function postUnitPostVerification(pctx) {
             const trigger = consumeRetryTrigger();
             if (trigger) {
                 ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting task state.`, "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/dist/resources/extensions/gsd/auto-prompts.js

@@ -7,15 +7,14 @@
  * state, no globals — every dependency is passed as a parameter or imported as a
  * utility.
  */
-import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
+import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection } from "./files.js";
 import { hasVerdict, getUatType, extractVerdict } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, 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 { getLoadedSkills } from "@gsd/pi-coding-agent";
-import { join, basename } from "node:path";
+import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
 import { getPendingGatesForTurn } from "./gsd-db.js";
@@ -27,10 +26,11 @@ 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 } 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 ─────────────────────────────────────────────────────────────
 /**
  * Static ceiling for the preamble cap. Kept as an upper bound even
@@ -1033,237 +1033,6 @@ export async function inlineRoadmapExcerpt(base, mid, sid) {
         return null;
     return `### Milestone Roadmap (excerpt)\nSource: \`${roadmapRel}\`\n\n${excerpt}`;
 }
-// ─── Skill Activation & Discovery ─────────────────────────────────────────
-function normalizeSkillReference(ref) {
-    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) {
-    const tokens = new Set();
-    const addVariants = (raw) => {
-        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, contextTokens) {
-    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, base) {
-    if (refs.length === 0)
-        return [];
-    const prefs = { 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, contextTokens) {
-    const whenTokens = tokenizeSkillContext(when);
-    return [...whenTokens].some(token => contextTokens.has(token) || [...contextTokens].some(ctx => ctx.includes(token) || token.includes(ctx)));
-}
-function resolveSkillRuleMatches(prefs, contextTokens, base) {
-    if (!prefs?.skill_rules?.length)
-        return { include: [], avoid: [] };
-    const include = [];
-    const avoid = [];
-    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, visibleSkills, contextTokens, base) {
-    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) {
-    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, skillNames) {
-    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) {
-    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();
-    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() {
-    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, heading) {
     const match = new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "m").exec(content);

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -352,23 +352,28 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         if (blockerPath && existsSync(blockerPath)) {
             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")
+                if (hasMilestoneResearch && slice.id === "S01")
                     continue;
-                const depsComplete = (slice.depends ?? []).every((depId) => !!resolveSliceFile(base, mid, depId, "SUMMARY"));
+                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;
                 }