@telora/daemon 0.22.245 → 0.22.289

package/dist/supervision/focus-delivery-aggregate-phase.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Focus delivery-aggregate phase derivation: the phase of a focus's execution
+ * workflow (kickoff -> coding -> verifying -> reviewing -> winding_down, or
+ * blocked), derived from its deliveries' execution statuses taken together.
+ *
+ * The focus workflow's stages represent what the team lead is doing right
+ * now, not the focus's intent lifecycle. Intent lives on
+ * product_focuses.status (proposed/active/complete/cancelled). Execution
+ * phase is derived from the focus's delivery aggregate and updated by the
+ * daemon as deliveries advance.
+ *
+ * Phase names match the workflow_stages.name values inserted by migration
+ * 20260503132446_focus_workflow_execution_phases.sql.
+ *
+ * Every execution status is classified by a TOTAL map, `STATUS_PHASE_CLASS`,
+ * keyed by the canonical `ExecutionStatus` set from @telora/daemon-core. Because
+ * it is a `Record<ExecutionStatus, PhaseClass>` object literal, adding a value to
+ * EXECUTION_STATUSES without giving it a class here is a genuine COMPILE ERROR
+ * (a Record literal missing a key fails `tsc`). The three exported classifier sets
+ * (ACTIVE/TERMINAL/CASCADABLE) are DERIVED from this map, so they have a single
+ * source and cannot silently omit a status. `pre_execution` statuses
+ * (draft/planning) are deliberately EXCLUDED from the phase denominator: they are
+ * not yet executable work, and counting them in `total` would make a finished
+ * aggregate report `kickoff`.
+ *
+ * An edge copy at supabase/functions/_shared/focus-delivery-aggregate-phase.ts mirrors this
+ * derivation with bare-string classifier sets (Deno cannot import
+ * @telora/daemon-core). The pair is held in lockstep by the twin parity test
+ * src/lib/__tests__/focus-delivery-aggregate-phase-parity.test.ts, which asserts both copies
+ * derive identical phases across an exhaustive status matrix. It lives in the
+ * ROOT vitest suite (not packages/daemon) on purpose: CI only runs root vitest,
+ * so that is the suite where a divergent edit to either copy actually fails CI.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (supervision/focus-delivery-aggregate-phase.ts).
+ */
+import type { ExecutionStatus } from '@telora/daemon-core';
+import { type ArmFacts } from './recorded-new-intent.js';
+export type FocusDeliveryAggregatePhase = 'kickoff' | 'coding' | 'verifying' | 'reviewing' | 'winding_down' | 'blocked';
+export interface FocusDeliveryAggregateMember {
+    executionStatus: string | null;
+}
+export interface FocusDeliveryAggregateInput {
+    deliveries: FocusDeliveryAggregateMember[];
+    reviewRequestedAt: string | Date | null;
+}
+/**
+ * Execution statuses that are NOT yet executable (draft/planning). Excluded from
+ * the phase denominator so a pre-execution delivery can never make a focus with
+ * finished work report `kickoff`.
+ */
+export declare const PRE_EXECUTION_STATUSES: ReadonlySet<ExecutionStatus>;
+export declare const ACTIVE_STATUSES: ReadonlySet<ExecutionStatus>;
+export declare const TERMINAL_STATUSES: ReadonlySet<ExecutionStatus>;
+export declare const CASCADABLE_STATUSES: ReadonlySet<ExecutionStatus>;
+export declare function deriveFocusDeliveryAggregatePhase(input: FocusDeliveryAggregateInput): FocusDeliveryAggregatePhase;
+/**
+ * A delivery is in a TERMINAL execution state when no further automated work
+ * will move it forward: it has passed the verify gate (`done`) or been
+ * `cancelled`. This reuses the single canonical TERMINAL_STATUSES set above
+ * (the same set deriveFocusDeliveryAggregatePhase counts for the settled `winding_down` phase),
+ * so "terminal" has exactly ONE definition in this package.
+ *
+ * `verify` and `verify_failed` are explicitly NOT terminal -- the verify gate
+ * may still route them back to `coding`, so a focus holding either is still a
+ * moving target, not settled. Non-canonical / null statuses are not terminal.
+ */
+export declare function isDeliveryTerminal(executionStatus: string | null | undefined): boolean;
+/**
+ * True iff the focus has SETTLED: it has at least one delivery AND every
+ * delivery is terminal ({done, cancelled}). A focus with zero deliveries is
+ * NOT settled -- nothing has been built to measure intent against. This is the
+ * same condition deriveFocusDeliveryAggregatePhase uses for `winding_down` (terminal === total,
+ * total > 0); callers gate steady-state-only work (e.g. the focus-loop audit
+ * spawn) on it so they sample residual error at the settle boundary rather than
+ * mid-slew while the team is still nulling error.
+ */
+export declare function areAllDeliveriesTerminal(deliveries: ReadonlyArray<{
+    executionStatus: string | null;
+}>): boolean;
+/**
+ * The set of statuses that mean a delivery is ACTUATING -- a team is actively
+ * nulling intent-vs-reality error on it right now. `coding` is the obvious case;
+ * `verify_failed` re-enters `coding` on the next tick, so it is mid-stroke too.
+ * `queued`/`planning` are PRE-actuation (work to be scoped, not yet being coded)
+ * and `verify`/`done`/`cancelled` are POST-actuation, so none of those actuate.
+ */
+export declare const ACTUATING_STATUSES: ReadonlySet<ExecutionStatus>;
+/**
+ * True iff the focus is at the FRONT OF A SCOPING ACT: it has pre-coding work to
+ * scope (at least one `queued`/`planning` delivery) AND nothing is actuating (no
+ * `coding`/`verify_failed` delivery). This is the gate the scope-time CRT
+ * self-refresh (audit-phase) fires on -- CRT-validation runs exactly when a
+ * scoping decision is about to READ the tree, and never while a team is
+ * mid-stroke (which would sample the team's transient, intended error as drift).
+ *
+ * It REPLACES the old all-terminal settle gate: a settled focus (all done) is
+ * NOT being scoped, so it no longer triggers an audit; a focus with queued work
+ * about to be decomposed into issues IS, so it does. The mid-stroke protection
+ * the settle gate provided is preserved by the "nothing actuating" clause,
+ * without the (contradictory-at-scope-time) requirement that ALL deliveries be
+ * terminal.
+ */
+export declare function isFocusEnteringScoping(deliveries: ReadonlyArray<{
+    id: string;
+    executionStatus: string | null;
+}>, 
+/**
+ * The focus's arm facts. Supplied => a delivery RECORDED as new intent under
+ * the live arm does NOT count as pre-coding work, so a run whose covered work
+ * has finished does not read as entering scoping again and re-fire the audit
+ * -- which would author more recorded intent, on a loop. Omitted => planning
+ * counts as it always has.
+ */
+armFacts?: ArmFacts | null): boolean;
+/**
+ * Every legal `(from, to)` phase pair `deriveFocusDeliveryAggregatePhase` can produce
+ * across consecutive daemon polls.
+ *
+ * The phase is a pure function of the delivery aggregate plus
+ * `review_requested_at`. Between polls, deliveries can be created,
+ * deleted, rescoped, paused, resumed, advanced through statuses, or
+ * iterated back to `coding` from any later status; `review_requested_at`
+ * can be set or cleared. As a result every pair `(A, B)` with `A !== B`
+ * across the six phases is reachable in principle. Examples:
+ *
+ *   verifying  -> coding        a delivery iterates back from verify
+ *   winding_down -> coding      a new delivery is added after completion
+ *   winding_down -> verifying   a new delivery enters in verify status
+ *   reviewing  -> verifying     review_requested_at is cleared
+ *   kickoff    -> verifying     fresh deliveries created already in verify
+ *   coding     -> winding_down  all active deliveries flip to done at once
+ *   blocked    -> winding_down  paused deliveries are cancelled
+ *   <any>      -> kickoff       all deliveries are deleted via rescoping
+ *
+ * The transition table in the focus workflow MUST contain a row for
+ * every pair listed here, otherwise `fireFocusTransitionTriggers`
+ * silently skips on legitimate phase jumps. Coverage is enforced by
+ * `packages/daemon/src/focus/transition-coverage.test.ts`.
+ */
+export declare const LEGAL_FOCUS_PHASE_PAIRS: ReadonlyArray<readonly [FocusDeliveryAggregatePhase, FocusDeliveryAggregatePhase]>;
+//# sourceMappingURL=focus-delivery-aggregate-phase.d.ts.map

