@crouton-kit/crouter 0.3.32 → 0.3.34

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

@@ -2,3 +2,9 @@
  *  0)` throws ESRCH when the process is gone; EPERM means it exists but isn't
  *  ours — still alive. A null/undefined pid (legacy / never-booted) reads dead. */
 export declare function isPidAlive(pid: number | null | undefined): boolean;
+/** SIGTERM a process GROUP by pid (the negative-pid convention) — best-effort,
+ *  swallowing ESRCH (already gone). Shared by triggers.ts (cancel-time reap of
+ *  an in-flight predicate evaluation) and daemon/predicate-eval.ts (per-eval
+ *  timeout + stale-lease recovery kills). Lives beside isPidAlive: canvas/ is
+ *  the lowest shared layer every process-liveness/-teardown primitive sits at. */
+export declare function killProcessGroup(pid: number, signal?: NodeJS.Signals): void;

package/dist/core/canvas/pid.js

@@ -21,3 +21,16 @@ export function isPidAlive(pid) {
         return e.code === 'EPERM';
     }
 }
+/** SIGTERM a process GROUP by pid (the negative-pid convention) — best-effort,
+ *  swallowing ESRCH (already gone). Shared by triggers.ts (cancel-time reap of
+ *  an in-flight predicate evaluation) and daemon/predicate-eval.ts (per-eval
+ *  timeout + stale-lease recovery kills). Lives beside isPidAlive: canvas/ is
+ *  the lowest shared layer every process-liveness/-teardown primitive sits at. */
+export function killProcessGroup(pid, signal = 'SIGTERM') {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        /* already gone */
+    }
+}

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

@@ -1,4 +1,9 @@
+import { type Fault } from '../runtime/fault.js';
 import type { NodeStatus, Lifecycle } from './types.js';
+export declare function activeFaultForDisplay<T extends {
+    status: NodeStatus;
+    pi_pid?: number | null;
+}>(node: T, fault: Fault | null): Fault | null;
 /**
  * Render the subscription sub-DAG rooted at `rootId` as an ASCII tree.
  * The root is the first line (no connector prefix); children are indented.
@@ -59,6 +64,13 @@ export interface DashboardRow {
      *  live "is it generating?" cue. Computed on the cheap boot path for LIVE nodes
      *  only (dormant rows are always false). */
     streaming?: boolean;
+    /** Set when the node is parked on an active fault. The otherwise-invisible
+     *  "stuck, awaiting recovery" window. Mutually exclusive with `streaming`
+     *  (hanging means the turn ended, so `busy` is gone); when set,
+     *  dashboardRowsAll forces `streaming:false`. Computed on the cheap boot path
+     *  for every node, then suppressed only for stale daemon-owned provider faults
+     *  whose broker pid is gone. */
+    hanging?: Fault | null;
     /** True when a viewer (focus row) is attached to the node — i.e. someone has it
      *  open on screen. Set on the cheap boot path from the one listFocuses() query. */
     viewed?: boolean;
@@ -70,6 +82,19 @@ export interface DashboardRow {
      *  session (prompts + lastAssistant). Idempotency marker for the selected row. */
     previewLoaded?: boolean;
 }
+/** Did this node's engine ever PRODUCE something — an assistant message with real
+ *  text, a tool call, or non-empty reasoning? The signal that a node did work and
+ *  is not an empty shell. A never-revived node (no session file) is trivially
+ *  false; an assistant turn that is only an empty/aborted `thinking` stub does NOT
+ *  count (that's a node started and killed before it did anything). CONSERVATIVE
+ *  by design: ANY substance keeps the node, so the reap never deletes real work
+ *  — a tool-call-only turn (no final text) still counts. Drives reap-on-close/
+ *  detach. One file read with an early exit on the first substantive turn. */
+export declare function nodeHasAssistantMessage(sessionFile: string | null | undefined): boolean;
+/** {@link isStreaming} keyed by node id alone — hydrates the broker pid off the
+ *  db row. The exported "is this node actively generating right now?" guard so a
+ *  reap never nukes a node mid-first-turn before its output lands on disk. */
+export declare function isNodeStreaming(nodeId: string): boolean;
 /** One row per node visible in the sub-DAG of `rootId` (including root). */
 export declare function dashboardRows(rootId: string): DashboardRow[];
 /**

package/dist/core/canvas/render.js

@@ -20,16 +20,22 @@ import { jobDir, contextDir } from './paths.js';
 import { countAsks, asksForNodes } from './attention.js';
 import { isPidAlive } from './pid.js';
 import { listFocuses } from './focuses.js';
+import { resolveNodeVisual, faultSummary } from './status-glyph.js';
+import { readFault } from '../runtime/fault.js';
 // ---------------------------------------------------------------------------
-// Glyphs
+// Active-fault overlay: stale daemon-owned provider faults are hidden once the
+// broker pid is gone; manual/client faults stay visible until cleared.
 // ---------------------------------------------------------------------------
-const STATUS_GLYPH = {
-    active: '●',
-    idle: '○',
-    done: '✓',
-    dead: '✗',
-    canceled: '⊘',
-};
+export function activeFaultForDisplay(node, fault) {
+    if (fault === null)
+        return null;
+    if (fault.link === 'pi→provider' && fault.retry.by === 'daemon' && fault.retry.disposition === 'auto' && !isPidAlive(node.pi_pid))
+        return null;
+    return fault;
+}
+function hangingFor(node) {
+    return activeFaultForDisplay(node, readFault(node.node_id));
+}
 function readNodeTelemetry(nodeId) {
     const path = join(jobDir(nodeId), 'telemetry.json');
     if (!existsSync(path))
@@ -57,12 +63,14 @@ function nodeLine(nodeId, indent, connector) {
         // Node id is in the db but meta.json is gone — paranoid guard.
         return `${indent}${connector}? <missing meta: ${nodeId}>`;
     }
-    const glyph = STATUS_GLYPH[node.status] ?? '?';
+    const hanging = hangingFor(node);
+    const glyph = resolveNodeVisual(node.status, { hanging }).glyph;
     const tel = readNodeTelemetry(nodeId);
     const ctx = fmtCtx(tel.tokens_in);
     const asks = countAsks(nodeId);
     const askSuffix = asks > 0 ? ` ⚑${asks}` : '';
-    return `${indent}${connector}${glyph} ${fullName(node)} [${node.kind}/${node.mode}] ctx ${ctx}${askSuffix}`;
+    const faultSuffix = hanging !== null ? ` · ${faultSummary(hanging)}` : '';
+    return `${indent}${connector}${glyph} ${fullName(node)} [${node.kind}/${node.mode}] ctx ${ctx}${askSuffix}${faultSuffix}`;
 }
 /**
  * Recursively walk the subscription sub-DAG rooted at `nodeId`, appending
@@ -112,9 +120,11 @@ export function renderTree(rootId) {
     const ctx = fmtCtx(tel.tokens_in);
     const asks = countAsks(rootId);
     const askSuffix = asks > 0 ? ` ⚑${asks}` : '';
-    const glyph = STATUS_GLYPH[node.status] ?? '?';
+    const hanging = hangingFor(node);
+    const glyph = resolveNodeVisual(node.status, { hanging }).glyph;
+    const faultSuffix = hanging !== null ? ` · ${faultSummary(hanging)}` : '';
     const out = [];
-    out.push(`${glyph} ${fullName(node)} [${node.kind}/${node.mode}] ctx ${ctx}${askSuffix}`);
+    out.push(`${glyph} ${fullName(node)} [${node.kind}/${node.mode}] ctx ${ctx}${askSuffix}${faultSuffix}`);
     // visited starts with root already rendered (walkTree doesn't re-emit root).
     const visited = new Set([rootId]);
     const children = subscriptionsOf(rootId);
@@ -261,6 +271,77 @@ function readSessionParts(sessionFile) {
     }
     return { prompts, lastAssistant };
 }
+/** Did this node's engine ever PRODUCE something — an assistant message with real
+ *  text, a tool call, or non-empty reasoning? The signal that a node did work and
+ *  is not an empty shell. A never-revived node (no session file) is trivially
+ *  false; an assistant turn that is only an empty/aborted `thinking` stub does NOT
+ *  count (that's a node started and killed before it did anything). CONSERVATIVE
+ *  by design: ANY substance keeps the node, so the reap never deletes real work
+ *  — a tool-call-only turn (no final text) still counts. Drives reap-on-close/
+ *  detach. One file read with an early exit on the first substantive turn. */
+export function nodeHasAssistantMessage(sessionFile) {
+    if (sessionFile === undefined || sessionFile === null || sessionFile === '')
+        return false;
+    let lines;
+    try {
+        if (!existsSync(sessionFile))
+            return false;
+        lines = readFileSync(sessionFile, 'utf8').split('\n');
+    }
+    catch {
+        return false;
+    }
+    for (const line of lines) {
+        if (line === '' || (line.indexOf('"role":"assistant"') === -1 && line.indexOf('"role": "assistant"') === -1))
+            continue;
+        let rec;
+        try {
+            rec = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (rec.type !== 'message' || rec.message?.role !== 'assistant')
+            continue;
+        if (assistantContentIsSubstantive(rec.message.content))
+            return true;
+    }
+    return false;
+}
+/** True when an assistant message's content has at least one block that PRODUCED
+ *  something: non-empty text, non-empty thinking, a tool call (`toolCall`/
+ *  `tool_use`/…), or any other non-thinking/text block type. The lone non-case is
+ *  an empty thinking stub (`[{type:'thinking',thinking:''}]`) or empty content —
+ *  what an immediately-aborted first turn leaves behind. */
+function assistantContentIsSubstantive(content) {
+    if (typeof content === 'string')
+        return content.trim() !== '';
+    if (!Array.isArray(content))
+        return false;
+    for (const block of content) {
+        if (block === null || typeof block !== 'object')
+            continue;
+        const b = block;
+        const t = (b.type ?? '').toLowerCase();
+        if (t === 'text') {
+            if (typeof b.text === 'string' && b.text.trim() !== '')
+                return true;
+        }
+        else if (t === 'thinking') {
+            if (typeof b.thinking === 'string' && b.thinking.trim() !== '')
+                return true;
+        }
+        else
+            return true; // toolCall / tool_use / toolResult / any other block = real output
+    }
+    return false;
+}
+/** {@link isStreaming} keyed by node id alone — hydrates the broker pid off the
+ *  db row. The exported "is this node actively generating right now?" guard so a
+ *  reap never nukes a node mid-first-turn before its output lands on disk. */
+export function isNodeStreaming(nodeId) {
+    return isStreaming(nodeId, getNode(nodeId)?.pi_pid ?? null);
+}
 /** Is the node GENUINELY mid-turn right now? The `busy` marker (touched on
  *  agent_start, removed on agent_end) AND-ed with broker-pid liveness, so a stale
  *  marker from a crashed pi reads false. This is the live "generating?" signal
@@ -354,6 +435,7 @@ export function dashboardRowsAll() {
     const focusedNodeIds = new Set(listFocuses().map((f) => f.node_id));
     return listNodes().map((row) => {
         const live = row.status === 'active' || row.status === 'idle';
+        const hanging = activeFaultForDisplay(row, readFault(row.node_id));
         return {
             node_id: row.node_id,
             name: row.name, // handle only; enrichRow upgrades to fullName (meta.description)
@@ -366,7 +448,8 @@ export function dashboardRowsAll() {
             created: row.created,
             lifecycle: row.lifecycle,
             mtimeMs: sessionMtime(row.node_id, row.created),
-            streaming: live ? isStreaming(row.node_id, row.pi_pid) : false,
+            streaming: hanging === null && live ? isStreaming(row.node_id, row.pi_pid) : false,
+            hanging,
             viewed: focusedNodeIds.has(row.node_id),
         };
     });

package/dist/core/canvas/status-glyph.d.ts

@@ -0,0 +1,35 @@
+import type { NodeStatus } from './types.js';
+import { type Fault, type FaultKind } from '../runtime/fault.js';
+export declare const STATUS_GLYPH: Record<NodeStatus, string>;
+export declare const STATUS_COLOR: Record<NodeStatus, number>;
+export declare const HANGING_GLYPH = "\u26A0";
+export declare const HANGING_COLOR = 33;
+/** Short label for the fault kind. The overlay keeps one glyph and lets the
+ *  label carry the distinction. */
+export declare function hangingLabel(kind: FaultKind): string;
+export interface NodeVisual {
+    glyph: string;
+    color: number;
+    /** Overlay word (hanging kind label / 'live'); undefined for a plain status
+     *  (the caller supplies its own status word). */
+    word?: string;
+    bold?: boolean;
+}
+/** Resolve a node's glyph + hue + overlay word, applying the precedence
+ *  hanging > streaming > status. */
+export declare function resolveNodeVisual(status: NodeStatus, opts: {
+    streaming?: boolean;
+    hanging?: Fault | {
+        kind: FaultKind;
+    } | null;
+}): NodeVisual;
+/** Human-friendly active-fault disposition text. `auto` faults show the current
+ *  retry attempt plus the next scheduled retry; client-owned redials say
+ *  `redialing`; everything else says `needs you`. */
+export declare function faultDispositionText(fault: Fault, now?: number): string;
+/** One-line active-fault summary used by the canvas surfaces: `link kind ·
+ *  disposition`. */
+export declare function faultSummary(fault: Fault, now?: number): string;
+/** Elapsed counter used by the browse rail's countdown slot. `faultSummary`
+ *  covers the presenter surfaces; this stays for the rail's existing time text. */
+export declare function hangingCountdown(since: string, now?: number): string;

package/dist/core/canvas/status-glyph.js

@@ -0,0 +1,104 @@
+// status-glyph.ts — the canonical status→glyph/color map + overlay resolution
+// for the TS canvas-GRAPH surfaces (the ASCII forest `render.ts` and the
+// interactive `browse/render.ts`). It replaces the copy-pasted STATUS_GLYPH /
+// STATUS_COLOR literals those two files used to carry.
+//
+// SCOPE: only the surfaces the hanging-node feature touches. The workspace rail,
+// feed/push roster, and attach chat-view keep their own glyph copies (out of
+// scope). The portable `.mjs` canvas monitor view CANNOT import this (TS dist) —
+// it carries its own mirrored map with a pointer back to fault.ts.
+//
+// OVERLAY PRECEDENCE: hanging > streaming > status. `hanging` and `streaming` are
+// mutually exclusive in practice (hanging means the turn ended, so `busy` is
+// gone) but the precedence is defined regardless.
+import { FAULT_QUIET_MS } from '../runtime/fault.js';
+// ── Status glyphs (the mono, color-free primary encoding) ─────────────────────
+export const STATUS_GLYPH = {
+    active: '●',
+    idle: '○',
+    done: '✓',
+    dead: '✗',
+    canceled: '⊘',
+};
+// ── Status hue: numeric SGR codes per status (lifted from browse/render.ts). ───
+// Reinforces the glyph; the glyph SHAPE stays the NO_COLOR carrier.
+export const STATUS_COLOR = {
+    active: 32, // green
+    idle: 33, // yellow
+    done: 36, // cyan
+    dead: 31, // red
+    canceled: 90, // grey (bright-black)
+};
+// ── Streaming overlay (genuinely mid-turn) — browse's existing statusRail visual.
+const STREAMING_GLYPH = '⟳';
+const STREAMING_COLOR = 92; // bright green (brighter than active-status green)
+// ── Active-fault overlay (one glyph, kind label carries the detail). ─────────
+export const HANGING_GLYPH = '⚠';
+export const HANGING_COLOR = 33; // yellow
+/** Short label for the fault kind. The overlay keeps one glyph and lets the
+ *  label carry the distinction. */
+export function hangingLabel(kind) {
+    switch (kind) {
+        case 'rate-limit': return 'rate-limited';
+        case 'overloaded': return 'overloaded';
+        case 'connection': return 'down';
+        case 'auth': return 'auth';
+        case 'protocol': return 'protocol';
+        default: return 'other';
+    }
+}
+/** Resolve a node's glyph + hue + overlay word, applying the precedence
+ *  hanging > streaming > status. */
+export function resolveNodeVisual(status, opts) {
+    if (opts.hanging != null) {
+        return { glyph: HANGING_GLYPH, color: HANGING_COLOR, word: hangingLabel(opts.hanging.kind), bold: true };
+    }
+    if (opts.streaming === true) {
+        return { glyph: STREAMING_GLYPH, color: STREAMING_COLOR, word: 'live', bold: true };
+    }
+    return { glyph: STATUS_GLYPH[status] ?? '?', color: STATUS_COLOR[status] };
+}
+function retryCountdown(iso, now) {
+    const at = Date.parse(iso);
+    if (Number.isNaN(at))
+        return 'now';
+    const remaining = at - now;
+    if (remaining <= 0)
+        return 'now';
+    if (remaining >= 60_000)
+        return `${Math.max(1, Math.round(remaining / 60_000))}m`;
+    return `${Math.max(1, Math.ceil(remaining / 1000))}s`;
+}
+/** Human-friendly active-fault disposition text. `auto` faults show the current
+ *  retry attempt plus the next scheduled retry; client-owned redials say
+ *  `redialing`; everything else says `needs you`. */
+export function faultDispositionText(fault, now = Date.now()) {
+    const retry = fault.retry;
+    if (retry.disposition === 'auto') {
+        if (retry.by === 'client')
+            return 'redialing';
+        const progress = typeof retry.attempt === 'number' && typeof retry.max === 'number'
+            ? `auto-retry ${retry.attempt}/${retry.max}`
+            : 'auto-retrying';
+        return retry.nextAt ? `${progress}, next ${retryCountdown(retry.nextAt, now)}` : progress;
+    }
+    return 'needs you';
+}
+/** One-line active-fault summary used by the canvas surfaces: `link kind ·
+ *  disposition`. */
+export function faultSummary(fault, now = Date.now()) {
+    return `${fault.link} ${hangingLabel(fault.kind)} · ${faultDispositionText(fault, now)}`;
+}
+/** Elapsed counter used by the browse rail's countdown slot. `faultSummary`
+ *  covers the presenter surfaces; this stays for the rail's existing time text. */
+export function hangingCountdown(since, now = Date.now()) {
+    const start = Date.parse(since);
+    if (Number.isNaN(start))
+        return 'retrying…';
+    const remaining = FAULT_QUIET_MS - (now - start);
+    if (remaining <= 0)
+        return 'retrying…';
+    if (remaining >= 60_000)
+        return `retry in ~${Math.max(1, Math.round(remaining / 60_000))}m`;
+    return `retry in ~${Math.ceil(remaining / 1000)}s`;
+}

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

@@ -0,0 +1,108 @@
+import type { ArmTriggerSpec, Trigger, TriggerScope } from './types.js';
+/** A thrown integrity-backstop error from armTrigger. `code` is mapped by the
+ *  command surface to a rendered error block — armTrigger carries integrity
+ *  backstops only (empty body / recur-on-deadline / unknown action_mode);
+ *  target-resolvability + recoverable-state + per-owner cap checks live in the
+ *  surface, so a non-surface armer could insert a dangling trigger — every
+ *  armer MUST route through the surface. */
+export declare class TriggerArmError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/** INSERT one trigger row from the pinned spec, returning its (caller-supplied)
+ *  `trigger_id`. JSON.stringifies the typed `payload` union into the TEXT
+ *  column and stamps `created`.
+ *
+ *  Deadline upsert (≤1 deadline per node): for `action_mode === 'deadline_message'`
+ *  the node's existing deadline is canceled first, then the new one inserted —
+ *  the partial unique index `idx_triggers_deadline` is the schema-level
+ *  backstop.
+ *
+ *  Integrity backstops (throw TriggerArmError):
+ *   - empty/whitespace payload `body` for inbox_message/deadline_message → `empty_body`
+ *     (a `trigger_type='when'` inbox_message may omit body entirely instead —
+ *     that is the stdout-as-body case, not a violation).
+ *   - non-NULL `recur` on a deadline_message                              → `deadline_cannot_recur`.
+ *   - unknown `action_mode`                                               → `bad_action_mode`. */
+export declare function armTrigger(spec: ArmTriggerSpec): string;
+/** UPDATE the next fire time — clock recurrence advancement (the daemon settles
+ *  a recurring row to its next slot BEFORE enacting, crash-safe). */
+export declare function advanceTrigger(trigger_id: string, nextFireIso: string): void;
+/** DELETE one trigger by id — one-shot consumption (the daemon settles a
+ *  one-shot row BEFORE enacting, crash-safe). */
+/** Deletes the row and reports whether it actually removed a LIVE one (vs a
+ *  no-op on an already-gone trigger) — callers racing another consumer of the
+ *  same trigger (e.g. predicate-eval.ts's close handler racing a wall-clock
+ *  reaper's kill) use the return value to no-op instead of double-enacting. */
+export declare function consumeTrigger(trigger_id: string): boolean;
+/** DELETE one trigger by id — the explicit user/surface cancel. Idempotent:
+ *  0 rows ⇒ no error. Kills any in-flight predicate process group for this
+ *  trigger before deleting. */
+export declare function cancelTrigger(trigger_id: string): void;
+/** DELETE every trigger anchored to this node AND every detached trigger it
+ *  ARMED — deliberate close/reap. Hooked at transition('cancel'). */
+export declare function cancelTriggersFor(node_id: string): void;
+/** DELETE this node's one-shot self-alarms (recur IS NULL); node-anchored
+ *  recurring triggers SURVIVE — finalize is the instance finishing, not a
+ *  teardown of standing schedules. Hooked at transition('finalize'). */
+export declare function cancelSelfAlarms(node_id: string): void;
+/** DELETE this node's pending deadline(s) — cancel-on-wake. Hooked at
+ *  reviveNode, so the deadline always belongs to the dormancy left. */
+export declare function cancelDeadlinesFor(node_id: string): void;
+/** The daemon's per-tick due query for CLOCK triggers only (`at`/`every`/
+ *  `until` — predicate `when` triggers fire via next_eval_at, see
+ *  duePredicateTriggers): every row whose fire_at has arrived, in fire_at
+ *  order, with `payload` parsed into the typed union. Returns exactly ONE row
+ *  per recurring trigger regardless of missed slots — coalescing is structural. */
+export declare function dueClockTriggers(nowIso: string): Trigger[];
+/** List triggers for a scope (node / owner / subtree / due / canvas), `payload`
+ *  parsed as in dueClockTriggers. The subtree variant binds the id set with `?`
+ *  placeholders (mirroring listNodes — the codebase's one safe dynamic-IN
+ *  spot); ids are NEVER string-concatenated. The `due` scope is clock-only,
+ *  matching dueClockTriggers' filter. */
+export declare function listTriggers(scope: TriggerScope): Trigger[];
+/** True if the node has ANY pending self-anchored trigger (of any type).
+ *  Consumed by the stop-guard self-wake seam so a no-child poll node releases
+ *  dormant after arming instead of being nagged to finish. */
+export declare function hasPendingSelfTrigger(node_id: string): boolean;
+/** Predicate triggers due for evaluation: idle, `next_eval_at` arrived,
+ *  deterministic order (`next_eval_at`, then `created`, then `trigger_id` —
+ *  spec §Daemon behavior step 3). Capacity enforcement (max concurrent
+ *  canvas-wide / per-owner) is the daemon's job, not this query's. */
+export declare function duePredicateTriggers(nowIso: string): Trigger[];
+/** Atomically acquire the idle lease for one predicate evaluation: flips
+ *  `eval_state` to 'running' and records lease/pid metadata, but ONLY if the
+ *  row is still idle (the `WHERE eval_state = 'idle'` guard is the atomicity —
+ *  two daemons racing the same row can't both win). Returns whether THIS call
+ *  acquired it. */
+export declare function acquirePredicateLease(trigger_id: string, leaseOwner: string, pid: number, startedAtIso: string): boolean;
+/** The settled outcome of one predicate evaluation, to be recorded by
+ *  recordPredicateEvalResult. `exitCode` null means the evaluation timed out
+ *  (no exit was observed). */
+export interface PredicateEvalResult {
+    completedAtIso: string;
+    /** When the row should next be checked (completed_at + eval_every). */
+    nextEvalAtIso: string;
+    exitCode: number | null;
+    stderrTail: string | null;
+}
+/** Record a non-firing predicate evaluation result (exit non-zero, or a
+ *  per-eval timeout): releases the lease back to idle and schedules the next
+ *  check. Exit-0 (fire) is NOT recorded here — the spec's settle-before-enact
+ *  rule means a firing predicate is consumed (consumeTrigger) then enacted,
+ *  never left as an idle row. */
+export declare function recordPredicateEvalResult(trigger_id: string, result: PredicateEvalResult): void;
+/** Every predicate trigger currently marked 'running' — the daemon's stale-
+ *  lease recovery scan on restart checks each recorded `eval_pid` for
+ *  liveness and calls resetPredicateLease for any that's gone. */
+export declare function runningPredicateTriggers(): Trigger[];
+/** Reset a predicate trigger's lease back to idle without recording a result —
+ *  stale-lease recovery for a row whose recorded eval_pid is no longer alive
+ *  (the prior daemon instance died mid-evaluation). */
+export declare function resetPredicateLease(trigger_id: string): void;
+/** Predicate triggers whose WALL-CLOCK timeout has arrived, regardless of
+ *  eval_state (an in-flight evaluation past its own trigger's timeout_at is
+ *  still reaped — the caller kills the process group itself since this is a
+ *  read, not a mutation). Spec §Predicate triggers: "Wall-clock timeout_at
+ *  reached: consume and notify owner." */
+export declare function duePredicateTimeouts(nowIso: string): Trigger[];