@telora/daemon 0.22.181 → 0.22.187

package/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commitSha": "95e96fd64",
-  "builtAt": "2026-09-22T00:40:56.533Z",
+  "commitSha": "db7b06909",
+  "builtAt": "2026-09-23T12:14:56.419Z",
   "expectedMigrations": [
     "20250829113330_create_org_nodes_table.sql",
     "20250829113402_fix_function_security_search_path.sql",
@@ -819,6 +819,12 @@
     "20260920213405_arm_covered_targets_are_fixed_at_the_arm.sql",
     "20260920220952_playbooks_organization_id_nullable.sql",
     "20260920225339_builtin_workflow_child_policies_authorize_on_entity.sql",
-    "20260921000043_stamp_arm_covered_target_nodes.sql"
+    "20260921000043_stamp_arm_covered_target_nodes.sql",
+    "20260922150418_product_request_source_and_mirrored_nodes.sql",
+    "20260922173056_arm_states_the_future_it_covers.sql",
+    "20260922185904_focus_debug_arm_refused_section.sql",
+    "20260922221935_product_request_observation_snapshot.sql",
+    "20260922225316_product_request_observation_entry_is_atomic.sql",
+    "20260923002532_capture_request_observation_in_one_snapshot.sql"
   ]
 }

package/dist/audit/audit-floor-policy.d.ts

