@telora/daemon 0.21.12 → 0.21.81

package/dist/circuit-wedge-watcher.js

@@ -1,94 +0,0 @@
-/**
- * Wedged-circuit watcher (Daemon Resilience Hardening, injection #13).
- *
- * Periodically inspects the control-plane circuit breakers and, when one has
- * been held open past a threshold, emits an error-severity health event naming
- * the wedged circuit. Without this signal the daemon can sit silently idle --
- * exactly the 2026-05-28 incident, where a control-plane circuit stayed open
- * ~2h and no team could spawn, with nothing surfacing the cause to the operator.
- *
- * Open-duration is tracked here (by sampling getState()) rather than inside the
- * breaker, so the watcher depends only on the already-published CircuitBreaker
- * surface and all new logic lives in the daemon package.
- */
-import { healthEvents, safeInterval } from '@telora/daemon-core';
-import { getApiCircuitBreakers, CONCERN_CLASS } from './queries/shared.js';
-/** Default: a control-plane circuit open continuously this long is "wedged". */
-const DEFAULT_WEDGE_THRESHOLD_MS = 120_000;
-/** Default polling cadence for the watcher. */
-const DEFAULT_CHECK_INTERVAL_MS = 30_000;
-export function createWedgeTracking() {
-    return { openSince: new Map(), reported: new Set() };
-}
-/**
- * Inspect control-plane breakers and return the concerns NEWLY detected as
- * wedged (open continuously >= thresholdMs and not yet reported this episode).
- *
- * Pure with respect to `now` (injectable clock) and `tracking` (caller-owned
- * state), so it is unit-testable with a simulated clock and a real
- * CircuitBreaker. Fires once per wedge episode; a recovery (breaker closes)
- * clears the tracking so a later wedge re-fires.
- */
-export function detectWedgedControlPlaneCircuits(breakers, concernClass, thresholdMs, tracking, now = Date.now()) {
-    const newlyWedged = [];
-    for (const [concern, breaker] of Object.entries(breakers)) {
-        if (concernClass[concern] !== 'control-plane')
-            continue;
-        const isOpen = breaker.getState() !== 'closed';
-        if (!isOpen) {
-            // Recovered (or never open): end the episode so a future wedge re-fires.
-            tracking.openSince.delete(concern);
-            tracking.reported.delete(concern);
-            continue;
-        }
-        if (!tracking.openSince.has(concern)) {
-            tracking.openSince.set(concern, now);
-        }
-        const openSince = tracking.openSince.get(concern) ?? now;
-        if (now - openSince >= thresholdMs && !tracking.reported.has(concern)) {
-            tracking.reported.add(concern);
-            newlyWedged.push(concern);
-        }
-    }
-    return newlyWedged;
-}
-/**
- * Emit an error-severity health event for each newly-wedged concern. The event
- * flows into heartbeat metadata for dashboard visibility (the operator signal).
- */
-export function emitWedgedCircuitHealthEvents(concerns) {
-    for (const concern of concerns) {
-        healthEvents.emit({
-            severity: 'error',
-            source: `circuit:${concern}`,
-            code: 'circuit.wedged',
-            message: `Control-plane circuit '${concern}' has been open past the wedge threshold; ` +
-                `control-plane actions (e.g. session creation) are blocked. Investigate the ` +
-                `upstream failure or force-close all breakers (SIGUSR2).`,
-        });
-    }
-}
-let tracking = createWedgeTracking();
-let timer = null;
-/**
- * Start the periodic wedged-circuit watcher. Idempotent-ish: a prior timer is
- * cleared first. The interval body is wrapped by safeInterval so a throw cannot
- * crash the process.
- */
-export function startCircuitWedgeWatcher(opts) {
-    const thresholdMs = opts?.thresholdMs ?? DEFAULT_WEDGE_THRESHOLD_MS;
-    const intervalMs = opts?.intervalMs ?? DEFAULT_CHECK_INTERVAL_MS;
-    stopCircuitWedgeWatcher();
-    tracking = createWedgeTracking();
-    timer = safeInterval(() => {
-        const wedged = detectWedgedControlPlaneCircuits(getApiCircuitBreakers(), CONCERN_CLASS, thresholdMs, tracking);
-        emitWedgedCircuitHealthEvents(wedged);
-    }, intervalMs, 'circuit-wedge-watcher');
-}
-export function stopCircuitWedgeWatcher() {
-    if (timer) {
-        clearInterval(timer);
-        timer = null;
-    }
-}
-//# sourceMappingURL=circuit-wedge-watcher.js.map

