Skip to content

ADR-406: attend reaches agents through a Claude Code mod that agent-ways installs: dormant by default, one status row, transport stays the signal store

Summary

  • Decided: attend's agent-facing side becomes a Claude Code mod, a plugin whose function hooks run inside the session. agent-ways ships it and ways reconcile installs, updates and removes it through Claude Code's own plugin CLI, from a local folder marketplace in the app source. Each project chooses how a session starts, active or dormant, through one key in the ways config that the project's .claude/ways.yaml can set; dormant is the default. A dormant session behaves as plain Claude Code: no polling, no delivery, no row, and one tool, attend_listen, which the agent calls when the user asks it to use attend. A session becomes active from session start in an active project, or from that call for the rest of the session; nothing carries over to the next start. An active session listens until it exits. Opening or closing attend-chat wakes nothing. A keepwarm toggle in the same config controls ADR-182's cache wakes in active sessions. While listening, the mod draws one status row and drives inbound delivery. Its typed tools attend_send, attend_reply, attend_join and attend_peers replace the attend tools that ADR-501 planned for ways-mcp, and that module stays on hold. Every message still travels through attend's signal store through the attend CLI, so the human reads and writes the same conversation in attend-chat. The mod is a thin driver: routing, enrollment, presence and threading belong to attend. A reply goes to the parent's sender as a direct message, a reply to an #open post included, and a reply to a post in a named channel stays in that channel. A send that names a recipient is a direct message, and a send that names none goes to #open. An idle session wakes for what is addressed to it and for any post in a named channel it belongs to, and nothing but keepwarm wakes it once its prompt cache has lapsed (items 2 and 10).
  • Trades away: a dormant session never hears a call meant for it until a person asks for attend or configures the project; a dependency on an early-access Claude Code API that can break on any Claude Code update; a TypeScript component in a Rust suite; a second place, the plugin cache, that holds a copy of shipped code and needs its own update step; and Monitor as the default inbound path in Claude Code.
  • One-way? No. Reversible: reconcile can remove the mod in one pass, and Monitor, /attend and the Stop-hook drain stay working throughout. It becomes expensive only once the Monitor path is removed, which item 9 holds until a stated condition.
  • Probes: Confident (door): In a dormant project Claude acts as plain Claude Code, with one attend tool listed and nothing else. Saying "use attend" or setting the project active turns listening on until Claude exits. The next start in a dormant project is dormant again. Confident (default-on): Once agent-ways is installed, the mod is in every Claude Code session on each enabled target. You turn the mod off in the ways config, and per project you choose whether it starts listening. Keepwarm keeps today's rules unless you switch it off. Not confident (channel-replies): An answer to a post in a named channel stays in that channel, where its members see it; only an answer to an #open post goes to the poster directly.
  • Inversion: Between a session that is always listening, the Monitor loop that /attend starts, and a session that hears nothing until a person starts something by hand. The answer is set per project: projects where several agents work together start listening, and every other session is plain Claude Code until the user asks for attend in it.

Context

ADR-501 planned attend's return path as typed tools in the attend module of ways-mcp, with inbound delivery staying on the Monitor-hosted attend run loop and the Stop-hook drain (ADR-172), and Claude Code channels as an optional third conduit behind a launch flag. None of that attend module has been built.

