gsd-pi 2.80.0-dev.c5f2443b3 → 2.80.0-dev.d4fc28e6b

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

@@ -6,7 +6,7 @@
  * utility.
  */
 import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
-import { hasVerdict, getUatType } from "./verdict-parser.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";
@@ -21,18 +21,20 @@ import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { composeContextModeInstructions, composeInlinedContext } from "./unit-context-composer.js";
+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";
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 /**
- * Historical static ceiling for the preamble cap. Kept as an upper bound even
+ * Static ceiling for the preamble cap. Kept as an upper bound even
  * after context-window-aware sizing so large-window users don't suddenly see
- * 10× looser caps than before. Small-window users get a tighter cap derived
+ * 10× looser caps than needed. Small-window users get a tighter cap derived
  * from their configured executor window.
  */
-const MAX_PREAMBLE_CHARS = 30_000;
+const MAX_PREAMBLE_CHARS = 20_000;
 /**
  * Resolve prompt budgets from the configured executor context window.
  *
@@ -62,9 +64,107 @@ function resolvePromptBudgets() {
 function resolveSummaryBudgetChars() {
     return resolvePromptBudgets().summaryBudgetChars;
 }
+function formatProjectClassificationForPlanning(classification) {
+    const sampleFiles = classification.contentFiles.slice(0, 8);
+    const sample = sampleFiles.length > 0 ? sampleFiles.map((file) => `\`${file}\``).join(", ") : "(none)";
+    const lines = [
+        "### Project Classification",
+        "",
+        `- **Kind:** ${classification.kind}`,
+        `- **Content files:** ${classification.contentFiles.length}`,
+        `- **Sample files:** ${sample}`,
+        `- **Reason:** ${classification.reason}`,
+        "",
+    ];
+    if (classification.kind === "untyped-existing") {
+        if (classification.contentFiles.length <= 2) {
+            lines.push("**Workflow sizing:** This is a tiny existing untyped project. Prefer exactly one slice unless the milestone request clearly spans multiple independent user-visible capabilities.");
+        }
+        else if (classification.contentFiles.length <= 5) {
+            lines.push("**Workflow sizing:** This is a small existing untyped project. Prefer 1-2 slices unless the milestone request clearly spans multiple independent user-visible capabilities.");
+        }
+        else {
+            lines.push("**Workflow sizing:** Existing untyped project. Use generic file-level workflow guidance and size slices by real capability boundaries, not by missing tooling markers.");
+        }
+    }
+    else if (classification.kind === "greenfield") {
+        lines.push("**Workflow sizing:** No project content exists yet. Use normal greenfield sizing for the requested scope.");
+    }
+    else if (classification.kind === "typed-existing") {
+        lines.push("**Workflow sizing:** Known project markers exist. Use normal ecosystem-aware planning guidance.");
+    }
+    else {
+        lines.push("**Workflow sizing:** Invalid repository state. Planning should surface this as a blocker rather than inventing project structure.");
+    }
+    return lines.join("\n");
+}
+function normalizeArtifactRef(value) {
+    return value.trim().replace(/^[-\s]+/, "").replace(/^["'`]+|["'`]+$/g, "").replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function parseCoveredArtifacts(validationContent) {
+    const covered = new Set();
+    const lines = validationContent.split(/\r?\n/);
+    let inCoveredArtifacts = false;
+    for (const line of lines) {
+        if (/^\s*covered[-_]?artifacts\s*:/i.test(line)) {
+            inCoveredArtifacts = true;
+            const inline = line.split(/covered[-_]?artifacts\s*:/i)[1]?.trim();
+            if (inline && inline !== "[]") {
+                inline.replace(/^\[|\]$/g, "").split(",").map(normalizeArtifactRef).filter(Boolean).forEach((item) => covered.add(item));
+            }
+            continue;
+        }
+        if (!inCoveredArtifacts)
+            continue;
+        if (/^\S/.test(line) && !/^\s*-/.test(line))
+            break;
+        const item = line.match(/^\s*-\s*(.+)$/)?.[1];
+        if (item)
+            covered.add(normalizeArtifactRef(item));
+    }
+    return covered;
+}
+function isValidationFreshOrApplicable(validationContent, currentArtifacts) {
+    if (!validationContent)
+        return false;
+    if (!/validation_metadata:/i.test(validationContent))
+        return false;
+    const coveredArtifacts = parseCoveredArtifacts(validationContent);
+    if (coveredArtifacts.size === 0)
+        return false;
+    return currentArtifacts
+        .map(normalizeArtifactRef)
+        .filter(Boolean)
+        .every((artifact) => coveredArtifacts.has(artifact));
+}
+function formatCloseoutReviewInstructions(validationContent, validationRel, currentArtifacts) {
+    const verdict = validationContent ? extractVerdict(validationContent) : null;
+    const validationFresh = isValidationFreshOrApplicable(validationContent, currentArtifacts);
+    if (verdict === "pass" && validationFresh) {
+        return [
+            "### Passing Validation Artifact",
+            "",
+            `A passing validation artifact is present at \`${validationRel}\`. Treat it as authoritative for success criteria, requirement coverage, verification classes, and cross-slice integration.`,
+            "",
+            "Do not delegate fresh reviewer/security/tester audits and do not redo the validation evidence review unless the artifact is internally inconsistent with the inlined summaries. Focus this unit on final milestone narrative, learnings, PROJECT/requirements updates, and `gsd_complete_milestone`.",
+        ].join("\n");
+    }
+    if (verdict) {
+        return [
+            "### Validation Requires Attention",
+            "",
+            `A validation artifact is present at \`${validationRel}\` with verdict \`${verdict}\`, but it is missing freshness metadata or does not cover current milestone artifacts. Do not treat the milestone as complete unless the issues are resolved and evidence supports completion.`,
+        ].join("\n");
+    }
+    return [
+        "### No Passing Validation Artifact",
+        "",
+        `No passing validation artifact was found at \`${validationRel}\`. Use the full closeout review path before completion.`,
+    ].join("\n");
+}
 function capPreamble(preamble) {
-    // Cap inlined context at min(historical 30K ceiling, scaled inline budget).
-    // The ceiling preserves pre-fix behavior for large-window users; the scaled
+    // Cap inlined context at min(static ceiling, scaled inline budget).
+    // The ceiling bounds repeated auto prompt payloads; the scaled
     // budget tightens the cap for small-window users whose true safe limit is
     // below 30K. `computeBudgets` allocates 40% of total chars to inline context.
     const budget = Math.min(MAX_PREAMBLE_CHARS, resolvePromptBudgets().inlineContextBudgetChars);
@@ -79,8 +179,19 @@ function renderContextModeForPrompt(unitType, base, renderMode = "standalone") {
         renderMode,
     });
 }
-function prependContextModeToBlock(unitType, base, block, renderMode = "standalone") {
+function renderContextModeBlockForPrompt(unitType, base, renderMode = "standalone") {
     const contextMode = renderContextModeForPrompt(unitType, base, renderMode);
+    if (!contextMode)
+        return "";
+    if (renderMode === "nested")
+        return contextMode;
+    const snapshot = readCompactionSnapshot(base);
+    if (!snapshot?.trim())
+        return contextMode;
+    return `${contextMode}\n\n## Context Snapshot\nSource: \`.gsd/last-snapshot.md\`\n\n${snapshot.trimEnd()}`;
+}
+function prependContextModeToBlock(unitType, base, block, renderMode = "standalone") {
+    const contextMode = renderContextModeBlockForPrompt(unitType, base, renderMode);
     if (!contextMode)
         return block;
     if (!block.trim())
@@ -460,9 +571,77 @@ export async function buildSliceSummaryExcerpt(absPath, relPath, sid) {
     }
     catch {
         // Defensive — any parse failure falls back to full inline.
-        return `### ${sid} Summary\nSource: \`${relPath}\`\n\n${content.trim()}`;
+        return `### ${sid} Summary\nSource: \`${relPath}\`\n\n${capMalformedSummary(content, relPath)}`;
     }
 }
+export async function buildTaskSummaryExcerpt(absPath, relPath, tid, options) {
+    const label = options?.blocker ? "Blocker Task Summary" : "Task Summary";
+    const header = `### ${label}: ${tid} (excerpt)\nSource: \`${relPath}\``;
+    const content = absPath ? await loadFile(absPath) : null;
+    if (!content) {
+        return `${header}\n\n_(not found — file does not exist yet)_`;
+    }
+    try {
+        const s = parseSummary(content);
+        if (!s.frontmatter.id) {
+            return `### ${label}: ${tid}\nSource: \`${relPath}\`\n\n${capMalformedSummary(content, relPath)}`;
+        }
+        const lines = [header, ""];
+        if (s.title)
+            lines.push(`**Title:** ${s.title}`);
+        if (s.oneLiner)
+            lines.push(`**One-liner:** ${s.oneLiner}`);
+        if (s.frontmatter.verification_result) {
+            lines.push(`**Verification:** \`${s.frontmatter.verification_result}\``);
+        }
+        lines.push(`**Blocker discovered:** ${s.frontmatter.blocker_discovered ? "yes — read full summary if blocker details are insufficient" : "no"}`);
+        if (s.frontmatter.provides.length > 0)
+            lines.push(`**Provides:** ${s.frontmatter.provides.slice(0, 4).join("; ")}`);
+        if (s.frontmatter.key_decisions.length > 0)
+            lines.push(`**Key decisions:** ${s.frontmatter.key_decisions.slice(0, 4).join("; ")}`);
+        if (s.frontmatter.patterns_established.length > 0)
+            lines.push(`**Patterns established:** ${s.frontmatter.patterns_established.slice(0, 4).join("; ")}`);
+        if (s.frontmatter.key_files.length > 0) {
+            const files = s.frontmatter.key_files.slice(0, 6);
+            const more = s.frontmatter.key_files.length > files.length ? ` (+${s.frontmatter.key_files.length - files.length} more)` : "";
+            lines.push(`**Key files:** ${files.join(", ")}${more}`);
+        }
+        const SECTION_CAP_CHARS = 500;
+        const capSection = (body) => {
+            const trimmed = body.trim();
+            if (trimmed.length <= SECTION_CAP_CHARS)
+                return trimmed;
+            return `${trimmed.slice(0, SECTION_CAP_CHARS)}\n… (truncated — see full \`${relPath}\`)`;
+        };
+        const verification = extractMarkdownSection(content, "Verification");
+        const diagnostics = extractMarkdownSection(content, "Diagnostics");
+        const knownIssues = extractMarkdownSection(content, "Known Issues");
+        if (verification && verification.trim()) {
+            lines.push("", "#### Verification", capSection(verification));
+        }
+        if (diagnostics && diagnostics.trim()) {
+            lines.push("", "#### Diagnostics", capSection(diagnostics));
+        }
+        if (s.deviations && s.deviations.trim()) {
+            lines.push("", "#### Deviations", capSection(s.deviations));
+        }
+        if (knownIssues && knownIssues.trim()) {
+            lines.push("", "#### Known issues", capSection(knownIssues));
+        }
+        lines.push("", `> **On-demand:** read \`${relPath}\` only when this excerpt is absent/truncated or you need fuller blocker, implementation, or file-change evidence.`);
+        return lines.join("\n");
+    }
+    catch {
+        return `### ${label}: ${tid}\nSource: \`${relPath}\`\n\n${capMalformedSummary(content, relPath)}`;
+    }
+}
+function capMalformedSummary(content, relPath) {
+    const trimmed = content.trim();
+    const limit = 1_500;
+    if (trimmed.length <= limit)
+        return trimmed;
+    return `${trimmed.slice(0, limit).trimEnd()}\n\n[Truncated malformed summary — read \`${relPath}\` for full details.]`;
+}
 /**
  * Load and inline dependency slice summaries (full content, not just paths).
  */
