@kontourai/flow-agents 1.2.0 → 1.4.0

package/kits/knowledge/adapters/obsidian-store/index.js

@@ -11,7 +11,25 @@
  *     graph-index.json                     (link graph — required by suite §13)
  *     .graph-index.json                    (path index — id→{path,archived})
  *
- * Frontmatter carries ALL contract fields; body rendered for Obsidian readability.
+ * Frontmatter carries all contract fields EXCEPT `body`.
+ * The rendered note body below the frontmatter fence IS the canonical body
+ * storage — body is parsed back from the rendered markdown on read.
+ *
+ * Body render/parse inverse:
+ *   ALL types → an invisible sentinel `<!-- kit:body-end -->` is emitted on
+ *               its own line immediately after the body text.  Obsidian renders
+ *               HTML comments as nothing so it is invisible to vault readers.
+ *               On read, everything before the sentinel (trimmed) is the body.
+ *               There is NO body-content constraint — bodies may freely contain
+ *               any markdown, including `## Sources`, `## Related`, etc.
+ *   raw    → body is additionally wrapped in a callout block for readability:
+ *              > [!note]- Raw Notes
+ *              > {body lines}
+ *            The sentinel follows the callout block.
+ *            Parse: strip callout wrapper, then split on sentinel.
+ *   others → body verbatim, then sentinel, then optional ## sections.
+ *            Parse: everything before the sentinel, trimmed.
+ *
  * Category dots map to directory segments: "eng.api" → "eng/api/".
  * Filename: slugified title, collision-suffixed (-2, -3, …).
  * Superseded records MOVE to archive/ (supersede-not-delete invariant).
@@ -41,6 +59,19 @@ import {
   validateCategory,
 } from "../shared/codec.js";
 
+// ---------------------------------------------------------------------------
+// Body render / parse constants
+// ---------------------------------------------------------------------------
+
+// Invisible sentinel emitted between the body and the generated structural
+// sections in every rendered note.  Obsidian renders HTML comments as nothing
+// so vault readers never see it.  On read, everything before this sentinel
+// (trimmed) is the canonical body — no heading-text collision possible.
+const BODY_END_SENTINEL = "<!-- kit:body-end -->";
+
+// Callout header line emitted for raw records
+const RAW_CALLOUT_HEADER = "> [!note]- Raw Notes";
+
 // ---------------------------------------------------------------------------
 // ObsidianKnowledgeStore
 // ---------------------------------------------------------------------------
@@ -128,6 +159,67 @@ export class ObsidianKnowledgeStore {
     fs.writeFileSync(this._pathIndexPath, JSON.stringify(index, null, 2) + "\n", "utf8");
   }
 
+  // -------------------------------------------------------------------------
+  // Body render / parse (render+parse must be an exact inverse for body)
+  // -------------------------------------------------------------------------
+
+  /**
+   * Parse the record body back from the rendered Obsidian markdown section
+   * (the text after the frontmatter fence).
+   *
+   * All record types use the invisible sentinel BODY_END_SENTINEL
+   * (`<!-- kit:body-end -->`) as the exclusive delimiter between the body
+   * and any appended structural sections.  The sentinel appears on its own
+   * line immediately after the body text; everything before it (trimmed) is
+   * the canonical body.  This is collision-proof: body text may freely contain
+   * any markdown, including lines like `## Sources` or `## Related`.
+   *
+   * raw records additionally wrap the body in a callout block for human
+   * readability.  The sentinel appears after the closing callout line.
+   * Parse: strip the callout (header line + `> ` prefix), then split on
+   * the sentinel to recover the exact original body.
+   *
+   * @param {string} type  - record type
+   * @param {string} renderedText  - text after the frontmatter fence (raw markdown)
+   * @returns {string}
+   */
+  _parseBodyFromRendered(type, renderedText) {
+    // Split on the sentinel first — the body is always everything before it,
+    // regardless of type.  For raw records we still need to strip the callout
+    // wrapper from within that portion.
+    const sentinelIdx = renderedText.indexOf(BODY_END_SENTINEL);
+    const bodySection = sentinelIdx === -1
+      ? renderedText          // sentinel missing (legacy note): fall back to full text
+      : renderedText.slice(0, sentinelIdx);
+
+    if (type === "raw") {
+      // bodySection is the callout block:
+      //   > [!note]- Raw Notes
+      //   > line1
+      //   > line2
+      // Strip the header line and the `> ` prefix from each body line.
+      const lines = bodySection.split("\n");
+      // First line is the callout header — skip it
+      const bodyLines = [];
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith("> ")) {
+          bodyLines.push(line.slice(2));
+        } else if (line === ">") {
+          bodyLines.push("");
+        } else {
+          // Safety: non-callout line stops the block (should not occur in
+          // well-formed notes written by this adapter).
+          break;
+        }
+      }
+      return bodyLines.join("\n");
+    }
+
+    // compiled / concept / snapshot / person: body is verbatim before sentinel
+    return bodySection.trimEnd();
+  }
+
   // -------------------------------------------------------------------------
   // Record I/O
   // -------------------------------------------------------------------------
