@mmnto/totem 1.121.0 → 1.122.0

package/dist/artifacts/schema.d.ts

@@ -24,6 +24,9 @@
 import { z } from 'zod';
 /**
  * The schemaVersion WRITTEN by this code. Readers accept any 1.x (F1).
+ * 1.3.0 (mmnto-ai/totem#2700): `grounding` gained the optional `anchor` +
+ * `floor`, bundle items the optional `relevance` (which enters
+ * `grounding.hash`), `runMetadata` the optional `promptSource`.
  * 1.2.0 (mmnto-ai/totem#2452): `output` gained optional execution-attempt
  * evidence for fallback/configured-shell provenance. 1.1.0
  * (mmnto-ai/totem#2101): `grounding` gained the optional per-item
@@ -31,7 +34,7 @@ import { z } from 'zod';
  * to hash-of-bundle — the minor is the observable marker for that meaning
  * change; the registry stays empty because the tolerant reader parses both.
  */
-export declare const RUN_ARTIFACT_SCHEMA_VERSION = "1.2.0";
+export declare const RUN_ARTIFACT_SCHEMA_VERSION = "1.3.0";
 /**
  * Schema version for the distinct terminal-invocation failure ledger. The
  * exact 1.0.0 literal is deliberate fail-closed behavior: before accepting a
@@ -76,6 +79,33 @@ export declare const PROVENANCE_CLASSES: readonly ["similarity-only", "structura
  * ("empty"). Honest-absent: a degraded run says so in its own record.
  */
 export declare const PROVENANCE_UNGROUNDED = "ungrounded";
+/**
+ * What the run was ANCHORED on (mmnto-ai/totem#2700). A closed vocabulary —
+ * these four strings are the single spelling shared by the writer, the strict
+ * pre-commit evidence reader and the artifact verbs, so a gate and a producer
+ * can never disagree about the word.
+ *
+ * `issue` — every resolved input was an issue; `record` — a hand-authored
+ * design record bound with `--from` (the only kind carrying a `sha256`);
+ * `free-text` — every input was a topic; `mixed` — issues AND topics together.
+ * `mixed` is the honest fourth kind, NOT evidence: its free-text half is the
+ * confabulation surface.
+ */
+export declare const GROUNDING_ANCHOR_ISSUE = "issue";
+export declare const GROUNDING_ANCHOR_RECORD = "record";
+export declare const GROUNDING_ANCHOR_FREE_TEXT = "free-text";
+export declare const GROUNDING_ANCHOR_MIXED = "mixed";
+export declare const GROUNDING_ANCHOR_KINDS: readonly ["issue", "record", "free-text", "mixed"];
+/**
+ * Which system prompt drafted the output (mmnto-ai/totem#2700). Closed
+ * vocabulary, derived at the writer (`getSystemPrompt(...) === SYSTEM_PROMPT`
+ * → `builtin`, read BEFORE the code-blind directive is folded in). The CLI's
+ * `spec` command sets it and the strict pre-commit reader chooses the TEMPLATE
+ * or the DOCUMENT shape on it.
+ */
+export declare const PROMPT_SOURCE_BUILTIN = "builtin";
+export declare const PROMPT_SOURCE_OVERRIDE = "override";
+export declare const PROMPT_SOURCES: readonly ["builtin", "override"];
 /**
  * Slice-1 admission class for both migrated callers (spec + review): factually
  * completion-only today. #2102 (backend admission contract) changes who
@@ -139,18 +169,30 @@ export declare const GroundingItemSchema: z.ZodObject<{
     filePath: z.ZodString;
     /** Linked-index name for cross-repo hits; ABSENT = the run's own repo (F1) — post-checks resolve `filePath` against the run's config root when absent. */
     sourceRepo: z.ZodOptional<z.ZodString>;
+    /**
+     * The vector-leg relevance the hit was delivered with (mmnto-ai/totem#2700):
+     * `1 / (1 + _distance)` ∈ [0, 1]. ABSENT iff the hit had no vector leg
+     * (FTS-only) — "no signal" stays distinguishable from "weak signal"
+     * (mmnto-ai/totem#2463 / mmnto-ai/totem#2494), so absence is the disclosure,
+     * never a zero. Identical bytes across stores need not give identical
+     * relevance (a linked store embeds with its own embedder), which is why the
+     * value lives on the item rather than in a hash-keyed map.
+     */
+    relevance: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     filePath: string;
     contentHash: string;
     provenance: string;
     sourceType: string;
     sourceRepo?: string | undefined;
