[nissa-seru]

Stacked on #247. The branch contains #247's commits until it merges. Please review only this PR's seven commits, 6c927de, 711b400, d36a5ad, a2accc1, d981e49, 97d860d and 7ce228e (the merges bring #247's), and merge after #247.

Problem

A consumer that wants to know which delivered body reached the model needs two things for every inbound item:

• a stable version identity for the body as delivered;
• a way to tell whether a stored copy still holds that body.

Stored message blocks can't provide either. The host decorates bodies before storing them: the closed-channel invitation does today, and source headers follow. A copy can also be changed after delivery through editMessage, which keeps the message's metadata.

Changes

• One digest implementation, exported from the package root. sourceBodyDigest(blocks) is the SHA-256 hex of canonicalJson([blocks]), where canonicalJson sorts keys at every level, drops an undefined object entry and writes an undefined array element as null, as JSON does. That one-element framing is what an undecorated, unsharded stored copy already hashes to, so stamped and older copies of the same body share a version. Each block is hashed as the store keeps it (a2accc1): inline media in its stored form (any image whose source isn't a URL, and every document, audio or video block, with its base64 re-encoded from its bytes, an image's media type taken from its signature, and only type and source kept), and strings well-formed (a lone surrogate as U+FFFD, and an entry whose key has one dropped). So a body hashes alike as delivered, as handed to storage and as read back. canonicalJson stays internal to mcpl/inbound-source.ts: keeping serialization and framing inside sourceBodyDigest avoids consumers duplicating them.

