@telora/daemon 0.22.245 → 0.22.290

package/dist/verify/effect-reconciliation/cascade-restatement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cascade-restatement.d.ts","sourceRoot":"","sources":["../../../src/verify/effect-reconciliation/cascade-restatement.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAE5F,sEAAsE;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,iBAAiB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC"}

package/dist/verify/effect-reconciliation/cascade-restatement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cascade-restatement.js","sourceRoot":"","sources":["../../../src/verify/effect-reconciliation/cascade-restatement.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,0FAA0F;AAC1F,gBAAgB"}

package/dist/verify/effect-reconciliation/de-restatement.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Desired-effect restatement helper.
+ *
+ * Turns a UDE (plus its resolving injection(s)) into one concise,
+ * injection-conditioned positive desired-effect sentence. Reuses the same
+ * model-invocation pattern as `ai-inspection-runner.ts` -- spawning the
+ * `claude` CLI in print mode -- so there is NO new client or secret wiring.
+ *
+ * Two prompt modes:
+ *   - injection-conditioned (injectionStatements present): the desired effect
+ *     is the positive state the UDE BECOMES given those injections; it carries
+ *     the resolution, it is NOT a naive antonym.
+ *   - observation-conditioned (no injections): a positive restatement grounded
+ *     in the evidence/observation of the UDE.
+ *
+ * Idempotency: callers use `needsRestatement()` to skip nodes that already
+ * carry a positive statement (an FRT overlay that is non-null, or a base
+ * statement that no longer equals the pre-flip UDE text).
+ *
+ * @module de-restatement
+ */
+import { type OneShotModelProcess } from '../../backends/claude/one-shot-model.js';
+export interface RestatementInputs {
+    /** The undesirable-effect statement to restate positively. */
+    udeStatement: string;
+    /** Resolving injection statement(s). Presence selects injection-conditioned mode. */
+    injectionStatements?: string[];
+    /** Supporting observation; used in observation-conditioned mode. */
+    evidence?: string;
+}
+export interface RestatementOptions extends OneShotModelProcess {
+    /** Names the caller in logs and the failure message (default: 'de-restatement'). */
+    label?: string;
+    /** Path to the `claude` CLI binary (default: 'claude'). */
+    claudeBin?: string;
+    /** Timeout in ms; defaults to 2 minutes. */
+    timeoutMs?: number;
+}
+/**
+ * The model call an authoring or reconciling judgement runs: the system prompt
+ * and user message in, the raw model text out. REQUIRED of every caller -- the
+ * composition root binds the one-shot CLI call ({@link invokeClaudeCli}); a test
+ * binds a stub, so no test reaches a real model by omission.
+ */
+export type ModelInvoker = (systemPrompt: string, userMessage: string) => Promise<string>;
+export declare const RESTATEMENT_SYSTEM_PROMPT = "You restate an undesirable effect (UDE) from a Goldratt reality tree as the single positive desired effect it becomes once resolved.\n\nRules:\n- Output exactly ONE sentence. No preamble, no list, no trailing commentary, no quotes.\n- The desired effect must read as a concrete positive outcome, not a negation of the problem (\"operators can tell...\" is weak; \"operators see at a glance which focuses are blocked and why\" is strong).\n- When resolving injection(s) are provided, the desired effect is the positive state the UDE BECOMES given those injections -- it must carry the resolution the injection delivers, not a naive antonym of the UDE.\n- Keep the subject and domain of the original UDE; only flip its polarity to the resolved, desirable state.";
+/**
+ * The system prompt is fixed for both modes (mode is conveyed by the user
+ * message). Exposed as a function to mirror `ai-inspection-runner`'s shape
+ * and to keep callers from depending on the constant directly.
+ */
+export declare function buildRestatementSystemPrompt(): string;
+/**
+ * Build the user message. Injection-conditioned when `injectionStatements`
+ * are present, otherwise observation-conditioned.
+ */
+export declare function buildRestatementUserMessage(inputs: RestatementInputs): string;
+/**
+ * Idempotency predicate. Returns true when a desired-effect node still needs a
+ * positive restatement.
+ *
+ * - `currentText` is the field a caller would write (frt_statement for the FRT
+ *   overlay case, statement for the base flip case). Null/blank => needs one.
+ * - `originalUdeText`, when supplied (base flip case), is the pre-flip UDE
+ *   statement. If `currentText` still equals it, the positive text was never
+ *   authored => needs one.
+ */
+export declare function needsRestatement(currentText: string | null | undefined, originalUdeText?: string | null): boolean;
+/**
+ * The production model invocation: the shared one-shot wrapper (backends/claude/one-shot-model.ts),
+ * returning the answer text. Rejects with ModelUnavailable -- a typed
+ * non-judgment -- when the model could not be reached; a caller that must not
+ * record that as a verdict reads `isModelUnavailable(err)`.
+ */
+export declare function invokeClaudeCli(systemPrompt: string, userMessage: string, opts: RestatementOptions): Promise<string>;
+/**
+ * Author the positive desired-effect restatement for a UDE.
+ *
+ * Returns a single positive sentence. Throws on model-invocation failure;
+ * callers (the at-source flip path, the reconciliation backstop) catch and
+ * skip so a single failure never aborts the surrounding loop.
+ */
+export declare function authorRestatement(inputs: RestatementInputs, invokeModel: ModelInvoker): Promise<string>;
+/**
+ * The production {@link ModelInvoker}: the one-shot `claude` call on `process`,
+ * logged under `label`. Bound at the composition root, which hands the process.
+ */
+export declare function claudeModelInvoker(label: string, process: OneShotModelProcess): ModelInvoker;
+//# sourceMappingURL=de-restatement.d.ts.map

