@telora/daemon 0.22.85 → 0.22.91

package/dist/queries/filing-observation.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The three shapes of act only a human can perform:
+ *  - irreversible: an act that cannot be undone by the machine (delete prod data,
+ *    rotate a shared secret, cancel a contract).
+ *  - outward: an act that leaves the system boundary (publish to a shared
+ *    registry, send to a customer, deploy to prod).
+ *  - unreachable_capability: a capability no agent session can reach (a
+ *    credential it does not hold, operator-only control-plane state, an armed
+ *    focus that does not exist).
+ */
+export type HumanActKind = 'irreversible' | 'outward' | 'unreachable_capability';
+/** The specific act a filing names -- from a detector, a PROPOSAL; from an agent, the human-facing act. */
+export interface HumanAct {
+    kind: HumanActKind;
+    /** The act itself, imperative and specific -- NOT the condition that contains it. */
+    act: string;
+}
+/**
+ * The explicit "no act named" marker a filing site passes as `humanAct` when its
+ * detector proposes a human owner (needs_operator) but can name no act only a
+ * human can perform. Spelling it out at the call site (rather than omitting the
+ * field) keeps each detector's proposal visible and lets the disposition scan
+ * gate require every needs_operator filing to carry a `humanAct` property. Named
+ * act or not, the chokepoint files the filing as an OBSERVATION.
+ */
+export declare const NO_HUMAN_ACT: null;
+/** metadata.observation: what a detector reported, and the routing it proposed. */
+export interface FilingObservation {
+    /** The disposition the detector asked for (its guess, not a routing decision). */
+    proposed_disposition: string;
+    /** A short head of the reported condition (first line of the description). */
+    condition: string;
+    /** The human act the detector named, if any (a proposal the deciding agent weighs). */
+    proposed_human_act?: HumanAct;
+}
+/** Cap on the stored condition head. */
+export declare const OBSERVATION_CONDITION_MAX = 200;
+/** Cap on a named act (a human-facing row leads its description with it, so it must leave room for the body). */
+export declare const HUMAN_ACT_MAX = 1000;
+/** Pure: the first non-blank line of a description, trimmed and capped. */
+export declare function conditionHead(description: string | null | undefined): string;
+/**
+ * Pure: narrow an unknown value to a named HumanAct -- a known kind and a
+ * non-blank act (trimmed, capped). Anything else is "no act named" (null).
+ */
+export declare function readHumanAct(value: unknown): HumanAct | null;
+/** Pure: narrow a row's metadata bag to its observation, when it carries a well-formed one. */
+export declare function readObservation(metadata: unknown): FilingObservation | null;
+/** The filing fields the routing rule reads and may rewrite. */
+export interface FilingRouteInput {
+    disposition?: string;
+    description: string;
+    helpNeeded?: string;
+    metadata?: Record<string, unknown>;
+    /** The detector's proposed human act -- carried into the observation, never routed on. */
+    humanAct?: HumanAct | null;
+}
+/** The routed filing: what createEscalation actually sends. */
+export interface FilingRoute {
+    /** agent_resolvable, or undefined when the filing named no disposition. Never a human-owning value. */
+    disposition: string | undefined;
+    description: string;
+    helpNeeded: string | undefined;
+    metadata: Record<string, unknown> | undefined;
+    /** Which branch of the rule applied (for logging + tests). There is no human-facing branch. */
+    route: 'observation' | 'pass_through';
+}
+/**
+ * Pure: lead a description with the named act, fitting the result under `cap`.
+ * The canonical lead-line format of a filing an AGENT made human-facing (the MCP
+ * escalate surface mirrors this template byte-for-byte and pins it against this
+ * source); the daemon chokepoint does not apply it.
+ */
+export declare function leadWithHumanAct(act: HumanAct, description: string, cap: number): string;
+/**
+ * Pure: apply the chokepoint routing rule (see the module header) to one filing.
+ * `_descriptionCap` (the server-side ESCALATION_DESCRIPTION_MAX createEscalation
+ * passes) is unused: no route rewrites the description any more. It stays in the
+ * signature so the createEscalation call site is unchanged.
+ */
+export declare function routeFilingDisposition(input: FilingRouteInput, _descriptionCap?: number): FilingRoute;
+//# sourceMappingURL=filing-observation.d.ts.map

