@monoes/monomindcli 2.9.6 → 2.9.8

package/dist/src/orgrt/daemon.js

@@ -21,7 +21,7 @@ import { KimiCodeAgentRunner } from './kimicode-runner.js';
 import { VercelAgentRunner } from './vercel-runner.js';
 import { CodexAgentRunner } from './codex-runner.js';
 import { AntigravityAgentRunner } from './antigravity-runner.js';
-import { captureCheckpoint } from './checkpoint.js';
+import { captureCheckpoint, generateChecksum, validateCheckpoint, isCheckpointExpired, restoreMailboxQueue, } from './checkpoint.js';
 import { loadGlobalFenceConfig, mergeFenceConfigs, createFenceForRole, } from './fence.js';
 // ── Extracted module imports ────────────────────────────────────────────
 import * as approvalOps from './approvals.js';
@@ -263,7 +263,7 @@ export class OrgDaemon {
             return ws;
         return isAbsolute(ws) ? ws : join(this.root, ws);
     }
-    async startOrg(name, taskOverride) {
+    async startOrg(name, taskOverride, options) {
         // A restart-driven start (scheduleBossRestart) keeps its crash counter so the
         // cap holds; any other (explicit) start resets it so a manual re-run gets a
         // fresh budget.
@@ -279,9 +279,31 @@ export class OrgDaemon {
             throw new Error(`org ${name} already running`);
         const defPath = join(this.root, ORG_DIR, `${name}.json`);
         const def = OrgDefSchema.parse(JSON.parse(readFileSync(defPath, 'utf8')));
-        // random suffix: second-precision stamps collide across processes (two CLI
-        // invocations in the same second would share a run dir and its bus.jsonl)
-        const run = `run-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)}-${Math.random().toString(36).slice(2, 6)}`;
+        let run;
+        let checkpoint;
+        if (options?.resume) {
+            const rtPath = join(this.root, ORG_DIR, name, 'runtime.json');
+            if (!existsSync(rtPath))
+                throw new Error(`cannot resume org "${name}": runtime.json not found`);
+            const rt = JSON.parse(readFileSync(rtPath, 'utf8'));
+            if (!rt?.run || !rt?.checkpoint)
+                throw new Error(`cannot resume org "${name}": no valid checkpoint found`);
+            if (isCheckpointExpired(rt.checkpoint))
+                throw new Error(`cannot resume org "${name}": checkpoint expired`);
+            if (!validateCheckpoint(rt.checkpoint))
+                throw new Error(`cannot resume org "${name}": checkpoint validation failed`);
+            run = rt.run;
+            checkpoint = rt.checkpoint;
+            if (rt.abandonedRoles) {
+                this.abandoned.set(name, new Set(rt.abandonedRoles));
+            }
+        }
+        else {
+            this.abandoned.delete(name); // a previous run's missing roles say nothing about this one
+            // random suffix: second-precision stamps collide across processes (two CLI
+            // invocations in the same second would share a run dir and its bus.jsonl)
+            run = `run-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)}-${Math.random().toString(36).slice(2, 6)}`;
+        }
         const dir = join(this.root, ORG_DIR, name, run);
         mkdirSync(dir, { recursive: true });
         // Role sessions run at the project root by default. They used to run in an
@@ -292,7 +314,6 @@ export class OrgDaemon {
         // not path-scoped, meaning the sandbox blocked the safe tools and let the
         // unrestricted one through. Opt back in with run_config.workspace:
         // 'isolated', or pin an absolute path.
-        this.abandoned.delete(name); // a previous run's missing roles say nothing about this one
         const ws = this.workspaceSetting(def);
         let cwd;
         let worktreePath;
@@ -483,7 +504,9 @@ export class OrgDaemon {
         // Extracted so a role that fails its gate check can be spawned later by
         // scheduleDeferredSpawn() once resources free up, without re-running the
         // gate logic or duplicating the session-wiring below.
-        const spawnRole = (role) => {
+        const spawnRole = (role, roleCheckpoint) => {
+            if (running.agents.has(role.id))
+                return;
             let roleCwd = cwd;
             if (ws === 'worktree-per-role' && role.id !== bossRole.id) {
                 const wtPath = join(this.root, ORG_DIR, name, `worktree-${role.id}`);
@@ -517,16 +540,32 @@ export class OrgDaemon {
                 }
             }
             const mailbox = new Mailbox();
+            if (roleCheckpoint?.mailboxQueue?.length) {
+                restoreMailboxQueue({ mailbox }, roleCheckpoint.mailboxQueue);
+            }
+            if (roleCheckpoint?.mailboxClosed) {
+                mailbox.close();
+            }
             const policy = new PolicyEngine(role.id, { maxTokens: role.budget_tokens ?? perRoleBudget, ...(role.policy ?? {}) }, bus, roleCwd);
+            if (roleCheckpoint?.tokensUsed) {
+                policy.setUsage(roleCheckpoint.tokensUsed);
+            }
             const runtime = {
                 mailbox,
                 policy,
-                status: 'running',
+                status: roleCheckpoint?.status ?? 'running',
                 done: Promise.resolve(),
-                metrics: { tokens: 0, costUsd: 0 },
+                metrics: { tokens: roleCheckpoint?.tokensUsed ?? 0, costUsd: roleCheckpoint?.costUsd ?? 0 },
+                lastMessageId: roleCheckpoint?.lastMessageId,
+                error: roleCheckpoint?.error,
+                sessionId: roleCheckpoint?.sessionId,
                 worktreePath: roleCwd !== cwd ? roleCwd : undefined,
                 scrollback: new ScrollbackBuffer(),
             };
+            if (roleCheckpoint?.scrollback?.length) {
+                for (const line of roleCheckpoint.scrollback)
+                    runtime.scrollback.push(line);
+            }
             const sessionOpts = {
                 org: name,
                 role,
@@ -540,8 +579,10 @@ export class OrgDaemon {
                 // instead of polluting the workspace cwd.
                 orgDir: join(this.root, ORG_DIR, name),
                 maxTurns: role.max_turns_per_message ?? def.run_config.max_turns_per_message,
+                resumeSessionId: roleCheckpoint?.sessionId,
                 lastMessageId: () => runtime.lastMessageId,
                 onOutput: (line) => runtime.scrollback.push(line),
+                onSessionId: (id) => { runtime.sessionId = id; },
                 deliver: (from, to, subject, body) => this.deliver(name, from, to, subject, body),
                 askHuman: (r, question) => this.askHuman(name, r, question),
                 onGate: (r, gateName, gateDesc) => this.createGate(name, r, gateName, gateDesc),
@@ -628,6 +669,18 @@ export class OrgDaemon {
                     const running = this.orgs.get(name);
                     return JSON.stringify(running?.taskDag?.all() ?? [], null, 2);
                 },
+                splitTask: (r, parentId, children) => {
+                    return this.dagSplitTask(name, r, parentId, children);
+                },
+                mergeTask: (r, sourceId, targetId) => {
+                    return this.dagMergeTask(name, r, sourceId, targetId);
+                },
+                cancelTask: (r, taskId, reason) => {
+                    return this.dagCancelTask(name, r, taskId, reason);
+                },
+                planGraph: (r, specs) => {
+                    return this.dagPlanGraph(name, r, specs);
+                },
                 queryFn: this.opts.queryFn,
                 // Runner resolution: explicit opts.runner > role `runtime` field >
                 // org def `runtime` field > MONOMIND_RUNTIME env (opencode/kimicode) >
@@ -646,133 +699,172 @@ export class OrgDaemon {
             // status chatter) so a dead agent surfaces instead of a run that
             // silently never progresses.
             const BACKOFFS_MS = this.opts.crashBackoffsMs ?? [1000, 5000, 15000];
-            runtime.done = (async () => {
-                for (let attempt = 0;; attempt++) {
-                    try {
-                        await runAgentSession(sessionOpts);
-                        runtime.status = 'ended';
-                        return;
-                    }
-                    catch (err) {
-                        // Drop the crashed session's stale waker immediately: a push()
-                        // during the backoff window must queue for the NEXT session, not
-                        // wake the dead generator to swallow it.
-                        mailbox.detach();
-                        const message = err instanceof Error ? err.message : String(err);
-                        // Exit 143 = SIGTERM. If the mailbox is already closed, we
-                        // sent the signal ourselves during stop — not a crash.
-                        const killedByStop = mailbox.isClosed && /exit(?:ed)? with code 143/.test(message);
-                        const crash = () => {
-                            if (killedByStop) {
-                                runtime.status = 'ended';
+            if (!mailbox.isClosed && runtime.status !== 'crashed') {
+                runtime.done = (async () => {
+                    for (let attempt = 0;; attempt++) {
+                        try {
+                            await runAgentSession(sessionOpts);
+                            runtime.status = 'ended';
+                            return;
+                        }
+                        catch (err) {
+                            // Drop the crashed session's stale waker immediately: a push()
+                            // during the backoff window must queue for the NEXT session, not
+                            // wake the dead generator to swallow it.
+                            mailbox.detach();
+                            const message = err instanceof Error ? err.message : String(err);
+                            const isTurnLimit = /Reached maximum number of turns|error_max_turns/i.test(message);
+                            // Bounded like every other recovery: attempt counts every pass
+                            // through this loop, so a role that keeps surfacing max-turns
+                            // errors here (session.ts already swallows the normal ones)
+                            // falls through to crash handling instead of looping forever.
+                            if (isTurnLimit && !mailbox.isClosed && attempt < BACKOFFS_MS.length) {
+                                sessionOpts.resumeSessionId = undefined;
+                                mailbox.push(`${Mailbox.CONTINUE_PREFIX} You reached the turn limit on your task. Continue your in-progress work from where you left off; if finished, end your turn.`);
                                 bus.emit({
                                     type: 'status',
                                     from: role.id,
-                                    msg: `agent "${role.id}" terminated by stop (was still working when drain window expired)`,
-                                    reason: 'terminated-by-stop',
+                                    reason: 'turn-limit-recover',
+                                    msg: `agent "${role.id}" hit turn limit error — continuing with fresh session`,
                                 });
-                                return;
+                                continue;
                             }
-                            runtime.status = 'crashed';
-                            runtime.error = message;
-                            // Close the mailbox so deliver()/receiveRemote() report a real
-                            // error instead of pushing into a queue no session will read
-                            // (and returning a false "delivered" receipt to the sender).
-                            mailbox.close();
-                            const isContextLimit = OrgDaemon.CONTEXT_LIMIT_RE.test(message);
-                            bus.emit({
-                                type: 'audit',
-                                from: role.id,
-                                msg: `agent "${role.id}" crashed: ${message}`,
-                                reason: isContextLimit ? 'agent-context-limit' : 'agent-session-crash',
-                                data: {
-                                    agentId: role.id,
-                                    error: message,
-                                    restarts: attempt,
-                                    contextLimit: isContextLimit,
-                                },
-                            });
-                            if (role.id !== bossRole.id) {
-                                // #2/#3: a worker is gone for the rest of this run. Without this
-                                // notice the coordinator keeps messaging a corpse (observed: four
-                                // unanswered org_send calls to a developer that had crashed on a
-                                // context-window limit). Tell the boss to reassign — and if the
-                                // crash was a context overflow, tell it to chunk smaller, since
-                                // re-dispatching the same task verbatim fails the same way.
-                                const bossRt = running.agents.get(bossRole.id);
-                                if (bossRt && !bossRt.mailbox.isClosed) {
-                                    const guidance = isContextLimit
-                                        ? ' This was a context-window overflow — re-dispatching the same task verbatim will fail identically. Break the work into smaller pieces (one file or section at a time) and do not paste large file contents in a single message.'
-                                        : '';
-                                    bossRt.mailbox.push(`[system] Worker "${role.id}" crashed and will not recover this run (${message}). It can no longer receive messages — stop messaging it. Reassign its outstanding work to another agent or take it on yourself.${guidance}`);
+                            // Exit 143 = SIGTERM. If the mailbox is already closed, we
+                            // sent the signal ourselves during stop — not a crash.
+                            const killedByStop = mailbox.isClosed && /exit(?:ed)? with code 143/.test(message);
+                            const crash = () => {
+                                if (killedByStop) {
+                                    runtime.status = 'ended';
                                     bus.emit({
-                                        type: 'audit',
-                                        from: bossRole.id,
-                                        reason: 'worker-crashed',
-                                        msg: `worker "${role.id}" crashed (contextLimit=${isContextLimit}); coordinator notified to reassign`,
+                                        type: 'status',
+                                        from: role.id,
+                                        msg: `agent "${role.id}" terminated by stop (was still working when drain window expired)`,
+                                        reason: 'terminated-by-stop',
                                     });
+                                    return;
+                                }
+                                runtime.status = 'crashed';
+                                runtime.error = message;
+                                // Close the mailbox so deliver()/receiveRemote() report a real
+                                // error instead of pushing into a queue no session will read
+                                // (and returning a false "delivered" receipt to the sender).
+                                mailbox.close();
+                                const isContextLimit = OrgDaemon.CONTEXT_LIMIT_RE.test(message);
+                                bus.emit({
+                                    type: 'audit',
+                                    from: role.id,
+                                    msg: `agent "${role.id}" crashed: ${message}`,
+                                    reason: isContextLimit ? 'agent-context-limit' : 'agent-session-crash',
+                                    data: {
+                                        agentId: role.id,
+                                        error: message,
+                                        restarts: attempt,
+                                        contextLimit: isContextLimit,
+                                    },
+                                });
+                                if (role.id !== bossRole.id) {
+                                    // #2/#3: a worker is gone for the rest of this run. Without this
+                                    // notice the coordinator keeps messaging a corpse (observed: four
+                                    // unanswered org_send calls to a developer that had crashed on a
+                                    // context-window limit). Tell the boss to reassign — and if the
+                                    // crash was a context overflow, tell it to chunk smaller, since
+                                    // re-dispatching the same task verbatim fails the same way.
+                                    const bossRt = running.agents.get(bossRole.id);
+                                    if (bossRt && !bossRt.mailbox.isClosed) {
+                                        const guidance = isContextLimit
+                                            ? ' This was a context-window overflow — re-dispatching the same task verbatim will fail identically. Break the work into smaller pieces (one file or section at a time) and do not paste large file contents in a single message.'
+                                            : '';
+                                        bossRt.mailbox.push(`[system] Worker "${role.id}" crashed and will not recover this run (${message}). It can no longer receive messages — stop messaging it. Reassign its outstanding work to another agent or take it on yourself.${guidance}`);
+                                        bus.emit({
+                                            type: 'audit',
+                                            from: bossRole.id,
+                                            reason: 'worker-crashed',
+                                            msg: `worker "${role.id}" crashed (contextLimit=${isContextLimit}); coordinator notified to reassign`,
+                                        });
+                                    }
+                                }
+                                else {
+                                    // #4: the coordinator itself died. Don't go silent and wait for a
+                                    // human — attempt a bounded whole-org restart with fresh sessions
+                                    // (which also sheds whatever bloated context caused the crash).
+                                    this.scheduleBossRestart(name);
                                 }
+                            };
+                            // Fatal errors (provider auth/quota/billing — tagged with
+                            // err.fatal by the runner) can NEVER be fixed by a restart: the
+                            // same call fails identically or hangs. Skip the backoff loop
+                            // and go straight to terminal crash handling instead of burning
+                            // the retry budget and wall-clock on a guaranteed failure.
+                            const fatal = err?.fatal === true;
+                            if (fatal) {
+                                bus.emit({
+                                    type: 'status',
+                                    from: role.id,
+                                    reason: 'agent-fatal',
+                                    msg: `agent "${role.id}" hit a fatal (non-retryable) error — not restarting`,
+                                });
+                                crash();
+                                return;
                             }
-                            else {
-                                // #4: the coordinator itself died. Don't go silent and wait for a
-                                // human — attempt a bounded whole-org restart with fresh sessions
-                                // (which also sheds whatever bloated context caused the crash).
-                                this.scheduleBossRestart(name);
+                            if (mailbox.isClosed || attempt >= BACKOFFS_MS.length) {
+                                crash();
+                                return;
                             }
-                        };
-                        // Fatal errors (provider auth/quota/billing — tagged with
-                        // err.fatal by the runner) can NEVER be fixed by a restart: the
-                        // same call fails identically or hangs. Skip the backoff loop
-                        // and go straight to terminal crash handling instead of burning
-                        // the retry budget and wall-clock on a guaranteed failure.
-                        const fatal = err?.fatal === true;
-                        if (fatal) {
                             bus.emit({
                                 type: 'status',
                                 from: role.id,
-                                reason: 'agent-fatal',
-                                msg: `agent "${role.id}" hit a fatal (non-retryable) error — not restarting`,
+                                reason: 'agent-restart',
+                                msg: `agent "${role.id}" crashed (${message}) — restarting in ${BACKOFFS_MS[attempt]}ms (attempt ${attempt + 1}/${BACKOFFS_MS.length})`,
                             });
-                            crash();
-                            return;
-                        }
-                        if (mailbox.isClosed || attempt >= BACKOFFS_MS.length) {
-                            crash();
-                            return;
+                            await new Promise((r) => {
+                                const t = setTimeout(r, BACKOFFS_MS[attempt]);
+                                t.unref?.();
+                            });
+                            if (mailbox.isClosed) {
+                                crash();
+                                return;
+                            } // org stopped during backoff — never recovered
                         }
-                        bus.emit({
-                            type: 'status',
-                            from: role.id,
-                            reason: 'agent-restart',
-                            msg: `agent "${role.id}" crashed (${message}) — restarting in ${BACKOFFS_MS[attempt]}ms (attempt ${attempt + 1}/${BACKOFFS_MS.length})`,
-                        });
-                        await new Promise((r) => {
-                            const t = setTimeout(r, BACKOFFS_MS[attempt]);
-                            t.unref?.();
-                        });
-                        if (mailbox.isClosed) {
-                            crash();
-                            return;
-                        } // org stopped during backoff — never recovered
                     }
-                }
-            })();
+                })();
+            }
             running.agents.set(role.id, runtime);
         };
-        spawnRole(bossRole); // always, ungated — see comment above
-        // Lazy spawn: register non-boss roles as pending. They spawn on first
-        // message (see deliver()), avoiding the memory gate stampede at startup.
-        const pendingRoles = new Map();
-        for (const role of def.roles) {
-            if (role.id === bossRole.id)
-                continue;
-            pendingRoles.set(role.id, role);
+        if (options?.resume && checkpoint) {
+            const restoredRoles = new Set(Object.keys(checkpoint.roleState));
+            for (const [roleId, roleState] of Object.entries(checkpoint.roleState)) {
+                const role = def.roles.find((r) => r.id === roleId);
+                if (role)
+                    spawnRole(role, roleState);
+            }
+            const pendingRoles = new Map();
+            for (const role of def.roles) {
+                if (!restoredRoles.has(role.id)) {
+                    pendingRoles.set(role.id, role);
+                }
+            }
+            running.pendingRoles = pendingRoles;
+            running.spawnRole = spawnRole;
+            running.taskDag = new TaskDag();
+            if (worktreePath)
+                running.worktreePath = worktreePath;
+        }
+        else {
+            spawnRole(bossRole); // always, ungated — see comment above
+            // Lazy spawn: register non-boss roles as pending. They spawn on first
+            // message (see deliver()), avoiding the memory gate stampede at startup.
+            const pendingRoles = new Map();
+            for (const role of def.roles) {
+                if (role.id === bossRole.id)
+                    continue;
+                pendingRoles.set(role.id, role);
+            }
+            running.pendingRoles = pendingRoles;
+            running.spawnRole = spawnRole;
+            running.taskDag = new TaskDag();
+            if (worktreePath)
+                running.worktreePath = worktreePath;
         }
-        running.pendingRoles = pendingRoles;
-        running.spawnRole = spawnRole;
-        running.taskDag = new TaskDag();
-        if (worktreePath)
-            running.worktreePath = worktreePath;
         // Crash cleanup: reap SDK children if this process exits abnormally.
         // monolean: process-scoped listener — upgrade path = per-org tracking
         const crashCleanup = () => {
@@ -816,25 +908,40 @@ export class OrgDaemon {
             }
         }
         const boss = bossRole;
-        // Cross-run memory: brief the coordinator on the previous run so scheduled
-        // orgs accumulate instead of starting cold every interval.
-        const prev = readHistory(this.root, name).at(-1);
-        const prevBrief = prev
-            ? `\n\nPrevious run (${prev.run}${prev.endedAt ? `, ${new Date(prev.endedAt).toISOString()}` : ''}): ` +
-                (prev.outcome
-                    ? `outcome "${prev.outcome.status}" — ${prev.outcome.summary}`
-                    : `no recorded outcome (${prev.messages} messages, ${prev.assets.length} assets${prev.crashes.length ? `, ${prev.crashes.length} crashed agent(s)` : ''})`) +
-                `\nBuild on that work — do not redo what is already done.`
-            : '';
-        running.agents
-            .get(boss.id)
-            .mailbox.push(`Org "${name}" started (run ${run}).\nGoal: ${taskOverride ?? def.goal}\n` +
-            `Coordinate your team via org_send. When the goal is achieved (or clearly can't be), record it with org_complete, then end your turn.${prevBrief}`);
-        bus.emit({
-            type: 'status',
-            msg: `org started (${def.roles.length} agents)`,
-            data: { goal: taskOverride ?? def.goal },
-        });
+        if (options?.resume) {
+            if (running.agents.get(boss.id)?.mailbox.serialize().queue.length === 0) {
+                running.agents
+                    .get(boss.id)
+                    ?.mailbox.push(`Org "${name}" resumed from checkpoint (run ${run}).\nGoal: ${taskOverride ?? def.goal}\n` +
+                    `Outstanding tasks and role states have been restored. Continue coordinating your team.`);
+            }
+            bus.emit({
+                type: 'status',
+                msg: `org resumed from checkpoint (${run})`,
+                data: { goal: taskOverride ?? def.goal },
+            });
+        }
+        else {
+            // Cross-run memory: brief the coordinator on the previous run so scheduled
+            // orgs accumulate instead of starting cold every interval.
+            const prev = readHistory(this.root, name).at(-1);
+            const prevBrief = prev
+                ? `\n\nPrevious run (${prev.run}${prev.endedAt ? `, ${new Date(prev.endedAt).toISOString()}` : ''}): ` +
+                    (prev.outcome
+                        ? `outcome "${prev.outcome.status}" — ${prev.outcome.summary}`
+                        : `no recorded outcome (${prev.messages} messages, ${prev.assets.length} assets${prev.crashes.length ? `, ${prev.crashes.length} crashed agent(s)` : ''})`) +
+                    `\nBuild on that work — do not redo what is already done.`
+                : '';
+            running.agents
+                .get(boss.id)
+                .mailbox.push(`Org "${name}" started (run ${run}).\nGoal: ${taskOverride ?? def.goal}\n` +
+                `Coordinate your team via org_send. When the goal is achieved (or clearly can't be), record it with org_complete, then end your turn.${prevBrief}`);
+            bus.emit({
+                type: 'status',
+                msg: `org started (${def.roles.length} agents)`,
+                data: { goal: taskOverride ?? def.goal },
+            });
+        }
         this.persistState(name, 'running', run);
         // Idle watchdog: a hung tool call (or a run that quietly finished without
         // org_complete) produces no bus events, and every agent just waits. After
@@ -966,7 +1073,7 @@ export class OrgDaemon {
         // Snapshot checkpoint BEFORE closing mailboxes / draining sessions — the
         // queue is emptied during the drain, so capturing afterwards loses all
         // unconsumed messages (the whole point of checkpoint-resume).
-        const stopCheckpoint = captureCheckpoint(org);
+        const stopCheckpoint = captureCheckpoint(org, 'stopped');
         // Capture THIS run's forwarder now: an autoWake-restart of the same org
         // during the long tail below (agent wait, flush, history write) would
         // register a NEW forwarder under the same name — settling/unsubscribing
@@ -1112,12 +1219,21 @@ export class OrgDaemon {
         const p = join(this.root, ORG_DIR, name, 'runtime.json');
         const missing = [...(this.abandoned.get(name) ?? [])];
         const running = org ?? this.orgs.get(name);
+        const validStatus = status === 'stopped' || status === 'crashed' ? status : 'running';
         // Pattern 3: Capture full checkpoint state for resume. On stop, finishStop
         // passes a snapshot captured BEFORE mailboxes close and sessions drain —
         // otherwise the queue is always empty by persist time.
         let checkpoint = checkpointOverride ?? null;
-        if (running) {
-            checkpoint = captureCheckpoint(running);
+        if (!checkpoint && running) {
+            checkpoint = captureCheckpoint(running, validStatus);
+        }
+        else if (checkpoint && checkpoint.status !== validStatus) {
+            const { checksum: _, ...state } = checkpoint;
+            checkpoint = {
+                ...state,
+                status: validStatus,
+                checksum: generateChecksum({ ...state, status: validStatus }),
+            };
         }
         // C4: writeJsonFileAtomic (tmp + rename) — a direct writeFileSync here
         // could leave runtime.json truncated on Ctrl-C during `org stop`, which
@@ -1216,6 +1332,18 @@ export class OrgDaemon {
     dagCompleteTask(org, role, taskId, result) {
         return decisionOps.dagCompleteTask(this, org, role, taskId, result);
     }
+    dagSplitTask(org, role, parentId, children) {
+        return decisionOps.dagSplitTask(this, org, role, parentId, children);
+    }
+    dagMergeTask(org, role, sourceId, targetId) {
+        return decisionOps.dagMergeTask(this, org, role, sourceId, targetId);
+    }
+    dagCancelTask(org, role, taskId, reason) {
+        return decisionOps.dagCancelTask(this, org, role, taskId, reason);
+    }
+    dagPlanGraph(org, role, specs) {
+        return decisionOps.dagPlanGraph(this, org, role, specs);
+    }
     recordDecision(org, role, decision) {
         decisionOps.recordDecision(this, org, role, decision);
     }