monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/dist/src/orgrt/daemon.js

@@ -1,965 +0,0 @@
-// 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, writeFileSync, existsSync, renameSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import { reapOrphanedSdkProcesses } from '../utils/resource-governor.js';
-import { OrgBus } from './bus.js';
-import { PolicyEngine } from './policy.js';
-import { Mailbox } from './mailbox.js';
-import { runAgentSession } from './session.js';
-import { attachForwarder } from './forwarder.js';
-import { BrokerLease, lookupOrg } from './broker.js';
-import { queueMessage, drainInbox } from './inbox.js';
-import { OrgDefSchema, ORG_DIR } from './types.js';
-import { summarizeRun, readRunEvents, readHistory, historyFile } from './reporting.js';
-import { checkResources, waitForCapacity, getResourceLimits } from '../utils/resource-governor.js';
-export class OrgDaemon {
-    root;
-    opts;
-    orgs = new Map();
-    waking = new Set();
-    globalSubscribers = new Set();
-    leases = new Map();
-    forwarders = new Map();
-    watchdogs = new Map();
-    stopping = new Map();
-    constructor(root, opts = {}) {
-        this.root = root;
-        this.opts = opts;
-    }
-    /** Publish this daemon's inbox so orgs started AFTER this call register with the broker. */
-    setInboxUrl(url) { this.opts.inboxUrl = url; }
-    /** subscribe to events from ALL running orgs (dashboard server uses this) */
-    subscribe(fn) {
-        this.globalSubscribers.add(fn);
-        return () => this.globalSubscribers.delete(fn);
-    }
-    listOrgs() { return [...this.orgs.values()]; }
-    getOrg(name) { return this.orgs.get(name); }
-    /** Names of the orgs this daemon currently has running. Snapshot — safe to
-     *  iterate while stopOrg() mutates the underlying map. */
-    listRunning() { return [...this.orgs.keys()]; }
-    async startOrg(name, taskOverride) {
-        if (this.orgs.has(name))
-            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)}`;
-        const dir = join(this.root, ORG_DIR, name, run);
-        mkdirSync(dir, { recursive: true });
-        const cwd = join(this.root, ORG_DIR, name, 'workspace');
-        mkdirSync(cwd, { recursive: true });
-        const bus = new OrgBus(name, run, dir);
-        // Lightweight in-memory tail for busEvents() (test-loop, /api/history).
-        // Full events (including Write content snapshots) live on disk in bus.jsonl;
-        // the in-memory copy strips bulky data.content to keep RAM flat.
-        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;
-            collected.push(slim);
-            if (collected.length > MAX_COLLECTED)
-                collected.splice(0, collected.length - MAX_COLLECTED);
-            // The watchdog's own nudge event must not count as org activity, or a
-            // hung boss would never trip the "nudge produced no activity" stop.
-            if (e.reason !== 'idle-nudge')
-                lastActivity = Date.now();
-            // org_complete IS the end of the run — self-stop instead of sitting
-            // "running" forever after a recorded outcome. Deferred (unref'd) so the
-            // tool call's receipt reaches the boss and its final turn text still
-            // lands on the bus before mailboxes close; stopOrg is reentrant-safe
-            // against a concurrent manual stop.
-            if (e.type === 'status' && e.reason === 'org-complete') {
-                const t = setTimeout(() => {
-                    this.stopOrg(name).catch(err => console.error(`org ${name}: auto-stop after org_complete failed:`, err instanceof Error ? err.message : err));
-                }, 1000);
-                t.unref?.();
-            }
-            for (const fn of this.globalSubscribers)
-                fn(e);
-        });
-        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] };
-        this.orgs.set(name, running);
-        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
-        // session layer previously keyed the tool on reports_to===null while the
-        // 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];
-        // 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 () => {
-            try {
-                if (!(await this.orgMemoryUsable()))
-                    return [];
-                const kg = await import('../memory/memory-kg.js');
-                return await kg.kgGlossary({ dbPath: this.orgMemoryDbPath() });
-            }
-            catch {
-                return [];
-            }
-        })();
-        // Resource-gated staggered spawn: check memory/process limits before each
-        // NON-BOSS agent, wait if under pressure. The boss always spawns immediately
-        // and ungated — the org has no coordinator at all without it, so gating it
-        // behind host memory pressure would make the whole org fail to start over a
-        // condition workers are specifically designed to ride out.
-        const limits = getResourceLimits();
-        // 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 mailbox = new Mailbox();
-            const policy = new PolicyEngine(role.id, { maxTokens: perRoleBudget, ...(role.policy ?? {}) }, bus, cwd);
-            const runtime = { mailbox, policy, status: 'running', done: Promise.resolve() };
-            const sessionOpts = {
-                org: name, role, bus, policy, mailbox, cwd, def,
-                maxTurns: role.max_turns_per_message ?? def.run_config.max_turns_per_message,
-                deliver: (from, to, subject, body) => this.deliver(name, from, to, subject, body),
-                askHuman: (r, question) => this.askHuman(name, r, question),
-                onComplete: role.id === bossRole.id
-                    ? (r, outcome, summary) => {
-                        bus.emit({ type: 'status', from: r, reason: 'org-complete', msg: `run outcome: ${outcome}`, data: { outcome, summary } });
-                    }
-                    : 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 } });
-                    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 } });
-                    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 } });
-                    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 },
-                    });
-                    return text;
-                },
-                queryFn: this.opts.queryFn,
-            };
-            // Supervised session: transient crashes (provider blips, network) restart
-            // with backoff; a crash with the mailbox already closed, or one that
-            // exhausts the retry budget, is terminal. runAgentSession already emits a
-            // 'status' event for the raw error; the terminal 'audit' event is for
-            // dashboards/alerts that filter on actionable failures (not routine
-            // status chatter) so a dead agent surfaces instead of a run that
-            // silently never progresses.
-            const BACKOFFS_MS = [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);
-                        const crash = () => {
-                            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();
-                            bus.emit({
-                                type: 'audit', from: role.id,
-                                msg: `agent "${role.id}" crashed: ${message}`,
-                                reason: 'agent-session-crash',
-                                data: { agentId: role.id, error: message, restarts: attempt },
-                            });
-                        };
-                        if (mailbox.isClosed || attempt >= BACKOFFS_MS.length) {
-                            crash();
-                            return;
-                        }
-                        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
-        for (const role of def.roles) {
-            if (role.id === bossRole.id)
-                continue;
-            // Gate non-boss agents: stagger when under 50% free mem, resource check.
-            const check = checkResources();
-            // Stagger only when memory pressure exists (< 50% free)
-            if (check.freeMemPct < 50) {
-                await new Promise(r => { const t = setTimeout(r, limits.spawnStaggerMs); t.unref?.(); });
-            }
-            if (!check.ok) {
-                bus.emit({ type: 'audit', from: role.id, reason: 'resource-pressure',
-                    msg: `pausing spawn of "${role.id}": ${check.reason} — waiting` });
-                const waited = await waitForCapacity(60_000);
-                if (!waited.ok) {
-                    // Deferred, not dropped: a role missing for the org's whole life is
-                    // worse than a slow retry loop. Retries in the background and
-                    // spawns the moment capacity returns (see scheduleDeferredSpawn).
-                    bus.emit({ type: 'audit', from: role.id, reason: 'resource-skip',
-                        msg: `deferring "${role.id}" — will keep retrying in the background: ${waited.reason}` });
-                    this.scheduleDeferredSpawn(name, running, role, spawnRole);
-                    continue;
-                }
-            }
-            spawnRole(role);
-        }
-        // Crash cleanup: reap SDK children if this process exits abnormally.
-        // monolean: process-scoped listener — upgrade path = per-org tracking
-        const crashCleanup = () => {
-            try {
-                // Statically imported: a process 'exit' handler must be synchronous,
-                // so `await import()` is unavailable — and a bare require() throws
-                // "require is not defined" in this ESM package. Guarded by
-                // no-cjs-require-in-esm.test.ts.
-                reapOrphanedSdkProcesses(new Set(), process.pid);
-            }
-            catch { /* best-effort */ }
-        };
-        process.on('exit', crashCleanup);
-        running._crashCleanup = crashCleanup;
-        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 } });
-        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
-        // idle_minutes of silence, nudge the boss to complete or reassign; if the
-        // nudge itself produces no activity (boss hung/crashed), or the org keeps
-        // going idle after MAX_IDLE_NUDGES nudges, stop the run instead of letting
-        // it freeze forever. idle_minutes: 0 disables.
-        const idleMs = (def.run_config.idle_minutes ?? 10) * 60_000;
-        if (idleMs > 0) {
-            const MAX_IDLE_NUDGES = 3;
-            let nudgedAt = 0;
-            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));
-            };
-            const wd = setInterval(() => {
-                const idleFor = Date.now() - lastActivity;
-                if (idleFor < idleMs) {
-                    nudgedAt = 0;
-                    return;
-                }
-                if (nudgedAt === 0) {
-                    if (nudges >= MAX_IDLE_NUDGES) {
-                        idleStop(`org idle again after ${nudges} nudges — stopping run`);
-                        return;
-                    }
-                    const bossRt = running.agents.get(bossRole.id);
-                    if (!bossRt || bossRt.status !== 'running' || bossRt.mailbox.isClosed) {
-                        idleStop(`org idle for ${Math.round(idleFor / 60_000)}m and boss "${bossRole.id}" is unreachable — stopping run`);
-                        return;
-                    }
-                    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})` });
-                    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.`);
-                }
-                else if (Date.now() - nudgedAt >= idleMs) {
-                    idleStop(`nudge produced no activity for another ${Math.round(idleMs / 60_000)}m — boss appears hung, stopping run`);
-                }
-            }, Math.max(200, Math.min(idleMs / 2, 30_000)));
-            wd.unref?.();
-            this.watchdogs.set(name, wd);
-        }
-        if (this.opts.crossProcess && this.opts.inboxUrl) {
-            const lease = new BrokerLease(name, this.opts.inboxUrl, this.opts.brokerDir);
-            lease.start();
-            this.leases.set(name, lease);
-        }
-        // Drain any messages that arrived while the org was offline
-        const queued = drainInbox(this.root, name);
-        for (const msg of queued) {
-            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 });
-                agent.mailbox.push(`[message from ${msg.fromQualified}] subject: ${msg.subject}\n\n${msg.body}`);
-            }
-        }
-        if (queued.length)
-            bus.emit({ type: 'status', msg: `drained ${queued.length} queued message(s) from inbox` });
-        return running;
-    }
-    /** A role that failed its resource gate at boot isn't abandoned — keep polling
-     *  for capacity in the background (bounded) and spawn it the moment resources
-     *  free up, instead of silently running the org shorthanded for its whole life.
-     *  Bails quietly if the org is stopped (or restarted under the same name)
-     *  before capacity returns; `running` is compared by identity, not `name`,
-     *  so a stale retry can never spawn into a different run. */
-    scheduleDeferredSpawn(name, running, role, spawnRole) {
-        const MAX_ATTEMPTS = 6; // ~30 min of retrying before giving up loudly
-        (async () => {
-            for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-                const waited = await waitForCapacity(5 * 60_000);
-                if (this.orgs.get(name) !== running)
-                    return; // org stopped/restarted — abandon quietly
-                if (waited.ok) {
-                    running.bus.emit({ type: 'audit', from: role.id, reason: 'resource-recovered',
-                        msg: `resources recovered after ${attempt} retr${attempt === 1 ? 'y' : 'ies'} — spawning deferred role "${role.id}"` });
-                    spawnRole(role);
-                    return;
-                }
-                running.bus.emit({ type: 'audit', from: role.id, reason: 'resource-pressure',
-                    msg: `still under pressure (attempt ${attempt}/${MAX_ATTEMPTS}) — retrying "${role.id}" spawn: ${waited.reason}` });
-            }
-            running.bus.emit({ type: 'audit', from: role.id, reason: 'resource-abandoned',
-                msg: `giving up spawning "${role.id}" after ${MAX_ATTEMPTS} retries — org will run without this role until manually restarted` });
-        })().catch(err => console.error(`org ${name}: deferred spawn of "${role.id}" failed:`, err instanceof Error ? err.message : err));
-    }
-    /**
-     * Resolves an org_send `to` address ("role" for same-org, "org:role" for
-     * cross-org) into its parts. Centralizes the one addressing rule that
-     * matters (an "own-org:role" self-prefix is intra-org, not cross-org) so
-     * deliver()/deliverRemote() don't each re-derive it — the qualified `to`
-     * string returned is always the canonical display form for that address.
-     */
-    resolveAddress(fromOrg, to) {
-        const cross = to.includes(':');
-        if (!cross)
-            return { cross: false, orgName: fromOrg, role: to, qualified: to };
-        const [orgName, role] = to.split(':', 2);
-        if (orgName === fromOrg)
-            return { cross: false, orgName, role, qualified: role }; // self-prefixed — still intra-org
-        return { cross: true, orgName, role, qualified: to };
-    }
-    /** Route a message. to = "role" (same org) or "org:role" (cross-org). Returns a receipt string. */
-    async deliver(fromOrg, fromRole, to, subject, body) {
-        const { cross, orgName: targetOrgName, role: targetRole, qualified: toQualified } = this.resolveAddress(fromOrg, to);
-        const targetOrg = this.orgs.get(targetOrgName);
-        const src = this.orgs.get(fromOrg);
-        if (!targetOrg || !targetOrg.agents.has(targetRole)) {
-            if (cross && this.opts.crossProcess)
-                return this.deliverRemote(fromOrg, fromRole, targetOrgName, targetRole, toQualified, subject, body, src);
-            // Queue + auto-wake: if the org definition exists locally but isn't running, spool the message and start it
-            if (cross && this.hasOrgDef(targetOrgName)) {
-                queueMessage(this.root, targetOrgName, { fromQualified: `${fromOrg}:${fromRole}`, toRole: targetRole, subject, body, ts: Date.now() });
-                src?.bus.emit({ type: 'xorg', from: `${fromOrg}:${fromRole}`, to: toQualified, subject, msg: body, data: { queued: true } });
-                this.autoWake(targetOrgName);
-                return `queued for ${toQualified} (org starting)`;
-            }
-            src?.bus.emit({ type: 'audit', from: fromRole, to: toQualified, msg: `undeliverable: ${subject}`, reason: 'unknown recipient' });
-            return `ERROR: unknown recipient "${toQualified}" (known: ${[...(targetOrg?.agents.keys() ?? this.orgs.keys())].join(', ')})`;
-        }
-        const targetAgent = targetOrg.agents.get(targetRole);
-        if (targetAgent.status === 'crashed') {
-            src?.bus.emit({ type: 'audit', from: fromRole, to: toQualified, msg: `undeliverable: ${subject}`, reason: 'recipient crashed (retry budget exhausted)' });
-            return `ERROR: recipient "${toQualified}" crashed and will not recover this run — message not delivered (${targetAgent.error ?? 'unknown error'})`;
-        }
-        if (targetAgent.mailbox.isClosed) {
-            // The org is mid-shutdown: mailboxes close before the org is removed
-            // from `this.orgs`, so a message can arrive in that window. push() would
-            // silently no-op — report the real outcome instead of a false "delivered".
-            src?.bus.emit({ type: 'audit', from: fromRole, to: toQualified, msg: `undeliverable: ${subject}`, reason: 'target mailbox closed (org shutting down)' });
-            return `ERROR: recipient "${toQualified}" is shutting down — message not delivered`;
-        }
-        const evt = { from: cross ? `${fromOrg}:${fromRole}` : fromRole, to: toQualified, subject, msg: body };
-        src?.bus.emit({ type: cross ? 'xorg' : 'message', ...evt });
-        if (cross && targetOrg !== src)
-            targetOrg.bus.emit({ type: 'xorg', ...evt });
-        targetAgent.mailbox.push(`[message from ${evt.from}] subject: ${subject}\n\n${body}`);
-        return `delivered to ${toQualified}`;
-    }
-    /** Cross-process leg of deliver(): ask the machine-local broker who hosts targetOrgName, then POST over HTTP.
-     *  `to` here is always the fully-qualified "org:role" display form (resolveAddress already normalized it). */
-    async deliverRemote(fromOrg, fromRole, targetOrgName, targetRole, to, subject, body, src) {
-        const remote = lookupOrg(targetOrgName, this.opts.brokerDir);
-        if (!remote) {
-            // No remote host either — queue + auto-wake if the org def exists locally
-            if (this.hasOrgDef(targetOrgName)) {
-                queueMessage(this.root, targetOrgName, { fromQualified: `${fromOrg}:${fromRole}`, toRole: targetRole, subject, body, ts: Date.now() });
-                src?.bus.emit({ type: 'xorg', from: `${fromOrg}:${fromRole}`, to, subject, msg: body, data: { queued: true } });
-                this.autoWake(targetOrgName);
-                return `queued for ${to} (org starting)`;
-            }
-            src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `undeliverable: ${subject}`, reason: 'unknown recipient' });
-            return `ERROR: unknown recipient "${to}" (no local org, and no process on this machine has org "${targetOrgName}" registered)`;
-        }
-        try {
-            const res = await fetch(`${remote.url}/api/xdeliver`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ fromOrg, fromRole, toOrg: targetOrgName, toRole: targetRole, subject, body }),
-                signal: AbortSignal.timeout(10_000),
-            });
-            const data = await res.json().catch(() => ({}));
-            if (res.ok && data.ok) {
-                src?.bus.emit({ type: 'xorg', from: `${fromOrg}:${fromRole}`, to, subject, msg: body });
-                return data.receipt ?? `delivered to ${to} (remote)`;
-            }
-            src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `remote delivery rejected: ${data.error ?? res.status}`, reason: 'remote-delivery-rejected' });
-            return `ERROR: remote org "${to}" rejected delivery: ${data.error ?? res.status}`;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `remote delivery failed: ${message}`, reason: 'remote-delivery-failed' });
-            return `ERROR: remote org "${targetOrgName}" unreachable: ${message}`;
-        }
-    }
-    /** Inbound handler for cross-process delivery — called by the server's POST /api/xdeliver route
-     *  when ANOTHER process's deliverRemote() reaches this daemon. Pushes straight into the target
-     *  agent's mailbox; the agent picks it up on its own next turn (see Mailbox — never interrupts). */
-    receiveRemote(toOrg, toRole, fromQualified, subject, body) {
-        const org = this.orgs.get(toOrg);
-        if (!org) {
-            // Org not running — queue the message and auto-wake if the def exists
-            if (this.hasOrgDef(toOrg)) {
-                queueMessage(this.root, toOrg, { fromQualified, toRole, subject, body, ts: Date.now() });
-                this.autoWake(toOrg);
-                return { ok: true, receipt: `queued for ${toOrg}:${toRole} (org waking)` };
-            }
-            return { ok: false, error: `org "${toOrg}" not hosted here` };
-        }
-        const agent = org.agents.get(toRole);
-        if (!agent)
-            return { ok: false, error: `role "${toRole}" not found in org "${toOrg}"` };
-        if (agent.status === 'crashed')
-            return { ok: false, error: `role "${toRole}" in org "${toOrg}" crashed and will not recover this run` };
-        if (agent.mailbox.isClosed)
-            return { ok: false, error: `role "${toRole}" in org "${toOrg}" is shutting down` };
-        org.bus.emit({ type: 'xorg', from: fromQualified, to: `${toOrg}:${toRole}`, subject, msg: body });
-        agent.mailbox.push(`[message from ${fromQualified}] subject: ${subject}\n\n${body}`);
-        return { ok: true, receipt: `delivered to ${toOrg}:${toRole} (remote)` };
-    }
-    hasOrgDef(name) {
-        return existsSync(join(this.root, ORG_DIR, `${name}.json`));
-    }
-    questionsPath(org) {
-        return join(this.root, ORG_DIR, org, 'questions.json');
-    }
-    readQuestions(org) {
-        try {
-            return JSON.parse(readFileSync(this.questionsPath(org), 'utf8'));
-        }
-        catch {
-            return { questions: [] };
-        }
-    }
-    writeQuestions(org, data) {
-        const dest = this.questionsPath(org);
-        mkdirSync(join(this.root, ORG_DIR, org), { recursive: true });
-        const tmp = `${dest}.${process.pid}.tmp`;
-        writeFileSync(tmp, JSON.stringify(data, null, 2));
-        renameSync(tmp, dest);
-    }
-    /** Agent-initiated human question (ask_human tool). Persists to questions.json (survives
-     *  process/dashboard restarts) and emits a 'question' BusEvent so the dashboard's SSE
-     *  stream and global inbox pick it up in real time. Returns a receipt string for the tool call. */
-    async askHuman(org, role, question) {
-        const running = this.orgs.get(org);
-        const questionId = `q-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-        const data = this.readQuestions(org);
-        data.questions.push({ questionId, role, question, ts: Date.now(), answer: null, answeredAt: null });
-        this.writeQuestions(org, data);
-        running?.bus.emit({ type: 'question', from: role, data: { questionId, question } });
-        return `Question recorded (id ${questionId}) — a human will answer it; you'll receive the answer as a new message.`;
-    }
-    /** Delivers a human's answer to a pending ask_human question. If the org is still
-     *  running, pushes straight into the role's live mailbox (picked up on its very next
-     *  generator tick — see Mailbox.stream()). If the org has since stopped, queues the
-     *  answer via the same offline fallback deliver()/receiveRemote() already use
-     *  (inbox.ts + autoWake) and it's delivered when the org next starts.
-     *
-     *  PERSIST-AFTER-DELIVERY: questions.json is only marked answered once delivery has
-     *  actually happened (mailbox push, or the message landing in inbox.jsonl). Marking it
-     *  first meant a rejected delivery — unknown role, mailbox closed mid-shutdown, a
-     *  queueMessage that threw on a full/read-only disk — left the question recorded as
-     *  answered while nobody ever received the answer, and the `already answered` guard
-     *  then refused every retry. The answer was simply gone. The inverse failure (crash
-     *  between delivery and the write) merely re-shows the question as pending, which a
-     *  human can act on; a silently swallowed answer is not recoverable. */
-    async answerQuestion(org, role, questionId, answer) {
-        const data = this.readQuestions(org);
-        const idx = data.questions.findIndex(q => q.questionId === questionId);
-        if (idx === -1)
-            return { ok: false, error: `question "${questionId}" not found for org "${org}"` };
-        if (data.questions[idx].answer !== null)
-            return { ok: false, error: `question "${questionId}" already answered` };
-        const question = data.questions[idx].question;
-        // Applied to questions.json ONLY after the delivery below succeeds.
-        const markAnswered = () => {
-            // Re-read so a question the daemon appended (or answered) meanwhile isn't
-            // clobbered by this stale snapshot — merge by questionId, never replace.
-            const fresh = this.readQuestions(org);
-            const fIdx = fresh.questions.findIndex(q => q.questionId === questionId);
-            if (fIdx === -1)
-                fresh.questions.push({ ...data.questions[idx], answer, answeredAt: Date.now() });
-            else
-                fresh.questions[fIdx] = { ...fresh.questions[fIdx], answer, answeredAt: Date.now() };
-            this.writeQuestions(org, fresh);
-        };
-        const running = this.orgs.get(org);
-        if (running) {
-            // Org IS running — deliver or report a real error, but never fall through to the
-            // offline queue+autoWake path below: autoWake() no-ops when this.orgs already has
-            // the org (see its own guard), so a role-specific delivery failure here (mailbox
-            // closed, role unknown) would otherwise queue the answer forever with no real error
-            // and no delivery. Mirrors deliver()'s existing "shutting down" error for the same
-            // mid-shutdown-mailbox-closed race.
-            const agent = running.agents.get(role);
-            if (!agent)
-                return { ok: false, error: `role "${role}" not found in org "${org}"` };
-            if (agent.mailbox.isClosed)
-                return { ok: false, error: `role "${role}" in org "${org}" is shutting down — answer not delivered` };
-            try {
-                agent.mailbox.push(`[answer from human] question: ${question}\n\nanswer: ${answer}`);
-            }
-            catch (err) {
-                return { ok: false, error: `delivery to "${role}" in org "${org}" failed — answer not recorded (${err instanceof Error ? err.message : String(err)})` };
-            }
-            markAnswered();
-            running.bus.emit({ type: 'status', from: role, msg: 'question answered', data: { questionId } });
-            return { ok: true };
-        }
-        // Org not running at all — queue for delivery on next start, matching deliver()'s
-        // existing offline fallback exactly (inbox.ts + autoWake).
-        if (!this.hasOrgDef(org))
-            return { ok: false, error: `org "${org}" not found (no saved definition)` };
-        try {
-            queueMessage(this.root, org, {
-                fromQualified: 'human', toRole: role,
-                subject: `answer:${questionId}`,
-                body: `question: ${question}\n\nanswer: ${answer}`,
-                ts: Date.now(),
-            });
-        }
-        catch (err) {
-            return { ok: false, error: `could not queue answer for org "${org}" — answer not recorded (${err instanceof Error ? err.message : String(err)})` };
-        }
-        markAnswered();
-        this.autoWake(org);
-        return { ok: true };
-    }
-    /** Start an offline org in the background so queued messages get drained.
-     *  Fire-and-forget — errors are logged but don't propagate to the sender. */
-    autoWake(name) {
-        if (this.orgs.has(name) || this.waking.has(name))
-            return;
-        this.waking.add(name);
-        this.startOrg(name)
-            .catch(err => { console.error(`auto-wake org "${name}" failed:`, err instanceof Error ? err.message : err); })
-            .finally(() => { this.waking.delete(name); });
-    }
-    async stopOrg(name) {
-        // Join an in-flight stop instead of no-oping: the self-stop paths
-        // (org_complete, idle watchdog) run detached, and a caller like
-        // `org run`'s final stopAll() must not resolve — letting the process
-        // exit — while that stop is still flushing the bus and writing
-        // history/runtime.json.
-        const inflight = this.stopping.get(name);
-        if (inflight)
-            return inflight;
-        const org = this.orgs.get(name);
-        if (!org)
-            return; // already stopped
-        // Remove immediately (not at the end) so a concurrent stopOrg(name) call —
-        // e.g. stopAll() racing a scheduler-triggered stop on SIGINT — joins this
-        // shutdown via `stopping` instead of re-running the whole sequence and
-        // double-emitting 'org stopped' (duplicate org:complete/session:complete).
-        this.orgs.delete(name);
-        const p = this.finishStop(name, org);
-        this.stopping.set(name, p);
-        try {
-            await p;
-        }
-        finally {
-            this.stopping.delete(name);
-        }
-    }
-    async finishStop(name, org) {
-        // 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
-        // that one would sever the new run's dashboard stream.
-        const forwarder = this.forwarders.get(name);
-        // Remove crash-cleanup handler — normal stop handles reaping itself
-        const cleanup = org._crashCleanup;
-        if (cleanup)
-            process.removeListener('exit', cleanup);
-        const wd = this.watchdogs.get(name);
-        if (wd) {
-            clearInterval(wd);
-            this.watchdogs.delete(name);
-        }
-        this.leases.get(name)?.stop();
-        this.leases.delete(name);
-        for (const a of org.agents.values())
-            a.mailbox.close();
-        // Bounded: a genuinely hung agent session (stuck mid-tool-call, not just
-        // idle) must not make stopOrg() hang forever — callers like the scheduler
-        // already race their own timeout around a run, and this wait re-blocking
-        // unboundedly on the same never-resolving promises defeated that bound.
-        const stopWaitMs = 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))]);
-        if (timedOut) {
-            org.bus.emit({
-                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
-            // ensures other `monomind org run` daemons' agents are untouched.
-            try {
-                const { reapOrphanedSdkProcesses } = await import('../utils/resource-governor.js');
-                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` });
-            }
-            catch { /* best-effort */ }
-        }
-        org.bus.emit({ type: 'status', msg: 'org stopped' });
-        await org.bus.flush();
-        // Append this run's summary to <org>/history.jsonl — read back from the
-        // flushed bus.jsonl (the full durable record) rather than the bounded
-        // in-memory buffer, so long runs summarize completely.
-        try {
-            const events = readRunEvents(this.root, name, org.run);
-            if (events.length) {
-                const summary = summarizeRun(events);
-                const { appendFileSync } = await import('node:fs');
-                appendFileSync(historyFile(this.root, name), JSON.stringify(summary) + '\n', 'utf8');
-                // Cross-run memory: make this run's outcome recallable by meaning
-                await this.storeRunMemory(name, org.def, org.run, summary);
-            }
-        }
-        catch (err) {
-            console.error(`org ${name}: could not write run history:`, err instanceof Error ? err.message : err);
-        }
-        finally {
-            this.recallUsage.delete(name);
-            this.orgLearnedRuns.delete(`${name}:${org.run}`);
-        }
-        // the "org stopped" event above triggers the forwarder's final org:complete /
-        // session:complete POST — without waiting for it here, the CLI process can exit
-        // (and kill the in-flight fetch) before that last event reaches the dashboard,
-        // leaving the run stuck showing "running" forever. Bounded: a stalled
-        // dashboard must not hang org shutdown indefinitely.
-        if (forwarder) {
-            await Promise.race([
-                forwarder.settle(),
-                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
-            // have registered the new run's forwarder under this name meanwhile.
-            if (this.forwarders.get(name) === forwarder)
-                this.forwarders.delete(name);
-        }
-        // Same guard for runtime.json: if a new run started during shutdown, its
-        // 'running' record must not be overwritten with this old run's 'stopped'.
-        if (!this.orgs.has(name))
-            this.persistState(name, 'stopped', org.run);
-    }
-    async stopAll() {
-        await Promise.all([
-            ...[...this.orgs.keys()].map(n => this.stopOrg(n)),
-            ...this.stopping.values(), // detached self-stops still flushing
-        ]);
-    }
-    orgMemoryNamespace(name, def) {
-        return def.run_config.memory_namespace ?? `org:${name}`;
-    }
-    /** Store dir for org cross-run memory — inside the org root so the bridge's
-     *  path guard accepts it when the daemon runs from the project (the normal
-     *  case) and test roots stay isolated. */
-    orgMemoryDbPath() {
-        return join(this.root, '.monomind', 'org-memory');
-    }
-    /** The memory bridge's traversal guard silently redirects out-of-tree paths
-     *  to the per-project default store. For an org rooted outside cwd (tests,
-     *  unusual daemon setups) that redirect would write into the WRONG project's
-     *  memory — verify the guard kept our path, and skip org memory otherwise. */
-    async orgMemoryUsable() {
-        try {
-            const { bridgeGetDbPath } = await import('../memory/memory-bridge.js');
-            const want = this.orgMemoryDbPath();
-            const got = bridgeGetDbPath(want);
-            const { realpathSync } = await import('node:fs');
-            const real = (p) => { try {
-                return realpathSync(p);
-            }
-            catch {
-                return p;
-            } };
-            return real(got) === real(want);
-        }
-        catch {
-            return false;
-        }
-    }
-    /** Namespace for a role's PRIVATE memories, inside the org memory DB. */
-    agentMemoryNamespace(name, def, role) {
-        return `agent:${this.orgMemoryNamespace(name, def)}:${role}`;
-    }
-    /** org_remember implementation: a deliberate write to org-shared or
-     *  role-private memory (both in the org memory DB, split by namespace). */
-    async rememberOrgMemory(name, def, role, content, scope, run) {
-        try {
-            if (!(await this.orgMemoryUsable()))
-                return 'org memory is not available in this environment.';
-            const { bridgeStoreEntry } = await import('../memory/memory-bridge.js');
-            const namespace = scope === 'agent' ? this.agentMemoryNamespace(name, def, role) : this.orgMemoryNamespace(name, def);
-            const res = await bridgeStoreEntry({
-                key: `mem-${run}-${Date.now().toString(36)}`,
-                value: content.slice(0, 20_000),
-                namespace,
-                dbPath: this.orgMemoryDbPath(),
-                tags: [scope, role],
-                metadata: { origin_refs: [`run:${run}`], by: role },
-            });
-            if (res?.duplicate)
-                return `Already remembered (near-duplicate exists) — reinforced instead.`;
-            return res?.success ? `Remembered (${scope} scope).` : `Could not store memory${res?.error ? `: ${res.error}` : ''}.`;
-        }
-        catch (err) {
-            return `org_remember failed (${err instanceof Error ? err.message : 'error'})`;
-        }
-    }
-    /** Entry IDs served by org_recall during the current run, per org. This is
-     *  the usage record the run-outcome auto-rating consumes (cognee's
-     *  used_graph_element_ids pattern) — recall renders text to the agent, so
-     *  the IDs must be captured here or they're gone. */
-    recallUsage = new Map();
-    /** org_recall implementation: search the org's memory namespace via the
-     *  memory bridge (semantic when the local model is available, tokenized
-     *  keyword otherwise). Failures return a message, never throw into the tool. */
-    async recallOrgMemory(name, def, query, role) {
-        try {
-            if (!(await this.orgMemoryUsable()))
-                return { text: 'org memory is not available in this environment.', hits: 0 };
-            const bridge = await import('../memory/memory-bridge.js');
-            // Shared org memory plus the caller's private agent scope, merged by score.
-            const [shared, priv] = await Promise.all([
-                bridge.bridgeSearchEntries({
-                    query, namespace: this.orgMemoryNamespace(name, def), limit: 5, dbPath: this.orgMemoryDbPath(),
-                }),
-                role ? bridge.bridgeSearchEntries({
-                    query, namespace: this.agentMemoryNamespace(name, def, role), limit: 3, dbPath: this.orgMemoryDbPath(),
-                }) : null,
-            ]);
-            const results = [
-                ...(shared?.results ?? []),
-                ...(priv?.results ?? []).map(r => ({ ...r, key: `${r.key} (private)` })),
-            ].sort((a, b) => b.score - a.score).slice(0, 6);
-            if (!results.length)
-                return { text: 'No matching org memory found — this may be the first run covering this topic.', hits: 0 };
-            const ids = results.map(r => r.id).filter(Boolean);
-            let used = this.recallUsage.get(name);
-            if (!used) {
-                used = new Set();
-                this.recallUsage.set(name, used);
-            }
-            for (const id of ids)
-                used.add(id);
-            // Frequency reinforcement is immediate; the feedback rating waits for the
-            // run outcome (positive-only — see storeRunMemory).
-            bridge.bridgeRecordUsage({ entryIds: ids, dbPath: this.orgMemoryDbPath() }).catch(() => { });
-            let text = results.map((r, i) => `${i + 1}. [${r.key}] ${r.content}`).join('\n\n');
-            // Structured knowledge: relationship triplets from the org KG, when any.
-            try {
-                const kg = await import('../memory/memory-kg.js');
-                const graph = await kg.kgSearch({ query, dbPath: this.orgMemoryDbPath(), limit: 5 });
-                if (graph.context)
-                    text += `\n\nKnowledge graph:\n${graph.context}`;
-            }
-            catch { /* best effort */ }
-            return { text, hits: results.length };
-        }
-        catch (err) {
-            return { text: `org memory unavailable (${err instanceof Error ? err.message : 'error'})`, hits: 0 };
-        }
-    }
-    /** knowledge_search implementation for org agents: the user's Second Brain
-     *  (this project's documents + the personal global brain), merged with the
-     *  same project-first ranking every other surface uses. Failures return a
-     *  message, never throw into the tool call. */
-    async searchProjectKnowledge(query) {
-        try {
-            const { searchKnowledge } = await import('../knowledge/document-pipeline.js');
-            const excerpts = await searchKnowledge(query, { rootDir: this.root, limit: 5, store: 'all' });
-            if (!excerpts.length)
-                return { text: 'No matching documents in the Second Brain for that query.', hits: 0 };
-            const text = excerpts.map((e, i) => `${i + 1}. [${e.filePath || 'unknown'}${e.scope === 'global' ? ' · global' : ''}] (${e.similarity.toFixed(2)})\n${e.text.slice(0, 800)}`).join('\n\n');
-            return { text, hits: excerpts.length };
-        }
-        catch (err) {
-            return { text: `knowledge search unavailable (${err instanceof Error ? err.message : 'error'})`, hits: 0 };
-        }
-    }
-    /** org_learn implementation: merge coordinator-extracted entities/relations/
-     *  rules into the org's knowledge graph (LLM extraction happens inside the
-     *  agent's own subscription-auth SDK session — no separate LLM call here). */
-    orgLearnedRuns = new Set();
-    async learnOrgKnowledge(name, run, payload) {
-        try {
-            if (!(await this.orgMemoryUsable()))
-                return 'org memory is not available in this environment.';
-            const kg = await import('../memory/memory-kg.js');
-            const dbPath = this.orgMemoryDbPath();
-            const originRef = `run:${run}`;
-            const graph = await kg.kgIngest({
-                nodes: (payload.nodes ?? []),
-                edges: (payload.edges ?? []),
-                originRef, dbPath,
-            });
-            const rules = Array.isArray(payload.rules) && payload.rules.length
-                ? await kg.kgIngestRules({ rules: payload.rules, originRef, dbPath })
-                : null;
-            this.orgLearnedRuns.add(`${name}:${run}`);
-            const parts = [
-                `entities: +${graph.nodesAdded} new, ${graph.nodesMerged} merged`,
-                `relations: +${graph.edgesAdded} new, ${graph.edgesMerged} merged`,
-            ];
-            if (rules)
-                parts.push(`rules: ${rules.accepted} accepted, ${rules.verdicts.filter(v => v.verdict === 'already_known').length} already known`);
-            return `Recorded in org knowledge graph — ${parts.join('; ')}. Rollback ref: ${originRef}.`;
-        }
-        catch (err) {
-            return `org_learn failed (${err instanceof Error ? err.message : 'error'})`;
-        }
-    }
-    /** Persist the run's outcome into cross-run org memory so org_recall (and
-     *  future runs) can find it by meaning, not just recency. Best-effort. */
-    async storeRunMemory(name, def, run, summary) {
-        try {
-            if (!(await this.orgMemoryUsable()))
-                return;
-            const { bridgeStoreEntry } = await import('../memory/memory-bridge.js');
-            const when = summary.endedAt ? new Date(summary.endedAt).toISOString().slice(0, 10) : '';
-            const lines = [
-                `Org run ${run}${when ? ` (${when})` : ''} — goal: ${def.goal}`,
-                summary.outcome
-                    ? `Outcome: ${summary.outcome.status} — ${summary.outcome.summary}`
-                    : `Outcome: not recorded (${summary.messages} messages exchanged)`,
-                summary.assets.length ? `Assets produced: ${summary.assets.slice(0, 10).join(', ')}` : '',
-                summary.crashes.length ? `Crashed agents: ${summary.crashes.join(', ')}` : '',
-            ].filter(Boolean);
-            await bridgeStoreEntry({
-                key: `run-${run}`,
-                value: lines.join('\n'),
-                namespace: this.orgMemoryNamespace(name, def),
-                dbPath: this.orgMemoryDbPath(),
-                upsert: true,
-            });
-            // Heuristic KG fallback: if the coordinator never called org_learn this
-            // run, extract lower-trust entities from the outcome summary so the
-            // graph still accumulates something. LLM-quality extraction only comes
-            // from org_learn (the agent's own session).
-            if (!this.orgLearnedRuns.delete(`${name}:${run}`)) {
-                try {
-                    const kg = await import('../memory/memory-kg.js');
-                    const extracted = kg.heuristicExtract(lines.join('\n'), { sourceName: `run:${run}` });
-                    if (extracted.nodes.length) {
-                        await kg.kgIngest({ ...extracted, originRef: `run:${run}`, dbPath: this.orgMemoryDbPath() });
-                    }
-                }
-                catch { /* best effort */ }
-            }
-            // Auto-rate the memories this run recalled — POSITIVE-ONLY: a failed run
-            // proves nothing about the recalled memories (the failure may be entirely
-            // unrelated), so failure never rates them down. Idempotent per run via
-            // the feedback ledger, so a retried stopOrg can't double-apply.
-            const used = this.recallUsage.get(name);
-            this.recallUsage.delete(name);
-            if (used?.size && summary.outcome?.status === 'achieved') {
-                const { bridgeApplyFeedback } = await import('../memory/memory-bridge.js');
-                await bridgeApplyFeedback({
-                    entryIds: [...used],
-                    score: 0.9,
-                    ledgerKey: `org-${name}-${run}`,
-                    dbPath: this.orgMemoryDbPath(),
-                }).catch(() => { });
-            }
-        }
-        catch (err) {
-            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                console.error(`org ${name}: run memory store failed:`, err instanceof Error ? err.message : err);
-        }
-    }
-    persistState(name, status, run) {
-        const p = join(this.root, ORG_DIR, name, 'runtime.json');
-        writeFileSync(p, JSON.stringify({ status, run, pid: process.pid, updated: new Date().toISOString() }, null, 2));
-    }
-    /** Mark every currently-running org as crashed in runtime.json.
-     *  Called from process-level crash handlers — must be synchronous and best-effort. */
-    persistCrashStateAll() {
-        for (const [name, org] of this.orgs) {
-            try {
-                const p = join(this.root, ORG_DIR, name, 'runtime.json');
-                writeFileSync(p, JSON.stringify({
-                    status: 'crashed', run: org.run, pid: process.pid,
-                    updated: new Date().toISOString(), closedBy: 'crash-handler',
-                }, null, 2));
-            }
-            catch { /* best effort — filesystem may be unavailable */ }
-        }
-    }
-    heartbeatPath() {
-        return join(this.root, '.monomind', 'serve-heartbeat.json');
-    }
-    /** Write a heartbeat file so `org status` can distinguish "daemon alive" from
-     *  "daemon gone" even when runtime.json still says running. */
-    writeHeartbeat() {
-        try {
-            const p = this.heartbeatPath();
-            mkdirSync(join(this.root, '.monomind'), { recursive: true });
-            writeFileSync(p, JSON.stringify({
-                pid: process.pid, updatedAt: new Date().toISOString(),
-                running: this.listRunning(),
-            }, null, 2));
-        }
-        catch { /* best effort */ }
-    }
-    clearHeartbeat() {
-        try {
-            unlinkSync(this.heartbeatPath());
-        }
-        catch { /* already gone or never written */ }
-    }
-}
-//# sourceMappingURL=daemon.js.map