@@ -142,17 +234,19 @@ export class ObsidianKnowledgeStore {
   }
 
   /**
-   * Read a record by id. Returns the full record object (all fields from
-   * frontmatter, with `body` included) or null if not found.
+   * Read a record by id. Returns the full record object with `body` parsed
+   * from the rendered note body (the canonical storage), or null if not found.
    */
   _readRecord(id, pathIndex) {
     const absPath = this._getAbsPath(id, pathIndex);
     if (!absPath || !fs.existsSync(absPath)) return null;
     const text = fs.readFileSync(absPath, "utf8");
-    const { meta } = parseMarkdown(text);
+    const { meta, body: renderedText } = parseMarkdown(text);
     if (!meta.id) return null;
-    // body is stored in frontmatter as meta.body
-    return { ...meta };
+    // Reconstruct the record body from the rendered markdown section.
+    // `meta` no longer contains `body` — the rendered text is the source of truth.
+    const body = this._parseBodyFromRendered(meta.type, renderedText);
+    return { ...meta, body };
   }
 
   /**
@@ -160,8 +254,8 @@ export class ObsidianKnowledgeStore {
    *
    * - On first write: computes slug path, registers in path index.
    * - On update with title change: renames file (old deleted, new path used).
-   * - All contract fields stored in YAML frontmatter.
-   * - Below the frontmatter: Obsidian-readable human body for the note type.
+   * - All contract fields EXCEPT `body` stored in YAML frontmatter.
+   * - `body` is encoded in the rendered Obsidian markdown section below the fence.
    */
   _writeRecord(record, pathIndex) {
     const ownedIndex = !pathIndex;
@@ -195,7 +289,7 @@ export class ObsidianKnowledgeStore {
       targetRelPath = newRelPath;
     }
 
-    // Render: all contract fields in frontmatter; human body below
+    // Frontmatter: all contract fields EXCEPT `body` (body is in the rendered section).
     const { body, ...frontmatterFields } = record;
     // Derived dimension fields (territory: east, customer: acme, ...) from
     // category segments after the domain segment — presentation-only, never
@@ -205,8 +299,7 @@ export class ObsidianKnowledgeStore {
       const segs = record.category.split(".").slice(1);
       this._dimensions.forEach((name, i) => { if (segs[i]) derived[name] = segs[i]; });
     }
-    // Store body in frontmatter so round-trip is lossless
-    const frontmatter = { ...frontmatterFields, ...derived, body };
+    const frontmatter = { ...frontmatterFields, ...derived };
     const obsidianBody = this._renderObsidianBody(record, pathIndex);
     const text = `---\n${serializeYaml(frontmatter)}\n---\n\n${obsidianBody}`;
 
@@ -262,7 +355,22 @@ export class ObsidianKnowledgeStore {
 
   /**
    * Render the human-readable Obsidian body below the frontmatter fence.
-   * This is decorative — the canonical data lives in frontmatter.
+   * The body content IS the canonical storage — parsing this rendered text
+   * back via _parseBodyFromRendered() must return the original body exactly.
+   *
+   * render/parse contract:
+   *   ALL types → emit BODY_END_SENTINEL (<!-- kit:body-end -->) on its own
+   *               line immediately after the body content and before any
+   *               generated ## sections.  The sentinel is invisible in Obsidian
+   *               (HTML comments are not rendered) and cannot be confused with
+   *               any user-supplied body text.
+   *
+   *   raw    → body is wrapped in a callout block for human readability:
+   *              > [!note]- Raw Notes
+   *              > {body lines}
+   *            The sentinel immediately follows the callout block.
+   *
+   *   others → body verbatim, then sentinel, then optional ## sections.
    */
   _renderObsidianBody(record, pathIndex) {
     const links = record.links || [];
@@ -282,40 +390,43 @@ export class ObsidianKnowledgeStore {
         .filter(Boolean)
         .join(", ");
 
-    const sections = [];
-
+    // bodyPart: the portion of the rendered note containing the record body
+    // (possibly wrapped in a callout for raw records).
+    let bodyPart;
     if (record.type === "raw") {
-      sections.push(`> [!note]- Raw Notes\n> ${record.body.replace(/\n/g, "\n> ")}`);
-    } else if (record.type === "person") {
-      // Person cards: lead with the body (role/org prose), then People links,
-      // then Appears In backlinks to sources, then Related.
-      sections.push(record.body);
+      // Callout block: header line + body lines each prefixed with `> `.
+      // _parseBodyFromRendered strips these back to recover the exact body.
+      bodyPart = `${RAW_CALLOUT_HEADER}\n> ${record.body.replace(/\n/g, "\n> ")}`;
     } else {
-      // compiled / concept / snapshot: insight as readable body
-      sections.push(record.body);
+      // compiled / concept / snapshot / person: body verbatim
+      bodyPart = record.body;
     }
 
+    // Sentinel immediately follows the body part, on its own line.
+    // Everything between the frontmatter fence and this sentinel is the body.
+    const parts = [`${bodyPart}\n${BODY_END_SENTINEL}`];
+
     if (sourceLinks.length > 0) {
-      sections.push(`## Sources\n\n${wikiLinks(sourceLinks)}`);
+      parts.push(`## Sources\n\n${wikiLinks(sourceLinks)}`);
     }
 
     // Person cards: render appears-in links (backlinks to raw+compiled records)
     const appearsInLinks = links.filter((l) => l.kind === "appears-in");
     if (record.type === "person" && appearsInLinks.length > 0) {
-      sections.push(`## Appears In\n\n${wikiLinks(appearsInLinks)}`);
+      parts.push(`## Appears In\n\n${wikiLinks(appearsInLinks)}`);
     }
 
     // Compiled/person records: render people links (links to person cards)
     const peopleLinks = links.filter((l) => l.kind === "person");
     if (peopleLinks.length > 0) {
-      sections.push(`## People\n\n${wikiLinks(peopleLinks)}`);
+      parts.push(`## People\n\n${wikiLinks(peopleLinks)}`);
     }
 
     if (relatedLinks.length > 0) {
-      sections.push(`## Related\n\n${wikiLinks(relatedLinks)}`);
+      parts.push(`## Related\n\n${wikiLinks(relatedLinks)}`);
     }
 
-    return sections.join("\n\n");
+    return parts.join("\n\n");
   }
 
   // -------------------------------------------------------------------------

package/kits/knowledge/evals/contract-suite/suite.test.js

@@ -672,4 +672,94 @@ describe("Knowledge Kit Store Contract Suite", () => {
       assert.ok(rev, "reverse index has the backlink");
     });
   });
+
+  // -----------------------------------------------------------------------
+  // §14  body round-trip — collision-proof delimiter regression (AC: sentinel)
+  // -----------------------------------------------------------------------
+  describe("body round-trip: sentinel delimiter (regression for heading-collision bug)", () => {
+    let dir, store;
+    before(() => { dir = makeTempDir(); store = makeStore(dir); });
+    after(() => fs.rmSync(dir, { recursive: true, force: true }));
+
+    test("body containing '## Sources' round-trips exactly (regression: was silently truncated)", async () => {
+      // Previously the adapter delimited body from structural sections by
+      // searching for '## Sources' / '## Related' etc. in the rendered text.
+      // A body that contained one of those exact headings was silently truncated
+      // on read.  The fix: an invisible sentinel <!-- kit:body-end --> is
+      // emitted after the body so body content cannot collide with the delimiter.
+      const body = "Findings below.\n\n## Sources\nThis is body content, not a structural section.";
+      const id = await store.create({
+        type: "concept",
+        title: "Sources In Body Regression",
+        body,
+        category: "test",
+        provenance: { agent: "tester" },
+      });
+      const record = await store.get(id);
+      assert.equal(record.body, body,
+        "body containing '## Sources' must round-trip exactly (no silent truncation)");
+    });
+
+    test("body containing '## Related' and '## People' round-trips exactly", async () => {
+      const body = "## Related\nSome related context.\n\n## People\nAlice, Bob.";
+      const id = await store.create({
+        type: "snapshot",
+        title: "Related And People In Body",
+        body,
+        category: "test",
+        provenance: { agent: "tester" },
+      });
+      const record = await store.get(id);
+      assert.equal(record.body, body,
+        "body containing '## Related' and '## People' must round-trip exactly");
+    });
+
+    test("raw body containing callout-like lines round-trips exactly", async () => {
+      const body = "> [!note] Looks like a callout\n> quoted line\nNormal line after.";
+      const id = await store.create({
+        type: "raw",
+        title: "Callout-like Raw Body",
+        body,
+        category: "test",
+        provenance: { agent: "tester" },
+      });
+      const record = await store.get(id);
+      assert.equal(record.body, body,
+        "raw body with callout-like lines must round-trip exactly");
+    });
+
+    test("multi-paragraph body with various ## headings round-trips exactly", async () => {
+      const body = "# Overview\n\nPara one.\n\n## Section A\n\nContent A.\n\n## Sources\n\nFake sources.\n\n## Related\n\nFake related.";
+      const id = await store.create({
+        type: "concept",
+        title: "Multi Heading Body",
+        body,
+        category: "test",
+        provenance: { agent: "tester" },
+      });
+      const record = await store.get(id);
+      assert.equal(record.body, body,
+        "body with multiple ## headings must round-trip exactly");
+    });
+
+    test("body field is NOT stored in frontmatter", async () => {
+      // Contract invariant: the body lives in the rendered note section,
+      // not as a YAML field.  Verifiable via the default adapter since the
+      // default store stores everything in memory (never writes body to YAML
+      // frontmatter), but the key guarantee is get() returns the correct body.
+      const body = "Should not appear as body: in frontmatter";
+      const id = await store.create({
+        type: "compiled",
+        title: "No Body In Frontmatter",
+        body,
+        category: "test",
+        provenance: { agent: "tester" },
+      });
+      const record = await store.get(id);
+      assert.equal(record.body, body, "body is preserved through get()");
+      // The record object itself should not have body as a frontmatter-derived
+      // field separate from the canonical body — just that get() works.
+      assert.ok(typeof record.body === "string", "body is a string");
+    });
+  });
 });

