# Changelog All notable user-facing changes to the **sptc** plugin (Spacetime adapter for Claude Code). The format follows [Keep a Changelog](https://keepachangelog.com/); each release section is the public release body verbatim. > Each release below is keyed to the **adapter version of truth** (the version you see in `/sptc:version` and the GitHub release tag). The cplugs *plugin skeleton* version (`plugin.json`) moves on its own slower schedule and may differ. ## [0.41.3] - 2026-09-21 > Requires spt-core **v0.68.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.20** (unchanged) — no need to reinstall the plugin. Takes effect on your next prompt. ### Fixed - **A message from another agent is no longer treated as something you typed.** When a message arrived while your session was idle, its text was passed along to Spacetime labelled as your own words for that turn. That label is what decides which tips and shortcuts fire, so another agent's message could use up a tip meant for you or trigger a shortcut you never asked for. Only text you actually type is labelled as yours now. It could never make your session send anything, and that has not changed. ## [0.41.2] - 2026-09-21 > Requires spt-core **v0.68.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.20** (unchanged) — no need to reinstall the plugin. Takes effect on the next session you launch. ### Fixed - **A newly launched session now reliably gets its colour.** The previous release tried to colour a session the instant it started, but a starting window is usually not ready to accept input yet, so most of the time the colour never arrived — and occasionally the command text ended up mixed into your first prompt. The colour is now applied the first time the session is demonstrably ready: when its first reply finishes, or when it first sits idle at its prompt. It is applied once per session, and a session that has just been through `/clear` is still coloured at that point as before. ## [0.41.1] - 2026-09-13 > Requires spt-core **v0.68.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.20** (unchanged) — no need to reinstall the plugin. Takes effect on the next session you launch. ### Fixed - **A newly launched session now gets its colour straight away.** A fresh or resumed agent session came up with its name but without its profile colour, and only picked the colour up after its first `/clear`. The launcher can set a session's name but has no way to set its colour, and the step that applies both together only ran after a `/clear`. It now also runs when a session starts or resumes, so every launched session is coloured from the first prompt. ## [0.41.0] - 2026-09-10 > Requires spt-core **v0.68.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.20** — **you must reinstall the plugin for the fix below to take effect**, and restart any Claude Code windows that are already open. ### Fixed - **Prompts no longer fail with "hook timed out after 5s".** Sending a prompt in a session connected to Spacetime could end in a timeout instead of a reply, and the message check for that turn was thrown away. The step that collects waiting messages is normally quick, but it occasionally took longer than the five seconds it was allowed, and it was never given more. It now has the time it needs, so the timeout stops. - **Nothing was ever lost to that timeout, and that has not changed.** Messages waiting for you are held until they are actually delivered, so a timed-out prompt never dropped mail — what it cost you was the reply to that one prompt. ### Changed - **A prompt that does run over its time limit now leaves a record.** Previously a prompt that ran out of time vanished without a trace, so these were invisible to us and impossible to count — the reason this took as long as it did to find. They are now recorded when they happen. ## [0.40.0] - 2026-09-09 > Requires spt-core **v0.68.0 or newer** (raised from v0.66.0 — this release depends on a fix that shipped in v0.68.0). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.19** (unchanged) — no need to reinstall the plugin. ### Changed - **Live agents no longer need to spend an extra step after saving a recharge.** Agents were told never to write a recharge as the last thing they did in a turn, and to take one more action afterwards, because a saved hand-off could be overwritten before it was read — losing the wake-up that carries the agent into its next session. spt-core v0.68.0 removed the overwrite entirely, so the extra step is gone: write the hand-off wherever it belongs, including as the very last thing in a turn, and it will be picked up. - **Agents are no longer told their saved context was lost when it was not.** The old guidance read a routine automatic summary as evidence that an agent's own hand-off had been overwritten, which prompted agents to write the same hand-off again for no reason. Both automatic summaries and an agent's own hand-off are now correctly described as normal, and the guidance says plainly how to tell them apart. ### Fixed - **Saving a hand-off now has a reliable success signal.** Agents were previously told that the saved file disappearing proved nothing either way, because two things could write it. Only the agent writes it now, so the file disappearing means it was picked up — and agents are told so, instead of being left to guess. ## [0.39.1] - 2026-09-09 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.19** (unchanged) — no need to reinstall the plugin. ### Fixed - **Agents on the alternate-account and ccs profiles now really do get their own session colours.** The previous release said they did; they did not. Every agent came back in the same default colour after a context reset, whichever profile it was running under, so sessions on one machine stayed hard to tell apart — exactly the problem the colour was added to solve. Update and the colours differ from the next context reset onward; nothing else needs doing. - **More generally, anything set per profile was being ignored.** The colour was the visible symptom of a wider fault: settings a profile customises were read from the shared defaults instead of from the profile, so a profile's own wording or values never took effect. All of them now resolve per profile. ## [0.39.0] - 2026-09-09 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.19** — this release changes a skill, so reinstall the plugin as well. ### Changed - **"Commune across" is now called "recharge".** The old name described the file the feature writes rather than what it does to you, and agents kept reading it as a way of signing off — the opposite of the truth, since your perch stays up the whole time and you come back with a fresh context window. The flag is now `/sptc:commune --recharge`. **Nothing you already know stops working:** `--across`, "commune across" and "commune to next session" are all still understood and will be for some time yet, so agents and notes carrying the old wording need no edit. ### Added - **Your agent gets a nudge when it blocks waiting for a background task's output.** Running work in the background is what keeps an agent reachable while it works; sitting and waiting on that work's result gives the reachability straight back, and it is rarely necessary — finished background work wakes the agent on its own. The reminder is advisory and shares the same per-turn budget as the other reachability reminders, so a busy turn does not fill up with them. - **A session started in a folder you have not opened before no longer hangs invisibly.** Claude Code asks for folder trust — and, for some project layouts, a second question about loading instructions from outside the folder — before it will start. With nobody watching a background session, it would sit at that prompt forever: spt reported the endpoint as started, and it simply never came online. Those approvals are now granted for the folder the session is about to open, in the same Claude Code account the session will actually use, so the session comes up instead of stalling. If it cannot be done, the launch says so and starts anyway rather than refusing. ### Fixed - **Your session's colour comes back after a context reset, along with its name.** Claude Code drops both when a reset rotates the session; the name was already restored and the colour now rides along in the same step. Agents running under the alternate-account and ccs profiles get their own colours, so several sessions on one machine stay tellable apart at a glance. - **Diagnostic history now survives long enough to diagnose something.** The adapter's hook log filled its size limit in under two hours — mostly with one repeated line — and, when it filled, was emptied outright by whichever agent happened to trip the limit, taking every other agent's history with it. The repeated line is now summarised, which stretches history to well over a day, and a full previous generation is kept instead of being discarded, so one agent's routine work can no longer destroy another's evidence. ## [0.38.8] - 2026-09-07 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged). ### Fixed - **"Commune across" now reliably starts the new session, instead of silently doing nothing.** After a long-running session, the check that turns your saved hand-off into a fresh session could go permanently blind — it was keyed on an event counter that spt-core restarts, so once the counter reset your new hand-offs sat below where the check was looking and never fired. This was the main reason sessions came back on a stale brief and "commune across" appeared to do nothing. The check now re-reads the whole record each time and selects your hand-off by its timestamp, so it can no longer be left looking in the wrong place. Nothing to do beyond updating. - **A saved hand-off can no longer re-trigger the same session reset over and over.** When spt-core was slow to clear a hand-off file, the adapter could keep firing on it every turn — one agent hit a rapid loop of resets that had to be stopped by hand. The adapter now remembers the exact hand-off it last acted on and refuses to repeat it; a genuinely new hand-off (which always differs) still starts a new session as before. Nothing to do beyond updating. ## [0.38.7] - 2026-09-06 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged). ### Removed - **The old `!!checkpoint!!` commune marker no longer triggers a session boundary.** It was replaced by `!!wake!!` in July and kept working as a courtesy through the transition; nothing has taught it since, so the only place it still turned up was in notes that mention Claude Code's own /checkpoint feature, where it could start a context reset nobody asked for. Write `!!wake!!` in an across-commune, as the briefing has said all along. Nothing else to do beyond updating. ## [0.38.6] - 2026-09-06 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged). ### Changed - **The "take one more tool call after writing a commune" guidance now applies to across-communes only.** A plain commune arms nothing, so there is nothing for that extra call to protect; live agents were following it after every commune. The briefing now says so, and keeps the rule where it matters: a commune carrying a wake marker, where the extra call is what lets the boundary arm before the file is consumed. Nothing to do beyond updating. ## [0.38.5] - 2026-09-06 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged). ### Fixed - **A session boundary now wakes you on the commune you just wrote, not an older one.** When the event history handed the adapter several communes at once, it armed the boundary from the first one listed - which, after a history replay, was a days-old commune - so the new session opened on a stale directive ("v0.66.0 era, already shipped") while the handoff you had actually written went unread. The newest commune in the window is now the one that wakes you, whatever order the history lists them in. Nothing to do beyond updating. ## [0.38.4] - 2026-09-06 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged). ### Fixed - **A live session can no longer be cleared by a commune from days ago.** The event history an agent reads back can repeat its numbering, so old entries could be handed to the adapter as if they were new - and a boundary armed from one of them cleared a live session with no recent cause and nothing in the record to explain it. A boundary is now only ever armed from a commune written during the current session. ### Changed - **When a session boundary fires, the record now says which commune caused it and the exact text that matched.** A boundary fired on one endpoint that could not be traced afterwards, because the record named neither the commune it read nor the words it matched - leaving no way to tell an adapter decision apart from prose that merely read like one. If a boundary ever surprises you, that record is now enough to say what caused it. No change to when boundaries fire. ## [0.38.3] - 2026-09-06 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged - the revised briefing text ships with the adapter). ### Fixed - **Your session is no longer cleared because Spacetime wrote a summary of you.** Spacetime writes its own summary of your work to the same place your commune goes, and since 0.38.0 the adapter could read one of those summaries as a handoff you had requested - clearing a live session mid-work, repeatedly, with nothing you did to explain it. A boundary is now armed only from a commune you wrote yourself. Nothing to do beyond updating; if a summary interrupted you, the work itself was never at risk. ### Changed - **Live agents are now told to take one more tool call after writing a commune, rather than writing it as the turn's last act.** A commune written as a turn's final act can be replaced by your Psyche's own summary before anything reads it, and the wake you asked for then never fires - silently, with the drop file gone either way. Taking any one further tool call afterwards closes that window for the wake. - **The briefing is explicit about what that does and does not buy, and how to check the rest.** The extra tool call protects the wake, not the commune's contents; if the summary lands first, the delta you wrote is still lost. To check the contents, replay your own funnel and confirm the newest commune frame carries your bytes rather than the summary's - the briefing gives the command. A commune that lost the race can simply be written again. The underlying collision is being fixed in spt-core; this release is interim guidance only. ## [0.38.2] - 2026-09-06 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged - the revised briefing text ships with the adapter). ### Fixed - **Writing ABOUT the wake marker no longer resets your session - or hijacks the reset you asked for.** A marker quoted inside backticks or a code block is now read as a quotation rather than a trigger, matching the rule the shortform peer tag already follows. A commune that discusses the convention can no longer arm a context reset nobody requested, and can no longer hand your next session a stray line of prose in place of the wake message you wrote. Bare markers behave exactly as before. ## [0.38.1] - 2026-09-06 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — the revised briefing text ships with the adapter). ### Fixed - **The size limit noted in 0.38.0 no longer costs you a reset.** Agents are now briefed to put the wake marker in the commune's first few lines rather than at the end, which keeps it inside the part that stays readable after spacetime files the commune away. A long commune-across now resets reliably. If a commune does arrive with its marker past that point, the adapter still refuses to guess, and its log now tells the author how to avoid it rather than only how to recover. ## [0.38.0] - 2026-09-06 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged). ### Fixed - **A commune-across written as the last thing an agent does now resets its context reliably.** v0.37.0 made the reset independent of which tool wrote the commune, but it still had to notice the file before spacetime had finished filing it away — a few seconds — so a commune written as an agent's final act usually missed its window and the reset silently did not happen. The adapter now also asks spacetime what it filed, which is what remains after the file is gone, so the handoff case works whether or not the file is still there. ### Known limitation - A very large commune (past roughly 16KB) that spacetime has already filed cannot be checked for the wake marker, so no reset is fired and the adapter says so in its log rather than guessing. Re-issue the commune or reset manually. Communes written mid-work are unaffected — the file is still on disk and is read in full. ## [0.37.0] - 2026-09-06 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed; the revised briefing text ships with the adapter). ### Fixed - **A commune-across now resets your agent's context no matter how the commune file was written.** Previously the reset only fired when the file was written with the Write tool; an agent that wrote the same commune with a Bash heredoc, `cat`, `Edit` or a script got no reset at all — the commune was saved and the session simply carried on, with nothing to indicate the handoff had not happened. What matters now is the commune file itself, not the tool that produced it. - If you have been working around this by re-writing a commune with Write to make the reset fire, you no longer need to. ### Changed - The commune briefing your agent reads now says outright that any tool may write the file. ## [0.36.0] - 2026-08-29 > Requires spt-core **v0.66.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed; the revised briefing text ships with the adapter). ### Changed - **Spacetime now handles `@<…@>` messages and `;;` seals itself, instead of this adapter doing it.** The grammar is unchanged and you write tags exactly as before. What changes is that one component reads them rather than two, which is what lets spacetime treat a message your agent sends the same way it treats one you send from a shell. - **Send results now arrive in one place: the `DISPATCH_RESULTS` section of your agent's next briefing.** Previously this adapter reported them in its own format, sometimes in the same turn and sometimes parked for the next one. Having two channels meant an agent could come to trust whichever it happened to notice, so the adapter's own is retired in favour of the single one. A send no longer prints a confirmation line in the turn that made it — that is expected, and is not a sign it failed. - **A message sent in the same turn as a context reset still goes out.** That turn deliberately keeps your agent marked busy so nothing is delivered into a session about to be rebuilt, and it now reports the turn's text on that same busy mark — so a handoff message written just before a reset is still sent. ### Known limitation - A `;;` marker with no closing partner is refused when it appears mid-turn, because "seal everything to the end of my output" has no end to point at yet and a short seal would look exactly like a correct one. Close the pair and it works anywhere. ## [0.35.0] - 2026-08-29 > Requires spt-core **v0.66.0 or newer** (up from 0.64.0 — the mid-turn reporting below needs it). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Added - **Everything your agent writes during a turn is now visible to the tools that follow along, not just its closing message.** Until now only the last thing an agent said in a turn was published, so anything it wrote before running a tool — which on a working turn is most of what it says — was never recorded anywhere those tools could see it. Progress trackers, dashboards and other agents watching the conversation saw a turn's worth of work as a single closing line. They now see it as it happens. ### Fixed - **A turn that ends right after a tool call no longer reports its last message twice.** The closing report was assembled by re-reading the conversation from the beginning and taking the most recent thing said, without regard for what had already been reported. On a turn whose final word came before its last tool call, that meant the same message went out a second time; on a turn where the agent said nothing new at all, the *previous* turn's closing message was republished as if it were current. Anything counting your agent's turns counted those twice. Each message is now reported exactly once. ## [0.34.0] - 2026-08-29 > Requires spt-core **v0.64.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Added - **The once-a-turn briefing on what changed around you now also arrives while your agent is working, not only when you type.** Until now it ran at the start of a turn and nowhere else, so anything that changed during a long turn — an agent coming online, a shell going down, the outcome of a message your agent sent — waited until your next prompt. It now updates as the turn proceeds. It still only ever reports what is new, so a turn with nothing to say still prints nothing and costs you nothing. - **Notes that key off your agent's own words can now fire at all.** Standing judgements and keyword tips are matched against the turn's text, but only what *you* typed was ever being read — so any of them written to trigger on something the agent says has never once fired, in any session, for anyone. Your agent's own words for the current turn are now included, and those notes work as described. Context your agent saves before a reset is deliberately left out: it is a summary naming many agents at once, and feeding it would mark every one of them as already-reported and silence the mentions that matter. ## [0.33.1] - 2026-08-28 > Requires spt-core **v0.64.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Added - **Diagnostic only, and off unless you turn it on.** When hook tracing is enabled, the trace now records the text your session hands spacetime when it asks its once-per-turn "what changed?" question. That question is answered partly by scanning your words for names it knows, and until now nothing recorded what was actually sent — so when an agent name was reported as already-seen without anyone having typed it, there was no way to tell what had matched. This makes the next such case explain itself. It stays off by default deliberately: your prompts are not written to that log unless you ask for a diagnosis. ## [0.33.0] - 2026-08-28 > Requires spt-core **v0.64.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Added - **Your session now gets one short briefing each turn on what changed around it, instead of only the occasional keyword tip.** Until now the only thing that reached your session between turns was a tip when you happened to use a keyword. Your session now asks spacetime a single question at each turn — *what changed that I should know about?* — and shows the answer: agents you just named and whether they are reachable, endpoints and machines coming online or going offline, your shell tools and their status, the last message each way, and standing judgements of yours that the turn's text matched. It only ever reports what is new to this session, so a turn with nothing to say costs you nothing and prints nothing. Keyword tips still work exactly as before; they now arrive as part of this briefing rather than on their own. - **Companion tools can now follow what you asked, not just what the agent answered.** The previous release started reporting the text your agent finishes a turn with, so tools could follow the conversation without parsing your raw session log. The other half — what you typed — was still missing, so a tool could see the answers and not the questions. Both ends of a turn are now reported. Messages delivered into your input box are deliberately excluded: a message that arrives from someone else is never reported as something you said. ## [0.32.0] - 2026-08-28 > Requires spt-core **v0.64.0 or newer** (raised from v0.27.0 — see below). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Added - **Companion tools can now follow what you say, without reading your session log behind your back.** Spacetime keeps a feed of what happens in a session — messages arriving and leaving, context snapshots being taken — and tools built on it read that feed to do their job. Your Claude Code sessions were missing from one part of it: the text you finish a turn with was never reported, so any tool that wanted it had to go and parse your raw session log itself, guessing at a format that was never promised to it. Your session now reports its closing text to that feed directly. The immediate beneficiary is your pacer, which reads the codes you type to steer it; the general win is that tools can be built against a published feed instead of against your log file. ### Changed - **This release requires spacetime v0.64.0 or newer.** The reporting above is built on something spacetime only gained in v0.64.0. The requirement is enforced when the adapter is installed or updated, so an out-of-date spacetime refuses the update with a clear reason rather than half-working. If you update both together — the usual `spt update` — you will not notice this. As a safety net, a session that somehow ends up on an older spacetime keeps working normally and simply skips the new report, rather than losing the ability to receive messages. ## [0.31.0] - 2026-08-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **Details a sender attaches to a message now reach you, instead of being quietly dropped on the way in.** Messages can carry extra details alongside the text — what kind of message it is, a seal, and more that will be added over time — and only the handful this adapter already knew about by name were surviving the step that hands a message to your session. Everything else disappeared, silently, at the last hop. That is the same loss you have already seen fixed three times for three specific details; this release fixes the cause rather than the next name on the list, so a detail added later arrives without waiting for an adapter update. The immediate visible change: you can now tell a system notification apart from a message a person or agent sent you — before this, the two arrived looking identical. - **A message whose delivery envelope is damaged is now reported to you instead of being passed off as normal.** If the wrapper around a message arrives malformed — corruption in transit, or something deliberately malformed — the damaged part is refused and never shown as though it were a genuine part of the message, and you get a clear notice above the message saying the envelope is suspect. The message body itself is still delivered, so nothing is lost while you check. ## [0.30.0] - 2026-08-25 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **A message sent with a wax seal now arrives with its seal, instead of arriving as an ordinary message.** When someone seals a message — a ceremony at their end where a human approves the exact text — the seal travels with it as proof you can check later. That proof was being dropped on the way into your session: you read the message with no sign it had been sealed and no token to look it up, so evidence the sender had deliberately attached was simply gone at the last step. A sealed message now arrives with its seal shown just above it, naming the token and the two commands that check it — `spt api seal describe ` for the record, and `spt api seal verify ` to confirm the text you received is the text that was approved. The seal is a citation, never a permission: it points at evidence you can verify yourself, and nothing is authorized by its presence. Sealed messages also keep their seal in your session digest, so it is still there when you look back later. ## [0.29.5] - 2026-08-24 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **Updating the adapter from a second-account session no longer reports FAILED.** On a second account (whose plugin store is shared from your main setup), the update's plugin-refresh step was refused by Claude Code — the shared store records paths under your main setup, and Claude Code checks them against the account you're running as — so every update run from such a session ended with a FAILED summary even though the adapter itself updated fine. The refresh now runs against the store's real home, which refreshes it for every account at once. If you saw FAILED there before: nothing was broken — the adapter had updated; this release just makes the summary say so. ## [0.29.4] - 2026-08-24 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **An inline message sent at the very end of a turn now confirms on your next turn — before, it never confirmed at all.** When an agent's last output in a turn carries an inline message to another agent, the message is sent as the turn ends — but a successful send at that moment showed the author nothing, so a delivered message looked identical to a lost one, and the natural defensive move of resending delivered it twice. The confirmation is now held and shown at the start of the author's next activity, clearly marked as the result of the previous turn's send, with an explicit note not to resend. Failed sends keep their existing immediate notice; mid-turn messages are unchanged and still confirm on the spot. ## [0.29.3] - 2026-08-23 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **A second account now shares your plugins, so its first session starts whole.** The first launch on an alt-account profile copies your settings — including which plugins are enabled — but the plugins themselves stayed behind in your main setup, so the new account's first session could start with its plugins listed as on yet not actually there: no adapter hooks, no skills, no way to receive messages, and nothing on screen saying why. The account root now shares your plugin store the same way it already shares your skills and commands — a plugin installed once is present under every account, while which plugins are switched on stays a per-account choice. Accounts set up before this release keep working as they are; to give one the shared store, move its `plugins` folder aside and run `claude-spt alt init ` once. ## [0.29.2] - 2026-08-23 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Added - **The adapter now keeps a record of what happened to every inline message it sends for you.** When you write a message to another agent inline, the adapter sends it and the messaging system answers — delivered, spooled, or failed. For a message sent at the end of a turn, a successful answer used to leave no record anywhere: if the message then never arrived, nothing on either side could say whether it was lost before or after the handoff, which is exactly what made a real lost-message report this week undiagnosable. The adapter's own diagnostic log now records the answer for every inline send, word for word. Nothing about sending changes and nothing new appears in your session — but the next time a message goes missing, the log answers which side lost it. ## [0.29.1] - 2026-08-22 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **A second account no longer needs a setup command — the first launch sets itself up.** v0.29.0 asked you to run `claude-spt alt init ` once before an alt-account endpoint could start, but that binary lives inside the adapter and there was no easy way to run it. Now the first launch of an endpoint on the alt profile notices the account root does not exist and builds it right there — shared work history, seeded trust, everything the command did — then carries straight on to Claude Code's login prompt. Launches after the first find the root in place and start exactly as fast as before. The account name defaults to `alt`, matching the shipped profile, so nothing has to be named or typed; the command still exists for building a root ahead of time or repairing one. ## [0.29.0] - 2026-08-21 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Added - **Run an agent on a second Anthropic account without logging out of the first.** Claude Code holds one account at a time, so running out of tokens on one used to mean logging out, logging in elsewhere, and losing the session you were in the middle of. The adapter can now keep a second account side by side and start an endpoint on it. Set one up once with `claude-spt alt init `, start an endpoint on the matching profile, and log in at Claude Code's own prompt the first time — after that the account is just there. - **Work in progress survives the switch.** Sessions, todos, file history and shell snapshots are shared across your accounts, so a session you started on one account can be resumed on the other and carry on where it stopped. Logins stay separate, as they must; prompt history is the one thing that does not follow a switch. - **The whole endpoint moves, not just the session.** Its Psyche and its end-of-session summary run on the same account you switched to, so nothing is left drawing on the account you just moved off. - **Add your own accounts without waiting for a release.** The adapter ships one worked example (`claude-spt:alt`); `spt adapter create-profile` clones it under your own account name, and that stays put across adapter updates. New in this release: [Alt accounts](https://sabermage.github.io/claude-spt/reference/alt-accounts.html) in the docs. ## [0.28.3] - 2026-08-21 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **Messages you send inline now prove who sent them, like the ones you send from a shell.** spt records who sent a message, and a recipient can write rules about you based on it. That proof was attached when you sent from your own shell, but not when the adapter sent for you from an inline message — so the same agent was identified on one path and anonymous on the other, with nothing at either end showing which. Nothing could be forged by this: an unproven sender makes a recipient's rules stand aside rather than match. But a rule someone wrote naming you would quietly not apply, and on a single machine you would never see it, because messages between agents on one machine skip the check entirely. Both paths now carry the same proof. Update the adapter; the next inline message you send is identified. ## [0.28.2] - 2026-08-21 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Added - **Groundwork, with nothing to see: the adapter now records how it sent a shortform message.** When you write a message inline for another agent, the adapter sends it for you — and there is an open question about whether those sends carry the same proof of who sent them that a message sent from your own shell does. If they do not, a rule the recipient wrote about you would quietly not apply, and neither end would show anything. This release adds a line to the adapter's own diagnostic log recording what the send inherited, so the question can be answered by measurement rather than assumption. Nothing about sending changes, and nothing new appears in your session. ## [0.28.1] - 2026-08-21 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Changed - **Asking for access now explains the choice it makes you make.** Asking an endpoint to let you reach it requires saying which way reach runs for your own side, and there is no default — you either also open yourself to them or you deliberately do not. The tip and the command's instructions now say so up front, including that the same choice applies when you redeem an invite code you were handed, so the first attempt stops failing on a missing flag. - **And it says what declining the reverse direction does not cost you.** Choosing not to open your own side does not silence the other endpoint: they can still answer what you send them. It only stops unsolicited messages. That was easy to read as "they can never write to me", which made the safer choice look more expensive than it is. - **Invite codes now explain who can redeem them.** A code is sealed to subnets — leave the option off and it seals to every subnet you belong to, or name them to narrow it. Someone must share a sealed subnet to use the code at all, so this decides who can redeem, not just how the code is labelled. ## [0.28.0] - 2026-08-21 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **A skill Claude Code picked for itself arrived without its instructions.** You can reach an `/sptc:` command two ways: by typing it, or by describing what you want and letting Claude Code pick the command for you. Only the typed way delivered the command's actual instructions. Picked-for-you calls got the short placeholder page and nothing else, so the agent guessed from `--help` or gave up and did the job the long way — and because the placeholder is written to degrade politely, nothing ever looked wrong. This affected every `/sptc:` command, on every picked-for-you call, since the commands were first slimmed down. Both routes now deliver the same instructions. Update the adapter; the next time Claude Code reaches for an spt command on your behalf, it gets the real thing. ## [0.27.0] - 2026-08-21 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **A session that failed to register no longer tells you it is reachable.** When a session starts, it registers with spt and then opens with a briefing that names your identity and states you hold a live perch. That claim was made whenever the session tried to register — not when it succeeded. So a registration the daemon refused still opened with the full "you are reachable right now" briefing, and you would work on for as long as it took to notice that nothing sent to you was arriving. The briefing now makes that claim only after the registration actually succeeded. - **A refused registration now tells you it was refused, and why.** The daemon explains itself when it turns a registration down — for instance, asking you to name which subnet to bind on a machine that belongs to several. That explanation was written only to a log file nobody reads, so the failure was invisible everywhere you would actually look. A session whose registration is refused now opens by saying it has no perch, is not reachable, and quoting the daemon's refusal word for word. If no explanation came back, it says that plainly rather than guessing at a cause. ### Added - **Groundwork: a caution about an unknown sender will now arrive attached to their message.** When someone you have never classified reaches you through an access rule, spt warns you about them. That warning is moving from a separate arrival to riding on the message it is about, so the caution and the message can no longer be separated — and this release makes sure it survives the step where your session's copy of a delivery is rebuilt. There is nothing to do and nothing to see yet: it takes effect once spt-core ships the change, and until then deliveries look exactly as they do today. ## [0.26.2] - 2026-08-05 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **A note you had written about someone never arrived with their message.** When you record a note about a peer, spt matches it as their message arrives and — because you have already made up your mind about them — deliberately drops the "you have never said anything about this sender" caution that would otherwise ride along. The note itself was then discarded on its way into your session, so a peer you had classified reached you with no caution and no note: they read as an ordinary sender, and nothing indicated either had been decided. Your matched notes now arrive with the message, ahead of it, in your own words, on every delivery path. Update the adapter; the next message from someone you hold a note about carries it. ## [0.26.1] - 2026-08-04 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (unchanged — no reinstall needed). ### Fixed - **Keyword tips never appeared — for anyone, since the feature shipped.** When your message mentioned something spt can do — asking for a knock code, pasting an invite code, wanting to pair machines, wanting to go live — a one-line tip naming the command for it was meant to arrive with that turn. It never did, in any session, for any keyword: the tips were written and shipped but nothing ever delivered them, so the whole feature was silent while looking present. Tips now arrive with the turn, at most once each per session (clearing your context re-arms them), and a turn that already starts with an `/sptc:` command stays quiet rather than telling you to run what you just ran. Update the adapter; the next matching message gets its tip. ## [0.26.0] - 2026-08-04 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton **0.1.18** (structural change — run `/sptc:update` or reinstall the plugin to pick it up). ### Added - **`/sptc:knock` — ask another agent for permission to reach it, and answer the asks you receive.** Knocking is how access is granted between agents: messaging, and the terminal surfaces that let one agent view or drive another's session. It is a different thing from `/sptc:subnet`, which pairs whole machines, and the two were easy to confuse with only one of them having a command. The skill covers the whole set: ask, see what is waiting for you, approve or refuse, mint an invite code to hand out, and redeem one you were given. Knocks stay quiet on purpose — a knock lands in the recipient's inbox and is never pushed at them, so nothing notifies you and nothing polls on your behalf; run the skill to look. That silence is deliberate, not a missed message. ### Changed - **A long-running command run in the foreground now gets a reminder to background it.** Your perch is unreachable for the whole time such a command runs, and this was the most common way agents went quiet without meaning to — builds, releases, test suites and searches across a whole repository. The reminder appears before the command runs, at most three times in a turn so it stays a nudge and never becomes noise. It is advice only: nothing is blocked and no command is refused. ### Fixed - **A message that arrives while you are handing over to your next session is no longer delivered into the session that is about to end.** Saving your context and clearing takes effect at the end of the turn, not the moment you ask for it, and until now anything arriving in that gap was delivered to you anyway — so you would answer it, sometimes write a second handover, and both would be lost when the clear happened. Messages arriving in that window are now held and delivered to your new session instead, which is where you can actually act on them. Messages you send are unaffected and keep going out normally throughout. - **A handover whose clear never happens no longer leaves you unreachable.** The hold above only works while the endpoint is marked busy, so if the clear were lost the endpoint could stay that way and quietly stockpile everything sent to it. Starting any new turn, or starting any new session, now proves the clear did not happen and releases the hold, and a hold older than fifteen minutes releases on its own. Recovery needs nothing from you: the next thing that happens in the session restores delivery. ## [0.25.32] - 2026-08-03 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Plugin skeleton unchanged (**0.1.17**). ### Fixed - **A message you send with the `@<…@>` shortform is no longer reported as undelivered when it was in fact delivered.** The confirmation you get back had one failure verdict — "NO PERCH (not delivered)" — that it used for every unsuccessful outcome, including ones that say nothing at all about the agent you were writing to. Chief among them: the adapter being unable to start the program that performs the send, on a machine briefly short of resources. The message could still be on its way, or already read, while your confirmation stated flatly that the recipient had no perch. The confirmation now distinguishes the recipient genuinely having no perch from a send that failed on your own machine, and when it does not recognise an answer it shows you that answer instead of guessing at a cause. A send that failed locally now says so and tells you to retry, because the old wording invited the opposite response: senders re-sent by another route and concluded a working agent was unreachable, so the observable cost was duplicate messages and a wrong picture of who is online. - **Mid-turn sends are now recorded in the adapter's own log alongside end-of-turn ones.** The shortform dispatches at two different moments, and only one of them left a record, so anyone diagnosing a delivery question could read a complete-looking history that was missing half of what happened — which is how the above went unexplained longer than it should have. Both are now recorded and are distinguishable from each other. ## [0.25.31] - 2026-07-31 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. **Linux users: this release is the fix — see below.** Plugin skeleton unchanged (**0.1.17**). ### Fixed - **The adapter now works on Linux at all.** Every release up to and including 0.25.30 packaged its Linux programs without the permission that marks a file as runnable, so Linux machines received a copy of the adapter they were not allowed to execute. The visible symptom was an update failing with a permission error, but the damage was wider: the adapter could not be run at all on those machines, which means no session hooks and no ability to host an agent there. Windows machines were never affected. The packaging is built on Windows, which has no equivalent permission to carry, so the setting is now applied as the package is assembled rather than inherited from the machine that built it — and the packaging step now refuses to produce a release whose Linux programs are not runnable, which is the check that was missing when this shipped. Reported from a Linux host where the adapter had been silently unusable. - **Release packages are now reproducible.** The package no longer records the building machine's account or local timestamps, so the same inputs produce the same package. ## [0.25.30] - 2026-07-30 > Requires spt-core **v0.27.0 or newer** (unchanged), but the reach described below is only safe on spt-core **v0.46.0+**. Update with `spt adapter update claude-spt`; the brief text rides the adapter, so it takes effect on each agent's next session start. Plugin skeleton **0.1.17** (structural change — run `/sptc:update` or reinstall the plugin to pick it up). ### Changed - **A session with no perch can ask a question and get an answer again.** Guidance for `spt ring` — which sends and then waits for the reply instead of returning immediately — was withdrawn in July after a defect where it could delete the very perch it mistook for absent. That defect is fixed in spt-core v0.46.0, verified on a throwaway endpoint before this guidance returned, so the reach is documented again with its version floor and a plain statement of what older versions did. - **Ring is now presented as the perchless reach only.** An agent that has a perch — however it is hosted — should always use `spt send` and let the reply arrive on its perch; waiting in place is what a session with nowhere to receive needs, and nothing else. The recommendation therefore appears only in the brief a perchless session reads, and a placement check keeps it from drifting into the briefs perched agents see. ## [0.25.29] - 2026-07-29 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; the fix rides the end-of-session summarizer, so it takes effect on the next summarized session. Plugin unchanged (**0.1.16**). ### Fixed - **The end-of-session summarizer no longer mistakes a machine for a teammate.** When a session ends without a formal sign-off, a bounded summarizer distills it into the context that survives into the agent's next session. It had no guidance on what counts as an agent, so it would compile a list of "peer agents" from names appearing in the transcript — and on a live session it promoted the host machine's name into that list, teaching the agent's future sessions to treat a computer as a colleague they could message. The summarizer is now instructed to name another agent only where the transcript shows a direct exchange with it, and never to present machine, host, or node names as agents. Replaying the affected session's exact input confirms the host is now described as the machine it is — or left out entirely. ## [0.25.28] - 2026-07-29 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; hook-carried — takes effect on each agent's next session start. Plugin unchanged (**0.1.16**). ### Fixed - **A background-service restart no longer delivers queued messages into a session that is still inside its usage-limit window.** When the background service restarts, it brings every hosted session back and marks each one available — correct for a healthy session, but for one waiting out its usage limit the mark released the queue a moment before the limit-window guard could re-apply itself, and whatever was queued was delivered into a session that could not respond. Session bring-up, and the routine "session is back at its prompt" recovery, now both check the session's own record first: if the most recent entry is the usage-limit notice, the session is left unavailable and the guard keeps messages queued until one minute past the stated reset. A notice that is merely old history — the session has answered since — never triggers this, so the ordinary stuck-session recoveries are untouched for healthy sessions. ## [0.25.27] - 2026-07-28 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; the hook half takes effect on the next turn, the watcher half rides each endpoint's restart. Plugin unchanged (**0.1.16**). ### Fixed - **The wait-for-reset behavior shipped in 0.25.26 now actually holds.** Two gaps let a limited session become reachable early. First, the recovery that fires when a turn ends in an API error was only skipped when the error was labeled as a rate limit — but in practice the label arrives empty, so the skip never applied and the session was marked reachable moments after hitting its limit, defeating the wait. The limit notice in the session's own record is now the sole test, with the label ignored. Second, the wait was passive: it only refrained from marking the session reachable itself, so any other recovery path could still do so underneath it. The wait is now actively enforced — while a session is inside its limited window, the adapter re-asserts its unavailable status every few seconds, so a stray recovery from any source is corrected within about fifteen seconds and queued messages stay queued until one minute past the stated reset. ## [0.25.26] - 2026-07-28 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; the watcher half rides each endpoint's next restart, the hook half takes effect on the next turn. Plugin unchanged (**0.1.16**). ### Changed - **A session that runs out of its usage limit now becomes reachable one minute after the limit resets, instead of immediately while it still cannot respond.** The limit notice names its own reset time ("You've hit your session limit · resets 7:50pm"), and the adapter now reads it. Previously each recovery marked the session reachable right away, so queued messages were delivered straight into a session that could not act on them — every delivery bounced off the limit, re-queued another recovery, and the message itself was effectively spent. Now the session is deliberately left unavailable for the remainder of the limited window: incoming messages wait safely in the queue, and the adapter marks the session reachable one minute after the stated reset, at which point everything queued arrives at a session that can actually answer. If the notice's time cannot be read, or looks implausible, the adapter falls back to the previous behavior of recovering immediately — the failure direction is always "reachable too early," never "stuck forever." A human waking the session early cancels the wait on its own. ## [0.25.25] - 2026-07-28 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; the fix lives in the per-endpoint watcher, so it takes effect when each hosted endpoint next restarts (or after a node service restart picks up the new binary). Plugin unchanged (**0.1.16**). ### Fixed - **An agent that runs out of its account's session limit no longer stays unreachable after the limit resets.** When a session hits the provider's usage limit, the harness writes a "You've hit your session limit" notice into the transcript and eventually stops attempting requests altogether — at which point it also stops firing the failure signal the adapter uses to mark the endpoint receivable. The endpoint stayed marked busy, every incoming message was queued and never delivered, and the notice itself made things worse: the adapter's stuck-session watcher read it as the agent actively producing output, so the safety net that should have recovered the session concluded the agent had resumed and stood down. The result was an agent that stayed dark past the moment its limit reset until a human intervened. The watcher now recognizes the session-limit notice for what it is: the session is stuck, not working. It marks the endpoint receivable, queued messages deliver, and the first message after the limit resets wakes the agent normally — including when later queued messages have piled on top of the notice, and when the same turn also contains real work from before the limit hit. ## [0.25.24] - 2026-07-27 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; the brief text rides the adapter, so it takes effect on each agent's next session start. Plugin skeleton carries the same warning but ships on its own slower schedule (**0.1.16** unchanged for now). ### Fixed - **Stopped telling agents to run a command that can silently delete their own perch.** A session that appears to have no perch was given `spt ring` as the way to send a message and wait for a reply. A defect in that command (reported across the fleet on 27 July, fix pending upstream) makes it treat an agent whose readiness marker is merely down — during a busy turn, a soft session end, a stale rebind — as having no perch at all, then take over the perch directory it finds and delete it on exit, along with every message spooled in it, leaving nothing in any log. An agent on this machine lost its perch and its queued mail that way. Since the guidance was shown on exactly the same misdetection that triggers the defect, it pointed the sessions most at risk straight at it. The guidance now recommends ordinary sending, explains that a reply needs a perch of your own, and carries the warning in full. ## [0.25.23] - 2026-07-27 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; hook-carried — takes effect on each agent's next turn, no endpoint bounce needed. Plugin unchanged (**0.1.16**). ### Changed - **A peer message that gets spooled now says so, instead of reporting as delivered.** When an agent sends a message with the inline tag form, the recipient may not be listening at that moment — the message is accepted and held until they next take a turn. Until now that outcome was reported to the sender as plain delivery, and at the end of a turn it was not reported at all, so a message sitting in a queue looked exactly like one that was never sent. The mid-turn confirmation now names spooled recipients separately from live ones, and an end-of-turn send that was spooled is written to the adapter's own log — not into the agent's context, since ordinary busy recipients queue all the time and a per-turn notice would be noise. Nothing about delivery itself changed; only what you are told about it. ## [0.25.22] - 2026-07-27 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; hook-carried fix — takes effect on each agent's next turn, no endpoint bounce needed. Plugin unchanged (**0.1.16**). ### Fixed - **Agents on a restarted node no longer lose their save-and-clear ceremony, idle recovery, and clear-boundary handling.** When the background service restarts, it resumes every hosted session with the environment it was originally started with — which still names the previous service's now-dead host process. A safety check added earlier (to stop a session launched from inside an agent's tools from acting as that agent) compared that stale process id against the live one and concluded every resumed agent on the machine was an impostor of itself. The agents looked healthy — ordinary turns kept working — but everything gated behind that check died quietly: an agent writing its save-and-clear note would sit forever with no clear arriving, a manual clear skipped its bookkeeping, and the post-clear session rename never happened. The check now also asks whether the claimed host process is actually alive: a live mismatch is still refused exactly as before (that protection stands), but a dead one is recognized as leftover state from before the restart and lets the agent proceed as itself. ## [0.25.21] - 2026-07-27 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; hook-carried fix — takes effect on each agent's next turn, no endpoint bounce needed. Plugin unchanged (**0.1.16**). ### Fixed - **A peer message written at the very end of a turn now sends when the turn ends, not when the agent next does something.** The previous release taught the turn-end scan to wait briefly for the turn's final output to reach the session record, but only when nothing else was pending there — and on any turn that used a tool, something else always was: the last tool's result. So the scan read that, missed the final message that had not landed yet, and the send waited for the agent's next turn — on a quiet stretch, minutes or hours, which is exactly the window in which it reads as a lost message. The wait is now keyed to the one thing a peer message can ride — the turn's closing output itself — so the send fires at turn end on tool-using turns too. Messages were never lost, only late; this removes the late. ## [0.25.20] - 2026-07-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **Starting a Claude Code session inside an agent's own working directories no longer takes over that agent's identity.** Every spt agent has a private area on disk where its background sessions run. A Claude Code session started by hand in there — to look at something, or to reproduce a problem — inherited the agent's identity from the surrounding shell and claimed the agent's place: it registered itself as that agent, took delivery of a message meant for it, and then exited. The agent was left registered to a session that no longer existed, so nothing could be delivered to it on arrival any more. It kept receiving everything, but only when it next happened to check, which on a quiet stretch meant waiting minutes for a message that was sitting there the whole time — with the agent still shown as online and healthy the entire time. A session running in that area is now recognised as an inner session of the agent that owns it and stays entirely out of the way: it registers nothing, changes no state, and is told nothing about the agent. This is decided from where the session is running, so it holds however the session was started, including by hand with no spt involvement at all. ## [0.25.19] - 2026-07-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **The hook log now says which endpoint each line is about.** One machine can host several agents, and they all write to the same log — so a line recording how a turn was handled could not be attributed to any one of them, and a question as simple as "was this agent marked idle at that minute?" had no answer in it. Each line now names the endpoint whose turn it describes. Nothing else was added: no prompt text, no message content, no session identifier. ## [0.25.18] - 2026-07-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **A Claude Code session started from inside your agent's own work no longer acts as that agent.** When an agent runs a command that opens another Claude Code session, the new session inherited enough of the original's setup to be mistaken for it — so it answered as your agent, marked your agent busy, and took delivery of messages meant for it, which then reached nobody. It could also take over your agent's saved place: the session an endpoint is pinned to, the instruction waiting for it after a context reset, its role. A session now has to prove the endpoint is its own before anything is written against it, and where there is nothing to prove it with, the session that owns the endpoint is identified by the Claude Code process the endpoint was started with. Nothing changes for a normal session; a borrowed one now does nothing at all, and says so in the hook log. ## [0.25.17] - 2026-07-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **A message too large to show inline can no longer go missing on the way to the file it is written to.** Large deliveries are written to a file and announced with a short note telling the agent to read it — but the note itself could fail in three ways, each looking exactly like a message that was never delivered at all. If the file could not be written, the note pointed at a file that did not exist and the message was discarded anyway; it now says plainly that the file could not be written, shows as much of the message as will fit, says where the rest can still be recovered from, and keeps the message queued for the next attempt instead of throwing it away. If an earlier large delivery had not been read yet, only one of the three places these notes are produced mentioned it — the other two, including the one that handles messages arriving while the agent is working, never did; all three now do. And on a busy session the list of earlier files grew until the note itself was too large to show, which silently cut it off: the list is now capped, keeping the oldest entries and counting the rest, so the note always arrives whole. ## [0.25.16] - 2026-07-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **A message your agent sends as the last thing it says now goes out immediately, instead of waiting until your agent does something else.** When an agent addressed a peer inline at the very end of its turn, the message was not actually sent at that point — it went out the next time that agent did anything at all. If the agent carried straight on working, the next thing happened seconds later and delivery looked instant, which is why this went unnoticed. But an agent that signs off with a message and then sits idle left it undelivered for as long as the idle lasted, with nothing to show it was still waiting: the sender believed it had sent, the recipient never got it, and the silence read as an unresponsive peer. Today one such message sat for thirteen minutes. The end-of-turn send now waits the moment it needs to for the turn to be finished being written, and goes out there and then. - **The very first message an agent sends on a newly-set-up endpoint is no longer dropped.** Setting up an endpoint deliberately ignores everything already in the conversation, so that old messages are not re-sent — but that also discarded anything the agent said in the turn where setup happened, silently and with no error. Only genuinely earlier conversation is skipped now; what the agent says in that turn is sent like any other message. ## [0.25.15] - 2026-07-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **A live agent's companion no longer looks broken when the problem is really a billing limit.** The companion that carries an agent's context between sessions runs a Claude Code session of its own, which is billed to an account — and when that account is refused, the companion simply failed, indistinguishably from a genuine fault. Whoever was triaging then went looking for a bug that does not exist: this week that exact confusion sent three people hunting a phantom fault for hours. An account refusal is now reported as what it is — an outage, not a fault — saying plainly that nothing is broken, that the session and its stored context are intact and untouched, and that a person needs to clear the limit on the account before anything will change, along with what the refused session actually said. The message names the cause and the fix in one line. - Note on what is and is not in this release: the clear reporting is here now. The companion also signals the refusal to spt itself in a way spt can act on, but *acting* on it — spacing the retries far apart instead of retrying at the normal rate, and keeping a long outage from counting against the companion as though it were malfunctioning — arrives in a future spt release. Until then the behaviour is exactly as before; only the reporting improves. Nothing needs updating twice and no version pinning is required. ## [0.25.14] - 2026-07-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **When a live agent's companion fails a turn, the failure now says what actually went wrong.** The companion that carries an agent's context between sessions runs a Claude Code session of its own, and when that session failed for a reason the adapter could not recognise, all that was recorded was that it had exited — nothing about why. That is exactly the case where the reason matters most: a recognised failure is repaired automatically, while an unrecognised one is retried unchanged, so an agent whose companion is failing for an unrecognised reason retries forever with no diagnosis available anywhere. The failure now carries what the inner session reported on both of its output channels, trimmed to a sane length, and says so explicitly when a channel was silent — silence being itself the thing worth knowing. In a live investigation this week the missing detail was the whole obstacle, and no repair was possible until it was recovered by hand. ## [0.25.13] - 2026-07-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **A Claude Code session started from inside a live agent's own work no longer acts as that agent.** When an agent launched a session from its own tooling, the new session inherited enough of the agent's environment to be mistaken for it — so it reported activity under the *agent's* identity and re-pointed that agent's session, which is what the digest and every summary of the agent's work are read from. The agent then went quiet to everyone watching while the session that stole its place looked perfectly healthy; in the field this happened to a live agent and had to be repaired by hand. A session now proves its own identity or gets none at all: one that has no endpoint of its own simply does nothing, instead of speaking for its parent. Agents that legitimately own their session are unaffected. ## [0.25.12] - 2026-07-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **A session that spt only reached after it had already started no longer perches into permanent silence.** If sptc became available part-way through a Claude Code session, that session never got its start-of-session setup — and because reloading plugins brings the skills and commands straight back, it looked completely healthy afterwards. A perch made from such a session was bound to a placeholder conversation rather than the real one, so its digest could never find anything to read: the endpoint looked idle to every peer, its Psyche synced no context, and nothing anywhere reported a problem (one endpoint in the field ran this way for two days before anyone noticed). Such a session is now registered on its first prompt and told plainly what is missing, and `/sptc:ready` and `/sptc:live` now hand you the exact bringup command that binds the real session. Where nothing can be recovered in place, you get a clear instruction to restart the session instead — and a warning that reloading plugins is not the cure, however healthy it makes the session look. - **A digest that comes back empty now says why.** Reading an endpoint's recent activity could return nothing at all, with no explanation — which is indistinguishable from an agent that simply has nothing to report, so an endpoint whose turns were being dropped read as a quiet one and stayed unexamined. When the session is found but none of your typed turns come through, that is now reported as a fault; when the session genuinely has no turn yet, that is said too, so the two can be told apart. A healthy read stays silent as before. ## [0.25.11] - 2026-07-26 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **A long start-of-session briefing is no longer destroyed by the next thing that arrives.** When a delivery is too large to hand your agent inline, it is written to a file and your agent is pointed at it — but every delivery reused the same file, so a later one could overwrite an earlier one that had not been read yet. In the field this wiped an agent's entire start brief — its identity, its role, and the context it needed to resume after a reset — and left nothing behind to show a brief had ever been there. Each delivery now gets its own file and is never overwritten, and every new pointer also names the ones still waiting from earlier in the session, so nothing goes unread. - **Messages that quote a command or a snippet of code are now actually sent.** When your agent addresses a peer inline, anything it wrote inside backticks confused the reader that finds those messages — so a message whose text quoted a command was dropped in full: it was never sent, and no error was reported anywhere. The agent had every reason to think it had been delivered, and read the peer's silence as the peer being unresponsive. Quoted code inside a message is now treated as ordinary text and the message goes out intact. ## [0.25.10] - 2026-07-25 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **An endpoint no longer goes dark in `spt endpoint digest` after starting under a different Claude Code configuration.** The digest reads your agent's live session, and the location it reads from was captured once when the endpoint bound — so if a later session started from a different Claude Code configuration root, the digest kept looking in the old place, found nothing, and reported nothing. The endpoint stayed silent for the rest of the session: peers reading it saw no activity, the Psyche synced no context, and anything steered through the digest stopped responding — with no error anywhere to explain it. The digest now finds your session wherever it actually lives, and when it genuinely cannot find it, it says so instead of returning empty. ## [0.25.9] - 2026-07-25 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **Your agent's start-of-session briefing no longer gets silently cut off.** Claude Code caps the extra context a hook can inject at about 2 KB and drops anything past it with no warning — so a longer start brief (your agent's identity, role, and the resume context it needs after a reset) was losing its tail, and the agent could come back not knowing who it was or what it was working on. The brief now stays within the limit: what fits is shown inline, and anything longer is written in full to a file with a clear, up-front instruction to read it first — so nothing is lost and your agent always gets its full context. ## [0.25.8] - 2026-07-24 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **Messages for your agent no longer get swallowed by a subagent it spawned.** When your agent ran a background subagent (an Agent/Task tool), a message that arrived mid-run could be delivered into the *subagent's* context instead of your agent's main conversation — where it might be relayed as an unverifiable second-hand claim, summarized, or quietly dropped, while your agent's main thread never saw it. Incoming messages now surface only in the main conversation; anything that arrives while a subagent is working is held and handed over the moment your agent takes its next step. ## [0.25.7] - 2026-07-22 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **Your hooks and plugins no longer run inside spt's own background sessions.** A live agent's Psyche and its end-of-session summarizer run as separate Claude Code sessions behind the scenes, and until now those sessions loaded your full configuration — so hooks and plugins you installed for yourself fired in sessions you never started, and a hook that reshapes how the agent talks could quietly distort the summaries your agent depends on across resets. These internal sessions now run cleanly isolated: no user hooks, no plugins, no memory files — just your normal login. Your own sessions are untouched; everything you installed still works exactly as before wherever you work. ## [0.25.6] - 2026-07-21 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **A message arriving just before `/compact` no longer sits unread until you next type something.** If a message reached an agent moments before its operator compacted the session, the compact could swallow the delivery — the message was kept safely, but the agent was left looking busy, so nothing more was delivered and the held message waited for a human to type (three quarters of an hour, in the field). After a compact you started finishes, the agent is now marked reachable again and any held messages are handed to it immediately, with a short note explaining the redelivery. Automatic compactions that happen while the agent is mid-task are left alone — the work in flight picks the held messages up itself. ## [0.25.5] - 2026-07-20 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Plugin unchanged (**0.1.16**). ### Fixed - **Watching a live agent's session no longer jumps around on its own.** Every live agent runs a background check that reads its own recent history, and that read was quietly resetting how much history everyone else saw — so anyone following a session (you, a tool, another agent) got the view yanked to a different depth and redrawn from scratch every 15 seconds, on every agent on the machine. The check now reads without changing anything, and follows stay steady. Interrupt recovery is unaffected and still looks back over the same amount of history. ## [0.25.4] - 2026-07-19 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. Ships alongside sptc plugin **0.1.16** — update the plugin too (`claude plugin install sptc@cplugs`), as the two halves reference each other. ### Fixed - **Going live no longer makes the agent stop and read a file first.** The instructions for `/sptc:live` had grown past what Claude Code will carry inline, so every single bringup was written to a file the agent had to open before it could do anything — slow, and easy to mistake for something being broken. The instructions are now assembled for the session actually in front of you: a session the daemon already launched no longer receives the several pages about arming a listener it must not arm, and a session you launched yourself no longer receives the part explaining why it should skip that step. Both now arrive inline, with room to spare. - **A live agent going live in a daemon-launched session is no longer told its upkeep twice.** Instructions for communing and signing off already arrive when such a session starts, so the go-live moment no longer repeats them. ## [0.25.3] - 2026-07-19 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. ### Fixed - **Typing the short form of a skill — `/ready terminus`, `/live perri` — now works.** Claude Code accepts the short name whenever it is unambiguous, but only the fully written out `/sptc:ready` form reached the adapter, so the short form arrived with none of the skill's instructions attached. The agent was left holding an empty stub, and the stub told it to go check whether spt was installed — turning a one-step bringup into a multi-step hunt through your machine, which is exactly what a stuck `/ready` looked like in the field. Every skill now answers to both forms, and a command that starts with a stray blank line (a paste, or a multi-line input box) resolves too. - **When a skill's instructions do not arrive, bringup now costs one step instead of five.** Each skill stub now carries the single command that does its own job, so `/ready` and `/live` still come up in one action even if the instructions go missing; `/sptc:setup` is suggested only when spt itself is actually absent. ## [0.25.2] - 2026-07-19 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. ### Fixed - **An interrupted live agent no longer gets stuck when its session summary lands right after the interrupt.** After you press Esc, a background watcher restores the agent within about 15 seconds — unless it mistook routine background bookkeeping for the agent going back to work. Because that bookkeeping is filed against the interrupted moment itself, the watcher concluded the agent had moved on, stood down, and left it marked busy and quietly not receiving messages (over half an hour in the field) until someone recovered it by hand. The watcher now only counts the agent actually working — its replies and tool use — and never reads the interrupted moment as a resume. ## [0.25.1] - 2026-07-18 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. ### Fixed - **A live agent you interrupt now recovers on its own even if a message arrived right as you interrupted it.** When you press Esc to interrupt an agent mid-task, no clean end-of-turn signal fires, so the agent is briefly left marked busy; a background watcher notices and restores it within about 15 seconds. Previously that watcher only looked at the single most recent moment of activity — so if a message landed in the instant right after you interrupted, the incoming message hid the interrupt from the watcher and the agent stayed stuck (marked busy, quietly not receiving) until someone recovered it by hand. The watcher now looks at a short window of recent activity, so it still spots the interrupt, recovers the agent, and drains any messages that piled up while it was stuck. ## [0.25.0] - 2026-07-18 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start — bounce your endpoints to pick it up. ### Fixed - **Notifications and gateway messages now reach an idle live agent the same reliable way peer messages do.** Until now only agent-to-agent messages were handed to an idle live agent as a compact prompt with the full text following; notifications (such as the spt-core update notice) and messages arriving through a gateway — including ones you send from your own phone or terminal — were instead typed in full into the input box, a less reliable path. They now all use the same delivery, so an idle live agent receives every kind of message consistently. The spt-core update prompt still appears whether that notice reaches your agent while it is idle or mid-task. - **Messages delivered to an idle live agent no longer leave stray leftover text.** Delivery now pauses briefly after each send so the message submits cleanly, without a fragment occasionally trailing into the sent turn. ## [0.24.1] - 2026-07-16 > Requires spt-core **v0.27.0 or newer** (unchanged), and is **required before updating a node to spt-core v0.33.0**. Update with `spt adapter update claude-spt`; takes effect on an endpoint's next start. ### Fixed - **Compatibility with spt-core v0.33.0's new identity command.** The upcoming core release changes what `spt whoami` reports. The adapter now understands both the new and the old form, so sessions keep resolving their own identity across the core update. Without this, a node updated to the new core would have agents silently lose their identity in ordinary (non-spt-hosted) sessions — messages, presence marks, and session briefs would stop working. Update the adapter first, then the core, on every node. ## [0.24.0] - 2026-07-16 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. **Takes effect on an endpoint's next start — bounce your endpoints to pick it up** (the fixes ride the hook binary and the skill instructions). ### Fixed - **Going live on Windows no longer fails with an empty anchor.** On some Windows sessions the adapter could not learn the Claude Code process id at session start, so `/sptc:live` bringup failed with a usage error and agents had to hunt the pid down by hand. The adapter now resolves the real Claude Code process itself by walking the live process tree, which also repairs session registration on those machines; and the live skill now checks the anchor before running the connection command, with the manual fallback spelled out up front. - **A peer message that fails to deliver is no longer silent.** When an agent's embedded `@<…@>` send at the very end of a turn could not be delivered (the target was not reachable), the failure notice was discarded and the sender never learned anything happened. Delivery failures now come back to the sender as a message; successful sends at end-of-turn stay quiet as before. ### Changed - **The context-reset signaling finishes its rename.** The adapter now emits the new wake-format signals introduced last release (every updated installation already understands them). The legacy `!!checkpoint!!` marker and old-format signals are still accepted for one more release — update your nodes before the next one if you have agents relying on the old spelling. ## [0.23.0] - 2026-07-16 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`, then `/reload-plugins` in active Claude Code sessions — this release also updates the plugin skills. Live endpoints pick up the new adapter on their next start. ### Changed - **"Checkpoint" is now "commune across."** The agent-driven context reset is asked for with `/sptc:commune --across` (or by telling your agent "commune across" / "commune to next session"), and the marker an agent embeds in its commune is now `!!wake!!` — a pair of markers brackets the wake message the next session opens with. The old `!!checkpoint!!` marker still works for this one release so nothing in flight breaks. The rename avoids a collision: Claude Code now ships its own unrelated `/checkpoint` command. ### Fixed - **A fresh installation can no longer silently skip the Claude Code plugin.** Installing or updating the adapter now verifies that the plugin marketplace and the sptc plugin actually landed before reporting success — a verified install prints a clear `✔ VERIFIED` line, and any failure stops loudly with the real error and a nonzero exit instead of a friendly notice over a missing plugin. ### Added - **The adapter installs Claude Code itself when missing.** On a machine with no `claude` (or `ccs`) command, installing or updating the adapter now runs the official Claude Code installer automatically, then continues. You still log in yourself: run `claude` once afterward. ## [0.22.0] - 2026-07-15 > Requires spt-core **v0.27.0 or newer** (unchanged). **One-time migration release:** the adapter's update channel moves to its new private development home. Run the per-platform migration script from the internal announcement once per node — it repoints the installed adapter and updates it in place. After that, `spt adapter update claude-spt` behaves exactly as before. Endpoints need no action; the updated adapter rides each endpoint's next start. ### Changed - **The adapter now lives in, and updates from, a private development home.** All releases publish there going forward; the old public repository remains readable as a source mirror but receives no new releases. Nodes already authenticated with the GitHub CLI keep the same update experience — only the source repository coordinate changes. - No functional changes otherwise: this is the relocation cut. ## [0.21.0] - 2026-07-15 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. **Takes effect on an endpoint's next start — bounce your endpoints to pick it up** (the fix rides the hook binary). ### Fixed - **An agent's turn bookkeeping no longer risks being killed by Claude Code's ~30-second limit on busy nodes.** Working out "which endpoint is this session" used a command that, on current spt-core, renders the full endpoint listing — walking every perch's project history (measured at 45 seconds on a loaded node). When that overran, the turn's bookkeeping died with it: the perch never marked busy, deferred messages never drained, and after a turn the perch could stay stuck busy and black-hole incoming messages. An spt-hosted session now proves its identity locally and instantly at every step — prompt start, tool calls, turn end, session end, and subagent starts. Sessions without that local proof (hand-launched live agents) still resolve the old way, which remains slow-node-vulnerable until spt-core ships a narrow identity-only lookup — a known, tracked limitation. - **A message could arrive as a bare marker with its text gone.** The held message body was consumed *before* the slow identity step — so when the time limit killed the turn-start work, the body was already gone and never reached the agent, while the sender's side correctly showed it as delivered. Message pickup is now transactional: the body is only discarded after it has actually been handed to the agent, anything in flight when a kill lands is redelivered on the next prompt, and the slow steps run before any pickup. A kill can now only cause a duplicate delivery, never a silent loss. - **A session that failed to register no longer corrupts its own recovery.** The adapter's session record used to advance even when the perch refused the registration, which poisoned the proof needed for the next `/clear` rotation. It now advances only after a successful registration. ### Added - **Per-stage timing trace at every prompt start.** Each prompt's turn-start work now writes one timing line to the adapter's `hook-trace.log`, naming how long each stage took and which identity path ran — work creeping toward the time limit now names the guilty stage instead of dying silently. No prompt or message text is ever logged. ### Changed - **Shortform messaging reframed.** The `@<…@>` tag is now taught as the fastest method for sending short messages and replies to one or more agents; longer messages should leverage the `spt send` CLI. ## [0.20.1] - 2026-07-10 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Takes effect on an endpoint's next start. **Nodes now need the GitHub CLI (`gh`) installed and authenticated with read access to the adapter's repository — see below.** ### Changed - **Adapter updates and installs now fetch through the GitHub CLI.** The adapter's home repository is now private, so the plain unauthenticated download path no longer works. Updates (`spt adapter update claude-spt`) and first installs (`spt adapter add --release`) ride your existing `gh` login (OAuth or `GH_TOKEN`) — no token is stored by spt. If a node has no `gh` or no repository access, updates fail loudly instead of silently trying a download that cannot succeed. ### Fixed - **An agent's identity now reaches the commands it runs.** Session identity was visible inside the agent's shell but not to programs the shell launched — so `spt send` run by an agent could go out stamped as the machine's command line rather than the agent, and replies to it could fail to route back. Identity is now persisted the way the harness expects, and messages sent from an agent's shell carry the agent's own name as sender. Pairs with spt-core **v0.31.0** (which fixed the core half of sender stamping); update both for the full effect. Existing sessions pick the fix up on their next start. ## [0.20.0] - 2026-07-10 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Takes effect on an endpoint's next start. ### Changed - **Messages that arrive while an agent is idle now land as a compact marker instead of the full text being typed into the input box.** Before, the whole message body was typed into the agent's session character by character — long messages were slow to arrive and vulnerable to garbling in transit. Now only a tiny marker is typed, and the full message body is handed to the agent inside the turn it wakes. Messages that queued up while the agent was away all arrive together on the first marker. - **The wake after a checkpoint is a compact marker too.** When an agent saves and clears, the wake instruction no longer rides the input box as a full paragraph — the marker wakes the refreshed session and the saved wake directive (including any custom wake text) arrives inside that turn. This closes the last case where a long text was typed at a session boundary. - **A delivered message can never sit undelivered past the agent's next activity.** If the marker races with the agent starting new work at that exact moment, the message body is handed over at the agent's next prompt or next tool use instead of waiting — delivery is bounded, never stalled. - **Session digests are more complete and easier to read.** Messages delivered to a busy agent mid-turn now show up in the digest (they were previously invisible), slash commands render as the bare command line instead of tag soup, internal boilerplate lines are stripped, and a marker turn merges with the messages it delivered into one record. ## [0.19.0] - 2026-07-10 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Takes effect on an endpoint's next start. ### Added - **Spawned agents now pace themselves for long autonomous runs.** Every spt-hosted session starts with a standing work-discipline briefing: keep the context window under about half full, checkpoint after each substantial body of work (recording next steps and the project's status and end goal), keep background work running straight through a checkpoint — it carries across and comes back to the refreshed session — and keep looping through checkpoint cycles until the goal is met. The briefing re-arrives after every checkpoint, so the discipline survives the agent's own context resets. Sessions you launch by hand are unaffected. ## [0.18.8] - 2026-07-10 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Takes effect on an endpoint's next start. **For the full effect on a node whose daemon was restarted from inside an agent session, also restart the spt daemon from a clean shell after updating.** ### Fixed - **A Psyche can no longer silently take over a live agent's seat.** A Psyche's background turns could inherit a stray agent identity from the environment and, every pulse, re-register that agent's perch as their own — the victim stayed "online" but its incoming messages drained into the Psyche's private transcript, its communes and pulses went dark, and its outgoing messages lost their sender name. Psyche and end-of-session summarizer turns are now fully identity-scrubbed and hook-inert: they can never seed, bind, or rebind any perch, no matter what environment they were spawned with. ## [0.18.7] - 2026-07-09 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Takes effect on an endpoint's next start. ### Fixed - **The `@<…@>` message shortcut no longer pings the sender back a turn later with its own "delivered" note.** When an agent fanned a message to peers with the inline `@` tag, the "delivered → …" confirmation could resurface as an unexpected incoming message on a *later*, unrelated turn. The confirmation now appears inline in the same turn the agent sent from — where it belongs, since it's what stops the agent re-sending by hand — and is dropped when the tag was the turn's final output. Peer delivery is unchanged. ## [0.18.6] - 2026-07-09 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Takes effect on an endpoint's next start. ### Fixed - **Agents no longer misread a `QUEUED` send as "the other agent is offline."** The messaging guidance told agents that `QUEUED` meant the target was offline. In fact it only means the target isn't draining its listener at that instant — which is just as often a *busy* live agent as an offline one; either way the message is spooled and delivers on the target's next listen. The guidance now says so plainly (QUEUED = success, offline-or-busy, do not retry), so agents stop treating a perfectly-delivered queued message as a failed send. ## [0.18.5] - 2026-07-09 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Takes effect on an endpoint's next start. ### Changed - **Checkpointing is clearer to your live agent.** When you ask a live agent to "checkpoint" (or "save and clear" / "compact and continue"), it now reliably runs a real checkpoint — a commune that also refreshes its own context window and resumes where it left off — instead of just quietly saving a note. And it no longer hesitates: the guidance now spells out that a checkpoint keeps the agent live and reachable the whole time (it does not sign the agent off or take its perch down), so agents stop avoiding it out of a mistaken worry about going offline. ### Fixed - **Delivered messages submit more reliably.** Slightly more settle time is allowed before the Enter that submits an injected message, wake, or `/clear` to a live session — closing an occasional race where a long message could land as a newline in the input box instead of being submitted. ## [plugin 0.1.13] - 2026-07-09 > **Plugin skeleton update only** (no adapter change). Pick it up with `claude plugin install sptc@cplugs` then `/reload-plugins` — the version-of-truth in `/sptc:version` is unchanged. ### Added - **Every `/sptc:*` command now shows its expected arguments as you type it.** Typing `/sptc:` in Claude Code now displays an argument hint next to each command — e.g. `/sptc:live` shows `[] [--auto]`, `/sptc:ready` shows `[] [--once]`, `/sptc:role` shows `[] [--include-desc]`, `/sptc:subnet` shows `[status|create|show-code|join]`. Commands that take no arguments are marked as such. Makes the whole command surface self-describing without reaching for the docs. ## [0.18.4] - 2026-07-09 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Takes effect on an endpoint's next start. ### Added - **Going live is more informed and asks the right question.** When you run `/sptc:live`, the agent now sees the node's full endpoint + subnet roster up front — so it knows at a glance whether that name is already live, exists but offline, or is brand new. For a brand-new agent on a machine that belongs to more than one subnet, it now asks which subnet to home you in instead of guessing or erroring. And a returning live agent now reloads its saved context (role, working notes) as it comes online, so it resumes where it left off. ## [0.18.3] - 2026-07-09 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Takes effect on an endpoint's next start. ### Fixed - **`/sptc:live` no longer trips over a bad process id on headless/git-bash setups.** A follow-up to the previous fix: in some shells the adapter was handing `/sptc:live` a bogus anchor id (a stray `1`), which could send it down the wrong path. The adapter now only passes that hint when it's trustworthy and otherwise lets `/sptc:live` find the right process itself — and the steps also check your subnet up front to avoid an extra retry on multi-subnet machines. (Thanks again to hertz.) ## [0.18.2] - 2026-07-09 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. Takes effect on an endpoint's next start. ### Fixed - **Going live with `/sptc:live` now works on a normal session on the first try.** Bringing a regular (self-launched) Claude Code session live could previously fail with a string of `ADAPTER_UNRESOLVED` / `NO_SEED` errors that took several manual command tweaks to get past — because the background relay runs under a helper shell that confused the auto-detection. The `/sptc:live` steps now use the reliable form directly, so the relay binds cleanly the first time. (Thanks to hertz for the detailed report.) ## [0.18.1] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`. No behavior change — a platform-compatibility addition only. ### Added - **Runs on older/static Linux hosts now.** The adapter package now includes a static (musl) Linux build alongside the standard one, so it installs and runs on Linux systems too old for the default build (pre-glibc-2.39) — matching spt-core v0.30.0's new musl support. On every other system nothing changes; the right build is picked automatically. ## [0.18.0] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). Update with `spt adapter update claude-spt`; to also pick up the new `/sptc:role` command, reinstall the plugin skeleton (`claude plugin install sptc@cplugs` + `/reload-plugins`). Takes effect on an endpoint's next start. ### Added - **New `/sptc:role` command — view or edit this agent's durable role.** Run `/sptc:role` on a live session and your current role opens as an editable draft right in the input box; tweak it and press enter to save. Add a directive to change it in words (`/sptc:role make it more senior`), or `--include-desc` to also edit the short service description. The role is what an agent leads with everywhere it appears, so this makes it easy to keep sharp. ### Changed - **You now get a heads-up when your spt-core is actually out of date.** When an update notice arrives and this machine is genuinely behind, the agent is reminded to run `spt update apply` at a safe moment — and only then. Once you update, the reminder stops on its own. It deliberately won't auto-dismiss the notice (dismissing hides it for every other machine that hasn't updated yet). - **Agents no longer wait around watching a commune file "disappear."** The save-your-context step is now correctly described as fire-and-forget, so an agent writes it and moves on instead of polling for a confirmation that isn't a reliable signal. ## [0.17.4] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). **Update-only** — `spt adapter update claude-spt` is the whole update. Takes effect on an endpoint's next start. ### Changed - **Agents now use the reliable commune path.** The "start a reply with `>>commune<<`" shortcut is no longer suggested to agents — in practice the marker had to be the very first thing in the reply, which agents routinely missed, so a commune could silently fail to save. Agents now commune via `/sptc:commune` (or by writing the commune file), which always works. The shortcut still functions if invoked correctly; it is simply no longer advertised. - **The message shortcut is now framed for what it's best at — reaching many agents at once.** `@` is taught as the primary way to send the same message to several agents in one go; for a single-target send, agents with a shell are steered to the direct `spt send` command. Nothing about how the shortcut works changed. ## [0.17.3] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). **Binary-only** — `spt adapter update claude-spt` is the whole update. Takes effect on an endpoint's next start. ### Fixed - **The message shortcut no longer cries "not delivered" when it actually delivered.** Sending with `@` would tell you the peer "wasn't reachable" even though the message had arrived — so you'd needlessly re-send by hand. The delivered/not-delivered confirmation is now correct. (Messaging to yourself was never affected.) ### Changed - **Communes now file project detail under the project, not your permanent identity.** When you commune (or when a session is auto-summarized), detail specific to the project you're in is kept separate from your cross-project, standing context — so your durable memory stays clean and project notes don't bleed between projects. Wrap project detail in `…` and identity/role context in `…`; anything left untagged is treated as standing context. ## [0.17.2] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). **Binary-only** — `spt adapter update claude-spt` is the whole update. Takes effect on an endpoint's next start. ### Fixed - **A message shortcut written as the last thing in a reply now actually sends.** Previously, if the `@<…@>` tag (or a `>>commune<<`) was the very last output of a turn — the normal "fire it off and wait for a reply" case — it wasn't delivered until you next did something, so a send-then-wait could hang. It's now delivered the moment the turn ends, for both live and daemon-hosted agents. Tags written mid-reply were unaffected and still work. ## [0.17.1] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). **Binary-only** — `spt adapter update claude-spt` is the whole update. Takes effect on an endpoint's next start. ### Fixed - **The message shortcut no longer fires when you're just *talking about* it.** In 0.17.0, writing an example of the `@<…@>` form in a reply — even wrapped in backticks — could actually send it. Now a tag only sends when written plainly; any tag inside inline-code (backticks) or a code block is treated as a quotation and ignored. Write a real send bare; show an example in backticks. ## [0.17.0] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). **Binary-only** for the feature — `spt adapter update claude-spt` is the whole update (the send-skill help note also refreshes if you reinstall the plugin skeleton). Takes effect on an endpoint's **next start** — restart (or re-launch) a daemon-launched endpoint to activate it on an already-running session. ### Added - **Message another agent without leaving your train of thought — no shell command needed.** Write `@` anywhere in a reply and the adapter delivers "hey, can you check the deploy?" to `alice`, then tells you (in your next context) whether it landed or the agent wasn't reachable. Send to several at once with `@`. Only that exact `@<…@>` form sends, so you can still talk *about* the syntax without firing anything. - **Save a working-context note the same way.** Start a message with `>>commune<<` and the rest becomes your commune (the context hand-off that survives a reset) — the same result as writing the commune file by hand, without the file step. Include `!!checkpoint!!` in it to also reset-and-rebuild your context from that note. ## [0.16.2] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). **Binary-only** — `spt adapter update claude-spt` is the whole update. Note: this heal rides the endpoint's background delivery process, so it takes effect on an endpoint's **next start** — restart (or re-launch) a daemon-launched endpoint to activate it on an already-running session. ### Fixed - **A daemon-launched endpoint interrupted with Esc no longer goes deaf.** Pressing Esc to interrupt a running turn — whether a tool was mid-flight or the agent was just thinking — used to leave the endpoint looking online while silently queuing every incoming message, sometimes for many minutes, until the next thing you typed flushed the backlog. The endpoint now notices it's sitting at an interrupted prompt and returns itself to ready-to-receive within ~15 seconds, so queued messages are delivered. To recover an already-stuck endpoint immediately, send it any message once it's back at an idle prompt, or restart it. ## [0.16.1] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). **Binary-only** — `spt adapter update claude-spt` is the whole update; no plugin reinstall or `/reload-plugins` needed. ### Fixed - **Follow-up to 0.16.0: the interrupted-turn recovery now actually takes effect on daemon-launched endpoints.** In 0.16.0 the recovery could silently fail to register (an ownership-check mismatch), so an endpoint interrupted mid-turn could still stop receiving. It now reliably marks the endpoint ready-to-receive again after an interrupt. Also adds a local diagnostic log (`hook-trace.log`, next to the adapter binary) recording endpoint lifecycle events, to make this class of issue observable. ## [0.16.0] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). Binary + plugin skeleton change. **Two-part update:** `spt adapter update claude-spt` picks up the binary; the new failure hooks require the refreshed plugin skeleton — reinstall the `sptc` plugin and run `/reload-plugins` (or restart Claude Code) to activate them. **Recommended for anyone running daemon-launched Claude Code endpoints.** ### Fixed - **A daemon-launched endpoint no longer goes deaf after an interrupted or errored turn.** Pressing Esc during a running tool, or a turn that ends with an API error (rate limit, server error), used to leave the endpoint looking online while silently queuing every incoming message instead of delivering it — until the next thing you typed happened to flush the backlog. The endpoint now returns to ready-to-receive the moment such a turn ends, so messages are delivered right away. Anything queued in the meantime is delivered as soon as it goes ready — nothing is lost. To recover an already-stuck endpoint immediately, send it any message once it's idle, or restart it. ## [0.15.9] - 2026-07-08 > Requires spt-core **v0.27.0 or newer** (unchanged). Binary + plugin skeleton change. **Two-part update:** `spt adapter update claude-spt` picks up the binary fix; the new idle notification requires the refreshed plugin skeleton — reinstall the `sptc` plugin and run `/reload-plugins` (or restart Claude Code) to activate it. **Recommended for anyone running daemon-launched Claude Code endpoints.** ### Fixed - **A daemon-launched endpoint that hasn't taken a turn yet no longer silently swallows every message sent to it.** A freshly-launched endpoint (or one whose only input so far was a client-side command like `/login`, which never produces a full turn) was treated as permanently busy, so incoming messages were queued and never delivered — the endpoint looked online and healthy while receiving nothing. Endpoints are now marked ready-to-receive as soon as they start, and re-marked ready whenever they return to an idle prompt, so messages are delivered instead of piling up. Any messages that were queued this way are delivered as soon as the endpoint next goes idle — nothing is lost. To recover an already-stuck endpoint immediately, send it any message once it's idle, or restart it. ## [0.15.8] - 2026-07-07 > Requires spt-core **v0.27.0 or newer** (unchanged). Instruction-only change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. Takes effect at the next endpoint launch; fully forward-safe on current spt-core and activates automatically once the matching spt-core release is deployed. ### Added - **Opt-in delivery verification for messages injected into a session.** The adapter now enables spt-core's echo-verification belt for Claude Code sessions: because the Claude Code terminal re-renders text that is typed into it, spt-core can confirm an injected message actually landed. This is off by default in spt-core and the adapter now turns it on for Claude Code. It stays dormant on spt-core versions that don't yet support it and switches on by itself once a supporting spt-core is installed — no configuration and no forced upgrade. ## [0.15.7] - 2026-07-07 > Requires spt-core **v0.27.0 or newer** (unchanged). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. Takes effect immediately after the update — no session restarts needed. Recommended for anyone who uses Claude Code's `/resume` on a daemon-launched endpoint. ### Fixed - **Using Claude Code's `/resume` inside a daemon-launched endpoint no longer makes it silently unreachable.** When an endpoint launched by the spt daemon switched conversations with the in-app `/resume` command, its perch could quietly detach from the live session — the endpoint still looked healthy and running, but messages sent to it went nowhere and the failure was never surfaced. Resuming now re-attaches the perch to the resumed conversation correctly, and if the re-attach is ever rejected it is reported loudly instead of swallowed. If an endpoint got stranded this way, relaunching it without `/resume` restores delivery. ## [0.15.6] - 2026-07-07 > Requires spt-core **v0.27.0 or newer** (unchanged). Binary + instruction change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. Takes effect immediately after the update — no session restarts needed. ### Fixed - **A message whose delivery gets cut off mid-transmission can no longer vanish silently.** Previously, if an incoming message's delivery frame arrived truncated, it was quietly dropped — counted as delivered but never shown to the agent. Now the agent sees a clear marker with whatever partial content survived and a pointer to where the full message can be recovered, so a cut-off delivery is always visible instead of lost. ### Changed - **Going live or ready in a daemon-launched session no longer starts a redundant listener.** A live agent or ready session that was launched by the spt daemon is already reachable through the broker — messages arrive on its turn automatically. Bringup now recognizes this kind of session and skips starting an extra in-session listener, which in that context could not receive anything anyway and only reported an error. Sessions you launch yourself are unaffected and still start their listener as before. ## [0.15.5] - 2026-07-07 > Requires spt-core **v0.27.0 or newer** (unchanged). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. Completes the 0.15.4 Psyche repair for ccs-launched endpoints. ### Fixed - **End-of-session summaries work for ccs-launched endpoints.** 0.15.4 fixed finding the session transcript, but the summarizer's own Claude run still failed for ccs-launched endpoints because it ran without the endpoint's ccs configuration (no auth). It now runs with the endpoint's own configuration, so end-of-session context capture works everywhere. Psyches affected by the earlier failures recover on their own at the next commune — no restart needed. ## [0.15.4] - 2026-07-07 > Requires spt-core **v0.27.0 or newer** (unchanged). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. **Update urgently** — inter-agent messages received while an agent is mid-task are silently lost without it. After updating, wake any endpoint whose Psyche shows a hosting error. ### Fixed - **Messages delivered while an agent is busy actually reach the agent again.** A message arriving while the receiving agent was mid-task was consumed but never shown — the sender saw a successful send, the receiver saw nothing, and the message was gone. Every agent was affected. Mid-task deliveries now surface reliably. - **Psyches no longer shut down when a session's transcript can't be found.** The end-of-session summarizer (added in 0.15.2) treated a missing transcript as a fatal error, which after a few occurrences shut down the endpoint's whole Psyche — and it missed transcripts for every ccs-launched session because it looked in the wrong place. It now finds ccs session transcripts correctly, and when a transcript genuinely doesn't exist it records that fact and moves on instead of escalating. ## [0.15.3] - 2026-07-07 > Requires spt-core **v0.27.0 or newer** (unchanged). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. Takes effect immediately after the update — no session restarts needed. ### Added - **Agents on a perch are now steered to run long tasks in the background.** Previously, agents routinely ran subagents and long commands in the foreground, which made them unreachable for incoming messages until the task finished. Every perched turn now carries a reachability notice reminding the agent to use background execution, with an extra targeted reminder right before a subagent launches — so agents stay responsive while work runs. (Ported from the legacy owl plugin, where this notice existed for the same reason.) ## [0.15.2] - 2026-07-07 > Requires spt-core **v0.27.0 or newer** (unchanged). Manifest + binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. **Update urgently if any live agents run on spt-core v0.27.0+** — agent checkpoints and communes are broken without it. Restart affected live agents once after updating. ### Fixed - **Agent checkpoints and communes work again on spt-core v0.27.0+.** Newer spt-core asks the adapter to summarize a session's history whenever a session ends without a signoff (and when syncing a commune). The adapter didn't provide that summarizer, so after a few attempts spt-core gave up on the whole Psyche — checkpoints did nothing, communes stopped reaching the agent's tracked mind, and the endpoint showed a Psyche hosting error. The adapter now ships the summarizer, so end-of-session context is captured and checkpoints fire normally again. ### Added - **Sessions that end without a signoff now keep their context.** When a live agent's session ends abruptly (closed window, crash, no `/sptc:signoff`), spt-core now gets a concise summary of what the session was doing, ingested into the agent's tracked mind — so the next session resumes with that context instead of losing it. ## [0.15.1] - 2026-07-06 > Requires spt-core **v0.27.0 or newer** (unchanged). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. The same fix is also available as **v0.14.3** for nodes still on spt-core v0.25.0/v0.26.0. ### Fixed - **A checkpoint's resume instruction can no longer get swallowed by the session-name restore.** Since 0.14.1, restoring the session name after a clear and delivering the checkpoint's resume instruction could occasionally collide: the resume text ended up inside the session's title, the agent never received it, and the session sat idle until someone noticed. The two now land as one carefully-paced delivery, so the name is restored and the resume instruction starts the agent every time. If an agent hit this, its session title contains the swallowed instruction — rename the session and resend the instruction to recover. ## [0.15.0] - 2026-07-06 > Requires spt-core **v0.27.0 or newer** (floor raised). Manifest + binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. **Update spt-core first** (`spt update fetch` then `spt update apply`), then the adapter. ### Fixed - **Subagent working perches no longer pile up as permanent offline entries.** Previously, every subagent an agent spawned left behind a dead worker perch that sat in your endpoint list forever and could never be cleaned up normally. With spt-core v0.27.0, worker perches now get proper names (like `flynn-w4` instead of a random hex string), stop cleanly when the subagent finishes, stay out of the default `spt endpoint list` view (pass `--workers` to see them), and any stragglers are reaped automatically within a day. If a worker can't be registered or stopped, the reason now appears in the session's hook log instead of failing silently. ## [0.14.2] - 2026-07-06 > Requires spt-core **v0.25.0 or newer** (unchanged). Manifest + binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. **Update urgently if any live agents run on spt-core v0.25.0+** — their Psyches are broken without it. ### Fixed - **A live agent's Psyche works again on spt-core v0.25.0+.** Since 0.14.0, every Psyche turn failed before it could start (a leftover reference to a setting the new Psyche lifecycle no longer provides), so a live agent's Psyche silently stopped producing context notes and resume briefs. The Psyche now runs its turns normally again. Recovery: update the adapter, then restart affected live agents once. ## [0.14.1] - 2026-07-05 > Requires spt-core **v0.25.0 or newer** (unchanged). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. ### Fixed - **Sessions keep their name across `/clear`.** Previously, running `/clear` (or an agent checkpoint, which clears internally) dropped the session's display name — the terminal lost its ` @ (/)` title and you could no longer tell at a glance which agent a window belonged to. The name is now automatically re-applied right after every clear, before the agent resumes work. Sessions started before this update keep the old behavior until they are restarted once. ## [0.14.0] - 2026-07-04 > Requires spt-core **v0.25.0 or newer** (floor raised). Manifest + binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. **Update spt-core first** (`spt update fetch` then `spt update apply`), then the adapter; live agents started before the update should be restarted once. ### Changed - **A live agent's Psyche no longer runs as a resident background process.** The Psyche now wakes for each update, handles it, and finishes — its memory carries over between wakes, so nothing about the Psyche experience changes. What does change is the failure surface: the whole class of problems that came from keeping a Psyche process alive — silent restart loops, a Psyche quietly dying and needing `/sptc:revive`, and the multi-subnet limitation called out in 0.13.4 where a Psyche couldn't hold its listener — disappears by design, because there is no longer a resident process to keep alive. - **Psyches with a large accumulated context now start reliably on Windows.** A Psyche resuming with a big context could previously fail to launch on Windows due to a system limit on how much can be passed to a starting program. The context now travels a route without that limit. - **Now requires spt-core v0.25.0 or newer** (up from v0.23.0). The new Psyche lifecycle is driven by spt-core from this release on; older spt-core versions cannot run it, so the requirement is a hard floor. ## [0.13.4] - 2026-07-04 > Requires spt-core **v0.23.0 or newer** (unchanged). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. ### Fixed - **A live agent's Psyche that can't establish its listening perch now fails visibly instead of silently restarting forever.** On machines that belong to more than one subnet, the Psyche's listener could be refused at startup in a way it mistook for a normal shutdown — so it quietly exited and got restarted every few seconds, indefinitely, wasting resources with no visible sign. That refusal now surfaces as a real, loggable fault. Note: on multi-subnet machines the Psyche still can't hold its listener until a matching spt-core improvement lands — its periodic context notes keep working either way; this change makes the condition observable instead of invisible. ## [0.13.3] - 2026-07-04 > Requires spt-core **v0.23.0 or newer** (unchanged; the full checkpoint experience needs **v0.24.0**). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. **Supersedes v0.13.2 — update immediately if you took 0.13.2.** ### Fixed - **v0.13.2 accidentally included an unfinished rework of how a live agent's Psyche runs, and it could quietly break a live agent's message delivery.** If your adapter is on 0.13.2, a freshly started live agent could stop being reachable for direct message delivery shortly after starting. 0.13.3 is the same release without that unfinished piece: it keeps the checkpoint follow-up submit fix and restores the proven Psyche behavior. Recovery: `spt adapter update claude-spt`, then restart any live agents started while on 0.13.2. ## [0.13.2] - 2026-07-04 > Requires spt-core **v0.23.0 or newer** (unchanged; the full checkpoint experience needs **v0.24.0**). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. ### Fixed - **The checkpoint's follow-up instruction now actually submits after the clear.** Previously the wake-up message could appear in the fresh session's input box with a stray blank line at the end and just sit there unsent — the automated keystroke that should send it was getting absorbed into the message text. The clear and wake-up steps now pace their keystrokes the same way normal message delivery does, so the follow-up sends reliably. Combined with the delivery fixes in spt-core v0.24.0, `/sptc:commune --checkpoint` now completes end-to-end. ## [0.13.1] - 2026-07-04 > Requires spt-core **v0.23.0 or newer** (unchanged). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. ### Fixed - **Clearing a live agent's context no longer silently breaks its message delivery.** Every time a live agent's session was cleared — by hand or as part of a checkpoint — the machinery that delivers incoming messages into the session could be shut down as collateral, and from then on messages quietly piled up unseen until the agent was restarted. Delivery now survives clears. This also removes the main reason a checkpoint's follow-up instruction (`/sptc:commune --checkpoint`) never appeared after the clear; a matching spt-core improvement that hardens the remaining cases is on its way. ## [0.13.0] - 2026-07-03 > Requires spt-core **v0.23.0 or newer** (floor raised). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. ### Fixed - **A live agent's Psyche can no longer get stuck in a silent restart loop.** If a Psyche's underlying session died instantly on every launch (for example, when its working folder isn't trusted yet), the Psyche used to relaunch several times a second, forever, with no visible sign — wasting resources and never recovering on its own. It now slows down between failed launches and, after several in a row, stops with a clear message so the system can notice and step in. Healthy Psyches are unaffected; a Psyche that recovers on its own resets and carries on. ### Changed - **Now requires spt-core v0.23.0 or newer** (up from v0.20.0). The Psyche restart-loop protection works together with a matching safeguard that arrived in this spt-core release; `/sptc:setup` and `spt adapter update` keep you current. ## [0.12.1] - 2026-07-03 > Requires spt-core **v0.20.0 or newer** (unchanged). Manifest-only change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. ### Fixed - **A live agent's Psyche no longer risks mixing up its identity with another agent on the same machine.** The Psyche a live agent runs alongside itself could inherit identity details from the session that started it, and in rare cases would update another agent's session records as if they were its own — quietly corrupting that agent's tracking. Psyches now start with a clean identity of their own. No action needed; the fix applies to Psyches started after the update. ## [0.12.0] - 2026-07-03 > Requires spt-core **v0.20.0 or newer** (unchanged). Binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. ### Fixed - **Checkpoint waits until after the session clear to send the wake message.** When a live agent checkpoints (`/sptc:commune --checkpoint`), it clears its context and then continues with a follow-up instruction. Previously the follow-up could be submitted before the clear finished, so it ran against the old context (or was lost). The clear now always completes first, and the follow-up runs as the first turn of the fresh session — reliably, regardless of how long the clear takes. ### Changed - **Session names now include the project folder.** Alongside the ` @ ` naming, your Claude Code sessions now show the project folder they're running in — e.g. `myagent @ lab (my-project/)` in the prompt box and `/resume` picker — so you can tell apart agents working in different projects on the same node. Remote-control names carry it too. Existing sessions pick up the new name on their next start. ## [0.11.0] - 2026-07-02 > Requires spt-core **v0.20.0 or newer** (floor raised). Manifest + binary change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. ### Changed - **Session names now use your node's spt name.** The ` @ ` session naming introduced in 0.10.3 previously used the machine's raw hostname. It now uses the node's name as known to spt — the same name shown across spt's own listings — so if you've given a node a friendly name, your Claude Code sessions match it. On nodes where that name isn't available, the hostname is used as before, and failing that the plain ``. - **Requires spt-core v0.20.0.** Update spt first (`spt update fetch` then `spt update apply`), then the adapter. Nodes on older spt-core keep working on adapter 0.10.4. ## [0.10.4] - 2026-07-02 > Requires spt-core **v0.19.0 or newer** (unchanged). Binary-only change — `spt adapter update claude-spt` picks it up; no plugin skeleton change. ### Fixed - **`/clear` and `/compact` no longer cut an agent off from its messages.** Previously, clearing or compacting an spt-hosted session could silently break message delivery: the session kept working normally, but messages sent to it never arrived — until the endpoint was fully relaunched. Sessions now stay reachable across `/clear` and `/compact`, and if re-registration ever fails it says so instead of failing silently. An endpoint already stuck from an earlier `/clear` recovers by relaunching once on this version. ## [0.10.3] - 2026-07-01 > Requires spt-core **v0.19.0 or newer** (unchanged). Manifest + binary change — `spt adapter update claude-spt` picks it up; run `/reload-plugins` once after. ### Added - **Sessions are named after their machine.** Every spt-hosted Claude Code session — fresh or resumed, `claude` or `ccs` — now shows up as **` @ `** in the prompt box, the `/resume` picker, and the terminal title, with a matching `--` Remote Control name, so a fleet of agents across machines is distinguishable at a glance. If the machine name can't be determined, both fall back to the plain ``, exactly as before. `spt rc ` is unaffected — it addresses the endpoint by id. - **Updates now reach `ccs` accounts too.** If `ccs` is installed alongside `claude`, updating the adapter also refreshes the plugin for ccs accounts, so ccs-launched sessions stop running a stale plugin after an update. Best-effort: accounts that never installed the plugin are skipped. ### Fixed - **`ccs` sessions launch reliably on Windows.** ## [0.10.2] - 2026-07-01 > Requires spt-core **v0.19.0 or newer** (unchanged). An emergency bugfix patch over 0.10.1. Binary-only change — `spt adapter update claude-spt` picks it up; run `/reload-plugins` once after. ### Fixed - **An out-of-step plugin no longer freezes your whole session.** If the installed plugin fell behind the adapter (for example right after an update, before `/reload-plugins`), every tool call in the session could be blocked with no way to recover. The session now keeps working through the mismatch and prints a one-line reminder to run `/reload-plugins`. A genuinely mistyped command still fails loudly, as before. ## [0.10.1] - 2026-07-01 > Requires spt-core **v0.19.0 or newer** (unchanged). A bugfix patch over 0.10.0. Binary-only change — `spt adapter update claude-spt` picks it up; run `/reload-plugins` once after. ### Fixed - **Agents no longer pick up the wrong identity.** On a machine that belongs to a subnet, a session could come back from `/clear` or `/compact` convinced its agent id was the subnet's name, and the mistake stuck for the rest of the session. Identity is now resolved reliably, and a session without an identity is treated as such instead of being given a wrong one. ## [0.10.0] - 2026-07-01 > Requires spt-core **v0.19.0 or newer** (floor bumped). Update spt-core first (`spt update fetch && spt update apply`), then `spt adapter update claude-spt`. ### Fixed - **Session digests now work everywhere.** `spt endpoint digest` could come back empty (`NO_DIGEST`) for `ccs` accounts and other relocated Claude Code installs, and in general whenever the daemon — rather than your own shell — produced the digest. The digest now finds the session transcript itself in all of these cases. ## [0.9.2] - 2026-06-30 > Requires spt-core **v0.16.0 or newer** (unchanged). A wording-only fix in the agent briefing (adapter strings — no binary or plugin change). `spt adapter update claude-spt` picks it up; no `/reload-plugins` needed for this one. ### Fixed - **More accurate guidance about receiving replies.** The 0.9.1 note "replies arrive automatically — don't set up a watcher" was only true for broker-hosted sessions. A live agent you start yourself (`/sptc:live`) relies on its own running relay to receive messages, so the briefing now says: don't arm an *extra* watcher for a single reply, and don't tear down the relay you're already running. ## [0.9.1] - 2026-06-30 > Requires spt-core **v0.16.0 or newer** (unchanged). A bugfix patch over 0.9.0. After updating, run `/reload-plugins` (or restart Claude Code) once. ### Fixed - **`hook: command not found` on every Bash command is gone.** A 0.9.0 regression left a malformed entry in the per-session environment, so every shell command printed a spurious `hook: command not found` and the message-delivery hooks could misfire. Fixed — the environment entry is now written safely (and tolerates paths with spaces). - **`spt adapter update claude-spt` no longer fails to update the plugin.** It now refreshes the Claude Code marketplace before installing, fixing `Plugin "sptc" not found in marketplace "cplugs"` on a stale local marketplace copy. - **Clearer update message.** After an update you now see `✔ Claude Code plugin "sptc" updated from to . Active sessions need to run the /reload-plugins command.` instead of the generic "Restart to apply changes." - **Agents know their own id.** A live/perched agent is now told its id up front and no longer runs `spt whoami` to look it up. - **No more redundant message watchers.** Agents are now told that replies arrive automatically on their existing perch, so they stop arming an extra watcher to wait for a response. - **ccs profile parity.** Sessions launched through the `claude-spt:ccs` profile now carry the same session name and remote-control settings as the base profile (they were dropped in 0.8.0). ## [0.9.0] - 2026-06-28 > Requires spt-core **v0.16.0 or newer** (unchanged from 0.8.0). This release is an internal re-plumbing of how Claude Code hooks run — there is **no change to what you do or see**. After updating, run `/reload-plugins` (or restart Claude Code) once, as the update reminds you. ### Changed - **Hook behaviour now updates with `spt adapter update` — no plugin reinstall needed.** Previously, any change to how a hook works (message delivery, the live-agent checkpoint, the session briefing) required a separate Claude Code plugin update. Now that logic lives in the `claude-spt` program that `spt adapter update` already refreshes, so a single update keeps hooks current. The plugin's hook wiring is now fixed and rarely needs a marketplace bump again. ### Fixed - Nothing user-visible. This is a behaviour-preserving refactor: messaging, the `/sptc:*` skills, the live-agent checkpoint (`/sptc:commune --checkpoint`), and the session briefing all work exactly as before — they are just driven by the consolidated `claude-spt` program instead of separate hook scripts shipped in the plugin. ## [0.8.0] - 2026-06-26 > Requires spt-core **v0.16.0 or newer** (was v0.15.0). This release unifies the project naming, turns updating into a single command, and consolidates the adapter to one tool binary — built on the update-arc + CLI features that arrive in spt-core v0.16.0. ### Added - **One-command update — `spt adapter update claude-spt`.** A single command now keeps *everything* current: it pulls the new adapter (manifest + binary + strings) **and** reconciles the Claude Code plugin in the same step. The only manual residual is `/reload-plugins` (an unavoidable Claude Code TUI action), which the update prints a reminder to run. - **Mid-turn reachability for live agents.** A live agent can now receive a message *while it is working* (not only between turns) — incoming messages surface mid-turn, with the endpoint honestly marked busy during a turn and idle when it finishes. ### Changed - **Name unification.** The project/repo and adapter are now **`claude-spt`** everywhere spt-core sees them (the repo was renamed `spt-claude-code` → `claude-spt`; install and update both read `claude-spt`). The Claude Code plugin stays `sptc` / `/sptc:*` this release. - **One tool binary.** The separate digest, psyche, and idle-translation binaries are consolidated into a single `claude-spt` binary (subcommands) — one artifact per platform in the release. - **Session display name + remote control.** A spawned/resumed endpoint now shows its `{id}` as the session display name and is remote-control-attachable under that id, on both bringup paths. - **Leaner skills.** `commune` / `send` / `signoff` guidance is now delivered by the adapter (so it updates with `spt adapter update`) rather than baked into the plugin. ### Requires - spt-core **v0.16.0+** (the composite `[update.post]`, the idle-translation `command` seam, and the `{adapter_dir}` substitution all land in v0.16.0). ## [0.7.0] - 2026-06-24 > Requires spt-core **v0.15.0 or newer** (was v0.13.2). This release adds self-checkpointing for live agents, automatic resume context, and clearer multi-line message delivery — all built on features that arrive in spt-core v0.15.0. ### Added - **Self-checkpointing for live agents — `/sptc:commune --checkpoint`.** A live agent can now reset and rebuild its own context without you running `/clear`. Write a commune containing the marker `!!checkpoint!!` and the session clears itself, then wakes back up from that very commune and keeps going. A single `!!checkpoint!!` wakes with a default "Proceed with next steps"; a **pair** of markers wakes with whatever instruction you write between them. The marker is one-shot — it never lingers in your rebuilt context. - **Automatic resume context.** When a live agent's session starts (or clears), it now pulls its durable role, working context, and latest unsynced commune and re-injects them automatically — so it resumes where it left off instead of coming back blank. ### Changed - **Incoming messages are easier to read.** A message delivered from another agent now renders across multiple lines — the envelope opening, the body, and the close each on their own line — instead of one dense single line. - **Requires spt-core v0.15.0+** (up from v0.13.2). Self-checkpointing and resume context both rely on capabilities introduced in that release; `/sptc:setup` and `spt adapter update` will keep you current. - Adapter version of truth is now **0.7.0** (shown in `/sptc:version` and the release tag). ## [0.6.2] - 2026-06-23 > Requires spt-core **v0.13.2 or newer** (unchanged). A small but important delivery fix — no change to commands or setup. ### Fixed - **Messages delivered while you're idle now actually send.** Previously an incoming message from another agent could be typed into your Claude Code input box but never submitted — it just sat there as an unsent draft. The delivery now presses **Enter** to send it, so idle-delivered messages arrive and run on their own. Your half-typed draft is still stashed and restored around the delivery, exactly as before. ## [0.6.1] - 2026-06-22 > Requires spt-core **v0.13.2 or newer** (the version that can install a multi-platform package). Packaging-only release — no change to what the adapter does, only how it ships. ### Packaging - **One download now covers every platform.** The adapter ships as a single multi-platform `adapter.spt` that bundles both the Windows and Linux builds beside one shared manifest; installing picks your platform automatically. This replaces the previous per-OS files and the Windows-only stopgap `adapter.spt` (which broke self-update on Linux), so `spt adapter add --release …` and `spt adapter update` now just work on either OS with no platform to pick. Requires spt-core **v0.13.2+** (the version that can read a multi-platform package). ### Changed - **Setup is simpler.** `/sptc:setup` now activates the adapter with a plain `spt adapter add --release SaberMage/spt-claude-code` — no OS detection or asset selection, since the one package is host-agnostic. - Adapter version of truth is now **0.6.1** (shown in `/sptc:version` and the release tag). The cplugs plugin skeleton bumps with the simplified setup body. ## [0.6.0] - 2026-06-22 > Requires spt-core **v0.13.0 or newer** for the two new capabilities below. On older spt-core they're simply inactive — nothing else changes, so this release is safe to take on any version. ### Added - **Idle agents now receive your messages.** When an spt-hosted agent is sitting at its prompt (idle, not mid-task), a message sent to it now lands *in that session* — typed in and submitted for you — instead of going unseen until the agent next acted. If you were part-way through typing your own input, your draft is stashed first and restored right after, so an incoming message never eats what you were writing. - **Resuming an agent brings back its conversation.** Relaunching a session now reloads its prior transcript instead of cold-starting a blank one, and the resume picker shows each session's project folder so you can tell them apart. ### Changed - Adapter version of truth is now **0.6.0** (shown in `/sptc:version` and the release tag). The cplugs plugin skeleton is unchanged (still on its own slower track). ## [0.5.0] - 2026-06-19 ### Added - **Agents now know who they are the moment a session starts.** When a session is already reachable — you launched it through `cc`, or it cleared/compacted mid-run — it now opens with a short brief: its own agent name, a reminder that it's already live (so it won't try to re-arm), and how to message other agents (`spt send` and reply, plus `spt endpoint list` to see who's around). Previously a resumed or spt-launched session could start not knowing its own name. - **Sessions that aren't reachable yet learn how to reach out.** On a machine that belongs to a subnet, a plain session with no perch now gets a one-line tip on reaching other agents with `spt ring` — without having to go reachable first. Solo machines with no peers see nothing. ## [0.4.0] - 2026-06-18 ### Changed - **Your live-agent companion now runs in a safe, limited mode.** When you go live with `/sptc:live`, the background companion that writes your context-resume notes works with a file-only toolset and a lighter, cheaper model. It is more contained and costs less to run, with no change to what you see or do. - **Removed the experimental `:deep` profile.** `claude-spt:deep` was an unused placeholder. The one shipped profile overlay is `claude-spt:ccs` (routes sessions through `ccs`). If you ever selected `:deep`, use `:ccs` or the base adapter instead. ### Fixed - **Sessions that spt starts for you no longer stall on a permission prompt.** When spt brings up a Claude Code session on your behalf (the live companion, and the spt-hosted launcher), it could hang waiting on an approval prompt that no one was there to answer. Those sessions now start cleanly. ## [0.3.0] - 2026-06-17 ### Changed - **Going live is now a single, seamless step.** A live agent comes up directly — no behind-the-scenes adapter selection, no chained setup commands. `/sptc:live` just brings your session up live, and `/sptc:ready` brings it up reachable-but-light; the difference is simply which one you run. This is full parity with the original live-agent experience. - **Requires spt-core 0.9.0 or newer.** This release uses spt-core's newer automatic harness-resolution, so the adapter now needs spt-core **0.9.0+**. If you keep spt-core up to date (it self-updates), there's nothing to do; on an older spt-core the adapter will decline to install until you update. ### Fixed - **Setup pins this adapter as your default.** `/sptc:setup` now records `claude-spt` as the active adapter for Claude Code, so going live or ready needs no extra flags. ## [0.2.1] - 2026-06-16 ### Fixed - **Going live shows a clean status, not raw machine output.** Starting a live agent previously leaked internal setup markers and tokens into the chat. `/sptc:live` now reports a single tidy summary — your agent id, online status, how other agents reach you, and how to reply — and nothing else. ### Changed - **Self-contained live setup.** Bringing a session live no longer bounces you to a separate help topic; `/sptc:live` carries the full bringup itself, so going live works in one step. ## [0.2.0] - 2026-06-16 ### Fixed - **Live agents now reliably start their background companion.** Previously a live agent could come up marked "online" while its persistent companion silently failed to start, leaving it with no running context. The companion now launches and stays resident. ### Changed - **Simpler setup — no manual PATH step.** The adapter's helper tools are now found automatically from where the adapter is installed; `/sptc:setup` no longer asks you to copy anything onto your PATH. - **Automatic adapter updates.** The adapter now updates itself from this project's GitHub releases (`spt adapter update`) — logic and instruction changes reach you without a reinstall. ### Added - **Linux support.** The adapter ships native **Windows and Linux** builds; `/sptc:setup` detects your OS and installs the right one. - **ccs integration.** If you use [ccs](https://github.com/kaitranntt/ccs), `/sptc:setup` wires the shipped `claude-spt:ccs` profile so live/ready agents can run on your ccs backends instead of `claude`. - **Private-network onboarding.** `/sptc:setup` now offers to create or join a private network (subnet) so you can pair machines and reach agents across them. ## [0.1.0] - 2026-06-15 First public release. ### Added - **One-step setup — `/sptc:setup`.** Sets the plugin up and installs the Spacetime (`spt`) engine for you if it isn't already present, so messaging and live agents just work. Also offers to create or join a private network and to register the always-on background service. - **Agent messaging.** `/sptc:ready` turns on your inbox so other agents can reach this session; `/sptc:send` messages another agent; `/sptc:list-agents` shows who is currently active. - **Live agents.** `/sptc:live` upgrades the current session into a live agent with a persistent companion that keeps its own running context. `/sptc:commune` pushes a context update to that companion, and `/sptc:signoff` ends a live session cleanly with a final summary. - **`/sptc:force-stop`** immediately tears down a listening or live agent when you need it gone. - **Cross-machine networks — `/sptc:subnet`.** Pair machines into a private network (create, show the join code, or join an existing one) so your agents can reach each other across nodes. - **`/sptc:version`** reports the running engine version. - **Alternate model backends (advanced).** Ships a ready-made `ccs` profile template you can select to launch sessions through [ccs](https://github.com/kaitranntt/ccs) — useful for routing an agent to a different model or billing backend. You supply your own ccs configuration. - **Invisible engine install.** Starting a session automatically installs the `spt` engine the first time if it is missing — no separate install step.