@telora/daemon 0.22.245 → 0.22.290

package/dist/completion/state-cascade/review-next-step.d.ts

@@ -0,0 +1,74 @@
+import type { PipelineConfig } from '../../types/index.js';
+import type { FocusDeliveryAggregatePhase } from '../../supervision/focus-delivery-aggregate-phase.js';
+/** The delivery slice the review-next-step question reads (structural). */
+export interface ReviewNextStepDelivery {
+    id: string;
+    executionStatus?: string | null;
+    /** The delivery's gate_state, read for a shortfall park; absent reads as not parked. */
+    gateState?: unknown;
+}
+/** The issue slice the review-next-step question reads (structural). */
+export interface ReviewNextStepIssue {
+    deliveryId: string;
+    status: string;
+    issueType: string;
+}
+/**
+ * The complete review-next-step decision.
+ *   - not_converged      -- the focus is not in phase 'verifying' (nothing active,
+ *                           at least one verify): no review window opens here.
+ *   - parked             -- converged, and EVERY verify delivery is parked on a
+ *                           repeating verify shortfall (verify/shortfalls/shortfall-park.ts):
+ *                           neither a coding pass nor a review is next -- verify
+ *                           re-judging a changed commit set (or a ruling) is. No
+ *                           window opens and no coding directive spawns.
+ *   - review_disabled    -- converged, but pipeline_config.review.enabled === false:
+ *                           the verify deliveries reach done with no verdict.
+ *   - open_work          -- converged and review-enabled, but an UNPARKED verify
+ *                           delivery carries an open Task/Bug (To Do / In Progress /
+ *                           Blocked): a coding pass, not a review, is next. Open
+ *                           work on a parked delivery is not coding work: nothing
+ *                           may route it back to coding until verify releases it.
+ *   - issues_unreadable  -- converged and review-enabled, but the issue read
+ *                           failed: the decision is unknown; each site fails open
+ *                           to its own pre-decision behaviour.
+ *   - review             -- converged, review-enabled, no open work: a review pass
+ *                           is the next actionable step.
+ * The issue list is read ONLY past the convergence + enablement checks, so an
+ * unconverged or review-disabled focus costs no issue fetch.
+ */
+export type ReviewNextStep<D extends ReviewNextStepDelivery> = {
+    step: 'not_converged';
+} | {
+    step: 'parked';
+    verifyDeliveries: D[];
+} | {
+    step: 'review_disabled';
+    verifyDeliveries: D[];
+} | {
+    step: 'open_work';
+    verifyDeliveries: D[];
+    openIssueCount: number;
+} | {
+    step: 'issues_unreadable';
+    verifyDeliveries: D[];
+    error: Error;
+} | {
+    step: 'review';
+    verifyDeliveries: D[];
+};
+/**
+ * Resolve the review-next-step decision for a focus.
+ *
+ * `phase` is the caller's derived focus execution phase. The pending-spawn gate
+ * derives it with review_requested_at deliberately null (state, not stamp); the
+ * cascade passes the phase it already derived, whose only difference is that an
+ * already-stamped window reads 'reviewing' (not_converged: the window is open).
+ */
+export declare function resolveReviewNextStep<D extends ReviewNextStepDelivery>(input: {
+    phase: FocusDeliveryAggregatePhase;
+    deliveries: readonly D[];
+    pipelineConfig: PipelineConfig | null | undefined;
+    readIssues: () => Promise<readonly ReviewNextStepIssue[]>;
+}): Promise<ReviewNextStep<D>>;
+//# sourceMappingURL=review-next-step.d.ts.map

package/dist/completion/state-cascade/review-next-step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-next-step.d.ts","sourceRoot":"","sources":["../../../src/completion/state-cascade/review-next-step.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qDAAqD,CAAC;AAKvG,2EAA2E;AAC3E,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,wFAAwF;IACxF,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,wEAAwE;AACxE,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,sBAAsB,IACvD;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,gBAAgB,EAAE,CAAC,EAAE,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,gBAAgB,EAAE,CAAC,EAAE,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,gBAAgB,EAAE,CAAC,EAAE,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACpE;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,gBAAgB,EAAE,CAAC,EAAE,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GAClE;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,gBAAgB,EAAE,CAAC,EAAE,CAAA;CAAE,CAAC;AAS9C;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CAAC,CAAC,SAAS,sBAAsB,EAAE,KAAK,EAAE;IACnF,KAAK,EAAE,2BAA2B,CAAC;IACnC,UAAU,EAAE,SAAS,CAAC,EAAE,CAAC;IACzB,cAAc,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,CAAC;IAClD,UAAU,EAAE,MAAM,OAAO,CAAC,SAAS,mBAAmB,EAAE,CAAC,CAAC;CAC3D,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAiB7B"}