package/kits/knowledge/flows/compile.flow.json

@@ -13,12 +13,12 @@
       "expects": [
         {
           "id": "raw-ids-selected",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "One or more raw record IDs have been selected for compilation. Each ID must resolve to an existing raw record in the store.",
-          "claim": {
-            "type": "knowledge.compile.selection",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.compile.selection",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }
@@ -29,12 +29,12 @@
       "expects": [
         {
           "id": "compiled-record-provenance",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "The compiled record has been created with provenance.source_ids listing every consumed raw ID, and source links (kind='source') from the compiled record to each raw record — satisfying the store contract's compiled record requirements.",
-          "claim": {
-            "type": "knowledge.compile.provenance",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.compile.provenance",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }
@@ -45,12 +45,12 @@
       "expects": [
         {
           "id": "provenance-refs-resolve",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "Every provenance ref in the compiled record resolves to a retrievable raw record via the store's get() operation. The graph index reflects all source links.",
-          "claim": {
-            "type": "knowledge.compile.link-integrity",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.compile.link-integrity",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }

package/kits/knowledge/flows/consolidate.flow.json

@@ -14,12 +14,12 @@
       "expects": [
         {
           "id": "related-compiled-records-found",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "One or more compiled records linked to the snapshot's topic have been identified. The trigger fires when new compiled records matching the snapshot topic (by category or explicit topic tag) are present. The result is a cluster of compiled record IDs that form the consolidation input.",
-          "claim": {
-            "type": "knowledge.consolidate.trigger",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.consolidate.trigger",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }
@@ -30,12 +30,12 @@
       "expects": [
         {
           "id": "consolidation-proposal-recorded",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "A consolidation proposal has been recorded. The proposal carries: the updated snapshot body (latest decisions), source_ids referencing every compiled record that contributed, and supersedes_ids referencing any prior snapshot(s) for the same topic. The snapshot record is NOT mutated at this step — only a consolidation proposal record and proposes link are created.",
-          "claim": {
-            "type": "knowledge.consolidate.proposal",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.consolidate.proposal",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }
@@ -46,12 +46,12 @@
       "expects": [
         {
           "id": "proposal-carries-source-refs",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "The consolidation proposal evidence includes source_ids referencing every compiled record that contributed to the proposed snapshot body. Gate rejects if source_ids is empty or any referenced record does not exist. Also verifies that the proposer record has a 'proposes' link to the snapshot target.",
-          "claim": {
-            "type": "knowledge.consolidate.evidence",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.consolidate.evidence",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }
@@ -62,12 +62,12 @@
       "expects": [
         {
           "id": "consolidation-gate-decision",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "A gate decision (apply or reject) has been recorded. If applied: snapshot body is updated via the store update op with the proposed body; supersede op links the new snapshot to any prior snapshots for the same topic; all superseded snapshots remain queryable with provenance intact. If rejected: the snapshot body is byte-identical to its pre-proposal state.",
-          "claim": {
-            "type": "knowledge.consolidate.gate-decision",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.consolidate.gate-decision",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }

package/kits/knowledge/flows/ingest.flow.json

@@ -13,12 +13,12 @@
       "expects": [
         {
           "id": "raw-text-received",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "Raw text and metadata have been received and are non-empty.",
-          "claim": {
-            "type": "knowledge.ingest.capture",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.ingest.capture",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }
@@ -29,12 +29,12 @@
       "expects": [
         {
           "id": "classification-recorded",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "The raw record has been classified and stored with a non-empty category and type='raw', satisfying the store contract's create op provenance requirements.",
-          "claim": {
-            "type": "knowledge.ingest.classification",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.ingest.classification",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }
@@ -45,12 +45,12 @@
       "expects": [
         {
           "id": "routing-decision",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "A routing decision has been recorded for the classified raw record (e.g. queue for compile, discard, or hold).",
-          "claim": {
-            "type": "knowledge.ingest.routing",
-            "subject": "decision",
+          "bundle_claim": {
+            "claimType": "knowledge.ingest.routing",
+            "subjectType": "decision",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }

package/kits/knowledge/flows/retire.flow.json

@@ -14,12 +14,12 @@
       "expects": [
         {
           "id": "target-record-found",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "The record to be retired has been identified and is in a retirable status (active or implemented). The record ID and current status are surfaced for the proposal step.",
-          "claim": {
-            "type": "knowledge.retire.identify",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.retire.identify",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }
@@ -30,12 +30,12 @@
       "expects": [
         {
           "id": "retirement-proposal-recorded",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "A retirement proposal has been recorded. The proposal carries: the target status (implemented or retired), the retirement rationale, and — when targetStatus is 'implemented' — an implementedByRef pointing to the implementing artifact (commit SHA, PR URL, issue number, etc.). The record is NOT mutated at this step — only a retirement proposal record and proposes link are created.",
-          "claim": {
-            "type": "knowledge.retire.proposal",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.retire.proposal",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }
@@ -46,12 +46,12 @@
       "expects": [
         {
           "id": "retirement-evidence-valid",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "The retirement proposal evidence is valid: rationale is non-empty; implementedByRef is non-empty when targetStatus is 'implemented'; the target record exists and is in a state that allows the requested transition (active→implemented, active→retired, implemented→retired). Gate rejects if any required evidence field is missing or the transition is invalid.",
-          "claim": {
-            "type": "knowledge.retire.evidence",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.retire.evidence",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }
@@ -62,12 +62,12 @@
       "expects": [
         {
           "id": "retirement-gate-decision",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "A gate decision (apply or reject) has been recorded. If applied: the record status is updated to the target status via the store retire op; the retirement evidence (rationale, implementedByRef, supersededByRef) is appended to the mutation log; the record body, links, and provenance remain intact; the record is excluded from default working-set queries (listByType, listByCategory, similarity detection). If rejected: the record status is byte-identical to its pre-proposal state.",
-          "claim": {
-            "type": "knowledge.retire.gate-decision",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.retire.gate-decision",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }

package/kits/knowledge/flows/store-contract.flow.json

@@ -11,34 +11,34 @@
       "expects": [
         {
           "id": "contract-suite-passed",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "The contract test suite has passed 100% against the target adapter, verifying round-trip integrity, required-evidence enforcement, and graph-index consistency.",
-          "claim": {
-            "type": "knowledge.store-contract.suite-result",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.store-contract.suite-result",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         },
         {
           "id": "mutation-provenance-enforced",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "Every mutation operation (create, update, link, propose, apply, reject) rejects requests missing required provenance fields, as verified by the contract suite.",
-          "claim": {
-            "type": "knowledge.store-contract.provenance-enforcement",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.store-contract.provenance-enforcement",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         },
         {
           "id": "round-trip-integrity",
-          "kind": "surface.claim",
+          "kind": "trust.bundle",
           "required": true,
           "description": "Records round-trip raw to stored to queried with category and links intact, as verified by the contract suite.",
-          "claim": {
-            "type": "knowledge.store-contract.round-trip",
-            "subject": "artifact",
+          "bundle_claim": {
+            "claimType": "knowledge.store-contract.round-trip",
+            "subjectType": "artifact",
             "accepted_statuses": ["trusted", "accepted"]
           }
         }