+    relevance?: number | undefined;
 }, {
     filePath: string;
     contentHash: string;
     provenance: string;
     sourceType: string;
     sourceRepo?: string | undefined;
+    relevance?: number | undefined;
 }>;
 /**
  * The per-item grounding record. No stored summary/count fields — counts are
@@ -169,18 +211,30 @@ export declare const GroundingBundleSchema: z.ZodObject<{
         filePath: z.ZodString;
         /** Linked-index name for cross-repo hits; ABSENT = the run's own repo (F1) — post-checks resolve `filePath` against the run's config root when absent. */
         sourceRepo: z.ZodOptional<z.ZodString>;
+        /**
+         * The vector-leg relevance the hit was delivered with (mmnto-ai/totem#2700):
+         * `1 / (1 + _distance)` ∈ [0, 1]. ABSENT iff the hit had no vector leg
+         * (FTS-only) — "no signal" stays distinguishable from "weak signal"
+         * (mmnto-ai/totem#2463 / mmnto-ai/totem#2494), so absence is the disclosure,
+         * never a zero. Identical bytes across stores need not give identical
+         * relevance (a linked store embeds with its own embedder), which is why the
+         * value lives on the item rather than in a hash-keyed map.
+         */
+        relevance: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         filePath: string;
         contentHash: string;
         provenance: string;
         sourceType: string;
         sourceRepo?: string | undefined;
