@north-light/cli 0.3.530 → 0.3.532

package/dist/core/async-array.d.ts

@@ -0,0 +1,7 @@
+export declare function mapAsync<T, U>(items: readonly T[], fn: (item: T, index: number, items: readonly T[]) => Promise<U>): Promise<U[]>;
+export declare function flatMapAsync<T, U>(items: readonly T[], fn: (item: T, index: number, items: readonly T[]) => Promise<U | readonly U[]>): Promise<U[]>;
+export declare function filterAsync<T>(items: readonly T[], fn: (item: T, index: number, items: readonly T[]) => Promise<unknown>): Promise<T[]>;
+export declare function someAsync<T>(items: readonly T[], fn: (item: T, index: number, items: readonly T[]) => Promise<unknown>): Promise<boolean>;
+export declare function everyAsync<T>(items: readonly T[], fn: (item: T, index: number, items: readonly T[]) => Promise<unknown>): Promise<boolean>;
+export declare function findAsync<T>(items: readonly T[], fn: (item: T, index: number, items: readonly T[]) => Promise<unknown>): Promise<T | undefined>;
+export declare function forEachAsync<T>(items: readonly T[], fn: (item: T, index: number, items: readonly T[]) => Promise<unknown>): Promise<void>;

package/dist/core/async-array.js

@@ -0,0 +1 @@
+var e=Object.defineProperty;var a=(n,t)=>e(n,"name",{value:t,configurable:!0});async function u(n,t){const r=[];for(let o=0;o<n.length;o++)r.push(await t(n[o],o,n));return r}a(u,"mapAsync");async function l(n,t){const r=[];for(let o=0;o<n.length;o++){const c=await t(n[o],o,n);Array.isArray(c)?r.push(...c):r.push(c)}return r}a(l,"flatMapAsync");async function y(n,t){const r=[];for(let o=0;o<n.length;o++)await t(n[o],o,n)&&r.push(n[o]);return r}a(y,"filterAsync");async function i(n,t){for(let r=0;r<n.length;r++)if(await t(n[r],r,n))return!0;return!1}a(i,"someAsync");async function p(n,t){for(let r=0;r<n.length;r++)if(!await t(n[r],r,n))return!1;return!0}a(p,"everyAsync");async function h(n,t){for(let r=0;r<n.length;r++)if(await t(n[r],r,n))return n[r]}a(h,"findAsync");async function s(n,t){for(let r=0;r<n.length;r++)await t(n[r],r,n)}a(s,"forEachAsync");export{p as everyAsync,y as filterAsync,h as findAsync,l as flatMapAsync,s as forEachAsync,u as mapAsync,i as someAsync};

package/dist/core/audit.d.ts

@@ -18,6 +18,6 @@ export interface PeerAuditRow {
     resource?: string | null;
 }
 /** Write one audit row. A failure to write is logged by the caller's wrapper and never changes the answer. */
-export declare function writePeerAudit(row: PeerAuditRow): void;
+export declare function writePeerAudit(row: PeerAuditRow): Promise<void>;
 /** The outcome string for an HTTP status. */
 export declare const auditOutcome: (status: number) => string;

package/dist/core/audit.js

@@ -1,3 +1,3 @@
-var n=Object.defineProperty;var i=(e,t)=>n(e,"name",{value:t,configurable:!0});import{prepared as u}from"./sqlite-statements.js";import{withCanvasWrite as r}from"./canvas/db.js";function s(e){r(t=>{u(t,`INSERT INTO audit_rows
+var n=Object.defineProperty;var t=(e,i)=>n(e,"name",{value:i,configurable:!0});import{openDb as u}from"./canvas/db.js";async function r(e){await(await u()).prepare(`INSERT INTO audit_rows
       (request_id, time, grantee, sub, class, operation, outcome, node_id, run_id, resource, via)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(e.request_id,new Date().toISOString(),e.grantee,e.sub,e.class,e.operation,e.outcome,e.node_id??null,e.run_id??null,e.resource??null,e.via)})}i(s,"writePeerAudit");const c=i(e=>e>=200&&e<300?"ok":`status:${e}`,"auditOutcome");export{c as auditOutcome,s as writePeerAudit};
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(e.request_id,new Date().toISOString(),e.grantee,e.sub,e.class,e.operation,e.outcome,e.node_id??null,e.run_id??null,e.resource??null,e.via)}t(r,"writePeerAudit");const d=t(e=>e>=200&&e<300?"ok":`status:${e}`,"auditOutcome");export{d as auditOutcome,r as writePeerAudit};