package/dist/completion/state-cascade/review-next-step.js

@@ -0,0 +1,67 @@
+// 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/focus/parked-shortfall-spawn.test.ts
+// PINNED-BY-END
+/**
+ * "Is the next actionable step on this focus a review pass?" -- keyed on delivery
+ * and issue STATE, never on review_requested_at.
+ *
+ * Two sites ask the same question and must not drift:
+ *   - the state cascade (completion/state-cascade/state-cascade.ts checkAutoReview), which OPENS
+ *     the review window when the focus converges on verify; and
+ *   - the pending-spawn pass (focus/pending-spawn-review-next-step.ts), which must
+ *     not spawn a CODING lead into that same state -- a coding lead there has no
+ *     work, holds the focus's single team slot, and deadlocks the review.
+ *
+ * Why state and not the stamp: a spawn decision can run BEFORE the cascade stamps
+ * review_requested_at, while the delivery aggregate that makes the cascade stamp
+ * the window is already true.
+ *
+ * Both sites consume ONE complete decision, resolveReviewNextStep: convergence on
+ * verify, review enablement, AND the open-work issue matrix -- so a verify
+ * delivery with a freshly opened Bug reads "coding is next" at both sites. Each
+ * site maps the outcome onto its own action (and its own fail-open reading of an
+ * unreadable issue list); the decision itself is here.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (completion/state-cascade/review-next-step.ts).
+ */
+import { DELIVERY_STATUS } from '@telora/daemon-core';
+import { isReviewEnabled } from '../../workflow/pipeline-config.js';
+import { CONTEXT_GROUP_TYPE, OPEN_ISSUE_STATUSES } from '../../types/issue-status.js';
+import { shortfallParkRefusingRework } from '../../verify/shortfalls/shortfall-park.js';
+/** Open work issues (Task/Bug in To Do / In Progress / Blocked) sitting on the given deliveries. */
+function countOpenWorkIssues(verifyIds, issues) {
+    return issues.filter((i) => verifyIds.has(i.deliveryId) && i.issueType !== CONTEXT_GROUP_TYPE && OPEN_ISSUE_STATUSES.has(i.status)).length;
+}
+/**
+ * Resolve the review-next-step decision for a focus.
+ *
+ * `phase` is the caller's derived focus execution phase. The pending-spawn gate
+ * derives it with review_requested_at deliberately null (state, not stamp); the
+ * cascade passes the phase it already derived, whose only difference is that an
+ * already-stamped window reads 'reviewing' (not_converged: the window is open).
+ */
+export async function resolveReviewNextStep(input) {
+    if (input.phase !== 'verifying')
+        return { step: 'not_converged' };
+    const verifyDeliveries = input.deliveries.filter((d) => d.executionStatus === DELIVERY_STATUS.VERIFY);
+    if (verifyDeliveries.length === 0)
+        return { step: 'not_converged' };
+    const unparked = verifyDeliveries.filter((d) => shortfallParkRefusingRework(d) === null);
+    if (unparked.length === 0)
+        return { step: 'parked', verifyDeliveries };
+    if (!isReviewEnabled(input.pipelineConfig))
+        return { step: 'review_disabled', verifyDeliveries };
+    let issues;
+    try {
+        issues = await input.readIssues();
+    }
+    catch (err) {
+        return { step: 'issues_unreadable', verifyDeliveries, error: err instanceof Error ? err : new Error(String(err)) };
+    }
+    const openIssueCount = countOpenWorkIssues(new Set(unparked.map((d) => d.id)), issues);
+    if (openIssueCount > 0)
+        return { step: 'open_work', verifyDeliveries, openIssueCount };
+    return { step: 'review', verifyDeliveries };
+}
+//# sourceMappingURL=review-next-step.js.map

