@telora/daemon 0.18.49 → 0.18.58

package/dist/queries/verification.js

@@ -6,6 +6,7 @@
  * - Trigger the existing reality_tree_verify_injection compound op on pass.
  */
 import { callApi } from './shared.js';
+import { decideNodeWriteback, detectInwardDrift, } from '../reality-writeback.js';
 export async function getPendingVerifications(productId) {
     const response = await callApi('daemon_get_pending_verifications', productId ? { productId } : {});
     return response.items ?? [];
@@ -46,4 +47,274 @@ export async function verifyInjectionWithEvidence(injectionNodeId, evidence) {
     });
     await callApi('reality_tree_verify_injection', { injectionNodeId });
 }
+/**
+ * Translate the pure `decideNodeWriteback` output into the verify call's
+ * `restatements` payload.
+ *
+ * The flip endpoint (`reality_tree_verify_injection`) is the only seam that
+ * persists a node's `verify_classification` / `verify_divergence_reason`, and
+ * it does so per-restatement -- but ONLY when the restatement carries a
+ * non-empty `statement` (an empty statement is dropped whole, classification
+ * included). So a writeback can be applied iff it carries achieved prose.
+ *
+ * Mapping:
+ *   - match | legitimate_divergence WITH a non-empty statement -> a
+ *     VerifyRestatement carried into the flip so classification (+ reason)
+ *     lands atomically with the promotion. The achieved statement is the prose
+ *     written as the targeted UDE's new base statement (for a match this equals
+ *     the declared desired effect carried forward unchanged).
+ *   - any writeback WITHOUT achieved prose, or a `shortfall` -> NOT emitted as
+ *     a restatement (there is no edge path that stamps classification without
+ *     prose, and a shortfall must not flip the node). Reported back via
+ *     `skipped` so the caller can see what was not stamped.
+ *
+ * Pure (no I/O); exported for unit testing the mapping.
+ */
+export function planNodeWritebackApply(writebacks) {
+    const restatements = [];
+    const skipped = [];
+    for (const wb of writebacks) {
+        if (wb.classification === 'shortfall') {
+            skipped.push({
+                nodeId: wb.nodeId,
+                reason: 'shortfall: no flip; classification not persisted (claim did not hold)',
+            });
+            continue;
+        }
+        // TEL-6: an `assumed` match carries no evidence. Persisting a
+        // verify_classification='match' for it would record an UNEARNED "verified"
+        // claim, so skip it -- the node stays unstamped until grounded by evidence.
+        if (wb.classification === 'match' && wb.assumed === true) {
+            skipped.push({
+                nodeId: wb.nodeId,
+                reason: 'assumed match: no evidence; not stamped verified (unearned certainty)',
+            });
+            continue;
+        }
+        const statement = wb.statement;
+        if (typeof statement !== 'string' || statement.trim().length === 0) {
+            skipped.push({
+                nodeId: wb.nodeId,
+                reason: 'no achieved statement: verify edge drops a restatement with empty prose',
+            });
+            continue;
+        }
+        // match | legitimate_divergence WITH prose -> restatement.
+        const entry = {
+            nodeId: wb.nodeId,
+            statement,
+            classification: wb.classification,
+        };
+        if (wb.classification === 'legitimate_divergence' && wb.verifyDivergenceReason) {
+            entry.divergenceReason = wb.verifyDivergenceReason;
+        }
+        restatements.push(entry);
+    }
+    return { restatements, skipped };
+}
+/**
+ * Same as `verifyInjectionWithEvidence` but additionally stamps the per-node
+ * realized/diverged writeback computed by `decideNodeWriteback`. Closes the
+ * reality-tree writeback loop: as a delivery lands, the nodes its injection
+ * targeted carry an explicit match / legitimate_divergence status legible to a
+ * later reader.
+ *
+ * Order of operations:
+ *   1. `reality_tree_node_update` on the injection node -> persist evidence.
+ *   2. `reality_tree_verify_injection` with the per-node restatements -> flips
+ *      the injection and promotes overlays, applying the classification (+
+ *      reason) to each targeted UDE atomically. Writebacks with no achieved
+ *      prose, and shortfalls, are skipped (logged) -- there is no edge path
+ *      that persists a classification without prose / a flip.
+ *
+ * Non-destructive: only stamps status + evidence/reason on nodes the injection
+ * owns; a match carries the declared desired effect forward unchanged. When
+ * `writebacks` is empty this is byte-equivalent to `verifyInjectionWithEvidence`.
+ */
+export async function verifyInjectionWithWriteback(injectionNodeId, evidence, writebacks, realityTreeId) {
+    await callApi('reality_tree_node_update', {
+        nodeId: injectionNodeId,
+        evidence,
+    });
+    const { restatements, skipped } = planNodeWritebackApply(writebacks);
+    if (skipped.length > 0) {
+        console.warn(`[reality-writeback] injection ${injectionNodeId.slice(0, 8)}: ` +
+            `${skipped.length} targeted node writeback(s) not stamped -- ` +
+            skipped.map((s) => `${s.nodeId.slice(0, 8)} (${s.reason})`).join('; '));
+    }
+    const verifyBody = { injectionNodeId };
+    if (restatements.length > 0)
+        verifyBody.restatements = restatements;
+    await callApi('reality_tree_verify_injection', verifyBody);
+    // Inward drift: any node reality CONTRADICTED (legitimate_divergence /
+    // shortfall) is a claim the tree got wrong. Turn each one into an inward
+    // crt_drift_proposal so the tree-owner can correct the asserting claim,
+    // instead of leaving a mistaken assertion frozen. Surfaced for human ratify;
+    // never auto-applied. Best-effort + non-fatal: a proposal-emit failure must
+    // not undo the verify/flip that already landed.
+    await emitInwardDriftProposals(injectionNodeId, writebacks, realityTreeId);
+}
+/**
+ * Surface inward drift proposals for the contradicted nodes in a writeback.
+ *
+ * For each writeback the pure `detectInwardDrift` deems a contradicted claim
+ * (`legitimate_divergence` / `shortfall`), create one `update_statement`
+ * crt_drift_proposal flagged `inward:true` via the EXISTING
+ * `crt_drift_proposal_create` pipeline. A `match` (or unstamped) node yields
+ * nothing, so a clean landing emits no proposals.
+ *
+ * Requires the reality tree id (the create action keys off it). When the tree
+ * id is unknown, the proposals cannot be created -- we log and skip, leaving
+ * the per-node stamps in place (a later reader still sees the divergence).
+ *
+ * Non-fatal: each create is independently try/caught so one failure neither
+ * blocks the others nor unwinds the already-applied verify flip.
+ */
+export async function emitInwardDriftProposals(injectionNodeId, writebacks, realityTreeId) {
+    const proposals = writebacks
+        .map((wb) => {
+        const stamped = {
+            nodeId: wb.nodeId,
+            verifyClassification: wb.classification,
+            verifyDivergenceReason: wb.verifyDivergenceReason ?? null,
+            // TEL-5: the claim a human ratifier must reconsider is the tree's
+            // ORIGINAL assertion (the claim reality CONTRADICTED), NOT the achieved
+            // reality prose. Carry `originalClaim`; the detector falls back to a
+            // placeholder when it is absent. (`wb.statement` is the achieved prose
+            // -- it belongs in proposedCorrection / the divergence reason, never in
+            // observedState.)
+            claimStatement: wb.originalClaim ?? null,
+        };
+        return detectInwardDrift(stamped);
+    })
+        .filter((p) => p !== null);
+    if (proposals.length === 0)
+        return;
+    if (!realityTreeId) {
+        console.warn(`[reality-writeback] injection ${injectionNodeId.slice(0, 8)}: ` +
+            `${proposals.length} contradicted node(s) detected but no realityTreeId -- ` +
+            `inward drift proposals NOT created (per-node stamps retained).`);
+        return;
+    }
+    for (const proposal of proposals) {
+        try {
+            await callApi('crt_drift_proposal_create', {
+                realityTreeId,
+                proposalKind: proposal.proposalKind,
+                observedState: proposal.observedState,
+                proposedCorrection: proposal.proposedCorrection,
+                nodeId: proposal.nodeId,
+                proposedMetadata: proposal.proposedMetadata,
+            });
+        }
+        catch (err) {
+            console.warn(`[reality-writeback] Failed to create inward drift proposal for node ` +
+                `${proposal.nodeId.slice(0, 8)} (tree ${realityTreeId.slice(0, 8)}): ` +
+                `${err.message}. Stamp retained; proposal not surfaced.`);
+        }
+    }
+}
+/**
+ * Resolve the targeted UDE nodes of an injection via the existing
+ * `reality_tree_edge_list` ('targets' edges out of the injection) joined to
+ * `reality_tree_node_list` for each target's declared prose. Returns [] when
+ * the tree id is unknown or a lookup fails -- the writeback then degrades to a
+ * plain injection verify (no per-node stamping), which is non-destructive and
+ * matches prior behavior.
+ */
+export async function resolveTargetedNodes(injectionId, treeId) {
+    if (!treeId)
+        return [];
+    try {
+        const [edgesResp, nodesResp] = await Promise.all([
+            callApi('reality_tree_edge_list', { treeId }),
+            callApi('reality_tree_node_list', { treeId }),
+        ]);
+        const targetIds = (edgesResp.items ?? [])
+            .filter((e) => e.edgeType === 'targets' && e.fromNodeId === injectionId)
+            .map((e) => e.toNodeId);
+        if (targetIds.length === 0)
+            return [];
+        const nodeById = new Map();
+        for (const n of nodesResp.items ?? [])
+            nodeById.set(n.id, n);
+        const isClassification = (v) => v === 'match' || v === 'legitimate_divergence' || v === 'shortfall';
+        return targetIds.map((nodeId) => {
+            const node = nodeById.get(nodeId);
+            const declared = node?.frtStatement ?? node?.statement ?? '';
+            const existing = node?.verifyClassification;
+            return {
+                nodeId,
+                achievedStatement: declared,
+                originalClaim: declared,
+                existingClassification: isClassification(existing) ? existing : null,
+            };
+        });
+    }
+    catch (err) {
+        console.warn(`[reality-writeback] Failed to resolve targeted nodes for injection ` +
+            `${injectionId.slice(0, 8)} (tree ${treeId.slice(0, 8)}): ${err.message}. ` +
+            `Falling back to plain verify (no per-node writeback).`);
+        return [];
+    }
+}
+/**
+ * Build the writeback-applying verify callback used by the close-loop sweep.
+ *
+ * For each injection the sweep verifies, this closure:
+ *   1. Resolves the injection's targeted UDE node ids (edge-list) + each node's
+ *      EXISTING verify_classification.
+ *   2. Models the landing as a CLEAN realization for the still-unstamped (or
+ *      already-match) targets -- the anchoring delivery closed successfully, so
+ *      the cascade is treated as flipped and the injection as delivered. A
+ *      target the per-delivery verify path ALREADY stamped as a contradiction
+ *      (legitimate_divergence / shortfall) is EXCLUDED from the landing so the
+ *      close-loop sweep never clobbers a diverged stamp back to 'match' (TEL-3).
+ *   3. Computes the per-node writeback and applies it via
+ *      `verifyInjectionWithWriteback`, stamping match/evidence on each targeted
+ *      UDE so a later reader sees which claims actually held.
+ *
+ * No targeted nodes -> the writeback is empty and the call is byte-equivalent
+ * to the plain `verifyInjectionWithEvidence`.
+ *
+ * `treeIdByInjection` maps an injection node id to its reality_tree id, captured
+ * by the dispatcher from the focus-injections snapshot. The returned callback
+ * matches the `(injectionId, evidence) => Promise<void>` shape the close-loop
+ * sweep expects, so it drops into `advanceFocusToDoneWithSweep` unchanged.
+ *
+ * Exported here (rather than in the dispatcher) so the wiring is unit-testable
+ * against the callApi mock seam without dragging the dispatcher's heavy import
+ * graph.
+ */
+export function buildWritebackVerify(treeIdByInjection) {
+    return async (injectionId, evidence) => {
+        const treeId = treeIdByInjection.get(injectionId);
+        const resolved = await resolveTargetedNodes(injectionId, treeId);
+        // TEL-3: a node the per-delivery verify path ALREADY stamped as a
+        // contradiction (legitimate_divergence / shortfall) must NOT be clobbered
+        // back to 'match' at close-loop. Exclude it from the clean-match landing --
+        // its stamp (and its inward drift proposal) already landed at verify time.
+        // Only un-stamped (or already-match) nodes get a fresh close-loop match.
+        const targetedNodes = resolved
+            .filter((n) => n.existingClassification !== 'legitimate_divergence' &&
+            n.existingClassification !== 'shortfall')
+            .map((n) => ({
+            nodeId: n.nodeId,
+            achievedStatement: n.achievedStatement,
+            originalClaim: n.originalClaim,
+        }));
+        const writebacks = decideNodeWriteback({
+            injectionId,
+            targetedNodes,
+            cascadeFlipped: true,
+            delivered: true,
+            evidence,
+        });
+        // Pass the tree id so any contradicted node (divergence/shortfall) can be
+        // surfaced as an inward drift proposal. The close-loop sweep models a clean
+        // landing (all 'match'), so this emits nothing here today -- but the seam is
+        // wired so a divergent landing routed through this path corrects the tree.
+        await verifyInjectionWithWriteback(injectionId, evidence, writebacks, treeId);
+    };
+}
 //# sourceMappingURL=verification.js.map