+        relevance?: number | undefined;
     }, {
         filePath: string;
         contentHash: string;
         provenance: string;
         sourceType: string;
         sourceRepo?: string | undefined;
+        relevance?: number | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     items: {
@@ -189,6 +243,7 @@ export declare const GroundingBundleSchema: z.ZodObject<{
         provenance: string;
         sourceType: string;
         sourceRepo?: string | undefined;
+        relevance?: number | undefined;
     }[];
 }, {
     items: {
@@ -197,16 +252,48 @@ export declare const GroundingBundleSchema: z.ZodObject<{
         provenance: string;
         sourceType: string;
         sourceRepo?: string | undefined;
+        relevance?: number | undefined;
     }[];
 }>;
+export declare const GroundingAnchorSchema: z.ZodEffects<z.ZodObject<{
+    /** Closed vocabulary — the canonical spellings are {@link GROUNDING_ANCHOR_KINDS}. */
+    kind: z.ZodEnum<["issue", "record", "free-text", "mixed"]>;
+    /** `#<n>` / the input as typed for a URL or `owner/repo#N` (comma-joined for several); the repo-relative record path for `record`; the topic text for `free-text`. Never carries a control character — it is echoed by the pre-commit hook. */
+    ref: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    /** sha256 of the bound record's bytes — `record` anchors only. */
+    sha256: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "record" | "issue" | "free-text" | "mixed";
+    ref: string;
+    sha256?: string | undefined;
+}, {
+    kind: "record" | "issue" | "free-text" | "mixed";
+    ref: string;
+    sha256?: string | undefined;
+}>, {
+    kind: "record" | "issue" | "free-text" | "mixed";
+    ref: string;
+    sha256?: string | undefined;
+}, {
+    kind: "record" | "issue" | "free-text" | "mixed";
+    ref: string;
+    sha256?: string | undefined;
+}>;
 /** What KIND of grounding the run had — day-one field, never retrofittable. */
 export declare const GroundingSchema: z.ZodObject<{
     /**
      * Deterministic hash of the grounding surface. From 1.1.0 this is
-     * `calculateDeterministicHash(bundle)` — the verifier recomputes it from
-     * the artifact surface ALONE (one enumeration, two readers). Slice-1
-     * artifacts (no `bundle`) carry their original hash-of-raw-context, which
-     * is self-consistent but not recomputable offline.
+     * `calculateDeterministicHash(bundle)` over the canonically SORTED items —
+     * sorted BECAUSE the hash is order-significant for arrays (the sort key
+     * `sourceType, sourceRepo, filePath, contentHash` is unchanged). The
+     * verifier recomputes it from the artifact surface ALONE (one enumeration,
+     * two readers) — an invariant mmnto-ai/totem#2700 leaves untouched. Each
+     * item's `relevance` is part of the item, so it ENTERS this hash; `anchor`
+     * and `floor` sit BESIDE the bundle and do NOT (they enter the artifact's
+     * content address like every other field, as `output.metrics.durationMs`
+     * already does). Slice-1 artifacts (no `bundle`) carry their original
+     * hash-of-raw-context, which is self-consistent but not recomputable
+     * offline.
      */
     hash: z.ZodString;
     /** Derived from the bundle since 1.1.0 (sorted class counts, or `ungrounded`); wholesale string in slice-1 artifacts. */
@@ -224,18 +311,30 @@ export declare const GroundingSchema: z.ZodObject<{
             filePath: z.ZodString;
             /** Linked-index name for cross-repo hits; ABSENT = the run's own repo (F1) — post-checks resolve `filePath` against the run's config root when absent. */
             sourceRepo: z.ZodOptional<z.ZodString>;
+            /**
+             * The vector-leg relevance the hit was delivered with (mmnto-ai/totem#2700):
+             * `1 / (1 + _distance)` ∈ [0, 1]. ABSENT iff the hit had no vector leg
+             * (FTS-only) — "no signal" stays distinguishable from "weak signal"
+             * (mmnto-ai/totem#2463 / mmnto-ai/totem#2494), so absence is the disclosure,
+             * never a zero. Identical bytes across stores need not give identical
+             * relevance (a linked store embeds with its own embedder), which is why the
+             * value lives on the item rather than in a hash-keyed map.
+             */
+            relevance: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             filePath: string;
             contentHash: string;
             provenance: string;
             sourceType: string;
             sourceRepo?: string | undefined;
+            relevance?: number | undefined;
         }, {
             filePath: string;
             contentHash: string;
             provenance: string;
             sourceType: string;
             sourceRepo?: string | undefined;
+            relevance?: number | undefined;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         items: {
@@ -244,6 +343,7 @@ export declare const GroundingSchema: z.ZodObject<{
             provenance: string;
             sourceType: string;
             sourceRepo?: string | undefined;
+            relevance?: number | undefined;
         }[];
     }, {
         items: {
@@ -252,11 +352,44 @@ export declare const GroundingSchema: z.ZodObject<{
             provenance: string;
             sourceType: string;
             sourceRepo?: string | undefined;
+            relevance?: number | undefined;
         }[];
     }>>;
+    /** What the run was anchored on (mmnto-ai/totem#2700). Optional: artifacts written before the anchored-evidence rule predate it, and the gate reads that absence as not-evidence. */
+    anchor: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        /** Closed vocabulary — the canonical spellings are {@link GROUNDING_ANCHOR_KINDS}. */
+        kind: z.ZodEnum<["issue", "record", "free-text", "mixed"]>;
+        /** `#<n>` / the input as typed for a URL or `owner/repo#N` (comma-joined for several); the repo-relative record path for `record`; the topic text for `free-text`. Never carries a control character — it is echoed by the pre-commit hook. */
+        ref: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        /** sha256 of the bound record's bytes — `record` anchors only. */
+        sha256: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "record" | "issue" | "free-text" | "mixed";
+        ref: string;
+        sha256?: string | undefined;
+    }, {
+        kind: "record" | "issue" | "free-text" | "mixed";
+        ref: string;
+        sha256?: string | undefined;
+    }>, {
+        kind: "record" | "issue" | "free-text" | "mixed";
+        ref: string;
+        sha256?: string | undefined;
+    }, {
+        kind: "record" | "issue" | "free-text" | "mixed";
+        ref: string;
+        sha256?: string | undefined;
+    }>>;
+    /** The relevance floor the run was judged against (`searchRelevanceFloor`, post-parse — always a number when recorded). No config-vs-default bit is stored: it is not derivable after `TotemConfigSchema.parse`. */
+    floor: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     hash: string;
     provenanceSummary: string;
+    anchor?: {
+        kind: "record" | "issue" | "free-text" | "mixed";
+        ref: string;
+        sha256?: string | undefined;
+    } | undefined;
     bundle?: {
         items: {
             filePath: string;
@@ -264,11 +397,18 @@ export declare const GroundingSchema: z.ZodObject<{
             provenance: string;
             sourceType: string;
             sourceRepo?: string | undefined;
+            relevance?: number | undefined;
         }[];
     } | undefined;
+    floor?: number | undefined;
 }, {
     hash: string;
     provenanceSummary: string;
+    anchor?: {
+        kind: "record" | "issue" | "free-text" | "mixed";
+        ref: string;
+        sha256?: string | undefined;
+    } | undefined;
     bundle?: {
         items: {
             filePath: string;
@@ -276,8 +416,10 @@ export declare const GroundingSchema: z.ZodObject<{
             provenance: string;
             sourceType: string;
             sourceRepo?: string | undefined;
+            relevance?: number | undefined;
         }[];
     } | undefined;
+    floor?: number | undefined;
 }>;
 /** Backend identity as RESOLVED (post quota-fallback), not as requested. */
 export declare const BackendSchema: z.ZodObject<{
@@ -1540,14 +1682,26 @@ export declare const RunMetadataSchema: z.ZodObject<{
      * recomputing `code.length === 0` from the grounding bundle.
      */
     codeBlind: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Which system prompt drafted the output (mmnto-ai/totem#2700): `builtin`
+     * when `getSystemPrompt(...) === SYSTEM_PROMPT`, `override` otherwise —
+     * derived at the writer, read BEFORE the code-blind directive is folded in.
+     * The strict evidence reader chooses the TEMPLATE vs DOCUMENT shape on it:
+     * a draft written under a custom prompt cannot be held to the built-in
+     * template's headings. Absent on pre-existing artifacts (which block on the
+     * missing anchor first, so the shape choice is never reached for them).
+     */
+    promptSource: z.ZodOptional<z.ZodEnum<["builtin", "override"]>>;
 }, "strip", z.ZodTypeAny, {
     caller?: string | undefined;
     command?: string | undefined;
     codeBlind?: boolean | undefined;
+    promptSource?: "builtin" | "override" | undefined;
 }, {
     caller?: string | undefined;
     command?: string | undefined;
     codeBlind?: boolean | undefined;
+    promptSource?: "builtin" | "override" | undefined;
 }>;
 /**
  * Token counts mirror `OrchestratorResult`: `null` means the provider did not
@@ -1600,10 +1754,17 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
     grounding: z.ZodObject<{
         /**
          * Deterministic hash of the grounding surface. From 1.1.0 this is
-         * `calculateDeterministicHash(bundle)` — the verifier recomputes it from
-         * the artifact surface ALONE (one enumeration, two readers). Slice-1
-         * artifacts (no `bundle`) carry their original hash-of-raw-context, which
-         * is self-consistent but not recomputable offline.
+         * `calculateDeterministicHash(bundle)` over the canonically SORTED items —
+         * sorted BECAUSE the hash is order-significant for arrays (the sort key
+         * `sourceType, sourceRepo, filePath, contentHash` is unchanged). The
+         * verifier recomputes it from the artifact surface ALONE (one enumeration,
+         * two readers) — an invariant mmnto-ai/totem#2700 leaves untouched. Each
+         * item's `relevance` is part of the item, so it ENTERS this hash; `anchor`
+         * and `floor` sit BESIDE the bundle and do NOT (they enter the artifact's
+         * content address like every other field, as `output.metrics.durationMs`
+         * already does). Slice-1 artifacts (no `bundle`) carry their original
+         * hash-of-raw-context, which is self-consistent but not recomputable
+         * offline.
          */
         hash: z.ZodString;
         /** Derived from the bundle since 1.1.0 (sorted class counts, or `ungrounded`); wholesale string in slice-1 artifacts. */
@@ -1621,18 +1782,30 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
                 filePath: z.ZodString;
                 /** Linked-index name for cross-repo hits; ABSENT = the run's own repo (F1) — post-checks resolve `filePath` against the run's config root when absent. */
                 sourceRepo: z.ZodOptional<z.ZodString>;
+                /**
+                 * The vector-leg relevance the hit was delivered with (mmnto-ai/totem#2700):
+                 * `1 / (1 + _distance)` ∈ [0, 1]. ABSENT iff the hit had no vector leg
+                 * (FTS-only) — "no signal" stays distinguishable from "weak signal"
+                 * (mmnto-ai/totem#2463 / mmnto-ai/totem#2494), so absence is the disclosure,
+                 * never a zero. Identical bytes across stores need not give identical
+                 * relevance (a linked store embeds with its own embedder), which is why the
+                 * value lives on the item rather than in a hash-keyed map.
+                 */
+                relevance: z.ZodOptional<z.ZodNumber>;
             }, "strip", z.ZodTypeAny, {
                 filePath: string;
                 contentHash: string;
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }, {
                 filePath: string;
                 contentHash: string;
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }>, "many">;
         }, "strip", z.ZodTypeAny, {
             items: {
@@ -1641,6 +1814,7 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         }, {
             items: {
@@ -1649,11 +1823,44 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         }>>;
+        /** What the run was anchored on (mmnto-ai/totem#2700). Optional: artifacts written before the anchored-evidence rule predate it, and the gate reads that absence as not-evidence. */
+        anchor: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            /** Closed vocabulary — the canonical spellings are {@link GROUNDING_ANCHOR_KINDS}. */
+            kind: z.ZodEnum<["issue", "record", "free-text", "mixed"]>;
+            /** `#<n>` / the input as typed for a URL or `owner/repo#N` (comma-joined for several); the repo-relative record path for `record`; the topic text for `free-text`. Never carries a control character — it is echoed by the pre-commit hook. */
+            ref: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+            /** sha256 of the bound record's bytes — `record` anchors only. */
+            sha256: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        }, {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        }>, {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        }, {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        }>>;
+        /** The relevance floor the run was judged against (`searchRelevanceFloor`, post-parse — always a number when recorded). No config-vs-default bit is stored: it is not derivable after `TotemConfigSchema.parse`. */
+        floor: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         hash: string;
         provenanceSummary: string;
+        anchor?: {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        } | undefined;
         bundle?: {
             items: {
                 filePath: string;
@@ -1661,11 +1868,18 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         } | undefined;
+        floor?: number | undefined;
     }, {
         hash: string;
         provenanceSummary: string;
+        anchor?: {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        } | undefined;
         bundle?: {
             items: {
                 filePath: string;
@@ -1673,8 +1887,10 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         } | undefined;
+        floor?: number | undefined;
     }>;
     requestedBackend: z.ZodObject<{
         provider: z.ZodString;
@@ -2257,14 +2473,26 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
              * recomputing `code.length === 0` from the grounding bundle.
              */
             codeBlind: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * Which system prompt drafted the output (mmnto-ai/totem#2700): `builtin`
+             * when `getSystemPrompt(...) === SYSTEM_PROMPT`, `override` otherwise —
+             * derived at the writer, read BEFORE the code-blind directive is folded in.
+             * The strict evidence reader chooses the TEMPLATE vs DOCUMENT shape on it:
+             * a draft written under a custom prompt cannot be held to the built-in
+             * template's headings. Absent on pre-existing artifacts (which block on the
+             * missing anchor first, so the shape choice is never reached for them).
+             */
+            promptSource: z.ZodOptional<z.ZodEnum<["builtin", "override"]>>;
         }, "strip", z.ZodTypeAny, {
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         }, {
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
         outputContract?: {
@@ -2279,6 +2507,7 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         } | undefined;
     }, {
         outputContract?: {
@@ -2293,6 +2522,7 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         } | undefined;
     }>>;
     createdAt: z.ZodString;
@@ -2346,6 +2576,11 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
     grounding: {
         hash: string;
         provenanceSummary: string;
+        anchor?: {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        } | undefined;
         bundle?: {
             items: {
                 filePath: string;
@@ -2353,8 +2588,10 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         } | undefined;
+        floor?: number | undefined;
     };
     requestedBackend: {
         model: string;
@@ -2391,6 +2628,7 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         } | undefined;
     } | undefined;
 }, {
@@ -2443,6 +2681,11 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
     grounding: {
         hash: string;
         provenanceSummary: string;
+        anchor?: {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        } | undefined;
         bundle?: {
             items: {
                 filePath: string;
@@ -2450,8 +2693,10 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         } | undefined;
+        floor?: number | undefined;
     };
     requestedBackend: {
         model: string;
@@ -2488,6 +2733,7 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         } | undefined;
     } | undefined;
 }>, {
@@ -2540,6 +2786,11 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
     grounding: {
         hash: string;
         provenanceSummary: string;
+        anchor?: {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        } | undefined;
         bundle?: {
             items: {
                 filePath: string;
@@ -2547,8 +2798,10 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         } | undefined;
+        floor?: number | undefined;
     };
     requestedBackend: {
         model: string;
@@ -2585,6 +2838,7 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         } | undefined;
     } | undefined;
 }, {
@@ -2637,6 +2891,11 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
     grounding: {
         hash: string;
         provenanceSummary: string;
+        anchor?: {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        } | undefined;
         bundle?: {
             items: {
                 filePath: string;
@@ -2644,8 +2903,10 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         } | undefined;
+        floor?: number | undefined;
     };
     requestedBackend: {
         model: string;
@@ -2682,6 +2943,7 @@ export declare const InvocationFailureArtifactSchema: z.ZodEffects<z.ZodObject<{
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         } | undefined;
     } | undefined;
 }>;
@@ -2710,10 +2972,17 @@ export declare const RunArtifactSchema: z.ZodObject<{
     grounding: z.ZodObject<{
         /**
          * Deterministic hash of the grounding surface. From 1.1.0 this is
-         * `calculateDeterministicHash(bundle)` — the verifier recomputes it from
-         * the artifact surface ALONE (one enumeration, two readers). Slice-1
-         * artifacts (no `bundle`) carry their original hash-of-raw-context, which
-         * is self-consistent but not recomputable offline.
+         * `calculateDeterministicHash(bundle)` over the canonically SORTED items —
+         * sorted BECAUSE the hash is order-significant for arrays (the sort key
+         * `sourceType, sourceRepo, filePath, contentHash` is unchanged). The
+         * verifier recomputes it from the artifact surface ALONE (one enumeration,
+         * two readers) — an invariant mmnto-ai/totem#2700 leaves untouched. Each
+         * item's `relevance` is part of the item, so it ENTERS this hash; `anchor`
+         * and `floor` sit BESIDE the bundle and do NOT (they enter the artifact's
+         * content address like every other field, as `output.metrics.durationMs`
+         * already does). Slice-1 artifacts (no `bundle`) carry their original
+         * hash-of-raw-context, which is self-consistent but not recomputable
+         * offline.
          */
         hash: z.ZodString;
         /** Derived from the bundle since 1.1.0 (sorted class counts, or `ungrounded`); wholesale string in slice-1 artifacts. */
@@ -2731,18 +3000,30 @@ export declare const RunArtifactSchema: z.ZodObject<{
                 filePath: z.ZodString;
                 /** Linked-index name for cross-repo hits; ABSENT = the run's own repo (F1) — post-checks resolve `filePath` against the run's config root when absent. */
                 sourceRepo: z.ZodOptional<z.ZodString>;
+                /**
+                 * The vector-leg relevance the hit was delivered with (mmnto-ai/totem#2700):
+                 * `1 / (1 + _distance)` ∈ [0, 1]. ABSENT iff the hit had no vector leg
+                 * (FTS-only) — "no signal" stays distinguishable from "weak signal"
+                 * (mmnto-ai/totem#2463 / mmnto-ai/totem#2494), so absence is the disclosure,
+                 * never a zero. Identical bytes across stores need not give identical
+                 * relevance (a linked store embeds with its own embedder), which is why the
+                 * value lives on the item rather than in a hash-keyed map.
+                 */
+                relevance: z.ZodOptional<z.ZodNumber>;
             }, "strip", z.ZodTypeAny, {
                 filePath: string;
                 contentHash: string;
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }, {
                 filePath: string;
                 contentHash: string;
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }>, "many">;
         }, "strip", z.ZodTypeAny, {
             items: {
@@ -2751,6 +3032,7 @@ export declare const RunArtifactSchema: z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         }, {
             items: {
@@ -2759,11 +3041,44 @@ export declare const RunArtifactSchema: z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         }>>;
+        /** What the run was anchored on (mmnto-ai/totem#2700). Optional: artifacts written before the anchored-evidence rule predate it, and the gate reads that absence as not-evidence. */
+        anchor: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            /** Closed vocabulary — the canonical spellings are {@link GROUNDING_ANCHOR_KINDS}. */
+            kind: z.ZodEnum<["issue", "record", "free-text", "mixed"]>;
+            /** `#<n>` / the input as typed for a URL or `owner/repo#N` (comma-joined for several); the repo-relative record path for `record`; the topic text for `free-text`. Never carries a control character — it is echoed by the pre-commit hook. */
+            ref: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+            /** sha256 of the bound record's bytes — `record` anchors only. */
+            sha256: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        }, {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        }>, {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        }, {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        }>>;
+        /** The relevance floor the run was judged against (`searchRelevanceFloor`, post-parse — always a number when recorded). No config-vs-default bit is stored: it is not derivable after `TotemConfigSchema.parse`. */
+        floor: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         hash: string;
         provenanceSummary: string;
+        anchor?: {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        } | undefined;
         bundle?: {
             items: {
                 filePath: string;
@@ -2771,11 +3086,18 @@ export declare const RunArtifactSchema: z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         } | undefined;
+        floor?: number | undefined;
     }, {
         hash: string;
         provenanceSummary: string;
+        anchor?: {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        } | undefined;
         bundle?: {
             items: {
                 filePath: string;
@@ -2783,8 +3105,10 @@ export declare const RunArtifactSchema: z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         } | undefined;
+        floor?: number | undefined;
     }>;
     backend: z.ZodObject<{
         provider: z.ZodString;
@@ -3547,14 +3871,26 @@ export declare const RunArtifactSchema: z.ZodObject<{
              * recomputing `code.length === 0` from the grounding bundle.
              */
             codeBlind: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * Which system prompt drafted the output (mmnto-ai/totem#2700): `builtin`
+             * when `getSystemPrompt(...) === SYSTEM_PROMPT`, `override` otherwise —
+             * derived at the writer, read BEFORE the code-blind directive is folded in.
+             * The strict evidence reader chooses the TEMPLATE vs DOCUMENT shape on it:
+             * a draft written under a custom prompt cannot be held to the built-in
+             * template's headings. Absent on pre-existing artifacts (which block on the
+             * missing anchor first, so the shape choice is never reached for them).
+             */
+            promptSource: z.ZodOptional<z.ZodEnum<["builtin", "override"]>>;
         }, "strip", z.ZodTypeAny, {
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         }, {
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
         outputContract?: {
@@ -3569,6 +3905,7 @@ export declare const RunArtifactSchema: z.ZodObject<{
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         } | undefined;
     }, {
         outputContract?: {
@@ -3583,6 +3920,7 @@ export declare const RunArtifactSchema: z.ZodObject<{
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         } | undefined;
     }>>;
     /**
@@ -3603,6 +3941,11 @@ export declare const RunArtifactSchema: z.ZodObject<{
     grounding: {
         hash: string;
         provenanceSummary: string;
+        anchor?: {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        } | undefined;
         bundle?: {
             items: {
                 filePath: string;
@@ -3610,8 +3953,10 @@ export declare const RunArtifactSchema: z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         } | undefined;
+        floor?: number | undefined;
     };
     backend: {
         model: string;
@@ -3683,6 +4028,7 @@ export declare const RunArtifactSchema: z.ZodObject<{
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         } | undefined;
     } | undefined;
 }, {
@@ -3698,6 +4044,11 @@ export declare const RunArtifactSchema: z.ZodObject<{
     grounding: {
         hash: string;
         provenanceSummary: string;
+        anchor?: {
+            kind: "record" | "issue" | "free-text" | "mixed";
+            ref: string;
+            sha256?: string | undefined;
+        } | undefined;
         bundle?: {
             items: {
                 filePath: string;
@@ -3705,8 +4056,10 @@ export declare const RunArtifactSchema: z.ZodObject<{
                 provenance: string;
                 sourceType: string;
                 sourceRepo?: string | undefined;
+                relevance?: number | undefined;
             }[];
         } | undefined;
+        floor?: number | undefined;
     };
     backend: {
         model: string;
@@ -3778,6 +4131,7 @@ export declare const RunArtifactSchema: z.ZodObject<{
             caller?: string | undefined;
             command?: string | undefined;
             codeBlind?: boolean | undefined;
+            promptSource?: "builtin" | "override" | undefined;
         } | undefined;
     } | undefined;
 }>;
@@ -3791,6 +4145,11 @@ export type InvocationFailureArtifact = z.infer<typeof InvocationFailureArtifact
 export type InputBundle = z.infer<typeof InputBundleSchema>;
 export type GroundingItem = z.infer<typeof GroundingItemSchema>;
 export type GroundingBundle = z.infer<typeof GroundingBundleSchema>;
+export type GroundingAnchor = z.infer<typeof GroundingAnchorSchema>;
+/** Inferred from the anchor schema's enum — the canonical anchor-kind union (mmnto-ai/totem#2700). */
+export type GroundingAnchorKind = GroundingAnchor['kind'];
+/** Inferred from the tuple the `RunMetadataSchema.promptSource` enum is built from — the canonical prompt-source union (mmnto-ai/totem#2700). */
+export type PromptSource = (typeof PROMPT_SOURCES)[number];
 export type OutputContract = z.infer<typeof OutputContractSchema>;
 export type ContextPolicy = z.infer<typeof ContextPolicySchema>;
 export type RunMetadata = z.infer<typeof RunMetadataSchema>;