@north-light/crouter 0.3.312 → 0.3.314

package/dist/core/canvas/node-sql-migration.js

@@ -0,0 +1,261 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { nodesRoot } from './paths.js';
+const REQUIRED_META_FIELDS = ['node_id', 'name', 'created', 'cwd', 'kind', 'mode', 'lifecycle'];
+function columns(db, table) {
+    return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map(({ name }) => name));
+}
+function addNodeColumns(db) {
+    const known = columns(db, 'nodes');
+    const additions = [
+        ['title', 'TEXT'], ['icon', 'TEXT'], ['spawned_by', 'TEXT'], ['creator', 'TEXT'], ['fork_from', 'TEXT'], ['fork_source_file', 'TEXT'],
+        ['passive_default', 'INTEGER NOT NULL DEFAULT 0 CHECK (passive_default IN (0,1))'], ['cycle_pending', 'INTEGER NOT NULL DEFAULT 0 CHECK (cycle_pending IN (0,1))'],
+        ['model_override', 'TEXT'], ['persona_ack_json', 'TEXT'], ['review_binding_json', 'TEXT'], ['launch_config_json', 'TEXT'],
+    ];
+    for (const [name, definition] of additions) {
+        if (!known.has(name))
+            db.exec(`ALTER TABLE nodes ADD COLUMN ${name} ${definition}`);
+    }
+    db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_cycle_pending ON nodes(cycle_pending) WHERE cycle_pending = 1');
+}
+function canonical(path) {
+    const absolute = resolve(path);
+    return existsSync(absolute) ? realpathSync(absolute) : absolute;
+}
+function json(value, field, path) {
+    if (value === undefined)
+        return null;
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined)
+        throw new Error(`cannot serialize ${field} in ${path}`);
+    return encoded;
+}
+function requiredString(meta, key, path) {
+    const value = meta[key];
+    if (typeof value !== 'string')
+        throw new Error(`cannot import node metadata ${path}: ${key} must be a string`);
+    return value;
+}
+function optionalString(meta, key, path) {
+    const value = meta[key];
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== 'string')
+        throw new Error(`cannot import node metadata ${path}: ${key} must be a string or null`);
+    return value;
+}
+function optionalNumber(meta, key, path) {
+    const value = meta[key];
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        throw new Error(`cannot import node metadata ${path}: ${key} must be a finite number or null`);
+    return value;
+}
+function optionalObject(value, field, path) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`cannot import ${field} from ${path}: expected an object`);
+    return value;
+}
+function readMetas() {
+    if (!existsSync(nodesRoot()))
+        return [];
+    const result = [];
+    for (const entry of readdirSync(nodesRoot(), { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const path = join(nodesRoot(), entry.name, 'meta.json');
+        if (!existsSync(path))
+            continue;
+        let meta;
+        try {
+            meta = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch (error) {
+            throw new Error(`cannot import node metadata ${path}: ${error.message}`);
+        }
+        for (const key of REQUIRED_META_FIELDS) {
+            if (meta[key] === undefined || meta[key] === null)
+                throw new Error(`cannot import node metadata ${path}: missing required ${key}`);
+        }
+        if (typeof meta['node_id'] !== 'string' || meta['node_id'] !== entry.name)
+            throw new Error(`cannot import node metadata ${path}: node_id does not match its directory`);
+        result.push({ path, meta });
+    }
+    return result;
+}
+function sqlOnlyPaths(db) {
+    const has = columns(db, 'nodes').has('pi_session_file');
+    if (!has)
+        return new Map();
+    return new Map(db.prepare('SELECT node_id, pi_session_file FROM nodes WHERE pi_session_file IS NOT NULL').all().map(({ node_id, pi_session_file }) => [node_id, pi_session_file]));
+}
+function createTables(db) {
+    db.exec(`
+CREATE TABLE IF NOT EXISTS sessions (
+  binding_id TEXT PRIMARY KEY,
+  session_id TEXT,
+  node_id TEXT NOT NULL REFERENCES nodes(node_id) ON DELETE CASCADE,
+  transcript_path TEXT,
+  source_session_id TEXT,
+  fork_entry_id TEXT,
+  created_at TEXT NOT NULL,
+  bound_at TEXT NOT NULL,
+  unbound_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_sessions_node ON sessions(node_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_sessions_session ON sessions(session_id);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_live_node ON sessions(node_id) WHERE unbound_at IS NULL;
+CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_live_transcript ON sessions(transcript_path) WHERE unbound_at IS NULL AND transcript_path IS NOT NULL;
+CREATE TABLE IF NOT EXISTS executions (
+  execution_id TEXT PRIMARY KEY,
+  node_id TEXT NOT NULL REFERENCES nodes(node_id) ON DELETE CASCADE,
+  daemon_epoch TEXT,
+  pid INTEGER,
+  process_identity TEXT,
+  state TEXT NOT NULL CHECK (state IN ('launching','running','exited')),
+  started_at TEXT NOT NULL,
+  ended_at TEXT,
+  exit_reason TEXT,
+  CHECK ((state = 'exited') = (ended_at IS NOT NULL))
+);
+CREATE INDEX IF NOT EXISTS idx_executions_node ON executions(node_id, started_at);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_executions_live_node ON executions(node_id) WHERE state != 'exited';
+CREATE TABLE IF NOT EXISTS worktrees (
+  node_id TEXT PRIMARY KEY REFERENCES nodes(node_id) ON DELETE CASCADE,
+  state TEXT NOT NULL CHECK (state IN ('open','closed','abandoned')),
+  cleanup_state TEXT CHECK (cleanup_state IS NULL OR cleanup_state IN ('pending','complete')),
+  path TEXT NOT NULL,
+  branch TEXT NOT NULL,
+  repo_root TEXT NOT NULL,
+  base_ref TEXT NOT NULL,
+  base_sha TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  closed_at TEXT,
+  next_attempt_at TEXT,
+  attempts INTEGER NOT NULL DEFAULT 0 CHECK (attempts >= 0),
+  quarantined INTEGER NOT NULL DEFAULT 0 CHECK (quarantined IN (0,1)),
+  sweep_reason TEXT,
+  sweep_detail TEXT,
+  sweep_last_at TEXT,
+  sweep_observed_json TEXT,
+  abandoned_json TEXT,
+  land_intent_json TEXT,
+  disposal_json TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_worktrees_sweep ON worktrees(state, cleanup_state, next_attempt_at);
+`);
+}
+function importMetas(db, entries, retainedPaths) {
+    const update = db.prepare(`INSERT INTO nodes (node_id, name, description, cycles, kind, mode, lifecycle, cwd, host_kind, profile_id, parent, created, title, icon, spawned_by, creator, fork_from, fork_source_file, passive_default, cycle_pending, model_override, persona_ack_json, review_binding_json, launch_config_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(node_id) DO UPDATE SET name=excluded.name, description=excluded.description, cycles=excluded.cycles, kind=excluded.kind, mode=excluded.mode, lifecycle=excluded.lifecycle, cwd=excluded.cwd, host_kind=excluded.host_kind, profile_id=excluded.profile_id, parent=excluded.parent, title=excluded.title, icon=excluded.icon, spawned_by=excluded.spawned_by, creator=excluded.creator, fork_from=excluded.fork_from, fork_source_file=excluded.fork_source_file, passive_default=excluded.passive_default, cycle_pending=excluded.cycle_pending, model_override=excluded.model_override, persona_ack_json=excluded.persona_ack_json, review_binding_json=excluded.review_binding_json, launch_config_json=excluded.launch_config_json`);
+    for (const { path, meta } of entries) {
+        const nodeId = requiredString(meta, 'node_id', path);
+        const indexedPath = retainedPaths.get(nodeId);
+        const metadataPath = optionalString(meta, 'pi_session_file', path);
+        if (indexedPath !== undefined && metadataPath !== null && canonical(indexedPath) !== canonical(metadataPath)) {
+            throw new Error(`cannot import node metadata ${path}: pi_session_file conflicts with indexed path ${indexedPath}`);
+        }
+        update.run(nodeId, requiredString(meta, 'name', path), optionalString(meta, 'description', path), optionalNumber(meta, 'cycles', path), requiredString(meta, 'kind', path), requiredString(meta, 'mode', path), requiredString(meta, 'lifecycle', path), requiredString(meta, 'cwd', path), optionalString(meta, 'host_kind', path), optionalString(meta, 'profile_id', path), optionalString(meta, 'parent', path), requiredString(meta, 'created', path), optionalString(meta, 'title', path), optionalString(meta, 'icon', path), optionalString(meta, 'spawned_by', path), optionalString(meta, 'creator', path), optionalString(meta, 'fork_from', path), optionalString(meta, 'fork_source_file', path), meta['passive_default'] === true ? 1 : 0, meta['cycle_pending'] === true ? 1 : 0, optionalString(meta, 'model_override', path), json(meta['persona_ack'], 'persona_ack', path), json(meta['review_binding'], 'review_binding', path), json(meta['launch'], 'launch', path));
+        // A readable metadata row without a session path must not consume the old
+        // indexed path: importSessions uses that path as its SQL fallback.
+        if (metadataPath !== null)
+            retainedPaths.delete(nodeId);
+    }
+}
+function importEdges(db, entries) {
+    const known = new Set(db.prepare('SELECT node_id FROM nodes').all().map(({ node_id }) => node_id));
+    const insert = db.prepare("INSERT INTO edges (type, from_id, to_id, active, created) VALUES ('spawned_by', ?, ?, 1, ?) ON CONFLICT(type, from_id, to_id) DO NOTHING");
+    for (const { meta } of entries) {
+        const nodeId = meta['node_id'];
+        const owner = typeof meta['spawned_by'] === 'string' ? meta['spawned_by'] : typeof meta['parent'] === 'string' ? meta['parent'] : null;
+        if (owner !== null && known.has(nodeId) && known.has(owner))
+            insert.run(nodeId, owner, new Date().toISOString());
+    }
+}
+function importSessions(db, entries, retainedPaths) {
+    const insert = db.prepare('INSERT INTO sessions (binding_id, session_id, node_id, transcript_path, source_session_id, fork_entry_id, created_at, bound_at, unbound_at) VALUES (?, ?, ?, ?, NULL, NULL, ?, ?, NULL)');
+    const seen = new Map();
+    for (const { path, meta } of entries) {
+        const nodeId = requiredString(meta, 'node_id', path);
+        const indexedPath = retainedPaths.get(nodeId);
+        const rawPath = typeof meta['pi_session_file'] === 'string' ? meta['pi_session_file'] : indexedPath;
+        const sessionId = typeof meta['pi_session_id'] === 'string' ? meta['pi_session_id'] : null;
+        if (rawPath === undefined && sessionId === null)
+            continue;
+        const transcript = rawPath === undefined ? null : canonical(rawPath);
+        if (transcript !== null) {
+            const owner = seen.get(transcript);
+            if (owner !== undefined)
+                throw new Error(`cannot import duplicate live transcript ${transcript}: ${owner}, ${nodeId}`);
+            seen.set(transcript, nodeId);
+        }
+        const created = requiredString(meta, 'created', path);
+        insert.run(randomUUID(), sessionId, nodeId, transcript, created, created);
+        if (indexedPath !== undefined)
+            retainedPaths.delete(nodeId);
+    }
+    for (const [nodeId, rawPath] of retainedPaths) {
+        const transcript = canonical(rawPath);
+        const owner = seen.get(transcript);
+        if (owner !== undefined)
+            throw new Error(`cannot import duplicate live transcript ${transcript}: ${owner}, ${nodeId}`);
+        seen.set(transcript, nodeId);
+        const created = db.prepare('SELECT created FROM nodes WHERE node_id = ?').get(nodeId)?.created;
+        if (created !== undefined)
+            insert.run(randomUUID(), null, nodeId, transcript, created, created);
+    }
+}
+function importWorktrees(db, entries) {
+    const insert = db.prepare('INSERT INTO worktrees (node_id, state, cleanup_state, path, branch, repo_root, base_ref, base_sha, created_at, closed_at, next_attempt_at, attempts, quarantined, sweep_reason, sweep_detail, sweep_last_at, sweep_observed_json, abandoned_json, land_intent_json, disposal_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
+    for (const { path, meta } of entries) {
+        const wt = optionalObject(meta['managed_worktree'], 'managed worktree', path);
+        if (wt === undefined)
+            continue;
+        const sweep = optionalObject(wt['sweep'], 'managed_worktree.sweep', path);
+        insert.run(requiredString(meta, 'node_id', path), requiredString(wt, 'state', path), optionalString(wt, 'cleanup', path), requiredString(wt, 'path', path), requiredString(wt, 'branch', path), requiredString(wt, 'repo_root', path), requiredString(wt, 'base_ref', path), requiredString(wt, 'base_sha', path), requiredString(wt, 'created', path), optionalString(wt, 'closed', path), sweep === undefined ? null : optionalString(sweep, 'next_attempt', path), sweep === undefined ? 0 : optionalNumber(sweep, 'attempts', path) ?? 0, sweep?.['quarantined'] === true ? 1 : 0, sweep === undefined ? null : optionalString(sweep, 'reason', path), sweep === undefined ? null : optionalString(sweep, 'detail', path), sweep === undefined ? null : optionalString(sweep, 'last_attempt', path), json(sweep?.['observed'], 'managed_worktree.sweep.observed', path), json(wt['abandoned'], 'managed_worktree.abandoned', path), json(wt['land_intent'], 'managed_worktree.land_intent', path), json(wt['disposal'], 'managed_worktree.disposal', path));
+    }
+}
+function importExecutions(db) {
+    const old = columns(db, 'nodes');
+    if (!old.has('pi_pid'))
+        return;
+    const rows = db.prepare('SELECT node_id, pi_pid, pi_pid_identity, launched_at, created FROM nodes WHERE pi_pid IS NOT NULL').all();
+    const insert = db.prepare("INSERT INTO executions (execution_id, node_id, daemon_epoch, pid, process_identity, state, started_at, ended_at, exit_reason) VALUES (?, ?, NULL, ?, ?, 'running', ?, NULL, NULL)");
+    for (const row of rows)
+        insert.run(randomUUID(), row.node_id, row.pi_pid, row.pi_pid_identity, row.launched_at ?? row.created);
+}
+function validate(db, priorRows) {
+    const rows = db.prepare('SELECT COUNT(*) AS count FROM nodes').get().count;
+    if (rows < priorRows)
+        throw new Error('node import removed an existing SQL row');
+    const foreignKeys = db.prepare('PRAGMA foreign_key_check').all();
+    if (foreignKeys.length > 0)
+        throw new Error('node import foreign key check failed');
+}
+function dropLegacyColumnsAndCreateView(db) {
+    db.exec('DROP INDEX IF EXISTS idx_nodes_pi_session_file');
+    const known = columns(db, 'nodes');
+    for (const name of ['pi_session_file', 'pi_pid', 'pi_pid_identity'])
+        if (known.has(name))
+            db.exec(`ALTER TABLE nodes DROP COLUMN ${name}`);
+    db.exec('DROP VIEW IF EXISTS node_rows');
+    db.exec(`CREATE VIEW node_rows AS SELECT n.*, CASE WHEN e.state = 'running' THEN e.pid ELSE NULL END AS pi_pid, CASE WHEN e.state = 'running' THEN e.process_identity ELSE NULL END AS pi_pid_identity, s.session_id AS pi_session_id, s.transcript_path AS pi_session_file FROM nodes n LEFT JOIN executions e ON e.node_id = n.node_id AND e.state != 'exited' LEFT JOIN sessions s ON s.node_id = n.node_id AND s.unbound_at IS NULL`);
+}
+/** Imported by the shared appended consolidation transaction. The caller owns the transaction and user_version. */
+export function importNodeSqlAuthority(db) {
+    const priorRows = db.prepare('SELECT COUNT(*) AS count FROM nodes').get().count;
+    const retainedPaths = sqlOnlyPaths(db);
+    const entries = readMetas();
+    addNodeColumns(db);
+    createTables(db);
+    importMetas(db, entries, retainedPaths);
+    importEdges(db, entries);
+    importSessions(db, entries, retainedPaths);
+    importWorktrees(db, entries);
+    importExecutions(db);
+    validate(db, priorRows);
+    dropLegacyColumnsAndCreateView(db);
+}

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

@@ -3,12 +3,7 @@
  *  visible top-level dir; `canvas/` keeps node-graph runtime state separate from
  *  durable user content (memory/plugins/marketplaces/config) at the scope root. */
 export declare function crtrHome(): string;
-/** Absolute path to the SQLite canvas db file — always `canvas.db` under the
- *  canvas home, beside the node data it indexes. Guest deployments (Blaxel
- *  volumes, local-docker mounts) put the whole canvas home on durable
- *  block storage, which supports SQLite's advisory fcntl/WAL locking like any
- *  local disk — so the db shares the node data's location and survives a
- *  sandbox recreate together with `nodes/`. */
+/** The canvas home requires durable storage with SQLite WAL locking support. */
 export declare function canvasDbPath(): string;
 export declare function onDiskMigrationLockPath(): string;
 export declare function onDiskMigrationMarkerPath(): string;
@@ -61,17 +56,8 @@ export declare function reportsDir(nodeId: string): string;
 export declare function messagesDir(nodeId: string): string;
 export declare function nodeMetaPath(nodeId: string): string;
 export declare function inboxPath(nodeId: string): string;
-/** The node-owned ambient "current situation" sidecar — ONE rendered runtime
- *  card, restated by the session-start bearings (see
- *  `runtime/situational-context.ts`), upserted in place rather than appended so
- *  only the newest applet/situation state is ever carried. Lives beside
- *  meta.json/inbox.jsonl (node-runtime state) rather than under context/ (the
- *  user-authored artifact store), because it is ambient machine state, not a
- *  document a human wrote. */
+/** Rendered ambient context lives outside the user-authored context directory. */
 export declare function situationalContextPath(nodeId: string): string;
-/** Passive-subscription accumulator. Pushes from publishers this node subscribes
- *  to PASSIVELY land here instead of inbox.jsonl — the inbox-watcher never polls
- *  it, so they never wake the node. Drained as XML pre-text on the next message. */
 export declare function passivePath(nodeId: string): string;
 export declare function transcriptPath(nodeId: string): string;
 export declare function sessionPtrPath(nodeId: string): string;

package/dist/core/canvas/paths.js

@@ -1,18 +1,3 @@
-// The `~/.crouter/canvas/` layout. One global, cwd-agnostic home for the whole canvas.
-//
-//   ~/.crouter/canvas/
-//     canvas.db                 sqlite (WAL) — topology only (nodes + edges)
-//     nodes/<node_id>/
-//       meta.json               source of truth for the node's row
-//       context/                roadmap.md, initial-prompt.md, explore-*.md, artifacts
-//       job/                    log.jsonl (canonical broker events), telemetry.json and fault (current state), broker.log (raw residue)
-//       reports/                append-only push history (<ts>-<kind>.md)
-//       messages/               overflow bodies for inbox entries too long to inline
-//       inbox.jsonl             messages + coalesced subscription feed
-//       transcript.jsonl        mirror/pointer of the pi session
-//       session.ptr             pi session id/path
-//
-// `CRTR_HOME` overrides the root (used by tests and isolated runs).
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { mkdirSync } from 'node:fs';
@@ -27,12 +12,7 @@ export function crtrHome() {
         ? override
         : join(homedir(), CRTR_DIR_NAME, 'canvas');
 }
-/** Absolute path to the SQLite canvas db file — always `canvas.db` under the
- *  canvas home, beside the node data it indexes. Guest deployments (Blaxel
- *  volumes, local-docker mounts) put the whole canvas home on durable
- *  block storage, which supports SQLite's advisory fcntl/WAL locking like any
- *  local disk — so the db shares the node data's location and survives a
- *  sandbox recreate together with `nodes/`. */
+/** The canvas home requires durable storage with SQLite WAL locking support. */
 export function canvasDbPath() {
     return join(crtrHome(), 'canvas.db');
 }
@@ -143,19 +123,10 @@ export function nodeMetaPath(nodeId) {
 export function inboxPath(nodeId) {
     return join(nodeDir(nodeId), 'inbox.jsonl');
 }
-/** The node-owned ambient "current situation" sidecar — ONE rendered runtime
- *  card, restated by the session-start bearings (see
- *  `runtime/situational-context.ts`), upserted in place rather than appended so
- *  only the newest applet/situation state is ever carried. Lives beside
- *  meta.json/inbox.jsonl (node-runtime state) rather than under context/ (the
- *  user-authored artifact store), because it is ambient machine state, not a
- *  document a human wrote. */
+/** Rendered ambient context lives outside the user-authored context directory. */
 export function situationalContextPath(nodeId) {
     return join(nodeDir(nodeId), 'situational-context.md');
 }
-/** Passive-subscription accumulator. Pushes from publishers this node subscribes
- *  to PASSIVELY land here instead of inbox.jsonl — the inbox-watcher never polls
- *  it, so they never wake the node. Drained as XML pre-text on the next message. */
 export function passivePath(nodeId) {
     return join(nodeDir(nodeId), 'passive.jsonl');
 }

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

@@ -0,0 +1,76 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { type Fault, type FaultKind, type FaultLink, type FaultProviderError, type FaultRetry } from '../fault-classifier.js';
+export type { Fault, FaultKind, FaultLink, FaultProviderError, FaultRetry } from '../fault-classifier.js';
+export declare const FAULT_QUIET_MS: number;
+export interface FaultRecordInput {
+    link: FaultLink;
+    op: string;
+    kind: FaultKind;
+    retry: FaultRetry;
+    message: string;
+    operation_id?: string;
+    since?: string;
+    anchorEntryId?: string;
+    providerError?: FaultProviderError;
+}
+export interface StoredFault extends Fault {
+    faultId: string;
+}
+export interface ProviderRetryEpisode {
+    state: 'pending' | 'admitted' | 'invalidated';
+    sessionId: string | null;
+    fault: StoredFault;
+}
+export interface TransportPoisonVerdict {
+    consecutivePasses: number;
+    routes: string[];
+}
+export interface BootFaultAttempt {
+    explanation(): string | null;
+}
+export declare function parseProviderError(value: unknown): FaultProviderError | undefined;
+export declare function openTurn(executionId: string, _opts: {
+    reason: 'agent-start' | 'prompt-unsettled';
+}): boolean;
+export declare function recordTurnProgress(executionId: string): boolean;
+export declare function closeTurn(executionId: string, opts: {
+    endReason: 'settled' | 'teardown-aborted';
+}): boolean;
+export declare function recordTransportPoisonVerdict(executionId: string, verdict: TransportPoisonVerdict): boolean;
+export declare function readTransportPoisonVerdict(nodeId: string): TransportPoisonVerdict | null;
+export declare function readLiveTurn(nodeId: string): {
+    busy: boolean;
+    progressAt: string | null;
+} | null;
+export declare function readInterruptedTurn(nodeId: string): {
+    interrupted: boolean;
+    progressAt: string | null;
+} | null;
+export declare function recordFault(nodeId: string, input: FaultRecordInput): StoredFault | null;
+export declare function clearFault(nodeId: string, opts?: {
+    link?: FaultLink;
+    preserveEpisode?: boolean;
+}): boolean;
+export declare function readFault(nodeId: string): StoredFault | null;
+export declare function recordPendingEpisode(nodeId: string, input: {
+    sessionId: string;
+    input: FaultRecordInput;
+}): StoredFault | null;
+export declare function admitEpisode(nodeId: string, input: {
+    sessionId: string;
+    faultId: string;
+    retry: FaultRetry;
+}): boolean;
+export declare function reopenEpisode(nodeId: string, input: {
+    sessionId: string;
+}): boolean;
+export declare function invalidateEpisode(nodeId: string, input: {
+    sessionId: string;
+}): boolean;
+export declare function clearEpisode(nodeId: string, input: {
+    sessionId: string;
+}): boolean;
+export declare function readEpisode(nodeId: string): ProviderRetryEpisode | null;
+export declare function beginBootFaultAttempt(nodeId: string): BootFaultAttempt;
+/** Import legacy witness and recovery files inside the parent's one shared consolidation transaction. */
+export declare function migrateRecoveryWitnesses(db: DatabaseSync): void;