package/dist/supervision/focus-delivery-aggregate-phase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-delivery-aggregate-phase.d.ts","sourceRoot":"","sources":["../../src/supervision/focus-delivery-aggregate-phase.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAuB,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAE9E,MAAM,MAAM,2BAA2B,GACnC,SAAS,GACT,QAAQ,GACR,WAAW,GACX,WAAW,GACX,cAAc,GACd,SAAS,CAAC;AAEd,MAAM,WAAW,4BAA4B;IAC3C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,2BAA2B;IAC1C,UAAU,EAAE,4BAA4B,EAAE,CAAC;IAC3C,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;CACzC;AAyCD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,eAAe,CAAoC,CAAC;AACrG,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,eAAe,CAA6B,CAAC;AACvF,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,eAAe,CAA+B,CAAC;AAC3F,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,eAAe,CAAyC,CAAC;AAEvG,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,2BAA2B,GAAG,2BAA2B,CA2DjH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAMtF;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,aAAa,CAAC;IAAE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,GAC5D,OAAO,CAGT;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,eAAe,CAG1D,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,aAAa,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AACzE;;;;;;GAMG;AACH,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,GACzB,OAAO,CAeT;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,uBAAuB,EAAE,aAAa,CACjD,SAAS,CAAC,2BAA2B,EAAE,2BAA2B,CAAC,CAiBjE,CAAC"}

