@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

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

@@ -17,7 +17,7 @@ import { logWarning, logError } from "./workflow-logger.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { isAwaitingUserInput } from "./consent-question.js";
-import { resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
+import { resolveSliceFile, resolveSlicePath, relSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, resolveFile, relMilestoneFile, relSliceFile, relTaskFile, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
@@ -187,7 +187,6 @@ function completeSliceReopenReplanHandoffDetected(s, agentEndMessages) {
     const unitId = s.currentUnit.id;
     return (agentEndMessagesIncludeSuccessfulToolResult(agentEndMessages, "gsd_task_reopen") ||
         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"));
 }
@@ -196,7 +195,6 @@ function completeSliceReplanSignalDetected(s, agentEndMessages) {
         return false;
     return (agentEndMessagesIncludeSuccessfulToolResult(agentEndMessages, "gsd_replan_slice") ||
         agentEndMessagesIncludeToolCall(agentEndMessages, "gsd_replan_slice") ||
-        agentEndMessagesMentionTool(agentEndMessages, "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"));
 }
@@ -359,6 +357,17 @@ function getPlannedKeyFiles(tasks) {
 }
 export const _parseReactiveBatchTaskIdsForTest = parseReactiveBatchTaskIds;
 export const _getPlannedKeyFilesForTest = getPlannedKeyFiles;
+function resolveTaskArtifactPath(basePath, mid, sid, tid, suffix) {
+    const legacy = resolveTaskFile(basePath, mid, sid, tid, suffix);
+    if (legacy)
+        return legacy;
+    const slicePath = resolveSlicePath(basePath, mid, sid);
+    if (!slicePath)
+        return null;
+    const taskDir = resolveTasksDir(basePath, mid, sid) ?? slicePath;
+    const file = resolveFile(taskDir, tid, suffix);
+    return file ? join(taskDir, file) : null;
+}
 function resolveVerificationFailureMarkerPath(unitType, unitId, basePath) {
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
@@ -366,22 +375,19 @@ function resolveVerificationFailureMarkerPath(unitType, unitId, basePath) {
             const existing = resolveMilestoneFile(basePath, mid, "VERIFICATION-FAILED");
             if (existing)
                 return existing;
-            const milestoneDir = resolveMilestonePath(basePath, mid);
-            return milestoneDir ? join(milestoneDir, `${mid}-VERIFICATION-FAILED.md`) : null;
+            return join(basePath, relMilestoneFile(basePath, mid, "VERIFICATION-FAILED"));
         }
         case "complete-slice": {
             const existing = resolveSliceFile(basePath, mid, sid, "VERIFICATION-FAILED");
             if (existing)
                 return existing;
-            const sliceDir = resolveSlicePath(basePath, mid, sid);
-            return sliceDir ? join(sliceDir, `${sid}-VERIFICATION-FAILED.md`) : null;
+            return join(basePath, relSliceFile(basePath, mid, sid, "VERIFICATION-FAILED"));
         }
         case "execute-task": {
-            const existing = resolveTaskFile(basePath, mid, sid, tid, "VERIFICATION-FAILED");
+            const existing = resolveTaskArtifactPath(basePath, mid, sid, tid, "VERIFICATION-FAILED");
             if (existing)
                 return existing;
-            const tasksDir = resolveTasksDir(basePath, mid, sid);
-            return tasksDir ? join(tasksDir, buildTaskFileName(tid, "VERIFICATION-FAILED")) : null;
+            return join(basePath, relTaskFile(basePath, mid, sid, tid, "VERIFICATION-FAILED"));
         }
         default:
             return null;
@@ -395,7 +401,7 @@ async function buildTaskCommitContextForUnit(basePath, unitId) {
     const slice = isDbAvailable() ? getSlice(mid, sid) : null;
     const task = isDbAvailable() ? getTask(mid, sid, tid) : null;
     let summary = null;
-    const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+    const summaryPath = resolveTaskArtifactPath(basePath, mid, sid, tid, "SUMMARY");
     if (summaryPath) {
         try {
             const summaryContent = await loadFile(summaryPath);
@@ -563,7 +569,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
     if (unitType === "execute-task") {
         if (!mid || !sid || !tid)
             return [];
-        const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+        const summaryPath = resolveTaskArtifactPath(basePath, mid, sid, tid, "SUMMARY");
         if (!summaryPath || !existsSync(summaryPath))
             return [];
         const dbRow = getTask(mid, sid, tid);
@@ -629,7 +635,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
     else if (unitType === "plan-task") {
         if (!mid || !sid || !tid)
             return [];
-        const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
+        const taskPlanPath = resolveTaskArtifactPath(basePath, mid, sid, tid, "PLAN");
         if (!taskPlanPath || !existsSync(taskPlanPath))
             return [];
         const dbRow = getTask(mid, sid, tid);
@@ -1717,7 +1723,10 @@ export async function postUnitPreVerification(pctx, opts) {
                         return "dispatched";
                     }
                     s.toolUnavailableRetries++;
-                    const delayMs = s.toolUnavailableRetries * 1000;
+                    // Exponential backoff starting at 10s (10s, 20s, 40s capped at 45s). MCP server
+                    // startup can take tens of seconds; a 1s/2s/3s linear delay re-dispatches before
+                    // the server finishes connecting, causing a stuck loop. See #817.
+                    const delayMs = Math.min(10_000 * Math.pow(2, s.toolUnavailableRetries - 1), 45_000);
                     debugLog("postUnit", { phase: "tool-unavailable-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, error: s.lastToolInvocationError, attempt: s.toolUnavailableRetries, delayMs });
                     ctx.ui.notify(`Tool unavailable for ${s.currentUnit.type}: ${s.lastToolInvocationError}. Waiting ${delayMs}ms for MCP server — retry ${s.toolUnavailableRetries}/${MAX_TOOL_UNAVAIL_RETRIES}.`, "warning");
                     s.lastToolInvocationError = null;
@@ -1825,7 +1834,7 @@ export async function postUnitPreVerification(pctx, opts) {
                     saveCustomVerifyRetryCounts(s, { logFailure: err => debugLog("postUnit", { phase: "save-verify-retries-failed", error: err instanceof Error ? err.message : String(err) }) });
                     s.pendingVerificationRetry = {
                         unitId: s.currentUnit.id,
-                        failureContext: `${failureDetails} (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
+                        failureContext: failureDetails,
                         attempt,
                     };
                     debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
@@ -1952,12 +1961,9 @@ export async function postUnitPostVerification(pctx) {
                     // 2. Delete SUMMARY.md for the task
                     if (mid && sid && tid) {
                         // Phase C: read+delete via canonical project root.
-                        const tasksDir = resolveTasksDir(s.canonicalProjectRoot, mid, sid);
-                        if (tasksDir) {
-                            const summaryFile = join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
-                            if (existsSync(summaryFile)) {
-                                unlinkSync(summaryFile);
-                            }
+                        const summaryPath = resolveTaskArtifactPath(s.canonicalProjectRoot, mid, sid, tid, "SUMMARY");
+                        if (summaryPath && existsSync(summaryPath)) {
+                            unlinkSync(summaryPath);
                         }
                     }
                     // 3. Delete the retry_on artifact (e.g. NEEDS-REWORK.md)
@@ -2089,7 +2095,7 @@ export async function postUnitPostVerification(pctx) {
                 // Write evidence JSON to slice artifacts directory
                 const slicePath = resolveSlicePath(s.canonicalProjectRoot, mid, sid);
                 const evidenceFileName = `${sid}-PRE-EXEC-VERIFY.json`;
-                let evidencePath = join(".gsd", "milestones", mid, "slices", sid, evidenceFileName);
+                let evidencePath = join(relSlicePath(s.canonicalProjectRoot, mid, sid), evidenceFileName);
                 if (slicePath) {
                     writePreExecutionEvidence(result, slicePath, mid, sid);
                     evidencePath = relative(s.canonicalProjectRoot, join(slicePath, evidenceFileName)) || evidenceFileName;

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

@@ -10,19 +10,21 @@
 import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection } from "./files.js";
 import { hasVerdict, 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 { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
+import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
 import { isContextModeEnabled } from "./preferences-types.js";
 import { parseRoadmap } from "./parsers-legacy.js";
-import { join } from "node:path";
+import { join, relative, sep } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
-import { getPendingGatesForTurn } from "./gsd-db.js";
+import { getGateResults, getPendingGatesForTurn } from "./gsd-db.js";
 import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { composeContextModeInstructions, composeContractedUnitContext, composeInlinedContext, composeToolSurfaceInstructions, composeUnitContext, } from "./unit-context-composer.js";
 import { resolveManifest } from "./unit-context-manifest.js";
+import { resolveSliceResearchLocation } from "./auto-artifact-paths.js";
 import { compileUnitContextContract } from "./tool-contract.js";
 import { readCompactionSnapshot } from "./compaction-snapshot.js";
 import { logWarning } from "./workflow-logger.js";
@@ -247,14 +249,21 @@ function requireComposedArtifactBlock(blocks, unitType, key) {
     return block.body;
 }
 function renderExecuteTaskOnDemandContext(base, mid, sid, artifacts) {
-    if (!artifacts.includes("slice-research"))
-        return "";
-    const researchPath = relSliceFile(base, mid, sid, "RESEARCH");
-    return [
-        "## On-demand Context",
-        "",
-        `Slice research is available at \`${researchPath}\`. Read it only if the inlined task plan, slice plan excerpt, and carry-forward context do not explain a required implementation detail.`,
-    ].join("\n");
+    if (!artifacts.includes("slice-research")) {
+        return { text: "", skipReason: "not declared by contract" };
+    }
+    const research = resolveSliceResearchLocation(base, mid, sid);
+    if (!research.absolutePath || !research.relativePath) {
+        return { text: "", skipReason: "missing" };
+    }
+    return {
+        text: [
+            "## On-demand Context",
+            "",
+            `Slice research is available at \`${research.relativePath}\`. Read it only if the inlined task plan, slice plan excerpt, and carry-forward context do not explain a required implementation detail.`,
+        ].join("\n"),
+        skipReason: null,
+    };
 }
 // ─── Executor Constraints ─────────────────────────────────────────────────────
 /**
@@ -287,6 +296,37 @@ function formatExecutorConstraints(sessionContextWindow, modelRegistry, sessionP
         `- Keep individual tasks completable within a single context window — if a task needs more context than fits, split it`,
     ].join("\n");
 }
+/**
+ * Builds the Declared Repositories block for parent-workspace planners.
+ * Returns "" for single-repo projects so the common-case prompt is unchanged;
+ * only parent mode with declared child repos gets the registry list and the
+ * targetRepositories assignment instruction.
+ */
+export function buildRepoRegistryBlock(base) {
+    let registry;
+    try {
+        registry = createRepositoryRegistryFromPreferences(base, loadEffectiveGSDPreferences(base)?.preferences);
+    }
+    catch {
+        return "";
+    }
+    const hasChildRepo = registry.repositories.some((repo) => repo.id !== "project");
+    if (registry.mode !== "parent" || !hasChildRepo)
+        return "";
+    const lines = registry.repositories.map((repo) => {
+        const relPath = relative(registry.projectRoot, repo.root).split(sep).join("/") || ".";
+        const role = repo.role ? ` — ${repo.role}` : "";
+        const root = repo.id === "project" ? " (root)" : ` (${relPath})`;
+        return `- \`${repo.id}\`${root}${role}`;
+    });
+    return [
+        "### Declared Repositories",
+        "",
+        ...lines,
+        "",
+        "This is a parent workspace. Assign each task's `targetRepositories` to the repository id(s) it touches (from the list above). Omit `targetRepositories` to inherit the slice-wide default from `gsd_plan_slice`; set it explicitly when a task differs (e.g. `[\"project\"]` for parent-root work).",
+    ].join("\n");
+}
 /**
  * Returns a markdown bullet list of known context file paths for the given
  * milestone (and optionally slice). Falls back to a generic tool-agnostic
@@ -1167,19 +1207,29 @@ export function extractSliceExecutionExcerpt(content, relPath) {
     return parts.join("\n");
 }
 // ─── Prior Task Summaries ──────────────────────────────────────────────────
-export async function getPriorTaskSummaryPaths(mid, sid, currentTid, base) {
+/** Resolve where task SUMMARY files live (legacy tasks/ subdir or flat-phase phase dir). */
+function resolveTaskSummariesLocation(base, mid, sid) {
+    const slicePath = resolveSlicePath(base, mid, sid);
+    if (!slicePath)
+        return null;
     const tDir = resolveTasksDir(base, mid, sid);
-    if (!tDir)
+    const sRel = relSlicePath(base, mid, sid);
+    if (tDir)
+        return { dir: tDir, relPrefix: `${sRel}/tasks` };
+    return { dir: slicePath, relPrefix: sRel };
+}
+export async function getPriorTaskSummaryPaths(mid, sid, currentTid, base) {
+    const loc = resolveTaskSummariesLocation(base, mid, sid);
+    if (!loc)
         return [];
-    const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
+    const summaryFiles = resolveTaskFiles(loc.dir, "SUMMARY");
     const currentNum = parseInt(currentTid.replace(/^T/, ""), 10);
-    const sRel = relSlicePath(base, mid, sid);
     return summaryFiles
         .filter(f => {
         const num = parseInt(f.replace(/^T/, ""), 10);
         return num < currentNum;
     })
-        .map(f => `${sRel}/tasks/${f}`);
+        .map(f => `${loc.relPrefix}/${f}`);
 }
 /**
  * Get carry-forward summary paths scoped to a task's derived dependencies.
@@ -1196,11 +1246,10 @@ export async function getDependencyTaskSummaryPaths(mid, sid, currentTid, depend
     if (dependsOn.length === 0) {
         return getPriorTaskSummaryPaths(mid, sid, currentTid, base);
     }
-    const tDir = resolveTasksDir(base, mid, sid);
-    if (!tDir)
+    const loc = resolveTaskSummariesLocation(base, mid, sid);
+    if (!loc)
         return [];
-    const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
-    const sRel = relSlicePath(base, mid, sid);
+    const summaryFiles = resolveTaskFiles(loc.dir, "SUMMARY");
     const depSet = new Set(dependsOn.map((d) => d.toUpperCase()));
     return summaryFiles
         .filter((f) => {
@@ -1208,7 +1257,7 @@ export async function getDependencyTaskSummaryPaths(mid, sid, currentTid, depend
         const tid = f.replace(/-SUMMARY\.md$/i, "").toUpperCase();
         return depSet.has(tid);
     })
-        .map((f) => `${sRel}/tasks/${f}`);
+        .map((f) => `${loc.relPrefix}/${f}`);
 }
 // ─── Adaptive Replanning Checks ────────────────────────────────────────────
 /**
@@ -1450,7 +1499,13 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
     const draftPath = resolveMilestoneFile(base, mid, "CONTEXT-DRAFT");
     const draftContent = draftPath ? await loadFile(draftPath) : null;
     if (includeDraftSeed && draftContent) {
-        return `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${draftContent}`;
+        const draftRelPath = relMilestoneFile(base, mid, "CONTEXT-DRAFT");
+        const draftSeed = `### Prior Discussion Draft\nSource: \`${draftRelPath}\`\n\n${draftContent.trim()}`;
+        const cappedDraftSeed = capPreamble(draftSeed);
+        const truncationNote = cappedDraftSeed !== draftSeed
+            ? `\n\n_(Draft seed truncated; read the full draft at \`${draftRelPath}\` if needed.)_`
+            : "";
+        return `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${cappedDraftSeed}${truncationNote}`;
     }
     return promptWithContextMode;
 }
@@ -1696,7 +1751,7 @@ export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     return loadPrompt("research-milestone", {
         workingDirectory: base,
         milestoneId: mid, milestoneTitle: midTitle,
-        milestonePath: relMilestonePath(base, mid),
+        milestonePath: relMilestonePath(base, mid, midTitle),
         contextPath: relMilestoneFile(base, mid, "CONTEXT"),
         outputPath: join(base, outputRelPath),
         inlinedContext,
@@ -1844,7 +1899,7 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
     return loadPrompt("plan-milestone", {
         workingDirectory: base,
         milestoneId: mid, milestoneTitle: midTitle,
-        milestonePath: relMilestonePath(base, mid),
+        milestonePath: relMilestonePath(base, mid, midTitle),
         contextPath: contextRel,
         researchPath: researchRel,
         researchOutputPath,
@@ -2151,6 +2206,7 @@ async function renderSlicePrompt(options) {
         inlinedContext,
         dependencySummaries: depContent,
         sourceFilePaths: buildSourceFilePaths(base, mid, sid),
+        repoRegistry: buildRepoRegistryBlock(base),
         executorContextConstraints,
         commitInstruction,
         skillActivation: buildSkillActivationBlock({
@@ -2259,7 +2315,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         : "- (no prior tasks)";
     const taskPlanPath = resolveTaskFile(base, mid, sid, tid, "PLAN");
     const taskPlanContent = taskPlanPath ? await loadFile(taskPlanPath) : null;
-    const taskPlanRelPath = relSlicePath(base, mid, sid) + `/tasks/${tid}-PLAN.md`;
+    const taskPlanRelPath = relTaskFile(base, mid, sid, tid, "PLAN");
     const taskPlanContext = taskPlanContent
         ? [
             "## Inlined Task Plan (authoritative local execution contract)",
@@ -2396,8 +2452,9 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const slicePlanExcerpt = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "slice-plan");
     const contractedCarryForward = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "prior-task-summaries");
     const contractedTemplates = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "templates");
-    const onDemandContext = renderExecuteTaskOnDemandContext(base, mid, sid, contractedContext.onDemand);
-    trackPromptContext(contextTelemetry, "slice-research", onDemandContext ? "on-demand" : "skipped", onDemandContext, onDemandContext ? undefined : "not declared by contract");
+    const onDemandResult = renderExecuteTaskOnDemandContext(base, mid, sid, contractedContext.onDemand);
+    const onDemandContext = onDemandResult.text;
+    trackPromptContext(contextTelemetry, "slice-research", onDemandContext ? "on-demand" : "skipped", onDemandContext, onDemandContext ? undefined : onDemandResult.skipReason ?? undefined);
     const prompt = loadPrompt("execute-task", {
         overridesSection,
         runtimeContext,
@@ -2474,17 +2531,16 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
                     return body;
                 }
             case "prior-task-summaries": {
-                const tDir = resolveTasksDir(base, mid, sid);
-                if (!tDir) {
+                const loc = resolveTaskSummariesLocation(base, mid, sid);
+                if (!loc) {
                     trackPromptContext(contextTelemetry, "prior-task-summaries", "skipped", null, "missing tasks dir");
                     return null;
                 }
-                const summaryFiles = resolveTaskFiles(tDir, "SUMMARY").sort();
-                const sRel = relSlicePath(base, mid, sid);
+                const summaryFiles = resolveTaskFiles(loc.dir, "SUMMARY").sort();
                 const blocks = [];
                 for (const file of summaryFiles) {
-                    const absPath = join(tDir, file);
-                    const relPath = `${sRel}/tasks/${file}`;
+                    const absPath = join(loc.dir, file);
+                    const relPath = `${loc.relPrefix}/${file}`;
                     const taskId = file.replace(/-SUMMARY\.md$/i, "");
                     blocks.push(await buildTaskSummaryExcerpt(absPath, relPath, taskId));
                 }
@@ -2734,8 +2790,10 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     trackPromptContext(contextTelemetry, "cap", cappedInlinedContext.length < rawInlinedContext.length ? "skipped" : "inline", null, cappedInlinedContext.length < rawInlinedContext.length ? `dropped ${rawInlinedContext.length - cappedInlinedContext.length} chars` : "within budget");
     const inlinedContext = prependContextModeToBlock("complete-milestone", base, cappedInlinedContext);
     emitPromptContextTelemetry("complete-milestone", contextTelemetry, inlinedContext);
-    const milestoneSummaryPath = join(base, `${relMilestonePath(base, mid)}/${mid}-SUMMARY.md`);
-    const learningsRelPath = join(relMilestonePath(base, mid), `${mid}-LEARNINGS.md`);
+    // Use relMilestoneFile to get the layout-aware filename (NN-SUFFIX.md for flat-phase,
+    // M001-SUFFIX.md for legacy) rather than manually appending the raw milestone id.
+    const milestoneSummaryPath = join(base, relMilestoneFile(base, mid, "SUMMARY"));
+    const learningsRelPath = relMilestoneFile(base, mid, "LEARNINGS");
     const learningsAbsPath = join(base, learningsRelPath);
     const extractLearningsSteps = buildExtractionStepsBlock({
         milestoneId: mid,
@@ -2881,6 +2939,47 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         inlined.push(outstandingBlock);
         trackPromptContext(contextTelemetry, "outstanding-items", "inline", outstandingBlock);
     }
+    const persistedGateFlags = [];
+    try {
+        const gateLabels = {
+            Q3: "Threat Surface",
+            Q4: "Requirement Impact",
+        };
+        for (const sid of seenValSlices) {
+            for (const gate of getGateResults(mid, sid, "slice")) {
+                if (gate.gate_id !== "Q3" && gate.gate_id !== "Q4")
+                    continue;
+                const findings = gate.findings.trim();
+                const rationale = gate.rationale.trim();
+                const verdict = gate.verdict ?? "";
+                const hasNonPassVerdict = verdict !== "" && verdict !== "pass" && verdict !== "omitted";
+                if (!findings && !hasNonPassVerdict)
+                    continue;
+                const displayVerdict = verdict || gate.status;
+                const detail = findings || rationale || "_No findings text recorded; reconcile the persisted non-pass verdict._";
+                persistedGateFlags.push(`- **${sid} / ${gate.gate_id} (${gateLabels[gate.gate_id]}) / ${displayVerdict}:** ${detail}`);
+                if (findings && rationale)
+                    persistedGateFlags.push(`  - Rationale: ${rationale}`);
+            }
+        }
+    }
+    catch (err) {
+        logWarning("prompt", `buildValidateMilestonePrompt persisted gate flags lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (persistedGateFlags.length > 0) {
+        const persistedGateFlagsBlock = [
+            "### Persisted Slice-Level Gate Flags (from quality_gates)",
+            "",
+            "These slice gates recorded findings or non-pass verdicts during execution. Reconcile each against the milestone-level evidence before returning MV03/MV04 verdicts.",
+            "",
+            ...persistedGateFlags,
+        ].join("\n");
+        inlined.push(persistedGateFlagsBlock);
+        trackPromptContext(contextTelemetry, "persisted-slice-gate-flags", "inline", persistedGateFlagsBlock);
+    }
+    else {
+        trackPromptContext(contextTelemetry, "persisted-slice-gate-flags", "skipped", null, "none");
+    }
     // Inline existing VALIDATION file if this is a re-validation round
     const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
     const validationRel = relMilestoneFile(base, mid, "VALIDATION");
@@ -2965,8 +3064,9 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     trackPromptContext(contextTelemetry, "cap", cappedInlinedContext.length < rawInlinedContext.length ? "skipped" : "inline", null, cappedInlinedContext.length < rawInlinedContext.length ? `dropped ${rawInlinedContext.length - cappedInlinedContext.length} chars` : "within budget");
     const inlinedContext = prependContextModeToBlock("validate-milestone", base, cappedInlinedContext);
     emitPromptContextTelemetry("validate-milestone", contextTelemetry, inlinedContext);
-    const validationOutputPath = join(base, `${relMilestonePath(base, mid)}/${mid}-VALIDATION.md`);
-    const roadmapOutputPath = `${relMilestonePath(base, mid)}/${mid}-ROADMAP.md`;
+    // Use relMilestoneFile for layout-aware filenames (NN-SUFFIX.md flat-phase, M001-SUFFIX.md legacy).
+    const validationOutputPath = join(base, relMilestoneFile(base, mid, "VALIDATION"));
+    const roadmapOutputPath = relMilestoneFile(base, mid, "ROADMAP");
     // Every milestone validation turn owns MV01–MV04 unconditionally: the
     // registry is the source of truth for which gates the validator must
     // address, and the block below is what the template renders so the
@@ -3009,17 +3109,16 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
     inlined.push(await inlineFile(slicePlanPath, slicePlanRel, "Current Slice Plan"));
     // Find the blocker task summary — the completed task with blocker_discovered: true
     let blockerTaskId = "";
-    const tDir = resolveTasksDir(base, mid, sid);
-    if (tDir) {
-        const summaryFiles = resolveTaskFiles(tDir, "SUMMARY").sort();
+    const summaryLoc = resolveTaskSummariesLocation(base, mid, sid);
+    if (summaryLoc) {
+        const summaryFiles = resolveTaskFiles(summaryLoc.dir, "SUMMARY").sort();
         for (const file of summaryFiles) {
-            const absPath = join(tDir, file);
+            const absPath = join(summaryLoc.dir, file);
             const content = await loadFile(absPath);
             if (!content)
                 continue;
             const summary = parseSummary(content);
-            const sRel = relSlicePath(base, mid, sid);
-            const relPath = `${sRel}/tasks/${file}`;
+            const relPath = `${summaryLoc.relPrefix}/${file}`;
             if (summary.frontmatter.blocker_discovered) {
                 blockerTaskId = summary.frontmatter.id || file.replace(/-SUMMARY\.md$/i, "");
                 inlined.push(await buildTaskSummaryExcerpt(absPath, relPath, blockerTaskId, { blocker: true }));
@@ -3035,7 +3134,7 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
     if (replanOverridesInline)
         inlined.unshift(replanOverridesInline);
     const inlinedContext = prependContextModeToBlock("replan-slice", base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`));
-    const replanPath = join(base, `${relSlicePath(base, mid, sid)}/${sid}-REPLAN.md`);
+    const replanPath = join(base, relSliceFile(base, mid, sid, "REPLAN"));
     // Build capture context for replan prompt (captures that triggered this replan)
     let captureContext = "(none)";
     try {
@@ -3351,7 +3450,7 @@ opts) {
         const depPaths = await getDependencyTaskSummaryPaths(mid, sid, tid, node?.dependsOn ?? [], base);
         const taskPlanPath = resolveTaskFile(base, mid, sid, tid, "PLAN");
         const taskPlanContent = taskPlanPath ? await loadFile(taskPlanPath) : null;
-        const taskPlanRelPath = `${relSlicePath(base, mid, sid)}/tasks/${tid}-PLAN.md`;
+        const taskPlanRelPath = relTaskFile(base, mid, sid, tid, "PLAN");
         const taskPlanInline = taskPlanContent
             ? [
                 "## Inlined Task Plan (authoritative local execution contract)",