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

package/README.md

@@ -28,16 +28,16 @@ See [CHANGELOG.md](./CHANGELOG.md) for release-by-release fixes and [Legacy Rele
 ## Latest Release Highlights
 
 <!-- release-highlights:start -->
-Latest release: **v1.9.0**
-
-- **gsd:** Add task rework briefs.
-- **web:** Delete unused chart.tsx and recharts.
-- **deps:** Move ajv to devDependencies.
-- **daemon:** Dedupe @anthropic-ai/sdk to ^0.91.1.
-- **deps:** Override hono to >=4.12.25.
-- **gsd:** Batch plan-v2 task queries and skip unchanged graph writes.
-- **gsd:** Open the worker DB once per parallel-monitor tick.
-- **gsd:** Batch parallel-eligibility task queries.
+Latest release: **v1.10.0**
+
+- **pi-ai:** Add Meta Muse Spark 1.1 to the model catalog.
+- **gsd:** Surface cacheRetention as a settable prompt-cache TTL preference.
+- **models:** Add GPT-5.6 as a first-class model.
+- **models:** Add Grok 4.5 as a first-class xAI model.
+- **agent-core:** Pin compaction summarization reasoning to low, bound degenerate-chunk retry.
+- **gsd:** Filter superseded context injections from provider payload.
+- **gsd:** Stop advertising alias tool schemas on model-facing surfaces.
+- **gsd:** Cap execute-task and discuss-slice inlined context; provider-aware budgets.
 
 <!-- release-highlights:end -->
 

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

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

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

@@ -261,7 +261,22 @@ async function enforceMinRequestInterval(s, prefs) {
         await new Promise(r => setTimeout(r, decision.waitMs));
     }
 }
-function closeOutCrashedUnit(s, iterData, err) {
+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) {
     const summary = formatDispatchExceptionSummary({ error: err });
     try {
         emitOpenUnitEndForUnit(s.basePath, iterData.unitType, iterData.unitId, "cancelled", {
@@ -278,6 +293,7 @@ function closeOutCrashedUnit(s, 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 →
@@ -400,11 +416,15 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             active: s.active,
             iteration,
             maxIterations: MAX_LOOP_ITERATIONS,
-            hasCommandContext: Boolean(s.cmdCtx),
+            hasCommandContext: typeof s.cmdCtx?.newSession === "function",
             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;
         }
@@ -586,7 +606,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     if (err instanceof ModelPolicyDispatchBlockedError) {
                         throw err;
                     }
-                    closeOutCrashedUnit(s, iterData, err);
+                    await closeOutCrashedUnit(ctx, s, deps, iterData, err);
                     throw err;
                 }
                 if (unitPhaseResult.action === "next") {
@@ -1109,7 +1129,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 if (err instanceof ModelPolicyDispatchBlockedError) {
                     throw err;
                 }
-                closeOutCrashedUnit(s, iterData, err);
+                await closeOutCrashedUnit(ctx, s, deps, iterData, err);
                 dispatchSettled = settleDispatchFailed(dispatchId, formatDispatchExceptionSummary({ error: err }), {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,

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

@@ -58,6 +58,24 @@ 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;
@@ -67,7 +85,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = s.cmdCtx.newSession({
+        const sessionPromise = cmdCtx.newSession({
             abortSignal: sessionAbortController.signal,
             workspaceRoot: s.basePath,
         }).finally(() => {

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

@@ -46,9 +46,10 @@ 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, rmSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, } from "node:fs";
 import { join } from "node:path";
 import { validateDirectory } from "./validate-directory.js";
 import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
@@ -73,6 +74,30 @@ 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;
 }
@@ -868,20 +893,15 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         ensureGitignore(base, { manageGitignore });
         if (manageGitignore !== false)
             untrackRuntimeFiles(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 });
+        // Bootstrap the flat-phase projection root and clean empty legacy scaffolds.
+        if (reconcileFlatPhaseBootstrapLayout(base)) {
             try {
                 nativeAddAll(base);
                 nativeCommit(base, "chore: init gsd");
             }
             catch (err) {
                 /* nothing to commit */
-                logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
+                logWarning("engine", `layout bootstrap commit 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 { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { logWarning } from "./workflow-logger.js";
 const PROJECT_PREFERENCES_FILE = "PREFERENCES.md";
@@ -143,10 +143,14 @@ 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);
+            .map((entry) => entry.name)
+            .filter((name) => layoutSegment !== "milestones" ||
+            dirIsContentBearingLegacyMilestone(join(mainMilestonesDir, name)));
+        if (mainMilestones.length === 0)
+            return;
+        mkdirSync(wtMilestonesDir, { recursive: true });
         for (const milestoneId of mainMilestones) {
             syncMilestoneDirectory(mainMilestonesDir, wtMilestonesDir, milestoneId, synced);
         }

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

@@ -2440,7 +2440,18 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         startedAt: hookStartedAt,
         workspaceRoot: s.basePath,
     });
-    const result = await s.cmdCtx.newSession({ 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 });
     if (result.cancelled) {
         await stopAuto(ctx, pi);
         return false;

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

@@ -58,6 +58,23 @@ 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");
@@ -322,7 +339,9 @@ function staleMilestonesArtifactRowFixable(basePath, row, artifactRows) {
 }
 function stalePhasesArtifactRowFixable(basePath, row, artifactRows) {
     const issuePath = artifactPathRelativeToGsd(row.path);
-    return issuePath.startsWith(`${LAYOUT_SEGMENTS.level1}/`) && hasPresentMilestonesReplacement(basePath, row, artifactRows);
+    return issuePath.startsWith(`${LAYOUT_SEGMENTS.level1}/`) &&
+        (hasPresentFlatPhaseReplacement(basePath, row, artifactRows) ||
+            hasPresentMilestonesReplacement(basePath, row, artifactRows));
 }
 function staleArtifactRowFixable(basePath, row, artifactRows) {
     return staleMilestonesArtifactRowFixable(basePath, row, artifactRows) ||
@@ -658,7 +677,7 @@ export async function checkEngineHealth(basePath, issues, fixesApplied, options)
     // block doctor.
     try {
         if (isDbAvailable()) {
-            checkProjectionCheckboxDbStatus(basePath, getAllMilestones().map((milestone) => milestone.id), issues);
+            checkProjectionCheckboxDbStatus(basePath, checkboxDbStatusMilestoneIds(basePath, getAllMilestones().map((milestone) => milestone.id)), issues);
         }
     }
     catch {

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

@@ -130,6 +130,17 @@ 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))
@@ -433,4 +444,5 @@ 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,6 +38,7 @@ 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");
@@ -169,6 +170,44 @@ 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");
@@ -207,37 +246,42 @@ export function insertMilestone(m) {
 export function upsertMilestonePlanning(milestoneId, planning) {
     if (!getDbOrNull())
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    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,
+    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);
     });
 }
 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 { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { logError, logWarning } from "./workflow-logger.js";
 // ─── Private helpers ──────────────────────────────────────────────────────
@@ -129,6 +129,8 @@ 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
@@ -219,25 +221,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);
-    forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
-    forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
+    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);
     // 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).