package/dist/completion/state-cascade/review-next-step.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-next-step.js","sourceRoot":"","sources":["../../../src/completion/state-cascade/review-next-step.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,oFAAoF;AACpF,6DAA6D;AAC7D,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtD,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACtF,OAAO,EAAE,2BAA2B,EAAE,MAAM,2CAA2C,CAAC;AAiDxF,oGAAoG;AACpG,SAAS,mBAAmB,CAAC,SAA8B,EAAE,MAAsC;IACjG,OAAO,MAAM,CAAC,MAAM,CAClB,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,KAAK,kBAAkB,IAAI,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAC9G,CAAC,MAAM,CAAC;AACX,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAmC,KAK7E;IACC,IAAI,KAAK,CAAC,KAAK,KAAK,WAAW;QAAE,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;IAClE,MAAM,gBAAgB,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,eAAe,KAAK,eAAe,CAAC,MAAM,CAAC,CAAC;IACtG,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;IACpE,MAAM,QAAQ,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,2BAA2B,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;IACzF,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IACvE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,cAAc,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IAEjG,IAAI,MAAsC,CAAC;IAC3C,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,KAAK,CAAC,UAAU,EAAE,CAAC;IACpC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;IACrH,CAAC;IACD,MAAM,cAAc,GAAG,mBAAmB,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IACvF,IAAI,cAAc,GAAG,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,gBAAgB,EAAE,cAAc,EAAE,CAAC;IACvF,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;AAC9C,CAAC"}