@@ -715,12 +894,12 @@ export async function inlineKnowledgeScoped(base, keywords) {
  * plan-milestone, complete-slice, complete-milestone, validate-milestone,
  * reassess-roadmap) previously injected the full KNOWLEDGE.md (~226KB for a
  * real project) on every invocation. This helper scopes by caller-supplied
- * keywords and caps the payload at `maxChars` (default 30,000 chars).
+ * keywords and caps the payload at `maxChars` (default 12,000 chars).
  *
  * Returns null when no KNOWLEDGE.md exists or no entries match any keyword.
  */
 export async function inlineKnowledgeBudgeted(base, keywords, options) {
-    const DEFAULT_MAX_CHARS = 30_000;
+    const DEFAULT_MAX_CHARS = 12_000;
     const HARD_MAX_CHARS = 100_000;
     const raw = Number(options?.maxChars ?? DEFAULT_MAX_CHARS);
     const maxChars = Number.isFinite(raw)
@@ -1465,6 +1644,7 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
     const researchAnchor = readPhaseAnchor(base, mid, "research-milestone");
     if (researchAnchor)
         inlined.push(formatAnchorForPrompt(researchAnchor));
+    inlined.push(formatProjectClassificationForPlanning(classifyProject(base)));
     inlined.push(await inlineFile(contextPath, contextRel, "Milestone Context"));
     const researchInline = await inlineFileOptional(researchPath, researchRel, "Milestone Research");
     if (researchInline)
@@ -1712,8 +1892,17 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
             `The previous plan-slice attempt was blocked by pre-execution validation.\n` +
             `Gate verdict: ${verdictExcerpt}\n\n` +
             `Blocked references that must be resolved in this plan:\n${findingsList}\n\n` +
-            `Revise the plan so that every reference listed above is satisfied before execution begins. ` +
-            `Do not reproduce the same file paths, package names, or task ordering that caused these failures.`);
+            `**How to fix each type of issue:**\n` +
+            `- **"[file] X doesn't exist and isn't created by prior or same-task outputs"**: ` +
+            `Either (a) add an earlier task that creates X on disk before the task that needs it, ` +
+            `or (b) if this task IS the one that creates X, move X from inputs to expected_output. ` +
+            `Do NOT put X in a task's expected_output if that task only reads or verifies X — only tasks that actually write X to disk should list it in expected_output.\n` +
+            `- **"[file] X: Task T_early reads X but it's created by task T_late (sequence violation)"**: ` +
+            `Either (a) reorder tasks so T_late (the creator) runs before T_early (the reader), ` +
+            `or (b) if T_late doesn't actually create X (it only reads/tests it), remove X from T_late's expected_output entirely.\n` +
+            `- **"[package] P not found on npm"**: Either remove the npm install for P, or use the correct package name.\n\n` +
+            `Every file listed in a task's inputs must either exist on disk already or appear in an earlier task's expected_output. ` +
+            `A task's expected_output must only list files it actually writes to disk.`);
     }
     return renderSlicePrompt({
         mid, sid, sTitle, base,
@@ -1936,11 +2125,9 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
                 const blocks = [];
                 for (const file of summaryFiles) {
                     const absPath = join(tDir, file);
-                    const content = await loadFile(absPath);
-                    if (!content)
-                        continue;
                     const relPath = `${sRel}/tasks/${file}`;
-                    blocks.push(`### Task Summary: ${file.replace(/-SUMMARY\.md$/i, "")}\nSource: \`${relPath}\`\n\n${content.trim()}`);
+                    const taskId = file.replace(/-SUMMARY\.md$/i, "");
+                    blocks.push(await buildTaskSummaryExcerpt(absPath, relPath, taskId));
                 }
                 return blocks.length > 0 ? blocks.join("\n\n---\n\n") : null;
             }
@@ -2017,6 +2204,9 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     const inlineLevel = level ?? resolveInlineLevel();
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
+    const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
+    const validationRel = relMilestoneFile(base, mid, "VALIDATION");
+    const validationContent = validationPath ? await loadFile(validationPath) : null;
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
     // Inline all slice summaries (deduplicated by slice ID)
@@ -2056,6 +2246,13 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
         const pathList = summaryRelPaths.map(p => `- \`${p}\``).join("\n");
         inlined.push(`### On-demand Slice Summaries\n\nExcerpted above. Read the full file for any slice when the excerpt's section heads don't carry enough narrative for the milestone summary you're drafting:\n\n${pathList}`);
     }