package/dist/circuit-wedge-watcher.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"circuit-wedge-watcher.js","sourceRoot":"","sources":["../src/circuit-wedge-watcher.ts"],"names":[],"mappings":"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"}

package/dist/close-loop-dispatcher.d.ts

@@ -1,325 +0,0 @@
-/**
- * Close-loop stage dispatcher.
- *
- * Handles focuses entering the `close_loop` workflow stage. Three asymmetric
- * checks are delegated to the spawned bookkeeper team via the assembled
- * directive; the dispatcher itself is responsible for the deterministic
- * pre- and post-conditions:
- *
- *   - **Short-circuit on no anchors.** If the focus has no anchoring
- *     injections, close_loop is a no-op: the dispatcher advances the focus
- *     directly to `done`. No team is spawned. This matches the
- *     `no_anchoring_injections_short_circuit` soft guard on
- *     `verify -> close_loop` in the focus workflow.
- *
- *   - **Otherwise, spawn a fresh bookkeeper team** (Sonnet model, fresh
- *     session) with the close_loop assembly recipe:
- *         loop.persona(variant=close_loop)
- *         focus.context
- *         focus.anchoring_injections
- *         git.diff_against_base
- *         delivery.acceptance_criteria
- *         review.outcomes
- *     The team handles the per-injection sweep (verified | escalated, no
- *     third option), the incomplete-planning check, and the tree-drift
- *     check skeleton (D5 wires `focus.description` through into the
- *     drift-check prompt section).
- *
- *   - **Monitor termination.** Once every anchored injection has reached a
- *     terminal state (`verified` or has an open `injection_unverified`
- *     escalation), the dispatcher advances the focus to `done`. While any
- *     injection is still non-terminal, the focus stays at `close_loop`.
- *
- * The dispatcher is intentionally split into small pure helpers so each
- * deterministic check (terminal classification, short-circuit detection,
- * directive composition) is unit-testable without DB or process spawning.
- */
-import type { DaemonConfig, StageDirective } from './types.js';
-import type { FocusDeliveryInfo } from './types.js';
-/**
- * Model used by close_loop bookkeeper teams. Sonnet because the bookkeeper
- * is a careful, deterministic role (sweep injections, file escalations);
- * Opus would be overkill and slower.
- */
-export declare const CLOSE_LOOP_MODEL = "claude-sonnet-4-6";
-/**
- * Assembly recipe for the close_loop stage. Composed in dispatcher when
- * the close_loop directive is synthesized. Persisted nowhere -- the
- * stage's stored `agent_directive` (if any) is ignored in favor of this
- * canonical recipe so the bookkeeper framing is deterministic regardless
- * of how the workflow stage row was seeded.
- */
-export declare const CLOSE_LOOP_ASSEMBLY_RECIPE: readonly string[];
-/**
- * Terminal injection statuses for close_loop. An injection is considered
- * terminal when it is either verified (the bookkeeper called
- * reality_tree_injection_verify) or has an `injection_unverified`
- * escalation filed against it. The first is detected by `injectionStatus`;
- * the second is detected by walking the agent_escalations table -- see
- * `isInjectionEscalated`.
- */
-export declare const TERMINAL_INJECTION_STATUSES: readonly string[];
-/**
- * Return the deliveries in the focus that anchor an injection.
- *
- * A delivery anchors an injection when `injection_id` (a column on
- * org_nodes rows of type='delivery', see migration
- * 20260510152110_add_injection_id_to_product_deliveries.sql) points at a
- * reality_tree_nodes row.
- */
-export declare function getAnchoringDeliveries(deliveries: FocusDeliveryInfo[]): FocusDeliveryInfo[];
-/**
- * Pure short-circuit predicate -- "does this focus have any anchoring
- * injections?". If false, close_loop is a no-op and the focus can advance
- * directly to `done`.
- */
-export declare function shouldShortCircuitToDone(deliveries: FocusDeliveryInfo[]): boolean;
-/**
- * Per-injection summary used by termination checks. The dispatcher composes
- * one of these per anchored injection from a snapshot of:
- *
- *   - the injection node's `injectionStatus` (from reality_tree_nodes)
- *   - whether there is an open `injection_unverified` escalation with
- *     metadata.injection_id == this injection id (from agent_escalations)
- */
-export interface InjectionTerminalState {
-    injectionId: string;
-    /** From reality_tree_nodes.injection_status (or null for non-injection nodes). */
-    injectionStatus: string | null;
-    /** Whether an open injection_unverified escalation targets this injection. */
-    hasOpenUnverifiedEscalation: boolean;
-}
-/**
- * Pure classifier. An injection is terminal for close_loop when:
- *
- *   - injectionStatus is `verified`, OR
- *   - there is an open `injection_unverified` escalation for it
- *     (this is the "escalated" outcome -- the bookkeeper filed the
- *     escalation and the focus is now blocked on a human).
- *
- * The "open escalation" case keeps the focus at close_loop (status='pending'
- * or 'in_review') -- this function classifies the escalation as terminal
- * for the dispatcher's perspective so the daemon does not loop forever
- * re-spawning the bookkeeper. A human must resolve or dismiss the
- * escalation; once resolved, the bookkeeper can be re-triggered.
- */
-export declare function isInjectionTerminal(state: InjectionTerminalState): boolean;
-/**
- * Pure aggregate predicate -- "are ALL anchored injections terminal?".
- * Returns true on an empty list (the short-circuit branch handles the
- * empty case separately, but this is safe to call after the short-circuit
- * filter).
- */
-export declare function allInjectionsTerminal(states: InjectionTerminalState[]): boolean;
-/**
- * One entry in the planned sweep: an injection that should be verified and
- * the evidence text to persist with the verify call.
- */
-export interface InjectionSweepEntry {
-    injectionId: string;
-    evidence: string;
-}
-/**
- * Pure planner. Given the focus's anchored deliveries and a snapshot of each
- * injection's current status, return the list of injections to verify and
- * the evidence text to attach.
- *
- * An injection is swept when ALL of:
- *   - its current `injectionStatus` is NOT 'verified'
- *   - at least one delivery anchoring it has executionStatus in the
- *     "closed successfully" set ('done', forward-compat 'verified').
- *
- * Injections backed only by cancelled / in-flight deliveries -- or with no
- * anchoring delivery in `anchored` at all -- are skipped (criterion 3 of the
- * close-loop sweep contract).
- *
- * Evidence text cites the first closed-and-successful anchoring delivery's
- * name and id so future audit reads can trace which delivery realized the
- * injection.
- */
-export declare function planInjectionSweep(anchored: FocusDeliveryInfo[], statusByInjectionId: ReadonlyMap<string, string | null>): InjectionSweepEntry[];
-/**
- * Outcome of running the planned sweep against a `verify` callable. Pure
- * with respect to side effects -- the `verify` argument owns the actual
- * I/O so tests can pass a stub.
- *
- * `ok === true` means every entry verified; `ok === false` means the loop
- * stopped at `failedAt.injectionId`. The dispatcher MUST NOT advance the
- * focus to 'done' when `ok` is false -- a partial sweep means the tree is
- * still in an inconsistent state and the next poll cycle should retry.
- */
-export interface SweepRunOutcome {
-    ok: boolean;
-    verified: string[];
-    failedAt?: {
-        injectionId: string;
-        error: Error;
-    };
-}
-/**
- * Execute a planned sweep in order. Short-circuits on the first failure --
- * the dispatcher returns the original `advance_to_done` decision without
- * calling `updateFocusStage`, so the failed verify is retried on the next
- * close_loop poll cycle.
- */
-export declare function executeSweep(entries: readonly InjectionSweepEntry[], verify: (injectionId: string, evidence: string) => Promise<void>): Promise<SweepRunOutcome>;
-/**
- * Dependencies for advancing a focus from close_loop -> done with a
- * preceding injection sweep. Both are owned by callers so tests can stub
- * them without mocking the daemon's I/O layer.
- */
-export interface AdvanceToDoneDeps {
-    verify: (injectionId: string, evidence: string) => Promise<void>;
-    updateFocusStage: (focusId: string, stage: 'done') => Promise<void>;
-}
-/**
- * Outcome of `advanceFocusToDoneWithSweep`. The dispatcher reads this to
- * decide whether to clear the bookkeeper-spawned flag (which is cleared
- * only when the focus actually leaves close_loop, success or terminal
- * failure).
- *
- *  - `advanced=true`  -- updateFocusStage was called and returned
- *  - `sweepFailure` set -- the sweep failed; updateFocusStage was NOT
- *    called; the focus is held at close_loop for the next poll cycle to
- *    retry. This is the explicit "focus does not advance" semantics from
- *    AC-6 of the focus-closure-correctness focus.
- *  - `advanceError` set -- the sweep succeeded (or was empty) but
- *    updateFocusStage threw. The focus did not advance, but the failure
- *    is on the stage-update side, not the sweep side.
- */
-export interface AdvanceToDoneOutcome {
-    advanced: boolean;
-    verifiedCount: number;
-    planSize: number;
-    sweepFailure?: {
-        injectionId: string;
-        error: Error;
-    };
-    advanceError?: Error;
-}
-/**
- * Run the close_loop sweep, then advance the focus to `done`. Pure with
- * respect to side effects -- callers inject `verify` and
- * `updateFocusStage` via `deps`.
- *
- * Order of operations is part of the contract:
- *   1. Build the sweep plan from `anchored` + `statusByInjectionId`.
- *   2. If non-empty, run the sweep. On failure: log + return early WITHOUT
- *      calling `deps.updateFocusStage`. This is the "focus does not
- *      advance" invariant — the failed verify is retried on the next poll
- *      cycle when the focus is re-evaluated.
- *   3. On sweep success (or empty plan), call `deps.updateFocusStage`.
- *
- * The dispatcher (`dispatchCloseLoopStage`) delegates the entire
- * advance_to_done branch to this function so the sweep-failure path is
- * unit-testable without DB or process mocking.
- */
-export declare function advanceFocusToDoneWithSweep(focus: {
-    focus_id: string;
-    focus_name: string;
-}, anchored: FocusDeliveryInfo[], statusByInjectionId: ReadonlyMap<string, string | null>, deps: AdvanceToDoneDeps): Promise<AdvanceToDoneOutcome>;
-/**
- * Compose the synthetic close_loop StageDirective. Used by the dispatcher
- * to seed the pending spawn directive map; pure for testability.
- */
-export declare function buildCloseLoopDirective(): StageDirective;
-/**
- * Query: are there any pending or in_review injection_unverified escalations
- * for the given injection ids? Returns the set of injection ids that have
- * an open escalation.
- *
- * Looks at agent_escalations with:
- *   - escalation_kind = 'injection_unverified'
- *   - status IN ('pending', 'in_review')
- *   - metadata->>'injection_id' IN (...)
- *
- * The dispatcher uses this to classify "escalated" injections as terminal
- * for advancement purposes.
- */
-export interface OpenInjectionEscalationLookup {
-    (params: {
-        organizationId: string;
-        injectionIds: string[];
-    }): Promise<Set<string>>;
-}
-/**
- * Top-level result of inspecting a focus for close_loop termination.
- * Tells the caller exactly what to do: short-circuit, spawn, advance to
- * done, or hold.
- */
-export type CloseLoopDecision = {
-    kind: 'short_circuit_to_done';
-} | {
-    kind: 'spawn_bookkeeper';
-    directive: StageDirective;
-} | {
-    kind: 'advance_to_done';
-} | {
-    kind: 'hold';
-    reason: string;
-};
-/**
- * Compute the close_loop decision for a focus given a snapshot of its
- * deliveries and the terminal state of each anchored injection.
- *
- * Pure -- no DB access. Tests pass snapshots in.
- *
- * Semantics:
- *
- *   - No anchored injections                -> short_circuit_to_done
- *   - Anchored injections, none yet sweeped -> spawn_bookkeeper
- *   - All anchored injections terminal      -> advance_to_done
- *   - Some terminal, some not               -> hold (waiting on bookkeeper)
- *
- * The "spawn_bookkeeper" branch is gated on "no sweep has happened yet"
- * which the caller communicates via `bookkeeperHasRun`. Without this gate
- * every poll cycle would respawn the bookkeeper while it's still working
- * (or before a stuck injection's escalation is filed).
- */
-export declare function decideCloseLoop(deliveries: FocusDeliveryInfo[], injectionStates: InjectionTerminalState[], bookkeeperHasRun: boolean): CloseLoopDecision;
-/**
- * Sentinel returned by the dispatcher when no action was taken (focus is
- * not in close_loop stage, or already processed this cycle). Caller can
- * log it but should not act on it.
- */
-export interface CloseLoopDispatchOutcome {
-    decision: CloseLoopDecision;
-    /** Anchored injection ids that were inspected (empty on short-circuit). */
-    anchoredInjectionIds: string[];
-}
-/**
- * Re-exported constant set so tests can assert the kind names used by the
- * dispatcher in the agent_escalations rows. Keeps the kind string under
- * a single source of truth in daemon-core.
- */
-export declare const CLOSE_LOOP_ESCALATION_KINDS: {
-    readonly INJECTION_UNVERIFIED: "injection_unverified";
-    readonly TREE_DRIFT: "tree_drift";
-    readonly INCOMPLETE_PLANNING: "incomplete_planning";
-};
-/**
- * Configuration knobs accepted by the dispatcher entry point. Exposed so
- * tests can inject a no-op spawner.
- */
-export interface CloseLoopDispatcherDeps {
-    /**
-     * Set the pending spawn directive for the focus so the next spawn cycle
-     * delivers the close_loop directive. In production this is the export
-     * from directive-executor; in tests this is a stub.
-     */
-    setPendingSpawnDirective: (focusId: string, directive: {
-        message: string;
-        model: string | null;
-        sessionType: 'coding' | 'review';
-        contentHash: string;
-    }) => void;
-    /** Advance the focus stage on product_focuses.stage. */
-    updateFocusStage: (focusId: string, stage: string) => Promise<void>;
-    /** Lookup open injection_unverified escalations. */
-    lookupOpenInjectionEscalations: OpenInjectionEscalationLookup;
-    /** Build the directive content (assembly resolution + prompt). */
-    assembleDirectiveContent: (config: DaemonConfig, focusId: string, directive: StageDirective, worktreePath: string | null) => Promise<string>;
-    /** Compute the content hash for the synthesized directive. */
-    computeDirectiveHash: (directive: StageDirective) => string;
-}
-//# sourceMappingURL=close-loop-dispatcher.d.ts.map

package/dist/close-loop-dispatcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"close-loop-dispatcher.d.ts","sourceRoot":"","sources":["../src/close-loop-dispatcher.ts"],"names":[],"mappings":"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"}