package/dist/verify/effect-reconciliation/de-restatement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"de-restatement.d.ts","sourceRoot":"","sources":["../../../src/verify/effect-reconciliation/de-restatement.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAsB,KAAK,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAEvG,MAAM,WAAW,iBAAiB;IAChC,8DAA8D;IAC9D,YAAY,EAAE,MAAM,CAAC;IACrB,qFAAqF;IACrF,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,oFAAoF;IACpF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAE1F,eAAO,MAAM,yBAAyB,4vBAMsE,CAAC;AAE7G;;;;GAIG;AACH,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAoB7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACtC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,GAC9B,OAAO,CAIT;AAcD;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,MAAM,CAAC,CASjB;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,YAAY,GACxB,OAAO,CAAC,MAAM,CAAC,CASjB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,YAAY,CAE5F"}

package/dist/verify/effect-reconciliation/de-restatement.js

@@ -0,0 +1,130 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/cli/backfill-frt-prose.test.ts,
+//   packages/daemon/src/verify/effect-reconciliation/de-restatement.test.ts
+// PINNED-BY-END
+/**
+ * Desired-effect restatement helper.
+ *
+ * Turns a UDE (plus its resolving injection(s)) into one concise,
+ * injection-conditioned positive desired-effect sentence. Reuses the same
+ * model-invocation pattern as `ai-inspection-runner.ts` -- spawning the
+ * `claude` CLI in print mode -- so there is NO new client or secret wiring.
+ *
+ * Two prompt modes:
+ *   - injection-conditioned (injectionStatements present): the desired effect
+ *     is the positive state the UDE BECOMES given those injections; it carries
+ *     the resolution, it is NOT a naive antonym.
+ *   - observation-conditioned (no injections): a positive restatement grounded
+ *     in the evidence/observation of the UDE.
+ *
+ * Idempotency: callers use `needsRestatement()` to skip nodes that already
+ * carry a positive statement (an FRT overlay that is non-null, or a base
+ * statement that no longer equals the pre-flip UDE text).
+ *
+ * @module de-restatement
+ */
+import { invokeOneShotModel } from '../../backends/claude/one-shot-model.js';
+export const RESTATEMENT_SYSTEM_PROMPT = `You restate an undesirable effect (UDE) from a Goldratt reality tree as the single positive desired effect it becomes once resolved.
+
+Rules:
+- Output exactly ONE sentence. No preamble, no list, no trailing commentary, no quotes.
+- The desired effect must read as a concrete positive outcome, not a negation of the problem ("operators can tell..." is weak; "operators see at a glance which focuses are blocked and why" is strong).
+- When resolving injection(s) are provided, the desired effect is the positive state the UDE BECOMES given those injections -- it must carry the resolution the injection delivers, not a naive antonym of the UDE.
+- Keep the subject and domain of the original UDE; only flip its polarity to the resolved, desirable state.`;
+/**
+ * The system prompt is fixed for both modes (mode is conveyed by the user
+ * message). Exposed as a function to mirror `ai-inspection-runner`'s shape
+ * and to keep callers from depending on the constant directly.
+ */
+export function buildRestatementSystemPrompt() {
+    return RESTATEMENT_SYSTEM_PROMPT;
+}
+/**
+ * Build the user message. Injection-conditioned when `injectionStatements`
+ * are present, otherwise observation-conditioned.
+ */
+export function buildRestatementUserMessage(inputs) {
+    const parts = [`Undesirable effect (UDE):\n${inputs.udeStatement}`];
+    const injections = (inputs.injectionStatements ?? []).filter((s) => s && s.trim() !== '');
+    if (injections.length > 0) {
+        parts.push(`Resolving injection(s):\n${injections.map((s) => `- ${s}`).join('\n')}`);
+        parts.push('Write the single positive desired-effect sentence that this UDE BECOMES once the injection(s) above are in place. It must carry the resolution the injection delivers, not a flat negation of the UDE.');
+    }
+    else {
+        if (inputs.evidence && inputs.evidence.trim() !== '') {
+            parts.push(`Evidence / observation:\n${inputs.evidence}`);
+        }
+        parts.push('Write the single positive desired-effect sentence that states the resolved, desirable version of the UDE above.');
+    }
+    parts.push('Respond with ONE sentence only.');
+    return parts.join('\n\n');
+}
+/**
+ * Idempotency predicate. Returns true when a desired-effect node still needs a
+ * positive restatement.
+ *
+ * - `currentText` is the field a caller would write (frt_statement for the FRT
+ *   overlay case, statement for the base flip case). Null/blank => needs one.
+ * - `originalUdeText`, when supplied (base flip case), is the pre-flip UDE
+ *   statement. If `currentText` still equals it, the positive text was never
+ *   authored => needs one.
+ */
+export function needsRestatement(currentText, originalUdeText) {
+    if (!currentText || currentText.trim() === '')
+        return true;
+    if (originalUdeText && currentText.trim() === originalUdeText.trim())
+        return true;
+    return false;
+}
+/** Normalize raw model output to one clean sentence (strip fences/quotes, collapse whitespace). */
+function normalizeSentence(raw) {
+    let s = raw.trim();
+    // Strip code fences if the model wrapped the answer.
+    s = s.replace(/```[a-zA-Z]*\s*/g, '').replace(/```/g, '').trim();
+    // Collapse all internal whitespace (incl. newlines) to single spaces.
+    s = s.replace(/\s+/g, ' ').trim();
+    // Strip a single layer of surrounding quotes/backticks.
+    s = s.replace(/^["'`]+/, '').replace(/["'`]+$/, '').trim();
+    return s;
+}
+/**
+ * The production model invocation: the shared one-shot wrapper (backends/claude/one-shot-model.ts),
+ * returning the answer text. Rejects with ModelUnavailable -- a typed
+ * non-judgment -- when the model could not be reached; a caller that must not
+ * record that as a verdict reads `isModelUnavailable(err)`.
+ */
+export async function invokeClaudeCli(systemPrompt, userMessage, opts) {
+    const result = await invokeOneShotModel(systemPrompt, userMessage, {
+        label: opts.label ?? 'de-restatement',
+        ...(opts.claudeBin !== undefined ? { claudeBin: opts.claudeBin } : {}),
+        ...(opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {}),
+        spawnFn: opts.spawnFn,
+        nowMs: opts.nowMs,
+    });
+    return result.text;
+}
+/**
+ * Author the positive desired-effect restatement for a UDE.
+ *
+ * Returns a single positive sentence. Throws on model-invocation failure;
+ * callers (the at-source flip path, the reconciliation backstop) catch and
+ * skip so a single failure never aborts the surrounding loop.
+ */
+export async function authorRestatement(inputs, invokeModel) {
+    const systemPrompt = buildRestatementSystemPrompt();
+    const userMessage = buildRestatementUserMessage(inputs);
+    const raw = await invokeModel(systemPrompt, userMessage);
+    const sentence = normalizeSentence(raw);
+    if (sentence === '') {
+        throw new Error('de-restatement produced empty output');
+    }
+    return sentence;
+}
+/**
+ * The production {@link ModelInvoker}: the one-shot `claude` call on `process`,
+ * logged under `label`. Bound at the composition root, which hands the process.
+ */
+export function claudeModelInvoker(label, process) {
+    return (systemPrompt, userMessage) => invokeClaudeCli(systemPrompt, userMessage, { label, ...process });
+}
+//# sourceMappingURL=de-restatement.js.map

package/dist/verify/effect-reconciliation/de-restatement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"de-restatement.js","sourceRoot":"","sources":["../../../src/verify/effect-reconciliation/de-restatement.ts"],"names":[],"mappings":"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"}

package/dist/verify/effect-reconciliation/injection-stamp.d.ts

@@ -0,0 +1,59 @@
+import type { PendingVerification, VerificationOutcome } from '../../queries/verification/verification.js';
+import type { TargetRestatement } from './verify-restatement.js';
+import type { VerificationDeps } from '../engine/verification-deps.js';
+/** Ticks a ledgered stamp is re-attempted before only the durable safety nets remain. */
+export declare const MAX_STAMP_RETRIES = 10;
+/** Everything one injection stamp needs, as the passing run authored it. */
+export interface InjectionStamp {
+    restatements: TargetRestatement[];
+    evidence: string;
+    /**
+     * Targets that must NOT flip with the injection: operator-EXCUSED shortfall
+     * nodes, AND the post-arm targets the reconciliation RECORDED rather than
+     * judged. See `stampWithheldNodeIds`.
+     */
+    withheldNodeIds: readonly string[];
+    realityTreeId?: string;
+}
+/**
+ * Everything this stamp must NOT promote: the operator-EXCUSED shortfall nodes
+ * PLUS the targets the focus's arm did not cover.
+ *
+ * Both are the same act for the stamp even though they are different judgements
+ * upstream. An EXCUSED node was judged and let go; a RECORDED one was never
+ * judged at all -- the arm the human gave did not cover it, so the
+ * reconciliation set it aside and it waits for the next arm
+ * (verify/effect-reconciliation/verify-restatement.ts narrowToArmCoverage). Neither may be flipped to
+ * `desired_effect` by this verify, and the stamp has exactly one way to say so.
+ *
+ * WHY THE STAMP CARRIES IT AT ALL, given the verify door now reads the arm rule
+ * itself (supabase/functions/product-api/handlers/reality-tree/verify-arm-coverage.ts):
+ * that read FAILS OPEN. A focus row it cannot read withholds nothing, and the run that DID
+ * reconcile is the one that knows which targets it declined to judge. Saying it
+ * explicitly costs one array and is the only signal that survives a read the
+ * edge could not make.
+ *
+ * Carried on the ledgered stamp like every other field, so the retries re-send
+ * exactly what the run authored rather than a set recomputed later.
+ *
+ * `recordedTargetNodeIds` is null when NO reconciliation ran -- the run learned
+ * nothing about coverage, so it withholds nothing on that account. Pure.
+ */
+export declare function stampWithheldNodeIds(excusedNodeIds: readonly string[], recordedTargetNodeIds: readonly string[] | null): string[];
+type StampDeps = Pick<VerificationDeps, 'verifyInjection' | 'emitInwardDrift' | 'fileEscalation' | 'organizationId'>;
+/**
+ * Stamp the injection of a delivery whose verify PASSED. Never throws and never
+ * touches the verdict: a failure is logged, surfaced once, and ledgered for a
+ * stamp-only retry. Returns whether the stamp landed.
+ */
+export declare function stampPassedInjection(deps: StampDeps, v: PendingVerification, stamp: InjectionStamp): Promise<boolean>;
+/** A newly recorded verdict supersedes the delivery's ledgered stamp (module doc). */
+export declare function supersedeLedgeredStamp(deliveryId: string, outcome: VerificationOutcome): void;
+/** Re-attempt ONLY the ledgered stamps -- no suite, no verdict. Called once per verification tick. */
+export declare function retryLedgeredStamps(deps: StampDeps): Promise<void>;
+/** Test seam: the ledgered delivery ids. */
+export declare function __ledgeredStampsForTests(): string[];
+/** Test seam: empty the ledger. */
+export declare function __resetStampLedgerForTests(): void;
+export {};
+//# sourceMappingURL=injection-stamp.d.ts.map

package/dist/verify/effect-reconciliation/injection-stamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection-stamp.d.ts","sourceRoot":"","sources":["../../../src/verify/effect-reconciliation/injection-stamp.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAE3G,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAKvE,yFAAyF;AACzF,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,4EAA4E;AAC5E,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,iBAAiB,EAAE,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,SAAS,MAAM,EAAE,EACjC,qBAAqB,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAC9C,MAAM,EAAE,CASV;AAWD,KAAK,SAAS,GAAG,IAAI,CAAC,gBAAgB,EAAE,iBAAiB,GAAG,iBAAiB,GAAG,gBAAgB,GAAG,gBAAgB,CAAC,CAAC;AA8CrH;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,SAAS,EACf,CAAC,EAAE,mBAAmB,EACtB,KAAK,EAAE,cAAc,GACpB,OAAO,CAAC,OAAO,CAAC,CAgBlB;AAED,sFAAsF;AACtF,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAE7F;AAED,sGAAsG;AACtG,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBxE;AAED,4CAA4C;AAC5C,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,CAEnD;AAED,mCAAmC;AACnC,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD"}

package/dist/verify/effect-reconciliation/injection-stamp.js

@@ -0,0 +1,175 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/verify/effect-reconciliation/stamp-withholds-recorded-targets.test.ts,
+//   packages/daemon/src/verify/engine/verification-commit-sharing.test.ts,
+//   packages/daemon/src/verify/engine/verification-engine.test.ts
+// PINNED-BY-END
+/**
+ * The injection stamp is a POST-VERDICT side effect, never part of the verdict.
+ *
+ * When a verify run passes a delivery anchored to an injection, the daemon
+ * stamps that injection verified (the reality_tree_verify_injection compound op)
+ * and surfaces any inward drift the reconciliation found. A stamp failure never
+ * demotes the PASS: demoting it would discard a rendered deterministic verdict
+ * and re-queue the whole suite on the same HEAD.
+ *
+ * The verdict is recorded as rendered, whatever happens here:
+ *   - the stamp is attempted once, in the run;
+ *   - on failure it is logged, surfaced ONCE as a machine-lane observation (not
+ *     as "no verdict"), and kept in a retry ledger;
+ *   - each verification tick re-attempts ONLY the ledgered stamps -- never the
+ *     suite -- with the same restatements and evidence the run authored, and
+ *     emits the drift once a stamp lands;
+ *   - a later verdict for the delivery supersedes its ledgered stamp: a newer
+ *     pass stamps afresh, and a non-pass means the stamp no longer describes the
+ *     delivery's work.
+ * The ledger is in-process. After a restart (or once its attempts run out) the
+ * stamp is still re-attempted by the durable safety nets, without the run's
+ * restatements: the verify_linked_injection trigger on verify -> done
+ * (guard/trigger-executor.ts) and the settle injection sweep
+ * (completion/state-cascade/settle-injection-sweep.ts). So the tree does not stay unverified.
+ *
+ * History: docs/daemon/history-verify.md (verify/effect-reconciliation/injection-stamp.ts).
+ *
+ * @module verify/effect-reconciliation/injection-stamp
+ */
+import { ESCALATION_DISPOSITIONS, ESCALATION_REASONS } from '@telora/daemon-core';
+import { createLogger } from '../../log/daemon-log.js';
+const log = createLogger({ module: 'verification' });
+/** Ticks a ledgered stamp is re-attempted before only the durable safety nets remain. */
+export const MAX_STAMP_RETRIES = 10;
+/**
+ * Everything this stamp must NOT promote: the operator-EXCUSED shortfall nodes
+ * PLUS the targets the focus's arm did not cover.
+ *
+ * Both are the same act for the stamp even though they are different judgements
+ * upstream. An EXCUSED node was judged and let go; a RECORDED one was never
+ * judged at all -- the arm the human gave did not cover it, so the
+ * reconciliation set it aside and it waits for the next arm
+ * (verify/effect-reconciliation/verify-restatement.ts narrowToArmCoverage). Neither may be flipped to
+ * `desired_effect` by this verify, and the stamp has exactly one way to say so.
+ *
+ * WHY THE STAMP CARRIES IT AT ALL, given the verify door now reads the arm rule
+ * itself (supabase/functions/product-api/handlers/reality-tree/verify-arm-coverage.ts):
+ * that read FAILS OPEN. A focus row it cannot read withholds nothing, and the run that DID
+ * reconcile is the one that knows which targets it declined to judge. Saying it
+ * explicitly costs one array and is the only signal that survives a read the
+ * edge could not make.
+ *
+ * Carried on the ledgered stamp like every other field, so the retries re-send
+ * exactly what the run authored rather than a set recomputed later.
+ *
+ * `recordedTargetNodeIds` is null when NO reconciliation ran -- the run learned
+ * nothing about coverage, so it withholds nothing on that account. Pure.
+ */
+export function stampWithheldNodeIds(excusedNodeIds, recordedTargetNodeIds) {
+    const out = [];
+    const seen = new Set();
+    for (const id of [...excusedNodeIds, ...(recordedTargetNodeIds ?? [])]) {
+        if (id === '' || seen.has(id))
+            continue;
+        seen.add(id);
+        out.push(id);
+    }
+    return out;
+}
+/** Failed stamps awaiting a stamp-only retry, by delivery id. */
+const ledger = new Map();
+/** Attempt the stamp, then surface inward drift for what it flipped. Throws when the stamp does. */
+async function applyStamp(deps, v, stamp) {
+    await deps.verifyInjection(v.injectionNodeId, stamp.restatements, stamp.evidence, stamp.withheldNodeIds);
+    // INWARD drift (TEL-3/TEL-4): a target stamped legitimate_divergence is a tree
+    // CLAIM reality contradicted -- surfaced only after the flip landed, carrying the
+    // tree's ORIGINAL claim. Best-effort: a failure here must not undo the flip.
+    const diverged = stamp.restatements
+        .filter((r) => r.classification === 'legitimate_divergence')
+        .map((r) => ({
+        nodeId: r.nodeId,
+        classification: 'legitimate_divergence',
+        statement: r.statement,
+        originalClaim: r.originalClaim,
+        ...(r.divergenceReason ? { verifyDivergenceReason: r.divergenceReason } : {}),
+    }));
+    if (diverged.length === 0)
+        return;
+    try {
+        await deps.emitInwardDrift(v.injectionNodeId, diverged, stamp.realityTreeId);
+    }
+    catch (err) {
+        log.warn(`[verification] inward drift emit failed for ${v.injectionNodeId}:`, err.message);
+    }
+}
+/** Surface a stamp failure once, in the machine lane: the verdict stands, only the stamp is owed. */
+async function surfaceStampFailure(deps, v, message) {
+    try {
+        await deps.fileEscalation({
+            organizationId: deps.organizationId,
+            ...(v.focusId ? { focusId: v.focusId } : {}),
+            ...(v.productId ? { productId: v.productId } : {}),
+            reason: `Verify passed delivery "${v.deliveryName}" but stamping its injection ${v.injectionNodeId} failed: ${message}. ` +
+                'The passed verdict is recorded; the daemon retries only the stamp on later verification ticks, and the ' +
+                'verify -> done trigger and settle injection sweep re-attempt it after that.',
+            reasonType: ESCALATION_REASONS.ERROR_ENCOUNTERED,
+            disposition: ESCALATION_DISPOSITIONS.AGENT_RESOLVABLE,
+            kind: 'verify_injection_stamp_failed',
+            details: { delivery_id: v.deliveryId, injection_node_id: v.injectionNodeId, error: message },
+        });
+    }
+    catch (err) {
+        log.warn(`[verification] could not surface the injection stamp failure for delivery ${v.deliveryId}:`, err.message);
+    }
+}
+/**
+ * Stamp the injection of a delivery whose verify PASSED. Never throws and never
+ * touches the verdict: a failure is logged, surfaced once, and ledgered for a
+ * stamp-only retry. Returns whether the stamp landed.
+ */
+export async function stampPassedInjection(deps, v, stamp) {
+    try {
+        await applyStamp(deps, v, stamp);
+        ledger.delete(v.deliveryId);
+        return true;
+    }
+    catch (err) {
+        const message = err.message;
+        const alreadyLedgered = ledger.has(v.deliveryId);
+        ledger.set(v.deliveryId, { ...stamp, delivery: v, attempts: 0, lastError: message });
+        log.warn(`[verification] post-verdict side effect failed for delivery "${v.deliveryName}" (${v.deliveryId}): ` +
+            `injection stamp ${v.injectionNodeId}: ${message} -- the passed verdict stands; the stamp alone is retried`);
+        if (!alreadyLedgered)
+            await surfaceStampFailure(deps, v, message);
+        return false;
+    }
+}
+/** A newly recorded verdict supersedes the delivery's ledgered stamp (module doc). */
+export function supersedeLedgeredStamp(deliveryId, outcome) {
+    if (outcome !== 'pending')
+        ledger.delete(deliveryId);
+}
+/** Re-attempt ONLY the ledgered stamps -- no suite, no verdict. Called once per verification tick. */
+export async function retryLedgeredStamps(deps) {
+    for (const [deliveryId, entry] of [...ledger]) {
+        try {
+            await applyStamp(deps, entry.delivery, entry);
+            ledger.delete(deliveryId);
+            log.info(`[verification] injection stamp ${entry.delivery.injectionNodeId} for delivery ${deliveryId} landed on retry`);
+        }
+        catch (err) {
+            entry.attempts += 1;
+            entry.lastError = err.message;
+            if (entry.attempts < MAX_STAMP_RETRIES)
+                continue;
+            ledger.delete(deliveryId);
+            log.warn(`[verification] injection stamp ${entry.delivery.injectionNodeId} for delivery ${deliveryId} still failing after ` +
+                `${entry.attempts} retries (${entry.lastError}); left to the verify -> done trigger and the settle injection sweep`);
+        }
+    }
+}
+/** Test seam: the ledgered delivery ids. */
+export function __ledgeredStampsForTests() {
+    return [...ledger.keys()];
+}
+/** Test seam: empty the ledger. */
+export function __resetStampLedgerForTests() {
+    ledger.clear();
+}
+//# sourceMappingURL=injection-stamp.js.map

package/dist/verify/effect-reconciliation/injection-stamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection-stamp.js","sourceRoot":"","sources":["../../../src/verify/effect-reconciliation/injection-stamp.ts"],"names":[],"mappings":"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"}

package/dist/verify/effect-reconciliation/judge-checkout.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `base` without any GIT_* variable or PAGER, with git's global and system
+ * config, system attributes and replacement objects switched off, and the
+ * HERMETIC_CONFIG set (module header). Pure over its input.
+ */
+export declare function hermeticGitEnv(base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** One hermetic git run's outcome. */
+export interface HermeticGitResult {
+    success: boolean;
+    output: string;
+    error?: string;
+}
+/** Run git in `cwd` under hermeticGitEnv. Never throws. */
+export declare function hermeticGit(args: readonly string[], cwd: string): HermeticGitResult;
+/** Where the export of a judgement's BASE tree (the state before the delivery's change) lives: beside the judged one. Pure. */
+export declare function judgeBaseDir(checkoutPath: string): string;
+/** Every file and directory under `root` without (false) or with (true) its owner write bit. Symlinks are skipped. */
+export declare function setCheckoutWritable(root: string, writable: boolean): void;
+/** A full commit sha for `rev` in `repoPath`, or null. */
+export declare function commitOf(repoPath: string, rev: string): string | null;
+/** How many bytes of blob content one `cat-file --batch` read holds at most. */
+export declare const EXPORT_BATCH_BYTES: number;
+/** How many entries one batch holds at most, however small their blobs. */
+export declare const EXPORT_BATCH_ENTRIES = 10000;
+/** How many bytes of the tree listing one read holds (plus the record it ends on). */
+export declare const EXPORT_LISTING_CHUNK_BYTES: number;
+/** Told the size of every read an export holds in memory, by what it read (a test's seam). */
+export type ExportReadObserver = (kind: 'listing' | 'blobs', bytesHeld: number) => void;
+/** An export's memory bounds (defaults: the EXPORT_* constants). */
+export interface ExportLimits {
+    batchBytes?: number;
+    batchEntries?: number;
+    listingChunkBytes?: number;
+}
+/**
+ * Write the tree of `sha` in `repoPath` to the new directory `dir` (module
+ * header), then make it read-only. Entries are exported as the listing is read:
+ * a submodule becomes a directory, a blob larger than a batch is streamed, and
+ * every other blob joins the pending batch, which is read and written once it
+ * would exceed `batchBytes` of content or `batchEntries` entries. Returns the
+ * failure, or null.
+ */
+export declare function exportCommitTree(repoPath: string, sha: string, dir: string, limits?: ExportLimits, onRead?: ExportReadObserver): string | null;
+//# sourceMappingURL=judge-checkout.d.ts.map

package/dist/verify/effect-reconciliation/judge-checkout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge-checkout.d.ts","sourceRoot":"","sources":["../../../src/verify/effect-reconciliation/judge-checkout.ts"],"names":[],"mappings":"AAsDA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAAC,UAAU,CAevF;AAED,sCAAsC;AACtC,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,2DAA2D;AAC3D,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAWnF;AAED,+HAA+H;AAC/H,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,sHAAsH;AACtH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAczE;AAED,0DAA0D;AAC1D,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIrE;AAuED,gFAAgF;AAChF,eAAO,MAAM,kBAAkB,QAAmB,CAAC;AACnD,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAC3C,sFAAsF;AACtF,eAAO,MAAM,0BAA0B,QAAc,CAAC;AAUtD,8FAA8F;AAC9F,MAAM,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;AAExF,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAqCD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,YAAiB,EACzB,MAAM,CAAC,EAAE,kBAAkB,GAC1B,MAAM,GAAG,IAAI,CAkCf"}