@monoes/monomindcli 2.9.2 → 2.9.4

package/dist/src/orgrt/daemon.js

@@ -1,7 +1,7 @@
 // packages/@monomind/cli/src/orgrt/daemon.ts
 // monolean: single-process inter-org — upgrade path = daemon-to-daemon HTTP when multi-host is real
 import { readFileSync, mkdirSync, existsSync, unlinkSync } from 'node:fs';
-import { execSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 import { join, isAbsolute } from 'node:path';
 import { writeJsonFileAtomic } from '../utils/json-file.js';
 import { reapOrphanedSdkProcesses } from '../utils/resource-governor.js';
@@ -12,13 +12,17 @@ import { runAgentSession } from './session.js';
 import { attachForwarder } from './forwarder.js';
 import { BrokerLease, normalizeCredential } from './broker.js';
 import { drainInbox } from './inbox.js';
-import { OrgDefSchema, ORG_DIR } from './types.js';
+import { OrgDefSchema, ORG_DIR, } from './types.js';
 import { TaskDag } from './task-dag.js';
-import { summarizeRun, readRunEvents, readHistory, historyFile } from './reporting.js';
+import { summarizeRun, readRunEvents, readHistory, historyFile, } from './reporting.js';
 import { getResourceLimits, configureResourceLimits } from '../utils/resource-governor.js';
 import { OpencodeAgentRunner } from './opencode-runner.js';
 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 { loadGlobalFenceConfig, mergeFenceConfigs, createFenceForRole, } from './fence.js';
 // ── Extracted module imports ────────────────────────────────────────────
 import * as approvalOps from './approvals.js';
 import * as questionOps from './questions.js';
@@ -31,7 +35,9 @@ import * as checkpointOps from './checkpoint-ops.js';
 class OtelTracer {
     enabled = false;
     spans = new Map();
-    enable() { this.enabled = true; }
+    enable() {
+        this.enabled = true;
+    }
     startSpan(name, metadata = {}) {
         if (!this.enabled)
             return;
@@ -57,31 +63,47 @@ class OtelTracer {
  *  for a sibling mid-build or mid-test to finish and flush its work. A hard
  *  stop keeps the short bound — see finishStop. */
 const COMPLETE_DRAIN_MS = 5 * 60_000;
-/** Resolve which AgentRunner hosts an org's role sessions.
- *  Precedence: role `runtime` field > org def `runtime` field >
- *  MONOMIND_RUNTIME env > undefined (the default path, where session.ts
- *  falls back to ClaudeAgentRunner). Returning undefined for the default
- *  path keeps Claude/Antigravity orgs byte-for-byte unchanged. Callers
- *  pass `role.runtime ?? def.runtime` as `orgRuntime` (see resolveRoleRunner). */
-export function resolveRunner(orgRuntime) {
-    const selected = orgRuntime ?? process.env.MONOMIND_RUNTIME;
+/** Auto-resolve runtime from provider kind. Returns undefined for Claude default. */
+function autoRuntimeFromProvider(kind) {
+    if (kind === 'vercel-api-key')
+        return 'vercel';
+    if (kind === 'codex')
+        return 'codex';
+    if (kind === 'antigravity')
+        return 'antigravity';
+    return undefined;
+}
+export function resolveRunner(orgRuntime, providerKind) {
+    const selected = orgRuntime ??
+        autoRuntimeFromProvider(providerKind) ??
+        process.env.MONOMIND_RUNTIME;
     if (selected === 'opencode')
         return new OpencodeAgentRunner();
     if (selected === 'kimicode')
         return new KimiCodeAgentRunner();
+    if (selected === 'vercel')
+        return new VercelAgentRunner();
+    if (selected === 'codex')
+        return new CodexAgentRunner();
+    if (selected === 'antigravity')
+        return new AntigravityAgentRunner();
     return undefined;
 }
 /** Per-session variant: a role's own `runtime` field wins over the org-level
  *  one (and the env var) — including `role.runtime === 'claude'`, which forces
  *  the default Claude path even when the org/env select another runtime.
- *  Roles without a `runtime` inherit the org-level resolution unchanged. */
-export function resolveRoleRunner(roleRuntime, orgRuntime) {
-    return resolveRunner(roleRuntime ?? orgRuntime);
+ *  Roles without a `runtime` inherit the org-level resolution unchanged.
+ *  If no explicit runtime is set, auto-resolve from the provider kind. */
+export function resolveRoleRunner(roleRuntime, orgRuntime, roleProviderKind, orgProviderKind) {
+    const explicit = roleRuntime ?? orgRuntime;
+    if (explicit)
+        return resolveRunner(explicit);
+    return resolveRunner(undefined, roleProviderKind ?? orgProviderKind);
 }
 /** Per-role token budget: a role's own `budget_tokens` wins; otherwise the
  *  even split of run_config.budget_tokens across all roles. */
 export function roleTokenBudget(role, def) {
-    return role.budget_tokens ?? Math.floor((def.run_config.budget_tokens ?? 1_000_000) / def.roles.length);
+    return (role.budget_tokens ?? Math.floor((def.run_config.budget_tokens ?? 1_000_000) / def.roles.length));
 }
 /** Bounded ring buffer for agent terminal scrollback. */
 export class ScrollbackBuffer {
@@ -95,8 +117,12 @@ export class ScrollbackBuffer {
         if (this.lines.length > this.maxLines)
             this.lines.splice(0, this.lines.length - this.maxLines);
     }
-    snapshot() { return [...this.lines]; }
-    clear() { this.lines.length = 0; }
+    snapshot() {
+        return [...this.lines];
+    }
+    clear() {
+        this.lines.length = 0;
+    }
 }
 export class OrgDaemon {
     root;
@@ -124,7 +150,9 @@ export class OrgDaemon {
     /** @internal */ recallUsage = new Map();
     /** @internal */ orgLearnedRuns = new Set();
     /** @internal */ abandoned = new Map();
-    constructor(/** @internal */ root, /** @internal */ opts = {}) {
+    constructor(
+    /** @internal */ root, 
+    /** @internal */ opts = {}) {
         this.root = root;
         this.opts = opts;
     }
@@ -139,8 +167,12 @@ export class OrgDaemon {
         this.globalSubscribers.add(fn);
         return () => this.globalSubscribers.delete(fn);
     }
-    listOrgs() { return [...this.orgs.values()]; }
-    getOrg(name) { return this.orgs.get(name); }
+    listOrgs() {
+        return [...this.orgs.values()];
+    }
+    getOrg(name) {
+        return this.orgs.get(name);
+    }
     /** Hot-reload an org definition from disk without stopping running sessions.
      *  Applies: goal, run_config, schedule. New roles are added as pending (lazy-spawnable).
      *  Removed roles are NOT killed — they finish their current work and won't be re-spawned.
@@ -166,8 +198,8 @@ export class OrgDaemon {
                 changed.push(`run_config.${key}`);
             }
         }
-        const existingRoleIds = new Set(running.def.roles.map(r => r.id));
-        const newRoleIds = new Set(newDef.roles.map(r => r.id));
+        const existingRoleIds = new Set(running.def.roles.map((r) => r.id));
+        const newRoleIds = new Set(newDef.roles.map((r) => r.id));
         for (const role of newDef.roles) {
             if (!existingRoleIds.has(role.id)) {
                 running.def.roles.push(role);
@@ -181,16 +213,23 @@ export class OrgDaemon {
             if (!newRoleIds.has(id))
                 removedRoles.push(id);
         }
-        running.bus.emit({ type: 'audit', reason: 'hot-reload',
+        running.bus.emit({
+            type: 'audit',
+            reason: 'hot-reload',
             msg: `org def reloaded: ${changed.length} fields changed, ${newRoles.length} new roles, ${removedRoles.length} removed roles`,
-            data: { changed, newRoles, removedRoles } });
+            data: { changed, newRoles, removedRoles },
+        });
         return { changed, newRoles, removedRoles };
     }
     /** Names of the orgs this daemon currently has running. Snapshot — safe to
      *  iterate while stopOrg() mutates the underlying map. */
-    listRunning() { return [...this.orgs.keys()]; }
+    listRunning() {
+        return [...this.orgs.keys()];
+    }
     /** Hook for the SSE server — registers a listener for all bus events across all orgs. */
-    onBusEvent = (fn) => { this.subscribe(fn); };
+    onBusEvent = (fn) => {
+        this.subscribe(fn);
+    };
     /** Snapshot of all running orgs for dashboard initial load. */
     getStatusSnapshot = () => {
         const orgs = [];
@@ -198,13 +237,15 @@ export class OrgDaemon {
             const roles = [];
             for (const [roleId, agent] of running.agents) {
                 roles.push({
-                    id: roleId, status: agent.status,
+                    id: roleId,
+                    status: agent.status,
                     worktree: agent.worktreePath ?? null,
                     metrics: agent.metrics,
                 });
             }
             orgs.push({
-                name, run: running.run,
+                name,
+                run: running.run,
                 roles,
                 pendingRoles: running.pendingRoles ? [...running.pendingRoles.keys()] : [],
                 tasks: running.taskDag?.all() ?? [],
@@ -228,6 +269,12 @@ export class OrgDaemon {
         // fresh budget.
         if (!this.restarting.has(name))
             this.bossRestartCounts.delete(name);
+        // Join any in-flight stop for this org before checking `this.orgs` — otherwise a
+        // start racing a stop's drain window (up to stopWaitMs) can share the stopping
+        // run's worktree path while it's still being force-removed.
+        const inflightStop = this.stopping.get(name);
+        if (inflightStop)
+            await inflightStop;
         if (this.orgs.has(name))
             throw new Error(`org ${name} already running`);
         const defPath = join(this.root, ORG_DIR, `${name}.json`);
@@ -251,23 +298,37 @@ export class OrgDaemon {
         let worktreePath;
         if (ws === 'worktree') {
             worktreePath = join(this.root, ORG_DIR, name, 'worktree');
-            const { execSync } = await import('node:child_process');
+            const { execFileSync } = await import('node:child_process');
             try {
                 // Remove stale worktree from a previous run
                 if (existsSync(worktreePath)) {
                     // R4: bound the call — a wedged git hook (git-lfs, gc lock, gpg sign
                     // prompt) would otherwise hang the whole daemon indefinitely.
-                    execSync(`git worktree remove --force "${worktreePath}"`, { cwd: this.root, stdio: 'ignore', timeout: 30_000 });
+                    // SEC-5: execFileSync + argv — no shell interpolation of worktreePath.
+                    execFileSync('git', ['worktree', 'remove', '--force', worktreePath], {
+                        cwd: this.root,
+                        stdio: 'ignore',
+                        timeout: 30_000,
+                    });
                 }
             }
-            catch { /* best-effort cleanup */ }
-            execSync(`git worktree add "${worktreePath}" HEAD --detach`, { cwd: this.root, stdio: 'ignore', timeout: 30_000 });
+            catch {
+                /* best-effort cleanup */
+            }
+            execFileSync('git', ['worktree', 'add', worktreePath, 'HEAD', '--detach'], {
+                cwd: this.root,
+                stdio: 'ignore',
+                timeout: 30_000,
+            });
             cwd = worktreePath;
         }
         else {
-            cwd = ws === 'repo' ? this.root
-                : ws === 'isolated' ? join(this.root, ORG_DIR, name, 'workspace')
-                    : ws;
+            cwd =
+                ws === 'repo'
+                    ? this.root
+                    : ws === 'isolated'
+                        ? join(this.root, ORG_DIR, name, 'workspace')
+                        : ws;
         }
         mkdirSync(cwd, { recursive: true });
         // An org must be able to seat its whole roster. maxSdkProcesses is sized for
@@ -276,7 +337,14 @@ export class OrgDaemon {
         // its 7th, and the work that role owned simply never happened. Raise the
         // ceiling to the role count. An explicit MONOMIND_MAX_SDK_PROCS still wins:
         // if the operator named a number, that number is the answer.
-        if (!process.env.MONOMIND_MAX_SDK_PROCS && getResourceLimits().maxSdkProcesses < def.roles.length) {
+        //
+        // Runner process model (relevant for sizing): ClaudeAgentRunner and
+        // VercelAgentRunner are in-process (no subprocess per role). KimiCodeAgentRunner,
+        // OpencodeAgentRunner, and CodexAgentRunner each spawn one subprocess per role.
+        // The current sizing (def.roles.length) is therefore safe — it over-provisions
+        // for in-process runners but never under-provisions for subprocess runners.
+        if (!process.env.MONOMIND_MAX_SDK_PROCS &&
+            getResourceLimits().maxSdkProcesses < def.roles.length) {
             configureResourceLimits({ maxSdkProcesses: def.roles.length });
         }
         // Validate per-role providers before spawning anything (fail-fast: a
@@ -299,10 +367,8 @@ export class OrgDaemon {
         const MAX_COLLECTED = 1000;
         const collected = [];
         let lastActivity = Date.now();
-        bus.subscribe(e => {
-            const slim = e.data?.content != null
-                ? { ...e, data: { ...e.data, content: undefined } }
-                : e;
+        bus.subscribe((e) => {
+            const slim = e.data?.content != null ? { ...e, data: { ...e.data, content: undefined } } : e;
             collected.push(slim);
             if (collected.length > MAX_COLLECTED)
                 collected.splice(0, collected.length - MAX_COLLECTED);
@@ -317,7 +383,7 @@ export class OrgDaemon {
             // against a concurrent manual stop.
             if (e.type === 'status' && e.reason === 'org-complete') {
                 const t = setTimeout(() => {
-                    this.stopOrg(name, { drainMs: COMPLETE_DRAIN_MS }).catch(err => console.error(`org ${name}: auto-stop after org_complete failed:`, err instanceof Error ? err.message : err));
+                    this.stopOrg(name, { drainMs: COMPLETE_DRAIN_MS }).catch((err) => console.error(`org ${name}: auto-stop after org_complete failed:`, err instanceof Error ? err.message : err));
                 }, 1000);
                 t.unref?.();
             }
@@ -351,8 +417,42 @@ export class OrgDaemon {
         });
         if (this.opts.forward !== false)
             this.forwarders.set(name, attachForwarder(bus, this.opts.controlJson ?? join(this.root, '.monomind/control.json')));
-        const running = { def, run, bus, agents: new Map(), busEvents: () => [...collected], workdir: cwd };
+        const running = {
+            def,
+            run,
+            bus,
+            agents: new Map(),
+            busEvents: () => [...collected],
+            workdir: cwd,
+        };
         this.orgs.set(name, running);
+        // ── MonoFence guardrail: pre-create per-role instances ────────────────
+        const globalFence = loadGlobalFenceConfig(this.root);
+        const orgFence = def.fence;
+        const roleFences = new Map();
+        for (const role of def.roles) {
+            const roleFenceCfg = role.policy?.fence;
+            const merged = mergeFenceConfigs(globalFence ?? undefined, orgFence, roleFenceCfg);
+            if (merged.enabled === false)
+                continue;
+            if (!globalFence && !orgFence && !roleFenceCfg)
+                continue;
+            try {
+                const instance = await createFenceForRole(merged);
+                if (instance) {
+                    roleFences.set(role.id, {
+                        instance,
+                        abortThreshold: typeof merged.abortThreshold === 'number' ? merged.abortThreshold : 0.8,
+                        scanMessages: merged.scanMessages !== false,
+                    });
+                }
+            }
+            catch {
+                /* monofence-ai not installed — skip silently */
+            }
+        }
+        if (roleFences.size > 0)
+            running.fences = roleFences;
         // Even-split budget; a role's own budget_tokens overrides it (roleTokenBudget).
         const perRoleBudget = Math.floor((def.run_config.budget_tokens ?? 1_000_000) / def.roles.length);
         // Single boss-selection rule for kickoff AND org_complete gating — the
@@ -360,7 +460,7 @@ export class OrgDaemon {
         // kickoff went to (type==='boss' || reports_to===null || roles[0]), so a
         // fallback-selected boss could be told to call org_complete without having
         // the tool.
-        const bossRole = def.roles.find(r => r.type === 'boss' || r.reports_to === null) ?? def.roles[0];
+        const bossRole = def.roles.find((r) => r.type === 'boss' || r.reports_to === null) ?? def.roles[0];
         // Canonical entity names from the org KG — injected into the coordinator
         // prompt so org_learn extractions reuse them instead of minting duplicates.
         const glossary = await (async () => {
@@ -388,29 +488,62 @@ export class OrgDaemon {
             if (ws === 'worktree-per-role' && role.id !== bossRole.id) {
                 const wtPath = join(this.root, ORG_DIR, name, `worktree-${role.id}`);
                 try {
-                    // Q7: top-level `import { execSync }` replaces the inlined
+                    // Q7: top-level `import { execFileSync }` replaces the inlined
                     // `require('node:child_process')` that broke ESM at runtime —
                     // vitest's CJS shim masked it in tests but the built package
                     // threw "require is not defined" in real Node ESM execution.
+                    // SEC-5: argv-array form, no shell.
                     if (existsSync(wtPath)) {
                         try {
-                            execSync(`git worktree remove --force "${wtPath}"`, { cwd: this.root, stdio: 'ignore', timeout: 30_000 });
+                            execFileSync('git', ['worktree', 'remove', '--force', wtPath], {
+                                cwd: this.root,
+                                stdio: 'ignore',
+                                timeout: 30_000,
+                            });
+                        }
+                        catch {
+                            /* best-effort */
                         }
-                        catch { /* best-effort */ }
                     }
-                    execSync(`git worktree add "${wtPath}" HEAD --detach`, { cwd: this.root, stdio: 'ignore', timeout: 30_000 });
+                    execFileSync('git', ['worktree', 'add', wtPath, 'HEAD', '--detach'], {
+                        cwd: this.root,
+                        stdio: 'ignore',
+                        timeout: 30_000,
+                    });
                     roleCwd = wtPath;
                 }
-                catch { /* fallback to shared cwd if git worktree fails */ }
+                catch {
+                    /* fallback to shared cwd if git worktree fails */
+                }
             }
             const mailbox = new Mailbox();
             const policy = new PolicyEngine(role.id, { maxTokens: role.budget_tokens ?? perRoleBudget, ...(role.policy ?? {}) }, bus, roleCwd);
-            const runtime = { mailbox, policy, status: 'running', done: Promise.resolve(), metrics: { tokens: 0, costUsd: 0 }, worktreePath: roleCwd !== cwd ? roleCwd : undefined, scrollback: new ScrollbackBuffer() };
+            const runtime = {
+                mailbox,
+                policy,
+                status: 'running',
+                done: Promise.resolve(),
+                metrics: { tokens: 0, costUsd: 0 },
+                sessionId: undefined,
+                worktreePath: roleCwd !== cwd ? roleCwd : undefined,
+                scrollback: new ScrollbackBuffer(),
+            };
             const sessionOpts = {
-                org: name, role, bus, policy, mailbox, cwd: roleCwd, def,
+                org: name,
+                role,
+                bus,
+                policy,
+                mailbox,
+                cwd: roleCwd,
+                def,
+                // Pass the org state directory so runners that persist per-role state
+                // (VercelAgentRunner session files) write under .monomind/orgs/<name>
+                // 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,
                 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),
@@ -421,9 +554,16 @@ export class OrgDaemon {
                     return { threshold: cb.failure_threshold ?? 5, state: { failures: 0, tripped: false } };
                 })(),
                 beforeTool: (r, toolName) => this.checkApproval(name, r, toolName),
+                fence: roleFences.get(role.id),
                 onComplete: role.id === bossRole.id
                     ? (r, outcome, summary) => {
-                        bus.emit({ type: 'status', from: r, reason: 'org-complete', msg: `run outcome: ${outcome}`, data: { outcome, summary } });
+                        bus.emit({
+                            type: 'status',
+                            from: r,
+                            reason: 'org-complete',
+                            msg: `run outcome: ${outcome}`,
+                            data: { outcome, summary },
+                        });
                     }
                     : undefined,
                 // #11: a boss that overflows its context window isn't a crash (it keeps
@@ -433,25 +573,50 @@ export class OrgDaemon {
                 onContextLimit: role.id === bossRole.id ? () => this.scheduleBossRestart(name) : undefined,
                 recall: async (r, q) => {
                     const answer = await this.recallOrgMemory(name, def, q, r);
-                    bus.emit({ type: 'status', from: r, reason: 'org-recall', msg: `recall: ${q.slice(0, 80)}`, data: { hits: answer.hits } });
+                    bus.emit({
+                        type: 'status',
+                        from: r,
+                        reason: 'org-recall',
+                        msg: `recall: ${q.slice(0, 80)}`,
+                        data: { hits: answer.hits },
+                    });
                     return answer.text;
                 },
                 searchKnowledge: async (r, q) => {
                     const answer = await this.searchProjectKnowledge(q);
-                    bus.emit({ type: 'status', from: r, reason: 'knowledge-search', msg: `knowledge: ${q.slice(0, 80)}`, data: { hits: answer.hits } });
+                    bus.emit({
+                        type: 'status',
+                        from: r,
+                        reason: 'knowledge-search',
+                        msg: `knowledge: ${q.slice(0, 80)}`,
+                        data: { hits: answer.hits },
+                    });
                     return answer.text;
                 },
                 glossary,
                 remember: async (r, content, scope) => {
                     const text = await this.rememberOrgMemory(name, def, r, content, scope, run);
-                    bus.emit({ type: 'status', from: r, reason: 'org-remember', msg: `remember (${scope}): ${content.slice(0, 80)}`, data: { scope } });
+                    bus.emit({
+                        type: 'status',
+                        from: r,
+                        reason: 'org-remember',
+                        msg: `remember (${scope}): ${content.slice(0, 80)}`,
+                        data: { scope },
+                    });
                     return text;
                 },
                 learn: async (r, payload) => {
                     const text = await this.learnOrgKnowledge(name, run, payload);
                     bus.emit({
-                        type: 'status', from: r, reason: 'org-learn', msg: `learn: ${text.slice(0, 120)}`,
-                        data: { nodes: payload.nodes?.length ?? 0, edges: payload.edges?.length ?? 0, rules: payload.rules?.length ?? 0 },
+                        type: 'status',
+                        from: r,
+                        reason: 'org-learn',
+                        msg: `learn: ${text.slice(0, 120)}`,
+                        data: {
+                            nodes: payload.nodes?.length ?? 0,
+                            edges: payload.edges?.length ?? 0,
+                            rules: payload.rules?.length ?? 0,
+                        },
                     });
                     return text;
                 },
@@ -465,6 +630,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) >
@@ -472,7 +649,8 @@ export class OrgDaemon {
                 // Leaving it undefined for the default path is what keeps
                 // Claude/Antigravity orgs byte-for-byte unchanged. Session opts are
                 // built per role here in spawnRole, so each role gets its own runner.
-                runner: this.opts.runner ?? resolveRoleRunner(role.runtime, def.runtime),
+                runner: this.opts.runner ??
+                    resolveRoleRunner(role.runtime, def.runtime, role.provider?.kind, undefined),
             };
             // Supervised session: transient crashes (provider blips, network) restart
             // with backoff; a crash with the mailbox already closed, or one that
@@ -502,7 +680,8 @@ export class OrgDaemon {
                             if (killedByStop) {
                                 runtime.status = 'ended';
                                 bus.emit({
-                                    type: 'status', from: role.id,
+                                    type: 'status',
+                                    from: role.id,
                                     msg: `agent "${role.id}" terminated by stop (was still working when drain window expired)`,
                                     reason: 'terminated-by-stop',
                                 });
@@ -516,10 +695,16 @@ export class OrgDaemon {
                             mailbox.close();
                             const isContextLimit = OrgDaemon.CONTEXT_LIMIT_RE.test(message);
                             bus.emit({
-                                type: 'audit', from: role.id,
+                                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 },
+                                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
@@ -534,8 +719,12 @@ export class OrgDaemon {
                                         ? ' 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` });
+                                    bus.emit({
+                                        type: 'audit',
+                                        from: bossRole.id,
+                                        reason: 'worker-crashed',
+                                        msg: `worker "${role.id}" crashed (contextLimit=${isContextLimit}); coordinator notified to reassign`,
+                                    });
                                 }
                             }
                             else {
@@ -553,7 +742,9 @@ export class OrgDaemon {
                         const fatal = err?.fatal === true;
                         if (fatal) {
                             bus.emit({
-                                type: 'status', from: role.id, reason: 'agent-fatal',
+                                type: 'status',
+                                from: role.id,
+                                reason: 'agent-fatal',
                                 msg: `agent "${role.id}" hit a fatal (non-retryable) error — not restarting`,
                             });
                             crash();
@@ -564,10 +755,15 @@ export class OrgDaemon {
                             return;
                         }
                         bus.emit({
-                            type: 'status', from: role.id, reason: 'agent-restart',
+                            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?.(); });
+                        await new Promise((r) => {
+                            const t = setTimeout(r, BACKOFFS_MS[attempt]);
+                            t.unref?.();
+                        });
                         if (mailbox.isClosed) {
                             crash();
                             return;
@@ -601,7 +797,9 @@ export class OrgDaemon {
                 // no-cjs-require-in-esm.test.ts.
                 reapOrphanedSdkProcesses(new Set(), process.pid);
             }
-            catch { /* best-effort */ }
+            catch {
+                /* best-effort */
+            }
         };
         process.on('exit', crashCleanup);
         running._crashCleanup = crashCleanup;
@@ -612,17 +810,24 @@ export class OrgDaemon {
         if (staleThreshold && staleThreshold > 0 && cwd === this.root) {
             try {
                 const { execSync } = await import('node:child_process');
-                const behind = execSync('git rev-list --count HEAD..@{upstream} 2>/dev/null', { cwd, encoding: 'utf8', timeout: 10_000 }).trim();
+                const behind = execSync('git rev-list --count HEAD..@{upstream} 2>/dev/null', {
+                    cwd,
+                    encoding: 'utf8',
+                    timeout: 10_000,
+                }).trim();
                 const count = parseInt(behind, 10);
                 if (!isNaN(count) && count > staleThreshold) {
                     bus.emit({
-                        type: 'audit', reason: 'stale-base',
+                        type: 'audit',
+                        reason: 'stale-base',
                         msg: `working tree is ${count} commits behind upstream (threshold: ${staleThreshold}) — consider pulling before running`,
                         data: { behind: count, threshold: staleThreshold },
                     });
                 }
             }
-            catch { /* no upstream tracking or git unavailable — skip silently */ }
+            catch {
+                /* no upstream tracking or git unavailable — skip silently */
+            }
         }
         const boss = bossRole;
         // Cross-run memory: brief the coordinator on the previous run so scheduled
@@ -635,9 +840,15 @@ export class OrgDaemon {
                     : `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` +
+        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 } });
+        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
@@ -652,13 +863,13 @@ export class OrgDaemon {
             let nudges = 0;
             const idleStop = (msg) => {
                 bus.emit({ type: 'audit', reason: 'idle-stop', msg });
-                this.stopOrg(name).catch(err => console.error(`org ${name}: idle-stop failed:`, err instanceof Error ? err.message : err));
+                this.stopOrg(name).catch((err) => console.error(`org ${name}: idle-stop failed:`, err instanceof Error ? err.message : err));
             };
             const wd = setInterval(() => {
                 if (this.restarting.has(name))
                     return; // boss auto-restart in flight — don't nudge or stop
                 // A pending gate means the org is legitimately waiting for human input
-                const pendingGates = this.readGates(name).gates.filter(g => g.status === 'pending');
+                const pendingGates = this.readGates(name).gates.filter((g) => g.status === 'pending');
                 if (pendingGates.length > 0)
                     return;
                 const idleFor = Date.now() - lastActivity;
@@ -678,7 +889,12 @@ export class OrgDaemon {
                     }
                     nudges++;
                     nudgedAt = Date.now();
-                    bus.emit({ type: 'audit', from: bossRole.id, reason: 'idle-nudge', msg: `no org activity for ${Math.round(idleFor / 60_000)}m — nudging boss (${nudges}/${MAX_IDLE_NUDGES})` });
+                    bus.emit({
+                        type: 'audit',
+                        from: bossRole.id,
+                        reason: 'idle-nudge',
+                        msg: `no org activity for ${Math.round(idleFor / 60_000)}m — nudging boss (${nudges}/${MAX_IDLE_NUDGES})`,
+                    });
                     bossRt.mailbox.push(`[watchdog] No activity in org "${name}" for ${Math.round(idleFor / 60_000)} minute(s). ` +
                         `If the goal is achieved (or clearly can't be), call org_complete now. Otherwise check on your team via org_send and reassign stalled work.`);
                 }
@@ -709,7 +925,13 @@ export class OrgDaemon {
             }
             const agent = running.agents.get(msg.toRole);
             if (agent && !agent.mailbox.isClosed) {
-                bus.emit({ type: 'xorg', from: msg.fromQualified, to: `${name}:${msg.toRole}`, subject: msg.subject, msg: msg.body });
+                bus.emit({
+                    type: 'xorg',
+                    from: msg.fromQualified,
+                    to: `${name}:${msg.toRole}`,
+                    subject: msg.subject,
+                    msg: msg.body,
+                });
                 agent.mailbox.push(this.mailBody(name, running, `[message from ${msg.fromQualified}] subject: ${msg.subject}`, msg.body, `inbox-${msg.ts}-${Math.random().toString(36).slice(2, 8)}`));
             }
         }
@@ -787,11 +1009,15 @@ export class OrgDaemon {
         // "crashed") and threw the work away. allSettled resolves as soon as every
         // session ends, so a long drain is a ceiling, not a delay.
         const stopWaitMs = drainMs ?? this.opts.stopWaitMs ?? 15_000;
-        const allDone = Promise.allSettled([...org.agents.values()].map(a => a.done)).then(() => false);
-        const timedOut = await Promise.race([allDone, new Promise(r => setTimeout(() => r(true), stopWaitMs))]);
+        const allDone = Promise.allSettled([...org.agents.values()].map((a) => a.done)).then(() => false);
+        const timedOut = await Promise.race([
+            allDone,
+            new Promise((r) => setTimeout(() => r(true), stopWaitMs)),
+        ]);
         if (timedOut) {
             org.bus.emit({
-                type: 'audit', msg: `org stop timed out after ${stopWaitMs}ms waiting for agent sessions to finish — proceeding anyway`,
+                type: 'audit',
+                msg: `org stop timed out after ${stopWaitMs}ms waiting for agent sessions to finish — proceeding anyway`,
                 reason: 'stop-timeout',
             });
             // Reap only SDK processes spawned by THIS node process — ownerPid filter
@@ -799,9 +1025,15 @@ export class OrgDaemon {
             try {
                 const reaped = reapOrphanedSdkProcesses(new Set(), process.pid);
                 if (reaped > 0)
-                    org.bus.emit({ type: 'audit', reason: 'orphan-reap', msg: `reaped ${reaped} orphaned SDK process(es) after stop timeout` });
+                    org.bus.emit({
+                        type: 'audit',
+                        reason: 'orphan-reap',
+                        msg: `reaped ${reaped} orphaned SDK process(es) after stop timeout`,
+                    });
+            }
+            catch {
+                /* best-effort */
             }
-            catch { /* best-effort */ }
         }
         org.bus.emit({ type: 'status', msg: 'org stopped' });
         await org.bus.flush();
@@ -833,7 +1065,10 @@ export class OrgDaemon {
         if (forwarder) {
             await Promise.race([
                 forwarder.settle(),
-                new Promise(r => { const t = setTimeout(r, 5_000); t.unref?.(); }),
+                new Promise((r) => {
+                    const t = setTimeout(r, 5_000);
+                    t.unref?.();
+                }),
             ]);
             forwarder.unsubscribe();
             // Only remove from the map if it's still OURS — an autoWake-restart may
@@ -848,27 +1083,41 @@ export class OrgDaemon {
             this.persistState(name, 'stopped', org.run, org, stopCheckpoint);
         // Clean up git worktrees — shared (workspace: 'worktree') and per-role.
         try {
-            const { execSync } = await import('node:child_process');
+            const { execFileSync } = await import('node:child_process');
             if (org.worktreePath) {
                 try {
-                    execSync(`git worktree remove --force "${org.worktreePath}"`, { cwd: this.root, stdio: 'ignore', timeout: 30_000 });
+                    execFileSync('git', ['worktree', 'remove', '--force', org.worktreePath], {
+                        cwd: this.root,
+                        stdio: 'ignore',
+                        timeout: 30_000,
+                    });
+                }
+                catch {
+                    /* best-effort */
                 }
-                catch { /* best-effort */ }
             }
             for (const agent of org.agents.values()) {
                 if (agent.worktreePath) {
                     try {
-                        execSync(`git worktree remove --force "${agent.worktreePath}"`, { cwd: this.root, stdio: 'ignore', timeout: 30_000 });
+                        execFileSync('git', ['worktree', 'remove', '--force', agent.worktreePath], {
+                            cwd: this.root,
+                            stdio: 'ignore',
+                            timeout: 30_000,
+                        });
+                    }
+                    catch {
+                        /* best-effort */
                     }
-                    catch { /* best-effort */ }
                 }
             }
         }
-        catch { /* node:child_process unavailable — skip */ }
+        catch {
+            /* node:child_process unavailable — skip */
+        }
     }
     async stopAll() {
         await Promise.all([
-            ...[...this.orgs.keys()].map(n => this.stopOrg(n)),
+            ...[...this.orgs.keys()].map((n) => this.stopOrg(n)),
             ...this.stopping.values(), // detached self-stops still flushing
         ]);
     }
@@ -889,7 +1138,10 @@ export class OrgDaemon {
         // would brick every subsequent `org status` / isOrgRunning / scheduler
         // call. The state files in 6 other daemon paths already use this helper.
         writeJsonFileAtomic(p, {
-            status, run, pid: process.pid, updated: new Date().toISOString(),
+            status,
+            run,
+            pid: process.pid,
+            updated: new Date().toISOString(),
             ...(missing.length ? { abandonedRoles: missing } : {}),
             ...(checkpoint ? { checkpoint } : {}),
         });
@@ -903,11 +1155,16 @@ export class OrgDaemon {
                 // C4: atomic write — crash handler is the most likely place to hit
                 // a partial write since the process is mid-teardown.
                 writeJsonFileAtomic(p, {
-                    status: 'crashed', run: org.run, pid: process.pid,
-                    updated: new Date().toISOString(), closedBy: 'crash-handler',
+                    status: 'crashed',
+                    run: org.run,
+                    pid: process.pid,
+                    updated: new Date().toISOString(),
+                    closedBy: 'crash-handler',
                 });
             }
-            catch { /* best effort — filesystem may be unavailable */ }
+            catch {
+                /* best effort — filesystem may be unavailable */
+            }
         }
     }
     heartbeatPath() {
@@ -922,17 +1179,22 @@ export class OrgDaemon {
             // C4: atomic write — heartbeat corruption is how `org status` reports
             // a phantom daemon after a crash.
             writeJsonFileAtomic(p, {
-                pid: process.pid, updatedAt: new Date().toISOString(),
+                pid: process.pid,
+                updatedAt: new Date().toISOString(),
                 running: this.listRunning(),
             });
         }
-        catch { /* best effort */ }
+        catch {
+            /* best effort */
+        }
     }
     clearHeartbeat() {
         try {
             unlinkSync(this.heartbeatPath());
         }
-        catch { /* already gone or never written */ }
+        catch {
+            /* already gone or never written */
+        }
     }
     // ── Delegated methods — extracted to focused modules ──────────────────
     // approvals.ts
@@ -968,6 +1230,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);
     }
@@ -983,16 +1257,26 @@ export class OrgDaemon {
     }
     // scheduler-integration.ts
     /** @internal */
-    autoWake(name) { scheduler.autoWake(this, name); }
-    scheduleBossRestart(name) { scheduler.scheduleBossRestart(this, name); }
+    autoWake(name) {
+        scheduler.autoWake(this, name);
+    }
+    scheduleBossRestart(name) {
+        scheduler.scheduleBossRestart(this, name);
+    }
     /** @internal */
     scheduleDeferredSpawn(name, running, role, spawnRole) {
         scheduler.scheduleDeferredSpawn(this, name, running, role, spawnRole);
     }
     // org-memory.ts
-    orgMemoryNamespace(name, def) { return orgMemory.orgMemoryNamespace(name, def); }
-    orgMemoryDbPath() { return orgMemory.orgMemoryDbPath(this.root); }
-    orgMemoryUsable() { return orgMemory.orgMemoryUsable(this.root); }
+    orgMemoryNamespace(name, def) {
+        return orgMemory.orgMemoryNamespace(name, def);
+    }
+    orgMemoryDbPath() {
+        return orgMemory.orgMemoryDbPath(this.root);
+    }
+    orgMemoryUsable() {
+        return orgMemory.orgMemoryUsable(this.root);
+    }
     async rememberOrgMemory(name, def, role, content, scope, run) {
         return orgMemory.rememberOrgMemory(this.root, name, def, role, content, scope, run);
     }