@telora/daemon 0.22.245 → 0.22.289

package/dist/queries/focuses/ended-arm.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The ENDED-ARM record: the shape the daemon sends with a release to state WHY
+ * it ended a focus's armed run.
+ *
+ * Its own module, not a member of queries/focuses/focuses.ts, because it is a wire
+ * SHAPE with two readers on different sides of the release -- the writer
+ * (focuses.ts releaseFocusArm) and the crossing that composes it
+ * (completion/review-cycle-budget/review-cycle-cap.ts) -- and focuses.ts sits at the file-size
+ * ceiling.
+ *
+ * @module queries/focuses/ended-arm
+ */
+/**
+ * The ended-arm record that rides a release, stating WHY the daemon ended the
+ * arm and what was still outstanding.
+ *
+ * ONE reason exists: 'review_budget_spent'. It is sent in the SAME call as the
+ * release (the edge refuses it otherwise, handlers/focus/arm-ended.ts) so the
+ * role-less focus is never readable without its reason, and so the record can
+ * never be mistaken for the operator stop (operator_stopped_at, which this path
+ * does not write) or the trigger's lifecycle clear (which writes neither).
+ *
+ * `detail` carries only what the DAEMON counted. The edge adds the acceptance
+ * criteria the last verdict-bearing review called not_met -- it owns the shape
+ * that record lives in -- so this daemon never parses a review summary.
+ *
+ * ARM_ENDED_REVIEW_BUDGET_SPENT is the value the DB CHECK constraint on
+ * product_focuses.arm_ended_reason allows and the wedge diagnosis reads back.
+ */
+export declare const ARM_ENDED_REVIEW_BUDGET_SPENT = "review_budget_spent";
+export interface EndedArmRecord {
+    reason: typeof ARM_ENDED_REVIEW_BUDGET_SPENT;
+    detail: {
+        /** The consecutive unconverged review cycles the count reached. */
+        reviewCycleCount: number;
+        /** TELORA_REVIEW_CYCLE_CAP, the budget it reached. */
+        cap: number;
+        /** The open blocking review-filed findings on the focus at the exit; none are closed. */
+        openBlockingFindings: Array<{
+            id: string;
+            key: string;
+            title: string;
+            deliveryId: string | null;
+        }>;
+    };
+}
+//# sourceMappingURL=ended-arm.d.ts.map

package/dist/queries/focuses/ended-arm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ended-arm.d.ts","sourceRoot":"","sources":["../../../src/queries/focuses/ended-arm.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,6BAA6B,wBAAwB,CAAC;AAEnE,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,6BAA6B,CAAC;IAC7C,MAAM,EAAE;QACN,mEAAmE;QACnE,gBAAgB,EAAE,MAAM,CAAC;QACzB,sDAAsD;QACtD,GAAG,EAAE,MAAM,CAAC;QACZ,yFAAyF;QACzF,oBAAoB,EAAE,KAAK,CAAC;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAC,CAAC;KACpG,CAAC;CACH"}

package/dist/queries/focuses/ended-arm.js

@@ -0,0 +1,35 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/review-cycle-budget/review-cycle-cap-regression.test.ts,
+//   packages/daemon/src/completion/review-cycle-budget/review-cycle-churn-meter.test.ts
+// PINNED-BY-END
+/**
+ * The ENDED-ARM record: the shape the daemon sends with a release to state WHY
+ * it ended a focus's armed run.
+ *
+ * Its own module, not a member of queries/focuses/focuses.ts, because it is a wire
+ * SHAPE with two readers on different sides of the release -- the writer
+ * (focuses.ts releaseFocusArm) and the crossing that composes it
+ * (completion/review-cycle-budget/review-cycle-cap.ts) -- and focuses.ts sits at the file-size
+ * ceiling.
+ *
+ * @module queries/focuses/ended-arm
+ */
+/**
+ * The ended-arm record that rides a release, stating WHY the daemon ended the
+ * arm and what was still outstanding.
+ *
+ * ONE reason exists: 'review_budget_spent'. It is sent in the SAME call as the
+ * release (the edge refuses it otherwise, handlers/focus/arm-ended.ts) so the
+ * role-less focus is never readable without its reason, and so the record can
+ * never be mistaken for the operator stop (operator_stopped_at, which this path
+ * does not write) or the trigger's lifecycle clear (which writes neither).
+ *
+ * `detail` carries only what the DAEMON counted. The edge adds the acceptance
+ * criteria the last verdict-bearing review called not_met -- it owns the shape
+ * that record lives in -- so this daemon never parses a review summary.
+ *
+ * ARM_ENDED_REVIEW_BUDGET_SPENT is the value the DB CHECK constraint on
+ * product_focuses.arm_ended_reason allows and the wedge diagnosis reads back.
+ */
+export const ARM_ENDED_REVIEW_BUDGET_SPENT = 'review_budget_spent';
+//# sourceMappingURL=ended-arm.js.map