@@ -0,0 +1,188 @@
+/**
+ * The AUDIT FLOOR: the round-5 pre-condition, as DATA.
+ *
+ * Split out of `audit-prompt.ts` when that file crossed the daemon file-size
+ * gate. Nothing about the floor changed in the move: this module owns the
+ * policy structure, the closed lexicon its sentences are composed from, the
+ * backstop over its remaining prose, and the renderers; `audit-prompt.ts` owns
+ * the prompt that embeds the rendered section. The pin that guarantees the
+ * whole rendered section (`FLOOR_SECTION_PIN` in `audit-phase.test.ts`) is
+ * unmoved and unchanged, which is what makes this a MOVE rather than an edit.
+ *
+ * @module audit/audit-floor-policy
+ */
+/**
+ * Round-5 pre-condition: the focus's own declared floor.
+ *
+ * Deliberately OUTSIDE the SHARED-AUDIT-GUIDE sentinels, for the same reason
+ * the residue hold below is: it states a precondition that only a pass holding
+ * the daemon's `focus.criteria_standing` section can satisfy, and the MCP
+ * guide's readers have no such section.
+ *
+ * WHY IT EXISTS. Round 5 anchors one remediation delivery per injection, and
+ * nothing in that loop ever asked what the focus SAID IT WAS FOR. An
+ * elaboration loop with no stated stopping condition does not stop -- it runs
+ * until someone gets tired -- so a focus grows deliveries while its declared
+ * criteria sit close to met. The standing section is the stated condition; this
+ * text is what makes the pass CONSULT it before it anchors, rather than after.
+ *
+ * The bases are given distinct instructions on purpose. The one that must not
+ * collapse into the others is `no_criteria_declared`: an empty criteria set is
+ * UNMEASURED, not arrived, and a pass that read it as a floor would stop
+ * hardest on exactly the focuses that declared nothing to be measured against.
+ *
+ * WHAT THE FLOOR IS NOT (round-5 correction, 2026-09-18). An earlier wording
+ * made CRITERION COVERAGE the test for whether a new root cause could be
+ * anchored, which converts the floor into the freeze the request rules out: a
+ * genuinely new root cause is perfectly capable of sitting inside an
+ * already-addressed criterion, and suppressing it there loses real signal to a
+ * bookkeeping fact about which criteria have deliveries pointing at them. The
+ * floor turns on RESIDUE (or restatement) vs GENUINELY NEW ROOT CAUSE, which
+ * is orthogonal to coverage: coverage answers "is there open declared work?",
+ * never "is this cause new?".
+ *
+ * WHY THE FLOOR IS DATA (rounds 6-7, 2026-09-19). Two earlier guards READ the
+ * hand-written floor prose looking for a restriction -- one sentence at a time,
+ * then across a wider window -- and both lost the same way: the restriction
+ * moved to a sentence the reading missed, or a wording its vocabulary lacked.
+ * So the normative content became the structure below, the prose became its
+ * rendering, and no rule carries a sentence of its own. The normative sentence
+ * is COMPOSED from the rule's typed fields against a CLOSED lexicon
+ * (`CANDIDATE_SUBJECT`, `DISPOSITION_VERB`, `UNCONDITIONAL_SCOPE`): subject
+ * from `candidate`, verb from `disposition`, scope from `conditions`, where an
+ * empty `conditions` renders an explicit "in every case this basis can present"
+ * rather than a silence a reader fills with the old freeze. Keep that: it makes
+ * a CONDITION countable instead of something to read prose for.
+ *
+ * WHY THE REMAINING PROSE IS PINNED BY EQUALITY (round-8 correction,
+ * 2026-09-19). Round 7 left the context prose -- leads, situations, caveats,
+ * obligations, and the two paragraphs `renderFloorSection` writes directly --
+ * guarded by `findFloorProseViolations`, and the commit that shipped it called
+ * that "a whitelist of CHANNEL, not an enumeration of wording". THAT CLAIM WAS
+ * FALSE, and review demonstrated it. `CANDIDATE_NOUN` and
+ * `DISPOSITION_VERB_IN_PROSE` are finite regex vocabularies, so the guard only
+ * recognised a normative claim written in words it already knew: appending
+ * "Fresh findings wait for review." or "A genuinely new root cause proceeds
+ * after every existing delivery is reviewed." draws NO violation and renders a
+ * contradictory restriction. Fourth iteration of one lesson, now unmistakable:
+ * ANY guard asking "does this text MEAN something normative?" loses, because
+ * meaning is open-ended.
+ *
+ * So the floor stops asking. This policy is a static constant, so the strings
+ * it can put in front of an assessor are a fixed, finite set, and the PRIMARY
+ * GUARANTEE is an equality pin on the whole rendered section:
+ * `FLOOR_SECTION_PIN` in audit-phase.test.ts holds an independent copy and the
+ * suite asserts `renderFloorSection()` equals it line for line. A synonym, an
+ * unlisted vocabulary and a wording nobody imagined then fail identically --
+ * not because a rule recognises them, but because none of them are the pinned
+ * string. It covers EVERY string the assessor reads here, the two paragraphs
+ * `renderFloorSection` writes among them, which no field-level guard ever saw.
+ *
+ * The cost is the intended one: editing floor prose is a TWO-PLACE, VISIBLE act
+ * -- the author updates the pin in the same change and a reviewer reads both
+ * halves. The pin is literal text rather than a checksum precisely so that
+ * second half stays readable. Its LIMIT, plainly: the pin is scoped to this
+ * floor section. It does not cover `AUDIT_UNREVIEWED_RESIDUE`, the posture
+ * sections, or `AUDIT_GUIDE_SHARED` (which carries its own byte pin against the
+ * MCP copy, in audit-guide-sync.test.ts).
+ */
+/** A candidate for anchoring, in the floor's own terms. */
+export type AnchorCandidate = 'residue_or_restatement' | 'new_root_cause';
+/** What the floor does with a candidate. */
+export type AnchorDisposition = 'withhold' | 'anchor';
+/**
+ * A fact a pass could mistake for the test. A factor named here is rendered as
+ * explicitly NOT deciding; it may never appear as a condition (tests pin that).
+ */
+export type NonDecidingFactor = 'criterion_coverage';
+/**
+ * One normative rule of the floor: what happens to a candidate, and on what.
+ *
+ * Every field is a typed enum or a DECLARED list. There is deliberately no
+ * sentence field: the rule's sentence is composed from these fields, because a
+ * hand-written sentence is the one place a restriction can sit where no
+ * structural channel sees it.
+ */
+export interface AnchoringRule {
+    readonly candidate: AnchorCandidate;
+    readonly disposition: AnchorDisposition;
+    /**
+     * Conditions the disposition genuinely depends on. EMPTY means
+     * UNCONDITIONAL. This is the ONLY door through which a condition on
+     * anchoring can reach the rendered prompt.
+     */
+    readonly conditions: readonly string[];
+    /** Facts that never decide this disposition; rendered as "not the test". */
+    readonly nonDeciding: readonly NonDecidingFactor[];
+    /** What is OWED when the disposition is exercised. An obligation is not a gate. */
+    readonly obligations: readonly string[];
+}
+/** One basis the criteria-standing section can report, with its own rules. */
+export interface FloorBasis {
+    /** Machine token the standing section reports (or `read_failed`). */
+    readonly basis: string;
+    /** Whether this basis IS a floor. `no_criteria_declared` is NOT one. */
+    readonly isFloor: boolean;
+    /** Bolded opening of the rendered bullet. Context, never a disposition. */
+    readonly lead: string;
+    /** What the basis means, before any rule applies. Context, never a disposition. */
+    readonly situation: string;
+    readonly rules: readonly AnchoringRule[];
+    /** Closing clarification for the basis. Context, never a disposition. */
+    readonly caveat?: string;
+}
+/** The floor's whole normative content, in one declarable structure. */
+export interface FloorPolicy {
+    /** Bolded opening of the universal paragraph. */
+    readonly universalLead: string;
+    /** Rules that hold at EVERY basis. */
+    readonly universal: readonly AnchoringRule[];
+    /** Closing prose of the universal paragraph. Context, never a disposition. */
+    readonly universalClosing: readonly string[];
+    readonly bases: readonly FloorBasis[];
+}
+/**
+ * The declared floor. Everything normative the floor says about what may be
+ * anchored is in the TYPED fields here; the prose below is generated from
+ * them, and the free-text fields carry context only.
+ */
+export declare const AUDIT_FLOOR_POLICY: FloorPolicy;
+/** Where a rule is being stated: the universal paragraph, or one basis. */
+export type RuleScope = 'universal' | 'basis';
+/** A free-text field of the policy, with the path it sits at. */
+export interface ProseField {
+    readonly path: string;
+    readonly text: string;
+}
+/** A prose field that has strayed into stating the floor's normative content. */
+export interface FloorProseViolation {
+    readonly path: string;
+    readonly text: string;
+    readonly reason: string;
+}
+/**
+ * Every free-text field of the policy. `conditions` is deliberately absent: it
+ * IS the declared channel for a scope, and it is counted rather than banned.
+ *
+ * Exported so the suite can prove the equality pin COVERS this set (every
+ * field's exact text appears verbatim inside the pinned render) rather than
+ * trusting a hand-maintained field list that goes stale on the next addition.
+ */
+export declare function floorProseFields(policy?: FloorPolicy): readonly ProseField[];
+/**
+ * Prose fields that state normative content IN A WORDING THESE LISTS KNOW. An
+ * empty result means "nothing recognised", NEVER "nothing normative" -- see the
+ * BACKSTOP note above for why no wording list can mean the latter. The
+ * completeness guarantee is the equality pin in audit-phase.test.ts; this only
+ * makes the recognised cases fail earlier, at load, with a named path. Exported
+ * so a test can demonstrate rejection on a mutated policy.
+ */
+export declare function findFloorProseViolations(policy?: FloorPolicy): readonly FloorProseViolation[];
+/** Render the policy: the universal paragraph, then one bullet per basis. */
+export declare function renderFloorPolicy(policy?: FloorPolicy): readonly string[];
+/**
+ * The composed floor section: the pointer at the standing section (which
+ * states no rule about what may be anchored), then the rendered policy.
+ */
+export declare function renderFloorSection(policy?: FloorPolicy): readonly string[];
+//# sourceMappingURL=audit-floor-policy.d.ts.map