package/dist/supervision/focus-delivery-aggregate-phase.js

@@ -0,0 +1,227 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/state-cascade/review-next-step.test.ts,
+//   packages/daemon/src/completion/state-cascade/review-window-winding-down-clear.test.ts,
+//   packages/daemon/src/focus/focus-reaches-review-with-held-delivery.test.ts,
+//   packages/daemon/src/focus/mixed-aggregate-review-gate.test.ts,
+//   packages/daemon/src/focus/parked-shortfall-spawn.test.ts,
+//   packages/daemon/src/focus/pending-spawn-review-next-step.test.ts,
+//   packages/daemon/src/focus/recorded-delivery-invisibility.test.ts,
+//   packages/daemon/src/focus/transition-coverage.test.ts,
+//   packages/daemon/src/integration/approved-head-gate-failure-respawn-regression.test.ts,
+//   packages/daemon/src/integration/approved-head-hold-release-regression.test.ts,
+//   packages/daemon/src/integration/failed-verdict-review-exit-respawn-regression.test.ts,
+//   packages/daemon/src/integration/failed-verdict-review-loop-regression.test.ts,
+//   packages/daemon/src/integration/verify-failure-rework-route.test.ts,
+//   packages/daemon/src/supervision/focus-delivery-aggregate-phase.test.ts,
+//   packages/daemon/src/supervision/unreviewed-settle-detector.test.ts
+// PINNED-BY-END
+import { isExecutionStatus, DELIVERY_STATUS } from '@telora/daemon-core';
+import { isRecordedNewIntent } from './recorded-new-intent.js';
+const STATUS_PHASE_CLASS = {
+    [DELIVERY_STATUS.DRAFT]: 'pre_execution',
+    [DELIVERY_STATUS.PLANNING]: 'pre_execution',
+    [DELIVERY_STATUS.QUEUED]: 'active',
+    [DELIVERY_STATUS.CODING]: 'active',
+    [DELIVERY_STATUS.VERIFY_FAILED]: 'active',
+    [DELIVERY_STATUS.VERIFY]: 'verify',
+    [DELIVERY_STATUS.DONE]: 'terminal',
+    [DELIVERY_STATUS.CANCELLED]: 'terminal',
+    [DELIVERY_STATUS.PAUSED]: 'paused',
+};
+/** Statuses in a given phase class, derived from the total map above. */
+function statusesInClass(...classes) {
+    const wanted = new Set(classes);
+    return new Set(Object.keys(STATUS_PHASE_CLASS).filter((s) => wanted.has(STATUS_PHASE_CLASS[s])));
+}
+/**
+ * Execution statuses that are NOT yet executable (draft/planning). Excluded from
+ * the phase denominator so a pre-execution delivery can never make a focus with
+ * finished work report `kickoff`.
+ */
+export const PRE_EXECUTION_STATUSES = statusesInClass('pre_execution');
+export const ACTIVE_STATUSES = statusesInClass('active');
+export const TERMINAL_STATUSES = statusesInClass('terminal');
+export const CASCADABLE_STATUSES = statusesInClass('verify', 'terminal');
+export function deriveFocusDeliveryAggregatePhase(input) {
+    const { deliveries, reviewRequestedAt } = input;
+    // The denominator is EXECUTABLE deliveries only -- pre_execution (draft/planning)
+    // and non-canonical/null statuses are not counted, so they cannot dilute a
+    // finished aggregate into `kickoff`.
+    let executable = 0;
+    let active = 0;
+    let terminal = 0;
+    let verify = 0;
+    let paused = 0;
+    for (const d of deliveries) {
+        const raw = d.executionStatus;
+        if (raw == null || !isExecutionStatus(raw))
+            continue;
+        const cls = STATUS_PHASE_CLASS[raw];
+        if (cls === 'pre_execution')
+            continue;
+        executable++;
+        switch (cls) {
+            case 'active':
+                active++;
+                break;
+            case 'verify':
+                verify++;
+                break;
+            case 'terminal':
+                terminal++;
+                break;
+            case 'paused':
+                paused++;
+                break;
+        }
+    }
+    // `kickoff` means exactly one thing -- nothing executable yet -- and is
+    // returned ONLY from this first branch, never as a catch-all guess for a
+    // mixed aggregate the branches below do not name. Every executable aggregate
+    // resolves to a deliberate phase; the final guard is provably unreachable and
+    // refuses (throws) rather than silently reporting the phase furthest from the
+    // truth.
+    if (executable === 0)
+        return 'kickoff';
+    if (paused === executable)
+        return 'blocked'; // all executable work halted
+    if (reviewRequestedAt && active === 0 && verify > 0)
+        return 'reviewing';
+    if (active > 0)
+        return 'coding'; // any in-flight work
+    if (verify > 0)
+        return 'verifying'; // reviewable work present, nothing active
+    if (paused > 0)
+        return 'blocked'; // remaining halted work, nothing progressing
+    if (terminal === executable)
+        return 'winding_down'; // all executable settled
+    // Unreachable: after the branches above, executable > 0 with active == 0,
+    // verify == 0 and paused == 0 implies every executable delivery is terminal,
+    // so `terminal === executable` has already returned. This guard makes the
+    // otherwise-impossible case fail LOUDLY (a new PhaseClass whose count is not
+    // summed here) instead of guessing `kickoff`. It never fires in practice; the
+    // daemon<->edge parity test proves no aggregate in the exhaustive matrix
+    // reaches it.
+    throw new Error(`deriveFocusDeliveryAggregatePhase: unclassified executable aggregate (executable=${executable}, ` +
+        `active=${active}, verify=${verify}, terminal=${terminal}, paused=${paused})`);
+}
+/**
+ * A delivery is in a TERMINAL execution state when no further automated work
+ * will move it forward: it has passed the verify gate (`done`) or been
+ * `cancelled`. This reuses the single canonical TERMINAL_STATUSES set above
+ * (the same set deriveFocusDeliveryAggregatePhase counts for the settled `winding_down` phase),
+ * so "terminal" has exactly ONE definition in this package.
+ *
+ * `verify` and `verify_failed` are explicitly NOT terminal -- the verify gate
+ * may still route them back to `coding`, so a focus holding either is still a
+ * moving target, not settled. Non-canonical / null statuses are not terminal.
+ */
+export function isDeliveryTerminal(executionStatus) {
+    return (executionStatus != null &&
+        isExecutionStatus(executionStatus) &&
+        TERMINAL_STATUSES.has(executionStatus));
+}
+/**
+ * True iff the focus has SETTLED: it has at least one delivery AND every
+ * delivery is terminal ({done, cancelled}). A focus with zero deliveries is
+ * NOT settled -- nothing has been built to measure intent against. This is the
+ * same condition deriveFocusDeliveryAggregatePhase uses for `winding_down` (terminal === total,
+ * total > 0); callers gate steady-state-only work (e.g. the focus-loop audit
+ * spawn) on it so they sample residual error at the settle boundary rather than
+ * mid-slew while the team is still nulling error.
+ */
+export function areAllDeliveriesTerminal(deliveries) {
+    if (deliveries.length === 0)
+        return false;
+    return deliveries.every((d) => isDeliveryTerminal(d.executionStatus));
+}
+/**
+ * The set of statuses that mean a delivery is ACTUATING -- a team is actively
+ * nulling intent-vs-reality error on it right now. `coding` is the obvious case;
+ * `verify_failed` re-enters `coding` on the next tick, so it is mid-stroke too.
+ * `queued`/`planning` are PRE-actuation (work to be scoped, not yet being coded)
+ * and `verify`/`done`/`cancelled` are POST-actuation, so none of those actuate.
+ */
+export const ACTUATING_STATUSES = new Set([
+    DELIVERY_STATUS.CODING,
+    DELIVERY_STATUS.VERIFY_FAILED,
+]);
+/**
+ * True iff the focus is at the FRONT OF A SCOPING ACT: it has pre-coding work to
+ * scope (at least one `queued`/`planning` delivery) AND nothing is actuating (no
+ * `coding`/`verify_failed` delivery). This is the gate the scope-time CRT
+ * self-refresh (audit-phase) fires on -- CRT-validation runs exactly when a
+ * scoping decision is about to READ the tree, and never while a team is
+ * mid-stroke (which would sample the team's transient, intended error as drift).
+ *
+ * It REPLACES the old all-terminal settle gate: a settled focus (all done) is
+ * NOT being scoped, so it no longer triggers an audit; a focus with queued work
+ * about to be decomposed into issues IS, so it does. The mid-stroke protection
+ * the settle gate provided is preserved by the "nothing actuating" clause,
+ * without the (contradictory-at-scope-time) requirement that ALL deliveries be
+ * terminal.
+ */
+export function isFocusEnteringScoping(deliveries, 
+/**
+ * The focus's arm facts. Supplied => a delivery RECORDED as new intent under
+ * the live arm does NOT count as pre-coding work, so a run whose covered work
+ * has finished does not read as entering scoping again and re-fire the audit
+ * -- which would author more recorded intent, on a loop. Omitted => planning
+ * counts as it always has.
+ */
+armFacts) {
+    if (deliveries.length === 0)
+        return false;
+    const hasPreCodingWork = deliveries.some((d) => d.executionStatus === DELIVERY_STATUS.QUEUED ||
+        (d.executionStatus === DELIVERY_STATUS.PLANNING && !isRecordedNewIntent(d, armFacts)));
+    if (!hasPreCodingWork)
+        return false;
+    const anyActuating = deliveries.some((d) => d.executionStatus != null &&
+        isExecutionStatus(d.executionStatus) &&
+        ACTUATING_STATUSES.has(d.executionStatus));
+    return !anyActuating;
+}
+/**
+ * Every legal `(from, to)` phase pair `deriveFocusDeliveryAggregatePhase` can produce
+ * across consecutive daemon polls.
+ *
+ * The phase is a pure function of the delivery aggregate plus
+ * `review_requested_at`. Between polls, deliveries can be created,
+ * deleted, rescoped, paused, resumed, advanced through statuses, or
+ * iterated back to `coding` from any later status; `review_requested_at`
+ * can be set or cleared. As a result every pair `(A, B)` with `A !== B`
+ * across the six phases is reachable in principle. Examples:
+ *
+ *   verifying  -> coding        a delivery iterates back from verify
+ *   winding_down -> coding      a new delivery is added after completion
+ *   winding_down -> verifying   a new delivery enters in verify status
+ *   reviewing  -> verifying     review_requested_at is cleared
+ *   kickoff    -> verifying     fresh deliveries created already in verify
+ *   coding     -> winding_down  all active deliveries flip to done at once
+ *   blocked    -> winding_down  paused deliveries are cancelled
+ *   <any>      -> kickoff       all deliveries are deleted via rescoping
+ *
+ * The transition table in the focus workflow MUST contain a row for
+ * every pair listed here, otherwise `fireFocusTransitionTriggers`
+ * silently skips on legitimate phase jumps. Coverage is enforced by
+ * `packages/daemon/src/focus/transition-coverage.test.ts`.
+ */
+export const LEGAL_FOCUS_PHASE_PAIRS = (() => {
+    const phases = [
+        'kickoff',
+        'coding',
+        'verifying',
+        'reviewing',
+        'winding_down',
+        'blocked',
+    ];
+    const pairs = [];
+    for (const from of phases) {
+        for (const to of phases) {
+            if (from !== to)
+                pairs.push([from, to]);
+        }
+    }
+    return pairs;
+})();
+//# sourceMappingURL=focus-delivery-aggregate-phase.js.map

