gsd-pi 2.78.1-dev.9d08d820b → 2.78.1-dev.b0759e59b

package/dist/resources/extensions/gsd/slice-cadence.js

@@ -22,11 +22,13 @@ import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { execFileSync } from "node:child_process";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
-import { MergeConflictError } from "./git-service.js";
-import { nativeBranchForceReset, nativeCheckoutBranch, nativeCommit, nativeCommitCountBetween, nativeConflictFiles, nativeDetectMainBranch, nativeMergeSquash, } from "./native-git-bridge.js";
+import { MergeConflictError, readIntegrationBranch } from "./git-service.js";
+import { nativeBranchForceReset, nativeBranchExists, nativeCheckoutBranch, nativeCommit, nativeCommitCountBetween, nativeConflictFiles, nativeDetectMainBranch, nativeMergeSquash, } from "./native-git-bridge.js";
 import { resolveGitDir } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
 import { emitSliceMerged, emitMilestoneResquash } from "./worktree-telemetry.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 /**
  * Auto-worktree milestone branch name. Must match autoWorktreeBranch() in
  * auto-worktree.ts; duplicated here to avoid a cyclic import.
@@ -34,6 +36,16 @@ import { emitSliceMerged, emitMilestoneResquash } from "./worktree-telemetry.js"
 function milestoneBranchName(milestoneId) {
     return `milestone/${milestoneId}`;
 }