package/dist/completion/state-cascade/settle-injection-sweep.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Focus-scope anchored-injection retirement on the lifecycle that ACTUALLY runs
+ * (the derived winding_down settle).
+ *
+ * The machine-completion family (directive/close-loop-dispatcher.ts
+ * advanceFocusToDoneWithSweep) sweeps only when the product_focuses.stage column
+ * reaches 'close_loop'. A focus can settle (all deliveries terminal -> derived
+ * phase winding_down) WITHOUT the stage column reaching close_loop -- e.g. review
+ * disabled, or a delivery exiting via review rather than the per-delivery verify
+ * gate -- and its anchored injections must still be retired, or the focus
+ * completes with a stale reality tree whose FRT overlays stay frozen.
+ *
+ * This runs the SAME sweep (planInjectionSweep + executeSweep +
+ * buildWritebackVerify, reused verbatim -- the FRT writeback is unrecoverable if
+ * reimplemented) when the DERIVED phase reaches winding_down, and writes NO focus
+ * stage: completion stays human-owned (the machine never writes focus.stage =
+ * 'done'). Idempotent + best-effort: planInjectionSweep plans only injections in
+ * an API-verifiable status (proposed / in_progress / realized) and skips anything
+ * else -- already 'verified', 'rejected_alternative', or an unresolvable/missing
+ * status -- so a re-run once the tree is settled (or a response-shape change) is
+ * an empty-plan no-op rather than a stream of refused verify writes; every I/O
+ * failure holds (retries next settle) rather than throwing.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (completion/state-cascade/settle-injection-sweep.ts).
+ */
+import type { FocusDeliveryInfo } from '../../types/index.js';
+import type { SweepFailure } from '../../directive/close-loop-dispatcher.js';
+/** The per-injection snapshot the sweep reads (status + owning tree id). */
+interface InjectionNodeSnapshot {
+    id: string;
+    injectionStatus: string | null;
+    realityTreeId?: string | null;
+}
+/** The sweep's IO; production binds it at the composition root (composition/state-cascade-context.ts). */
+export interface SettleSweepDeps {
+    /** Current injection-status snapshot for the focus (reality_tree_focus_injections). */
+    fetchInjectionSnapshot: (focusId: string) => Promise<InjectionNodeSnapshot[]>;
+    /**
+     * The per-injection FRT writeback verify, keyed by owning tree id. Also
+     * carries the OBSERVED per-injection delivered verdict (from each anchoring
+     * delivery's real terminal state) so the writeback's `delivered` is sourced
+     * from observation, never a hardcoded literal.
+     */
+    buildVerify: (treeIdByInjection: ReadonlyMap<string, string>, deliveredByInjection: ReadonlyMap<string, boolean>) => (injectionId: string, evidence: string) => Promise<void>;
+}
+/** Injectable API-client shape for the snapshot resolver (test seam). */
+type SnapshotCallApi = <T>(action: string, params?: Record<string, unknown>) => Promise<T>;
+/**
+ * Resolve every injection node for a focus across statuses (active + retired),
+ * keyed by node id -- so an injection's status is read DIRECTLY from its node
+ * rather than inferred from presence in an active-only list.
+ *
+ * Why not `reality_tree_focus_injections`: that action filters injection nodes
+ * to status='active' (graph-traversal.ts), and verifying an injection retires
+ * its node (graph-verification.ts sets injection_status='verified' AND
+ * status='retired'). So a verified injection is ABSENT from that list entirely,
+ * making "already verified" and "absent for an unknown reason" the SAME
+ * observation. Fetching the retired injection nodes too makes a verified
+ * injection PRESENT with injectionStatus='verified' (which planInjectionSweep
+ * then skips as settled), leaving genuine absence to mean only "could not
+ * resolve". `reality_tree_node_list` filters a single status, so both an active
+ * and a retired pass are issued per focus tree. Bounded and once-per-settle
+ * (the caller latches a settled focus quiet), not a per-tick cost.
+ */
+export declare function resolveInjectionSnapshot(focusId: string, api: SnapshotCallApi): Promise<InjectionNodeSnapshot[]>;
+export interface SettleSweepOutcome {
+    planSize: number;
+    verified: number;
+    /** Per-entry verify failures; empty when every planned injection retired. */
+    failures: SweepFailure[];
+    /**
+     * True when the sweep reached a definite conclusion this settle: it fetched
+     * the injection snapshot and either found nothing to plan (a settled tree) or
+     * ran the plan to a result. False ONLY when an I/O failure -- the snapshot
+     * fetch throwing, or executeSweep throwing -- prevented the sweep from knowing
+     * whether the tree settled at all.
+     *
+     * This is the distinction the caller's swept-latch guard reads. `complete` is
+     * whole-sweep and NOT attributable to any one injection, which is exactly why
+     * an I/O failure is carried here rather than synthesised into `failures[]`
+     * (that array is per-injection verify rejections). A focus is marked swept
+     * only when `complete === true && failures.length === 0`; a sweep that could
+     * not run (`complete === false`) is left unmarked so the next settle retries.
+     */
+    complete: boolean;
+    /**
+     * Ids of anchored injections whose status could NOT be resolved from the
+     * snapshot this settle -- absent from the fetched injection nodes, or present
+     * with a null/absent status field. This is the observability signal that separates the two
+     * causes of an empty plan: a SETTLED tree (every anchored injection present,
+     * e.g. 'verified') leaves this empty and stays silent, while an UNRESOLVABLE
+     * response (a degraded injections read, a response-shape regression) populates
+     * it and emits a one-per-settle trace. Empty on the I/O-failure paths, where
+     * `complete: false` already carries the "could not run" signal and no
+     * per-injection claim is made. Delivery "An empty plan leaves a
+     * distinguishable trace".
+     */
+    unresolvedAnchored: string[];
+}
+/**
+ * Retire the focus's anchored injections whose anchoring delivery closed
+ * successfully but whose injection is not yet 'verified', at the winding_down
+ * settle. Writes no focus stage. Returns the sweep tally; never throws.
+ */
+export declare function sweepAnchoredInjectionsOnSettle(focus: {
+    focus_id: string;
+    focus_name: string;
+}, deliveries: FocusDeliveryInfo[], deps: SettleSweepDeps): Promise<SettleSweepOutcome>;
+export {};
+//# sourceMappingURL=settle-injection-sweep.d.ts.map

package/dist/completion/state-cascade/settle-injection-sweep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle-injection-sweep.d.ts","sourceRoot":"","sources":["../../../src/completion/state-cascade/settle-injection-sweep.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAM9D,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAM9F,4EAA4E;AAC5E,UAAU,qBAAqB;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,0GAA0G;AAC1G,MAAM,WAAW,eAAe;IAC9B,uFAAuF;IACvF,sBAAsB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAC9E;;;;;OAKG;IACH,WAAW,EAAE,CACX,iBAAiB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9C,oBAAoB,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,KAC/C,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/D;AAED,yEAAyE;AACzE,KAAK,eAAe,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAE3F;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,eAAe,GACnB,OAAO,CAAC,qBAAqB,EAAE,CAAC,CA+BlC;AAmCD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB;;;;;;;;;;;;;OAaG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;OAWG;IACH,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAsB,+BAA+B,CACnD,KAAK,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,EAC/C,UAAU,EAAE,iBAAiB,EAAE,EAC/B,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAmH7B"}

