@opengsd/gsd-pi 1.9.0-dev.d2070876 → 1.9.0-dev.e10b60d4

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-5f0f1c788a126951
+b54acda1c11b5a17

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

@@ -261,22 +261,7 @@ async function enforceMinRequestInterval(s, prefs) {
         await new Promise(r => setTimeout(r, decision.waitMs));
     }
 }
-async function snapshotCrashedUnitWork(ctx, s, deps, iterData) {
-    try {
-        const commitMsg = await deps.autoCommitUnit?.(s.basePath, iterData.unitType, iterData.unitId, ctx);
-        if (commitMsg) {
-            debugLog("autoLoop", {
-                phase: "crash-snapshot-commit",
-                unitType: iterData.unitType,
-                unitId: iterData.unitId,
-            });
-        }
-    }
-    catch (snapshotErr) {
-        logWarning("dispatch", `unit crash snapshot failed: ${snapshotErr instanceof Error ? snapshotErr.message : String(snapshotErr)}`);
-    }
-}
-async function closeOutCrashedUnit(ctx, s, deps, iterData, err) {
+function closeOutCrashedUnit(s, iterData, err) {
     const summary = formatDispatchExceptionSummary({ error: err });
     try {
         emitOpenUnitEndForUnit(s.basePath, iterData.unitType, iterData.unitId, "cancelled", {
@@ -293,7 +278,6 @@ async function closeOutCrashedUnit(ctx, s, deps, iterData, err) {
     catch (closeoutErr) {
         logWarning("dispatch", `unit crash closeout failed: ${closeoutErr instanceof Error ? closeoutErr.message : String(closeoutErr)}`);
     }
-    await snapshotCrashedUnitWork(ctx, s, deps, iterData);
 }
 /**
  * Main auto-mode execution loop. Iterates: orchestration.advance → guards →
@@ -416,15 +400,11 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             active: s.active,
             iteration,
             maxIterations: MAX_LOOP_ITERATIONS,
-            hasCommandContext: typeof s.cmdCtx?.newSession === "function",
+            hasCommandContext: Boolean(s.cmdCtx),
             sessionLockValid: true,
         });
         if (commandContextDecision.action === "stop" && commandContextDecision.reason === "missing-command-context") {
             debugLog("autoLoop", { phase: "exit", reason: "no-cmdCtx" });
-            if (s.currentUnit) {
-                await deps.autoCommitUnit?.(s.basePath, s.currentUnit.type, s.currentUnit.id, ctx);
-            }
-            await deps.stopAuto(ctx, pi, commandContextDecision.message, { preserveWorktree: true });
             finishTurn("stopped", "manual-attention", commandContextDecision.reason);
             break;
         }
@@ -606,7 +586,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     if (err instanceof ModelPolicyDispatchBlockedError) {
                         throw err;
                     }
-                    await closeOutCrashedUnit(ctx, s, deps, iterData, err);
+                    closeOutCrashedUnit(s, iterData, err);
                     throw err;
                 }
                 if (unitPhaseResult.action === "next") {
@@ -1129,7 +1109,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 if (err instanceof ModelPolicyDispatchBlockedError) {
                     throw err;
                 }
-                await closeOutCrashedUnit(ctx, s, deps, iterData, err);
+                closeOutCrashedUnit(s, iterData, err);
                 dispatchSettled = settleDispatchFailed(dispatchId, formatDispatchExceptionSummary({ error: err }), {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,

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

@@ -58,24 +58,6 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
-    const cmdCtx = s.cmdCtx;
-    if (typeof cmdCtx?.newSession !== "function") {
-        const msg = "command context is missing newSession";
-        debugLog("runUnit", {
-            phase: "session-error",
-            unitType,
-            unitId,
-            error: msg,
-        });
-        return {
-            status: "cancelled",
-            errorContext: {
-                message: `Session creation failed: ${msg}`,
-                category: "session-failed",
-                isTransient: false,
-            },
-        };
-    }
     let sessionResult;
     let sessionTimeoutHandle;
     const mySessionSwitchGeneration = ++sessionSwitchGeneration;
@@ -85,7 +67,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = cmdCtx.newSession({
+        const sessionPromise = s.cmdCtx.newSession({
             abortSignal: sessionAbortController.signal,
             workspaceRoot: s.basePath,
         }).finally(() => {

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

@@ -46,10 +46,9 @@ import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.
 import { extractVerdict } from "./verdict-parser.js";
 import { auditOrphanedPreflightStashes } from "./orphan-stash-audit.js";
 import { parseProject } from "./schemas/parsers.js";
-import { LAYOUT_SEGMENTS } from "./layout-policy.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
 import { join } from "node:path";
 import { validateDirectory } from "./validate-directory.js";
 import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
@@ -74,30 +73,6 @@ const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
 export function hasGitIndexLockForTest(basePath) {
     return existsSync(join(basePath, ".git", "index.lock"));
 }
-function isEmptyDirectory(dirPath) {
-    try {
-        return existsSync(dirPath) && readdirSync(dirPath).length === 0;
-    }
-    catch {
-        return false;
-    }
-}
-export function reconcileFlatPhaseBootstrapLayout(basePath) {
-    const gsdDir = join(basePath, ".gsd");
-    const phasesPath = join(gsdDir, LAYOUT_SEGMENTS.level1);
-    const milestonesPath = join(gsdDir, "milestones");
-    if (isEmptyDirectory(milestonesPath)) {
-        if (!existsSync(phasesPath))
-            mkdirSync(phasesPath, { recursive: true });
-        rmSync(milestonesPath, { recursive: true, force: true });
-        return true;
-    }
-    if (!existsSync(phasesPath) && !existsSync(milestonesPath)) {
-        mkdirSync(phasesPath, { recursive: true });
-        return true;
-    }
-    return false;
-}
 export function _shouldAbortBootstrapForUnavailableDbForTest(gsdDbPath, dbAvailable, pathExists = existsSync) {
     return pathExists(gsdDbPath) && !dbAvailable;
 }
@@ -893,15 +868,20 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         ensureGitignore(base, { manageGitignore });
         if (manageGitignore !== false)
             untrackRuntimeFiles(base);
-        // Bootstrap the flat-phase projection root and clean empty legacy scaffolds.
-        if (reconcileFlatPhaseBootstrapLayout(base)) {
+        // Bootstrap milestones/ if it doesn't exist.
+        // Check milestones/ directly — ensureGsdSymlink above already created .gsd/,
+        // so checking .gsd/ existence would be dead code (#2942).
+        const gsdDir = join(base, ".gsd");
+        const milestonesPath = join(gsdDir, "milestones");
+        if (!existsSync(milestonesPath)) {
+            mkdirSync(milestonesPath, { recursive: true });
             try {
                 nativeAddAll(base);
                 nativeCommit(base, "chore: init gsd");
             }
             catch (err) {
                 /* nothing to commit */
-                logWarning("engine", `layout bootstrap commit failed: ${err instanceof Error ? err.message : String(err)}`);
+                logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
         {

package/dist/resources/extensions/gsd/auto-worktree-sync.js

@@ -5,7 +5,7 @@
 import { cpSync, existsSync, lstatSync as lstatSyncFn, mkdirSync, readdirSync, } from "node:fs";
 import { join } from "node:path";
 import { _isSamePath as isSamePath, } from "./auto-worktree-cleanup.js";
-import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
+import { resolveGsdPathContract } from "./paths.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { logWarning } from "./workflow-logger.js";
 const PROJECT_PREFERENCES_FILE = "PREFERENCES.md";
@@ -143,14 +143,10 @@ function syncMilestoneLayout(mainGsd, wtGsd, layoutSegment, synced) {
     if (!existsSync(mainMilestonesDir))
         return;
     try {
+        mkdirSync(wtMilestonesDir, { recursive: true });
         const mainMilestones = readdirSync(mainMilestonesDir, { withFileTypes: true })
             .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name)
-            .filter((name) => layoutSegment !== "milestones" ||
-            dirIsContentBearingLegacyMilestone(join(mainMilestonesDir, name)));
-        if (mainMilestones.length === 0)
-            return;
-        mkdirSync(wtMilestonesDir, { recursive: true });
+            .map((entry) => entry.name);
         for (const milestoneId of mainMilestones) {
             syncMilestoneDirectory(mainMilestonesDir, wtMilestonesDir, milestoneId, synced);
         }

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

@@ -2440,18 +2440,7 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         startedAt: hookStartedAt,
         workspaceRoot: s.basePath,
     });
-    const cmdCtx = s.cmdCtx;
-    if (typeof cmdCtx?.newSession !== "function") {
-        const message = "Auto-mode has no command context for dispatch.";
-        ctx.ui.notify(message, "error");
-        const unitToCommit = previousCurrentUnit ?? s.currentUnit;
-        if (unitToCommit) {
-            await autoCommitUnit(s.basePath, unitToCommit.type, unitToCommit.id, ctx);
-        }
-        await stopAuto(ctx, pi, message, { preserveWorktree: true });
-        return false;
-    }
-    const result = await cmdCtx.newSession({ workspaceRoot: s.basePath });
+    const result = await s.cmdCtx.newSession({ workspaceRoot: s.basePath });
     if (result.cancelled) {
         await stopAuto(ctx, pi);
         return false;

package/dist/resources/extensions/gsd/doctor-engine-checks.js

@@ -58,23 +58,6 @@ function reportCheckboxDbStatusDivergence(issues, basePath, filePath, scope, uni
         fixable: false,
     });
 }
-function bareDuplicateMilestoneId(milestoneId) {
-    const match = milestoneId.match(/^(M\d{3})-[a-z0-9]{6}$/i);
-    return match?.[1]?.toUpperCase() ?? null;
-}
-function checkboxDbStatusMilestoneIds(basePath, milestoneIds) {
-    if (!hasFlatPhaseLayout(basePath))
-        return milestoneIds;
-    // Flat-phase directories are keyed by phase number. A restored
-    // M003-xxxxxx row alongside M003 is a stale duplicate for the same
-    // phases/03-* projection, so checking both can compare DB status against two
-    // competing PLAN files and report a persistent false divergence.
-    const allIds = new Set(milestoneIds.map((id) => id.toUpperCase()));
-    return milestoneIds.filter((milestoneId) => {
-        const bareId = bareDuplicateMilestoneId(milestoneId);
-        return !bareId || !allIds.has(bareId);
-    });
-}
 function checkProjectionCheckboxDbStatus(basePath, milestoneIds, issues) {
     for (const milestoneId of milestoneIds) {
         const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
@@ -339,9 +322,7 @@ function staleMilestonesArtifactRowFixable(basePath, row, artifactRows) {
 }
 function stalePhasesArtifactRowFixable(basePath, row, artifactRows) {
     const issuePath = artifactPathRelativeToGsd(row.path);
-    return issuePath.startsWith(`${LAYOUT_SEGMENTS.level1}/`) &&
-        (hasPresentFlatPhaseReplacement(basePath, row, artifactRows) ||
-            hasPresentMilestonesReplacement(basePath, row, artifactRows));
+    return issuePath.startsWith(`${LAYOUT_SEGMENTS.level1}/`) && hasPresentMilestonesReplacement(basePath, row, artifactRows);
 }
 function staleArtifactRowFixable(basePath, row, artifactRows) {
     return staleMilestonesArtifactRowFixable(basePath, row, artifactRows) ||
@@ -677,7 +658,7 @@ export async function checkEngineHealth(basePath, issues, fixesApplied, options)
     // block doctor.
     try {
         if (isDbAvailable()) {
-            checkProjectionCheckboxDbStatus(basePath, checkboxDbStatusMilestoneIds(basePath, getAllMilestones().map((milestone) => milestone.id)), issues);
+            checkProjectionCheckboxDbStatus(basePath, getAllMilestones().map((milestone) => milestone.id), issues);
         }
     }
     catch {

package/dist/resources/extensions/gsd/flat-phase-migration.js

@@ -130,17 +130,6 @@ function isInsideFlatProjectionBackup(backupDir, src) {
     const phaseBackupDir = join(backupDir, "__phases");
     return src === phaseBackupDir || src.startsWith(`${phaseBackupDir}/`) || src.startsWith(`${phaseBackupDir}\\`);
 }
-function removeFlatProjectionBackup(backupDir) {
-    const phaseBackupDir = join(backupDir, "__phases");
-    if (!existsSync(phaseBackupDir))
-        return;
-    try {
-        removePathWithRetries(phaseBackupDir);
-    }
-    catch (err) {
-        logWarning("migration", `flat-phase migration succeeded but could not remove temporary ${LAYOUT_SEGMENTS.level1}/ backup: ${err.message}`);
-    }
-}
 function restoreFlatProjectionFromBackup(basePath, backupDir) {
     const phaseBackupDir = join(backupDir, "__phases");
     if (!existsSync(phaseBackupDir))
@@ -444,5 +433,4 @@ export async function migrateToFlatPhase(basePath) {
     catch (err) {
         logWarning("migration", `flat-phase migration succeeded but could not remove ${LEGACY_MIGRATING_SEGMENT}: ${err.message}`);
     }
-    removeFlatProjectionBackup(backupDir);
 }

package/dist/resources/extensions/gsd/gsd-db.js

@@ -38,7 +38,6 @@ export * from "./db/queries.js";
 export * from "./db/writers/cascades.js";
 import { TERMINAL_STATUS_SQL } from "./db/sql-constants.js";
 import { applyStatusTransition } from "./db/writers/status.js";
-import { LAYOUT_SEGMENTS, derivePhaseSlug, milestoneIdToPhaseNum, milestoneIdUniqueSuffix, phaseDirName, } from "./layout-policy.js";
 export function insertDecision(d) {
     if (!getDbOrNull())
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -170,44 +169,6 @@ export function insertArtifact(a) {
         ":content_hash": contentHash,
     });
 }
-function canonicalPhaseDirNameForDb(milestoneId, title) {
-    const phaseNum = milestoneIdToPhaseNum(milestoneId);
-    const slug = derivePhaseSlug(title || milestoneId);
-    const suffix = milestoneIdUniqueSuffix(milestoneId);
-    return phaseDirName(phaseNum, suffix ? `${suffix}-${slug}` : slug);
-}
-function reconcileMilestonePhaseArtifactPaths(milestoneId, title) {
-    const db = getDbOrNull();
-    const phaseNumPrefix = String(milestoneIdToPhaseNum(milestoneId)).padStart(2, "0");
-    const canonicalDir = canonicalPhaseDirNameForDb(milestoneId, title);
-    const staleRows = db.prepare(`SELECT path
-       FROM artifacts
-      WHERE milestone_id = :milestone_id
-        AND path LIKE :phase_prefix`).all({
-        ":milestone_id": milestoneId,
-        ":phase_prefix": `${LAYOUT_SEGMENTS.level1}/${phaseNumPrefix}-%/%`,
-    });
-    const updatePath = db.prepare("UPDATE artifacts SET path = :new_path WHERE path = :old_path");
-    const deletePath = db.prepare("DELETE FROM artifacts WHERE path = :path");
-    const existingPath = db.prepare("SELECT 1 AS present FROM artifacts WHERE path = :path");
-    for (const row of staleRows) {
-        const parts = row.path.split("/");
-        if (parts.length < 3)
-            continue;
-        if (parts[0] !== LAYOUT_SEGMENTS.level1)
-            continue;
-        if (parts[1] === canonicalDir)
-            continue;
-        if (!parts[1]?.startsWith(`${phaseNumPrefix}-`))
-            continue;
-        const newPath = [LAYOUT_SEGMENTS.level1, canonicalDir, ...parts.slice(2)].join("/");
-        if (existingPath.get({ ":path": newPath })) {
-            deletePath.run({ ":path": row.path });
-            continue;
-        }
-        updatePath.run({ ":new_path": newPath, ":old_path": row.path });
-    }
-}
 export function insertMilestone(m) {
     if (!getDbOrNull())
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -246,42 +207,37 @@ export function insertMilestone(m) {
 export function upsertMilestonePlanning(milestoneId, planning) {
     if (!getDbOrNull())
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    transaction(() => {
-        getDbOrNull().prepare(`UPDATE milestones SET
-        title = COALESCE(NULLIF(:title, ''), title),
-        status = COALESCE(NULLIF(:status, ''), status),
-        depends_on = COALESCE(:depends_on, depends_on),
-        vision = COALESCE(:vision, vision),
-        success_criteria = COALESCE(:success_criteria, success_criteria),
-        key_risks = COALESCE(:key_risks, key_risks),
-        proof_strategy = COALESCE(:proof_strategy, proof_strategy),
-        verification_contract = COALESCE(:verification_contract, verification_contract),
-        verification_integration = COALESCE(:verification_integration, verification_integration),
-        verification_operational = COALESCE(:verification_operational, verification_operational),
-        verification_uat = COALESCE(:verification_uat, verification_uat),
-        definition_of_done = COALESCE(:definition_of_done, definition_of_done),
-        requirement_coverage = COALESCE(:requirement_coverage, requirement_coverage),
-        boundary_map_markdown = COALESCE(:boundary_map_markdown, boundary_map_markdown)
-       WHERE id = :id`).run({
-            ":id": milestoneId,
-            ":title": planning.title ?? "",
-            ":status": planning.status ?? "",
-            ":depends_on": planning.depends_on ? JSON.stringify(planning.depends_on) : null,
-            ":vision": planning.vision ?? null,
-            ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
-            ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
-            ":proof_strategy": planning.proofStrategy ? JSON.stringify(planning.proofStrategy) : null,
-            ":verification_contract": planning.verificationContract ?? null,
-            ":verification_integration": planning.verificationIntegration ?? null,
-            ":verification_operational": planning.verificationOperational ?? null,
-            ":verification_uat": planning.verificationUat ?? null,
-            ":definition_of_done": planning.definitionOfDone ? JSON.stringify(planning.definitionOfDone) : null,
-            ":requirement_coverage": planning.requirementCoverage ?? null,
-            ":boundary_map_markdown": planning.boundaryMapMarkdown ?? null,
-        });
-        const finalTitle = planning.title?.trim();
-        if (finalTitle)
-            reconcileMilestonePhaseArtifactPaths(milestoneId, finalTitle);
+    getDbOrNull().prepare(`UPDATE milestones SET
+      title = COALESCE(NULLIF(:title, ''), title),
+      status = COALESCE(NULLIF(:status, ''), status),
+      depends_on = COALESCE(:depends_on, depends_on),
+      vision = COALESCE(:vision, vision),
+      success_criteria = COALESCE(:success_criteria, success_criteria),
+      key_risks = COALESCE(:key_risks, key_risks),
+      proof_strategy = COALESCE(:proof_strategy, proof_strategy),
+      verification_contract = COALESCE(:verification_contract, verification_contract),
+      verification_integration = COALESCE(:verification_integration, verification_integration),
+      verification_operational = COALESCE(:verification_operational, verification_operational),
+      verification_uat = COALESCE(:verification_uat, verification_uat),
+      definition_of_done = COALESCE(:definition_of_done, definition_of_done),
+      requirement_coverage = COALESCE(:requirement_coverage, requirement_coverage),
+      boundary_map_markdown = COALESCE(:boundary_map_markdown, boundary_map_markdown)
+     WHERE id = :id`).run({
+        ":id": milestoneId,
+        ":title": planning.title ?? "",
+        ":status": planning.status ?? "",
+        ":depends_on": planning.depends_on ? JSON.stringify(planning.depends_on) : null,
+        ":vision": planning.vision ?? null,
+        ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
+        ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
+        ":proof_strategy": planning.proofStrategy ? JSON.stringify(planning.proofStrategy) : null,
+        ":verification_contract": planning.verificationContract ?? null,
+        ":verification_integration": planning.verificationIntegration ?? null,
+        ":verification_operational": planning.verificationOperational ?? null,
+        ":verification_uat": planning.verificationUat ?? null,
+        ":definition_of_done": planning.definitionOfDone ? JSON.stringify(planning.definitionOfDone) : null,
+        ":requirement_coverage": planning.requirementCoverage ?? null,
+        ":boundary_map_markdown": planning.boundaryMapMarkdown ?? null,
     });
 }
 export function insertSlice(s) {

package/dist/resources/extensions/gsd/worktree-state-projection.js

@@ -21,7 +21,7 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
 import { reconcileWorktreeDb } from "./gsd-db.js";
-import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
+import { resolveGsdPathContract } from "./paths.js";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { logError, logWarning } from "./workflow-logger.js";
 // ─── Private helpers ──────────────────────────────────────────────────────
@@ -129,8 +129,6 @@ function syncOtherMilestoneArtifacts(srcMilestonesDir, dstMilestonesDir, current
             if (milestoneEntry.name === currentMilestoneId)
                 continue;
             const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
-            if (!dirIsContentBearingLegacyMilestone(srcMilestoneDir))
-                continue;
             const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
             // Additively project the entire milestone subtree (force:false), not just
             // top-level files. Prior completed milestones keep their per-slice and
@@ -221,25 +219,25 @@ export function _projectRootToWorktreeImpl(projectRoot, worktreePath_, milestone
     // Without this, worktree-local files (e.g. VALIDATION.md written
     // by validate-milestone) get clobbered by stale project root copies,
     // causing an infinite re-validation loop (#1886).
+    safeCopyRecursive(join(prGsd, "milestones", milestoneId), join(wtGsd, "milestones", milestoneId), { force: false });
+    // Additively project the full subtree of every OTHER milestone so
+    // worktree-bound units can read prior-milestone context artifacts and so
+    // completed milestones retain their per-slice/per-task SUMMARY.md and
+    // UAT.md on the worktree filesystem (otherwise the stale-render detector
+    // flags them as "complete in DB but missing on disk").
+    syncOtherMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"), milestoneId);
+    // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
+    // The additive-only copy above preserves worktree-local files, but
+    // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
+    // syncs it to the project root, the worktree may retain a stale copy (e.g.
+    // verdict:fail while the project root has verdict:pass from a retry). On
+    // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
+    // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
+    // run-uat indefinitely (stuck-loop ×9).
     const prMilestoneDir = join(prGsd, "milestones", milestoneId);
     const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
-    if (dirIsContentBearingLegacyMilestone(prMilestoneDir)) {
-        safeCopyRecursive(prMilestoneDir, wtMilestoneDir, { force: false });
-        // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
-        // The additive-only copy above preserves worktree-local files, but
-        // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
-        // syncs it to the project root, the worktree may retain a stale copy (e.g.
-        // verdict:fail while the project root has verdict:pass from a retry). On
-        // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
-        // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
-        // run-uat indefinitely (stuck-loop ×9).
-        forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
-        forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
-    }
-    // Additively project the full subtree of every OTHER content-bearing legacy
-    // milestone so worktree-bound units can read prior-milestone context artifacts
-    // without recreating empty/meta-only milestones/ scaffolds in flat-phase projects.
-    syncOtherMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"), milestoneId);
+    forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
+    forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
     // Forward-sync completed-units.json from project root to worktree.
     // Project root is authoritative for completion state after crash recovery;
     // without this, the worktree re-dispatches already-completed units (#1886).