+function resolveIntegrationBranch(projectRoot, milestoneId) {
+    const recorded = readIntegrationBranch(projectRoot, milestoneId);
+    if (recorded && nativeBranchExists(projectRoot, recorded))
+        return recorded;
+    const prefs = loadEffectiveGSDPreferences(projectRoot)?.preferences?.git ?? {};
+    const configured = prefs.main_branch;
+    if (configured && nativeBranchExists(projectRoot, configured))
+        return configured;
+    return nativeDetectMainBranch(projectRoot);
+}
 function cleanupMergeArtifacts(projectRoot) {
     try {
         const gitDir = resolveGitDir(projectRoot);
@@ -47,6 +59,39 @@ function cleanupMergeArtifacts(projectRoot) {
         logWarning("worktree", `merge artifact cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+function advanceMilestoneBranch(projectRoot, worktreeCwd, milestoneBranch, mainBranch) {
+    let worktreeBranch = null;
+    try {
+        worktreeBranch = execFileSync("git", ["branch", "--show-current"], {
+            cwd: worktreeCwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        }).trim();
+    }
+    catch {
+        worktreeBranch = null;
+    }
+    if (worktreeCwd !== projectRoot && worktreeBranch === milestoneBranch) {
+        const status = execFileSync("git", ["status", "--porcelain"], {
+            cwd: worktreeCwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        }).trim();
+        if (status) {
+            throw new GSDError(GSD_GIT_ERROR, `slice-cadence cannot advance ${milestoneBranch}: worktree has uncommitted changes. Status:\n${status}`);
+        }
+        execFileSync("git", ["reset", "--hard", mainBranch], {
+            cwd: worktreeCwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        });
+        return;
+    }
+    nativeBranchForceReset(projectRoot, milestoneBranch, mainBranch);
+}
 /**
  * Squash-merge one slice's commits from the milestone branch to main.
  *
@@ -67,7 +112,10 @@ export function mergeSliceToMain(projectRoot, milestoneId, sliceId) {
     const started = Date.now();
     const worktreeCwd = process.cwd();
     const milestoneBranch = milestoneBranchName(milestoneId);
-    const mainBranch = nativeDetectMainBranch(projectRoot);
+    const mainBranch = resolveIntegrationBranch(projectRoot, milestoneId);
+    if (mainBranch === milestoneBranch) {
+        throw new GSDError(GSD_GIT_ERROR, `slice-cadence resolved integration branch "${mainBranch}" to the milestone branch; refusing to self-merge.`);
+    }
     // Fast path: if the milestone branch has no commits ahead of main, there
     // is nothing to merge. Return a skip result instead of no-op'ing silently
     // so the caller's telemetry shows the decision.
@@ -127,9 +175,10 @@ export function mergeSliceToMain(projectRoot, milestoneId, sliceId) {
         // Commit the squash with a slice-scoped message
         const commitSha = nativeCommit(projectRoot, `gsd: merge ${sliceId} of ${milestoneId} (slice-cadence)`);
         // Advance the milestone branch to main so the next slice's commits start
-        // from a clean base. Force-reset is safe because we just merged this
-        // branch's entire delta.
-        nativeBranchForceReset(projectRoot, milestoneBranch, mainBranch);
+        // from a clean base. When the milestone branch is checked out in an auto
+        // worktree, Git refuses a project-root branch -f; reset from inside the
+        // checked-out worktree instead.
+        advanceMilestoneBranch(projectRoot, worktreeCwd, milestoneBranch, mainBranch);
         const durationMs = Date.now() - started;
         try {
             emitSliceMerged(projectRoot, milestoneId, sliceId, {
@@ -169,7 +218,7 @@ export function mergeSliceToMain(projectRoot, milestoneId, sliceId) {
  * No-op (returns false) if startSha equals HEAD (nothing to re-squash).
  */
 export function resquashMilestoneOnMain(projectRoot, milestoneId, startSha) {
-    const mainBranch = nativeDetectMainBranch(projectRoot);
+    const mainBranch = resolveIntegrationBranch(projectRoot, milestoneId);
     const worktreeCwd = process.cwd();
     process.chdir(projectRoot);
     try {

package/dist/resources/extensions/gsd/token-counter.js

@@ -1,5 +1,6 @@
 const CHARS_PER_TOKEN_BY_PROVIDER = {
     anthropic: 3.5,
+    "claude-code": 3.5,
     openai: 4.0,
     google: 4.0,
     mistral: 3.8,

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -74,11 +74,12 @@ function validateParams(params) {
         throw new Error("goal is required");
     return {
         ...params,
-        // Apply defaults for optional enrichment fields (#2771)
-        successCriteria: params.successCriteria ?? "Not provided.",
-        proofLevel: params.proofLevel ?? "Not provided.",
-        integrationClosure: params.integrationClosure ?? "Not provided.",
-        observabilityImpact: params.observabilityImpact ?? "Not provided.",
+        // Keep optional enrichment fields empty when omitted. The renderer supplies
+        // conservative defaults where needed, without surfacing placeholder prose.
+        successCriteria: params.successCriteria ?? "",
+        proofLevel: params.proofLevel ?? "",
+        integrationClosure: params.integrationClosure ?? "",
+        observabilityImpact: params.observabilityImpact ?? "",
         tasks: validateTasks(params.tasks),
     };
 }

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -1,9 +1,9 @@
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
-import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
-import { getMilestone, getSliceStatusSummary, getSliceTaskCounts, readTransaction, saveGateResult, } from "../gsd-db.js";
+import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot, shouldBlockRootArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
+import { getActiveRequirements, getMilestone, getSliceStatusSummary, getSliceTaskCounts, readTransaction, saveGateResult, } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
-import { saveArtifactToDb } from "../db-writer.js";
+import { generateRequirementsMd, saveArtifactToDb } from "../db-writer.js";
 import { resolveMilestoneFile, resolveSliceFile } from "../paths.js";
 import { unlinkSync } from "node:fs";
 import { handleCompleteMilestone } from "./complete-milestone.js";
@@ -16,10 +16,27 @@ import { handleReassessRoadmap } from "./reassess-roadmap.js";
 import { handleValidateMilestone } from "./validate-milestone.js";
 import { logError, logWarning } from "../workflow-logger.js";
 import { invalidateStateCache } from "../state.js";
-export const SUPPORTED_SUMMARY_ARTIFACT_TYPES = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT", "CONTEXT-DRAFT"];
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+export const SUPPORTED_SUMMARY_ARTIFACT_TYPES = [
+    "SUMMARY",
+    "RESEARCH",
+    "CONTEXT",
+    "ASSESSMENT",
+    "CONTEXT-DRAFT",
+    "PROJECT",
+    "PROJECT-DRAFT",
+    "REQUIREMENTS",
+    "REQUIREMENTS-DRAFT",
+];
 export function isSupportedSummaryArtifactType(artifactType) {
     return SUPPORTED_SUMMARY_ARTIFACT_TYPES.includes(artifactType);
 }
+function isRootSummaryArtifactType(artifactType) {
+    return artifactType === "PROJECT" ||
+        artifactType === "PROJECT-DRAFT" ||
+        artifactType === "REQUIREMENTS" ||
+        artifactType === "REQUIREMENTS-DRAFT";
+}
 export async function executeSummarySave(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {
@@ -36,7 +53,24 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
             isError: true,
         };
     }
-    const contextGuard = shouldBlockContextArtifactSaveInSnapshot(loadWriteGateSnapshot(basePath), params.artifact_type, params.milestone_id ?? null, params.slice_id ?? null);
+    if (!isRootSummaryArtifactType(params.artifact_type) && !params.milestone_id) {
+        return {
+            content: [{ type: "text", text: `Error: milestone_id is required for artifact_type "${params.artifact_type}". Root-level artifacts must use PROJECT, PROJECT-DRAFT, REQUIREMENTS, or REQUIREMENTS-DRAFT.` }],
+            details: { operation: "save_summary", error: "missing_milestone_id" },
+            isError: true,
+        };
+    }
+    const writeGateSnapshot = loadWriteGateSnapshot(basePath);
+    const prefs = loadEffectiveGSDPreferences(basePath)?.preferences;
+    const rootArtifactGuard = shouldBlockRootArtifactSaveInSnapshot(writeGateSnapshot, params.artifact_type, { requireVerifiedApproval: prefs?.planning_depth === "deep" });
+    if (rootArtifactGuard.block) {
+        return {
+            content: [{ type: "text", text: `Error saving artifact: ${rootArtifactGuard.reason ?? "root artifact write blocked"}` }],
+            details: { operation: "save_summary", error: "root_artifact_write_blocked" },
+            isError: true,
+        };
+    }
+    const contextGuard = shouldBlockContextArtifactSaveInSnapshot(writeGateSnapshot, params.artifact_type, params.milestone_id ?? null, params.slice_id ?? null);
     if (contextGuard.block) {
         return {
             content: [{ type: "text", text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
@@ -46,7 +80,19 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
     }
     try {
         let relativePath;
-        if (params.task_id && params.slice_id) {
+        if (params.artifact_type === "PROJECT") {
+            relativePath = "PROJECT.md";
+        }
+        else if (params.artifact_type === "PROJECT-DRAFT") {
+            relativePath = "PROJECT-DRAFT.md";
+        }
+        else if (params.artifact_type === "REQUIREMENTS") {
+            relativePath = "REQUIREMENTS.md";
+        }
+        else if (params.artifact_type === "REQUIREMENTS-DRAFT") {
+            relativePath = "REQUIREMENTS-DRAFT.md";
+        }
+        else if (params.task_id && params.slice_id) {
             relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/tasks/${params.task_id}-${params.artifact_type}.md`;
         }
         else if (params.slice_id) {
@@ -55,13 +101,30 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         else {
             relativePath = `milestones/${params.milestone_id}/${params.milestone_id}-${params.artifact_type}.md`;
         }
+        const activeRequirements = params.artifact_type === "REQUIREMENTS"
+            ? getActiveRequirements()
+            : null;
+        if (params.artifact_type === "REQUIREMENTS" && activeRequirements?.length === 0) {
+            return {
+                content: [{ type: "text", text: "Error: Cannot save REQUIREMENTS artifact — no active requirements found in the database. Call gsd_requirement_save for each requirement before calling gsd_summary_save(REQUIREMENTS)." }],
+                details: { operation: "save_summary", error: "no_active_requirements" },
+                isError: true,
+            };
+        }
+        const contentToSave = params.artifact_type === "REQUIREMENTS"
+            ? generateRequirementsMd(activeRequirements ?? [])
+            : params.content;
+        const contentSource = params.artifact_type === "REQUIREMENTS"
+            ? "requirements_table"
+            : "provided_content";
+        const isRootArtifact = isRootSummaryArtifactType(params.artifact_type);
         await saveArtifactToDb({
             path: relativePath,
             artifact_type: params.artifact_type,
-            content: params.content,
-            milestone_id: params.milestone_id,
-            slice_id: params.slice_id,
-            task_id: params.task_id,
+            content: contentToSave,
+            milestone_id: isRootArtifact ? undefined : params.milestone_id,
+            slice_id: isRootArtifact ? undefined : params.slice_id,
+            task_id: isRootArtifact ? undefined : params.task_id,
         }, basePath);
         if (params.artifact_type === "CONTEXT" && !params.task_id) {
             try {
@@ -77,7 +140,7 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         }
         return {
             content: [{ type: "text", text: `Saved ${params.artifact_type} artifact to ${relativePath}` }],
-            details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type },
+            details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type, content_source: contentSource },
         };
     }
     catch (err) {

package/dist/resources/extensions/gsd/unit-context-manifest.js

@@ -122,6 +122,12 @@ export const KNOWN_UNIT_TYPES = [
     "run-uat",
     "gate-evaluate",
     "rewrite-docs",
+    // Deep planning mode (project-level) units
+    "workflow-preferences",
+    "discuss-project",
+    "discuss-requirements",
+    "research-decision",
+    "research-project",
 ];
 export const UNIT_MANIFESTS = {
     // ─── Milestone-scoped ────────────────────────────────────────────────
@@ -175,7 +181,11 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: false,
         preferences: "active-only",
-        tools: TOOLS_PLANNING,
+        // planning-dispatch: validation is a verification-fan-out unit. It reads
+        // the milestone surface and dispatches reviewer/security/tester subagents
+        // to report findings without touching user source. Mirrors
+        // complete-milestone's policy. Write isolation to .gsd/ is preserved.
+        tools: TOOLS_PLANNING_DISPATCH_REVIEW,
         artifacts: {
             inline: ["roadmap", "slice-summary", "slice-uat", "requirements", "decisions", "templates"],
             excerpt: [],
@@ -381,6 +391,91 @@ export const UNIT_MANIFESTS = {
         },
         maxSystemPromptChars: COMMON_BUDGET_MEDIUM,
     },
+    // ─── Deep planning mode (project-level) units ────────────────────────
+    // workflow-preferences: default-writing stage that records
+    // commit_policy / branch_model in PREFERENCES.md, defaults
+    // uat_dispatch/executor_class, and records the research decision. No project artifacts needed.
+    "workflow-preferences": {
+        skills: { mode: "none" },
+        knowledge: "none",
+        memory: "none",
+        codebaseMap: false,
+        preferences: "none",
+        tools: TOOLS_PLANNING,
+        artifacts: {
+            inline: [],
+            excerpt: [],
+            onDemand: [],
+        },
+        maxSystemPromptChars: COMMON_BUDGET_SMALL,
+    },
+    // discuss-project: PROJECT.md interview (deep mode only). Project-scoped
+    // discussion runs before any milestone exists, so milestone artifacts are
+    // not loaded. Keeps templates available for PROJECT.md scaffolding.
+    "discuss-project": {
+        skills: { mode: "all" },
+        knowledge: "scoped",
+        memory: "prompt-relevant",
+        codebaseMap: true,
+        preferences: "active-only",
+        tools: TOOLS_PLANNING,
+        artifacts: {
+            inline: ["templates"],
+            excerpt: [],
+            onDemand: [],
+        },
+        maxSystemPromptChars: COMMON_BUDGET_MEDIUM,
+    },
+    // discuss-requirements: REQUIREMENTS.md interview. PROJECT.md is the
+    // primary context input; templates carry the requirements format.
+    "discuss-requirements": {
+        skills: { mode: "all" },
+        knowledge: "scoped",
+        memory: "prompt-relevant",
+        codebaseMap: true,
+        preferences: "active-only",
+        tools: TOOLS_PLANNING,
+        artifacts: {
+            inline: ["project", "templates"],
+            excerpt: [],
+            onDemand: [],
+        },
+        maxSystemPromptChars: COMMON_BUDGET_MEDIUM,
+    },
+    // research-decision: lightweight one-question yes/no unit. Writes a
+    // marker JSON; no project artifacts needed.
+    "research-decision": {
+        skills: { mode: "none" },
+        knowledge: "none",
+        memory: "none",
+        codebaseMap: false,
+        preferences: "none",
+        tools: TOOLS_PLANNING,
+        artifacts: {
+            inline: [],
+            excerpt: [],
+            onDemand: [],
+        },
+        maxSystemPromptChars: COMMON_BUDGET_SMALL,
+    },
+    // research-project: orchestrator that fans out 4 parallel scout subagents
+    // for project research (stack, features, architecture, pitfalls). Needs the
+    // planning-dispatch policy to dispatch them. PROJECT.md + REQUIREMENTS.md
+    // give the orchestrator the framing context.
+    "research-project": {
+        skills: { mode: "all" },
+        knowledge: "scoped",
+        memory: "prompt-relevant",
+        codebaseMap: true,
+        preferences: "active-only",
+        tools: { mode: "planning-dispatch", allowedSubagents: ["scout"] },
+        artifacts: {
+            inline: ["project", "requirements", "templates"],
+            excerpt: [],
+            onDemand: [],
+        },
+        maxSystemPromptChars: COMMON_BUDGET_MEDIUM,
+    },
 };
 // ─── Lookup helper ────────────────────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/unit-runtime.js

@@ -1,8 +1,72 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { atomicWriteSync } from "./atomic-write.js";
 import { gsdRoot, relSliceFile, relTaskFile, resolveSliceFile, resolveTaskFile, } from "./paths.js";
 import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
 import { parseUnitId } from "./unit-id.js";
+// Per-record advisory lock — prevents read-modify-write races between
+// concurrent writers updating disjoint fields of the same runtime record.
+// Within a single Node process this is moot (writeUnitRuntimeRecord is sync),
+// but cross-process callers (parallel slice executors, doctor --fix while a
+// detached auto-mode session is alive) can otherwise clobber each other.
+const RECORD_LOCK_TIMEOUT_MS = 2_000;
+const RECORD_LOCK_STALE_MS = 5_000;
+const RECORD_LOCK_SLEEP_BUFFER = new SharedArrayBuffer(4);
+const RECORD_LOCK_SLEEP_VIEW = new Int32Array(RECORD_LOCK_SLEEP_BUFFER);
+function withRecordLock(recordPath, fn) {
+    const lockPath = recordPath + ".lock";
+    try {
+        mkdirSync(dirname(lockPath), { recursive: true });
+    }
+    catch {
+        // best-effort
+    }
+    const deadline = Date.now() + RECORD_LOCK_TIMEOUT_MS;
+    while (true) {
+        try {
+            // O_EXCL atomic create-if-not-exists.
+            closeSync(openSync(lockPath, "wx"));
+            break;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            // Existing lock — check for staleness before either waiting or stealing.
+            try {
+                const stat = statSync(lockPath);
+                if (Date.now() - stat.mtimeMs > RECORD_LOCK_STALE_MS) {
+                    try {
+                        unlinkSync(lockPath);
+                    }
+                    catch { /* race: already removed */ }
+                    continue;
+                }
+            }
+            catch {
+                // stat failed (file removed between EEXIST and stat) — retry create.
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                // Last-resort steal — unlikely in practice but avoids permanent wedge.
+                try {
+                    unlinkSync(lockPath);
+                }
+                catch { /* race */ }
+                continue;
+            }
+            Atomics.wait(RECORD_LOCK_SLEEP_VIEW, 0, 0, 5);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            unlinkSync(lockPath);
+        }
+        catch { /* best-effort */ }
+    }
+}
 function runtimeDir(basePath) {
     return join(gsdRoot(basePath), "runtime", "units");
 }
@@ -12,29 +76,29 @@ function runtimePath(basePath, unitType, unitId) {
     return join(runtimeDir(basePath), `${sanitizedUnitType}-${sanitizedUnitId}.json`);
 }
 export function writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, updates = {}) {
-    const dir = runtimeDir(basePath);
-    mkdirSync(dir, { recursive: true });
     const path = runtimePath(basePath, unitType, unitId);
-    const prev = readUnitRuntimeRecord(basePath, unitType, unitId);
-    const next = {
-        version: 1,
-        unitType,
-        unitId,
-        startedAt,
-        updatedAt: Date.now(),
-        phase: updates.phase ?? prev?.phase ?? "dispatched",
-        wrapupWarningSent: updates.wrapupWarningSent ?? prev?.wrapupWarningSent ?? false,
-        continueHereFired: updates.continueHereFired ?? prev?.continueHereFired ?? false,
-        timeoutAt: updates.timeoutAt ?? prev?.timeoutAt ?? null,
-        lastProgressAt: updates.lastProgressAt ?? prev?.lastProgressAt ?? Date.now(),
-        progressCount: updates.progressCount ?? prev?.progressCount ?? 0,
-        lastProgressKind: updates.lastProgressKind ?? prev?.lastProgressKind ?? "dispatch",
-        recovery: updates.recovery ?? prev?.recovery,
-        recoveryAttempts: updates.recoveryAttempts ?? prev?.recoveryAttempts ?? 0,
-        lastRecoveryReason: updates.lastRecoveryReason ?? prev?.lastRecoveryReason,
-    };
-    writeFileSync(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
-    return next;
+    return withRecordLock(path, () => {
+        const prev = readUnitRuntimeRecord(basePath, unitType, unitId);
+        const next = {
+            version: 1,
+            unitType,
+            unitId,
+            startedAt,
+            updatedAt: Date.now(),
+            phase: updates.phase ?? prev?.phase ?? "dispatched",
+            wrapupWarningSent: updates.wrapupWarningSent ?? prev?.wrapupWarningSent ?? false,
+            continueHereFired: updates.continueHereFired ?? prev?.continueHereFired ?? false,
+            timeoutAt: updates.timeoutAt ?? prev?.timeoutAt ?? null,
+            lastProgressAt: updates.lastProgressAt ?? prev?.lastProgressAt ?? Date.now(),
+            progressCount: updates.progressCount ?? prev?.progressCount ?? 0,
+            lastProgressKind: updates.lastProgressKind ?? prev?.lastProgressKind ?? "dispatch",
+            recovery: updates.recovery ?? prev?.recovery,
+            recoveryAttempts: updates.recoveryAttempts ?? prev?.recoveryAttempts ?? 0,
+            lastRecoveryReason: updates.lastRecoveryReason ?? prev?.lastRecoveryReason,
+        };
+        atomicWriteSync(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
+        return next;
+    });
 }
 export function readUnitRuntimeRecord(basePath, unitType, unitId) {
     const path = runtimePath(basePath, unitType, unitId);

package/dist/resources/extensions/gsd/uok/plan-v2.js

@@ -48,6 +48,9 @@ export function hasFinalizedMilestoneContext(basePath, milestoneId) {
 export function isMissingFinalizedContextResult(result) {
     return !result.ok && result.finalizedContextIncluded === false;
 }
+export function isEmptyPlanV2GraphResult(result) {
+    return !result.ok && result.emptyGraph === true;
+}
 function countSliceResearchArtifacts(basePath, milestoneId, slices) {
     let count = 0;
     for (const slice of slices) {
@@ -138,6 +141,7 @@ export function compileUnitGraphFromState(basePath, state) {
         ok: true,
         graphPath: outPath,
         nodeCount: nodes.length,
+        sliceCount: slices.length,
         clarifyRoundLimit,
         researchSynthesized: output.pipeline.researchSynthesized,
         draftContextIncluded: output.pipeline.draftContextIncluded,
@@ -149,7 +153,16 @@ export function ensurePlanV2Graph(basePath, state) {
     if (!compiled.ok)
         return compiled;
     if ((compiled.nodeCount ?? 0) <= 0) {
-        return { ok: false, reason: "compiled graph is empty" };
+        if ((state.phase === "validating-milestone" || state.phase === "completing-milestone") &&
+            (compiled.sliceCount ?? 0) > 0) {
+            return compiled;
+        }
+        return {
+            ...compiled,
+            ok: false,
+            reason: "compiled graph is empty",
+            emptyGraph: true,
+        };
     }
     return compiled;
 }