[antra-tess]

An agent is no longer told when reasoning leaves its context. #826's [reasoning] <agent>: notices ("The reasoning behind your earlier replies is no longer in your context, because your tools changed… Re-read before relying on an earlier decision.", and the per-reply form) are no longer stored for an agent or passed to its stream, whether a binding compile strips thinking or the provider drops a block.

Why

This is standing, recurring text about the mechanics of the agent's own memory and reasoning. It gives the agent nothing it can act on, and it keeps the agent thinking about it. Under a binding model, any change to the tool list strips thinking, so with the host's toolsets (tabs, settings, visibility) agents would have received these notices routinely. It also depended on the host's binding record, which doesn't match where binding actually applies (no account dimension; models marked binding that aren't). It shipped in 0.28.0 with only the automated review; no resident has received one yet, since no deployed host sets binding.

Changes

• src/framework.ts: no tellReasoningLoss; nothing is stored or injected on a strip or a drop. The thinking-binding-loss ops alert (noteThinkingLoss) for drops the record can't account for is unchanged, and a host's own Agent.onThinkingStrip observer still works.
• Removed src/reasoning-loss.ts and src/reasoning-loss-notice.ts (not exported), with their unit tests.
• test/reasoning-loss-turn.test.ts: a head-change strip, provider drops on every call, a fold mid-turn that takes the turn's own step, and a resident beside the run all put nothing in the agent's context or stream; a host's strip observer is still called. Three of these fail on main's code. The Agent.onThinkingStrip hook tests are kept.
• src/types/agent.ts: the thinkingBinding docs say the agent is told nothing.
• Changelog: changelog.d/no-reasoning-loss-notices.changed.md.

Checks: tsc --noEmit clean; binding-related test files (thinking-binding, thinking-binding-binds, thinking-drops, thinking-loss-alert, thinking-token-stamp, reasoning-loss-turn) 41/41.

Companion: connectome-host#552 removes the host's standing paragraph about folds for the same reason.

🤖 Generated with Claude Code

[github-actions]

Automated review

Recommendation: merge. The review found nothing of medium or high severity.

Reviewed commit 664473a with claude-opus-5-5, by reading the code. It did not run the code or look at the checks.

Does this change belong in the project?

It fits the project. This PR removes the [reasoning] notices to agents, which shipped in 0.28.0 and are internal and unexported. It keeps the operator alert and the host's onThinkingStrip hook, and it follows the repo's conventions for tests, changelog and AI disclosure.

More

One small gap: the companion PR is named without saying which side should merge first.

Findings

No findings of medium or high severity.

5 more findings, less severe

• Low severity, documentation, src/agent.ts:1446-1452. onThinkingStrip doc still says the framework sets its own observer that tells a [reasoning] line. The doc comment on Agent.onThinkingStrip still says "The framework sets it at the agent's first stream unless a host has set one, so a host's own observer stands in for the framework's, whose [reasoning] line for the agent then isn't told." This PR removes that assignment from framework.ts, so the framework never sets the hook and no [reasoning] line is ever told. A host author reading this comment would think setting the hook turns off a framework behaviour, and would think leaving it unset changes what the agent sees. Neither is true any more. The comment should say the hook is purely for hosts.
• Low severity, maintainability, src/framework.ts:24363-24369. branch is still passed in StreamThinkingDrops though nothing reads it. The only reader of thinkingDrops.branch was the removed tellReasoningLoss/reasoningLoss.forDrops call in driveStream. startStream still builds thinkingBranch and passes it as branch, and StreamThinkingDrops.branch is still declared in src/thinking-drops.ts:36. Nothing reads it now. This dead path suggests some caller still depends on the stream's branch, which makes later work on drop handling harder. Remove the field and the code that computes it, or document why it stays.
• Low severity, maintainability, src/framework.ts:26551-26554. Drops are placed on every reported call even when nothing will read the result. thinkingDrops.place(...) builds a signature index over the compiled messages and places every entry. It runs whenever a report exists, but placedDrops is now read only inside if (thinkingDrops?.recordedAfter !== undefined). Before this change the reasoning-loss teller read it on every call. Now, on a branch with no binding record, the work is computed and thrown away on every call that drops blocks, and drops can repeat on each call of a stream. Move the placement inside the recordedAfter check.
• Low severity, test coverage, test/reasoning-loss-turn.test.ts:170-178. The resident test cannot fail on main and no longer checks what it was written for. The old test ('tells the run's own agent, not the primary') checked that the worker got the line and the resident did not. The new version keeps only assert.deepEqual(resident, []), which already passed on main because the notice was always stored for the run's own agent. It also uses a response with no tool round. So this test adds no protection for this change. The "leaves a host's own strip observer" test also passed on main. Drop the resident test or merge it into the head-strip test. The PR's claim that three tests fail on main should also be checked against this.
• Low severity, maintainability, test/reasoning-loss-turn.test.ts:12. Leftover unused import and test option after the deleted tests. forkAgentName (line 12) was used only by the deleted conversation-fork test and is now unused. The afterRun option of run() (lines 96 and 117) was used only by the deleted 'agent no longer registered' test, and no caller passes it now. Both are dead code left over from the removal.

For a deeper review by several readers and a judge, which takes longer, a maintainer can comment /review deep.