Claude Code now offers plugins with function hooks: a module that runs in the session, registers typed tools, polls on a clock, submits a prompt into an idle session, and draws in the terminal around the prompt. A spike (draft PR #901) built attend's agent-facing jobs on it, and a trial in a second session exercised it against live attend traffic. The spike showed that one component can do what three do today: the wake that needs Monitor, the tools that needed MCP, and a status display that does not exist. The trial also showed that most of the remaining defects belong to attend's routing model, not to the mod.

The operator set the constraints. Attend matters when several agents work on related concerns, not every time attend-chat is open, so the default is quiet. Which projects those are is known ahead of time, so the choice to listen belongs to the project, in the overlay agent-ways already reads (ADR-115), not to whether a human has attend-chat open. A session in any other project should behave as plain Claude Code unless the user asks for attend in it. The mod may take one status line. The human stays in the conversation, so the transport is attend's store, not Claude Code's own session messaging. agent-ways' lifecycle installs and removes it. The preamble shows once and then recurs on a cadence, as ways do. Mod problems stay separate from attend's routing.

Decision

  1. The mod is attend's agent-facing driver in Claude Code. It does five jobs: decide whether this session is listening, drive inbound delivery while it is, serve the outbound tools, show one status row, and drive keepwarm wakes (item 13). It holds no message state of its own. Every read and write goes through the attend CLI as an argv array with no shell, and any state the mod keeps (active or dormant, its delivery counter, the short-id map) lives in the session's process and is never persisted.

  2. Start state per project, dormant by default. The key attend_mod.listening is active or dormant. It is read through the ways config layers (ADR-115): the user config, then the target's config, then the project overlay {project}/.claude/ways.yaml, which wins. With no key at any layer the session is dormant.

  3. Dormant is inert. The session behaves as plain Claude Code. The mod polls nothing, delivers nothing, draws nothing, joins nothing and submits nothing, and no event wakes it: not a message to its project, an @name, an invite, a call to every session, or the agent's own wish to send. Messages addressed to it wait in the store, where attend-chat can show them as unread. At session start the mod sets the session not listening in attend (item 10), so the Stop-hook drain delivers nothing either.
  4. Becoming active. A session is active from session start when its project resolves to active. Otherwise it becomes active when the user asks Claude to use attend and the agent calls attend_listen. Either way it stays active for the rest of the process's life, through /compact and /clear, and ends when Claude Code exits. Nothing is persisted per session: the next claude in a dormant project starts dormant again.
  5. Active listens until exit. The mod sets the session listening, draws the row, and polls. There is no sleep inside a session. After a quiet period (default 20 minutes) with no delivery, no send, reply or join of its own and no turn running, it slows its poll to the slow interval, and returns to the awake interval on the next delivery or turn. That keeps the load on a remote store bounded (item 12) without missing idle-time messages, which are the point of an active session. An idle session starts a turn for a message addressed to it: one whose to holds its session id, a post in #open among them, one sent to its project, or a reply to a message it sent (ADR-401, to). It also starts a turn for any post in a named channel it is a member of, addressed or not; its own post there does not wake it. An id the session had before a /clear counts as its own, so a message to it, or a reply to one it sent, still arrives. An idle session whose prompt cache has lapsed is never woken, by a message addressed or not, whatever its context size: the wake would rewrite its whole context at the cache-write price. The clock is keepwarm's (ADR-182): the newest turn in the session's transcript, read through ways context, against that turn's own cache tier (an hour, or five minutes on the short tier), less two minutes, since the transcript line trails the request that refreshed the cache. A transcript that cannot be read in five seconds, or holds no turn, counts as lapsed. The message stays unread and reaches the model with the operator's next prompt, as context on that prompt or through the drain at the turn's end; a prompt that does not enter leaves it for the next one. The mod's row, attend unread and attend status show it as N waiting · cold. The mod polls only between turns, so its gate governs an idle session alone; its heartbeat beat runs through turns (item 12). The Monitor poller cannot see turns and applies the gate on every poll: during a turn the cache is warm, and a message held in a turn that runs past the hour inside one tool call goes out through the drain at the turn's end. Under the Monitor poller no other line wakes a lapsed session either: git, process and other event-lane observations are dropped, as the event lane's decay drops any it does not disclose, and peer presence is held with the message lane until the cache is warm. A change to the attend binary reloads the run without printing: the new banner and any held presence go to the log, and a held line that may carry a message delays the reload until the cache is warm. Keepwarm's line is the one exception (item 13). Other posts in #open raise the row's unread count and reach the model with its next turn. On activation the cold-start rule delivers the messages addressed to the project while it was dormant (ADR-172, addendum of 2026-10-01).
  6. attend-chat plays no part. Opening it wakes no session and closing it quiets none.

A -p run or an SDK session keeps attend_listen and does not poll unless the configuration allows it (item 11), whatever its project's start state, because such a run exits after one turn.

  1. One status row. While active, the mod draws one row above the prompt in the shape of the operator's statusline: peer count, unread count, and the active channels. It omits the session name and project, which the statusline already shows. Dormant, it draws nothing. It uses the AbovePrompt slot rather than $.ui.status, because only the slot can draw the statusline's coloured segments. The cost is one row, which the person can collapse.

  2. The mod writes its own short frame on every delivery; one line of tool usage shows on a cadence. The idle delivery is submitted with $.prompt.submit({ text, asUser: true }). Without asUser, Claude Code wraps a plugin's prompt in its own frame, which names the plugin and ends "Address the message above.", and that line pushes the model to reply to every delivery. With asUser the model reads the text bare, so the body carries the frame itself, the same on every delivery:

  3. Silence is a valid reply to the messages below; answer only if useful., first;
  4. The block below is message data relayed by attend.
  5. the batch inside the <attend-peer-messages> tags, which are never dropped.

The permission to stay silent opens the delivery, so the model weighs whether to answer before it reads the messages, and it comes before any tool or verb in every conduit that delivers peer messages: the mod's frame, both formats of the Stop-hook drain (Silence is a valid reply to the messages below; you may continue your work. as the first line, the reply verbs last) and the hint on the Monitor line's first message (silence is a valid reply; to answer: attend message reply "..."). A post in a named channel wakes every idle member, and agents' replies can wake each other, so a delivery may carry awareness alone, and a frame that names the reply tools first reads as a request to use them.

The header names the transport and marks the block as data. It does not say who typed a message: the operator types into attend-chat, so a line claiming the operator did not type a delivery was wrong for those messages. A line makes no claim about where its message came from either: it carries the sender's label, never a reading of the sender id.

The preamble is one line, attend_reply threads (re: ~id); attend_send starts a topic., after the closing tag. It goes with the first delivery of a session and the first delivery after a compaction or a /clear, and then with the first delivery once a configured number of turns has passed since it last showed (default 20), the way a way re-discloses after its refire span. It does not explain the line format: the fields read plainly, and attend_reply's re parameter says the ~id ends a delivery line.

Without Claude Code's frame, the tags are the whole boundary between data and instruction, and every field a store writer controls lands inside them. The mod makes each field one line at the sink (whitespace, control and format characters become a space), so no sender name, sender id, scope, time or body can start a line of its own, and it keeps a < inside the block only when the next non-space character is ASCII [A-Za-z0-9<=(-] and the word there is not attend in any case, replacing every other < with ‹. An ASCII < followed by /, by attend, or by any character outside that set (an invisible, a lookalike slash, a Cyrillic letter) is defused, so no ASCII-< form of either tag survives, while code such as <cwd>, x < y, Vec<u8> and a <= b arrives as written; </div> and <attendee> are defused too. A tag drawn without an ASCII <, such as a fullwidth <, is not covered. The sender label keeps a safe charset (letters, digits, space and _ . - @ ( ); anything else becomes -), so a sender cannot write the line's : or ~ separators. The Stop-hook drain's mod format (item 9) sanitises its lines the same way, so both routes render one format.

No line labels a sender as a person or as an agent, because attend does not make the sender id unforgeable: the sender id is written into a plain signal file by whichever process sends, attend send falls back to external:$USER whenever it cannot resolve a Claude session, USER is the sender's own environment, and any process that can write the store can write any id. Switching between the user and another agent, as the operator asked, needs an origin attend derives and a peer cannot produce: for example attend-chat signing its sends with a key only it holds, or a store write path only attend-chat's process can use, checked by the drain before it reports the sender as a person.

asUser changes only what the model reads. The origin every hook sees stays { kind: 'plugin', name: 'attend', asUser: true }, so the human's row for a delivery (item 5) is drawn as before, and the transcript still names the plugin. The keepwarm wake (item 13) is submitted without asUser.

  1. A compact view for the human, full text for the model. Each message is one line, [#channel] Name (project) HH:MM: text ~id, where ~id is a short handle the mod maps back to the full id for attend_reply. The model receives the framed batch. The operator's transcript shows a delivery the mod submitted as one dim line per message, expanded on request. The view is the mod's; the line's fields come from attend, and a field the line needs (the thread parent) is added in attend (item 10), not computed in the mod.

  2. Transport stays attend's signal store. The mod never uses $.session.send, the SendMessage tool, or a session.receive peer delivery, though attend's session ids are Claude Code session ids and that route is a few lines away. Every message, agent to agent included, is written to attend's store, where attend-chat and any other reader see it. This is the reason the mod exists instead of Claude Code's own cross-session messaging.

  3. Tools. A dormant session lists one tool, attend_listen. Its description says to call it only when the user asks to use attend, and that it turns listening on for the rest of the session. That is the smallest surface that lets "use attend" work. A skill alone cannot change the mod's state, because the mod holds that state inside the session and a tool call is the channel the mod serves. Listing nothing would leave the agent no way to act on the request. Listing all five tools while dormant would put four tools in every session that the operator wants to behave as plain Claude Code. On activation the mod registers attend_send, attend_reply, attend_join and attend_peers. If the API cannot register a tool after session start, they are registered deferred, so only their names are listed, and each refuses while dormant with a pointer to attend_listen. In a mod host, /attend calls attend_listen instead of starting Monitor. The message tools take typed parameters. A body is one argv element after --, so no quoting rule applies to it. ADR-187 items 7, 9 and 10 carry over to these tools: mechanical guidance in the tool descriptions, envelope fields as typed parameters, and the tool surface as the contract. The tool permission entries are written by the settings merge under the names Claude Code gives a plugin's tools. Splitting a long body is done in the mod until attend's send splits on its own (item 10). attend_send's to takes a session name, a person's member id or a project path. A send that names a recipient is a direct message. With no to and no channel it posts to #open, as it does with channel set to open or #open. With both channel and to, the post stays in the channel, addressed to the recipients; every member reads it, and like any channel post it wakes the idle members (item 2). attend_reply's description says the reply goes to the sender as a direct message, or stays in the parent's channel when that is a named channel.

  4. Distribution: a local folder marketplace, installed by reconcile through Claude Code's CLI. The mod lives in the app source under plugins/attend/, beside a plugins/.claude-plugin/marketplace.json that declares the marketplace agent-ways. It is not a projection root and never sits under skills/. For each enabled target, after the settings merge and the MCP registration, ways reconcile:

  5. adds the marketplace with claude plugin marketplace add <app>/plugins --scope user when it is missing;
  6. installs attend@agent-ways --scope user when it is missing;
  7. runs claude plugin marketplace update agent-ways and claude plugin update attend@agent-ways when the installed version is older than the shipped one. Running sessions keep their version until they restart, as with ways-mcp.

Each call runs without CLAUDE_CONFIG_DIR for the default target and with it for any other, by the same rule as ADR-501 item 9. An attend plugin from another marketplace is the operator's own: it is reported and left alone. A missing claude binary or a failed call is reported and never fails the reconcile. ways status reports the installed and shipped versions per target. The plugin carries attend's version and is released with attend, since it depends on attend's verbs.

Writing CLAUDE_CODE_PLUGIN_DIRS into the env block of settings.json was the other candidate. It loads the folder in place with no cache, so an update reaches the next session with no extra step. It lost for four reasons: - The three-way merge (ADR-500) owns hooks and permissions, and treats env as the user's. A variable that holds a list of paths, which the operator or an SDK host may also set, would need a new owned slice that splits and rejoins a string inside the self-audited merge. - The plugin CLI is the route Claude Code provides for this state, and agent-ways already writes .claude.json through Claude Code's CLI rather than by hand (ADR-501 item 9). The plugin route has the same shape: add, check current, replace, remove. - An installed plugin is visible and controllable where the operator already looks: /plugin, claude plugin list, claude plugin disable. - Whether a CLAUDE_CODE_PLUGIN_DIRS set in the settings env block takes effect before plugin discovery is untested. The spike saw that variable work only from the process environment of an SDK host.

The cost of the marketplace route is the cache: reconcile must notice a version change and run the update step, and the plugin's version must change whenever its files do. A check in the release path refuses a change under plugins/attend/ without a version bump. For development, claude --plugin-dir <checkout>/plugins/attend stays the way to load a working copy.

  1. Removal and fallbacks.
  2. A disabled target has the plugin uninstalled and the marketplace removed through the same CLI, before its links are removed, as ADR-501 orders the MCP registration. make uninstall withdraws every target first, so it removes the mod too.
  3. The Stop-hook drain stays in every host. It is how a message reaches a session at the end of a running turn, which continues the turn rather than starting a new one. It delivers by attend's listening state, which the mod sets, so in a mod host the mod decides and the hook delivers.
  4. Monitor and /attend stay as the fallback for hosts that cannot run the mod: SDK and desktop hosts where the mod's process or UI hooks do not run, a Claude Code build where the early-access API breaks, and an operator who has turned the mod off. /attend checks whether the mod is loaded (attend_listen is present) and calls it instead of starting a second poller. Two pollers on one seen-set are safe but noisy. The Monitor path is deprecated as the default in Claude Code and kept until the plugin function-hook API leaves early access and SDK hosts load mods without an environment variable. A later decision removes it then.
  5. The ways-mcp attend module stays on hold. It resumes if the mod route is withdrawn, or if a host without mods needs typed attend tools. ways-mcp itself, ways_status and the keepalive module of ADR-501 are unchanged.

  6. What attend must provide. These are attend's routing model, changed in attend and not worked around in the mod. A workaround in the mod for the reply channel was tried and reverted for this reason.

    • Listening without joining. A session can be listening without joining a channel. The mod sets it on activation and sets it off at session start in a dormant project, through an attend verb, along the lines of the passive and active state proposed on #538. While the session is not listening, the drain delivers nothing and marks nothing seen. Today the drain delivers only to a session that ran attend run or joined a channel (ADR-172, addendum of 2026-10-01).
    • A keepwarm check the mod can run. A verb that runs ADR-182's keepwarm judgment once for this session and prints the wake line or nothing, so the mod drives keepwarm without the Monitor-hosted sensor loop (item 13).
    • A non-consuming unread count for the row.
    • A send that names someone is a direct message. A send names a session, a person, a project or a channel; one that names none posts to #open. ADR-401's to section holds the addressing rules: what each recipient resolves to, the person tray, and which session in a shared project tray reads a message.
    • Replies go back to the parent's sender as a direct message, a reply to an #open post included. A reply to a post in a named channel stays in that channel. No reply falls back to #open (ADR-401, to). Drain lines carry the thread parent.
    • attend-chat shows each agent's direct messages. An agent's row opening its direct view is follow-up chat work after #972, and amends ADR-405.
    • Smaller defects: send --to with the session's own path fails with "no active peer"; a partly failed multi-part send does not say which parts went out; a body starting with re: is ambiguous on the wire; and splitting a long body belongs in attend send.
  7. Configuration in the ways config. One section, attend_mod, is described in the settings registry (ADR-503), and the same name is used at every layer: listening (active or dormant, default dormant; set at user, target or project scope, project wins), keepwarm (on or off, default on; same layers, project wins; item 13), install (default true; user and target scope only, since reconcile acts per target and not per project; reconcile reads it), the slow poll interval, the awake poll interval, the quiet period, the preamble's repeat span in turns, and whether a -p or SDK session may poll (default false). The mod reads its section through the ways CLI at session start and again on activation, so a change applies without a reinstall. Turning install off and reconciling removes the mod from every target. With install off the mod is unavailable to Claude Code: no attend tool is listed, nothing listens, and /attend falls back to the Monitor path.

  8. A remote store. The signal store may be a mounted remote directory. The mod therefore polls and never watches files: change notification is unreliable on network mounts. Each poll is one attend process with a timeout; a dormant session never polls and an idle active one polls slowly; and a session on another host is judged alive by data in the store, its heartbeat, never by a process here. The mod keeps that heartbeat inside the grace with attend listen beat, run every 30 seconds on a timer of its own, during turns too; a listening session whose recorded Claude Code process runs on this host is alive whatever its heartbeat says (ADR-129, addendum of 2026-10-13). Liveness facts drawn from processes are host-scoped: the process key a session's enrollment records carries the host it ran on, and a key from another host, or one written before keys carried a host, is unknown here, neither alive nor exited. A session known only by such a key is judged by its heartbeat, and a send to it that a stale heartbeat refuses can still be sent now (ADR-409, amendment of 2026-10-13); a session this host never saw exit is never refused for good. Intervals are configuration so a slow mount can be given longer ones.

  9. Keepwarm in mod sessions, with a toggle. attend_mod.keepwarm (on or off) is read through the same layers as listening, with the project winning. The time settings stay as ADR-182 and the sensor define them: a window the operator arms with attend keepwarm on (six hours by default), one wake after 50 idle minutes against the one-hour cache, only with 50k tokens of context or more, disarm when a wake produces no turn within ten minutes, and a three-hour window armed on its own after a paid cold write.

  10. Unset or on keeps ADR-182's behaviour. In an active session the mod runs attend's keepwarm check (item 10) on its poll and submits the keepwarm: line as a turn, as Monitor does today. The one-word, no-tools contract is unchanged.
  11. off means no keepwarm wake in that project's sessions, and the mod never runs the check, so a paid cold write arms nothing. This amends ADR-182 item 4: the automatic three-hour arm does not happen where keepwarm is off.
  12. Keepwarm's wake is not gated by the cache gate (item 2). It is how a session stays wakeable: it fires at 50 idle minutes, while the cache is warm, and it never fires once the cache has lapsed.
  13. A dormant session gets no keepwarm, because it is inert. A user who arms keepwarm in a dormant session is asking Claude to use attend, and the agent calls attend_listen first.
  14. The Monitor fallback keeps ADR-182 as written. ADR-501's keepalive module, an eight-hour window over channels, is a separate mechanism and is unchanged.

Consequences

Positive

  • Inbound delivery needs no Monitor. A project set to active listens from the first turn, and "use attend" turns any other session on. Elsewhere Claude Code behaves as it would without agent-ways' attend.
  • Outbound loses shell quoting, hand splitting and the send-or-reply guess, the three near misses the #538 field report recorded.
  • The operator gets a status display for attend where there was none, in one row, only while it matters.
  • The human remains a participant in every exchange, and the store remains the one place where attend traffic is kept and managed.
  • agent-ways owns the mod's whole life, through the same reconcile that owns its other projections.

Negative

  • The mod rests on an early-access API. A Claude Code update can break it with no notice; the Monitor fallback is the mitigation, and the mod's plugin tests should run against each new Claude Code build.
  • A TypeScript component joins a Rust suite, with its own tests and type checking.
  • The plugin cache holds a copy that is stale until reconcile runs the update step and the session restarts.
  • Until the item 10 prerequisites land, the mod works around attend: the row's unread count covers only what it drained, and keepwarm needs the Monitor loop.
  • The operator has to mark the projects where agents should listen. In an unmarked project, a peer or the human cannot reach a session at all until the user there asks for attend. A message to it waits, unread, with no signal in the session.
  • A session in an active project polls until it exits, at the slow interval once idle, including sessions doing unrelated work in that project.
  • Every session carries one tool description, attend_listen, even in dormant projects.

Neutral

  • ADR-501's server, its registration and its keepalive module are unchanged. Its item 4 (the attend module) and item 5 (channels as an attend conduit) are amended: the attend module is on hold and the mod takes its place.
  • ADR-182's keepwarm moves into active mod sessions with a per-project toggle; ADR-501's keepalive on channels is unchanged.
  • The skill, the way and the messaging reheat that hold messaging guidance in lockstep (ADR-187) stay its three readers. The mod's preamble carries tool usage only, and its reply-optional line (item 4) is the mod's own, not taken from that source.

Alternatives Considered

  • Monitor as it is. Rejected as the default. The session listens only after the operator or the agent starts attend run under Monitor, and the operator said none of it should be operator driven. Monitor also cannot draw a status row or offer typed tools. It stays as the fallback (item 9).
  • The MCP return path planned in ADR-501. Typed tools from the ways-mcp attend module, inbound through Monitor, the drain and channels. Rejected for Claude Code because the tools would come from one component and the wake from another, and the channel wake needs a development launch flag on every session. MCP has no way to draw a status row. The mod does all three in one place. It stays on hold as the route for hosts without mods.
  • Claude Code's native session messaging ($.session.send and session.receive). Rejected: messages would pass between sessions directly, out of attend-chat's sight and out of the store, which removes the human from the conversation and the single place where attend traffic is managed.
  • Waking every interactive session when a human is present in attend-chat. The operator chose this when first asked, then reversed it: "I'm actually rethinking waking every working session. I think that's a mistake." Sessions doing unrelated work would be pulled into the conversation whenever attend-chat opened. Which projects should listen is known ahead of time and is set per project instead. This also removes the presence query from attend's prerequisites, since nothing else in the mod needed it.
  • Waking a dormant session when it is called or reaches out (a message to its project, an @name, an invite, a call to every session, or its own send), as an earlier draft of this record had it. Rejected by the operator, who redefined dormant: "claude invoked in a project where it's dormant will essentially be have as regular claude code." Waking on a call also meant polling in every dormant session to notice the call.
  • All attend tools listed while dormant. Rejected: four tool descriptions in every session that should behave as plain Claude Code, when one is enough to act on the user's request (item 7).
  • Keepwarm configured only through attend keepwarm and attend's own config. Rejected: the toggle is about what attend does to a session's attention, the same question listening answers, so it sits beside listening and resolves per project the same way.
  • Shipping the mod under skills/, so the user skills folder loads it. Rejected: reconcile projects the whole skills/ root, so the mod would load in every target with no switch of its own, and no step could update or remove it apart from the skills root. A project .claude/skills folder does not load it at all.
  • CLAUDE_CODE_PLUGIN_DIRS written into the settings env block. Rejected for the reasons in item 8.

Addendum, 2026-10-12: installed hooks modules sit behind a rollout flag

Appended after acceptance; nothing above is changed. It adds to the early-access risk in the Negative consequences and in item 8.

On Claude Code 2.1.296 the debug log of a session with attend@agent-ways installed says installed plugins' hooks modules held 1ms for the rollout flag (tengu_plugin_hooks_modules): the fetch settled with no payload. An installed mod's hooks module therefore loads behind a server-side rollout flag, which a --plugin-dir load does not wait for. In that run the session was logged out, the flag fetch returned no payload, and the mod still loaded. Whether a flag that is fetched and set to off would stop an installed mod from loading is untested. If it would, the Monitor fallback of item 9 is the path for those sessions, as it is for any host that cannot run the mod.

Addendum, 2026-10-12: a folder-marketplace plugin runs from the folder, not the cache

Appended after acceptance; nothing above is changed. It corrects item 8's account of updates and its cost, and says what ways status compares.

Item 8 assumed that sessions run the copy claude plugin install makes in the plugin cache, so that reconcile's update step and a version bump were what carried a change to sessions ("Running sessions keep their version until they restart"; "the cost of the marketplace route is the cache"). That does not hold for this marketplace. Claude Code's plugin reference for 2.1.296 says that a plugin whose marketplace is a folder, with a relative-path entry, "is read from that folder itself, never from the copy claude plugin install made", and that /reload-plugins re-reads the folder when it changed. A test on Claude Code 2.1.296, in a throwaway config laid out like this install, matched it: with the cache copy at one version and the folder at the next, /reload-plugins ran the folder's; with the folder moved on again, a fresh session ran the folder's; claude plugin update after a bump wrote a new cache copy and said to restart, and no session ran that copy.

Consequences:

  • A change to the app's plugins/attend/ reaches every session that starts after it, as soon as the app source moves (ways manage update, or --ref), before reconcile runs. A running session takes it with /reload-plugins. The attend binary is read at each call, so it needs no step.
  • Reconcile's update step and the release rule that refuses a change under plugins/attend/ without a version bump do not affect what loads. Both stay, as record-keeping: the bump labels what a release shipped, which claude plugin list and the release notes name, and the update step keeps Claude Code's record of the installed version in line with it. Neither is a delivery mechanism.
  • ways status reported the installed version from Claude Code's record, which can trail what runs. It now reports the version sessions run: the shipped version when attend@agent-ways is installed from this app's plugins/ folder, with the recorded version beside it when the two differ, and the record alone where the marketplace is some other folder.
  • The plugin cache is no longer a cost of this route. A session that has not run /reload-plugins keeps the module it loaded, which is the remaining sense in which a running session keeps its version.

Addendum, 2026-10-12: resume is decided in ADR-411

Appended after acceptance; nothing above is changed. The operator's answers recorded as considered entries 7 and 8 reverse the door probe's "until Claude exits" for a resumed session id. ADR-411 records that change: it amends items 1 and 2 of the Decision, so that a session that listened comes back listening when its session id is resumed.

Addendum, 2026-10-12: splitting is removed in ADR-412

Appended after acceptance; nothing above is changed. Item 10 moved splitting a long body into attend send. ADR-412 amends the Decision so that one message is one signal whatever its length, and no conduit splits it on delivery.

Addendum, 2026-10-16: a session with no turn yet is wakeable

Appended after acceptance; nothing above is changed. Item 2 counts a transcript that holds no turn as lapsed, and a session with no transcript yet read the same way, so a new session was never woken before the operator's first prompt. A session with no turn has no cache for a wake to rewrite. The gate now wakes a session whose transcript does not exist yet, or whose reading shows no turn and no API usage (ways context then estimates the context from the file's bytes, as for a transcript a local command such as /mcp wrote before the first prompt). A transcript that cannot be read in five seconds still counts as lapsed. The mod's poll, attend message unread, the Monitor poller and the peers sensor read the one gate.

What rides the operator's prompt as context, a message held on a lapsed cache or the cold start's held-back note, is text Claude Code does not draw. The mod draws it under the prompt as transcript lines the model never reads: a line saying how many messages went with the prompt, one dim line per message as a delivery's row draws them, and the note.