@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/canvas/canvas.js

@@ -1,933 +1,26 @@
-// The canvas data-access layer. Nodes, their sessions, executions, and managed
-// worktrees are SQL-authoritative. Node directories hold only artifacts.
-import { envNodeId } from '../../shared/env.js';
-import { existsSync, realpathSync, rmSync, statSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { openDb, withCanvasWrite } from './db.js';
-import { activateArmedExternalActionDelivery, armExternalActionDelivery } from './deliveries.js';
-import { findNodeBySessionFileSql } from './sessions.js';
-import { readFault, readLiveTurn } from './recovery.js';
-import { hasUnreconciledWorktree, openWorktree, readWorktree } from './worktrees.js';
-import { isPidAlive, recordedPidLiveness } from './pid.js';
-import { ensureHome, ensureNodeDirs, jobDir, nodeDir } from './paths.js';
-function jsonValue(value, field) {
-    if (value === undefined || value === null)
-        return null;
-    const encoded = JSON.stringify(value);
-    if (encoded === undefined)
-        throw new TypeError(`${field} must be JSON-serializable`);
-    return encoded;
-}
-function insertArmedOutcomeDelivery(db, nodeId, delivery) {
-    armExternalActionDelivery(db, {
-        destinationId: delivery.actionName,
-        adapter: {
-            adapter: 'subprocess', argv: delivery.argv, cwd: delivery.cwd,
-            config_origin: delivery.configOrigin, payload: delivery.payload ?? null,
-        },
-        idempotencyKey: `node-outcome:${nodeId}`,
-    });
-}
-function seedRow(meta, db) {
-    db.prepare(`INSERT INTO nodes (node_id, name, description, title, icon, cycles, kind, mode, lifecycle, cwd, host_kind, profile_id, parent, spawned_by, creator, fork_from, fork_source_file, created, passive_default, cycle_pending, model_override, persona_ack_json, review_binding_json, launch_config_json, status, intent, waiting_for, final_report, finalized_at, deadline_at, "window", tmux_session, pane) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(meta.node_id, meta.name, meta.description ?? null, meta.title ?? null, meta.icon ?? null, meta.cycles ?? null, meta.kind, meta.mode, meta.lifecycle, meta.cwd, meta.host_kind ?? null, meta.profile_id ?? null, meta.parent ?? null, meta.spawned_by ?? null, meta.creator ?? null, meta.fork_from ?? null, meta.fork_source_file ?? null, meta.created, meta.passive_default === true ? 1 : 0, meta.cycle_pending === true ? 1 : 0, meta.model_override ?? null, jsonValue(meta.persona_ack, 'persona_ack'), jsonValue(meta.review_binding, 'review_binding'), jsonValue(meta.launch, 'launch'), meta.status ?? 'active', meta.intent ?? null, meta.waiting_for ?? null, meta.final_report ?? null, meta.finalized_at ?? null, meta.deadline_at ?? null, meta.window ?? null, meta.tmux_session ?? null, meta.pane ?? null);
-}
-function rowFrom(r) {
-    const node = {
-        node_id: r['node_id'],
-        name: r['name'],
-        description: r['description'] ?? undefined,
-        cycles: r['cycles'] ?? undefined,
-        kind: r['kind'],
-        mode: r['mode'],
-        lifecycle: r['lifecycle'],
-        status: r['status'],
-        cwd: r['cwd'],
-        host_kind: r['host_kind'] ?? null,
-        profile_id: r['profile_id'] ?? null,
-        parent: r['parent'] ?? null,
-        created: r['created'],
-        intent: r['intent'] ?? null,
-        waiting_for: r['waiting_for'] ?? null,
-        frozen_at: r['frozen_at'] ?? null,
-        respawn_failures: r['respawn_failures'] ?? 0,
-        respawn_not_before: r['respawn_not_before'] ?? null,
-        launched_at: r['launched_at'] ?? null,
-        last_settled_at: r['last_settled_at'] ?? null,
-        terminal_reason: r['terminal_reason'] ?? null,
-        final_report: r['final_report'] ?? null,
-        finalized_at: r['finalized_at'] ?? null,
-        outcome_kind: r['outcome_kind'] ?? null,
-        outcome_reason: r['outcome_reason'] ?? null,
-        outcome_at: r['outcome_at'] ?? null,
-        outcome_revision: r['outcome_revision'] ?? 0,
-        outcome_detail_json: r['outcome_detail_json'] ?? null,
-        deadline_at: r['deadline_at'] ?? null,
-        pi_pid: r['pi_pid'] ?? null,
-        pi_pid_identity: r['pi_pid_identity'] ?? null,
-        window: r['window'] ?? null,
-        tmux_session: r['tmux_session'] ?? null,
-        pane: r['pane'] ?? null,
-        fault: null,
-        streaming: false,
-    };
-    const fault = readFault(node.node_id);
-    node.fault = fault?.link === 'pi→provider' && fault.retry.by === 'daemon' && fault.retry.disposition === 'auto' && !isPidAlive(node.pi_pid)
-        ? null
-        : fault;
-    node.streaming = readLiveTurn(node.node_id)?.busy === true && isPidAlive(node.pi_pid);
-    return node;
-}
-// Nodes
-/** Create a SQL-authoritative node, then ensure its artifact directories exist. */
-export function createNode(meta, opts = {}) {
-    ensureHome();
-    withCanvasWrite((db) => {
-        seedRow(meta, db);
-        if (meta.managed_worktree !== undefined && meta.managed_worktree !== null)
-            openWorktree(meta.node_id, meta.managed_worktree, db);
-        if (opts.outcomeDelivery !== undefined)
-            insertArmedOutcomeDelivery(db, meta.node_id, opts.outcomeDelivery);
-    });
-    ensureNodeDirs(meta.node_id);
-    return getNode(meta.node_id);
-}
-/** The canonical node record, hydrated from SQL. Null if unknown. */
-export function getNode(nodeId) {
-    const row = openDb().prepare('SELECT * FROM node_rows WHERE node_id = ?').get(nodeId);
-    if (row === undefined)
-        return null;
-    const worktree = readWorktree(nodeId);
-    return {
-        ...rowFrom(row),
-        title: row['title'] ?? undefined,
-        icon: row['icon'] ?? undefined,
-        spawned_by: row['spawned_by'] ?? null,
-        creator: row['creator'] ?? null,
-        fork_from: row['fork_from'] ?? null,
-        fork_source_file: row['fork_source_file'] ?? null,
-        passive_default: row['passive_default'] === 1,
-        cycle_pending: row['cycle_pending'] === 1,
-        model_override: row['model_override'] ?? null,
-        persona_ack: row['persona_ack_json'] == null ? undefined : JSON.parse(row['persona_ack_json']),
-        review_binding: row['review_binding_json'] == null ? undefined : JSON.parse(row['review_binding_json']),
-        launch: row['launch_config_json'] == null ? undefined : JSON.parse(row['launch_config_json']),
-        pi_session_id: row['pi_session_id'] ?? null,
-        pi_session_file: row['pi_session_file'] ?? null,
-        ...(worktree === null ? {} : { managed_worktree: worktree }),
-    };
-}
-export function canonicalSessionFile(sessionFile) {
-    const absolute = resolve(sessionFile);
-    return existsSync(absolute) ? realpathSync(absolute) : absolute;
-}
-/** Resolve the crouter node that owns one exact Pi session file. */
-export function findNodeBySessionFile(sessionFile) {
-    const nodeId = findNodeBySessionFileSql(sessionFile);
-    return nodeId === null ? null : getNode(nodeId);
-}
-/** The indexed row (from the db) — cheap for queries that don't need full meta. */
-export function getRow(nodeId) {
-    const r = openDb().prepare('SELECT * FROM node_rows WHERE node_id = ?').get(nodeId);
-    return r ? rowFrom(r) : null;
-}
-/** The node row whose durable LOCATION pane is `pane`, or null. Lets placement
- *  resolve "who sits in this pane" by the first-class `%pane_id` handle (e.g.
- *  to adopt a caller's pane as a focus). pane is not UNIQUE in the schema, but a
- *  live pane backs at most one node, so this returns the single match. */
-export function getRowByPane(pane) {
-    const r = openDb().prepare('SELECT * FROM node_rows WHERE pane = ?').get(pane);
-    return r ? rowFrom(r) : null;
-}
-/** Nodes whose persisted spawn deadline has elapsed and that remain live work. */
-export function dueNodeDeadlines(nowIso) {
-    return openDb().prepare(`SELECT * FROM node_rows
+var x=Object.defineProperty;var o=(e,n)=>x(e,"name",{value:n,configurable:!0});import{envNodeId as O}from"../../shared/env.js";import{existsSync as W,realpathSync as k,rmSync as N,statSync as H}from"node:fs";import{join as F,resolve as M}from"node:path";import{openDb as s,withCanvasWrite as p}from"./db.js";import{activateArmedExternalActionDelivery as U,armExternalActionDelivery as j}from"./deliveries.js";import{findNodeBySessionFileSql as I}from"./sessions.js";import{readFault as P,readLiveTurn as C}from"./recovery.js";import{hasUnreconciledWorktree as $,openWorktree as B,readWorktree as z}from"./worktrees.js";import{isPidAlive as g,recordedPidLiveness as J}from"./pid.js";import{ensureHome as Y,ensureNodeDirs as q,jobDir as V,nodeDir as S}from"./paths.js";function E(e,n){if(e==null)return null;const t=JSON.stringify(e);if(t===void 0)throw new TypeError(`${n} must be JSON-serializable`);return t}o(E,"jsonValue");function h(e,n,t){j(e,{destinationId:t.actionName,adapter:{adapter:"subprocess",argv:t.argv,cwd:t.cwd,config_origin:t.configOrigin,payload:t.payload??null},idempotencyKey:`node-outcome:${n}`})}o(h,"insertArmedOutcomeDelivery");function G(e,n){n.prepare('INSERT INTO nodes (node_id, name, description, title, icon, cycles, kind, mode, lifecycle, cwd, host_kind, profile_id, parent, spawned_by, creator, fork_from, fork_source_file, created, passive_default, cycle_pending, model_override, persona_ack_json, review_binding_json, launch_config_json, status, intent, waiting_for, final_report, finalized_at, deadline_at, "window", tmux_session, pane) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)').run(e.node_id,e.name,e.description??null,e.title??null,e.icon??null,e.cycles??null,e.kind,e.mode,e.lifecycle,e.cwd,e.host_kind??null,e.profile_id??null,e.parent??null,e.spawned_by??null,e.creator??null,e.fork_from??null,e.fork_source_file??null,e.created,e.passive_default===!0?1:0,e.cycle_pending===!0?1:0,e.model_override??null,E(e.persona_ack,"persona_ack"),E(e.review_binding,"review_binding"),E(e.launch,"launch"),e.status??"active",e.intent??null,e.waiting_for??null,e.final_report??null,e.finalized_at??null,e.deadline_at??null,e.window??null,e.tmux_session??null,e.pane??null)}o(G,"seedRow");function _(e){const n={node_id:e.node_id,name:e.name,description:e.description??void 0,cycles:e.cycles??void 0,kind:e.kind,mode:e.mode,lifecycle:e.lifecycle,status:e.status,cwd:e.cwd,host_kind:e.host_kind??null,profile_id:e.profile_id??null,parent:e.parent??null,created:e.created,intent:e.intent??null,waiting_for:e.waiting_for??null,frozen_at:e.frozen_at??null,respawn_failures:e.respawn_failures??0,respawn_not_before:e.respawn_not_before??null,launched_at:e.launched_at??null,last_settled_at:e.last_settled_at??null,terminal_reason:e.terminal_reason??null,final_report:e.final_report??null,finalized_at:e.finalized_at??null,outcome_kind:e.outcome_kind??null,outcome_reason:e.outcome_reason??null,outcome_at:e.outcome_at??null,outcome_revision:e.outcome_revision??0,outcome_detail_json:e.outcome_detail_json??null,deadline_at:e.deadline_at??null,pi_pid:e.pi_pid??null,pi_pid_identity:e.pi_pid_identity??null,window:e.window??null,tmux_session:e.tmux_session??null,pane:e.pane??null,fault:null,streaming:!1},t=P(n.node_id);return n.fault=t?.link==="pi\u2192provider"&&t.retry.by==="daemon"&&t.retry.disposition==="auto"&&!g(n.pi_pid)?null:t,n.streaming=C(n.node_id)?.busy===!0&&g(n.pi_pid),n}o(_,"rowFrom");function ce(e,n={}){return Y(),p(t=>{G(e,t),e.managed_worktree!==void 0&&e.managed_worktree!==null&&B(e.node_id,e.managed_worktree,t),n.outcomeDelivery!==void 0&&h(t,e.node_id,n.outcomeDelivery)}),q(e.node_id),f(e.node_id)}o(ce,"createNode");function f(e){const n=s().prepare("SELECT * FROM node_rows WHERE node_id = ?").get(e);if(n===void 0)return null;const t=z(e);return{..._(n),title:n.title??void 0,icon:n.icon??void 0,spawned_by:n.spawned_by??null,creator:n.creator??null,fork_from:n.fork_from??null,fork_source_file:n.fork_source_file??null,passive_default:n.passive_default===1,cycle_pending:n.cycle_pending===1,model_override:n.model_override??null,persona_ack:n.persona_ack_json==null?void 0:JSON.parse(n.persona_ack_json),review_binding:n.review_binding_json==null?void 0:JSON.parse(n.review_binding_json),launch:n.launch_config_json==null?void 0:JSON.parse(n.launch_config_json),pi_session_id:n.pi_session_id??null,pi_session_file:n.pi_session_file??null,...t===null?{}:{managed_worktree:t}}}o(f,"getNode");function pe(e){const n=M(e);return W(n)?k(n):n}o(pe,"canonicalSessionFile");function _e(e){const n=I(e);return n===null?null:f(n)}o(_e,"findNodeBySessionFile");function fe(e){const n=s().prepare("SELECT * FROM node_rows WHERE node_id = ?").get(e);return n?_(n):null}o(fe,"getRow");function Ee(e){const n=s().prepare("SELECT * FROM node_rows WHERE pane = ?").get(e);return n?_(n):null}o(Ee,"getRowByPane");function me(e){return s().prepare(`SELECT * FROM node_rows
      WHERE deadline_at IS NOT NULL AND outcome_at IS NULL
        AND deadline_at <= ? AND status IN ('active','idle') AND kind != 'human'
-     ORDER BY deadline_at, created, node_id`).all(nowIso).map(rowFrom);
-}
-/** Write a claimed warm spare's deadline before it is handed to its caller. */
-export function setNodeDeadline(nodeId, deadlineAt) {
-    return Number(openDb().prepare('UPDATE nodes SET deadline_at = ? WHERE node_id = ?').run(deadlineAt, nodeId).changes) === 1;
-}
-/** Shift active/idle profile deadlines by a completed profile pause duration. */
-export function shiftProfileNodeDeadlines(profileId, pauseDurationMs) {
-    if (!Number.isFinite(pauseDurationMs) || pauseDurationMs <= 0)
-        return 0;
-    return withCanvasWrite((db) => {
-        const rows = db.prepare(`SELECT node_id, deadline_at FROM nodes
-       WHERE profile_id = ? AND deadline_at IS NOT NULL AND status IN ('active', 'idle')`).all(profileId);
-        const update = db.prepare('UPDATE nodes SET deadline_at = ? WHERE node_id = ? AND deadline_at = ?');
-        let shifted = 0;
-        for (const row of rows) {
-            const at = Date.parse(row.deadline_at);
-            if (Number.isNaN(at))
-                continue;
-            shifted += Number(update.run(new Date(at + pauseDurationMs).toISOString(), row.node_id, row.deadline_at).changes);
-        }
-        return shifted;
-    });
-}
-function sqlInput(value, field) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint' || value instanceof Uint8Array)
-        return value;
-    throw new TypeError(`${field} must be a SQLite scalar`);
-}
-/** Update node identity/configuration columns. Sessions and worktrees have named stores. */
-export function updateNode(nodeId, patch) {
-    const fields = [];
-    const add = (key, column = key) => {
-        if (Object.prototype.hasOwnProperty.call(patch, key))
-            fields.push([column, sqlInput(patch[key], key)]);
-    };
-    add('name');
-    add('description');
-    add('title');
-    add('icon');
-    add('cycles');
-    add('kind');
-    add('mode');
-    add('lifecycle');
-    add('cwd');
-    add('host_kind');
-    add('profile_id');
-    add('parent');
-    add('spawned_by');
-    add('creator');
-    add('fork_from');
-    add('fork_source_file');
-    add('model_override');
-    if (Object.prototype.hasOwnProperty.call(patch, 'passive_default'))
-        fields.push(['passive_default', patch.passive_default === true ? 1 : 0]);
-    if (Object.prototype.hasOwnProperty.call(patch, 'cycle_pending'))
-        fields.push(['cycle_pending', patch.cycle_pending === true ? 1 : 0]);
-    if (Object.prototype.hasOwnProperty.call(patch, 'persona_ack'))
-        fields.push(['persona_ack_json', jsonValue(patch.persona_ack, 'persona_ack')]);
-    if (Object.prototype.hasOwnProperty.call(patch, 'review_binding'))
-        fields.push(['review_binding_json', jsonValue(patch.review_binding, 'review_binding')]);
-    if (Object.prototype.hasOwnProperty.call(patch, 'launch'))
-        fields.push(['launch_config_json', jsonValue(patch.launch, 'launch')]);
-    if (fields.length === 0) {
-        const existing = getNode(nodeId);
-        if (existing === null)
-            throw new Error(`unknown node: ${nodeId}`);
-        return existing;
-    }
-    const result = openDb().prepare(`UPDATE nodes SET ${fields.map(([column]) => `${column} = ?`).join(', ')} WHERE node_id = ?`).run(...fields.map(([, value]) => value), nodeId);
-    if (result.changes !== 1)
-        throw new Error(`unknown node: ${nodeId}`);
-    return getNode(nodeId);
-}
-// Atomic runtime setters — each one a single-statement UPDATE on the WAL'd row,
-// the authoritative store for live state. No read-modify-write, so concurrent
-// writers of DIFFERENT fields (the daemon stamping pi_pid while a node flips
-// status) can never clobber each other: WAL serializes the two statements.
-// `"window"` is quoted defensively — it is a SQLite keyword.
-/** Set a node's status. Atomic single-column write. */
-export function setStatus(nodeId, status) {
-    openDb().prepare('UPDATE nodes SET status = ? WHERE node_id = ?').run(status, nodeId);
-}
-/** Set a node's exit intent. Atomic single-column write. */
-export function setIntent(nodeId, intent) {
-    openDb().prepare('UPDATE nodes SET intent = ? WHERE node_id = ?').run(intent ?? null, nodeId);
-}
-/** Atomically write status and/or intent, gated on an optional from-status set
- *  and/or on the row carrying no committed final_report. The lifecycle state
- *  machine (runtime/lifecycle.ts) is the one caller: it owns the legality
- *  table and the unknown-node/illegal-move/already-finalized-cancel branching,
- *  this only performs the single conditional UPDATE it needs. A PRESENT key in
- *  `fields` (even `intent: null`) writes that column; an ABSENT key leaves it
- *  unchanged. Returns the row-changed count so the caller can distinguish "no
- *  such node", "gate failed", and "already applied" without a second query. */
-export function transitionStatusIntent(nodeId, fields, opts = {}) {
-    // Keep the ordinary lifecycle write exactly as its pre-outcome form: one
-    // conditional UPDATE and no transaction boundary.
-    if (opts.outcome === undefined) {
-        const assignments = [];
-        const values = [];
-        if (Object.prototype.hasOwnProperty.call(fields, 'status')) {
-            assignments.push('status = ?');
-            values.push(fields.status ?? null);
-        }
-        if (Object.prototype.hasOwnProperty.call(fields, 'intent')) {
-            assignments.push('intent = ?');
-            values.push(fields.intent ?? null);
-        }
-        if (Object.prototype.hasOwnProperty.call(fields, 'terminal_reason')) {
-            assignments.push('terminal_reason = ?');
-            values.push(fields.terminal_reason ?? null);
-        }
-        const predicates = ['node_id = ?'];
-        values.push(nodeId);
-        if (opts.fromStatuses !== undefined) {
-            predicates.push(`status IN (${opts.fromStatuses.map(() => '?').join(', ')})`);
-            values.push(...opts.fromStatuses);
-        }
-        if (opts.requireNoFinalReport === true)
-            predicates.push('final_report IS NULL');
-        const result = openDb()
-            .prepare(`UPDATE nodes SET ${assignments.join(', ')} WHERE ${predicates.join(' AND ')}`)
-            .run(...values);
-        return Number(result.changes);
-    }
-    const outcome = opts.outcome;
-    return withCanvasWrite((db) => {
-        const assignments = [];
-        const values = [];
-        if (Object.prototype.hasOwnProperty.call(fields, 'status')) {
-            assignments.push('status = ?');
-            values.push(fields.status ?? null);
-        }
-        if (Object.prototype.hasOwnProperty.call(fields, 'intent')) {
-            assignments.push('intent = ?');
-            values.push(fields.intent ?? null);
-        }
-        if (Object.prototype.hasOwnProperty.call(fields, 'terminal_reason')) {
-            assignments.push('terminal_reason = ?');
-            values.push(fields.terminal_reason ?? null);
-        }
-        const outcomeValue = (value, column) => outcome.supersede === true ? '?' : `CASE WHEN outcome_at IS NULL THEN ? ELSE ${column} END`;
-        assignments.push(`outcome_kind = ${outcomeValue(outcome.kind, 'outcome_kind')}`, `outcome_reason = ${outcomeValue(outcome.reason, 'outcome_reason')}`, `outcome_detail_json = ${outcomeValue(outcome.detailJson, 'outcome_detail_json')}`, `outcome_revision = ${outcome.supersede === true ? 'outcome_revision + 1' : 'CASE WHEN outcome_at IS NULL THEN outcome_revision + 1 ELSE outcome_revision END'}`, `outcome_at = ${outcomeValue(outcome.at, 'outcome_at')}`);
-        values.push(outcome.kind, outcome.reason, outcome.detailJson, outcome.at);
-        const predicates = ['node_id = ?'];
-        values.push(nodeId);
-        if (opts.fromStatuses !== undefined) {
-            predicates.push(`status IN (${opts.fromStatuses.map(() => '?').join(', ')})`);
-            values.push(...opts.fromStatuses);
-        }
-        if (opts.requireNoFinalReport === true)
-            predicates.push('final_report IS NULL');
-        const result = db.prepare(`UPDATE nodes SET ${assignments.join(', ')} WHERE ${predicates.join(' AND ')}`).run(...values);
-        if (Number(result.changes) === 0)
-            return 0;
-        const latched = db.prepare('SELECT outcome_at FROM nodes WHERE node_id = ?').get(nodeId);
-        if ((outcome.supersede === true || latched.outcome_at === outcome.at) && outcome.documentJson !== null && outcome.documentJson !== undefined) {
-            activateArmedExternalActionDelivery(db, {
-                idempotencyKey: `node-outcome:${nodeId}`,
-                label: nodeId,
-                bodyJson: outcome.documentJson,
-                supersede: outcome.supersede === true,
-            });
-        }
-        return Number(result.changes);
-    });
-}
-/** Read a node's committed-final latch pointer. Pure read, no side effect. */
-export function getFinalReport(nodeId) {
-    const row = openDb().prepare('SELECT final_report FROM nodes WHERE node_id = ?').get(nodeId);
-    return row?.final_report ?? null;
-}
-/** CAS-clear a node's finalization latch (final_report + finalized_at) —
- *  retract-pointer-only. Gated on the exact final_report value the caller
- *  observed via getFinalReport, so a concurrent clear/refinalize can never be
- *  clobbered. Returns true iff the CAS matched and cleared. */
-export function clearFinalReportIfMatches(nodeId, expectedFinalReport) {
-    const result = openDb()
-        .prepare('UPDATE nodes SET final_report = NULL, finalized_at = NULL WHERE node_id = ? AND final_report = ?')
-        .run(nodeId, expectedFinalReport);
-    return result.changes > 0;
-}
-/** Set a node's tmux presence in one atomic write: the durable LOCATION anchor
- *  `pane` (the `%pane_id`) plus its derived cache (`tmux_session` + `window`).
- *  All three move together — `pane` joins the others inside the single UPDATE so
- *  a move never half-writes the location. `pane` is optional: a caller that does
- *  not yet track it (every caller, until the placement layer lands) writes null,
- *  which is harmless because nothing reads `pane` yet. */
-export function setPresence(nodeId, presence) {
-    openDb()
-        .prepare('UPDATE nodes SET tmux_session = ?, "window" = ?, pane = ? WHERE node_id = ?')
-        .run(presence.tmux_session ?? null, presence.window ?? null, presence.pane ?? null, nodeId);
-}
-export function recordLaunch(nodeId, at) {
-    openDb()
-        .prepare('UPDATE nodes SET launched_at = ?, frozen_at = NULL, respawn_not_before = NULL WHERE node_id = ?')
-        .run(at, nodeId);
-}
-export function recordSettledTurn(nodeId, at) {
-    openDb().prepare('UPDATE nodes SET last_settled_at = ? WHERE node_id = ?').run(at, nodeId);
-}
-export function setFrozen(nodeId, at) {
-    openDb().prepare('UPDATE nodes SET frozen_at = ? WHERE node_id = ?').run(at, nodeId);
-}
-export function clearFrozen(nodeId) {
-    openDb().prepare('UPDATE nodes SET frozen_at = NULL WHERE node_id = ?').run(nodeId);
-}
-export function recordRespawnAttempt(nodeId, attempt) {
-    openDb()
-        .prepare('UPDATE nodes SET respawn_failures = ?, respawn_not_before = ? WHERE node_id = ?')
-        .run(attempt.failures, attempt.notBefore, nodeId);
-}
-/** The one clause that hides unclaimed warm-pool spares from every listing.
- *  A spare is a real node with a booted broker, but nobody has been handed it
- *  yet — surfacing it would put a phantom empty conversation in the user's
- *  sidebar. Claiming deletes the marker, which is what makes the node visible. */
-const NOT_A_SPARE = 'node_id NOT IN (SELECT node_id FROM warm_pool)';
-/** Every hydrated node whose durable profile identity equals `profileId`.
- *  Unlike `listNodes`, this includes unclaimed warm-pool spares: profile
- *  deletion owns every matching row, whether or not it is user-visible. */
-export function listNodesByProfile(profileId) {
-    const ids = openDb()
-        .prepare('SELECT node_id FROM nodes WHERE profile_id = ? ORDER BY created')
-        .all(profileId);
-    return ids.map(({ node_id }) => {
-        const meta = getNode(node_id);
-        if (meta === null) {
-            throw new Error(`profile deletion cannot hydrate indexed node ${node_id}`);
-        }
-        return meta;
-    });
-}
-/** All rows, optionally filtered by status and terminal execution traces. Unclaimed warm spares are excluded. */
-/** Every node's durable memory-resolution coordinates, including unclaimed warm-pool spares. */
-export function listNodeMemoryTargets() {
-    return openDb()
-        .prepare('SELECT node_id, cwd, profile_id FROM nodes ORDER BY created')
-        .all()
-        .map((row) => {
-        const node = row;
-        return { nodeId: node.node_id, cwd: node.cwd, profileId: node.profile_id };
-    });
-}
-export function listNodes(filter) {
-    const clauses = [NOT_A_SPARE];
-    const params = [];
-    if (filter?.status !== undefined) {
-        const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
-        clauses.push(`status IN (${statuses.map(() => '?').join(',')})`);
-        params.push(...statuses);
-    }
-    if (filter?.withRecordedPid === true)
-        clauses.push('pi_pid IS NOT NULL');
-    if (filter?.withRecordedPidOrFrozen === true)
-        clauses.push('(pi_pid IS NOT NULL OR frozen_at IS NOT NULL)');
-    const rows = openDb()
-        .prepare(`SELECT * FROM node_rows WHERE ${clauses.join(' AND ')} ORDER BY created`)
-        .all(...params);
-    return rows.map(rowFrom);
-}
-/** Identity-only projection of every user-visible row: the broker's report
- *  resolver needs only "does this sender exist, and what is it called", and a
- *  three-column read stays cheap against a canvas of thousands of rows where a
- *  full `listNodes()` hydration does not. */
-export function listNodeIdentities() {
-    return openDb()
-        .prepare(`SELECT node_id, name, created FROM nodes WHERE ${NOT_A_SPARE} ORDER BY created`)
-        .all();
-}
-// Warm pool — spare booted roots awaiting a `prefer_warm` claim (see
-// `runtime/warm-pool.ts` for the recipe key and the mint/refill policy).
-/** Mark an already-spawned node as an unclaimed spare for `recipeKey`. Hides it
- *  from every listing until it is claimed. */
-export function registerWarmSpare(nodeId, recipeKey) {
-    withCanvasWrite((db) => {
-        db.prepare('INSERT OR REPLACE INTO warm_pool (node_id, recipe_key, created) VALUES (?, ?, ?)')
-            .run(nodeId, recipeKey, new Date().toISOString());
-    });
-}
-/** Take a parked spare OUT of the pool without claiming it — the reaper's
- *  first move. Returns false when the marker was already gone (a concurrent
- *  claim won it), which is the reaper's signal to leave that node alone: it is
- *  somebody's live conversation now, not a spare. Deleting the marker under the
- *  write lock is exactly what `claimWarmSpare` does, so the two can never both
- *  succeed on the same node. */
-export function unregisterWarmSpare(nodeId) {
-    return withCanvasWrite((db) => db.prepare('DELETE FROM warm_pool WHERE node_id = ?').run(nodeId).changes > 0);
-}
-function warmSpareRowsFor(db, recipeKey) {
-    const sql = `SELECT w.node_id AS node_id, w.recipe_key AS recipe_key, w.created AS created,
+     ORDER BY deadline_at, created, node_id`).all(e).map(_)}o(me,"dueNodeDeadlines");function we(e,n){return Number(s().prepare("UPDATE nodes SET deadline_at = ? WHERE node_id = ?").run(n,e).changes)===1}o(we,"setNodeDeadline");function Re(e,n){return!Number.isFinite(n)||n<=0?0:p(t=>{const r=t.prepare(`SELECT node_id, deadline_at FROM nodes
+       WHERE profile_id = ? AND deadline_at IS NOT NULL AND status IN ('active', 'idle')`).all(e),i=t.prepare("UPDATE nodes SET deadline_at = ? WHERE node_id = ? AND deadline_at = ?");let d=0;for(const a of r){const u=Date.parse(a.deadline_at);Number.isNaN(u)||(d+=Number(i.run(new Date(u+n).toISOString(),a.node_id,a.deadline_at).changes))}return d})}o(Re,"shiftProfileNodeDeadlines");function Q(e,n){if(e==null)return null;if(typeof e=="string"||typeof e=="number"||typeof e=="bigint"||e instanceof Uint8Array)return e;throw new TypeError(`${n} must be a SQLite scalar`)}o(Q,"sqlInput");function Ne(e,n){const t=[],r=o((d,a=d)=>{Object.prototype.hasOwnProperty.call(n,d)&&t.push([a,Q(n[d],d)])},"add");if(r("name"),r("description"),r("title"),r("icon"),r("cycles"),r("kind"),r("mode"),r("lifecycle"),r("cwd"),r("host_kind"),r("profile_id"),r("parent"),r("spawned_by"),r("creator"),r("fork_from"),r("fork_source_file"),r("model_override"),Object.prototype.hasOwnProperty.call(n,"passive_default")&&t.push(["passive_default",n.passive_default===!0?1:0]),Object.prototype.hasOwnProperty.call(n,"cycle_pending")&&t.push(["cycle_pending",n.cycle_pending===!0?1:0]),Object.prototype.hasOwnProperty.call(n,"persona_ack")&&t.push(["persona_ack_json",E(n.persona_ack,"persona_ack")]),Object.prototype.hasOwnProperty.call(n,"review_binding")&&t.push(["review_binding_json",E(n.review_binding,"review_binding")]),Object.prototype.hasOwnProperty.call(n,"launch")&&t.push(["launch_config_json",E(n.launch,"launch")]),t.length===0){const d=f(e);if(d===null)throw new Error(`unknown node: ${e}`);return d}if(s().prepare(`UPDATE nodes SET ${t.map(([d])=>`${d} = ?`).join(", ")} WHERE node_id = ?`).run(...t.map(([,d])=>d),e).changes!==1)throw new Error(`unknown node: ${e}`);return f(e)}o(Ne,"updateNode");function ge(e,n){s().prepare("UPDATE nodes SET status = ? WHERE node_id = ?").run(n,e)}o(ge,"setStatus");function Se(e,n){s().prepare("UPDATE nodes SET intent = ? WHERE node_id = ?").run(n??null,e)}o(Se,"setIntent");function ye(e,n,t={}){if(t.outcome===void 0){const i=[],d=[];Object.prototype.hasOwnProperty.call(n,"status")&&(i.push("status = ?"),d.push(n.status??null)),Object.prototype.hasOwnProperty.call(n,"intent")&&(i.push("intent = ?"),d.push(n.intent??null)),Object.prototype.hasOwnProperty.call(n,"terminal_reason")&&(i.push("terminal_reason = ?"),d.push(n.terminal_reason??null));const a=["node_id = ?"];d.push(e),t.fromStatuses!==void 0&&(a.push(`status IN (${t.fromStatuses.map(()=>"?").join(", ")})`),d.push(...t.fromStatuses)),t.requireNoFinalReport===!0&&a.push("final_report IS NULL");const u=s().prepare(`UPDATE nodes SET ${i.join(", ")} WHERE ${a.join(" AND ")}`).run(...d);return Number(u.changes)}const r=t.outcome;return p(i=>{const d=[],a=[];Object.prototype.hasOwnProperty.call(n,"status")&&(d.push("status = ?"),a.push(n.status??null)),Object.prototype.hasOwnProperty.call(n,"intent")&&(d.push("intent = ?"),a.push(n.intent??null)),Object.prototype.hasOwnProperty.call(n,"terminal_reason")&&(d.push("terminal_reason = ?"),a.push(n.terminal_reason??null));const u=o((Z,v)=>r.supersede===!0?"?":`CASE WHEN outcome_at IS NULL THEN ? ELSE ${v} END`,"outcomeValue");d.push(`outcome_kind = ${u(r.kind,"outcome_kind")}`,`outcome_reason = ${u(r.reason,"outcome_reason")}`,`outcome_detail_json = ${u(r.detailJson,"outcome_detail_json")}`,`outcome_revision = ${r.supersede===!0?"outcome_revision + 1":"CASE WHEN outcome_at IS NULL THEN outcome_revision + 1 ELSE outcome_revision END"}`,`outcome_at = ${u(r.at,"outcome_at")}`),a.push(r.kind,r.reason,r.detailJson,r.at);const c=["node_id = ?"];a.push(e),t.fromStatuses!==void 0&&(c.push(`status IN (${t.fromStatuses.map(()=>"?").join(", ")})`),a.push(...t.fromStatuses)),t.requireNoFinalReport===!0&&c.push("final_report IS NULL");const l=i.prepare(`UPDATE nodes SET ${d.join(", ")} WHERE ${c.join(" AND ")}`).run(...a);if(Number(l.changes)===0)return 0;const R=i.prepare("SELECT outcome_at FROM nodes WHERE node_id = ?").get(e);return(r.supersede===!0||R.outcome_at===r.at)&&r.documentJson!==null&&r.documentJson!==void 0&&U(i,{idempotencyKey:`node-outcome:${e}`,label:e,bodyJson:r.documentJson,supersede:r.supersede===!0}),Number(l.changes)})}o(ye,"transitionStatusIntent");function Oe(e){return s().prepare("SELECT final_report FROM nodes WHERE node_id = ?").get(e)?.final_report??null}o(Oe,"getFinalReport");function he(e,n){return s().prepare("UPDATE nodes SET final_report = NULL, finalized_at = NULL WHERE node_id = ? AND final_report = ?").run(e,n).changes>0}o(he,"clearFinalReportIfMatches");function Te(e,n){s().prepare('UPDATE nodes SET tmux_session = ?, "window" = ?, pane = ? WHERE node_id = ?').run(n.tmux_session??null,n.window??null,n.pane??null,e)}o(Te,"setPresence");function De(e,n){s().prepare("UPDATE nodes SET launched_at = ?, frozen_at = NULL, respawn_not_before = NULL WHERE node_id = ?").run(n,e)}o(De,"recordLaunch");function Le(e,n){s().prepare("UPDATE nodes SET last_settled_at = ? WHERE node_id = ?").run(n,e)}o(Le,"recordSettledTurn");function Ae(e,n){s().prepare("UPDATE nodes SET frozen_at = ? WHERE node_id = ?").run(n,e)}o(Ae,"setFrozen");function be(e){s().prepare("UPDATE nodes SET frozen_at = NULL WHERE node_id = ?").run(e)}o(be,"clearFrozen");function ve(e,n){s().prepare("UPDATE nodes SET respawn_failures = ?, respawn_not_before = ? WHERE node_id = ?").run(n.failures,n.notBefore,e)}o(ve,"recordRespawnAttempt");const m="node_id NOT IN (SELECT node_id FROM warm_pool)";function xe(e){return s().prepare("SELECT node_id FROM nodes WHERE profile_id = ? ORDER BY created").all(e).map(({node_id:t})=>{const r=f(t);if(r===null)throw new Error(`profile deletion cannot hydrate indexed node ${t}`);return r})}o(xe,"listNodesByProfile");function We(){return s().prepare("SELECT node_id, cwd, profile_id FROM nodes ORDER BY created").all().map(e=>{const n=e;return{nodeId:n.node_id,cwd:n.cwd,profileId:n.profile_id}})}o(We,"listNodeMemoryTargets");function K(e){const n=[m],t=[];if(e?.status!==void 0){const i=Array.isArray(e.status)?e.status:[e.status];n.push(`status IN (${i.map(()=>"?").join(",")})`),t.push(...i)}return e?.withRecordedPid===!0&&n.push("pi_pid IS NOT NULL"),e?.withRecordedPidOrFrozen===!0&&n.push("(pi_pid IS NOT NULL OR frozen_at IS NOT NULL)"),s().prepare(`SELECT * FROM node_rows WHERE ${n.join(" AND ")} ORDER BY created`).all(...t).map(_)}o(K,"listNodes");function ke(){return s().prepare(`SELECT node_id, name, created FROM nodes WHERE ${m} ORDER BY created`).all()}o(ke,"listNodeIdentities");function He(e,n){p(t=>{t.prepare("INSERT OR REPLACE INTO warm_pool (node_id, recipe_key, created) VALUES (?, ?, ?)").run(e,n,new Date().toISOString())})}o(He,"registerWarmSpare");function Fe(e){return p(n=>n.prepare("DELETE FROM warm_pool WHERE node_id = ?").run(e).changes>0)}o(Fe,"unregisterWarmSpare");function y(e,n){const t=`SELECT w.node_id AS node_id, w.recipe_key AS recipe_key, w.created AS created,
             n.status AS status, n.pi_pid AS pi_pid, n.pi_pid_identity AS pi_pid_identity
-       FROM warm_pool w JOIN node_rows n ON n.node_id = w.node_id` +
-        (recipeKey === undefined ? '' : ' WHERE w.recipe_key = ?') +
-        ' ORDER BY w.created';
-    const rows = (recipeKey === undefined ? db.prepare(sql).all() : db.prepare(sql).all(recipeKey));
-    return rows.map((r) => ({
-        node_id: r['node_id'],
-        recipe_key: r['recipe_key'],
-        created: r['created'],
-        status: r['status'],
-        pi_pid: r['pi_pid'] ?? null,
-        pi_pid_identity: r['pi_pid_identity'] ?? null,
-    }));
-}
-/** Every parked spare, oldest first — what the reaper (`runtime/warm-pool.ts`
- *  `reapStaleSpares`) sweeps. Deliberately NOT filtered by liveness: judging a
- *  spare is the caller's job. */
-export function listWarmSpares() {
-    return warmSpareRowsFor(openDb());
-}
-/** True while `nodeId` is an UNCLAIMED spare — nobody owns this conversation
- *  yet. `registerWarmSpare` runs the instant the row exists and BEFORE the
- *  broker launch, and a claim deletes the marker atomically, so this is a
- *  reliable read from inside the booting engine (the context-intro extension
- *  asks it at `session_start` to withhold bearings that would otherwise assert
- *  the spare's placeholder persona instead of its eventual claimant's). */
-export function isWarmSpare(nodeId) {
-    const row = openDb().prepare('SELECT 1 FROM warm_pool WHERE node_id = ?').get(nodeId);
-    return row !== undefined;
-}
-/** A spare is claimable only when its broker is CONFIRMED alive. Status alone
- *  is not enough: a broker torn down by a daemon handover leaves the row at
- *  `active`/`idle` with a dead pid, and handing that out would answer a create
- *  with a node that has no engine behind it. The probe is identity-aware, so a
- *  recycled pid never reads as alive; `indeterminate` (probe failed) is treated
- *  as not-claimable — a cold spawn is cheap, a broken node is not. */
-function spareIsClaimable(row) {
-    if (row.status !== 'active' && row.status !== 'idle')
-        return false;
-    return recordedPidLiveness(row.pi_pid, row.pi_pid_identity) === 'alive';
-}
-/** Hand out the oldest CLAIMABLE spare matching `recipeKey`, or null when the
- *  pool has none. The select+delete run inside ONE canvas write-lock
- *  transaction, so two concurrent creates can never be handed the same spare.
- *  A spare whose broker is gone is skipped here and reaped by
- *  `reapStaleSpares` — nothing ever resumes a spare (the daemon's row query
- *  hides them), so a dead spare is garbage, not a parked one.
- *
- *  The claim also restamps the row's `created` to `created` — birth time is a
- *  spare's MINT time, and consumers sort conversations on it, so an hour-old
- *  spare must not sort as an hour-old conversation. This is the one sanctioned
- *  write of `created` after birth. */
-export function claimWarmSpare(recipeKey, created, opts = {}) {
-    return withCanvasWrite((db) => {
-        const row = warmSpareRowsFor(db, recipeKey).find(spareIsClaimable);
-        if (row === undefined)
-            return null;
-        const res = db.prepare('DELETE FROM warm_pool WHERE node_id = ?').run(row.node_id);
-        if (res.changes === 0)
-            return null;
-        db.prepare('UPDATE nodes SET created = ?, deadline_at = ? WHERE node_id = ?')
-            .run(created, opts.deadlineAt ?? null, row.node_id);
-        if (opts.outcomeDelivery !== undefined)
-            insertArmedOutcomeDelivery(db, row.node_id, opts.outcomeDelivery);
-        return row.node_id;
-    });
-}
-/** How many CLAIMABLE spares are parked for `recipeKey` (the depth check a
- *  refill reads before minting). Uses the same liveness test as the claim, so a
- *  spare the claim would skip can never hold the pool at depth 1 and starve
- *  every later create of a warm start. */
-export function warmSpareCount(recipeKey) {
-    return warmSpareRowsFor(openDb(), recipeKey).filter(spareIsClaimable).length;
-}
-/** Direct children of `id`, oldest first — an indexed point query
- *  (`idx_nodes_parent`) instead of a full-table `listNodes()` scan. */
-export function childrenOf(id) {
-    return openDb()
-        .prepare('SELECT node_id FROM nodes WHERE parent = ? ORDER BY created')
-        .all(id).map((r) => r.node_id);
-}
-/** Every node's lean roster row, oldest first — a single scan indexed by
- *  `idx_nodes_created`, with no per-row hydration or N+1 query. */
-export function rosterNodes() {
-    return openDb()
-        .prepare(`SELECT node_id, name, kind, mode, lifecycle, status, cwd, host_kind, parent, created
-         FROM nodes WHERE ${NOT_A_SPARE} ORDER BY created`)
-        .all().map((r) => ({
-        node_id: r['node_id'],
-        name: r['name'],
-        kind: r['kind'],
-        mode: r['mode'],
-        lifecycle: r['lifecycle'],
-        status: r['status'],
-        cwd: r['cwd'],
-        host_kind: r['host_kind'] ?? null,
-        parent: r['parent'] ?? null,
-        created: r['created'],
-    }));
-}
-/** Every `subscribes_to` edge (passive + multiple preserved, never collapsed) —
- *  a single scan indexed by `idx_edges_from`/`idx_edges_to` (composite
- *  `(type, from_id|to_id)`, so a bare `type` predicate still uses one of
- *  them). Paired with `rosterNodes()` as the roster's exactly-two-query
- *  contract. */
-export function rosterEdges() {
-    return openDb()
-        .prepare(`SELECT from_id, to_id, active, created FROM edges WHERE type = 'subscribes_to' ORDER BY created`)
-        .all().map((r) => ({
-        from_id: r['from_id'],
-        to_id: r['to_id'],
-        active: r['active'] === 1,
-        created: r['created'],
-    }));
-}
-/** Resumable ROOT conversations pinned to `cwd`, most-recently-created first.
- *  A "root" is the top of a spine (`parent IS NULL`) that is a real
- *  conversation (not a `kind:'human'` ask) and still resumable (`active`/`idle`,
- *  never a `done`/`dead`/`canceled` node). This backs the front-door
- *  `crtr -c`/`-r` resume: cwd is the key (the Claude-Code mental model — "my
- *  last session HERE"), so it never teleports across projects. */
-export function listResumableRoots(cwd) {
-    const rows = openDb()
-        .prepare(`SELECT * FROM node_rows
+       FROM warm_pool w JOIN node_rows n ON n.node_id = w.node_id`+(n===void 0?"":" WHERE w.recipe_key = ?")+" ORDER BY w.created";return(n===void 0?e.prepare(t).all():e.prepare(t).all(n)).map(i=>({node_id:i.node_id,recipe_key:i.recipe_key,created:i.created,status:i.status,pi_pid:i.pi_pid??null,pi_pid_identity:i.pi_pid_identity??null}))}o(y,"warmSpareRowsFor");function Me(){return y(s())}o(Me,"listWarmSpares");function Ue(e){return s().prepare("SELECT 1 FROM warm_pool WHERE node_id = ?").get(e)!==void 0}o(Ue,"isWarmSpare");function T(e){return e.status!=="active"&&e.status!=="idle"?!1:J(e.pi_pid,e.pi_pid_identity)==="alive"}o(T,"spareIsClaimable");function je(e,n,t={}){return p(r=>{const i=y(r,e).find(T);return i===void 0||r.prepare("DELETE FROM warm_pool WHERE node_id = ?").run(i.node_id).changes===0?null:(r.prepare("UPDATE nodes SET created = ?, deadline_at = ? WHERE node_id = ?").run(n,t.deadlineAt??null,i.node_id),t.outcomeDelivery!==void 0&&h(r,i.node_id,t.outcomeDelivery),i.node_id)})}o(je,"claimWarmSpare");function Ie(e){return y(s(),e).filter(T).length}o(Ie,"warmSpareCount");function Pe(e){return s().prepare("SELECT node_id FROM nodes WHERE parent = ? ORDER BY created").all(e).map(n=>n.node_id)}o(Pe,"childrenOf");function Ce(){return s().prepare(`SELECT node_id, name, kind, mode, lifecycle, status, cwd, host_kind, parent, created
+         FROM nodes WHERE ${m} ORDER BY created`).all().map(e=>({node_id:e.node_id,name:e.name,kind:e.kind,mode:e.mode,lifecycle:e.lifecycle,status:e.status,cwd:e.cwd,host_kind:e.host_kind??null,parent:e.parent??null,created:e.created}))}o(Ce,"rosterNodes");function $e(){return s().prepare("SELECT from_id, to_id, active, created FROM edges WHERE type = 'subscribes_to' ORDER BY created").all().map(e=>({from_id:e.from_id,to_id:e.to_id,active:e.active===1,created:e.created}))}o($e,"rosterEdges");function Be(e){return s().prepare(`SELECT * FROM node_rows
         WHERE parent IS NULL AND kind != 'human'
           AND status IN ('active','idle') AND cwd = ?
-          AND ${NOT_A_SPARE}
-        ORDER BY created DESC`)
-        .all(cwd);
-    return rows.map(rowFrom);
-}
-// Edges
-function addEdge(type, from, to, active) {
-    openDb()
-        .prepare(`INSERT INTO edges (type, from_id, to_id, active, created)
+          AND ${m}
+        ORDER BY created DESC`).all(e).map(_)}o(Be,"listResumableRoots");function D(e,n,t,r){s().prepare(`INSERT INTO edges (type, from_id, to_id, active, created)
        VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT(type, from_id, to_id) DO UPDATE SET active=excluded.active`)
-        .run(type, from, to, active ? 1 : 0, new Date().toISOString());
-}
-/** Record `A subscribes_to B` — A receives B's output. active=true wakes A on
- *  emit; passive accumulates pointers without a wake. Mutable; callable by anyone. */
-export function subscribe(subscriber, publisher, active = true) {
-    addEdge('subscribes_to', subscriber, publisher, active);
-}
-/** Drop a subscription edge. */
-export function unsubscribe(subscriber, publisher) {
-    openDb()
-        .prepare('DELETE FROM edges WHERE type = ? AND from_id = ? AND to_id = ?')
-        .run('subscribes_to', subscriber, publisher);
-}
-/** Flip an existing subscription's wake behavior. */
-export function setSubscriptionActive(subscriber, publisher, active) {
-    openDb()
-        .prepare('UPDATE edges SET active = ? WHERE type = ? AND from_id = ? AND to_id = ?')
-        .run(active ? 1 : 0, 'subscribes_to', subscriber, publisher);
-}
-/** Record the audit-only `child spawned_by parent` edge. */
-export function recordSpawn(child, parent) {
-    addEdge('spawned_by', child, parent, true);
-}
-/** Who subscribes to `publisher` — the targets a push fans out to. */
-export function subscribersOf(publisher) {
-    return openDb()
-        .prepare(`SELECT from_id AS node_id, active, created FROM edges
-         WHERE type = 'subscribes_to' AND to_id = ? ORDER BY created`)
-        .all(publisher).map((r) => ({
-        node_id: r['node_id'],
-        active: r['active'] === 1,
-        created: r['created'],
-    }));
-}
-/** Who `subscriber` subscribes to — its reports / the nodes feeding it. */
-export function subscriptionsOf(subscriber) {
-    return openDb()
-        .prepare(`SELECT to_id AS node_id, active, created FROM edges
-         WHERE type = 'subscribes_to' AND from_id = ? ORDER BY created`)
-        .all(subscriber).map((r) => ({
-        node_id: r['node_id'],
-        active: r['active'] === 1,
-        created: r['created'],
-    }));
-}
-// Graph queries
-/** A "view": every node whose output cascades up to `root` via subscriptions —
- *  the subscription sub-DAG reachable downward (root → its reports → theirs …).
- *  Returns ids excluding root, in BFS order. Cycle-safe. */
-export function view(root) {
-    const seen = new Set([root]);
-    const out = [];
-    const queue = subscriptionsOf(root).map((s) => s.node_id);
-    while (queue.length > 0) {
-        const id = queue.shift();
-        if (seen.has(id))
-            continue;
-        seen.add(id);
-        out.push(id);
-        for (const s of subscriptionsOf(id)) {
-            if (!seen.has(s.node_id))
-                queue.push(s.node_id);
-        }
-    }
-    return out;
-}
-/** Stop-guard primitive: does this node hold an *active* subscription to a node
- *  that's still live (active|idle) — i.e. something that can actually wake it?
- *  If so, stopping is a legitimate await; if not, it must finish or escalate. */
-export function hasActiveLiveSubscription(nodeId) {
-    const r = openDb()
-        .prepare(`SELECT 1 FROM edges e JOIN nodes n ON n.node_id = e.to_id
+       ON CONFLICT(type, from_id, to_id) DO UPDATE SET active=excluded.active`).run(e,n,t,r?1:0,new Date().toISOString())}o(D,"addEdge");function ze(e,n,t=!0){D("subscribes_to",e,n,t)}o(ze,"subscribe");function Je(e,n){s().prepare("DELETE FROM edges WHERE type = ? AND from_id = ? AND to_id = ?").run("subscribes_to",e,n)}o(Je,"unsubscribe");function Ye(e,n,t){s().prepare("UPDATE edges SET active = ? WHERE type = ? AND from_id = ? AND to_id = ?").run(t?1:0,"subscribes_to",e,n)}o(Ye,"setSubscriptionActive");function qe(e,n){D("spawned_by",e,n,!0)}o(qe,"recordSpawn");function Ve(e){return s().prepare(`SELECT from_id AS node_id, active, created FROM edges
+         WHERE type = 'subscribes_to' AND to_id = ? ORDER BY created`).all(e).map(n=>({node_id:n.node_id,active:n.active===1,created:n.created}))}o(Ve,"subscribersOf");function L(e){return s().prepare(`SELECT to_id AS node_id, active, created FROM edges
+         WHERE type = 'subscribes_to' AND from_id = ? ORDER BY created`).all(e).map(n=>({node_id:n.node_id,active:n.active===1,created:n.created}))}o(L,"subscriptionsOf");function Ge(e){const n=new Set([e]),t=[],r=L(e).map(i=>i.node_id);for(;r.length>0;){const i=r.shift();if(!n.has(i)){n.add(i),t.push(i);for(const d of L(i))n.has(d.node_id)||r.push(d.node_id)}}return t}o(Ge,"view");function Qe(e){return s().prepare(`SELECT 1 FROM edges e JOIN nodes n ON n.node_id = e.to_id
        WHERE e.type = 'subscribes_to' AND e.from_id = ? AND e.active = 1
-         AND n.status IN ('active', 'idle') LIMIT 1`)
-        .get(nodeId);
-    return r !== undefined;
-}
-/** Whether a LIVE node still subscribes to this one. The mirror of
- * `hasActiveLiveSubscription`: that asks what can still wake this node, this
- * asks what this node still owes — a subscriber that is itself active or idle
- * is waiting on a report this node has not delivered. */
-export function hasLiveSubscriber(nodeId) {
-    const r = openDb()
-        .prepare(`SELECT 1 FROM edges e JOIN nodes n ON n.node_id = e.from_id
+         AND n.status IN ('active', 'idle') LIMIT 1`).get(e)!==void 0}o(Qe,"hasActiveLiveSubscription");function Ke(e){return s().prepare(`SELECT 1 FROM edges e JOIN nodes n ON n.node_id = e.from_id
        WHERE e.type = 'subscribes_to' AND e.to_id = ? AND e.active = 1
-         AND n.status IN ('active', 'idle') LIMIT 1`)
-        .get(nodeId);
-    return r !== undefined;
-}
-/** Whether a node explicitly awaits a controller that can still deliver. A
- * parent relationship never implies this wait; the node must declare it. */
-export function hasLiveMessageWait(nodeId) {
-    const controller = getNode(nodeId)?.waiting_for;
-    if (controller == null)
-        return false;
-    const target = getNode(controller);
-    return target !== null && (target.status === 'active' || target.status === 'idle');
-}
-/** Settle an explicit message wait before appending the qualifying delivery.
- * This ordering makes the delivery's one wake observe cleared durable state. */
-export function setMessageWait(nodeId, controller) {
-    openDb().prepare('UPDATE nodes SET waiting_for = ?, waiting_for_generation = waiting_for_generation + 1 WHERE node_id = ?').run(controller, nodeId);
-}
-/** Append a qualifying delivery and settle its matching wait while holding the
- * canvas write lock. A concurrent `node wait controller` runs before or after this whole
- * boundary, never between the durable inbox append and its compare-and-clear. */
-export function deliverAndSettleMessageWait(nodeId, from, deliver) {
-    return withCanvasWrite((db) => {
-        const armed = db.prepare('SELECT waiting_for_generation FROM nodes WHERE node_id = ? AND waiting_for = ?').get(nodeId, from);
-        const result = deliver();
-        if (from !== null && armed !== undefined) {
-            db.prepare('UPDATE nodes SET waiting_for = NULL WHERE node_id = ? AND waiting_for = ? AND waiting_for_generation = ?').run(nodeId, from, armed.waiting_for_generation);
-        }
-        return result;
-    });
-}
-/** Write one controller-death notice and settle only the still-current dead
- * wait. The check, notice append, and clear share one canvas write boundary. */
-export function settleDeadMessageWait(nodeId, controller, deliver) {
-    return withCanvasWrite((db) => {
-        const row = db.prepare(`SELECT waiter.waiting_for, waiter.waiting_for_generation, target.status AS controller_status
+         AND n.status IN ('active', 'idle') LIMIT 1`).get(e)!==void 0}o(Ke,"hasLiveSubscriber");function Xe(e){const n=f(e)?.waiting_for;if(n==null)return!1;const t=f(n);return t!==null&&(t.status==="active"||t.status==="idle")}o(Xe,"hasLiveMessageWait");function Ze(e,n){s().prepare("UPDATE nodes SET waiting_for = ?, waiting_for_generation = waiting_for_generation + 1 WHERE node_id = ?").run(n,e)}o(Ze,"setMessageWait");function en(e,n,t){return p(r=>{const i=r.prepare("SELECT waiting_for_generation FROM nodes WHERE node_id = ? AND waiting_for = ?").get(e,n),d=t();return n!==null&&i!==void 0&&r.prepare("UPDATE nodes SET waiting_for = NULL WHERE node_id = ? AND waiting_for = ? AND waiting_for_generation = ?").run(e,n,i.waiting_for_generation),d})}o(en,"deliverAndSettleMessageWait");function nn(e,n,t){return p(r=>{const i=r.prepare(`SELECT waiter.waiting_for, waiter.waiting_for_generation, target.status AS controller_status
        FROM nodes AS waiter LEFT JOIN nodes AS target ON target.node_id = waiter.waiting_for
-       WHERE waiter.node_id = ?`).get(nodeId);
-        const live = row?.controller_status === 'active' || row?.controller_status === 'idle';
-        if (row?.waiting_for !== controller || live)
-            return null;
-        const result = deliver();
-        db.prepare('UPDATE nodes SET waiting_for = NULL WHERE node_id = ? AND waiting_for = ? AND waiting_for_generation = ?').run(nodeId, controller, row.waiting_for_generation);
-        return result;
-    });
-}
-/** Close the TOCTOU between checking a target has a natural cycle ahead
- *  of it and the write that depends on that (for example, a deferred inbox
- *  append). Fresh-reads `nodeId`'s
- *  (status, final_report, frozen_at) and either runs `body` (a write) or short-circuits
- *  with a `'terminal'`/`'missing'` outcome — the read and `body`'s write share
- *  ONE canvas write-lock boundary (`withCanvasWrite`'s `BEGIN IMMEDIATE`), so
- *  a concurrent finish/cancel/finalization/deletion either commits entirely
- *  before this reads (observed here, `body` never runs) or entirely after
- *  (`body` completes uncontested) — never in the gap a separate check-then-
- *  write left open. Pass the shared `hasNoNaturalCycle` predicate rather than
- *  a bespoke one so the two never drift.
- *
- *  A dangling `nodeId` — the row deleted after the
- *  caller's own selection but before this guard's fresh read — MUST NEVER run
- *  `body`. Reporting `'missing'` distinctly from `'terminal'` (rather than
- *  folding it into either the terminal branch or a fabricated "safe" empty
- *  snapshot) keeps the two failure shapes from being conflated: a terminal
- *  target has a real `status`/`final_report` to report and its own
- *  `deferred_no_natural_cycle`-style rejection, while a missing target has
- *  nothing to report and belongs to the caller's own not-found contract. */
-export function withFreshTerminalGuard(nodeId, isTerminal, body) {
-    return withCanvasWrite((db) => {
-        const row = db
-            .prepare('SELECT status, final_report, frozen_at FROM nodes WHERE node_id = ?')
-            .get(nodeId);
-        if (row === undefined) {
-            return { kind: 'missing' };
-        }
-        if (isTerminal(row)) {
-            return { kind: 'terminal', status: row.status, final_report: row.final_report };
-        }
-        return { kind: 'ran', result: body() };
-    });
-}
-/** True when this node's identity is still required to own a managed checkout.
- *
- *  Ownership outlives the OPEN state. A closed record whose cleanup is still
- *  pending names a checkout and a branch that are physically still there, and
- *  this node record is the only proof of who they belong to — deleting it turns
- *  a retained residual into an ownerless orphan the daemon sweep can never
- *  safely reclaim, because it must never guess at a worktree it cannot prove it
- *  created. So prune may take this node only once cleanup is COMPLETE. A
- *  historical closed record written before the cleanup field existed carries no
- *  such proof and counts as incomplete.
- *
- *  An abandoned record is deliberately NOT protected: abandon already removed
- *  the checkout and retains its branch for a person on purpose, so there is no
- *  residual for the sweep to own. */
-function hasUnreconciledManagedWorktree(nodeId) {
-    return hasUnreconciledWorktree(nodeId);
-}
-/** Whether a row may be removed by an automatic collection sweep. */
-export function isCollectible(row, opts = {}) {
-    if (!['done', 'dead', 'canceled'].includes(row.status)
-        || row.pi_pid !== null
-        || row.frozen_at !== null
-        || hasUnreconciledManagedWorktree(row.node_id)
-        || row.node_id === envNodeId())
-        return false;
-    return opts.pastTtl === true || !['crashed', 'stranded', null].includes(row.terminal_reason ?? null);
-}
-/** Hard-delete ONE node: drop its row (the edges→nodes FK, ON DELETE CASCADE,
- *  GCs its edges) and remove its on-disk `nodes/<id>/` dir. The single-node
- *  analogue of {@link pruneNodes}, for IMMEDIATE reaping — e.g. an empty node the
- *  user closed or detached from. An open managed worktree is never deleted: its
- *  node retains the ownership needed for `node worktree close`. Pure persisted-state
- *  removal: the caller MUST have already torn down the broker engine +
- *  viewer (this does not signal any process). The node row and its FK-coupled
- *  state are removed in one canvas write boundary. Best-effort dir removal
- *  follows the commit. */
-export function deleteNode(nodeId) {
-    if (hasUnreconciledManagedWorktree(nodeId))
-        return { deleted: false };
-    const result = withCanvasWrite((db) => {
-        db.prepare('DELETE FROM nodes WHERE node_id = ?').run(nodeId);
-        return { deleted: true };
-    });
-    rmSync(nodeDir(nodeId), { recursive: true, force: true });
-    return result;
-}
-/** Hard-delete a validated set of nodes in one row transaction, then remove
- *  their directories. The caller must tear down engines and viewers first. */
-export function deleteNodes(nodeIds) {
-    const ids = [...new Set(nodeIds)];
-    if (ids.length === 0)
-        return [];
-    const blocked = ids.filter(hasUnreconciledManagedWorktree);
-    if (blocked.length > 0) {
-        throw new Error(`refusing to delete nodes with unreconciled managed worktrees: ${blocked.join(', ')}`);
-    }
-    const placeholders = ids.map(() => '?').join(',');
-    const deleted = withCanvasWrite((db) => {
-        const existing = db
-            .prepare(`SELECT node_id FROM nodes WHERE node_id IN (${placeholders}) ORDER BY created`)
-            .all(...ids).map(({ node_id }) => node_id);
-        db.prepare(`DELETE FROM nodes WHERE node_id IN (${placeholders})`).run(...ids);
-        return existing;
-    });
-    for (const id of deleted)
-        rmSync(nodeDir(id), { recursive: true, force: true });
-    return deleted;
-}
-/** Retention sweep: remove TERMINAL nodes (status dead | done | canceled) whose
- *  `created` is older than `ttlDays`, bounding the otherwise-unbounded growth of
- *  node rows + dirs. Open managed-worktree nodes are retained so their checkout
- *  remains owned until `node worktree close`. The edges→nodes FK (`ON DELETE
- *  CASCADE`, migration v4) GCs each pruned node's edges automatically; the
- *  on-disk `nodes/<id>/` dir is removed too.
- *
- *  With `includeStale`, ALSO prunes nominally-live (active | idle) nodes past the
- *  TTL whose process is provably gone — `pi_pid` is NULL or no longer alive. This
- *  reaps stale roots (a bare `crtr` whose pi died without the row transitioning),
- *  which the daemon's supervision never reconciled. A genuinely-running node keeps
- *  a live `pi_pid`, so it is protected, as is the CALLER ($CRTR_NODE_ID). Without
- *  the flag, active | idle are NEVER touched (the daemon's domain).
- *
- *  Row deletes run in ONE transaction, so the sweep is all-or-nothing. Dir
- *  removals follow after COMMIT — the fs isn't transactional, and by then
- *  the rows are gone, so a re-run never re-finds a half-deleted node. `dryRun`
- *  reports the candidate set and deletes NOTHING. */
-export function pruneNodes(opts) {
-    const dryRun = opts.dryRun ?? false;
-    const includeStale = opts.includeStale ?? false;
-    const cutoff = new Date(Date.now() - opts.ttlDays * 86_400_000).toISOString();
-    const selfId = envNodeId() ?? '';
-    const db = openDb();
-    const terminal = db
-        .prepare(`SELECT * FROM node_rows
+       WHERE waiter.node_id = ?`).get(e),d=i?.controller_status==="active"||i?.controller_status==="idle";if(i?.waiting_for!==n||d)return null;const a=t();return r.prepare("UPDATE nodes SET waiting_for = NULL WHERE node_id = ? AND waiting_for = ? AND waiting_for_generation = ?").run(e,n,i.waiting_for_generation),a})}o(nn,"settleDeadMessageWait");function tn(e,n,t){return p(r=>{const i=r.prepare("SELECT status, final_report, frozen_at FROM nodes WHERE node_id = ?").get(e);return i===void 0?{kind:"missing"}:n(i)?{kind:"terminal",status:i.status,final_report:i.final_report}:{kind:"ran",result:t()}})}o(tn,"withFreshTerminalGuard");function w(e){return $(e)}o(w,"hasUnreconciledManagedWorktree");function A(e,n={}){return!["done","dead","canceled"].includes(e.status)||e.pi_pid!==null||e.frozen_at!==null||w(e.node_id)||e.node_id===O()?!1:n.pastTtl===!0||!["crashed","stranded",null].includes(e.terminal_reason??null)}o(A,"isCollectible");function rn(e){if(w(e))return{deleted:!1};const n=p(t=>(t.prepare("DELETE FROM nodes WHERE node_id = ?").run(e),{deleted:!0}));return N(S(e),{recursive:!0,force:!0}),n}o(rn,"deleteNode");function on(e){const n=[...new Set(e)];if(n.length===0)return[];const t=n.filter(w);if(t.length>0)throw new Error(`refusing to delete nodes with unreconciled managed worktrees: ${t.join(", ")}`);const r=n.map(()=>"?").join(","),i=p(d=>{const a=d.prepare(`SELECT node_id FROM nodes WHERE node_id IN (${r}) ORDER BY created`).all(...n).map(({node_id:u})=>u);return d.prepare(`DELETE FROM nodes WHERE node_id IN (${r})`).run(...n),a});for(const d of i)N(S(d),{recursive:!0,force:!0});return i}o(on,"deleteNodes");function dn(e){const n=e.dryRun??!1,t=e.includeStale??!1,r=new Date(Date.now()-e.ttlDays*864e5).toISOString(),i=O()??"",d=s(),a=d.prepare(`SELECT * FROM node_rows
        WHERE status IN ('dead', 'done', 'canceled') AND created < ?
-       ORDER BY created`)
-        .all(cutoff)
-        .map(rowFrom)
-        .filter((row) => isCollectible(row, { pastTtl: true }))
-        .map((row) => ({ node_id: row.node_id, status: row.status, created: row.created }));
-    // Stale non-terminal sweep (opt-in): active | idle past the TTL whose process
-    // is provably gone (pi_pid NULL or not alive). Never the caller itself.
-    const stale = !includeStale ? [] : db
-        .prepare(`SELECT node_id, status, created, pi_pid FROM node_rows
+       ORDER BY created`).all(r).map(_).filter(l=>A(l,{pastTtl:!0})).map(l=>({node_id:l.node_id,status:l.status,created:l.created})),u=t?d.prepare(`SELECT node_id, status, created, pi_pid FROM node_rows
          WHERE status IN ('active', 'idle') AND created < ?
-         ORDER BY created`)
-        .all(cutoff)
-        .filter((r) => {
-        if (r['node_id'] === selfId)
-            return false;
-        const pid = r['pi_pid'];
-        return !isPidAlive(pid);
-    })
-        .map((r) => ({
-        node_id: r['node_id'],
-        status: r['status'],
-        created: r['created'],
-    }))
-        .filter((node) => !hasUnreconciledManagedWorktree(node.node_id));
-    const candidates = [...terminal, ...stale];
-    if (dryRun || candidates.length === 0)
-        return { pruned: candidates, dryRun };
-    deletePrunedNodes(candidates);
-    return { pruned: candidates, dryRun };
-}
-/** Hard-delete a set of pruned nodes in one transaction (the edges→nodes and
- *  anchored-crons FKs cascade their coupled state), followed by best-effort
- *  on-disk `nodes/<id>/` removal. Shared by TTL and count pruning so their
- *  delete semantics never drift. */
-function deletePrunedNodes(candidates) {
-    if (candidates.length === 0)
-        return;
-    withCanvasWrite((db) => {
-        const del = db.prepare('DELETE FROM nodes WHERE node_id = ?');
-        for (const c of candidates)
-            del.run(c.node_id);
-    });
-    for (const c of candidates) {
-        rmSync(nodeDir(c.node_id), { recursive: true, force: true });
-    }
-}
-/** "Most recent activity" sort key (epoch ms) read CHEAPLY: a `statSync` (no file
- *  read, no parse) of the node's `job/telemetry.json` — rewritten on every
- *  turn_end at a deterministic path, so it tracks last-message recency without a
- *  meta read. Falls back to `created`'s epoch when a node never ran a turn.
- *  Mirrors render.ts's `sessionMtime` (the same key the snapshot roster surfaces
- *  as `last_activity`). Never throws. */
-function recencyMs(nodeId, created) {
-    try {
-        const st = statSync(join(jobDir(nodeId), 'telemetry.json'), { throwIfNoEntry: false });
-        if (st !== undefined)
-            return st.mtimeMs;
-    }
-    catch {
-        /* fall through to created */
-    }
-    const t = Date.parse(created);
-    return Number.isNaN(t) ? 0 : t;
-}
-/** Count-based retention sweep: retain the `maxNodes` MOST-RECENTLY-ACTIVE
- *  nodes plus every row the collection authority retains, so the real retained
- *  floor is `max(maxNodes, retainedCount)`. Bounds the otherwise-unbounded growth
- *  the TTL sweep can't (a canvas that never crosses the TTL still grows without
- *  limit).
- *
- *  Algorithm: order ALL nodes by recency DESC (telemetry.json mtime, falling back
- *  to `created`); `target = max(maxNodes, retainedCount)`; delete every node
- *  ranked beyond `target` (0-indexed rank >= target) that is collectible.
- *
- *  Mirrors {@link pruneNodes} exactly for the delete (shared `deletePrunedNodes`:
- *  transactioned row sweep + FK edge cascade + best-effort dir removal). `dryRun`
- *  reports the candidate set and deletes NOTHING. */
-export function pruneToLimit(opts) {
-    const dryRun = opts.dryRun ?? false;
-    const rows = listNodes();
-    const ranked = rows
-        .map((row) => ({
-        row,
-        recency: recencyMs(row.node_id, row.created),
-        retained: !isCollectible(row),
-    }))
-        .sort((a, b) => b.recency - a.recency);
-    const retainedCount = ranked.filter((r) => r.retained).length;
-    const target = Math.max(opts.maxNodes, retainedCount);
-    const candidates = ranked
-        .filter((r, rank) => rank >= target && !r.retained)
-        .map(({ row }) => ({ node_id: row.node_id, status: row.status, created: row.created }));
-    if (dryRun || candidates.length === 0)
-        return { pruned: candidates, dryRun };
-    deletePrunedNodes(candidates);
-    return { pruned: candidates, dryRun };
-}
+         ORDER BY created`).all(r).filter(l=>{if(l.node_id===i)return!1;const R=l.pi_pid;return!g(R)}).map(l=>({node_id:l.node_id,status:l.status,created:l.created})).filter(l=>!w(l.node_id)):[],c=[...a,...u];return n||c.length===0?{pruned:c,dryRun:n}:(b(c),{pruned:c,dryRun:n})}o(dn,"pruneNodes");function b(e){if(e.length!==0){p(n=>{const t=n.prepare("DELETE FROM nodes WHERE node_id = ?");for(const r of e)t.run(r.node_id)});for(const n of e)N(S(n.node_id),{recursive:!0,force:!0})}}o(b,"deletePrunedNodes");function X(e,n){try{const r=H(F(V(e),"telemetry.json"),{throwIfNoEntry:!1});if(r!==void 0)return r.mtimeMs}catch{}const t=Date.parse(n);return Number.isNaN(t)?0:t}o(X,"recencyMs");function sn(e){const n=e.dryRun??!1,r=K().map(u=>({row:u,recency:X(u.node_id,u.created),retained:!A(u)})).sort((u,c)=>c.recency-u.recency),i=r.filter(u=>u.retained).length,d=Math.max(e.maxNodes,i),a=r.filter((u,c)=>c>=d&&!u.retained).map(({row:u})=>({node_id:u.node_id,status:u.status,created:u.created}));return n||a.length===0?{pruned:a,dryRun:n}:(b(a),{pruned:a,dryRun:n})}o(sn,"pruneToLimit");export{pe as canonicalSessionFile,Pe as childrenOf,je as claimWarmSpare,he as clearFinalReportIfMatches,be as clearFrozen,ce as createNode,rn as deleteNode,on as deleteNodes,en as deliverAndSettleMessageWait,me as dueNodeDeadlines,_e as findNodeBySessionFile,Oe as getFinalReport,f as getNode,fe as getRow,Ee as getRowByPane,Qe as hasActiveLiveSubscription,Xe as hasLiveMessageWait,Ke as hasLiveSubscriber,A as isCollectible,Ue as isWarmSpare,ke as listNodeIdentities,We as listNodeMemoryTargets,K as listNodes,xe as listNodesByProfile,Be as listResumableRoots,Me as listWarmSpares,dn as pruneNodes,sn as pruneToLimit,De as recordLaunch,ve as recordRespawnAttempt,Le as recordSettledTurn,qe as recordSpawn,He as registerWarmSpare,$e as rosterEdges,Ce as rosterNodes,Ae as setFrozen,Se as setIntent,Ze as setMessageWait,we as setNodeDeadline,Te as setPresence,ge as setStatus,Ye as setSubscriptionActive,nn as settleDeadMessageWait,Re as shiftProfileNodeDeadlines,ze as subscribe,Ve as subscribersOf,L as subscriptionsOf,ye as transitionStatusIntent,Fe as unregisterWarmSpare,Je as unsubscribe,Ne as updateNode,Ge as view,Ie as warmSpareCount,tn as withFreshTerminalGuard};