package/dist/completion/state-cascade/settle-injection-sweep.js

@@ -0,0 +1,189 @@
+// 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/settle-injection-sweep.test.ts,
+//   packages/daemon/src/completion/state-cascade/state-cascade.test.ts
+// PINNED-BY-END
+import { getAnchoringDeliveries, planInjectionSweep, executeSweep, } from '../../directive/close-loop-dispatcher.js';
+import { createLogger } from '../../log/daemon-log.js';
+const log = createLogger({ module: 'settle-injection-sweep' });
+/**
+ * Resolve every injection node for a focus across statuses (active + retired),
+ * keyed by node id -- so an injection's status is read DIRECTLY from its node
+ * rather than inferred from presence in an active-only list.
+ *
+ * Why not `reality_tree_focus_injections`: that action filters injection nodes
+ * to status='active' (graph-traversal.ts), and verifying an injection retires
+ * its node (graph-verification.ts sets injection_status='verified' AND
+ * status='retired'). So a verified injection is ABSENT from that list entirely,
+ * making "already verified" and "absent for an unknown reason" the SAME
+ * observation. Fetching the retired injection nodes too makes a verified
+ * injection PRESENT with injectionStatus='verified' (which planInjectionSweep
+ * then skips as settled), leaving genuine absence to mean only "could not
+ * resolve". `reality_tree_node_list` filters a single status, so both an active
+ * and a retired pass are issued per focus tree. Bounded and once-per-settle
+ * (the caller latches a settled focus quiet), not a per-tick cost.
+ */
+export async function resolveInjectionSnapshot(focusId, api) {
+    const treesResp = await api('reality_tree_list', { focusId });
+    const trees = (treesResp.items ?? []).filter((t) => t.status === 'active');
+    if (trees.length === 0)
+        return [];
+    const snapshot = [];
+    const seen = new Set();
+    for (const tree of trees) {
+        const [activeResp, retiredResp] = await Promise.all([
+            api('reality_tree_node_list', {
+                treeId: tree.id,
+                nodeType: 'injection',
+                status: 'active',
+            }),
+            api('reality_tree_node_list', {
+                treeId: tree.id,
+                nodeType: 'injection',
+                status: 'retired',
+            }),
+        ]);
+        for (const node of [...(activeResp.items ?? []), ...(retiredResp.items ?? [])]) {
+            if (seen.has(node.id))
+                continue;
+            seen.add(node.id);
+            snapshot.push({
+                id: node.id,
+                injectionStatus: node.injectionStatus,
+                realityTreeId: node.realityTreeId || tree.id,
+            });
+        }
+    }
+    return snapshot;
+}
+/**
+ * The set of delivery execution_status values that count as a delivery having
+ * DELIVERED its work. Mirrors the close-loop dispatcher's "closed successfully"
+ * set: a done (or forward-compat 'verified') delivery delivered; anything else
+ * (cancelled / in-flight / paused) did not.
+ */
+const DELIVERED_EXECUTION_STATUSES = new Set(['done', 'verified']);
+/**
+ * Build the OBSERVED per-injection delivered verdict from the focus's anchored
+ * deliveries: an injection is `delivered` iff at least one delivery anchoring it
+ * reached a delivered terminal state. Sourced from the real delivery outcome, so
+ * the writeback never assumes delivery via a hardcoded literal.
+ */
+function buildDeliveredByInjection(anchored) {
+    const deliveredByInjection = new Map();
+    for (const d of anchored) {
+        const injectionId = d.injectionId;
+        if (typeof injectionId !== 'string' || injectionId.length === 0)
+            continue;
+        const isDelivered = typeof d.executionStatus === 'string' &&
+            DELIVERED_EXECUTION_STATUSES.has(d.executionStatus);
+        if (isDelivered) {
+            deliveredByInjection.set(injectionId, true);
+        }
+        else if (!deliveredByInjection.has(injectionId)) {
+            deliveredByInjection.set(injectionId, false);
+        }
+    }
+    return deliveredByInjection;
+}
+/**
+ * Retire the focus's anchored injections whose anchoring delivery closed
+ * successfully but whose injection is not yet 'verified', at the winding_down
+ * settle. Writes no focus stage. Returns the sweep tally; never throws.
+ */
+export async function sweepAnchoredInjectionsOnSettle(focus, deliveries, deps) {
+    const anchored = getAnchoringDeliveries(deliveries);
+    // No anchored injections -> nothing this focus could ever sweep. A definite
+    // conclusion, so complete: true (the caller may latch the focus quiet).
+    if (anchored.length === 0) {
+        return { planSize: 0, verified: 0, failures: [], complete: true, unresolvedAnchored: [] };
+    }
+    let snapshot;
+    try {
+        snapshot = await deps.fetchInjectionSnapshot(focus.focus_id);
+    }
+    catch (err) {
+        log.warn(`[settle-sweep] failed to fetch injections for focus ${focus.focus_id.slice(0, 8)}: ` +
+            `${err.message} -- holding; next settle retries`);
+        // Could not read the tree -- we do NOT know whether it settled. complete: false
+        // so the caller holds the focus unswept and retries on the next settle.
+        // unresolvedAnchored stays empty: with no snapshot we make no per-injection
+        // claim; complete:false is the signal here.
+        return { planSize: 0, verified: 0, failures: [], complete: false, unresolvedAnchored: [] };
+    }
+    const statusById = new Map();
+    const treeIdByInjection = new Map();
+    for (const item of snapshot) {
+        statusById.set(item.id, item.injectionStatus);
+        const treeId = item.realityTreeId;
+        if (typeof treeId === 'string' && treeId.length > 0) {
+            treeIdByInjection.set(item.id, treeId);
+        }
+    }
+    // Anchored injections whose status the snapshot could NOT resolve: absent
+    // from the fetched injection nodes, OR present with a null/undefined status
+    // (a renamed/absent status field -- the response-shape regression this trace
+    // exists to catch). `statusById.get(id) == null` covers both (absent -> get
+    // returns undefined; present-null -> null). After the node-based resolution a
+    // settled injection is PRESENT with a real status ('verified'), so a null-or-
+    // absent anchor means a genuinely degraded read -- not a settled tree.
+    const unresolvedAnchored = [
+        ...new Set(anchored
+            .map((d) => d.injectionId)
+            .filter((id) => typeof id === 'string' && id.length > 0 && statusById.get(id) == null)),
+    ].sort();
+    const plan = planInjectionSweep(anchored, statusById);
+    if (plan.length === 0) {
+        // An empty plan has two causes that were previously byte-identical (silent):
+        // a SETTLED tree (every anchored injection present and terminal) vs an
+        // UNRESOLVABLE read (some anchored injection absent). Log ONLY the
+        // unresolvable case, so a settled focus stays silent and a degraded
+        // injections response leaves a trace readable from the daemon log alone.
+        // Rate is bounded to once per settle-entry: this complete:true return arms
+        // the caller's settledSweptFocuses latch, which then skips the sweep on
+        // subsequent ticks -- so this never reintroduces the per-tick flood.
+        if (unresolvedAnchored.length > 0) {
+            const sample = unresolvedAnchored
+                .slice(0, 3)
+                .map((id) => id.slice(0, 8))
+                .join(', ');
+            log.warn(`[settle-sweep] Focus "${focus.focus_name}" planned no injections but ` +
+                `${unresolvedAnchored.length} anchored injection(s) could not be resolved from the ` +
+                `injection snapshot (sample: ${sample}${unresolvedAnchored.length > 3 ? ', ...' : ''}) ` +
+                `-- a degraded injections read, not a settled tree. Logged once per settle-entry.`);
+        }
+        return { planSize: 0, verified: 0, failures: [], complete: true, unresolvedAnchored };
+    }
+    let outcome;
+    try {
+        outcome = await executeSweep(plan, deps.buildVerify(treeIdByInjection, buildDeliveredByInjection(anchored)));
+    }
+    catch (err) {
+        log.warn(`[settle-sweep] sweep threw for focus ${focus.focus_id.slice(0, 8)}: ${err.message}`);
+        // executeSweep threw before producing a per-entry outcome -- we do NOT know
+        // which injections retired. complete: false so the caller retries next settle;
+        // unresolvedAnchored stays empty per the I/O-failure convention.
+        return { planSize: plan.length, verified: 0, failures: [], complete: false, unresolvedAnchored: [] };
+    }
+    if (outcome.verified.length > 0) {
+        log.info(`[settle-sweep] Focus "${focus.focus_name}" reached winding_down -- retired ` +
+            `${outcome.verified.length}/${plan.length} anchored injection(s) at focus scope ` +
+            `(no stage write; completion stays human-owned)`);
+    }
+    if (!outcome.ok) {
+        const first = outcome.failures[0];
+        log.warn(`[settle-sweep] Focus "${focus.focus_name}" sweep: ` +
+            `${outcome.verified.length}/${plan.length} retired, ${outcome.failures.length} failed ` +
+            `(first: ${first ? `${first.injectionId.slice(0, 8)} -- ${first.error.message}` : 'n/a'}); ` +
+            `next settle retries the rest`);
+    }
+    // The plan ran to a per-entry result. complete: true -- the caller latches
+    // the focus only if there were also no per-injection failures.
+    return {
+        planSize: plan.length,
+        verified: outcome.verified.length,
+        failures: outcome.failures,
+        complete: true,
+        unresolvedAnchored,
+    };
+}
+//# sourceMappingURL=settle-injection-sweep.js.map