+    const validationContext = [
+        formatCloseoutReviewInstructions(validationContent, validationRel, [validationRel, roadmapRel, ...summaryRelPaths]),
+    ];
+    if (validationContent) {
+        validationContext.push(`### Milestone Validation\nSource: \`${validationRel}\`\n\n${validationContent.trim()}`);
+    }
+    inlined.unshift(...validationContext);
     // Inline root GSD files (skip for minimal — completion can read these if needed)
     if (inlineLevel !== "minimal") {
         const requirementsInline = await inlineRequirementsFromDb(base, mid, undefined, inlineLevel);
@@ -2277,7 +2474,7 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
             const relPath = `${sRel}/tasks/${file}`;
             if (summary.frontmatter.blocker_discovered) {
                 blockerTaskId = summary.frontmatter.id || file.replace(/-SUMMARY\.md$/i, "");
-                inlined.push(`### Blocker Task Summary: ${blockerTaskId}\nSource: \`${relPath}\`\n\n${content.trim()}`);
+                inlined.push(await buildTaskSummaryExcerpt(absPath, relPath, blockerTaskId, { blocker: true }));
             }
         }
     }

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

@@ -12,7 +12,7 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -30,7 +30,49 @@ import { getProjectResearchStatus } from "./project-research-policy.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
-// ─── Artifact Resolution & Verification ───────────────────────────────────────
+export function refreshRecoveryDbForArtifact(unitType, unitId) {
+    if (unitType !== "plan-slice" && unitType !== "execute-task")
+        return { ok: true };
+    if (!isDbAvailable())
+        return { ok: true };
+    if (!refreshOpenDatabaseFromDisk()) {
+        return {
+            ok: false,
+            fatal: unitType === "execute-task",
+            reason: `${unitType}-db-refresh-failed`,
+            message: `Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed.`,
+        };
+    }
+    if (unitType !== "execute-task")
+        return { ok: true };
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (!mid || !sid || !tid) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-invalid-unit-id",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but the unit id could not be parsed for DB verification.`,
+        };
+    }
+    const task = getTask(mid, sid, tid);
+    if (!task) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-artifact-db-missing",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but no matching DB task row exists after refresh.`,
+        };
+    }
+    if (!isClosedStatus(task.status)) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-artifact-db-mismatch",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but the DB task status is still '${task.status}' after refresh.`,
+        };
+    }
+    return { ok: true };
+}
 function hasCapturedWorkflowPrefs(base) {
     const prefsPath = resolveExpectedArtifactPath("workflow-preferences", "WORKFLOW-PREFS", base);
     if (!prefsPath || !existsSync(prefsPath))
@@ -110,17 +152,32 @@ export function hasImplementationArtifacts(basePath, milestoneId) {
         // milestone commits instead of treating the self-diff as proof of no work.
         if (changedFiles.length === 0) {
             if (milestoneId && currentBranch === integrationBranch) {
-                const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
-                if (!tagged.ok)
+                const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+                if (!milestoneEvidence.ok)
                     return "unknown";
-                if (tagged.matched)
-                    return classifyImplementationFiles(tagged.files);
+                if (milestoneEvidence.matched)
+                    return classifyImplementationFiles(milestoneEvidence.files);
             }
             if (currentBranch && currentBranch !== "HEAD")
                 return "absent";
             return "unknown";
         }
-        return classifyImplementationFiles(changedFiles);
+        const branchClassification = classifyImplementationFiles(changedFiles);
+        if (branchClassification === "present")
+            return "present";
+        // A completing milestone branch can have a non-empty diff containing only
+        // .gsd/ closeout files after implementation commits already landed on the
+        // recorded integration branch. In that topology, the branch diff alone is
+        // insufficient; use the same milestone-tagged evidence fallback as the
+        // self-diff retry path before declaring the milestone implementation-free.
+        if (milestoneId) {
+            const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+            if (!milestoneEvidence.ok)
+                return "unknown";
+            if (milestoneEvidence.matched)
+                return classifyImplementationFiles(milestoneEvidence.files);
+        }
+        return "absent";
     }
     catch (e) {
         // Non-fatal — if git operations fail, return unknown so callers can decide
@@ -148,6 +205,9 @@ function classifyImplementationFiles(files) {
 function isImplementationPath(file) {
     return !file.startsWith(".gsd/") && !file.startsWith(".gsd\\");
 }
+function normalizeRepoPath(file) {
+    return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
 /**
  * Detect the main/master branch name.
  */
@@ -217,7 +277,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     ]);
     if (!scoped.ok)
         return scoped;
-    if (scoped.matched)
+    if (scoped.matched && classifyImplementationFiles(scoped.files) === "present")
         return scoped;
     // Fallback (#5033): when .gsd/ is gitignored / external / untracked, the
     // path-scoped scan matches no commits even though GSD-tagged commits
@@ -228,9 +288,137 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // Intentionally unbounded — symmetric with the primary scan, and avoids
     // reintroducing the rolling-depth failure class removed in #4699 where
     // milestone evidence aged out behind unrelated activity.
-    return scanGsdTaggedCommits(basePath, milestoneId, [
+    const unscoped = scanGsdTaggedCommits(basePath, milestoneId, [
         "log", "--format=%H%x1f%B%x1e", "HEAD",
     ]);
+    if (!unscoped.ok)
+        return scoped.matched ? scoped : unscoped;
+    if (!unscoped.matched)
+        return scoped;
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...scoped.files, ...unscoped.files])],
+    };
+}
+function getChangedFilesFromMilestoneEvidence(basePath, milestoneId) {
+    const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
+    if (!tagged.ok)
+        return tagged;
+    if (tagged.matched && classifyImplementationFiles(tagged.files) === "present")
+        return tagged;
+    const attributed = getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId);
+    if (!attributed.ok)
+        return tagged.matched ? tagged : attributed;
+    if (attributed.matched && classifyImplementationFiles(attributed.files) === "present")
+        return attributed;
+    const backfilled = backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId);
+    if (!backfilled.ok)
+        return tagged.matched ? tagged : attributed.matched ? attributed : backfilled;
+    if (!backfilled.matched) {
+        if (tagged.matched)
+            return tagged;
+        return attributed.matched ? attributed : backfilled;
+    }
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...tagged.files, ...attributed.files, ...backfilled.files])],
+    };
+}
+function getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const shas = getMilestoneCommitAttributionShas(milestoneId);
+        if (shas.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const files = new Set();
+        let matched = false;
+        for (const sha of shas) {
+            if (!isFullCommitSha(sha))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, sha);
+            if (commitFiles.length === 0)
+                continue;
+            matched = true;
+            for (const file of commitFiles)
+                files.add(file);
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution scan failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const milestone = getMilestone(milestoneId);
+        const milestoneStartedAt = milestone?.created_at ? Math.floor(Date.parse(milestone.created_at) / 1000) * 1000 : NaN;
+        if (!Number.isFinite(milestoneStartedAt))
+            return { ok: true, matched: false, files: [] };
+        const taskFileHints = getCompletedMilestoneTaskFileHints(milestoneId);
+        if (taskFileHints.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const hintSet = new Set(taskFileHints.map(normalizeRepoPath).filter(Boolean));
+        if (hintSet.size === 0)
+            return { ok: true, matched: false, files: [] };
+        const records = getCommitRecords(basePath);
+        const files = new Set();
+        let matched = false;
+        for (const record of records) {
+            if (!isFullCommitSha(record.hash))
+                continue;
+            if (Date.parse(record.committedAt) < milestoneStartedAt)
+                continue;
+            if (record.parents.trim().split(/\s+/).filter(Boolean).length > 1)
+                continue;
+            if (commitMessageHasGsdTrailer(record.message))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, record.hash);
+            const implementationFiles = commitFiles.map(normalizeRepoPath).filter(isImplementationPath);
+            if (implementationFiles.length === 0)
+                continue;
+            if (!implementationFiles.some((file) => hintSet.has(file)))
+                continue;
+            matched = true;
+            for (const file of implementationFiles)
+                files.add(file);
+            recordMilestoneCommitAttribution({
+                commitSha: record.hash,
+                milestoneId,
+                source: "backfill",
+                confidence: 0.8,
+                files: implementationFiles,
+                createdAt: new Date().toISOString(),
+            });
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution backfill failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function getCommitRecords(basePath) {
+    const logOutput = execFileSync("git", ["log", "--format=%H%x1f%P%x1f%cI%x1f%B%x1e", "HEAD"], {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+    });
+    return logOutput
+        .split("\x1e")
+        .map((record) => record.trim())
+        .filter(Boolean)
+        .flatMap((record) => {
+        const parts = record.split("\x1f");
+        if (parts.length < 4)
+            return [];
+        const [hash, parents, committedAt, ...messageParts] = parts;
+        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message: messageParts.join("\x1f") }];
+    });
+}
+function isFullCommitSha(value) {
+    return /^[0-9a-f]{40}$/i.test(value);
 }
 function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
     try {