package/dist/core/canvas/attention.d.ts

@@ -9,10 +9,10 @@ export interface TicketEntry {
 /** Kept for callers that reset a canvas home in process. SQL has no directory-scan cache to invalidate. */
 export declare function invalidateTicketCounts(): void;
 /** Count pending tickets asked by one node. */
-export declare function countTickets(nodeId: string): number;
+export declare function countTickets(nodeId: string): Promise<number>;
 /** Pending tickets for every reachable asking node, including the root. */
-export declare function pendingTicketsForView(rootId: string): TicketEntry[];
+export declare function pendingTicketsForView(rootId: string): Promise<TicketEntry[]>;
 /** Per-node pending ticket counts for an explicit node set. */
-export declare function ticketCountsForNodes(ids: string[]): Record<string, number>;
+export declare function ticketCountsForNodes(ids: string[]): Promise<Record<string, number>>;
 /** Pending tickets across the entire canvas, attributed to asking nodes. */
-export declare function ticketsAcrossCanvas(): TicketEntry[];
+export declare function ticketsAcrossCanvas(): Promise<TicketEntry[]>;

package/dist/core/canvas/attention.js

@@ -1 +1 @@
-var u=Object.defineProperty;var s=(t,n)=>u(t,"name",{value:n,configurable:!0});import{listOpenReplyBearingRequests as d}from"../human/requests.js";import{getNode as f,listNodes as l,view as p}from"./canvas.js";function h(){}s(h,"invalidateTicketCounts");function c(){const t=new Map;for(const n of d()){const e=n.requester_node_id,o=t.get(e);o===void 0?t.set(e,[n.title]):o.push(n.title)}return t}s(c,"ticketSubjects");function w(t){return c().get(t)?.length??0}s(w,"countTickets");function k(t){const n=c(),e=[];for(const o of[t,...p(t)]){const i=f(o),r=n.get(o)??[];i!==null&&r.length>0&&e.push({node_id:o,name:i.name,cwd:i.cwd,count:r.length,subjects:r})}return e}s(k,"pendingTicketsForView");function _(t){const n=c();return Object.fromEntries(t.map(e=>[e,n.get(e)?.length??0]))}s(_,"ticketCountsForNodes");function b(){const t=c(),n=[];for(const e of l()){const o=t.get(e.node_id)??[];o.length>0&&n.push({node_id:e.node_id,name:e.name,cwd:e.cwd,count:o.length,subjects:o})}return n}s(b,"ticketsAcrossCanvas");export{w as countTickets,h as invalidateTicketCounts,k as pendingTicketsForView,_ as ticketCountsForNodes,b as ticketsAcrossCanvas};
+var r=Object.defineProperty;var s=(t,n)=>r(t,"name",{value:n,configurable:!0});import{listOpenReplyBearingRequests as u}from"../human/requests.js";import{getNode as d,listNodes as f,view as l}from"./canvas.js";function m(){}s(m,"invalidateTicketCounts");async function i(){const t=new Map;for(const n of await u()){const e=n.requester_node_id,o=t.get(e);o===void 0?t.set(e,[n.title]):o.push(n.title)}return t}s(i,"ticketSubjects");async function h(t){return(await i()).get(t)?.length??0}s(h,"countTickets");async function k(t){const n=await i(),e=[];for(const o of[t,...await l(t)]){const c=await d(o),a=n.get(o)??[];c!==null&&a.length>0&&e.push({node_id:o,name:c.name,cwd:c.cwd,count:a.length,subjects:a})}return e}s(k,"pendingTicketsForView");async function y(t){const n=await i();return Object.fromEntries(t.map(e=>[e,n.get(e)?.length??0]))}s(y,"ticketCountsForNodes");async function _(){const t=await i(),n=[];for(const e of await f()){const o=t.get(e.node_id)??[];o.length>0&&n.push({node_id:e.node_id,name:e.name,cwd:e.cwd,count:o.length,subjects:o})}return n}s(_,"ticketsAcrossCanvas");export{h as countTickets,m as invalidateTicketCounts,k as pendingTicketsForView,y as ticketCountsForNodes,_ as ticketsAcrossCanvas};

package/dist/core/canvas/boot.d.ts

@@ -64,14 +64,14 @@ export interface BootReconcileResult {
  *
  *  `current` defaults to the real identity; tests inject a synthetic one against
  *  an isolated CRTR_HOME to simulate a boot change without a real reboot. */
-export declare function reconcileBootLiveness(current?: BootIdentity): BootReconcileResult;
+export declare function reconcileBootLiveness(current?: BootIdentity): Promise<BootReconcileResult>;
 /** The one-time execution-identity migration, injected into the startup
  *  composition. In production this is `migrateLegacyExecutionIdentities` from
  *  executions.ts. It remains injected so tests can exercise this composition
  *  without reaching process inspection. */
-export type MigrateLegacyExecutionIdentities = (captureIdentity?: (pid: number) => string | undefined) => {
+export type MigrateLegacyExecutionIdentities = (captureIdentity?: (pid: number) => string | undefined) => Promise<{
     migrated: string[];
-};
+}>;
 export interface BootStartupResult {
     /** The pid-liveness reconciliation result (boot-change sweep + provenance). */
     reconcile: BootReconcileResult;
@@ -89,4 +89,4 @@ export interface BootStartupResult {
  *
  *  `migrate` is injected (see `MigrateLegacyPidIdentities`); `current` and
  *  `captureIdentity` pass through to the two steps for test injection. */
-export declare function reconcileAndMigrateBoot(migrate: MigrateLegacyExecutionIdentities, current?: BootIdentity, captureIdentity?: (pid: number) => string | undefined): BootStartupResult;
+export declare function reconcileAndMigrateBoot(migrate: MigrateLegacyExecutionIdentities, current?: BootIdentity, captureIdentity?: (pid: number) => string | undefined): Promise<BootStartupResult>;

package/dist/core/canvas/boot.js

@@ -1 +1 @@
-var E=Object.defineProperty;var n=(e,o)=>E(e,"name",{value:o,configurable:!0});import{prepared as d}from"../sqlite-statements.js";import{uptime as f}from"node:os";import{openDb as p}from"./db.js";import{readKernelBootId as b}from"./boot-id.js";import{readKernelBootId as R}from"./boot-id.js";const I=6e4;function M(e=Date.now()){return{bootId:b(),bootEpochMs:e-Math.round(f()*1e3)}}n(M,"currentBootIdentity");function m(e,o){return o===null?!1:e.bootId!==null&&o.bootId!==null?e.bootId!==o.bootId:Math.abs(e.bootEpochMs-o.bootEpochMs)>I}n(m,"bootChanged");function x(e,o){return o!==null&&e.bootId!==null&&o.bootId!==null&&e.bootId===o.bootId}n(x,"bootProvenSame");const s="boot_identity";function h(e){const o=d(e,"SELECT value FROM canvas_meta WHERE key = ?").get(s);if(o===void 0)return null;try{const t=JSON.parse(o.value);return typeof t.bootEpochMs!="number"?null:{bootId:typeof t.bootId=="string"?t.bootId:null,bootEpochMs:t.bootEpochMs}}catch{return null}}n(h,"readBootMarker");function u(e,o){e.prepare("INSERT INTO canvas_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(s,JSON.stringify(o))}n(u,"writeBootMarker");function O(e=M()){const o=p();o.exec("BEGIN IMMEDIATE");try{const t=h(o);if(!m(e,t)){t===null&&u(o,e);const a=x(e,t);return o.exec("COMMIT"),{changed:!1,cleared:[],sameBootProven:a}}const r=d(o,"SELECT execution_id, node_id FROM executions WHERE state != 'exited'").all(),c=d(o,"UPDATE executions SET state = 'exited', ended_at = ?, exit_reason = 'boot-change' WHERE execution_id = ? AND state != 'exited'"),i=[],l=new Date().toISOString();for(const a of r)c.run(l,a.execution_id).changes>0&&i.push(a.node_id);return u(o,e),o.exec("COMMIT"),{changed:!0,cleared:i,sameBootProven:!1}}catch(t){try{o.exec("ROLLBACK")}catch{}throw t}}n(O,"reconcileBootLiveness");function v(e,o,t){const r=O(o),c=r.sameBootProven?e(t).migrated:[];return{reconcile:r,migrated:c}}n(v,"reconcileAndMigrateBoot");export{m as bootChanged,x as bootProvenSame,M as currentBootIdentity,R as readKernelBootId,v as reconcileAndMigrateBoot,O as reconcileBootLiveness};
+var l=Object.defineProperty;var n=(t,o)=>l(t,"name",{value:o,configurable:!0});import{uptime as p}from"node:os";import{withCanvasWrite as f}from"./db.js";import{readKernelBootId as E}from"./boot-id.js";import{readKernelBootId as S}from"./boot-id.js";const b=6e4;function I(t=Date.now()){return{bootId:E(),bootEpochMs:t-Math.round(p()*1e3)}}n(I,"currentBootIdentity");function h(t,o){return o===null?!1:t.bootId!==null&&o.bootId!==null?t.bootId!==o.bootId:Math.abs(t.bootEpochMs-o.bootEpochMs)>b}n(h,"bootChanged");function m(t,o){return o!==null&&t.bootId!==null&&o.bootId!==null&&t.bootId===o.bootId}n(m,"bootProvenSame");const s="boot_identity";async function x(t){const o=await t.prepare("SELECT value FROM canvas_meta WHERE key = ?").get(s);if(o===void 0)return null;try{const e=JSON.parse(o.value);return typeof e.bootEpochMs!="number"?null:{bootId:typeof e.bootId=="string"?e.bootId:null,bootEpochMs:e.bootEpochMs}}catch{return null}}n(x,"readBootMarker");async function u(t,o){await t.prepareUncached("INSERT INTO canvas_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(s,JSON.stringify(o))}n(u,"writeBootMarker");async function _(t=I()){return f(async o=>{const e=await x(o);if(!h(t,e)){e===null&&await u(o,t);const r=m(t,e);return{changed:!1,cleared:[],sameBootProven:r}}const a=await o.prepare("SELECT execution_id, node_id FROM executions WHERE state != 'exited'").all(),i=o.prepare("UPDATE executions SET state = 'exited', ended_at = ?, exit_reason = 'boot-change' WHERE execution_id = ? AND state != 'exited'"),c=[],d=new Date().toISOString();for(const r of a)(await i.run(d,r.execution_id)).changes>0&&c.push(r.node_id);return await u(o,t),{changed:!0,cleared:c,sameBootProven:!1}})}n(_,"reconcileBootLiveness");async function g(t,o,e){const a=await _(o),i=a.sameBootProven?(await t(e)).migrated:[];return{reconcile:a,migrated:i}}n(g,"reconcileAndMigrateBoot");export{h as bootChanged,m as bootProvenSame,I as currentBootIdentity,S as readKernelBootId,g as reconcileAndMigrateBoot,_ as reconcileBootLiveness};

package/dist/core/canvas/canvas.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseSync } from 'node:sqlite';
+import { type CanvasDb } from './db.js';
 import type { ExitIntent, Lifecycle, Mode, NodeIdentity, NodeMeta, NodeOutcomeKind, NodeRow, NodeStatus, TerminalReason } from './types.js';
 export interface OutcomeDeliveryBinding {
     actionName: string;
@@ -7,65 +7,65 @@ export interface OutcomeDeliveryBinding {
     configOrigin: string;
     payload?: unknown;
 }
-export declare function assertRunNotDeleting(db: DatabaseSync, runId: string): void;
+export declare function assertRunNotDeleting(db: CanvasDb, runId: string): Promise<void>;
 /** Create a SQL-authoritative node, then ensure its artifact directories exist. */
 export declare function createNode(meta: NodeMeta, opts?: {
     outcomeDelivery?: OutcomeDeliveryBinding;
-    withinCreate?: (db: DatabaseSync, row: NodeMeta) => void;
-}): NodeMeta;
+    withinCreate?: (db: CanvasDb, row: NodeMeta) => Promise<void> | void;
+}): Promise<NodeMeta>;
 /** The canonical node record, hydrated from SQL. Null if unknown. */
-export declare function getNode(nodeId: string): NodeMeta | null;
+export declare function getNode(nodeId: string): Promise<NodeMeta | null>;
 export type CreateRequestState = 'reserved' | 'warm_claimed' | 'complete';
 export interface CreateRequestRecord {
     requestKey: string;
     nodeId: string | null;
     state: CreateRequestState;
 }
-export declare function findCreateRequest(requestKey: string): CreateRequestRecord | null;
+export declare function findCreateRequest(requestKey: string): Promise<CreateRequestRecord | null>;
 /** Reserve an idempotency key before creation. A null node id means the request
  *  has not yet selected a cold-birth identity or claimed a warm spare. */
-export declare function reserveCreateRequest(requestKey: string): CreateRequestRecord;
+export declare function reserveCreateRequest(requestKey: string): Promise<CreateRequestRecord>;
 /** Delete keys past their recovery window; returns how many were removed. */
-export declare function pruneExpiredCreateRequests(now?: number): number;
+export declare function pruneExpiredCreateRequests(now?: number): Promise<number>;
 /** Bind a reserved key to the node it created (state `complete`). The mapping is
  *  durable so a retry after a daemon handover returns the original node. */
-export declare function recordCreateRequestNode(requestKey: string, nodeId: string): void;
+export declare function recordCreateRequestNode(requestKey: string, nodeId: string): Promise<void>;
 /** Reserve a cold-birth node id for a key (state stays `reserved`) so a retry
  *  after a daemon restart resumes the same identity instead of minting another. */
-export declare function reserveCreateRequestNode(requestKey: string, nodeId: string): void;
-export declare function completeCreateRequest(requestKey: string, nodeId: string): void;
+export declare function reserveCreateRequestNode(requestKey: string, nodeId: string): Promise<void>;
+export declare function completeCreateRequest(requestKey: string, nodeId: string): Promise<void>;
 /** Forget an unserved reservation after a pre-birth failure. A record that
  *  names a durable node is never removed by this path. */
-export declare function abandonCreateRequest(requestKey: string, nodeId: string | null): void;
+export declare function abandonCreateRequest(requestKey: string, nodeId: string | null): Promise<void>;
 export declare function canonicalSessionFile(sessionFile: string): string;
 /** Resolve the crouter node that owns one exact Pi session file. */
-export declare function findNodeBySessionFile(sessionFile: string): NodeMeta | null;
+export declare function findNodeBySessionFile(sessionFile: string): Promise<NodeMeta | null>;
 /** The indexed row (from the db) — cheap for queries that don't need full meta. */
-export declare function getRow(nodeId: string): NodeRow | null;
+export declare function getRow(nodeId: string): Promise<NodeRow | 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 declare function getRowByPane(pane: string): NodeRow | null;
+export declare function getRowByPane(pane: string): Promise<NodeRow | null>;
 /** Nodes whose persisted spawn deadline has elapsed and that remain live work. */
-export declare function dueNodeDeadlines(nowIso: string): NodeRow[];
+export declare function dueNodeDeadlines(nowIso: string): Promise<NodeRow[]>;
 /** Write a claimed warm spare's deadline before it is handed to its caller. */
-export declare function setNodeDeadline(nodeId: string, deadlineAt: string | null): boolean;
+export declare function setNodeDeadline(nodeId: string, deadlineAt: string | null): Promise<boolean>;
 /** Shift active/idle profile deadlines by a completed profile pause duration. */
-export declare function shiftProfileNodeDeadlines(profileId: string, pauseDurationMs: number): number;
+export declare function shiftProfileNodeDeadlines(profileId: string, pauseDurationMs: number): Promise<number>;
 /** OWN-11 for a joined runtime: a `user:local` subject becomes the owner, a
  *  `user:local` grantee becomes `app:terminal` (no node has the owner as grantee),
  *  a terminal node born before the local grant mirror (no subject) gets the owner,
  *  and a reference to the dropped local grant is cleared so the node resolves the
  *  synced grant by grantee and subject. */
-export declare function rewriteLocalNodeIdentity(db: DatabaseSync, owner: string, localGrantId: string): number;
+export declare function rewriteLocalNodeIdentity(db: CanvasDb, owner: string, localGrantId: string): Promise<number>;
 type NodeUpdate = Partial<Omit<NodeIdentity, 'node_id' | 'pi_session_id' | 'pi_session_file' | 'managed_worktree'>>;
 /** Update node identity/configuration columns. Sessions and worktrees have named stores. */
-export declare function updateNode(nodeId: string, patch: NodeUpdate): NodeMeta;
+export declare function updateNode(nodeId: string, patch: NodeUpdate): Promise<NodeMeta>;
 /** Set a node's status. Atomic single-column write. */
-export declare function setStatus(nodeId: string, status: NodeStatus): void;
+export declare function setStatus(nodeId: string, status: NodeStatus): Promise<void>;
 /** Set a node's exit intent. Atomic single-column write. */
-export declare function setIntent(nodeId: string, intent: ExitIntent): void;
+export declare function setIntent(nodeId: string, intent: ExitIntent): Promise<void>;
 /** 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
@@ -92,14 +92,14 @@ export declare function transitionStatusIntent(nodeId: string, fields: {
         /** Action-independent document composed before the conditional latch. */
         documentJson?: string | null;
     };
-}): number;
+}): Promise<number>;
 /** Read a node's committed-final latch pointer. Pure read, no side effect. */
-export declare function getFinalReport(nodeId: string): string | null;
+export declare function getFinalReport(nodeId: string): Promise<string | 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 declare function clearFinalReportIfMatches(nodeId: string, expectedFinalReport: string): boolean;
+export declare function clearFinalReportIfMatches(nodeId: string, expectedFinalReport: string): Promise<boolean>;
 /** 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
@@ -110,27 +110,27 @@ export declare function setPresence(nodeId: string, presence: {
     tmux_session?: string | null;
     window?: string | null;
     pane?: string | null;
-}): void;
-export declare function recordLaunch(nodeId: string, at: string): void;
-export declare function recordSettledTurn(nodeId: string, at: string): void;
-export declare function setFrozen(nodeId: string, at: string): void;
-export declare function clearFrozen(nodeId: string): void;
+}): Promise<void>;
+export declare function recordLaunch(nodeId: string, at: string): Promise<void>;
+export declare function recordSettledTurn(nodeId: string, at: string): Promise<void>;
+export declare function setFrozen(nodeId: string, at: string): Promise<void>;
+export declare function clearFrozen(nodeId: string): Promise<void>;
 export declare function recordRespawnAttempt(nodeId: string, attempt: {
     failures: number;
     notBefore: string | null;
-}): void;
-export declare function listNodesByProfile(profileId: string): NodeMeta[];
+}): Promise<void>;
+export declare function listNodesByProfile(profileId: string): Promise<NodeMeta[]>;
 /** Browse's first frame: select only fields its rows/tree use. Keep the fault and
  * turn columns for rowFrom's live fault/streaming semantics, but never hydrate
  * outcomes, placement, metadata or the (often large) telemetry activity text. */
-export declare function browseNodes(): NodeRow[];
+export declare function browseNodes(): Promise<NodeRow[]>;
 /** All rows, optionally filtered by status and terminal execution traces. Unclaimed warm spares are excluded. */
 export declare function updateNodeTelemetry(nodeId: string, telemetry: {
     tokensIn: number;
     contextTokens: number | null;
     lastActivity: string | null;
     updatedAt: string;
-}): void;
+}): Promise<void>;
 export interface GraphNodeRow {
     node_id: string;
     name: string;
@@ -148,39 +148,39 @@ export interface GraphNodeRow {
 /** Stored fields the attach graph displays, plus the two live execution cues it
  * needs. This keeps the interactive graph off the full node-summary projection
  * and its unused runtime, outcome, and placement fields. */
-export declare function graphNodes(): GraphNodeRow[];
+export declare function graphNodes(): Promise<GraphNodeRow[]>;
 export declare function listNodes(filter?: {
     status?: NodeStatus | NodeStatus[];
     withRecordedPid?: boolean;
     withRecordedPidOrFrozen?: boolean;
-}): NodeRow[];
+}): Promise<NodeRow[]>;
 /** Placement-only terminal rows for the daemon's residue pass. These columns
  * preserve lastActivityMs's timestamp inputs and the teardown event fields;
  * unlike node_rows, the nodes table needs no execution/session/fault joins. */
 export type TerminalPlacementResidue = Pick<NodeRow, 'node_id' | 'created' | 'launched_at' | 'last_settled_at' | 'finalized_at' | 'outcome_at' | 'last_activity_at' | 'pane' | 'window' | 'tmux_session'>;
 export declare const terminalPlacementResidueSql = "SELECT\n      node_id, created, launched_at, last_settled_at, finalized_at,\n      outcome_at, last_activity_at, pane, \"window\", tmux_session\n    FROM nodes INDEXED BY idx_nodes_terminal_placement_created\n    WHERE node_id NOT IN (SELECT node_id FROM warm_pool)\n      AND status IN ('done', 'canceled', 'dead')\n      AND (pane IS NOT NULL OR \"window\" IS NOT NULL OR tmux_session IS NOT NULL)\n    ORDER BY created";