package/dist/completion/state-cascade/settle-injection-sweep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle-injection-sweep.js","sourceRoot":"","sources":["../../../src/completion/state-cascade/settle-injection-sweep.ts"],"names":[],"mappings":"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"}

package/dist/completion/state-cascade/standing-approval-convergence.d.ts

@@ -0,0 +1,71 @@
+import type { FocusDeliveryInfo } from '../../types/index.js';
+import type { updateDeliveryStatus } from '../../queries/deliveries/deliveries.js';
+import type { getDeliveryIssues } from '../../queries/deliveries/issues.js';
+import type { fetchEffectiveWorkflow } from '../../queries/workflow-transitions/workflows.js';
+import type { findOpenOperatorHoldForDelivery } from '../../supervision/holds.js';
+import type { OpenShortfallProposalLister } from '../../drift/open-shortfall-proposals.js';
+import { type ExternalConditionEvaluator } from '../../delivery/external-hold.js';
+import { type CommitVerdictGateDeps } from '../review-exit-holds/review-exit-verdict-gate.js';
+import type { GateReads } from '../../verify/gate-verdicts/own-gate-verdict.js';
+import { type ReviewHeadApproval } from './review-approved-head-gate.js';
+import type { ReviewCensus } from '../review-exit/review-census-record.js';
+/** The focus a pass converges. */
+export interface StandingApprovalFocus {
+    organizationId: string;
+    productId: string;
+    focusId: string;
+    focusName: string;
+    readOnly: boolean;
+}
+/** Injected reads and the single writer; production wiring lives in state-cascade.ts. */
+export interface StandingApprovalDeps extends GateReads, Pick<CommitVerdictGateDeps, 'resolveJudgedCommit'> {
+    /** The focus head and the commit its current approval judged. Throws when unreadable. */
+    readReviewHeadApproval: () => Promise<ReviewHeadApproval>;
+    /** The focus's review censuses, newest first. */
+    listReviewCensuses: () => readonly ReviewCensus[];
+    isReviewSessionActive: (focusId: string) => boolean;
+    getDeliveryIssues: typeof getDeliveryIssues;
+    fetchEffectiveWorkflow: typeof fetchEffectiveWorkflow;
+    updateDeliveryStatus: typeof updateDeliveryStatus;
+    findOpenOperatorHoldForDelivery: typeof findOpenOperatorHoldForDelivery;
+    listOpenShortfallProposalIds: OpenShortfallProposalLister;
+    evaluateExternalCondition: ExternalConditionEvaluator;
+    /** The ISO clock the external-hold gate stamps and ages holds with. */
+    externalHoldClock: () => string;
+}
+/** What one pass did. */
+export interface StandingApprovalOutcome {
+    /** Deliveries moved verify -> done on the standing approval. */
+    converged: string[];
+    /** Candidates left in verify, with the reason. */
+    held: Array<{
+        deliveryId: string;
+        reason: string;
+    }>;
+}
+/**
+ * Whether a gate_state carries no hold or failure detail of any kind. Defensive over the JSONB. Pure.
+ *
+ * `shortfallProposalIds` (the review exit's undisposed-proposal marker) is NOT read
+ * here: it only renders a hold this pass re-reads LIVE, fail-closed, before any done
+ * write (resolveShortfallHold). Nothing clears that marker at an approved head -- the
+ * review exit wrote it and no review runs there -- so treating it as a hold would
+ * strand a delivery whose proposals an operator ruling has since disposed. The done
+ * write clears gate_state, marker included.
+ */
+export declare function gateStateHoldsNothing(gateState: unknown): boolean;
+/** Whether a delivery sits in verify with a durable verify PASS and no hold. Pure. */
+export declare function isStandingApprovalCandidate(d: Pick<FocusDeliveryInfo, 'executionStatus' | 'verificationOutcome' | 'gateState'>): boolean;
+/**
+ * Whether the newest census of `approvedSha` is an approving one naming the
+ * delivery at its current re-code iteration. Pure.
+ */
+export declare function censusCoversDelivery(censuses: readonly ReviewCensus[], approvedSha: string, delivery: Pick<FocusDeliveryInfo, 'id' | 'iterationCount'>): boolean;
+/** Test seam: forget logged hold reasons. */
+export declare function __resetStandingApprovalConvergenceForTests(): void;
+/**
+ * Converge every covered, passed, unheld verify delivery of the focus on its
+ * standing approval (see the module header). Never throws.
+ */
+export declare function convergeOnStandingApproval(focus: StandingApprovalFocus, deliveries: readonly FocusDeliveryInfo[], deps: StandingApprovalDeps): Promise<StandingApprovalOutcome>;
+//# sourceMappingURL=standing-approval-convergence.d.ts.map