package/dist/queries/focuses/ended-arm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ended-arm.js","sourceRoot":"","sources":["../../../src/queries/focuses/ended-arm.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,qGAAqG;AACrG,wFAAwF;AACxF,gBAAgB;AAEhB;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,qBAAqB,CAAC"}

package/dist/queries/focuses/focus-criteria-standing.d.ts

@@ -0,0 +1,296 @@
+/**
+ * The FOCUS CRITERIA STANDING read: what a focus is FOR, and where each part of
+ * it stands. Two statements, both carried: the futures of the undesired effects
+ * its ARM covers (met only when verify recorded the future as landed), and the
+ * focus's OWN declared acceptance criteria (addressed when a current delivery
+ * declares one).
+ *
+ * EVERY ENUM HERE IS A DEPLOY-ORDER CONTRACT. The schemas are `.passthrough()`,
+ * so a field the edge adds costs nothing -- but an enum VALUE the edge adds and
+ * this daemon has not learned throws, and the one reader turns a throw into the
+ * explicit READ FAILED line. So the widening ships FIRST and the edge second;
+ * every optional field below is optional for the same reason, read from the
+ * other side.
+ *
+ * Read through the `focus_criteria_standing` product-api action
+ * (handlers/focus/criteria-standing.ts), which loads the focus's own
+ * `acceptance_criteria` plus its current non-cancelled deliveries and delegates
+ * every matching decision to the shared composer
+ * (`supabase/functions/_shared/focus-criteria-standing.ts`). NOTHING is re-decided here: this
+ * module is a typed wire boundary, not a second matcher. A daemon-side matcher
+ * would drift from the one a review later verdicts with, and the two would
+ * disagree about whether a criterion was ever addressed.
+ *
+ * WHY THE ACTION AND NOT THE FOCUS WIRE. `acceptance_criteria` is not carried on
+ * the daemon's focus wire contract (scripts/wire-contract-manifest.json), and
+ * the standing is a COMPUTATION over the focus plus every one of its
+ * deliveries, not a column. Widening the wire would ship the raw text and leave
+ * the daemon to re-derive the standing from it -- exactly the second matcher
+ * above. The action returns the computed standing, so the daemon stays a
+ * reader.
+ *
+ * The response is zod-validated at this boundary; a malformed payload throws
+ * like any other failed read, and the one reader (the
+ * `focus.criteria_standing` assembly resolver) renders an EXPLICIT failure line
+ * on a throw rather than an empty section.
+ *
+ * @module queries/focuses/focus-criteria-standing
+ */
+import { z } from 'zod';
+/** The product-api action that computes a focus's criteria standing. */
+export declare const FOCUS_CRITERIA_STANDING_ACTION = "focus_criteria_standing";
+/**
+ * One delivery's claim on one criterion.
+ *
+ * `matchBasis` is a plain string, NOT an enum: it is a label this daemon only
+ * echoes into prose, so a new basis added at the edge must not fail the whole
+ * read and cost the pass its entire standing section. Every field a decision
+ * hangs on below IS enumerated.
+ */
+declare const CriterionMatchSchema: z.ZodObject<{
+    deliveryId: z.ZodString;
+    deliveryName: z.ZodString;
+    matchBasis: z.ZodString;
+    overlap: z.ZodNumber;
+    matchedTokens: z.ZodArray<z.ZodString>;
+    significantTokenCount: z.ZodNumber;
+}, z.core.$loose>;
+/**
+ * What VERIFY recorded about a tree criterion's node -- carried out of the
+ * edge's landing predicate (`supabase/functions/_shared/effect-future-landed.ts`) verbatim.
+ *
+ * Every field here is a plain string, NOT an enum, for the same reason
+ * `matchBasis` is: the resolver only ECHOES them into prose. The met/open
+ * decision hangs on `status` above, which IS enumerated, so a new landing basis
+ * added at the edge must not cost the pass its whole standing section.
+ */
+declare const CriterionLandingSchema: z.ZodObject<{
+    standing: z.ZodString;
+    basis: z.ZodString;
+    classification: z.ZodNullable<z.ZodString>;
+    divergenceReason: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * One criterion and where it stands.
+ *
+ * `status` IS enumerated: rendering a criterion as met, addressed or open is
+ * the decision this whole section carries, so an unrecognized status must fail
+ * the read loudly rather than be printed as if it were understood. `'met'` and
+ * `'addressed'` are DIFFERENT claims and the resolver renders them as such --
+ * `'addressed'` says a delivery POINTS AT a declared criterion (scoping),
+ * `'met'` says verify RECORDED a tree criterion's declared future as landed
+ * (reality). A daemon that lacked `'met'` threw on every armed focus carrying
+ * one and rendered the READ FAILED line in place of the whole section; that is
+ * the failure this enum's width exists to prevent, and why widening it ships
+ * BEFORE the edge that emits the value.
+ *
+ * `source` and the three TREE-only fields are OPTIONAL, deliberately. The
+ * daemon deploys ahead of the edge, so for one window the edge answering this
+ * action is the older one that emits neither -- and a required field would
+ * invert the very deploy order this widening exists to honour. An absent
+ * `source` is rendered as UNSTATED rather than guessed at.
+ */
+declare const CriterionStandingSchema: z.ZodObject<{
+    criterion: z.ZodString;
+    addressedBy: z.ZodArray<z.ZodObject<{
+        deliveryId: z.ZodString;
+        deliveryName: z.ZodString;
+        matchBasis: z.ZodString;
+        overlap: z.ZodNumber;
+        matchedTokens: z.ZodArray<z.ZodString>;
+        significantTokenCount: z.ZodNumber;
+    }, z.core.$loose>>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        deliveryId: z.ZodString;
+        deliveryName: z.ZodString;
+        matchBasis: z.ZodString;
+        overlap: z.ZodNumber;
+        matchedTokens: z.ZodArray<z.ZodString>;
+        significantTokenCount: z.ZodNumber;
+    }, z.core.$loose>>>;
+    source: z.ZodOptional<z.ZodEnum<{
+        tree: "tree";
+        declared: "declared";
+    }>>;
+    nodeId: z.ZodOptional<z.ZodString>;
+    seq: z.ZodOptional<z.ZodNumber>;
+    drafted: z.ZodOptional<z.ZodBoolean>;
+    landing: z.ZodOptional<z.ZodObject<{
+        standing: z.ZodString;
+        basis: z.ZodString;
+        classification: z.ZodNullable<z.ZodString>;
+        divergenceReason: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>>;
+    status: z.ZodEnum<{
+        open: "open";
+        met: "met";
+        addressed: "addressed";
+    }>;
+}, z.core.$loose>;
+/**
+ * A covered undesired effect that states NO future. On an un-armed focus this
+ * is exactly what the arm would REFUSE on, named by the same `seq` the refusal
+ * message names -- which is the whole value of the un-armed preview.
+ */
+declare const UnstatedCoveredEffectSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    seq: z.ZodNumber;
+    statement: z.ZodString;
+}, z.core.$loose>;
+/** A covered undesired effect whose future is only a MACHINE DRAFT. */
+declare const DraftedCoveredEffectSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    seq: z.ZodNumber;
+    draft: z.ZodString;
+}, z.core.$loose>;
+/**
+ * The bounds the edge's TREE scans applied. OPTIONAL for the same reason
+ * `deliveryScan` is, and reported for a sharper reason: a truncated NODE scan
+ * can only move a criterion toward open, but a truncated EDGE scan SHRINKS a
+ * live-derived bar, so a caller must never be left to assume it saw the whole
+ * tree.
+ */
+declare const TreeScanSchema: z.ZodObject<{
+    limit: z.ZodNumber;
+    injections: z.ZodNumber;
+    edges: z.ZodNumber;
+    nodes: z.ZodNumber;
+    truncated: z.ZodBoolean;
+}, z.core.$loose>;
+/**
+ * The bounds the edge's delivery scan applied. OPTIONAL on purpose: if a future
+ * edge stops reporting it, the standing itself is still usable and the resolver
+ * says the bounds were not reported. An absent bound is STATED, never silently
+ * treated as "the whole focus was scanned".
+ */
+declare const DeliveryScanSchema: z.ZodObject<{
+    limit: z.ZodNumber;
+    scanned: z.ZodNumber;
+    evaluated: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    anchors: z.ZodOptional<z.ZodNumber>;
+    anchorsTruncated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * The standing. `floorBasis` is enumerated deliberately: `no_criteria_declared`
+ * is NOT a floor, and the difference between it and `all_criteria_addressed` is
+ * the entire point of the read. A basis this daemon cannot interpret must throw
+ * -- rendering an unknown basis would be guessing at exactly the value that
+ * decides whether the elaboration loop stops.
+ *
+ * `derived_live_unarmed` is the fourth member and a FIFTH situation: the tree
+ * half is a PREVIEW of the bar an arm would stamp, so there is no stamped bar
+ * to have reached. It is neither a floor nor a missed floor, and the resolver
+ * renders it as its own line.
+ *
+ * `treeBasis` is enumerated for the same reason -- it answers "whose statement
+ * of the bar am I reading", and an un-armed PREVIEW must never be rendered as
+ * the arm's own stamp -- but it is OPTIONAL: an edge predating the tree half
+ * reports none, and the resolver says the tree half was not reported rather
+ * than inventing one.
+ */
+export declare const FocusCriteriaStandingSchema: z.ZodObject<{
+    focusId: z.ZodString;
+    criteria: z.ZodArray<z.ZodObject<{
+        criterion: z.ZodString;
+        addressedBy: z.ZodArray<z.ZodObject<{
+            deliveryId: z.ZodString;
+            deliveryName: z.ZodString;
+            matchBasis: z.ZodString;
+            overlap: z.ZodNumber;
+            matchedTokens: z.ZodArray<z.ZodString>;
+            significantTokenCount: z.ZodNumber;
+        }, z.core.$loose>>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            deliveryId: z.ZodString;
+            deliveryName: z.ZodString;
+            matchBasis: z.ZodString;
+            overlap: z.ZodNumber;
+            matchedTokens: z.ZodArray<z.ZodString>;
+            significantTokenCount: z.ZodNumber;
+        }, z.core.$loose>>>;
+        source: z.ZodOptional<z.ZodEnum<{
+            tree: "tree";
+            declared: "declared";
+        }>>;
+        nodeId: z.ZodOptional<z.ZodString>;
+        seq: z.ZodOptional<z.ZodNumber>;
+        drafted: z.ZodOptional<z.ZodBoolean>;
+        landing: z.ZodOptional<z.ZodObject<{
+            standing: z.ZodString;
+            basis: z.ZodString;
+            classification: z.ZodNullable<z.ZodString>;
+            divergenceReason: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>>;
+        status: z.ZodEnum<{
+            open: "open";
+            met: "met";
+            addressed: "addressed";
+        }>;
+    }, z.core.$loose>>;
+    floorReached: z.ZodBoolean;
+    floorBasis: z.ZodEnum<{
+        all_criteria_addressed: "all_criteria_addressed";
+        open_criteria_remain: "open_criteria_remain";
+        no_criteria_declared: "no_criteria_declared";
+        derived_live_unarmed: "derived_live_unarmed";
+        derived_live_incomplete: "derived_live_incomplete";
+    }>;
+    treeBasis: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        derived_live_unarmed: "derived_live_unarmed";
+        armed_stamp: "armed_stamp";
+        derived_live_unstamped_arm: "derived_live_unstamped_arm";
+    }>>;
+    unstatedCoveredEffects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        seq: z.ZodNumber;
+        statement: z.ZodString;
+    }, z.core.$loose>>>;
+    draftedCoveredEffects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        seq: z.ZodNumber;
+        draft: z.ZodString;
+    }, z.core.$loose>>>;
+    treeCoverageIncomplete: z.ZodOptional<z.ZodBoolean>;
+    armWouldRefuseNoEffect: z.ZodOptional<z.ZodBoolean>;
+    openCriteria: z.ZodArray<z.ZodString>;
+    deliveryScan: z.ZodOptional<z.ZodObject<{
+        limit: z.ZodNumber;
+        scanned: z.ZodNumber;
+        evaluated: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        anchors: z.ZodOptional<z.ZodNumber>;
+        anchorsTruncated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    treeScan: z.ZodOptional<z.ZodObject<{
+        limit: z.ZodNumber;
+        injections: z.ZodNumber;
+        edges: z.ZodNumber;
+        nodes: z.ZodNumber;
+        truncated: z.ZodBoolean;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** One delivery's claim on one criterion, with its evidence. */
+export type CriterionMatch = z.infer<typeof CriterionMatchSchema>;
+/** One criterion -- tree or declared -- and its standing. */
+export type CriterionStanding = z.infer<typeof CriterionStandingSchema>;
+/** What verify recorded about a tree criterion's node. */
+export type CriterionLanding = z.infer<typeof CriterionLandingSchema>;
+/** A covered undesired effect stating no future -- what an arm would refuse on. */
+export type UnstatedCoveredEffect = z.infer<typeof UnstatedCoveredEffectSchema>;
+/** A covered undesired effect whose stated future is a machine draft. */
+export type DraftedCoveredEffect = z.infer<typeof DraftedCoveredEffectSchema>;
+/** The bounds the edge's delivery scan applied, when it reported them. */
+export type CriteriaDeliveryScan = z.infer<typeof DeliveryScanSchema>;
+/** The bounds the edge's tree scans applied, when it reported them. */
+export type CriteriaTreeScan = z.infer<typeof TreeScanSchema>;
+/** A focus's declared criteria measured against its current deliveries. */
+export type FocusCriteriaStanding = z.infer<typeof FocusCriteriaStandingSchema>;
+/**
+ * Read a focus's criteria standing. Throws on a failed or malformed read --
+ * the caller renders that as an explicit failure, never as an empty section.
+ */
+export declare function getFocusCriteriaStanding(focusId: string): Promise<FocusCriteriaStanding>;
+export {};
+//# sourceMappingURL=focus-criteria-standing.d.ts.map

package/dist/queries/focuses/focus-criteria-standing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-criteria-standing.d.ts","sourceRoot":"","sources":["../../../src/queries/focuses/focus-criteria-standing.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,wEAAwE;AACxE,eAAO,MAAM,8BAA8B,4BAA4B,CAAC;AAExE;;;;;;;GAOG;AACH,QAAA,MAAM,oBAAoB;;;;;;;iBAOV,CAAC;AAEjB;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB;;;;;iBAKZ,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgBb,CAAC;AAEjB;;;;GAIG;AACH,QAAA,MAAM,2BAA2B;;;;iBAIjB,CAAC;AAEjB,uEAAuE;AACvE,QAAA,MAAM,0BAA0B;;;;iBAIhB,CAAC;AAEjB;;;;;;GAMG;AACH,QAAA,MAAM,cAAc;;;;;;iBAMJ,CAAC;AAEjB;;;;;GAKG;AACH,QAAA,MAAM,kBAAkB;;;;;;;iBAmBR,CAAC;AAEjB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCxB,CAAC;AAEjB,gEAAgE;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,6DAA6D;AAC7D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,mFAAmF;AACnF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,yEAAyE;AACzE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,0EAA0E;AAC1E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEtE,uEAAuE;AACvE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE9D,2EAA2E;AAC3E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,CAAC,CAEhC"}

package/dist/queries/focuses/focus-criteria-standing.js

@@ -0,0 +1,232 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/resolvers/focus-criteria-standing.test.ts
+// PINNED-BY-END
+/**
+ * The FOCUS CRITERIA STANDING read: what a focus is FOR, and where each part of
+ * it stands. Two statements, both carried: the futures of the undesired effects
+ * its ARM covers (met only when verify recorded the future as landed), and the
+ * focus's OWN declared acceptance criteria (addressed when a current delivery
+ * declares one).
+ *
+ * EVERY ENUM HERE IS A DEPLOY-ORDER CONTRACT. The schemas are `.passthrough()`,
+ * so a field the edge adds costs nothing -- but an enum VALUE the edge adds and
+ * this daemon has not learned throws, and the one reader turns a throw into the
+ * explicit READ FAILED line. So the widening ships FIRST and the edge second;
+ * every optional field below is optional for the same reason, read from the
+ * other side.
+ *
+ * Read through the `focus_criteria_standing` product-api action
+ * (handlers/focus/criteria-standing.ts), which loads the focus's own
+ * `acceptance_criteria` plus its current non-cancelled deliveries and delegates
+ * every matching decision to the shared composer
+ * (`supabase/functions/_shared/focus-criteria-standing.ts`). NOTHING is re-decided here: this
+ * module is a typed wire boundary, not a second matcher. A daemon-side matcher
+ * would drift from the one a review later verdicts with, and the two would
+ * disagree about whether a criterion was ever addressed.
+ *
+ * WHY THE ACTION AND NOT THE FOCUS WIRE. `acceptance_criteria` is not carried on
+ * the daemon's focus wire contract (scripts/wire-contract-manifest.json), and
+ * the standing is a COMPUTATION over the focus plus every one of its
+ * deliveries, not a column. Widening the wire would ship the raw text and leave
+ * the daemon to re-derive the standing from it -- exactly the second matcher
+ * above. The action returns the computed standing, so the daemon stays a
+ * reader.
+ *
+ * The response is zod-validated at this boundary; a malformed payload throws
+ * like any other failed read, and the one reader (the
+ * `focus.criteria_standing` assembly resolver) renders an EXPLICIT failure line
+ * on a throw rather than an empty section.
+ *
+ * @module queries/focuses/focus-criteria-standing
+ */
+import { z } from 'zod';
+import { callApiValidated } from '../api-client/shared.js';
+/** The product-api action that computes a focus's criteria standing. */
+export const FOCUS_CRITERIA_STANDING_ACTION = 'focus_criteria_standing';
+/**
+ * One delivery's claim on one criterion.
+ *
+ * `matchBasis` is a plain string, NOT an enum: it is a label this daemon only
+ * echoes into prose, so a new basis added at the edge must not fail the whole
+ * read and cost the pass its entire standing section. Every field a decision
+ * hangs on below IS enumerated.
+ */
+const CriterionMatchSchema = z.object({
+    deliveryId: z.string(),
+    deliveryName: z.string(),
+    matchBasis: z.string(),
+    overlap: z.number(),
+    matchedTokens: z.array(z.string()),
+    significantTokenCount: z.number(),
+}).passthrough();
+/**
+ * What VERIFY recorded about a tree criterion's node -- carried out of the
+ * edge's landing predicate (`supabase/functions/_shared/effect-future-landed.ts`) verbatim.
+ *
+ * Every field here is a plain string, NOT an enum, for the same reason
+ * `matchBasis` is: the resolver only ECHOES them into prose. The met/open
+ * decision hangs on `status` above, which IS enumerated, so a new landing basis
+ * added at the edge must not cost the pass its whole standing section.
+ */
+const CriterionLandingSchema = z.object({
+    standing: z.string(),
+    basis: z.string(),
+    classification: z.string().nullable(),
+    divergenceReason: z.string().nullable(),
+}).passthrough();
+/**
+ * One criterion and where it stands.
+ *
+ * `status` IS enumerated: rendering a criterion as met, addressed or open is
+ * the decision this whole section carries, so an unrecognized status must fail
+ * the read loudly rather than be printed as if it were understood. `'met'` and
+ * `'addressed'` are DIFFERENT claims and the resolver renders them as such --
+ * `'addressed'` says a delivery POINTS AT a declared criterion (scoping),
+ * `'met'` says verify RECORDED a tree criterion's declared future as landed
+ * (reality). A daemon that lacked `'met'` threw on every armed focus carrying
+ * one and rendered the READ FAILED line in place of the whole section; that is
+ * the failure this enum's width exists to prevent, and why widening it ships
+ * BEFORE the edge that emits the value.
+ *
+ * `source` and the three TREE-only fields are OPTIONAL, deliberately. The
+ * daemon deploys ahead of the edge, so for one window the edge answering this
+ * action is the older one that emits neither -- and a required field would
+ * invert the very deploy order this widening exists to honour. An absent
+ * `source` is rendered as UNSTATED rather than guessed at.
+ */
+const CriterionStandingSchema = z.object({
+    criterion: z.string(),
+    addressedBy: z.array(CriterionMatchSchema),
+    /** Weak, NON-CLOSING signals. Absent on an edge predating the field. */
+    evidence: z.array(CriterionMatchSchema).optional(),
+    /** WHICH statement this came from, and therefore which rule judged it. */
+    source: z.enum(['tree', 'declared']).optional(),
+    /** TREE only: `reality_tree_nodes.id` of the covered undesired effect. */
+    nodeId: z.string().optional(),
+    /** TREE only: `reality_tree_nodes.seq` -- how a human names the node. */
+    seq: z.number().optional(),
+    /** TREE only: a MACHINE wrote this future and a human accepted it by arming. */
+    drafted: z.boolean().optional(),
+    /** TREE only: what verify recorded about the node. See the schema. */
+    landing: CriterionLandingSchema.optional(),
+    status: z.enum(['addressed', 'met', 'open']),
+}).passthrough();
+/**
+ * A covered undesired effect that states NO future. On an un-armed focus this
+ * is exactly what the arm would REFUSE on, named by the same `seq` the refusal
+ * message names -- which is the whole value of the un-armed preview.
+ */
+const UnstatedCoveredEffectSchema = z.object({
+    nodeId: z.string(),
+    seq: z.number(),
+    statement: z.string(),
+}).passthrough();
+/** A covered undesired effect whose future is only a MACHINE DRAFT. */
+const DraftedCoveredEffectSchema = z.object({
+    nodeId: z.string(),
+    seq: z.number(),
+    draft: z.string(),
+}).passthrough();
+/**
+ * The bounds the edge's TREE scans applied. OPTIONAL for the same reason
+ * `deliveryScan` is, and reported for a sharper reason: a truncated NODE scan
+ * can only move a criterion toward open, but a truncated EDGE scan SHRINKS a
+ * live-derived bar, so a caller must never be left to assume it saw the whole
+ * tree.
+ */
+const TreeScanSchema = z.object({
+    limit: z.number(),
+    injections: z.number(),
+    edges: z.number(),
+    nodes: z.number(),
+    truncated: z.boolean(),
+}).passthrough();
+/**
+ * The bounds the edge's delivery scan applied. OPTIONAL on purpose: if a future
+ * edge stops reporting it, the standing itself is still usable and the resolver
+ * says the bounds were not reported. An absent bound is STATED, never silently
+ * treated as "the whole focus was scanned".
+ */
+const DeliveryScanSchema = z.object({
+    limit: z.number(),
+    scanned: z.number(),
+    evaluated: z.number(),
+    truncated: z.boolean(),
+    /**
+     * Injection anchors the TREE half was derived over. OPTIONAL: the edge that
+     * resolves anchors separately from the bounded delivery rows ships AFTER
+     * this daemon, so for one window the answer carries neither this nor
+     * `anchorsTruncated`.
+     */
+    anchors: z.number().optional(),
+    /**
+     * True when the separate anchor read hit its own bound -- the only case in
+     * which a truncated delivery scan still shortens the tree half. Absent means
+     * the edge did not resolve anchors separately, which the resolver reports as
+     * the weaker reading rather than as "the tree half is whole".
+     */
+    anchorsTruncated: z.boolean().optional(),
+}).passthrough();
+/**
+ * The standing. `floorBasis` is enumerated deliberately: `no_criteria_declared`
+ * is NOT a floor, and the difference between it and `all_criteria_addressed` is
+ * the entire point of the read. A basis this daemon cannot interpret must throw
+ * -- rendering an unknown basis would be guessing at exactly the value that
+ * decides whether the elaboration loop stops.
+ *
+ * `derived_live_unarmed` is the fourth member and a FIFTH situation: the tree
+ * half is a PREVIEW of the bar an arm would stamp, so there is no stamped bar
+ * to have reached. It is neither a floor nor a missed floor, and the resolver
+ * renders it as its own line.
+ *
+ * `treeBasis` is enumerated for the same reason -- it answers "whose statement
+ * of the bar am I reading", and an un-armed PREVIEW must never be rendered as
+ * the arm's own stamp -- but it is OPTIONAL: an edge predating the tree half
+ * reports none, and the resolver says the tree half was not reported rather
+ * than inventing one.
+ */
+export const FocusCriteriaStandingSchema = z.object({
+    focusId: z.string(),
+    criteria: z.array(CriterionStandingSchema),
+    floorReached: z.boolean(),
+    floorBasis: z.enum([
+        'all_criteria_addressed',
+        'open_criteria_remain',
+        'no_criteria_declared',
+        'derived_live_unarmed',
+        // The FIFTH member: a live derivation over coverage the edge could not
+        // fully resolve. Learned here BEFORE the edge can emit it -- that is the
+        // whole deploy-order contract this schema's header states, and an enum
+        // value is exactly the kind of widening that must ship first.
+        'derived_live_incomplete',
+    ]),
+    treeBasis: z
+        .enum(['armed_stamp', 'derived_live_unstamped_arm', 'derived_live_unarmed', 'none'])
+        .optional(),
+    unstatedCoveredEffects: z.array(UnstatedCoveredEffectSchema).optional(),
+    draftedCoveredEffects: z.array(DraftedCoveredEffectSchema).optional(),
+    /**
+     * True when the tree half was derived LIVE over coverage the edge could not
+     * fully resolve, so a criterion may be MISSING from the list entirely.
+     * OPTIONAL for the deploy order: the edge that computes it ships after this
+     * daemon, and an absent flag means the older edge, not "the bar is whole".
+     */
+    treeCoverageIncomplete: z.boolean().optional(),
+    /**
+     * True when a live derivation walked real coverage and found no judgeable
+     * undesired effect in it -- the `arm_criteria_required` refusal an arm would
+     * raise right now. OPTIONAL for the same deploy-order reason.
+     */
+    armWouldRefuseNoEffect: z.boolean().optional(),
+    openCriteria: z.array(z.string()),
+    deliveryScan: DeliveryScanSchema.optional(),
+    treeScan: TreeScanSchema.optional(),
+}).passthrough();
+/**
+ * Read a focus's criteria standing. Throws on a failed or malformed read --
+ * the caller renders that as an explicit failure, never as an empty section.
+ */
+export async function getFocusCriteriaStanding(focusId) {
+    return callApiValidated(FOCUS_CRITERIA_STANDING_ACTION, FocusCriteriaStandingSchema, { focusId });
+}
+//# sourceMappingURL=focus-criteria-standing.js.map

package/dist/queries/focuses/focus-criteria-standing.js.map

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