-export declare function listTerminalPlacementResidue(): TerminalPlacementResidue[];
+export declare function listTerminalPlacementResidue(): Promise<TerminalPlacementResidue[]>;
 /** The daemon's complete supervision set. Live rows participate regardless of
  * PID; terminal rows participate only while they retain a PID or freeze mark. */
 export declare const nodesForSupervisionSql = "WITH candidates AS MATERIALIZED (\n    SELECT node_id FROM nodes WHERE status IN ('active', 'idle')\n    UNION\n    SELECT node_id FROM nodes INDEXED BY idx_nodes_supervision_frozen\n      WHERE frozen_at IS NOT NULL AND status IN ('done', 'canceled', 'dead')\n    UNION\n    SELECT node_id FROM executions\n      WHERE state != 'exited' AND state = 'running' AND pid IS NOT NULL\n  )\n  SELECT v.* FROM candidates c CROSS JOIN node_rows v\n  WHERE v.node_id = c.node_id\n    AND v.node_id NOT IN (SELECT node_id FROM warm_pool)\n    AND v.kind != 'human'\n    AND (v.status IN ('active', 'idle') OR (v.status IN ('done', 'canceled', 'dead') AND (v.pi_pid IS NOT NULL OR v.frozen_at IS NOT NULL)))\n  ORDER BY v.created";