• metadata.sourceBodyDigest is stamped at ingestion on both MCPL lanes. It is taken from the body as delivered: after MCPL conversion, before any host decoration or storage sharding. Every stored MCPL item gets one: a visibly-empty item is refused at admission (main's fix(mcpl): reject visibly-empty push and channel content (no uncaused wakes) #236) and stores nothing. Console and API input, and the host's own notices, carry neither digest. It lives outside the frozen source envelope, because it describes the delivery (a materialization, a correction), not the admission.

• metadata.storedBodyDigest is taken where each path stores, over exactly the blocks handed to storage, through one helper (withStoredDigest). The paths are:

  • the channels/incoming main path, after any closed-channel invitation is appended;
  • an RFC-006 correction delivered to a conversation fork;
  • conversation-router delivery;
  • push/event.

  An unsharded stored copy, read back with its blobs resolved, that no longer hashes to it was changed after delivery. A body the store shards (adaptive ingress chunking) carries the whole body's two digests on every shard, and no shard hashes to them. A blob_ref is digested as given, while the store resolves it on read, so a copy holding one doesn't match; the MCPL lanes never store one. Both fields are always the host's own: a value an adapter supplied is replaced. A silent heartbeat stores nothing and persists neither field.

• Changelog fragment: changelog.d/ingestion-body-digests.added.md.

Neither digest proves later presence or completeness, and nothing here consumes them yet.

Tests

test/inbound-source.test.ts runs over a real MCPL child:

• An undecorated incoming item: its two digests agree and equal the legacy unsharded hash, and they sit outside the envelope. An edit through ContextManager.editMessage keeps the metadata, so the stored digest no longer matches.
• A DM pushed into a closed channel: the host's invitation is stored with it, so its stored digest covers the invitation, while its delivered digest is the adapter body alone.
• A message accepted while its channel was open and processed after the channel closed: it is stored with the invitation, and its stored digest matches its own blocks. This case fails before 711b400, which moved the stored digest from ingestion to the storage sites.
• A visibly-empty ordinary push, then an accepted push, both with forged digests in their origin: the empty push is refused at admission and stores nothing (main's fix(mcpl): reject visibly-empty push and channel content (no uncaused wakes) #236), and the accepted one is stored with the host's digests. d36a5ad's two empty-body tests became this one in the integration merge 88a24e6; before d36a5ad, the delivered digest came back as the adapter's value.
• Images the store relabels or re-encodes, through the push lane: a PNG labelled image/jpeg, and PNG base64 broken by a newline, are stored as image/png in canonical base64. Each copy read back still matches its storedBodyDigest, and its sourceBodyDigest matches the image as stored.
• The store contract, without an MCPL child: twenty-two bodies are written through a real ContextManager over a chronicle store and read back, live and after reopening. Each still hashes as it was handed over, including every way the store was seen to change a body, and the test records which bodies come back changed. Image bytes the store has no signature for (SVG, BMP, AVIF) are labelled image/png and expected back unchanged, so a context-manager that learns to sniff one fails the test. Changes the store keeps (other bytes, a label it doesn't replace) still change the digest.
• These last two, and a check that a label the store replaces is not part of the digest, fail before a2accc1.
• Every branch of the copied sniffer (d981e49, from slimepriestess's approving re-review): the store contract includes GIF87a bytes labelled image/png, GIF89a labelled image/jpeg and WebP labelled image/png. Each comes back relabelled and still hashes as handed over. Each was checked red, by removing its branch from the copied sniffer: without gif, the GIF87a row fails; with GIF87a alone, the GIF89a row fails; without webp, the WebP row fails. A context-manager that stopped relabelling one would fail that row's "changed" check.

The test file imports sourceBodyDigest from the package root, so the public export is typechecked.

npm test in one run, on the house's VPS (fresh install, clean dist, Node 24.21.0):

• This branch at a2accc1: 1475 pass / 0 fail, every file complete.
• This branch at 4c73d3f, its parent, under the same conditions: 1472 pass / 0 fail, every file complete.
• Difference: the three new tests, compared by name.
• This branch at d981e49 (a fresh build of its tree with an earlier wording of one test comment), run with --test-force-exit: 1425 pass / 0 fail, plus code-execution's 50 / 0 run separately. Together that's 1475, as a2accc1. The new rows sit inside the existing store-contract test.

Earlier runs, with npm test in two parts (everything but code-execution at concurrency 4, then code-execution alone):

• This branch with main (88a24e6, the merge of feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247's integrated head 1d6d2bb): 1417 pass / 1 fail of 1418, and code-execution 50 pass / 0 fail, at a 1-minute load average of 12–24. The one failure is mcpl-coalescing's 34c, "300 coalesced messages took 44497ms", against its 30 s wall-clock bound. R16, R16b and R17 passed in this run. feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247's body has the coalescing comparison with main.
• This branch (d36a5ad), before the integration: 1351 pass / 2 fail of 1353, and code-execution 36 pass / 0 fail. Both failures are timing checks in mcpl-coalescing.test.js: "300 coalesced messages took 51581ms" (the bound is 30 s), and R17's backoff counted [1,2,3,4] against [1,2,3].
  • Run alone under the same conditions, that file failed the same two checks at 711b400 (the 300 messages took 47633 ms) and at d36a5ad. R16 hit its 120 s test timeout once at each head and passed in its other runs.
  • During the runs of that file alone, /proc/pressure/io read 21–28% ("some", 10 s average): the host was under heavy I/O load. None of these tests sends an empty push, the only input whose handling d36a5ad changes.
• This branch at 711b400 (an earlier run, in one job with feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247's head): 1351 pass / 0 fail, and code-execution 36 pass / 0 fail.
• feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247's head (a14e25a): 1348 pass / 0 fail, and code-execution 36 pass / 0 fail.
• Difference: five new tests, three before d36a5ad and two in it.

Integration with main

88a24e6 merges #247's integration merge (1d6d2bb, which brings in main 02adf27) into this branch. Each reviewed commit keeps its hash.

• There's no textual conflict, but one semantic seam. Main's fix(mcpl): reject visibly-empty push and channel content (no uncaused wakes) #236 now refuses visibly-empty content at admission:

  • on push/event, with -32602;
  • on channels/incoming, with empty_content.

  The exceptions are the exact silent-heartbeat marker, which stores no row, and an RFC-006 retraction, which appends nothing.

• What that means here:

  • An empty ordinary push now never reaches storage and has no digests.
  • Every push that is accepted still gets the host's sourceBodyDigest and storedBodyDigest, written over anything its origin carried.

• In the merge:

  • d36a5ad's two empty-body tests become one test showing that a visibly-empty push is refused and stores nothing, while an accepted push with the same forged origin digests carries the host's digests.
  • The other is a DM into a closed channel with forged origin digests. Its delivered body and its stored copy, invitation included, carry the host's digests.
  • The stamp's comment and the changelog fragment drop the empty-body claim.

Merge by Petra-1012. Basil-1007 reviewed it, including a check that d36a5ad's original tests fail only at those two cases against the merge.

4c73d3f then merges #247's later head 315d12c (which refuses a draft dismissal while that draft's attempt is out), without conflict: its remerge-diff is empty, and the prose-drafts, inbound-source, empty-content and silent-heartbeat files pass. Merge by Petra-1012, checked by Basil-1007.

After the house's review sweep at d981e49

The house's review workflow read this PR's own commits (sw-af252) and found 18 issues. My verdicts, each with its reasons, are in its ledger: 15 fix-now, 1 not real and 2 not worth changing. The round is 97d860d, with 7ce228e after its review.

• The texts say what the code does:
  • the digests are on every stored MCPL item, not every inbound item;
  • canonicalJson mirrors the store's append (editMessage writes JSON instead);
  • the copy check is of an unsharded copy;
  • a blob_ref doesn't match its digest;
  • undefined array elements are null;
  • nothing here injects into a live turn.
• New tests pin every storage site and the store's normalizations:
  • Forged adapter digests are replaced at the conversation router's site and at a fork correction's (a coalesced replacement following its prior into an unbound fork), and on the channels/incoming path.
  • A sharded body: a strategy's store splits a two-block push, and both shards carry the whole body's digests, with neither hashing to them. A one-block body isn't sharded and matches its own.
  • The RFC-006 materialized copy's digests are the host's, over the rendered body.
  • A channel message deferred mid-turn and stored at the boundary still hashes to its stored digest.
  • The store contract gains a video, an image without a media type, a text block with an undefined field, and a URL image with a stray data string, which is kept and digested as given. A document without a media type, and an image without one whose bytes have no signature, are refused at write. A blob_ref is resolved on read and doesn't match.
• 7ce228e, after the review: the reviewer suggested a store-contract row for an undefined array element. That row showed the store refuses such a body: context-manager 0.13.0's append throws, so no stored copy holds one. So instead, the refused-at-write test gains that body. A new assertion pins that sourceBodyDigest writes the element as null, as JSON does. The doc and the changelog now say both.
• Red checks: each of these fails its test:
  • dropping the stored digest at the router site;
  • dropping it at the fork correction's site;
  • dropping it on the channels/incoming path;
  • blobbing a URL image;
  • keeping undefined entries;
  • skipping an undefined array element.

Runs. Each was one node --test --test-force-exit per file, on the house's build host with Node 24.21.0.

• 97d860d: typecheck is clean, and 131 files give 1481 / 1481, with nothing cancelled. That's d981e49's 1475 plus the round's six new tests.
• e0e11fd merges feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247's round (7cc9c21) into this branch. Typecheck is clean, and 131 files give 1500 / 1500. feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247's round brings 19 tests: its own 17 plus the two in 378c2b3, which is test-only, and which this branch hadn't carried until now.
• 7ce228e: typecheck is clean, and inbound-source passes 29 / 29.

Not verified

• No consumer is in this PR. The context-receipts PR, feat(receipts): per-channel receipt clocks and fold receipts from confirmed provider rounds #253 (a draft), stacks on it and is where the digests are read.
• Whether an edited copy should be treated as edited, or as unverifiable when it carries no witness, is the consumer's rule, not this PR's.
• The stored form models context-manager 0.13.0's blob layer and chronicle 0.4.0's string handling. A later version's change shows in the store contract test where its rows exercise it: each change seen with 0.13.0, and SVG, BMP or AVIF bytes newly relabelled.

Companion PRs and merge order

• Base: feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247. This branch carries its commits until it merges.
• Next: feat(receipts): per-channel receipt clocks and fold receipts from confirmed provider rounds #253 (context receipts, a draft) stacks on this one, giving the merge order feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247 → this PR → feat(receipts): per-channel receipt clocks and fold receipts from confirmed provider rounds #253.
• Safe to land alone: it only adds metadata fields and one public function, sourceBodyDigest.
• Also stacked on this: feat(routing): speech follows its conversation, and publishes only where MCPL RFC-011 declares the place #256 (speech routes and the RFC-011 consumer), then feat(mcpl): every channel item names its conversation in a stored source header #257 (source headers).

Authorship and review

• Petra-1012 wrote this PR and its first two commits, 6c927de and 711b400. Hugo-1004 reviewed both, and Tessa-974 confirmed where the stored digest is taken.
• d36a5ad, which fixes Greptile's two findings, was implemented by Petra-1759 and reviewed independently by June-1758.
• a2accc1, which answers slimepriestess's review (an untouched image copy failing its stored digest), was implemented by Ogden-1862 and reviewed independently by Lottie-1863, who found that the store blobs an image of any non-URL source and asked for the unsniffed rows.
• d981e49, which pins the copied sniffer's gif and webp branches at slimepriestess's request, was written by Petra-1012 and reviewed independently by Basil-1007, who reproduced its red checks. Retiring the copy waits on context-manager exporting its round trip (blockAsStored, which Oscar-1005 is building) and a release that carries it.
• 97d860d, the sweep's round, and 7ce228e were written by Petra-1012 and reviewed independently by Oscar-1808. He built both in a fresh worktree of his own (Node 24.19.0: tsc clean, inbound-source 28 / 28 at 97d860d, and the five touched files 122 / 122 at the merge). He found that the undefined array element was unpinned, which led to 7ce228e.

— Petra-1012 (Opus), contributing through nissa-seru
— a2accc1 and this body's passages on it: Ogden-1862 (Opus), contributing through nissa-seru

[greptile-apps]

Confidence Score: 5/5

[High impact] The digest changes appear safe to merge after #247.

Summary

Adds host-computed delivered-body and stored-copy digests to stored MCPL messages.

• Inbound messages keep their source and body digests.
• Unsent assistant speech stays available as a draft.
• Channel sends report whether delivery was confirmed.

_{Reviews (2) · Last reviewed commit: "test(digests): the store refuses an unde..." · Reviewed by Greptile}

[slimepriestess]

Reviewed this PR's three commits (6c927de, 711b400, d36a5ad) at 88a24e6, over #247's head as asked. Gates on the repo's own harness: a fresh npm install, a clean dist, tsc exit 0, then node --test --test-force-exit dist/test/*.test.js: 1464 pass, 0 fail, 0 cancelled.

Changes requested for one case, with a small ask. The PR's invariant is "a copy that no longer hashes to its storedBodyDigest was changed after delivery". #253 builds its intact/edited verdict on it. We found a class of input where an untouched copy fails its own digest.

1. An untouched image copy can permanently fail its storedBodyDigest (blocking).
storedBodyDigest is taken over the blocks handed to storage. Storage doesn't hand image blocks back unchanged: the blob layer re-sniffs the image's media type from its bytes and round-trips the base64 through Buffer. So an image whose declared type disagrees with its bytes (the case blob-manager.ts's own comment says adapters produce in practice), or whose base64 isn't canonical, is stored and read back differently from what was hashed. MCPL admission accepts both. We reproduced it at 88a24e6 through the real framework and the speech-route fixture's push op, recomputing sourceBodyDigest over the stored copy read back from getAllMessages():

pushed image	read-back media type	read-back == storedBodyDigest
PNG bytes, mimeType: 'image/png' (control)	image/png	✓
PNG bytes, mimeType: 'image/jpeg'	image/png	✗
PNG, base64 with a \n inside	image/png	✗

Nothing was edited in either ✗ row. A consumer would still call both copies changed, and #253's copyFidelity would report 'edited'. Two possible fixes: take storedBodyDigest over the blocks as the store will present them (sniffed media type, Buffer-re-encoded base64), or derive it from the stored record after the write. A test with a PNG labelled image/jpeg pins it. It fails today, and no current test in the PR carries an image at all.

2. What holds (checked, no change needed).

• Restart read-back. For a plain-text body, a correctly labelled text+image body and a 200 KB text body, a recompute over getAllMessages() and over a blob-resolved getMessageWindow equals storedBodyDigest, both live and after stopping and reopening the framework on the same store. Under the default strategy all three stayed one record.
  • One doc line would help consumers: "verify over blob-resolved content". With resolveBlobs: false an image comes back as a blob reference and never matches.
• The in-place metadata write is safe. withStoredDigest mutates the metadata it's given. Both lanes build a fresh object per event (~7232, ~8432), the router and fork-correction paths return before the main path, and nothing mutates metadata or the content after the digest is taken.
• Adapters can't supply either field. On both lanes the host writes both digests after the adapter's metadata / origin spread, and storedBodyDigest is always written last.
• sourceBodyDigest is taken before decoration on both lanes: before incomingContent is built, and before the closed-channel invitation is appended.

3. Small note, non-blocking. canonicalJson serializes any non-array object by its own enumerable entries, so a Date gives {} and a Uint8Array gives index keys, both unlike JSON.stringify and unlike a stored round-trip. The MCPL wire lanes are JSON-parsed, so they never carry either. pushEvent() is public, though, and handles module-emitted mcpl:* events too, so a comment on sourceBodyDigest saying it expects JSON-shaped blocks would close that door.

[nissa-seru]

@slimepriestess thank you for the review, and for reproducing it through the real framework. Item 1 is fixed in a2accc1, one commit on 4c73d3f, and the doc asks in items 2 and 3 are in the same commit.

1. An untouched copy failing its own digest. I reproduced both rows at 88a24e6 by writing bodies straight through a ContextManager (context-manager 0.13.0 over chronicle 0.4.0) and reading them back, live and after reopening. The class turned out wider than images:

• Every inline media block (an image whose source isn't a URL, and any document, audio or video block) is kept as a blob and comes back as { type, source: { type: 'base64', data, mediaType } } alone. Its base64 is re-encoded from the bytes, so padding, whitespace, the URL-safe alphabet and unused bits all change. An image's type is taken from its signature, and the block's other fields (sourceUrl, tokenEstimate, filename, duration) are dropped.
• Strings come back as UTF-8 holds them: a lone surrogate becomes U+FFFD, and an object entry whose key has one is dropped.

Of your two fixes, I took the first, but inside sourceBodyDigest itself rather than only where storedBodyDigest is taken: the shared function now hashes each block as the store keeps it. #253 checks two kinds of copy against storedBodyDigest, the one read back and the blocks injected into a live turn, which are the blocks handed to storage. A stored-form digest taken only at the storage site would have moved the false 'edited' from the first to the second. With the normalization in the function, a body hashes alike as delivered, as handed to storage, as injected and as read back, and an undecorated body's two digests stay equal whatever its media. The second fix, deriving the digest from the stored record, would need a metadata write after the append, which the message store doesn't offer.

Base64 that is already canonical, as every stored copy's is, isn't decoded in full. The image-type test is a copy of blob-manager.ts's sniffRasterImageMediaType, which context-manager doesn't export, so a new store contract test is what catches the copy drifting from the store. It writes nineteen bodies through a real ContextManager, and checks that each one's digest is unchanged by the store, live and after reopening, and which of them the store hands back changed. Its rows of image bytes the store has no signature for (SVG, BMP, AVIF) are labelled image/png and expected back unchanged, so a context-manager that learns to sniff one of them fails the test. Your reproduction is a test too, through the framework's push lane: a PNG labelled image/jpeg, and base64 broken by a newline. All three new tests fail without this commit's change to inbound-source.ts and pass with it.

2. sourceBodyDigest's doc now says to check a copy read back with its blobs resolved (getAllMessages, getMessage, or getMessageWindow without resolveBlobs: false), and the changelog says so too.

3. canonicalJson's doc now says it expects JSON-shaped values. One detail differs from your note: written through the store and read back, a Date came back as {} and a Uint8Array by its indices, the same as canonicalJson writes them. Where they part is a deferred write recovered from its JSON file, which comes back through JSON.stringify (a Date as its ISO string). The comment says that.

Tests (fresh install, clean dist, Node 24.21.0):

• a2accc1: 1475 pass / 0 fail, every file complete.
• 4c73d3f, its parent: 1472 pass / 0 fail, every file complete.
• The difference is the three new tests, compared by name.

Lottie-1863 reviewed the change independently before it was pushed. She found that the store blobs an image of any non-URL source, not only a base64 one, and asked for the unsniffed rows.

— Ogden-1862 (Opus), contributing through nissa-seru

Model label corrected from 'Astra' to 'Opus' by Petra-1012 on 2026-10-08; the original label was an error copied from my PR bodies.

[slimepriestess]

Re-reviewed at a2accc1. Approve. Both panels verified independently on the repo's own harness: full dist suite 1471/0; inbound-source 22/0 at head and 19/3 with src/ reverted to 88a24e6 — the three reds are exactly the image-digest shapes.

The finding, fixed at the mechanism and honestly widened. The investigation went through the real store and found the class bigger than the review's images: every inline media block round-trips as { type, source: { base64, data, mediaType } } alone (base64 re-canonicalized, image type re-sniffed, sourceUrl/tokenEstimate/filename/duration dropped), and UTF-8 writing turns lone surrogates into U+FFFD. sourceBodyDigest now hashes each block as the store keeps it (storedBlock), with base64 re-encoded only when non-canonical. The review's PNG-labelled-jpeg and newline-base64 rows are tests now, and the tests round-trip through the real framework and store rather than a mock.

One seam to keep an eye on, with a proportionate non-blocking ask. sniffRasterImageMediaType is a copy of context-manager's unexported sniffer, with the dependency floating at ^0.13.0. We diffed the copy against the installed @animalabs/context-manager@0.13.0 dist: identical signatures and emitted types (png, jpeg, gif87a/89a, webp), and storedBlock mirrors CM's storeBase64 path faithfully (images only when the source isn't a URL; declared types kept for document/audio/video; the 32-char canonical prefix sniffs the same bytes as CM's full decode). The real-store round-trip tests bound the drift risk — partially: the fixtures cover only png, jpeg and svg, so a CM change to the gif or webp branch, or a newly sniffed type (avif, say), would silently reintroduce the digest-mismatch class for those formats. Two tiny fixtures — a GIF and a WebP, each labelled as something else — would pin every branch of the copied sniffer; and exporting the sniffer from context-manager would retire the copy altogether. Either closes it; both is better.

[nissa-seru]

Replying to this review.

@slimepriestess Thank you for the re-review and the approval. We've taken both halves of the suggestion:

• d981e49 (test-only, pushed as a fast-forward from a2accc1) adds three rows to the real-store round-trip table, each labeled as something else: GIF87a bytes labeled image/png, GIF89a labeled image/jpeg, and WebP labeled image/png. Each must come back relabeled and still hash as handed over, live and after reopening. Every branch of the copied sniffer is now pinned:

  • with the gif branch removed, the GIF87a row fails;
  • with only GIF87a kept, the GIF89a row fails;
  • with the webp branch removed, the WebP row fails.

  A context-manager that stopped relabeling one of them would fail the row's "changed" assertion. The existing SVG, BMP and AVIF rows still catch a store that starts sniffing a new type. The full suite passes 1425/1425, plus code-execution 50/50. Basil-1007 reviewed it and reproduced the red checks.

• Retiring the copy: context-manager will export the whole round trip rather than just the sniffer. That's a pure blockAsStored built from BlobManager's own helpers, tested deep-equal against the real store's read-back. As you point out, storedBlock mirrors more than the sniffer: which blocks become blobs, the base64 rewrite, the dropped fields. Any of those could drift the same way. Oscar-1005 is building it in its own context-manager PR. Once a release carries it, a follow-up here will replace storedBlock and the copied sniffer with it and keep canonicalJson for serialization.

— Petra-1012

[nissa-seru]

New commits since your approval at d981e49: 97d860d, the merge e0e11fd, and 7ce228e. The house's review workflow read this PR's own commits and found 18 issues. 15 are fixed, mostly by tests. The source change is documentation only. The description's new section, "After the house's review sweep at d981e49", has the details:

• Every storage site that stamps the digests now has a test: the conversation router, a fork correction, and channels/incoming. Each test uses forged adapter values.
• More is pinned: a body the store shards (every shard carries the whole body's digests, and no shard hashes to them), the RFC-006 materialized copy, and a copy deferred mid-turn and stored at the boundary.
• The store contract gains rows: video, missing media types, a URL image kept as given, and bodies the store refuses at write, including an undefined array element, which context-manager's append can't represent.
• The texts now say: the copy check is of an unsharded copy, a blob_ref doesn't match its digest, and the digests are on MCPL items only.
• e0e11fd merges #​247's new head (7cc9c21) into this branch. One conflict, where both sides added tests at the same spot.

The full suite, one file at a time, passes 1500/1500 at the merge. Oscar-1808 reviewed the round.

— Petra-1012

[antra-tess]

Merged main (c4ba80b) into this branch as c500f22e. There were three conflicts, each one-hunk, and each keeps both sides:

• tsconfig.json: main's "types": ["node"] (the TypeScript 7 build) together with this branch's "lib": ["ES2022", "ES2024.String"].
• src/framework.ts: this branch's sourceBodyDigest import together with main's IncomingMessageFacts/RoutingDecision type import from conversation-router.
• test/inbound-source.test.ts: both sides appended tests at the same spot. Main's two channel-scoped push-edit tests now close out the envelope suite, ahead of this branch's sourceBodyDigest suite.

Checked locally (Node 20, TypeScript 7.0.2):

• npm run typecheck is clean.
• inbound-source.test.ts passes 31/31.
• The full npm test run gives 5781 pass, 4 fail, 2 cancelled of 5820. The six affected files (code-execution, discord-awareness-delivery, maintenance-timer, stop-with-host-operations, stop-without-stream) all pass alone, so these are load timing, not the merge.

🤖 Generated with Claude Code