package/dist/completion/state-cascade/standing-approval-convergence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standing-approval-convergence.d.ts","sourceRoot":"","sources":["../../../src/completion/state-cascade/standing-approval-convergence.ts"],"names":[],"mappings":"AAsEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iDAAiD,CAAC;AAC9F,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AAClF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yCAAyC,CAAC;AAI3F,OAAO,EAA6C,KAAK,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAE7H,OAAO,EAAwB,KAAK,qBAAqB,EAAE,MAAM,kDAAkD,CAAC;AACpH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gDAAgD,CAAC;AAChF,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAChG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAC;AAM3E,kCAAkC;AAClC,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,yFAAyF;AACzF,MAAM,WAAW,oBAAqB,SAAQ,SAAS,EAAE,IAAI,CAAC,qBAAqB,EAAE,qBAAqB,CAAC;IACzG,yFAAyF;IACzF,sBAAsB,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC1D,iDAAiD;IACjD,kBAAkB,EAAE,MAAM,SAAS,YAAY,EAAE,CAAC;IAClD,qBAAqB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IACpD,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;IAC5C,sBAAsB,EAAE,OAAO,sBAAsB,CAAC;IACtD,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;IAClD,+BAA+B,EAAE,OAAO,+BAA+B,CAAC;IACxE,4BAA4B,EAAE,2BAA2B,CAAC;IAC1D,yBAAyB,EAAE,0BAA0B,CAAC;IACtD,uEAAuE;IACvE,iBAAiB,EAAE,MAAM,MAAM,CAAC;CACjC;AAED,yBAAyB;AACzB,MAAM,WAAW,uBAAuB;IACtC,gEAAgE;IAChE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,kDAAkD;IAClD,IAAI,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAQD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAQjE;AAED,sFAAsF;AACtF,wBAAgB,2BAA2B,CACzC,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,iBAAiB,GAAG,qBAAqB,GAAG,WAAW,CAAC,GAClF,OAAO,CAET;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,gBAAgB,CAAC,GACzD,OAAO,CAMT;AAKD,6CAA6C;AAC7C,wBAAgB,0CAA0C,IAAI,IAAI,CAEjE;AA6DD;;;GAGG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,qBAAqB,EAC5B,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC,uBAAuB,CAAC,CA4ClC"}