package/dist/queries/filing-observation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filing-observation.d.ts","sourceRoot":"","sources":["../../src/queries/filing-observation.ts"],"names":[],"mappings":"AA6DA;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG,SAAS,GAAG,wBAAwB,CAAC;AAEjF,2GAA2G;AAC3G,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,qFAAqF;IACrF,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,MAAO,CAAC;AAEjC,mFAAmF;AACnF,MAAM,WAAW,iBAAiB;IAChC,kFAAkF;IAClF,oBAAoB,EAAE,MAAM,CAAC;IAC7B,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAC;IAClB,uFAAuF;IACvF,kBAAkB,CAAC,EAAE,QAAQ,CAAC;CAC/B;AAID,wCAAwC;AACxC,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,iHAAiH;AACjH,eAAO,MAAM,aAAa,OAAO,CAAC;AAMlC,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAG5E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,CAM5D;AAED,+FAA+F;AAC/F,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,GAAG,iBAAiB,GAAG,IAAI,CAY3E;AAED,gEAAgE;AAChE,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC5B;AAED,+DAA+D;AAC/D,MAAM,WAAW,WAAW;IAC1B,uGAAuG;IACvG,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAC9C,+FAA+F;IAC/F,KAAK,EAAE,aAAa,GAAG,cAAc,CAAC;CACvC;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAMxF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,gBAAgB,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,WAAW,CAyBrG"}

package/dist/queries/filing-observation.js

