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

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

@@ -37,7 +37,7 @@ import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures
 import { debugLog } from "./debug-logger.js";
 import { runSafely } from "./auto-utils.js";
 import { isMilestoneCloseoutSettled, runMilestoneCloseoutGitHub, } from "./milestone-closeout.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 } from "./safety/evidence-cross-ref.js";
 import { validateContent } from "./safety/content-validator.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;
 }
@@ -170,12 +179,35 @@ function completeSliceReopenReplanHandoffDetected(s, agentEndMessages) {
         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") ||
-        agentEndMessagesIncludeSuccessfulToolResult(agentEndMessages, "gsd_replan_slice") ||
+        unitActivityMentionsTool(s.canonicalProjectRoot, unitType, unitId, "gsd_task_reopen"));
+}
+function completeSliceReplanSignalDetected(s, agentEndMessages) {
+    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, agentEndMessages) {
+    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) {
     const category = check.category?.trim() || "unknown category";
@@ -396,12 +428,6 @@ export function _shouldDispatchQuickTaskForTest(state) {
         !!state.currentUnit &&
         state.currentUnit.type !== "quick-task";
 }
-function isExecutionToolName(name) {
-    if (typeof name !== "string")
-        return false;
-    const normalized = name.trim().toLowerCase();
-    return normalized === "bash" || normalized === "gsd_exec";
-}
 export function _hasExecutionToolCallsInSessionForTest(entries) {
     for (const entry of entries) {
         const e = entry;
@@ -1235,8 +1261,8 @@ export async function postUnitPreVerification(pctx, opts) {
                                         });
                                     }
                                     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");
                                     }
                                 }
                                 const blockingMismatch = mismatches.find((mismatch) => mismatch.severity === "error");
@@ -1360,7 +1386,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
@@ -1518,7 +1544,23 @@ export async function postUnitPreVerification(pctx, opts) {
                 ctx.ui.notify(`complete-slice ${s.currentUnit.id} intentionally handed off via reopen/replan; continuing orchestration instead of retrying closeout.`, "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(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — DB unavailable, skipping retry.${dbSkipDiag ? ` Expected: ${dbSkipDiag}` : ""}`, "error");
@@ -1582,7 +1624,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 +1757,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;
                 }