package/dist/audit/audit-floor-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-floor-policy.d.ts","sourceRoot":"","sources":["../../src/audit/audit-floor-policy.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AAEH,2DAA2D;AAC3D,MAAM,MAAM,eAAe,GAAG,wBAAwB,GAAG,gBAAgB,CAAC;AAE1E,4CAA4C;AAC5C,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEtD;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AAErD;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACnD,mFAAmF;IACnF,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED,8EAA8E;AAC9E,MAAM,WAAW,UAAU;IACzB,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,wEAAwE;AACxE,MAAM,WAAW,WAAW;IAC1B,iDAAiD;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,sCAAsC;IACtC,QAAQ,CAAC,SAAS,EAAE,SAAS,aAAa,EAAE,CAAC;IAC7C,8EAA8E;IAC9E,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC;AAcD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAoHhC,CAAC;AAEF,2EAA2E;AAC3E,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;AA6F9C,iEAAiE;AACjE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,iFAAiF;AACjF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,GAAE,WAAgC,GAAG,SAAS,UAAU,EAAE,CAkBhG;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,GAAE,WAAgC,GACvC,SAAS,mBAAmB,EAAE,CAwBhC;AA2ED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,WAAgC,GAAG,SAAS,MAAM,EAAE,CAS7F;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,GAAE,WAAgC,GAAG,SAAS,MAAM,EAAE,CAS9F"}