-export declare function listNodesForSupervision(): NodeRow[];
+export declare function listNodesForSupervision(): Promise<NodeRow[]>;
 /** 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 declare function listNodeIdentities(): Array<Pick<NodeRow, 'node_id' | 'name' | 'created'> & {
+export declare function listNodeIdentities(): Promise<Array<Pick<NodeRow, 'node_id' | 'name' | 'created'> & {
     grantee: string;
-}>;
+}>>;
 /** Mark an already-spawned node as an unclaimed spare for `recipeKey`. Hides it
  *  from every listing until it is claimed. */
-export declare function registerWarmSpare(nodeId: string, recipeKey: string): void;
+export declare function registerWarmSpare(nodeId: string, recipeKey: string): Promise<void>;
 /** 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 declare function unregisterWarmSpare(nodeId: string): boolean;
+export declare function unregisterWarmSpare(nodeId: string): Promise<boolean>;
 /** One parked spare, joined to the node row a claim/reap needs to judge it. */
 export interface WarmSpareRow {
     node_id: string;
@@ -194,14 +194,14 @@ export interface WarmSpareRow {
 /** 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 declare function listWarmSpares(): WarmSpareRow[];
+export declare function listWarmSpares(): Promise<WarmSpareRow[]>;
 /** 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 declare function isWarmSpare(nodeId: string): boolean;
+export declare function isWarmSpare(nodeId: string): Promise<boolean>;
 /** 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.
@@ -217,15 +217,15 @@ export declare function claimWarmSpare(recipeKey: string, created: string, opts?
     deadlineAt?: string;
     outcomeDelivery?: OutcomeDeliveryBinding;
     requestKey?: string;
-}): string | null;
+}): Promise<string | null>;
 /** 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 declare function warmSpareCount(recipeKey: string): number;
+export declare function warmSpareCount(recipeKey: string): Promise<number>;
 /** Direct children of `id`, oldest first — an indexed point query
  *  (`idx_nodes_parent`) instead of a full-table `listNodes()` scan. */
-export declare function childrenOf(id: string): string[];
+export declare function childrenOf(id: string): Promise<string[]>;
 /** One lean roster row: only the `nodes` columns needed by the roster. Backs
  *  `GET /v1/canvas/roster` — the recurring attach /
  *  browser topology poll, distinct from the enriched per-row
@@ -244,14 +244,14 @@ export interface RosterRow {
 }
 /** 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 declare function rosterNodes(): RosterRow[];
+export declare function rosterNodes(): Promise<RosterRow[]>;
 /** 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 declare function listResumableRoots(cwd: string): NodeRow[];
+export declare function listResumableRoots(cwd: string): Promise<NodeRow[]>;
 export * from './tree.js';
 /** The outcome of {@link withFreshTerminalGuard} — exactly one of three
  *  tagged states, never conflated:
@@ -300,7 +300,7 @@ export declare function withFreshTerminalGuard<T>(nodeId: string, isTerminal: (r
     status: NodeStatus;
     final_report: string | null;
     frozen_at: string | null;
-}) => boolean, body: () => T): TerminalGuardResult<T>;
+}) => boolean, body: () => Promise<T> | T): Promise<TerminalGuardResult<T>>;
 /** A node selected for pruning (or that would be, under --dry-run). */
 export interface PrunedNode {
     node_id: string;
@@ -315,7 +315,7 @@ export interface PruneResult {
 /** Whether a row may be removed by an automatic collection sweep. */
 export declare function isCollectible(row: NodeRow, opts?: {
     pastTtl?: boolean;
-}): boolean;
+}): Promise<boolean>;
 /** {@link deleteNode}'s result: whether it actually deleted the node. */
 export interface DeleteNodeResult {
     deleted: boolean;
@@ -325,10 +325,10 @@ export interface NodeFiles {
     nodeId: string;
     app: string | null;
 }
-export declare function nodeFiles(nodeId: string): NodeFiles;
+export declare function nodeFiles(nodeId: string): Promise<NodeFiles>;
 /** Remove every directory a deleted node owned. A conversation another node
  *  still references keeps its file, and so its conversations directory. */
-export declare function removeNodeFiles(files: NodeFiles): void;
+export declare function removeNodeFiles(files: NodeFiles): Promise<void>;
 /** Delete ONE node with what it owns ({@link deleteNodeWithOwned}) 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
@@ -337,10 +337,10 @@ export declare function removeNodeFiles(files: NodeFiles): void;
  *  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 declare function deleteNode(nodeId: string): DeleteNodeResult;
+export declare function deleteNode(nodeId: string): Promise<DeleteNodeResult>;
 /** 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 declare function deleteNodes(nodeIds: readonly string[]): string[];
+export declare function deleteNodes(nodeIds: readonly string[]): Promise<string[]>;
 /** Retention sweep: remove TERMINAL nodes (status dead | done | canceled) whose
  *  last activity ({@link lastActivityMs}) is older than `ttlDays`, bounding the
  *  otherwise-unbounded growth of node rows + dirs. Only {@link isCollectible}
@@ -358,11 +358,11 @@ export declare function deleteNodes(nodeIds: readonly string[]): string[];
  *  reports the candidate set and deletes NOTHING. */
 export declare function pruneNodes(opts: {
     ttlDays: number;
-    held: (nodeId: string) => boolean;
+    held: (nodeId: string) => Promise<boolean>;
     dryRun?: boolean;
     includeStale?: boolean;
     removeDirs?: (dirs: string[]) => void;
-}): PruneResult;
+}): Promise<PruneResult>;
 /** A node's most recent activity (epoch ms): the latest of its lifecycle
  *  timestamps (created, launched, settled, finalized, outcome, last run event)
  *  and the mtime of `job/telemetry.json`, which every turn_end rewrites. 0 when
@@ -379,6 +379,6 @@ export declare function lastActivityMs(row: Pick<NodeRow, 'node_id' | 'created'
  *  reports the candidate set and deletes NOTHING. */
 export declare function pruneToLimit(opts: {
     maxNodes: number;
-    held: (nodeId: string) => boolean;
+    held: (nodeId: string) => Promise<boolean>;
     dryRun?: boolean;
-}): PruneResult;
+}): Promise<PruneResult>;