@@ -0,0 +1,157 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/ci/ci-escalation.test.ts, packages/daemon/src/ci/ci-sensor-loop.test.ts,
+//   packages/daemon/src/directive/directive-executor.test.ts,
+//   packages/daemon/src/focus-stage-lifecycle/wedge-watchdog.test.ts,
+//   packages/daemon/src/merge/dirty-worktree-merge-refusal.test.ts,
+//   packages/daemon/src/merge/merge-back-loop.test.ts,
+//   packages/daemon/src/merge/merge-conflict-escalation-dedup.test.ts,
+//   packages/daemon/src/queries/filing-chokepoint.test.ts, packages/daemon/src/shell/crash-recovery.test.ts
+// PINNED-BY-END
+/**
+ * The filing chokepoint's routing rule: detectors REPORT conditions; the daemon
+ * has NO human-facing route. Only an agent that has assembled the intent ladder
+ * makes a filing human-facing, through the MCP escalate surface.
+ *
+ * Deterministic detectors used to assign the human-facing disposition
+ * themselves (needs_operator / external_wait / needs_intent / needs_clarification),
+ * and a detector that attached a `humanAct` reached the operator inbox directly,
+ * before anything able to climb the intent ladder had examined the condition.
+ * The worked example (2026-09-11, delivery e8e8fa15): a needs_operator filing
+ * whose three remediations were two plain machine tasks (bump a root pin,
+ * regenerate a lockfile) and ONE authority act (publish an unpublished package
+ * to the shared registry). The human was handed the whole condition instead of
+ * the one act, and no agent had judged whether even that act was the human's.
+ *
+ * routeFilingDisposition is applied inside queries/escalations.ts createEscalation,
+ * so every daemon filing path (fileEscalationIdempotent, fileEscalation, direct
+ * callers) inherits it:
+ *
+ *  - ANY disposition other than agent_resolvable (needs_operator, external_wait,
+ *    needs_intent, needs_clarification -- and any value added later) -> sent
+ *    agent_resolvable as an OBSERVATION: metadata.observation =
+ *    { proposed_disposition, condition, proposed_human_act? }. The detector's
+ *    named `humanAct`, when it passed one, travels as proposed_human_act -- a
+ *    PROPOSAL for the deciding agent, never a routing decision. Description and
+ *    helpNeeded are the condition as filed, unchanged.
+ *  - agent_resolvable / no disposition -> untouched (a humanAct on them is ignored).
+ *
+ * The rule is by EXCLUSION (everything that is not already machine-lane enters
+ * the machine lane), so no branch here can return a human-owning disposition,
+ * and this module names none: queries/detector-disposition-gate.test.ts fails
+ * if the source regains one, and queries/filing-chokepoint.test.ts feeds every
+ * disposition value through the rule.
+ *
+ * This module does NOT write metadata.human_act. That key marks a row an AGENT
+ * made human-facing through the MCP escalate surface
+ * (mcp/telora-products/src/handlers/agentHandlers.ts), which leads the
+ * description with leadWithHumanAct's format (kept here as the canonical
+ * template that surface mirrors and pins).
+ *
+ * Why the call-site `humanAct` still exists: every daemon needs_operator filing
+ * states it (a named act or NO_HUMAN_ACT), so each detector's proposal stays
+ * visible at the site and in the observation the deciding agent reads.
+ *
+ * Pure and dependency-light (no daemon-core VALUE import -- see the mock-loader
+ * note in queries/escalation-dispositions.ts). Types live daemon-side because
+ * @telora/daemon-core is registry-installed.
+ */
+import { DISPOSITION_AGENT_RESOLVABLE } from './escalation-dispositions.js';
+/**
+ * The explicit "no act named" marker a filing site passes as `humanAct` when its
+ * detector proposes a human owner (needs_operator) but can name no act only a
+ * human can perform. Spelling it out at the call site (rather than omitting the
+ * field) keeps each detector's proposal visible and lets the disposition scan
+ * gate require every needs_operator filing to carry a `humanAct` property. Named
+ * act or not, the chokepoint files the filing as an OBSERVATION.
+ */
+export const NO_HUMAN_ACT = null;
+const HUMAN_ACT_KINDS = new Set(['irreversible', 'outward', 'unreachable_capability']);
+/** Cap on the stored condition head. */
+export const OBSERVATION_CONDITION_MAX = 200;
+/** Cap on a named act (a human-facing row leads its description with it, so it must leave room for the body). */
+export const HUMAN_ACT_MAX = 1000;
+function capText(text, max) {
+    return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+/** Pure: the first non-blank line of a description, trimmed and capped. */
+export function conditionHead(description) {
+    const first = (description ?? '').split('\n').map((l) => l.trim()).find((l) => l.length > 0) ?? '';
+    return capText(first, OBSERVATION_CONDITION_MAX);
+}
+/**
+ * Pure: narrow an unknown value to a named HumanAct -- a known kind and a
+ * non-blank act (trimmed, capped). Anything else is "no act named" (null).
+ */
+export function readHumanAct(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const v = value;
+    if (typeof v.kind !== 'string' || !HUMAN_ACT_KINDS.has(v.kind))
+        return null;
+    if (typeof v.act !== 'string' || v.act.trim().length === 0)
+        return null;
+    return { kind: v.kind, act: capText(v.act.trim(), HUMAN_ACT_MAX) };
+}
+/** Pure: narrow a row's metadata bag to its observation, when it carries a well-formed one. */
+export function readObservation(metadata) {
+    if (!metadata || typeof metadata !== 'object')
+        return null;
+    const obs = metadata.observation;
+    if (!obs || typeof obs !== 'object')
+        return null;
+    const o = obs;
+    if (typeof o.proposed_disposition !== 'string' || typeof o.condition !== 'string')
+        return null;
+    const act = readHumanAct(o.proposed_human_act);
+    return {
+        proposed_disposition: o.proposed_disposition,
+        condition: o.condition,
+        ...(act ? { proposed_human_act: act } : {}),
+    };
+}
+/**
+ * Pure: lead a description with the named act, fitting the result under `cap`.
+ * The canonical lead-line format of a filing an AGENT made human-facing (the MCP
+ * escalate surface mirrors this template byte-for-byte and pins it against this
+ * source); the daemon chokepoint does not apply it.
+ */
+export function leadWithHumanAct(act, description, cap) {
+    const lead = `**Human act required (${act.kind}):** ${act.act}\n\n`;
+    const full = `${lead}${description}`;
+    if (full.length <= cap)
+        return full;
+    const budget = cap - lead.length - 3;
+    return budget > 0 ? `${lead}${description.slice(0, budget)}...` : lead.slice(0, cap);
+}
+/**
+ * Pure: apply the chokepoint routing rule (see the module header) to one filing.
+ * `_descriptionCap` (the server-side ESCALATION_DESCRIPTION_MAX createEscalation
+ * passes) is unused: no route rewrites the description any more. It stays in the
+ * signature so the createEscalation call site is unchanged.
+ */
+export function routeFilingDisposition(input, _descriptionCap) {
+    const proposed = input.disposition;
+    if (proposed === undefined || proposed === DISPOSITION_AGENT_RESOLVABLE) {
+        return {
+            disposition: proposed,
+            description: input.description,
+            helpNeeded: input.helpNeeded,
+            metadata: input.metadata,
+            route: 'pass_through',
+        };
+    }
+    const act = readHumanAct(input.humanAct);
+    const observation = {
+        proposed_disposition: proposed,
+        condition: conditionHead(input.description),
+        ...(act ? { proposed_human_act: act } : {}),
+    };
+    return {
+        disposition: DISPOSITION_AGENT_RESOLVABLE,
+        description: input.description,
+        helpNeeded: input.helpNeeded,
+        metadata: { ...(input.metadata ?? {}), observation },
+        route: 'observation',
+    };
+}
+//# sourceMappingURL=filing-observation.js.map

package/dist/queries/filing-observation.js.map

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

package/dist/queries/holds.d.ts

@@ -11,7 +11,24 @@
  *     question the daemon reads back to the asking agent. Fails OPEN at its
  *     call site.
  *
- * Plus two exclusion families the operator predicate drops: SELF_REPORT_STALL_HOLD_KINDS
+ * The operator family ALSO matches an open OBSERVATION anchored to the delivery
+ * whose metadata.observation proposed_disposition is an operator-hold disposition.
+ * The chokepoint in queries/escalations.ts createEscalation sends EVERY daemon
+ * filing that names a human-owning disposition to the machine lane as an
+ * observation (named act or not), so the observation form is how a daemon-detected
+ * hold now arrives. Routing decides WHO resolves a condition; it does not clear
+ * the condition. An uncleared condition keeps its delivery out of done whether an
+ * agent or a human resolves it. A plain agent_resolvable filing (no observation)
+ * still does not hold. A DIRECT needs_operator / external_wait row is one an agent
+ * made human-facing through MCP escalate (metadata.human_act), or a legacy row;
+ * both still hold. No hold here depends on a disposition only the daemon routed.
+ *
+ * isMachineStopObservation (below) is the focus-level sibling: a stop-kind
+ * observation carrying its detector's proposed act keeps the machine stopped
+ * (the respawn guard reads it through queries/escalations.ts).
+ *
+ * Plus two exclusion families the operator predicate drops, for a direct match
+ * and an observation match alike: SELF_REPORT_STALL_HOLD_KINDS
  * (machine-filed alarms ABOUT a delivery's own cycling, so an alarm cannot
  * constitute the condition it reports) and REFUSED_OPERATOR_HOLD_KINDS (kinds that
  * name no human-only act -- refused at their filing surface and routed to bounded
@@ -136,11 +153,60 @@ export declare const SELF_REPORT_STALL_HOLD_KINDS: readonly string[];
  * 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/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 (spawn/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-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;
 /** 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
@@ -148,7 +214,8 @@ export interface OperatorHoldEscalation {
  *
  * 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). This is the vocabulary the verify->done gate
+ * (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

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

@@ -1 +1 @@
-{"version":3,"file":"holds.d.ts","sourceRoot":"","sources":["../../src/queries/holds.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAExD,yEAAyE;AACzE,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAAqC,CAAC;AAE/F;;;;;;;;;;;;;;;;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,mFAAmF;AACnF,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,+BAA+B,CACnD,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,EAChB,IAAI,GAAE,WAAgB,GACrB,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAYxC;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,EAChB,IAAI,GAAE,WAAgB,GACrB,OAAO,CAAC,OAAO,CAAC,CAElB"}
+{"version":3,"file":"holds.d.ts","sourceRoot":"","sources":["../../src/queries/holds.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAKxD,yEAAyE;AACzE,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAAqC,CAAC;AAE/F;;;;;;;;;;;;;;;;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,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,EAChB,IAAI,GAAE,WAAgB,GACrB,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAYxC;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,EAChB,IAAI,GAAE,WAAgB,GACrB,OAAO,CAAC,OAAO,CAAC,CAElB"}

package/dist/queries/holds.js

@@ -1,5 +1,6 @@
 // PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
 // Pinned by: packages/daemon/src/queries/has-open-operator-hold-for-delivery.test.ts,
+//   packages/daemon/src/queries/incident-correlation.test.ts,
 //   packages/daemon/src/queries/no-directed-hold-producer.test.ts
 // PINNED-BY-END
 /**
@@ -15,7 +16,24 @@
  *     question the daemon reads back to the asking agent. Fails OPEN at its
  *     call site.
  *
- * Plus two exclusion families the operator predicate drops: SELF_REPORT_STALL_HOLD_KINDS
+ * The operator family ALSO matches an open OBSERVATION anchored to the delivery
+ * whose metadata.observation proposed_disposition is an operator-hold disposition.
+ * The chokepoint in queries/escalations.ts createEscalation sends EVERY daemon
+ * filing that names a human-owning disposition to the machine lane as an
+ * observation (named act or not), so the observation form is how a daemon-detected
+ * hold now arrives. Routing decides WHO resolves a condition; it does not clear
+ * the condition. An uncleared condition keeps its delivery out of done whether an
+ * agent or a human resolves it. A plain agent_resolvable filing (no observation)
+ * still does not hold. A DIRECT needs_operator / external_wait row is one an agent
+ * made human-facing through MCP escalate (metadata.human_act), or a legacy row;
+ * both still hold. No hold here depends on a disposition only the daemon routed.
+ *
+ * isMachineStopObservation (below) is the focus-level sibling: a stop-kind
+ * observation carrying its detector's proposed act keeps the machine stopped
+ * (the respawn guard reads it through queries/escalations.ts).
+ *
+ * Plus two exclusion families the operator predicate drops, for a direct match
+ * and an observation match alike: SELF_REPORT_STALL_HOLD_KINDS
  * (machine-filed alarms ABOUT a delivery's own cycling, so an alarm cannot
  * constitute the condition it reports) and REFUSED_OPERATOR_HOLD_KINDS (kinds that
  * name no human-only act -- refused at their filing surface and routed to bounded
@@ -29,6 +47,9 @@
  * @module queries/holds
  */
 import { callApi } from './shared.js';
+import { DISPOSITION_AGENT_RESOLVABLE } from './escalation-dispositions.js';
+import { readObservation } from './filing-observation.js';
+import { readSymptoms } from './incident-correlation.js';
 /** Escalation statuses that count as OPEN for every hold lookup here. */
 export const OPEN_ESCALATION_STATUSES = new Set(['pending', 'in_review']);
 /**
@@ -147,13 +168,65 @@ export const SELF_REPORT_STALL_HOLD_KINDS = [
 export const REFUSED_OPERATOR_HOLD_KINDS = [
     'verify_evidence_unavailable',
 ];
+/**
+ * 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/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 (spawn/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-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 const MACHINE_STOP_KINDS = [
+    'team_failure',
+    'respawn_cycle_exhausted',
+    'review_handoff_exhausted',
+];
+/**
+ * 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 function isMachineStopObservation(row) {
+    if (row.status && !OPEN_ESCALATION_STATUSES.has(row.status))
+        return false;
+    const metaKind = row.metadata?.kind;
+    const kind = row.escalationKind ?? (typeof metaKind === 'string' ? metaKind : null);
+    if (kind === null || !MACHINE_STOP_KINDS.includes(kind))
+        return false;
+    return readObservation(row.metadata)?.proposed_human_act !== undefined;
+}
 /**
  * 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). This is the vocabulary the verify->done gate
+ * (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
@@ -199,7 +272,9 @@ export async function hasOpenOperatorHoldForDelivery(deliveryId, focusId, deps =
  * address -- and returns the first whose delivery matches (typed delivery_id
  * COLUMN preferred, metadata.deliveryId fallback for rows open at deploy time)
  * AND whose disposition (typed column preferred, metadata fallback) is in the
- * given set. Status is re-checked client-side as defense-in-depth against a
+ * given set -- or, when it is not, whose metadata.observation proposed a
+ * disposition in the set (an observation hold; the result then carries
+ * proposedDisposition). Status is re-checked client-side as defense-in-depth against a
  * deploy-lagged edge fn returning resolved rows. THROWS on a hard API error;
  * fail-open/closed is the CALLER's choice.
  *
@@ -224,14 +299,34 @@ async function findOpenHoldForDelivery(deliveryId, dispositions, focusId, exclud
         const disposition = (typeof e.disposition === 'string' ? e.disposition : null) ??
             (typeof meta?.disposition === 'string' ? meta.disposition : null);
         const matchedDelivery = e.deliveryId === deliveryId || meta?.deliveryId === deliveryId;
-        if (matchedDelivery && disposition !== null && holdSet.has(disposition)) {
-            const kind = (typeof e.escalationKind === 'string' ? e.escalationKind : null) ??
-                (typeof meta?.kind === 'string' ? meta.kind : null);
-            // A self-referential stall alarm about this delivery must not hold it.
-            if (excludeKinds && kind !== null && excludeKinds.has(kind))
-                continue;
-            return { id: e.id, escalationKind: e.escalationKind ?? null, disposition };
-        }
+        if (!matchedDelivery)
+            continue;
+        const direct = disposition !== null && holdSet.has(disposition);
+        const kind = (typeof e.escalationKind === 'string' ? e.escalationKind : null) ??
+            (typeof meta?.kind === 'string' ? meta.kind : null);
+        // The row's own condition first, then each condition correlated onto it as a
+        // symptom (queries/incident-correlation.ts): an attached observation keeps the
+        // hold it proposed even when the row that absorbed it holds nothing itself.
+        const conditions = [
+            { kind, reportedKind: e.escalationKind ?? null, proposed: readObservation(meta)?.proposed_disposition ?? null },
+            ...readSymptoms(meta).map((s) => ({ kind: s.escalation_kind, reportedKind: s.escalation_kind, proposed: s.proposed_disposition ?? null })),
+        ];
+        const held = conditions.find(
+        // An observation proposing a hold disposition is the same uncleared condition,
+        // routed to the machine lane (see the module header). A self-referential stall
+        // alarm about this delivery must not hold it -- and the exclusions bind an
+        // observation of an excluded kind exactly as they bind a direct filing, so the
+        // fixpoint cannot return through the machine lane (or through a symptom).
+        (c) => (direct || (c.proposed !== null && holdSet.has(c.proposed))) &&
+            !(excludeKinds && c.kind !== null && excludeKinds.has(c.kind)));
+        if (!held)
+            continue;
+        return {
+            id: e.id,
+            escalationKind: held.reportedKind,
+            disposition: disposition ?? DISPOSITION_AGENT_RESOLVABLE,
+            ...(!direct && held.proposed !== null ? { proposedDisposition: held.proposed } : {}),
+        };
     }
     return null;
 }

package/dist/queries/holds.js.map

@@ -1 +1 @@
-{"version":3,"file":"holds.js","sourceRoot":"","sources":["../../src/queries/holds.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"holds.js","sourceRoot":"","sources":["../../src/queries/holds.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,sFAAsF;AACtF,8DAA8D;AAC9D,kEAAkE;AAClE,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAE,OAAO,EAAoB,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,yEAAyE;AACzE,MAAM,CAAC,MAAM,wBAAwB,GAAwB,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC;AAE/F;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAsB;IAC3D,gBAAgB;IAChB,eAAe;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAsB;IAC7D,yBAAyB;CAC1B,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAsB;IAC5D,6BAA6B;CAC9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAsB;IACnD,cAAc;IACd,yBAAyB;IACzB,0BAA0B;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,wBAAwB,CAAC,GAIxC;IACC,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IAC1E,MAAM,QAAQ,GAAG,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC;IACpC,MAAM,IAAI,GAAG,GAAG,CAAC,cAAc,IAAI,CAAC,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACpF,IAAI,IAAI,KAAK,IAAI,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IACtE,OAAO,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,kBAAkB,KAAK,SAAS,CAAC;AACzE,CAAC;AAeD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,KAAK,UAAU,+BAA+B,CACnD,UAAkB,EAClB,OAAgB,EAChB,OAAoB,EAAE;IAEtB,OAAO,uBAAuB,CAC5B,UAAU,EACV,0BAA0B,EAC1B,OAAO;IACP,8EAA8E;IAC9E,+EAA+E;IAC/E,+EAA+E;IAC/E,uFAAuF;IACvF,IAAI,GAAG,CAAC,CAAC,GAAG,4BAA4B,EAAE,GAAG,2BAA2B,CAAC,CAAC,EAC1E,IAAI,CACL,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,8BAA8B,CAClD,UAAkB,EAClB,OAAgB,EAChB,OAAoB,EAAE;IAEtB,OAAO,CAAC,MAAM,+BAA+B,CAAC,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,CAAC;AACrF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,KAAK,UAAU,uBAAuB,CACpC,UAAkB,EAClB,YAA+B,EAC/B,OAAgB,EAChB,YAAkC,EAClC,OAAoB,EAAE;IAEtB,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC;IACrC,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,CAAC;IACtC,MAAM,MAAM,GAA4B,EAAE,QAAQ,EAAE,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,CAAC;IAC/E,IAAI,OAAO;QAAE,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC;IACtC,MAAM,MAAM,GAAG,MAAM,IAAI,CAStB,iBAAiB,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IAE9C,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,WAAW,IAAI,EAAE,EAAE,CAAC;QACzC,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;YAAE,SAAS;QAClE,MAAM,IAAI,GAAI,CAAC,CAAC,QAA2C,IAAI,IAAI,CAAC;QACpE,MAAM,WAAW,GACf,CAAC,OAAO,CAAC,CAAC,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC;YAC1D,CAAC,OAAO,IAAI,EAAE,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACpE,MAAM,eAAe,GACnB,CAAC,CAAC,UAAU,KAAK,UAAU,IAAI,IAAI,EAAE,UAAU,KAAK,UAAU,CAAC;QACjE,IAAI,CAAC,eAAe;YAAE,SAAS;QAC/B,MAAM,MAAM,GAAG,WAAW,KAAK,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAChE,MAAM,IAAI,GACR,CAAC,OAAO,CAAC,CAAC,cAAc,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC;YAChE,CAAC,OAAO,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAE,IAAI,CAAC,IAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAClE,6EAA6E;QAC7E,+EAA+E;QAC/E,4EAA4E;QAC5E,MAAM,UAAU,GAAG;YACjB,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI,EAAE,QAAQ,EAAE,eAAe,CAAC,IAAI,CAAC,EAAE,oBAAoB,IAAI,IAAI,EAAE;YAC/G,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,eAAe,EAAE,YAAY,EAAE,CAAC,CAAC,eAAe,EAAE,QAAQ,EAAE,CAAC,CAAC,oBAAoB,IAAI,IAAI,EAAE,CAAC,CAAC;SAC3I,CAAC;QACF,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI;QAC1B,+EAA+E;QAC/E,+EAA+E;QAC/E,2EAA2E;QAC3E,+EAA+E;QAC/E,0EAA0E;QAC1E,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC5D,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CACjE,CAAC;QACF,IAAI,CAAC,IAAI;YAAE,SAAS;QACpB,OAAO;YACL,EAAE,EAAE,CAAC,CAAC,EAAE;YACR,cAAc,EAAE,IAAI,CAAC,YAAY;YACjC,WAAW,EAAE,WAAW,IAAI,4BAA4B;YACxD,GAAG,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,mBAAmB,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACrF,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}