package/dist/audit/audit-floor-policy.js

@@ -0,0 +1,353 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/audit/audit-phase.test.ts
+// PINNED-BY-END
+/**
+ * The withhold half of the test, identical wherever it is stated: the same
+ * candidate, the same disposition, no conditions anywhere.
+ */
+const WITHHOLD_RESIDUE = {
+    candidate: 'residue_or_restatement',
+    disposition: 'withhold',
+    conditions: [],
+    nonDeciding: [],
+    obligations: [],
+};
+/**
+ * The declared floor. Everything normative the floor says about what may be
+ * anchored is in the TYPED fields here; the prose below is generated from
+ * them, and the free-text fields carry context only.
+ */
+export const AUDIT_FLOOR_POLICY = {
+    universalLead: 'The floor stops ELABORATION, not new work.',
+    universal: [
+        WITHHOLD_RESIDUE,
+        {
+            candidate: 'new_root_cause',
+            disposition: 'anchor',
+            conditions: [],
+            nonDeciding: ['criterion_coverage'],
+            obligations: ['why the cause is new rather than residue or a restatement'],
+        },
+    ],
+    universalClosing: [
+        'Anchoring past a reached floor is a DECLARED act, never a silent one -- but it is declared by what you DRAW, not by what you write. On an armed focus a delivery that serves no effect the arm covers is recorded and waits for the next arm; to have it run now, draw the causal edge that makes it means. There is no reason field that substitutes for the edge.',
+    ],
+    bases: [
+        {
+            basis: 'all_criteria_addressed',
+            isFloor: true,
+            lead: 'Basis `all_criteria_addressed` -- the floor is REACHED.',
+            situation: 'Every criterion the focus declared already has a delivery pointing at it, so there is no OPEN declared work to elaborate against.',
+            rules: [
+                WITHHOLD_RESIDUE,
+                {
+                    candidate: 'new_root_cause',
+                    disposition: 'anchor',
+                    conditions: [],
+                    nonDeciding: ['criterion_coverage'],
+                    obligations: [
+                        'why the cause is new rather than residue or a restatement',
+                        'which criterion it touches',
+                    ],
+                },
+            ],
+            caveat: 'Note what the basis does NOT mean: addressed is not MET. Whether the work satisfies a criterion is the focus review\'s judgement, not yours, so "the floor is reached" is never "the focus is done" -- it is "there is nothing further for THIS pass to ELABORATE".',
+        },
+        {
+            basis: 'open_criteria_remain',
+            isFloor: false,
+            lead: 'Basis `open_criteria_remain` -- the open criteria ARE the remaining work.',
+            situation: 'Work against them by name: each injection you author should trace to an OPEN criterion, and your audit summary should say which.',
+            rules: [
+                {
+                    candidate: 'new_root_cause',
+                    disposition: 'anchor',
+                    conditions: [],
+                    nonDeciding: [],
+                    obligations: [],
+                },
+            ],
+            caveat: 'A new delivery that addresses no open criterion needs an explicit reason for existing, stated in the summary.',
+        },
+        {
+            basis: 'no_criteria_declared',
+            isFloor: false,
+            lead: 'Basis `no_criteria_declared` -- this is NOT a floor.',
+            situation: 'A focus that declared no acceptance criteria has gone UNMEASURED, not arrived. The act that produces criteria is concrete and it is yours: give each delivery an injection (`telora_product_delivery` create/update with `injectionNodeId`), and state the declared future -- the `frt_statement` -- on every undesired effect that injection targets (`telora_reality_tree_node` update). Those futures ARE this focus\'s criteria: an arm stamps them as the bar, and verify judges them against reality. An empty set means that act has not happened here yet, which is a fact about the tree and never a measurement of the work.',
+            rules: [
+                WITHHOLD_RESIDUE,
+                {
+                    candidate: 'new_root_cause',
+                    disposition: 'anchor',
+                    conditions: [],
+                    nonDeciding: [],
+                    obligations: [
+                        'that this focus declares no criteria, so no floor could be computed for it',
+                    ],
+                },
+            ],
+            caveat: 'Do not read the empty set as "everything is addressed", and do not read it as licence to elaborate without limit: judge each candidate on the tree\'s own evidence.',
+        },
+        {
+            basis: 'derived_live_unarmed',
+            isFloor: false,
+            lead: 'Basis `derived_live_unarmed` -- there is no floor to reach yet.',
+            situation: 'This focus is UN-ARMED, so the criteria in that section are a PREVIEW of the bar an arm would stamp, derived live from the tree rather than recorded by any arm. Nothing has been stamped, so nothing can have been reached. That section also names the covered effects stating NO future -- what an arm would refuse on -- and the ones whose future is a machine draft; stating those futures is work owed before a human can arm this focus at all.',
+            rules: [
+                WITHHOLD_RESIDUE,
+                {
+                    candidate: 'new_root_cause',
+                    disposition: 'anchor',
+                    conditions: [],
+                    nonDeciding: [],
+                    obligations: [
+                        'that this focus is un-armed, so the criteria you read were a preview rather than a stamped bar',
+                    ],
+                },
+            ],
+            caveat: 'Do not read a preview as a floor, and do not read it as licence to elaborate without limit: the futures it previews are the same ones an arm would hold this focus to.',
+        },
+        {
+            basis: 'read_failed',
+            isFloor: false,
+            lead: 'If that section says READ FAILED, you have NO floor.',
+            situation: 'An unreadable standing is not evidence that every criterion is addressed.',
+            rules: [
+                WITHHOLD_RESIDUE,
+                {
+                    candidate: 'new_root_cause',
+                    disposition: 'anchor',
+                    conditions: [],
+                    nonDeciding: [],
+                    obligations: ['that the standing was unreadable on this pass'],
+                },
+            ],
+        },
+    ],
+};
+/**
+ * CLOSED LEXICON (1/4): the subject of the normative sentence, chosen by the
+ * rule's `candidate`. Stated in full where the test is introduced, and short
+ * at each basis so the definition is given once rather than four times.
+ */
+const CANDIDATE_SUBJECT = {
+    universal: {
+        new_root_cause: 'A GENUINELY NEW ROOT CAUSE -- one no existing delivery already covers --',
+        residue_or_restatement: 'RESIDUE of work still in flight -- or a RESTATEMENT or refinement of a cause an existing delivery already covers --',
+    },
+    basis: {
+        new_root_cause: 'A genuinely new root cause',
+        residue_or_restatement: 'Residue, or a restatement or refinement of a cause already covered,',
+    },
+};
+/** CLOSED LEXICON (2/4): the same candidate named as the side of the test. */
+const CANDIDATE_LABEL = {
+    new_root_cause: 'NEW ROOT CAUSE',
+    residue_or_restatement: 'RESIDUE OR RESTATEMENT',
+};
+/** CLOSED LEXICON (3/4): what the floor DOES, chosen by `disposition`. */
+const DISPOSITION_VERB = {
+    anchor: 'is ANCHORED',
+    withhold: 'is WITHHELD',
+};
+/**
+ * CLOSED LEXICON (4/4): how a disposition with NO declared conditions states
+ * its own scope. An unconditional rule must SAY it is unconditional: a
+ * sentence that merely omits the scope is one a reader fills with the last
+ * rule they were taught.
+ */
+const UNCONDITIONAL_SCOPE = {
+    universal: {
+        anchor: 'at every basis below, in every case those bases can present, with nothing further to satisfy first',
+        withhold: 'at every basis below, in every case those bases can present',
+    },
+    basis: {
+        anchor: 'here, in every case this basis can present, with nothing further to satisfy first',
+        withhold: 'here, in every case this basis can present',
+    },
+};
+/**
+ * Prose for each non-deciding factor. One sentence per factor, stated once
+ * here, so "coverage is not the test" cannot drift from rule to rule.
+ */
+const NON_DECIDING_PROSE = {
+    criterion_coverage: 'Whether a declared criterion already covers the ground a cause sits on is NOT the test and never decides it: coverage tells you whether declared work remains OPEN, it cannot tell you whether a cause is NEW.',
+};
+/** How an obligation sentence opens, per disposition. */
+const OBLIGATION_LEAD = {
+    anchor: 'When you anchor, say in your audit summary',
+    withhold: 'When you withhold, say in your audit summary',
+};
+// ---- BACKSTOP: a fast, INCOMPLETE check on the policy's remaining prose ----
+//
+// Read this before trusting the rules below. They are an ENUMERATION of
+// wordings, NOT the guarantee that context prose carries no restriction -- the
+// equality pin on the rendered section is (round-8 note above). What they buy
+// is EARLINESS and a NAMED reason: a claim in vocabulary they happen to know
+// fails at module load with the offending path, instead of surfacing later as
+// an unexplained diff against the pin. Stated limits:
+//   - the lists are finite, and no list can be complete. The two escapes review
+//     filed -- "Fresh findings wait for review." and "A genuinely new root
+//     cause proceeds after every existing delivery is reviewed." -- carry no
+//     listed noun/verb pair and no scope marker, so these rules PASS them. The
+//     pin rejects them.
+//   - they can only ADD rejections. Nothing reads a green result as evidence
+//     that prose is clean: a green backstop over a changed render is still RED.
+// Widening the lists is allowed and harmless. It is not progress, and it must
+// never be written up as closing the class.
+/** Nouns that name one of the floor's candidates. Finite; not exhaustive. */
+const CANDIDATE_NOUN = /\b(root causes?|residue|restatements?|refinements?)\b/i;
+/** Verbs that state what the floor DOES with a candidate. Finite; not exhaustive. */
+const DISPOSITION_VERB_IN_PROSE = /\b(anchors?|anchored|anchoring|withholds?|withheld|suppress(?:es|ed)?|defers?|deferred|skips?|skipped|omits?|omitted|excludes?|excluded)\b/i;
+/** Markers that narrow a claim's scope. A scope is declared, never written. */
+const SCOPE_MARKER = /\b(only|unless|except|solely|provided that|so long as|as long as|conditional on|contingent on)\b/i;
+/**
+ * Every free-text field of the policy. `conditions` is deliberately absent: it
+ * IS the declared channel for a scope, and it is counted rather than banned.
+ *
+ * Exported so the suite can prove the equality pin COVERS this set (every
+ * field's exact text appears verbatim inside the pinned render) rather than
+ * trusting a hand-maintained field list that goes stale on the next addition.
+ */
+export function floorProseFields(policy = AUDIT_FLOOR_POLICY) {
+    const obligationsOf = (at, rules) => rules.flatMap((rule, j) => rule.obligations.map((text, k) => ({ path: `${at}.rules[${j}].obligations[${k}]`, text })));
+    const fields = [
+        { path: 'universalLead', text: policy.universalLead },
+        ...policy.universalClosing.map((text, i) => ({ path: `universalClosing[${i}]`, text })),
+        ...obligationsOf('universal', policy.universal),
+    ];
+    policy.bases.forEach((basis, i) => {
+        const at = `bases[${i}]`;
+        fields.push({ path: `${at}.lead`, text: basis.lead });
+        fields.push({ path: `${at}.situation`, text: basis.situation });
+        if (basis.caveat !== undefined)
+            fields.push({ path: `${at}.caveat`, text: basis.caveat });
+        fields.push(...obligationsOf(at, basis.rules));
+    });
+    return fields;
+}
+/**
+ * Prose fields that state normative content IN A WORDING THESE LISTS KNOW. An
+ * empty result means "nothing recognised", NEVER "nothing normative" -- see the
+ * BACKSTOP note above for why no wording list can mean the latter. The
+ * completeness guarantee is the equality pin in audit-phase.test.ts; this only
+ * makes the recognised cases fail earlier, at load, with a named path. Exported
+ * so a test can demonstrate rejection on a mutated policy.
+ */
+export function findFloorProseViolations(policy = AUDIT_FLOOR_POLICY) {
+    const violations = [];
+    for (const field of floorProseFields(policy)) {
+        if (CANDIDATE_NOUN.test(field.text) && DISPOSITION_VERB_IN_PROSE.test(field.text)) {
+            violations.push({
+                path: field.path,
+                text: field.text,
+                reason: 'states a DISPOSITION for a CANDIDATE in prose. That claim is composed from '
+                    + '`candidate` + `disposition` + `conditions`; written by hand it is the one place a '
+                    + 'restriction sits where no structural channel sees it.',
+            });
+        }
+        if (SCOPE_MARKER.test(field.text)) {
+            violations.push({
+                path: field.path,
+                text: field.text,
+                reason: 'narrows a claim with a scope marker. A scope on the floor is declared in a rule\'s '
+                    + '`conditions`, where it is rendered as one clause and counted; context prose states none.',
+            });
+        }
+    }
+    return violations;
+}
+/**
+ * Fail LOUDLY rather than compose a prompt that contradicts its own structure.
+ * The policy is a static constant, so a green test run is proof this can never
+ * throw at runtime; it throws at module load if someone edits prose into a
+ * normative claim THE BACKSTOP RECOGNISES. Prose it does not recognise composes
+ * fine here and is caught by the equality pin instead.
+ */
+function assertFloorProseIsContextOnly(policy) {
+    const violations = findFloorProseViolations(policy);
+    if (violations.length === 0)
+        return;
+    const detail = violations
+        .map((v) => `  ${v.path}: ${v.reason}\n    text: ${v.text}`)
+        .join('\n');
+    throw new Error('audit floor policy: free-text field(s) carry normative content. The floor\'s normative '
+        + 'claims are composed from the typed fields (candidate, disposition, conditions, '
+        + 'nonDeciding); prose carries context only.\n' + detail);
+}
+/** Join clauses into one readable list ("a, b, and c"). */
+function joinClauses(items) {
+    if (items.length < 2)
+        return items[0] ?? '';
+    return `${items.slice(0, -1).join(', ')}, and ${items[items.length - 1] ?? ''}`;
+}
+/**
+ * Render one rule as prose, entirely from its typed fields. A CONDITIONAL
+ * clause is emitted if and only if the rule declares conditions -- that
+ * one-to-one correspondence is what the tests count, so a freeze cannot be
+ * smuggled in as an extra sentence, and there is no sentence to write it in.
+ */
+function renderRule(rule, scope) {
+    const dispositionScope = rule.conditions.length > 0
+        ? `only where ${joinClauses(rule.conditions)}`
+        : UNCONDITIONAL_SCOPE[scope][rule.disposition];
+    const parts = [
+        `${CANDIDATE_SUBJECT[scope][rule.candidate]} ${DISPOSITION_VERB[rule.disposition]} ${dispositionScope}.`,
+    ];
+    for (const factor of rule.nonDeciding)
+        parts.push(NON_DECIDING_PROSE[factor]);
+    if (rule.obligations.length > 0) {
+        parts.push(`${OBLIGATION_LEAD[rule.disposition]} ${joinClauses(rule.obligations)}.`);
+    }
+    return parts.join(' ');
+}
+/**
+ * Name the test, and state whether it holds everywhere. The "same test at
+ * every basis" half is COMPUTED against the bases rather than asserted, so a
+ * basis that departed from the universal rule would change this sentence
+ * instead of being contradicted by it.
+ */
+function renderTestSentence(policy) {
+    const universalDisposition = new Map(policy.universal.map((rule) => [rule.candidate, rule.disposition]));
+    const uniform = policy.bases.every((basis) => basis.rules.every((rule) => {
+        const declared = universalDisposition.get(rule.candidate);
+        return declared === undefined || (declared === rule.disposition && rule.conditions.length === 0);
+    }));
+    const sameness = uniform
+        ? 'and it is the SAME test at every basis below'
+        : 'and the bases below depart from it -- read each one on its own terms';
+    return `The test is ${CANDIDATE_LABEL.residue_or_restatement} vs ${CANDIDATE_LABEL.new_root_cause}, ${sameness}.`;
+}
+/** Render one basis as a markdown bullet. */
+function renderBasis(basis) {
+    const body = [basis.situation, ...basis.rules.map((rule) => renderRule(rule, 'basis'))];
+    if (basis.caveat !== undefined)
+        body.push(basis.caveat);
+    return `- **${basis.lead}** ${body.join(' ')}`;
+}
+/** Render the policy: the universal paragraph, then one bullet per basis. */
+export function renderFloorPolicy(policy = AUDIT_FLOOR_POLICY) {
+    assertFloorProseIsContextOnly(policy);
+    const universal = [
+        `**${policy.universalLead}**`,
+        renderTestSentence(policy),
+        ...policy.universal.map((rule) => renderRule(rule, 'universal')),
+        ...policy.universalClosing,
+    ].join(' ');
+    return [universal, '', ...policy.bases.map(renderBasis)];
+}
+/**
+ * The composed floor section: the pointer at the standing section (which
+ * states no rule about what may be anchored), then the rendered policy.
+ */
+export function renderFloorSection(policy = AUDIT_FLOOR_POLICY) {
+    return [
+        '',
+        '## Before you anchor (round 5): has this focus reached its declared floor?',
+        '',
+        'The "Focus acceptance criteria standing" section of your context lists what this focus is FOR from both statements of it -- the futures of the undesired effects its arm covers, then its OWN declared acceptance criteria -- states for each its source and whether it is MET (verify recorded the future as landed), ADDRESSED (a current delivery points at it) or OPEN, and states the FLOOR with the basis it rests on. READ IT BEFORE YOU ANCHOR ANYTHING. It is the only thing in your context that says what this focus was for, and therefore the only thing that can tell you there is nothing left to anchor.',
+        '',
+        ...renderFloorPolicy(policy),
+    ];
+}
+//# sourceMappingURL=audit-floor-policy.js.map

package/dist/audit/audit-floor-policy.js.map

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