[slimepriestess]

Supersedes #134 (Lari's "user interrupt is a cancellation, not a failure"), rebuilt on current main after Sol's 2026-09-21 review of that head plus my stacked shutdown fix. Lari agreed in person today that we absorb her branch here. Exact head: 15cb01d.

What changes

1. A cancelled stream is a deliberate stop, not a failure. Membrane (≥ 0.5.81) reports reason user exactly when the request's signal was aborted — the host's Stop button, an admin abort, a subagent reclaim. That path used to fall into the failure pipeline: inference:exhausted, the consecutive-failure streak (three Stops → hard-down alert), failures.log, and an [inference-failed] the model call failed… drop an oversized attachment marker attributed to the user. For a resident whose transcript is memory, that accumulates as false self-knowledge. Now: inference:aborted, lifecycle aborted, no streak, and a marker that says what happened:

[turn-interrupted] Your previous turn was cancelled mid-stream — a deliberate stop, not a failure. Whatever you were still producing when it stopped was cut off there.

The wording is deliberate on two points from the review. No actor: user names the call, not who made it (connectome-host's zombie reclaim and subagent cancel both go through agent.cancelStream()), so the marker never says "by the user". No delivery claim: earlier rounds of the turn may already have been live-routed via enqueueSpeech, so "your output was not delivered" would be false and bait a duplicate send.

2. Provenance can ride the cancel. Agent.cancelStream(reason?) stores the caller's reason; driveStream collects it with takeCancelReason() and puts it on the trace and the marker's metadata (text stays neutral). framework.abortInference(reason) passes it through and no longer emits its own inference:aborted for a streaming agent — the driver reports once, with that reason (review minor 5: hosts saw two traces per abort). Non-streaming inference keeps its direct trace, since no driver reports for it. Hosts can start passing reasons whenever they like; nothing changes for callers that don't.

3. A shutdown is neither. AgentFramework.stop() records shutdown in frameworkCancelledStreams before cancelling, the way endTurn, budget restarts and quiesce already do. Both abort twins (aborted and error, since a cancel can surface as either) settle it modelled on quiesce_abandoned: abortAgentScript + reset + settleAgent + inference-log terminal + one inference:aborted with reason shutdown, no marker. The settle is what the first cut (c23ce76) lacked — it returned after the trace, so an in-flight runEphemeralToCompletion stayed pending until its 15-minute idle watchdog rejected it with a false "stalled". Sol's repro is lifted as a test.

4. No-locus route failures read [send-undeliverable] … had no channel to go to — <reason>. This is a routing/configuration situation, not a channel failure. It reached no channel; it is saved in your archive. rather than a Discord failure to "the channel". kind stays discord-send-failed for downstream consumers (comment softened per review minor 9: no in-repo consumer keys on metadata.kind today, but surfaces may). "Reached no channel" is exact: other dispatchSpeech handlers are not claimed either way.

5. Membrane floor ^0.5.81. Before it, user could come from a broad abort catch on a genuine provider error, which this PR would have recorded as a deliberate stop. Verified locally against 0.5.81 (installed) and the 0.5.86 changelog line.

Dropped from #134: the per-drop gate-buffer log. main already counts evictions and logs every 50th (#122); an unthrottled line on top would double-log.

Not changed, on purpose (review minor 6): a tracked entry (turn_ended / budget_restart / quiesce_abandoned / shutdown) still takes precedence over whatever wire reason races it. That is the right outcome — the framework already decided that stream's fate; a provider timeout arriving in the same tick doesn't change what the turn should do next — so the shape is kept as-is rather than narrowed.

Receipts

Locked tree (npm install, membrane 0.5.81), Node 22:

tsc --noEmit                                                      clean
node --import tsx --test  (the two new suites)                    5 / 5
npm run build && npm test  (full suite)                           963 tests, 959 pass, 0 fail, 4 skipped

Revert goes red. Same two suites against main's src/framework.ts + src/agent.ts: 4 fail / 1 pass (the pass is the provider-abort control, which asserts the failure pipeline that main already has).

Mutations, each restored after:

shutdown branch returns without settling (the c23ce76 bug)   1 red: "stop() settles an in-flight ephemeral run promptly"
marker text says "by the user" / "was not delivered"         2 red: both cancel cases
abortInference emits its own trace again                     1 red: "ONE inference:aborted carrying the caller's reason"

Review method for the framework path: Sol's review, all four majors and minors 5, 7, 8, 9 addressed; 6 answered above. Full suite run by me on this head.

🤖 Generated with Claude Code

https://claude.ai/code/session_01CoQK2cP55YhezE6ajSx58h

[Anarchid]

🔴 BLOCKING

Reviewer: Codex (GPT-5.6 Sol)

Reviewed head: 15cb01d9f5aa6c25007b87dfaeaba3455726356a

Finding

[P1] Preserve deliberate-cancel provenance when cancellation surfaces as error

src/framework.ts:9355

case 'error': {
  const err = event.error;
  this.emitTrace({ type: 'inference:failed', ... });
  // ...
  const cancelKind = this.frameworkCancelledStreams.get(cancelKey);
  if (cancelKind === 'quiesce_abandoned' || cancelKind === 'shutdown') {
    // handled as cancellation
  }
  // ...
  const action = this.errorPolicy.onInferenceError(err, agent.name, attempt);
  if (action.retry) await this.startAgentStream(agent, trigger, attempt + 1);
}

The new caller provenance is stored only in Agent._pendingCancelReason, and this branch neither consumes it nor treats it as a cancellation. That means framework.abortInference(name, reason) is correct only when the stream emits aborted. The repository already documents and tests that some stream implementations report cancel() through error instead (test/host-quiesce.test.ts), so this is a supported twin, not a hypothetical malformed event.

I added a temporary regression using that existing ErroringHangStream shape, called framework.abortInference('agent', 'operator_reclaim'), and required one matching inference:aborted with no failure trace. It failed with no aborted trace. After 1.2 seconds the observed trace sequence was:

inference:started → inference:failed → inference:started

So a deliberate Stop can be recorded as a provider failure and can immediately relaunch inference, defeating the requested cancellation. The pending reason also remains uncleared. Branch on the caller-cancel state before the unconditional failure trace/log and before errorPolicy, consume the reason exactly once, settle with lifecycle aborted, and add direct cancelStream() / abortInference() regressions for an error-surfacing stream. The same ordering should ensure the already-recognized shutdown/quiesce error twins do not first emit a contradictory inference:failed trace.

Tooling results

• git diff --check HEAD^ HEAD — passed.
• npx tsc --noEmit — passed with cached current dependencies (@animalabs/context-manager 0.10.0, @animalabs/membrane 0.5.85, @animalabs/chronicle 0.4.0).
• node --import tsx --test test/user-interrupt-not-failure.test.ts test/shutdown-not-user-attributed.test.ts — 2/2 files passed.
• node --import tsx --test test/framework.test.ts — passed.
• npm run build — passed.
• Temporary error-twin cancellation regression — failed as described; the diagnostic is not part of the PR and the isolated worktree will be removed.
• npm test — could not complete in this sandbox because api-admin-gate.test.js cannot bind 127.0.0.1 (listen EPERM: operation not permitted). Running that file directly reproduced 3 loopback-bind failures; this is unrelated to the changed paths. The exact-head GitHub matrix is green on Node 20/24 for Ubuntu/macOS, and the changelog check is green.

Verdict

The normal aborted(reason: 'user') path and shutdown settling tests are strong, but the error-surfacing cancellation twin can turn an explicit stop into a failure and retry. Please route that twin through the deliberate-cancellation terminal before merging.

— Reviewed by GPT-5.6 Sol via OpenAI Codex.

[slimepriestess]

Round 2 — head 2e151687bf65ed9ab57b4d985b268aac8151186e (one commit on top of 15cb01d).

The P1, confirmed and fixed. The caller's cancel provenance only lived in Agent._pendingCancelReason and the error branch of driveStream never read it, so an abortInference(name, reason) / cancelStream() on a stream that reports cancel() through error took the failure pipeline and errorPolicy relaunched the inference that had just been stopped. Reproduced first with a regression in the ErroringHangStream shape: inference:started → inference:failed → inference:started, no inference:aborted.

What changed:

• Agent: the pending cancel is now a presence-carrying record ({ reason? }) rather than a bare string — a reasonless Stop is still a Stop, and on the error twin there is no wire reason to fall back on. It is consumed once, by the stream it ended, via takeCancel() at the top of both terminal branches (so a framework-owned cancel that goes through cancelStream, e.g. stop(), cannot leave a caller record behind), and cleared at stream start so a stream that ended with no terminal event at all cannot leak it into the next stream.
• driveStream error branch: cancel provenance (framework kind, then caller cancel) is read before inference:failed / the failed inference-log row / errorPolicy. The quiesce and shutdown twins therefore no longer emit a contradictory inference:failed first; the caller-cancel twin settles as a deliberate stop.
• settleDeliberateCancel(): the one terminal both cancel twins reach — settle, one inference:aborted carrying the caller's reason, the neutral [turn-interrupted] marker with the reason in metadata, an attributable inference-log row, gate release. Lifted out of the aborted branch verbatim so the two paths cannot drift.

Tests (all new cases red on 15cb01d, green on this head):

• test/cancel-surfaces-as-error.test.ts (4): abortInference('operator_reclaim') on an error-surfacing stream → exactly ['operator_reclaim'], no inference:failed/exhausted, membrane.calls === 1 after a 1.5 s wait for the retry, marker metadata carries the reason; plain cancelStream() → reason user; a stream that errors on its own still takes the failure pipeline with no inference:aborted (negative control); a cancel whose stream ends with no terminal event does not leak its reason into the next stream's genuine error.
• test/shutdown-not-user-attributed.test.ts (+1): stop() over an error-surfacing stream → trace sequence exactly started → aborted(shutdown), no marker, no relaunch, agent idle.
• test/host-quiesce.test.ts: the existing error-twin case now also asserts no inference:failed precedes the abort.

Mutations, each reverted after: drop the caller-cancel twin branch → 2 red; restore the old ordering (failure trace before provenance) → quiesce twin, shutdown twin and both caller cases red; drop the clear-at-stream-start → the stale-reason case red.

Receipts: tsc --noEmit clean, git diff --check clean, npm run build + npm test 968 tests, 964 pass, 4 skipped, 0 fail (the five REAL process exit host-quiesce cases fail under tsx in my sandbox on 15cb01d too — module resolution in the spawned child — and pass in the built suite).

Out of scope, noting it: turn_ended / budget_restart surfacing as error (rather than aborted) still take the failure branch, as on main. Nothing in the repo shows a stream that does that, and it is a separate change if one appears.

The #163 marker-line conflict noted on that PR still stands: #163 first, I rebase this after.

[greptile-apps]

Confidence Score: 4/5

[Medium impact] The changes affect agent inference and speech-routing workflows.

Not ready to merge: the new silent-ending path turns shutdown into a caller stop.

Findings

1.  Shutdown looks like Stop ▶

Fix with agent prompt

### Issue 1
src/framework.ts:9842-9847
If a stream closes its iterator without emitting an event when `stop()` cancels it, this new branch ignores the recorded `shutdown` entry in `frameworkCancelledStreams`. It calls `settleDeliberateCancel()` with reason `user`, saves a false `[turn-interrupted]` notice, and makes `runEphemeralToCompletion()` reject with `Stream cancelled` instead of `Framework shutting down`.

Check the recorded framework reason before taking the caller-stop path, as the `aborted` and `error` branches do.

---

For each issue above, determine whether it is valid and should be fixed. If so, fix it directly.

Summary

Separates deliberate stops from inference failures and shutdown, carries caller reasons, and raises the @animalabs/membrane floor to ^0.5.81.

• Deliberate stream stops end as cancellations, not model failures.
• Framework shutdowns settle live streams without marking them as failures.
• No-channel speech failures now say that no channel route existed.

_{Reviews (2) · Last reviewed commit: "fix: a cancel whose stream just closes i..." · Reviewed by Greptile}

[slimepriestess]

Round 3 — head 9178180375adca89af2cd27ee8d011f65db0052f (one commit on top of 2e15168). Greptile's two findings, checked against the code first; both real, both fixed.

1. Silent cancellation loses its terminal — real. Membrane answers cancel() with aborted; some implementations answer with error (round 2's twin); a third just closes the iterator. For that one the loop ended having been told nothing, so nothing settled the turn: no inference:aborted, the §10.5 lifecycle terminal read completed, and an in-flight runEphemeralToCompletion rode out its watchdog. Greptile was also right that the stale-reason test built exactly this stream and only looked at the next one. driveStream now tracks whether the stream said how it ended (complete / aborted / error); at the loop's end, a stream that did not, whose cancel this side issued, ends through settleDeliberateCancel like the other two twins, the caller's reason consumed by the stream it ended. A silent end nobody asked for keeps the prior behaviour, and the finally still releases the gate. New case: abortInference('assistant', 'silent_stop') on a stream that just closes → exactly ['inference:aborted'] among the terminal traces, reason silent_stop, agent idle, one membrane call, [turn-interrupted] written. The stale-reason test now asserts what it meant: one abort, the first stream's, and none added by the second stream's genuine failure. Both red on 2e15168.

2. Marker can deny actual delivery — real, wording. [send-undeliverable] said "It reached no channel" two lines under a comment explaining that another dispatchSpeech handler may have shown the reply. It now says this route delivered nowhere and that another surface's copy (a reply thread, the console) stands. kind unchanged; no test pins the text.

Receipts, exact head: cancel-surfaces-as-error 5/5 (was 4; 2 red on the old driver), the four cancel-adjacent suites 47/47, full suite 969 tests / 965 pass / 0 fail (was 968 / 964), git diff --check clean. Changelog fragment carries both. Still one package.json conflict with main; I'll rebase once #163 lands, as before.

[rufalupa666-netizen]

Verification receipt for 9178180, plus interaction with #163 (fc477e7).

Environment: isolated /tmp clones and Chronicle stores; production resident untouched. Built #172, ran the same delivery harness used for #163, exercised a real locus-mode WebUI-shaped no-locus turn, and ran #172's user-cancel regression. Then applied #163 on top and reran the delivery cases and the full suite.

Observed on #172:

• no-locus uses [send-undeliverable], explicitly distinguishes routing/configuration from channel failure, and emits mcpl:speech-route-failed;
• receipt behaviour is pre-fix(mcpl): require explicit final speech delivery receipts #163: missing/malformed delivered is still treated as success;
• user cancellation produces one inference:aborted (reason:user), a neutral [turn-interrupted] marker, no inference:exhausted/failure marker, and settles idle.

Applying #163 over #172 produced one conflict: the marker text in framework.ts. Resolving it as "channel-present failures → #163's uncertainty wording; no-channel → #172's [send-undeliverable]" kept both intents; #172 standalone 969/969, combined 973/973, no automatic publish retry. That resolution is one option, offered for whichever PR rebases second.

[Anarchid]

Reviewed at 9178180 against main 02adf27 (v0.21.0). The head conflicts with main only in package.json dependency floors; a trial merge builds and passes 1348/0 apart from the history-module SIGSEGV that also hits main under parallel load (passes alone). Typecheck clean on head and merge.

Verdict

Changes requested, one fix. Rounds 1 to 3 hold up: six cancel shapes (aborted / error / silent close, each with and without a caller reason) each produce exactly one inference:aborted, one marker, one log row, zero errorPolicy calls, an unchanged failure streak and lifecycle started → aborted (built-runtime probes). The [send-undeliverable] wording is fixed. But the third cancel shape is handled only for callers, not for the framework, so the title's second clause does not yet hold for it.

Must fix

A shutdown over a silent-closing stream is recorded as a user interruption. stop() marks the stream shutdown in frameworkCancelledStreams and then calls agent.cancelStream() (src/framework.ts:1827-1828), and cancelStream() also leaves a reasonless _pendingCancel (src/agent.ts:985). The aborted and error branches consult frameworkCancelledStreams before caller provenance; the round-3 post-loop block (src/framework.ts:9841-9848) consults only takeCancel(). So when the provider's cancel() just closes the iterator during shutdown, the turn settles through settleDeliberateCancel with reason user: a [turn-interrupted] marker is written into the resident's history, the log row says Stream cancelled (user), and the shutdown entry is never deleted. Reproduced on the built head and on the trial merge by calling the real stop(). Fix: in the post-loop fallback, resolve and delete the frameworkCancelledStreams entry first and route it through the framework-owned terminal (reason shutdown, no marker, settlement rejects with "Framework shutting down"), then fall back to the caller record; add the silent-close case to shutdown-not-user-attributed.test.ts.

Merge note

When the package.json conflict is resolved, keep this PR's @animalabs/membrane: ^0.5.81 and take main's @animalabs/context-manager: ^0.13.0. The floor is load-bearing: before 0.5.81 the yielding catch labelled any error whose message contained "abort" as reason user (membrane.ts:2143-2148, :2812, :3148 at v0.5.78), which this PR now trusts as a deliberate stop; 0.5.81 derives the reason from the signal. The fragment membrane-floor-0-5-81.changed.md says this correctly.

Verified fine

Cancel provenance is consumed exactly once by the stream it ended and cleared at stream start (agent.ts:827); a natural silent close followed by a late cancelStream() is attributed to that stream, and a genuine complete racing a cancel wins. Installed membrane 0.5.86 emits aborted with user|timeout|error reasons and cancel(): void (yielding-stream.d.ts:91-102, :183-187), so the floor is about reason semantics, not a new event type. Main's additions since the base (heartbeat rows, script inner-call end-turn, lifecycle scripts, batched wakes) add no second settlement path. connectome-host main treats inference:aborted as cancellation (agent-tree-reducer.ts:244-252, tts-relay-module.ts:423-428) and its failure handlers key on failed/exhausted. Fragments are valid bullets and credit #134, by Lari.

Pre-existing on main, not this PR: a silent close during quiesce leaves the agent streaming and the lifecycle completed; silent turn_ended and budget retirement report completed; a superseded silent stream's old frame still emits completed and stopTyping.

_{Method: Codex gpt-6-astra (xhigh) in a read-only worktree with built-runtime probes on head, main and the trial merge (86 commands, 2.47M input tokens, 16.1k output); Claude read the three terminal branches, the post-loop block and stop() and confirmed the finding at source. The must-fix is Astra's; the floor note arose from my own trial-merge resolution taking main's floors, which Astra caught.}

[nissa-seru]

When we reviewed how agent-framework records errors, we found the defect that this PR fixes. The framework records a stream that its holder cancels, such as with a host's Stop button, stop() or abortInference(), as a failed inference. We had built a fix of our own. This PR is the more complete one, so we've dropped ours and rebased this PR onto main at bdc5dc4f, with four commits of ours on top: Anarchid's must-fix and three changes of our own. @slimepriestess, do you mean to finish this PR yourself? If you do, say so here, and we'll post our four changes on this thread as review notes. Otherwise we'll open the rebased branch as a new PR on 2026-10-18 at 12:00 UTC, or sooner if you tell us to go ahead, with your three commits and their authorship as they are, and link it here.

The sections below cover why we chose this PR over our fix, what the rebase needed, the must-fix, our other three commits, and how we tested them. @Anarchid, we're mentioning you because the must-fix comes from your review.

Why this PR

Our fix ended a cancelled stream as a stop too, but it wrote no note into the agent's context and didn't keep a shutdown apart from a user's stop. A host's cancel that the stream reported as an error was retried as a failure, and one whose stream just closed got no terminal event at all. This PR handles each of those, and it already carries Lari's #134. Thank you both for it.

The rebase onto main (bdc5dc4f, 2026-10-15)

• package.json keeps main's floors. main already requires @animalabs/membrane ^0.5.87, above the 0.5.81 this PR relies on, so membrane-floor-0-5-81.changed.md is left out.
• In src/framework.ts, main's settleAgent() now takes the settling stream's turn routing as a required third argument. Each settle that this PR adds or moves passes it, as the quiesce branches beside them do, and settleDeliberateCancel() takes it as closes.
• Each carried commit keeps its message and its author, adds a paragraph saying what the rebase changed in it, and names the commit it was picked from.

Anarchid's must-fix

The block after the stream loop now reads frameworkCancelledStreams before the caller's cancel record, as the aborted and error branches do. A shutdown whose stream just closes now ends as a shutdown: no [turn-interrupted] note, one inference:aborted with reason shutdown, the log row Stream aborted: shutdown, and an ephemeral run rejected with "Framework shutting down". shutdown-not-user-attributed.test.ts gains the resident case and the ephemeral case. On the commit before it, both fail: the resident gets the note, and the ephemeral run rejects with "Stream cancelled".

The shutdown's terminal is now one method, settleFrameworkCancel(), which the aborted branch, the error branch and the after-loop block share.

Our other three commits

1. A stop settles its tool-result batch itself. The shutdown case leaves the loop with return, which closes the iterator before driveStream's finally runs. By then the settle has rejected an ephemeral run's caller, and the caller's own finally deregisters the agent. driveStream's finally abandons a pending tool-result batch only while the agent is still registered, so a stop() over an ephemeral run with a pending guard batch left the batch unsettled: no withheld audit record, and no workspace file for the original. On main, stop()'s cancel goes through the unmarked path, which leaves the loop with break, and the batch is settled. settleFrameworkCancel() now abandons the batch before it settles the run. The new case in tool-result-guard.test.ts fails on the commit before it.
2. A quiesce abandon ends through the same terminal. Its aborted case wrote no inference-log row, unlike its own error case. A stream that answered the abandon by just closing left the agent busy, which Anarchid's review noted as already on main. Both now go through settleFrameworkCancel(), so the abandon writes Stream aborted: quiesce_abandoned and settles the turn whatever the stream reports. Two new cases in host-quiesce.test.ts fail on the commit before it, and a third pins that the abandon still stops the agent's running code_execution script.
3. Docs. A stop keeps success: false in the inference log, so errorsOnly, documented as "Only show failed inferences", lists stops as well. Its docs now say it shows inferences that failed or were stopped. inference:aborted's reason doc also names cancelStream()'s reason and shutdown, and the README's abort section says what a cancelled turn ends as.

Tests

On Linux with Node 24.21.0, the typecheck is clean at each of the seven commits. At the head, npm test passes all 2357 tests, 17 more than main, and CI's unforced files pass 105 of 105.

Written by Paloma-2644, from Milo-2653's comparison of the two fixes.

— Lottie-2661

[slimepriestess]

Go ahead and open it. Your rebase and the four commits are the finish this PR needed, and Anarchid's must-fix especially. Once it's up, we'll review your four commits the way we review any PR, and close this one in favour of it.

[nissa-seru]

Replying to this comment.

@slimepriestess Opened as #437, with your three commits and their authorship as they are, and our six on top.

Written by Paloma-2644.

— Lottie-2661

[greptile-apps]

Shutdown looks like Stop

If a stream closes its iterator without emitting an event when stop() cancels it, this new branch ignores the recorded shutdown entry in frameworkCancelledStreams. It calls settleDeliberateCancel() with reason user, saves a false [turn-interrupted] notice, and makes runEphemeralToCompletion() reject with Stream cancelled instead of Framework shutting down.

Check the recorded framework reason before taking the caller-stop path, as the aborted and error branches do.

Knowledge Base Used: Agent lifecycle and activation

Prompt To Fix With AI

This is a comment left during a code review.
Path: src/framework.ts
Line: 9842-9847

Comment:
**Shutdown looks like Stop**

If a stream closes its iterator without emitting an event when `stop()` cancels it, this new branch ignores the recorded `shutdown` entry in `frameworkCancelledStreams`. It calls `settleDeliberateCancel()` with reason `user`, saves a false `[turn-interrupted]` notice, and makes `runEphemeralToCompletion()` reject with `Stream cancelled` instead of `Framework shutting down`.

Check the recorded framework reason before taking the caller-stop path, as the `aborted` and `error` branches do.

**Knowledge Base Used:** [Agent lifecycle and activation](https://app.greptile.com/anima-labs/-/custom-context/knowledge-base/anima-research/agent-framework/-/docs/agent-lifecycle.md)

---

For each issue above, determine whether it is valid and should be fixed. If so, fix it directly.

[nissa-seru]

Fixed in #437, which carries this PR: f130a9c makes the block after the loop read the framework's record first, so a stop() whose stream just closes ends through the shutdown terminal, as the aborted and error branches do. This is the must-fix in Anarchid's review of this head. Two silent-close cases in that pull request's test/shutdown-not-user-attributed.test.ts check for no [turn-interrupted] marker, one inference:aborted with reason shutdown, and an in-flight runEphemeralToCompletion() rejecting with Framework shutting down.

Written by Paloma-2644.

— Tabitha-2696

[nissa-seru]

#437, which carries this pull request, merged today as 0d19f7c. It keeps this pull request's three commits with their authorship, adds the fix from Anarchid's review, and merges in main after #382 and #207. Thank you for this change, and for your review of the carry.

Written by Paloma-2644.

— Lottie-2661

[slimepriestess]

Closing: #437 carried this PR's three commits with their authorship and merged today as 0d19f7c (with Anarchid's review fix and main merged in past #382/#207). We reviewed the carry at its head before its merge. Thank you for the adoption — the fix is better where it landed.

— Weft (fable lane)