package/dist/supervision/focus-delivery-aggregate-phase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-delivery-aggregate-phase.js","sourceRoot":"","sources":["../../src/supervision/focus-delivery-aggregate-phase.ts"],"names":[],"mappings":"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"}

package/dist/supervision/holds.d.ts

@@ -0,0 +1,218 @@
+/**
+ * The escalation dispositions that mean "a human operator or an external party
+ * must act before this delivery's declared work can be considered real":
+ * needs_operator (operator/infra/security action) and external_wait (blocked on
+ * a third party). Distinct from needs_intent / needs_clarification (a steering
+ * question, not a blocked-on-reality signal) and agent_resolvable (no human at
+ * all). Keyed on the DISPOSITION axis so ANY escalation kind carrying one of
+ * these holds its delivery -- the gate must not enumerate kinds.
+ *
+ * Declared as daemon-local string literals (not imported from @telora/daemon-core's
+ * ESCALATION_DISPOSITIONS) on purpose, mirroring MERGE_CONFLICT_ESCALATION_KIND
+ * below: a bare `@telora/*` VALUE import in a query module pulled into a mocked
+ * node:test fails to resolve under the module-mock loader (the daemon-local-copy
+ * rule). The canonical enum lives in packages/daemon-core/src/disposition.ts and
+ * the DB CHECK on agent_escalations.disposition is the real constraint; these
+ * strings must stay in sync with it.
+ */
+export declare const OPERATOR_HOLD_DISPOSITIONS: readonly string[];
+/**
+ * escalation_kind discriminators that are SELF-REFERENTIAL stall alarms: a
+ * machine-filed escalation ABOUT a delivery's own cycling, which must NOT be
+ * allowed to satisfy the operator-hold predicate that holds that same delivery.
+ *
+ * The fixpoint this removes (observed 2026-07-26, delivery 50131436, escalations
+ * 96262dfa -> 43c4dade): the verify_failed cap detector files
+ * verify_gate_unclearable (disposition needs_operator, anchored to the delivery)
+ * when iteration_count exceeds the cap. findOpenOperatorHoldForDelivery matched
+ * on disposition ONLY, so that alarm satisfied the very hold predicate it was
+ * raised about; the delivery was held out of `done`; `done` is the only
+ * non-cancelled terminal that makes exceedsVerifyFailedCap stop firing; and
+ * iteration_count is monotonic -- so the alarm blocked the only exit that would
+ * silence it, and resolving one let the detector file the next on the following
+ * tick.
+ *
+ * ENUMERATION -- every machine-filed, delivery-anchored needs_operator kind,
+ * tested against ONE governing rule ("A hold must name a human act", 2026-07-28):
+ * does the kind name a specific act ONLY a human can perform? A kind that names
+ * one is a GENUINE hold and stays. A kind that names none must NOT hold a
+ * delivery out of done: it is refused at its filing surface and routed into the
+ * machine's own bounded re-work path, and any legacy row is EXCLUDED from this
+ * predicate. (This rule GOVERNS -- it supersedes the older fixpoint-only test,
+ * which read a kind's legitimacy from its re-arm behaviour; the two disagreed on
+ * verify_evidence_unavailable and this rule is the one that wins.) The parallel
+ * self-referential-alarm exclusion still applies too: an alarm ABOUT a delivery's
+ * own cycling cannot constitute the hold it reports.
+ *
+ *   verify_gate_unclearable (stall-detectors.ts) -- SELF-REFERENTIAL. Trigger
+ *     (iteration_count) is monotonic and re-arms every tick while non-terminal;
+ *     silenced only by done/cancelled, which the hold blocks. It IS the sole
+ *     surviving human residue of the bounded re-work cap, and it names a human
+ *     act (an operator must decide the unclearable delivery's fate), so it holds
+ *     -- but it must not hold ITSELF, hence the exclusion below. EXCLUDE from the
+ *     predicate for its own delivery (SELF_REPORT_STALL_HOLD_KINDS).
+ *   verify_evidence_unavailable (verification-feedback.ts) -- NAMES NO HUMAN ACT.
+ *     Its ask was "fix the diff range / confirm the merge / clear the delivery" --
+ *     the gate reporting its own BLINDNESS, not work an operator must do. As of
+ *     "A hold must name a human act" it is refused at the filing surface (nothing
+ *     files it; the empty-bundle path re-enters bounded verify_failed re-work in
+ *     verification-engine/feedback) and any legacy open row is EXCLUDED here
+ *     (REFUSED_OPERATOR_HOLD_KINDS) so it cannot hold a delivery out of done.
+ *     REFUSED + ROUTED, no longer a hold.
+ *   schema_drift_blocked (focus-poller-auto-advance.ts) -- an operator must apply a
+ *     migration (a human-only act on external reality). KEEP.
+ *   advance_blocked (delivery-advance-block.ts) -- dirty worktree / lockfile
+ *     state an operator or agent must resolve on the host. KEEP.
+ *   cd_push_failed (ci-escalation.ts) -- external CD state a human must act on.
+ *     KEEP.
+ *   ci_run_red (ci-sensor-loop.ts) -- fixing a failing CI gate is CODING work,
+ *     so the sensor now files it as agent_resolvable anchored to a focus (the
+ *     machine's next coding pass resolves it), NOT needs_operator. A
+ *     needs_operator ci_run_red is only ever produced by the 24h agent_resolvable
+ *     promotion backstop once the machine has failed to clear it. It is also
+ *     focus-anchored (not delivery-anchored), so findOpenOperatorHoldForDelivery
+ *     -- which keys on deliveryId -- never matches it regardless of disposition;
+ *     the fail-closed integration->main merge gate (resolveCiMergeGate, reading
+ *     the git ref) is what holds main out on a red, independent of this filing.
+ *   propagation_stale (staleness-sensor.ts) -- external propagation state. KEEP.
+ *
+ * (Focus-anchored kinds -- merge_conflict, merge_refused_dirty,
+ * review_window_stalled, stuck_focus_branch -- are never matched by
+ * findOpenOperatorHoldForDelivery, which keys on deliveryId, so they need no
+ * exclusion here.)
+ *
+ * Daemon-local literal for the same reason as OPERATOR_HOLD_DISPOSITIONS above:
+ * a bare `@telora/*` value import mis-resolves under the node:test module-mock
+ * loader, and importing stall-detectors.VERIFY_GATE_UNCLEARABLE_KIND would also
+ * form an import cycle (stall-detectors imports from this module). Keep in sync
+ * with stall-detectors.VERIFY_GATE_UNCLEARABLE_KIND and the DB CHECK.
+ */
+export declare const SELF_REPORT_STALL_HOLD_KINDS: readonly string[];
+/**
+ * escalation_kind discriminators that are REFUSED at their filing surface and
+ * routed into the machine's own bounded re-work path because they NAME NO ACT
+ * ONLY A HUMAN CAN PERFORM ("A hold must name a human act", 2026-07-28). Nothing
+ * files these anymore, but a LEGACY row opened before the filing refusal deployed
+ * must not hold its delivery out of done -- so it is excluded from the
+ * operator-hold predicate here, and the delivery clears itself via re-work
+ * instead of parking on a human inbox.
+ *
+ *   verify_evidence_unavailable -- the verify gate reporting its own blindness
+ *     (empty judgeable bundle). Its ask named no human-only act; the empty-bundle
+ *     path now re-enters bounded verify_failed re-work (verification-feedback.ts
+ *     requeueEvidenceUnavailableAsRework), and verify_gate_unclearable (the
+ *     iteration cap) is the sole surviving human residue.
+ *
+ * Daemon-local string literal for the same node:test module-mock-loader reason as
+ * SELF_REPORT_STALL_HOLD_KINDS / OPERATOR_HOLD_DISPOSITIONS above.
+ */
+export declare const REFUSED_OPERATOR_HOLD_KINDS: readonly string[];
+/**
+ * escalation_kind discriminators whose filing reports a MACHINE STOP -- the daemon
+ * has halted something and the detector proposed the act that ends it. Read from
+ * the filing sites that name a humanAct and stop the machine; each stop is
+ * enforced where its row is read:
+ *
+ *   team_failure -- completion/stall-escalations/event-escalations.ts escalateNonAdvanceable and
+ *     escalateDeliveryAdvancementStalled. Enforced by the respawn guard
+ *     (focus/focus-respawn-guard.ts, via hasOpenTeamFailureEscalation).
+ *   respawn_cycle_exhausted -- spawn/respawn-cycle-escalation.ts. Enforced by the
+ *     durable spawn-cooldown `exhausted` latch (supervision/spawn-cooldown.ts), NOT by
+ *     this row: the respawn guard does not read the kind, so the halt is
+ *     disposition-independent, and the latch's spawn-independent recovery
+ *     (clearSpawnCooldown on an auto-advance) is never stranded behind a row that
+ *     nothing auto-resolves.
+ *   review_handoff_exhausted (zero findings) -- completion/review-exit/review-exit-escalations.ts.
+ *     Enforced by the state cascade's kind-keyed breaker hold (any disposition).
+ *
+ * Not a stop kind: review_coverage_incomplete names no act; it is a machine
+ * wait-state the coverage stabilizer clears, and the respawn guard reads it by
+ * kind regardless of disposition.
+ */
+export declare const MACHINE_STOP_KINDS: readonly string[];
+/**
+ * Pure: whether an escalation row is an OPEN machine-stop OBSERVATION -- a
+ * MACHINE_STOP_KINDS row (typed kind column, metadata.kind fallback) whose
+ * well-formed metadata.observation carries the detector's proposed_human_act.
+ *
+ * The ONE definition of "a machine-lane record that still stops the machine".
+ * The filing chokepoint sends every daemon filing to the machine lane, so a
+ * detector's named act no longer makes its row needs_operator; this predicate is
+ * what keeps that stop holding. The respawn guard's machine-lane exclusion keeps
+ * such a row blocking, and the routing decider treats it as immediately eligible
+ * (a stopped focus spawns no team to decide it). A stop-kind observation with NO
+ * proposed act is a plain record the incoming team resolves (TEL-2) -> false.
+ * Disposition-independent: a row an agent made human-facing (needs_operator,
+ * metadata.human_act) blocks on its disposition, not on this predicate.
+ */
+export declare function isMachineStopObservation(row: {
+    status?: string | null;
+    escalationKind?: string | null;
+    metadata?: Record<string, unknown> | null;
+}): boolean;
+/**
+ * Pure: whether an open escalation row HOLDS the focus's respawn (TEL-2) -- the
+ * predicate the respawn guard hands queries/escalations/escalations.ts
+ * hasOpenTeamFailureEscalation (the coverage lookup is deliberately not given
+ * it: that wait-state parks whatever its disposition). A MACHINE-owned (agent_resolvable) row is a
+ * RECORD the incoming team resolves, not a hold -- EXCEPT a machine-stop
+ * observation (isMachineStopObservation): the chokepoint sends every daemon
+ * filing agent_resolvable, so a detector that proposed the act ending its stop
+ * (non-advanceable, advancement-stalled) keeps blocking on that proposal. A null
+ * / needs_intent / needs_operator row (agent-filed or legacy) still holds.
+ */
+export declare function rowHoldsRespawn(row: {
+    status?: string | null;
+    escalationKind?: string | null;
+    metadata?: Record<string, unknown> | null;
+    disposition?: string | null;
+}): boolean;
+/** The open operator-hold escalation a delivery is blocked on (for gate_state). */
+export interface OperatorHoldEscalation {
+    id: string;
+    escalationKind: string | null;
+    /** The row's own disposition (agent_resolvable for an observation). */
+    disposition: string;
+    /**
+     * Present only when the hold is an OBSERVATION: the operator-hold disposition
+     * its detector proposed (metadata.observation.proposed_disposition).
+     */
+    proposedDisposition?: string;
+}
+/**
+ * Returns the OPEN (pending|in_review) operator-hold escalation anchored to the
+ * given delivery, or null when none is open.
+ *
+ * DISPOSITION-keyed sibling of hasOpenEscalationForDelivery (which is KIND-keyed):
+ * it matches ANY escalation_kind whose disposition is in OPERATOR_HOLD_DISPOSITIONS
+ * (needs_operator / external_wait), or that is an observation proposing one (see
+ * the module header). This is the vocabulary the verify->done gate
+ * previously lacked -- an operator blocked ON a delivery (e.g. "the host restore
+ * was NOT executed") could not hold that delivery out of done, so a clean review
+ * auto-approved it. Returning the matching row (id + kind + disposition), not a
+ * bare boolean, lets the gate write the block into the delivery's gate_state.
+ *
+ * Matches on the typed delivery_id + disposition COLUMNS in preference to the
+ * metadata bag, with a metadata fallback (metadata.deliveryId / metadata.disposition)
+ * for rows already open at deploy time. The status is re-checked client-side as
+ * defense-in-depth against a deploy-lagged edge fn returning resolved rows.
+ *
+ * escalation_list has NO server-side delivery_id filter, so the delivery match is
+ * applied client-side over the org's open rows. Pass `focusId` to narrow the page
+ * server-side (the same busy-org paging concern hasOpenWorktreeDirtyEscalation
+ * addresses); omit it and the lookup reads the newest 500 open org rows.
+ *
+ * FAIL-CLOSED is the CALLER's responsibility. This function reports what it finds
+ * and THROWS on a hard API error. The verify->done gate that consumes it exists
+ * precisely to fail closed, so it must treat a lookup error as "held" -- the
+ * opposite of the other escalation lookups (dedup/auto-close), which fail OPEN
+ * because a spurious park is worse than a missed dedup. Here a missed hold lets an
+ * operator-blocked delivery reach done, which is the failure this gate prevents.
+ */
+export declare function findOpenOperatorHoldForDelivery(deliveryId: string, focusId?: string): Promise<OperatorHoldEscalation | null>;
+/**
+ * Boolean convenience over findOpenOperatorHoldForDelivery for call sites that
+ * only need to know whether the hold exists (not which escalation it is).
+ */
+export declare function hasOpenOperatorHoldForDelivery(deliveryId: string, focusId?: string): Promise<boolean>;
+//# sourceMappingURL=holds.d.ts.map

package/dist/supervision/holds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"holds.d.ts","sourceRoot":"","sources":["../../src/supervision/holds.ts"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,MAAM,EAGvD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,MAAM,EAEzD,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,2BAA2B,EAAE,SAAS,MAAM,EAExD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAI/C,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE;IAC5C,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC3C,GAAG,OAAO,CAMV;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE;IACnC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1C,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,GAAG,OAAO,CAEV;AAED,mFAAmF;AACnF,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,+BAA+B,CACnD,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAWxC;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAElB"}