package/dist/queries/verification.js.map

@@ -1 +1 @@
-{"version":3,"file":"verification.js","sourceRoot":"","sources":["../../src/queries/verification.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAiBtC,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,SAAkB;IAElB,MAAM,QAAQ,GAAG,MAAM,OAAO,CAC5B,kCAAkC,EAClC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAC/B,CAAC;IACF,OAAO,QAAQ,CAAC,KAAK,IAAI,EAAE,CAAC;AAC9B,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,iCAAiC,CACrD,UAAkB,EAClB,OAA4B;IAE5B,MAAM,OAAO,CAAC,6CAA6C,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC;AACxF,CAAC;AAiBD;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,eAAuB,EACvB,YAAkC;IAElC,MAAM,IAAI,GAA4B,EAAE,eAAe,EAAE,CAAC;IAC1D,IAAI,YAAY,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC;QAAE,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IAC9E,MAAM,OAAO,CAAC,+BAA+B,EAAE,IAAI,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAC/C,eAAuB,EACvB,QAAgB;IAEhB,MAAM,OAAO,CAAC,0BAA0B,EAAE;QACxC,MAAM,EAAE,eAAe;QACvB,QAAQ;KACT,CAAC,CAAC;IACH,MAAM,OAAO,CAAC,+BAA+B,EAAE,EAAE,eAAe,EAAE,CAAC,CAAC;AACtE,CAAC"}
+{"version":3,"file":"verification.js","sourceRoot":"","sources":["../../src/queries/verification.ts"],"names":[],"mappings":"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"}

package/dist/reality-writeback.d.ts

@@ -0,0 +1,257 @@
+/**
+ * Reality-tree writeback: decide the per-node verify classification a landing
+ * stamps onto the nodes an injection owns.
+ *
+ * The differential problem this closes: a confident-but-wrong tree stays wrong
+ * because reality never writes back. When a delivery lands, the injection it
+ * materialized is flipped to `verified`, but the *targeted* UDE nodes are not
+ * told whether the asserted desired effect actually held. So a mistaken claim
+ * is frozen, not corrected. This module computes -- deterministically, from a
+ * small typed landing signal -- what status each targeted node should carry so
+ * a later reader can see which claims actually realized.
+ *
+ * Reuses the EXISTING node verify-classification model (no new status
+ * machinery, no migration):
+ *   - `classification`: 'match' | 'legitimate_divergence' | 'shortfall'
+ *     (mirrors reality_tree_nodes.verify_classification)
+ *   - `evidence`: rationale for a clean realization (-> node.evidence)
+ *   - `verifyDivergenceReason`: why the achieved effect differs
+ *     (-> node.verify_divergence_reason)
+ *
+ * The function is PURE: no DB, no I/O, no clock. The dispatcher (close-loop
+ * landing path) supplies the landing signal and applies the result via the
+ * existing callApi verify / node-update seam. Nothing here is destructive --
+ * the output only stamps status + evidence/reason on nodes the injection owns.
+ *
+ * @module reality-writeback
+ */
+/** The three verify outcomes a node can carry. Mirrors VerifyClassification
+ * in src/types/reality-tree.ts -- duplicated here only because the daemon
+ * cannot import the Vite app's types. */
+export type WritebackClassification = 'match' | 'legitimate_divergence' | 'shortfall';
+/**
+ * One node the injection targets, as seen at landing. Intentionally minimal --
+ * just enough to identify the node and, optionally, observe whether its UDE
+ * flipped and how the achieved effect compares to what was declared. We model
+ * the landing observation per-node so a partially-divergent landing (one UDE
+ * flipped, another did not) stamps each node correctly.
+ */
+export interface TargetedNodeLanding {
+    /** reality_tree_nodes.id of the UDE this injection targeted. */
+    nodeId: string;
+    /**
+     * The node's ACHIEVED desired-effect prose. For a clean `match`, this is the
+     * declared desired effect carried forward unchanged (achieved == declared).
+     * Carried into the writeback's `statement` so the apply step has non-empty
+     * prose -- the verify edge only stamps a node's classification when the
+     * restatement carries a non-empty statement (an empty statement is dropped
+     * whole, classification included). Optional: omit when no prose is available
+     * and the apply step will fall back to leaving the node un-stamped.
+     */
+    achievedStatement?: string;
+    /**
+     * Did the FRT cascade actually flip this targeted UDE (UDE -> DE)? A clean
+     * landing flips it; a divergent landing leaves it unflipped. Optional so a
+     * caller that only has a focus-wide clean/divergent signal can omit it and
+     * fall back to the landing-level `cascadeFlipped`.
+     */
+    flipped?: boolean;
+    /**
+     * Whether the achieved effect (what reality delivered) differs from the
+     * declared desired effect even though the UDE flipped. A flipped-but-different
+     * landing is a `legitimate_divergence`, not a `match`.
+     */
+    achievedDiffersFromDeclared?: boolean;
+    /**
+     * Free-text reason describing the divergence or shortfall. Carried verbatim
+     * into verifyDivergenceReason. Ignored for a clean match.
+     */
+    divergenceReason?: string;
+    /**
+     * The node's ORIGINAL claim -- its declared desired-effect prose
+     * (frt_statement, else statement) AS IT STOOD BEFORE this landing. Distinct
+     * from `achievedStatement` (what reality delivered). Carried onto the
+     * writeback so the inward-drift detector can frame the contradiction as the
+     * tree's claim (observedState) vs what reality showed (proposedCorrection).
+     * A confident-but-wrong assertion is corrected by surfacing the CLAIM the
+     * ratifier must reconsider, not the reality that already happened. Optional:
+     * absent, the inward detector falls back to a deterministic placeholder.
+     */
+    originalClaim?: string;
+}
+/**
+ * The landing signal for one injection. Deliberately NOT coupled to a live
+ * derive_frt run -- the caller distills derive_frt (or a simpler delivery
+ * close) into this typed shape and hands it in.
+ */
+export interface InjectionLanding {
+    /** reality_tree_nodes.id of the injection node that landed. */
+    injectionId: string;
+    /** The nodes this injection targets (the UDEs it claimed to dissolve). */
+    targetedNodes: readonly TargetedNodeLanding[];
+    /**
+     * Landing-wide flip signal: did the cascade flip the targeted UDEs as a
+     * whole? Used as the fallback when a `TargetedNodeLanding` does not carry its
+     * own per-node `flipped`. A clean landing is `true`; a divergent landing is
+     * `false`.
+     */
+    cascadeFlipped: boolean;
+    /**
+     * Did the injection deliver its effect at all? When false, the gap means the
+     * injection did not produce the intended change and the targeted nodes are
+     * stamped `shortfall` rather than `legitimate_divergence`. Defaults to true
+     * (the injection delivered something) when omitted.
+     */
+    delivered?: boolean;
+    /**
+     * Evidence text for a clean realization. Cited verbatim on each matched
+     * node's evidence field so an audit read can trace why the claim was
+     * accepted. Optional -- absent, the match carries no evidence string.
+     */
+    evidence?: string;
+}
+/**
+ * Per-node writeback decision. Shaped to feed straight into the existing
+ * verify/node-update seam:
+ *   - match               -> stamp evidence (the achieved effect held)
+ *   - legitimate_divergence | shortfall -> stamp verifyDivergenceReason
+ */
+export interface NodeWriteback {
+    nodeId: string;
+    classification: WritebackClassification;
+    /**
+     * The achieved desired-effect prose to stamp on the node alongside the
+     * classification, carried from the landing's `achievedStatement`. Required
+     * by the apply step for the classification to land (the verify edge drops a
+     * restatement with an empty statement). Absent when the landing supplied no
+     * prose -- the apply step then skips the node.
+     */
+    statement?: string;
+    /** Set only for `match`; the rationale the claim held. */
+    evidence?: string;
+    /** Set only for divergence/shortfall; why the achieved effect differs. */
+    verifyDivergenceReason?: string;
+    /**
+     * The node's ORIGINAL claim (declared desired-effect prose before this
+     * landing), carried from the landing's `originalClaim`. Distinct from
+     * `statement` (the ACHIEVED prose). Threaded so a contradicted node's inward
+     * drift proposal frames the tree's claim (observedState), not the reality
+     * that already happened. Absent when the landing supplied no original claim.
+     */
+    originalClaim?: string;
+    /**
+     * TEL-6: an `assumed` match is a clean landing that carries NO evidence.
+     * Recording it as a `verified` (`match`) stamp would assert an UNEARNED
+     * certainty -- the exact disease this writeback fights. So an unevidenced
+     * match is flagged `assumed` and the apply step does NOT persist a
+     * `verify_classification='match'` for it (it stays unstamped until grounded).
+     * Only ever true on a `match`.
+     */
+    assumed?: boolean;
+}
+/**
+ * Pure decision: given one injection's landing signal, decide the per-node
+ * writeback for each targeted node.
+ *
+ * Rules (deterministic, evaluated per node):
+ *   1. Empty target set            -> empty output.
+ *   2. Injection did not deliver    -> EVERY node 'shortfall' + reason.
+ *      (delivered === false; the gap means the injection produced nothing.)
+ *   3. Node flipped AND achieved == declared -> 'match' (+ evidence if any).
+ *      Flip is the node's own `flipped` when present, else the landing's
+ *      `cascadeFlipped`.
+ *   4. Node flipped BUT achieved differs     -> 'legitimate_divergence'
+ *      (+ verifyDivergenceReason).
+ *   5. Node did NOT flip                      -> 'legitimate_divergence'
+ *      (+ verifyDivergenceReason) -- the targeted UDE did not move as claimed,
+ *      but the injection still delivered (rule 2 already handled non-delivery).
+ *
+ * No side effects. The caller applies the result via callApi.
+ */
+export declare function decideNodeWriteback(landing: InjectionLanding): NodeWriteback[];
+/**
+ * True iff the landing realized cleanly: every targeted node matched. An
+ * empty target set is vacuously clean. Convenience predicate for callers that
+ * need a single clean/divergent bit (e.g. to choose whether to short-circuit
+ * the flip), derived from the same pure decision so the two never disagree.
+ */
+export declare function isCleanLanding(landing: InjectionLanding): boolean;
+/**
+ * One node's stamped verify status as the inward detector sees it. Mirrors the
+ * columns the writeback persists onto reality_tree_nodes
+ * (`verify_classification` / `verify_divergence_reason`) plus the node's own
+ * claim prose, so the detector can frame the contradiction as
+ * observedState (the claim) vs proposedCorrection (what reality showed).
+ *
+ * Deliberately decoupled from `NodeWriteback`: any caller with a stamped node
+ * row (a fresh DB read, or the writeback's own output) can satisfy this shape.
+ */
+export interface StampedNode {
+    /** reality_tree_nodes.id of the stamped node. */
+    nodeId: string;
+    /**
+     * The node's stamped verify classification. `null`/`undefined` = unstamped
+     * (reality has not written back yet) -> no inward proposal.
+     */
+    verifyClassification?: WritebackClassification | null;
+    /** The recorded reason the achieved effect diverged. */
+    verifyDivergenceReason?: string | null;
+    /**
+     * The tree's CLAIM about this node -- its declared desired-effect prose
+     * (frt_statement, else statement). Carried into the proposal's observedState
+     * as the assertion reality contradicted. Optional: absent, a deterministic
+     * placeholder is used so the proposal still frames the contradiction.
+     */
+    claimStatement?: string | null;
+}
+/**
+ * The inward drift-proposal payload, shaped to feed straight into the existing
+ * `crt_drift_proposal_create` edge action (snake-cased by the caller / edge).
+ * `proposalKind` is always `update_statement` -- a contradicted claim is a
+ * claim whose statement reality showed to be wrong; the human ratifier decides
+ * the actual correction. `proposedMetadata.inward` flags it as INWARD drift
+ * (vs outward audit drift) and `sourceNodeId` records the stamped node that
+ * produced it.
+ */
+export interface InwardDriftProposal {
+    nodeId: string;
+    proposalKind: 'update_statement';
+    /** The tree's claim about the node -- the assertion reality contradicted. */
+    observedState: string;
+    /** What realized reality showed (the divergence reason) -- the correction. */
+    proposedCorrection: string;
+    proposedMetadata: {
+        /** Distinguishes inward (reality-contradicts-tree) from outward audit drift. */
+        inward: true;
+        /** The stamped node id that produced this proposal. */
+        sourceNodeId: string;
+        /** The stamped classification that triggered it (legitimate_divergence | shortfall). */
+        verifyClassification: 'legitimate_divergence' | 'shortfall';
+    };
+}
+/**
+ * Pure inward-drift detector.
+ *
+ * Detection rule (deterministic): a node whose `verifyClassification` is
+ * `legitimate_divergence` or `shortfall` is a CONTRADICTED claim -- realized
+ * reality did not match what the tree asserted. It maps to one inward
+ * `update_statement` drift proposal carrying:
+ *   - observedState      = the tree's claim (claimStatement, else a placeholder)
+ *   - proposedCorrection = what reality showed (verifyDivergenceReason, else a
+ *                          placeholder)
+ *   - proposedMetadata   = { inward:true, sourceNodeId, verifyClassification }
+ *
+ * A node stamped `match` produces NO proposal (reality confirmed the claim).
+ * An unstamped node (null/undefined classification) produces NO proposal
+ * (reality has not written back yet, so there is nothing to contradict).
+ *
+ * No side effects. The caller surfaces the result via crt_drift_proposal_create
+ * -- never auto-applies it.
+ */
+export declare function detectInwardDrift(node: StampedNode): InwardDriftProposal | null;
+/**
+ * Batch convenience: run `detectInwardDrift` over many stamped nodes, dropping
+ * the nulls. Order-preserving; pure.
+ */
+export declare function detectInwardDriftForNodes(nodes: readonly StampedNode[]): InwardDriftProposal[];
+//# sourceMappingURL=reality-writeback.d.ts.map

package/dist/reality-writeback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reality-writeback.d.ts","sourceRoot":"","sources":["../src/reality-writeback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;yCAEyC;AACzC,MAAM,MAAM,uBAAuB,GAAG,OAAO,GAAG,uBAAuB,GAAG,WAAW,CAAC;AAEtF;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,aAAa,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC9C;;;;;OAKG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,uBAAuB,CAAC;IACxC;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAWD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,GAAG,aAAa,EAAE,CAyE9E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAEjE;AAqBD;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,oBAAoB,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAAC;IACtD,wDAAwD;IACxD,sBAAsB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,kBAAkB,CAAC;IACjC,6EAA6E;IAC7E,aAAa,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE;QAChB,gFAAgF;QAChF,MAAM,EAAE,IAAI,CAAC;QACb,uDAAuD;QACvD,YAAY,EAAE,MAAM,CAAC;QACrB,wFAAwF;QACxF,oBAAoB,EAAE,uBAAuB,GAAG,WAAW,CAAC;KAC7D,CAAC;CACH;AAOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,mBAAmB,GAAG,IAAI,CA2B/E;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,WAAW,EAAE,GAC5B,mBAAmB,EAAE,CAOvB"}