Releases shipped in August 2026, newest first. The current releases are on the changelog.
[1.12.22] - 2026-08-31
A release now has to prove the node works, and the node has a brake on what it spends
The previous release shipped with evidence that a node could be built from nothing, and the node built from it could not get an agent to do a single piece of work. Every gate we had read the repository. This one adds the gate that runs the product, and then spent the day being caught by it: three of the defects below were found by the acceptance run rather than by a person, and one of them was found in the acceptance run itself.
A publish now requires a node that answered, not only a node that installed. tools/acceptance-run.sh executes the nine web-chat criteria against a live throwaway node and writes acceptance-evidence/<version>.json only on a clean pass; release.sh --publish refuses without it, the same shape as the release-evidence gate it sits beside. The run reports PASS, FAIL or SKIP per criterion, and SKIP is not decoration: a missing precondition must be distinguishable from a defect, or the first red run gets argued with and the gate gets waived.
Cross-channel memory reached an agent for the first time. The design shipped in August and was verified live then; on a desk turn it had been dead code ever since. brin/main.py resolved the person into person_identity and passed it to the ledger sections, while the cross-channel block was gated on principal, a key nothing in the web-chat path ever sets. Two mechanisms for one idea, arriving from two different releases -- the failure the shared history path must prevent. The person's history now folds into the turn, so an agent asked on one desk about something said on another answers from the record instead of denying it exists.
The node's spending had a meter and no brake. sn_config.budgets metered to the cent and carried limit_usd = 100000 with hard_limit = false, which looks identical to a working limit on every dashboard. There is now a write path for budgets through the API, so a limit can be changed without a direct database UPDATE, and a soft limit finally emits rather than sitting in a status nobody reads. The gateway enforcement itself needed no change: it was correct and unconfigured.
The supervisor was written, documented as periodic, and had never run once. staleness_sweep reminds on an approval older than 24h, escalates past 48h, unblocks tasks whose blocker is already closed, and escalates a task looping in review. Nothing called it. It now runs hourly from cron rather than from an in-process timer, because a wedged process must not be able to silence its own supervisor.
A message to a recipient that cannot receive it is refused at the door. Internal mail to a non-agent was accepted, written, and then dropped by routing, with nothing told to the sender. Two agents spent an afternoon believing they had reported results that reached no one. The send now fails loudly instead of succeeding quietly.
Status changes made through the API are recorded. Only the web UI went through the pipeline, so every move an agent made left no audit row, no notification and no comment. Three tasks were found sitting in blocked with nothing anywhere saying who blocked them or why.
The installer finishes on a host-local install. voice.sh left foreign ownership after rsync, the permissions stage aborted at exit 7, and nothing was written -- including /etc/smart-node/classes.json, so the node could not verify its own declaration afterwards. The same rsync pattern in workflows.sh was found and fixed with it. The missing class file was not a separate defect: it was this one, two stages downstream.
A caller refused by network origin is told so. /api/secrets/resolve answered a generic 404, so an agent denied by its network concluded the secret did not exist and went looking through the filesystem for it. It now answers 403. The secrets contract itself is registered as a tool granted to every agent, so an agent has a documented way to ask instead of searching.
doci distinguishes a missing document from a broken one. An outer exception catch overrode the handler's 404 with a flat 400 across six API files, so a caller could not tell an absent document from an internal failure.
Seeded policy rules are reachable through the API. The filter matched tenant_id IS NULL while seeded rules carry tenant_id = 1, so on a fresh node every seeded rule was invisible to edit and delete.
A throwaway node can be stood up under credential isolation. The installer accepts --seed-manifest, which names a credential per channel or the word disconnected, and admin-runner gained lxc_node_provision, lxc_node_destroy and lxc_node_status. A manifest carrying a live node credential is refused before the container is created, so isolation is enforced by the provisioner rather than agreed between people.
Known and not fixed here: the model credential is written to the systemd journal on every agent run, because sudo logs the environment it is asked to preserve. There is no sudoers flag that suppresses it on sudo 1.9; the fix is to keep the token out of the sudo boundary entirely, and it is in progress.
[1.12.21] - 2026-08-25
The node stops reporting success it did not achieve
Five changes, one theme. Each is a place where the node answered "done" for something that had not happened, and where the person in front of it had no way to tell. None of them was found by a gate; all of them were found by a human noticing that the outcome was missing.
Every knowledge write on every node was a silent no-op. core-api's unit set eleven addresses and not MESH_API_URL, so the code fell back to its own default, https://mesh.local, which resolves nowhere. The API answered 201, the panel drew the chip, the row landed in sn_config.agent_knowledge -- and the agent never learned the fact, because the mesh snapshot is what composes into its prompt. Measured on a reference node before the fix: 4 of 19 rows carried a mesh_guid, all four old. After: 15 of 19, and the documents appear under "# Documents you can read". This is why the demo's specialists looked like they had "lost their knowledge" -- they had not; every repair added another row that also went nowhere. companions/core-api.sh now resolves the mesh container the way dispatcher.sh does, and a write whose snapshot failed no longer reports success: the response carries delivered and a detail naming which of the three things happened.
A node may now have a public name. B05 built the entire sign-in identity from SMART_NODE_DOMAIN, so on a node administered by an internal name while its customers use another, a routine update replaced a working public identity with a VPN-only one: sign-in unreachable from an ordinary browser, the session cookie scoped to a domain that does not cover the public host, and the WebAuthn relying party reset -- which invalidates every registered passkey. validate.sh passed 197/197 an hour later, because every gate reads internal names. The routing contract now carries SMART_NODE_PUBLIC_DOMAIN and carries it FORWARD across a re-run that did not restate it, which is the half that makes it hold: the flag is passed once and every update after that is typed from memory. The public host is routed by a dynamic file rather than a container label, because container labels do not provide durable host routes. And B05 --verify now asserts the identity the container ANNOUNCES, which is the check whose absence let this pass.
A service that acts for an agent says so on the row. Work done through the API on an agent's behalf was recorded as the door rather than the agent, so the provenance of an entry could not be read back.
The node reads the journal it has always written. Every component logs its exceptions; nothing collected them, so a component could fail repeatedly and report nothing but a green service state. tools/node-exceptions.sh sweeps the journal and reports, on a cron.
Switching agents clears the voice feed. The server has always kept one conversation per (caller, agent) pair -- ring a colleague you have never rung and you get an empty thread, as you would with a person -- while the screen kept the previous agent's lines, showing a conversation the new agent has no knowledge of. Clearing is the honest half; loading what the chosen agent DOES remember has to come from the message registry, not the in-process window that dies with the container, and is tracked separately.
[1.12.20] - 2026-08-25
The fix that only reached one of the two paths
1.12.19 fixed a session dying on an oversize line. It fixed it in the stack a human chats through, and not in the stack every agent runs on. This release is that omission, and it is the more serious of the two, because the path left behind is the one that wakes agents.
An agent wake died before it did anything. backends/cli_claude.py spawned the CLI with no line ceiling, so it kept asyncio's 64 KiB default, and its read guarded only a timeout, so the overrun arrived as a bare ValueError about separators and chunks. The CLI echoes the agent's assembled system prompt back on its FIRST output line, escaped. Measured on our own nodes, those prompts are 27.3 KiB on one node (158 sessions, 18.4 KiB mean) and 34 KiB on another -- under the default, which is precisely why nothing here ever failed. On a node whose prompt was larger the first read failed, the session died in about 80 ms, the Runner marked the agent broken, and the node quietly stopped doing autonomous work. agent_runtime stayed free, every service read active, and validate passed, so nothing anywhere said a word.
The ceiling now has one definition, in config, beside SPAWN_ENV_KEYS. That neighbour is the point: SPAWN_ENV_KEYS lives there because these same two files held two copies of a spawn constant and drifted, the OAuth token reached one and not the other, and nodes spawned a CLI that was simply not logged in. Same two files, same shape, so the same remedy rather than a second copy of a number.
The spawn now reports the prompt size on every session, and warns within 4x of the ceiling. Not a limit -- a gauge. Nobody knew ours sat at half the default until somebody else's went over it.
Capping the system prompt was considered and rejected. The ceiling is an artifact of our own pipe reader, not of the model, and the same limit applies to every output line -- so a cap would have left 1.12.19's original case, a turn quoting a document, failing exactly as before. It would have closed the door we came in by and left the other one open, which is the whole story of this release.
The regression test asserted this and did not test it. Its own helper docstring read "Every CLI spawn passes the ceiling. Both of them: the fix is worthless on whichever path is left behind, and there are two" while its target was a single file. It counted that file's spawns, found two of two, and passed while the other path was broken on every node. It now parses each call and requires the ceiling on every spawn that pipes stdout, across both modules, exempting the helper that pipes nothing -- because a check that must be wrong forever is a check that gets switched off.
Found from outside, again: the node this was happening to ran a controlled wake, could not reconcile a 64 MiB constant with a session dying at 80 ms, and deduced there had to be a third read without the limit. There was.
[1.12.19] - 2026-08-25
A day of a real node's findings, and the four that were code
A node in the field spent a day porting a real flow end to end and reported six things. It is the only clean install of the current release in existence, which is why its reports keep finding what our own building cannot. Four of the six were code. This release is those four; the rest are decisions in a bug's clothing, and are held rather than guessed at.
Reading a document no longer kills the session. A ~15KB document failed the session outright, with a message about separators and chunks. The gateway spawned the CLI without asking for a buffer, so it kept asyncio's 64 KiB default while the CLI speaks one JSON object per line -- and a turn that quotes a document back clears that easily. The document itself was never the problem, which is why nobody would find this by opening a bigger file. The ceiling is now explicit and far above any real turn, and a line that still exceeds it says so instead of ending the session obscurely.
A hyphen in a mail domain no longer stops the install. The installer wrote an accounts file and then refused to accept it, because the key it derives keeps hyphens and the validator that checks the key did not. It died claiming the file held no keys. Two validators had the same gap, and fixing only the one the report named would have left the install passing while the doctor kept calling the node broken.
A companion re-run no longer strips the business name. Outbound mail lost its From name and its signature on any second run, silently, because the value lived in a file the installer rewrites wholesale and nothing carried it across. Notifications substituted a generic name rather than failing, so nothing looked wrong. It is an input now, and it survives a re-run -- which is the half that repairs the nodes already installed.
The office panel says who wrote. Every address rendered as "A customer": a client, the owner's own second address, a supplier and a bounce all read identically, and the feed could not be used. That mask arrived with a vendored snapshot and was never a decision here. The panel sits behind authentication, so its only reader is someone already signed in -- the mask was hiding the owner's correspondence from the owner. A known contact now reads by name, an unknown one reads as its address, and the generic words stay where they are true: the public landing panel, where the viewer really is a stranger.
Held back on purpose: an agent-facing tool for the workflow engine, and what makes a block a gate in the diagram. Both are decisions rather than defects, and a release is the wrong place to guess at one. Also held: the node's session lifecycle, where the reported cause does not match this tree -- the wake gate here is the agent runtime with lease recovery, not the session row -- and acting on the wrong cause costs more than waiting for the numbers.
[1.12.18] - 2026-08-22
A message can go to more than one person
Until now a node could answer one address. It could not reply to everyone on a thread, copy a colleague, or bring the owner into a conversation, because a message carried a single recipient and everything downstream assumed it. For a business whose mail is mostly group threads, that is most of what a secretary does.
A message now carries a set of recipients, each with a role. The set is the same on every channel, because the journal it lives in is shared by all of them; the role is not, and only email reads it. That distinction is the whole design: copying someone is an email idea, while several people in one conversation is not, and a node that will later put two agents in a chat with its owner should not have to invent the same thing twice.
Permission did not change, only how many times it is asked. Every address on a message is checked exactly as the single recipient always was, and the answer comes from the node's own records rather than from a list written into configuration.
If any recipient is refused, the whole message is refused, and the reason names them. Not a partial send. The alternative hides a decision: someone asked to write to a group, some of them silently did not receive it, and a conversation carrying on without the person you meant to include is a worse failure than a refusal you can see and fix.
Blind copies are deliberately not here yet. A blind recipient is not one more address: they must not appear in what the others receive, and must not be gathered up when someone later replies to everyone. That is a rule about rendering rather than about sets, and it waits until the simple case has carried real traffic.
Shaped with a node in the field, whose owner argued for the whole-message refusal and was right.
[1.12.17] - 2026-08-22
A flow that branches, runs blocks side by side or loops back is now drawn as it is.
The picture of a workflow was a straight line of blocks. Most flows are not a straight line. Of the five the engine ships as examples, three are not: one runs three analyses at once and joins them, one is three phases of seven blocks where each block in the middle phase depends on two blocks in the first, and one branches on a condition and loops back for another attempt. Drawn as a line, all three are wrong in the same quiet way, and the one shipped with a node was missing its revise loop entirely.
Underneath, the record was missing the same things. It kept each block's routing and its next, but dropped the phase it belongs to, what it depends on, and whether it runs in parallel -- which is how those three flows express their shape. A picture cannot draw edges that were never stored, so this is fixed first: the record now carries the whole shape.
The view then draws it. The same blocks, with the same look, placed by depth instead of in a row, and the connections drawn over them: a labelled line for each branch, and a loop back arced underneath so it cannot be mistaken for another step. A flow that really is a straight line is drawn exactly as before, untouched.
Two smaller things came out of building it. The end of a flow is now the block nothing leaves, worked out from the connections, where before it was any block that did not declare an onward step itself -- so a block linked by the next one was marked as an ending, which on a three-way fan-out marked all three. And the picture is drawn from measurements taken after the browser has laid the blocks out, so it stays correct when the window changes rather than only when it opens.
Prompted by a node in the field, which offered a renderer of its own, and by the observation that a node must be able to show any flow, not the one flow the picture was written for.
[1.12.16] - 2026-08-22
The workflow diagram described one business's process and drew it over everyone's
The picture a node shows of a workflow was written around a single flow. It put an inbound enquiry at the front of every diagram whether or not the flow has one, called every gate a wait for the owner, hid any step whose next was one particular block name, and renamed blocks called send and done to deliver and complete. On the flow it was written for it read correctly. On any other it asserted things that were untrue: a flow with no incoming message was shown starting with one, and a step that runs a script and writes a file was shown as a pause for a human.
The same shape as the run harness removed in 1.12.14, one layer up: one business's story written into code that runs for every business.
The diagram now says only what the flow's own record says. No invented first node, a trigger only where the flow declares one, labels from each block's own kind and specialist, and last-step drawn from having nothing leaving it rather than from a name the renderer happened to recognise. It is still a straight line; branches and the loop back are in the data and are not drawn yet.
Underneath it, the record itself was wrong in the same way. Anything with routing and no specialist was filed as a gate, so every block that runs a script was stored as a pause for a human, and the panel was repeating that faithfully. A block that runs a script is now recorded as what it is. The distinction was in the flow file all along and simply was not carried across. Nodes pick this up when the registrar next runs, which the install does.
Reported by a node in the field, on their own flow, where the picture was wrong in both of those ways at once.
[1.12.15] - 2026-08-22
Agents could think while nothing else could, and every check said the node was healthy
On a node whose model credential is an OAuth token, which is what the node's own login mints, agents answered normally and everything else that reached a model through the gateway came back "not logged in". The install passed. The check that exists for precisely this passed too, because it looks in the credential file and the file was correct.
The cause was two copies of one list. What a spawned CLI is allowed to inherit was written out twice, in two different files, and over time they drifted: the OAuth token was added to one and not the other. Every session taking the older path spawned a command-line tool with no credential whatsoever. A node holding an API key instead was unaffected, because that key was in both lists, which is why this went unnoticed for so long.
Nothing had made it visible before, either, because until yesterday's release the one caller that routinely takes that path had nowhere to run. A workflow block asks the gateway for a model as nobody in particular, so it was the first thing on a node to ask that way as a matter of course. Blocks ran, produced output, and none of the output had been near a model.
The list and the credential lookup now exist once and both paths call it. Putting a third copy of the lookup next to the two lists would have repeated the mistake that caused this.
The same lookup now also reads the credential file when the process environment has no key. Systemd reads that file once, when the gateway starts, so a credential stored afterwards never reached a running gateway, while an agent saw it on its next wake because it reads the file every time. That asymmetry is gone.
This was proven by building the failing state rather than trusting a green check: the tool says "not logged in" when it has no credential and "401, token invalid" when it has a bad one, so a deliberately invalid token was enough to show the credential now arrives where it did not before.
Found by a node in the field within hours of installing 1.12.14, on the first node that had both the workflow subsystem and real credentials.
[1.12.14] - 2026-08-22
The workflow engine shipped with nowhere to run
A node has had the orchestrator installed for months. What it has not had is the tree the orchestrator reads from. The runner names four paths -- a Rein install at /opt/smart-node/rein, and runner-agents, agents/flows and a run wrapper under /opt/smart-node/flows -- and no install stage in this repository has ever created any of them. The workflows companion installs Rein to /opt/smart-node/workflows and stops there.
So sn_core.workflows was empty on every node built from a release, and not for the reason it looked like. Nobody had failed to write a flow. There was nowhere on disk to put one that anything would find. The tree existed on exactly one machine, the demo node, where it had been assembled by hand and had therefore been mistaken for what an install produces. The owner's own live node did not have it either.
This release ships the runtime as a component, on the same terms as memory, the planner and documents: mechanism, empty of anyone's business. The tree is laid down by the workflows stage, the dispatcher's half of it is linked to the authored half so a flow written once is visible to both, and one reference flow comes with it -- draft, then an independent review that can send it back once, then delivery -- depending on nothing but Rein and the AI gateway, so it runs on a node the day that node is built.
Two things were removed rather than added. There is no second copy of Rein: the runner now points at the install that exists, which is the same version it was asking for, instead of a 120 MB duplicate. And the endpoint behind "run this workflow" no longer calls a demo harness belonging to one customer, which had that customer's document identifiers, sample name and block names written into it and emitted nothing at all for any other flow. Its replacement reads the flow's own YAML, so a flow authored on the node five minutes ago is reported the same way as one that shipped with it.
Two further gaps surfaced while building it, both of the same kind as the first. The installer ships each companion only the sibling files it is listed with, and the new tree was not on that list, so it would have been laid down by a stage that never received it. And the registrar that projects a flow YAML into the catalog has never been called by anything: before this release its only mentions in the repository were in documentation. A node could therefore have had the tree, the flow and the engine, and still shown an empty workflow catalog. It is run by the install now, and says plainly when core-api is not there to register into rather than passing quietly.
Found by a node in the field, which went to author its first flow and could not.
[1.12.13] - 2026-08-22
The reference on an email was stored in the text, so sometimes it appeared twice and sometimes not at all
Every outbound email carries a short reference so a reply can be tied back to it. That reference was being written into the body of the message when the row was created, which made whether it appeared depend on who created the row.
Notifications wrote it in; replies did not. Mail is sent with a plain and an HTML version and a reader sees one of them, so on the ordinary path each version happened to carry exactly one reference and nothing looked wrong. Two paths were not ordinary: when the brand template could not be fetched, the HTML fell back to wrapping the body that already held the reference and added its own, giving two; and a reader without HTML, replying to an agent, got none.
The reference is now added to each version as it is built, and the stored message holds text and nothing else.
core-api 0.19.7 -> 0.19.8, communication 1.8.2 -> 1.8.3.
[1.12.12] - 2026-08-22
A read is recognised by what it did, not by its name
1.12.9 stopped the activity feed reporting planner polls as work, by matching a list of operation names. That list lived in the feed, which meant the interface held knowledge about the planner, and any new read operation would have shown up as work until somebody remembered the list existed.
The information was there all along and was being discarded: the event written when a call finishes knew the request method and did not record it. It does now, and the feed asks the event what happened instead of recognising it by name.
core-api 0.19.6 -> 0.19.7, office 0.5.3 -> 0.5.4.
[1.12.11] - 2026-08-21
Four things a node could not tell you about itself
An agent asked why it kept waking could read its schedule and nothing else, which describes one of the two ways it is woken and not the one in use. It answered truthfully and under-reported itself to its owner. It can now account for its own wakes and spend, and the answer is about whoever asked: there is no way to ask after another agent.
Cached tokens were billed and counted nowhere, so a turn cost real money and displayed eight tokens. Every provider that caches reports those separately under its own name and both backends dropped them at the boundary.
Notifications composed a sender and a link out of the node's bare domain. Both are fine to look at and impossible to use anywhere the mail and console are not on that exact name: the sender was refused at the egress gate minutes after the API had answered that the mail was sent, and the link went nowhere. Neither is invented now; the node refuses and says which setting is missing.
And the boundary between an agent and the machine under it, which was real, enforced by file permissions, and written down nowhere, is now one rule that reaches every agent.
core-api 0.19.5 -> 0.19.6, gateway 2.6.0 -> 2.6.1.
[1.12.10] - 2026-08-21
One malformed message stopped an agent reading any of its messages
/api/messages/inbox answered 500 when a single row carried a metadata.origin that was a string rather than an object. Several producers write that field and one of them writes a string, so the crash was reachable in normal operation.
What made it serious is the blast radius: the failing row did not become unreadable, the whole inbox did. On the node that reported it, agents woke, could not read their inbox, and left everything at new -- an owner's own message included -- while the agents themselves filed friction tasks about being unable to work.
A non-conforming origin is now skipped and logged instead of fatal.
It surfaced only when a real end-to-end task was driven through the agents, which is worth recording: no gate that reads the repository, and no clean install, would have found it.
core-api 0.19.4 -> 0.19.5.
[1.12.9] - 2026-08-21
The activity feed reported polling as work, so the owner could not see what the agents did
The Dashboard card exists to answer one question -- what did the office do -- and on a working node it answered with planner polls and one misconfiguration restated until it filled the card. Reported from the field by a node in real use, and confirmed on a second node.
None of it was UI. The endpoint forwarded the wrong things: a successful read was indistinguishable from a write, the verb was taken from entity_id (always the literal planner) instead of payload.op which names the actual call, and 337 identical "held a message" verdicts each got their own row.
The held rows are collapsed, not dropped. A voice call arriving where no agent is bound is a genuine configuration gap; what nobody can use is being told 337 times.
Measured on 7 days of real events: inbound messages visible in the feed went from 9 to 22, because the repetition had been consuming the row budget and pushing real messages out.
The card could also be empty rather than noisy, and filtering is what exposed it. The endpoint fetched the newest 400 raw events and filtered afterwards, so on a node whose owner simply had the dashboard OPEN -- twelve planner polls a minute -- the window covered half an hour and held 379 reads out of 400, while the day's 34 real actions sat outside it. Watching the feed was what emptied it. It now queries per event type and merges, so depth is measured in real events.
Office 0.5.2 -> 0.5.3. Native service, no image change.
[1.12.8] - 2026-08-20
The node could not hear its own doorbell, and the log that said so was 900 MB
1.12.7 fixed two of the three places that called core-api as an agent over the TCP door. This is the third, and it was the one that mattered most: the message watcher, whose whole job is to notice a new inbound message and wake whoever it is for.
It had been answering 403 on every poll, every ten seconds, on every node, since the earlier change identity hardening. Nothing surfaced it. The service stayed active, validate passed, and the failures went into a file that had grown to 429 MB on one node and 901 MB on another -- 130523 and 51374 tracebacks respectively. Nobody reads a file that size. On the owner's live node 354 inbound messages had been sitting at new since 2026-08-16, and no agent had woken for any of them.
It was found from outside, again: the session installing a node for someone else hit it on a clean install and sent it here by mail.
The mistake was in the premise. _actor() existed to decide "which agent this watcher polls as", and the watcher is not an agent: it reads the WHOLE inbound queue in order to route it, which is a node-level job. Borrowing an agent's name for node-level routing would forge its identity.
The socket, which fixed the other two call sites, does not fix this one. That is worth stating plainly because it looks like it should: mcp_messaging.py is spawned as the agent's own OS user, so SO_PEERCRED names an agent row. The dispatcher runs as smart-node-dispatcher, a service account with no agent row, and on the socket the Remote-User header is ignored entirely -- it answers no active user for identity 'unknown-peer'. Neither door will carry an agent identity on this watcher's behalf.
So the watcher calls as the node owner, at the asserted level auth.py defines as good enough for ordinary work and not for anything the owner is relied upon to have decided. Routing inbound is ordinary work.
Fixed
- The message watcher polls and marks as the node rather than as an agent, so inbound routing works and agents wake on new messages again. brin 1.7.2.
- A failing poll is loud once and then rate-limited with a back-off, instead of a traceback every ten seconds into a log nobody will ever open.
[1.12.7] - 2026-08-18
An agent could not read its own mail, on any node, and it looked like an empty inbox
Both of an agent's routes to the messages registry called core-api at its address and said who they were with a Remote-User header. core-api refuses an agent identity on that door on purpose: a header is an assertion anything on the node can make, so it answers 403 and names the unix socket, where the kernel reports the caller and the caller cannot forge it.
So every messaging call from every agent on every node returned 403. Nothing surfaced it. The tool handed the model an error object, the model read it as nothing to do, and a woken agent produced a short non-answer, left the inbound at new, and never completed the wake -- so the mechanical closer that exists for exactly this did not run either. The node looked idle. It was mute.
It was found from the outside, by a session installing a node for someone else, and then reproduced on the owner's live node, where comm.sh inbox had been answering curl exit 22 for anyone who ran it as an agent.
Two files, because the same mistake was in both and only one of them had been looked at:
companions/brin/mcp_messaging.py, the messaging MCP every agent is granted.companions/communication/tools/comm.sh, the CLI a secretary uses for the inbox work it exists to do. This is the one that blocks a coordinator agent.
Both now call the socket, which they already have the identity for: each is spawned as the agent's own OS user, and that user is in smart-node-agents, which is exactly who the socket admits. SN_CORE_API_URL still selects the address for a test bed that has no socket, and is deliberately NOT a fallback -- falling through to it would restore the 403 and report it as an empty inbox, which is how this survived a whole release cycle unseen.
Fixed
- The messaging MCP and
comm.shreach core-api over its unix socket, so an agent can read its inbox and answer. brin 1.7.1, communication 1.8.2.
[1.12.6] - 2026-08-16
One home per class, and a node that can say when that stops being true
A node's own documentation said where each kind of thing lives, and it was wrong in four places. Schedule pointed at sn_config.crons and Desk at sn_config.desks; neither table has ever existed. Secret pointed at sn_config.secrets; secrets are a sops-encrypted FILE. Workflow pointed at sn_config.flows, which exists, holds nothing, and sits beside the live sn_core.workflows that the API actually reads.
That last one is the shape worth naming: a same-named EMPTY twin answers every existence check and reads as the home of a class. This release stops the node manufacturing them. sn_config.tools, sn_config.flows and sn_config.flow_versions are retired by B02 when empty, and KEPT with a loud warning when not, because a duplicate that is in use is a finding rather than a cleanup. Nothing referenced them: on both live nodes agent_tools.tool_id points at sn_core.tools and agent_workflows.workflow_id at sn_core.workflows.
New /etc/smart-node/classes.json: one declaration per class, the registry always schema-qualified, the kind of home (a table, a file, another service), and whether the class is real or still a gap. Stamped at install with the same release written to /etc/smart-node/release.
New daily check on the node, classes-verify.py, asking whether the node still matches that declaration. It compares the STAMP first -- a file from another release makes every later comparison meaningless, and a pass there would be a lie -- then that every registry exists, that no class points at the twin of a live table, that the secret store is present and actually encrypted rather than a plaintext file at the right path, and that a class marked as a gap has not quietly acquired a home. It runs once at install into the install report, then daily on a timer.
Two gates were added to the release path so this cannot rot in canon: classes-check.sh (the declaration and the contract describe the same system) and capabilities-check.sh (every call quoted to an agent exists in the contract).
Also corrected: capabilities.md reaches the CONFIGURATOR's prompt, not every agent's. Three files said otherwise, including two written yesterday.
A node can be built from scratch again
Proving the above on a clean machine took eleven attempts and found seven defects, every one of them invisible on an existing node, because an update finds the rows, keys and integrations already there from earlier releases. Releases 1.12.0 to 1.12.5 update a node perfectly and cannot build one.
- fail2ban was dead on every fresh node. Layer A writes an sshd jail with
backend = systemdand never installedpython3-systemd, so fail2ban failed to initialise ANY backend and exited. Not a degraded jail: no fail2ban at all. The package is installed now, and a failed restart prints the reason from the log at the moment it happens instead of leaving the verify to fail bare forty seconds later. - Two foreign keys were created before the keys they reference.
usersreferencedcontacts, andmessage_identityreferencedmessages, while a dump puts every primary key at the end of the file. On an empty database postgres refuses and B02 dies. Both are now ensured in place, and the guards match onconrelid, not on the constraint NAME alone -- a name is unique per table, andpublic.messagescarries amessages_pkeyof its own. - The
core-apiintegration was created with an UPDATE, which succeeds and does nothing when the row is absent, so themessages_searchtool then failed its foreign key and core-api never started. It is an upsert now. - Three smaller ones in the new check itself: it ran in Phase 2 before the declaration it checks is laid in Phase 3.5; its output was captured into
out=$(...)underset -e, which aborted the whole companion silently; and its timer fired before the file existed, leaving afailedunit that validate correctly refused.
Worth knowing for anything added near the end of an install: phase 3.5 runs AFTER validate. sn-version, capabilities.md, classes.json and the release stamp itself are all written after the last check that could refuse them, so a node that fails validate keeps the previous release's stamp while running the new code. Everything validate inspects has to be in place before it: the class timer therefore counts its first firing from OnActiveSec, not OnBootSec, which on a long-running machine is already in the past and fires the instant the timer is enabled.
Verified end to end on a node built from the base image: validate 167/167, /etc/smart-node/classes.json stamped 1.12.6, the three duplicate tables gone, and the verifier reporting OK 33 checks: the node matches its declaration.
A release cannot be published until a node has been built from nothing on it
The seven defects above were each shipping for days behind a fully green release path, because every gate reads the REPOSITORY and none touches an empty database. install-on.sh now asks once, before Layer C, whether the target was empty, and a clean run that ends with validate passing writes release-evidence/<version>.json itself. tools/release.sh --publish refuses without it, and refuses evidence that records an update -- an update proves the update path and says nothing about the install path.
Publish-only, deliberately: gating every tag would make a full install the price of every commit, and a gate that expensive gets switched off.
[1.12.5] - 2026-08-16
Two office chat bugs, and the release carries its images again
Reopening a desk chat came back EMPTY: desk_history looked for a session keyed desk:<id>, but brin keys it per agent now (<agent>:desk:<id>), so a reload found nothing over a conversation that was all there. Fixed and tested. And an expired session showed as "the agent did not respond in time" until you manually refreshed; the office now detects the auth bounce and goes to login.
Loose end swept: this release attaches its component image tarballs (doci, mesh, planner) again -- 1.12.0 through 1.12.4 were published source-only, so a fresh install from the release stopped at the image download. Installing from a published release works again.
Components: core-api 0.19.4, office 0.5.2.
[1.12.4] - 2026-08-16
Recall stops hiding the quiet channels behind the loud one
Asked "what did we discuss by email", the voice agent answered "we did not email" over an inbox full of it: the person's cross-channel view was the recent N total, and voice -- now a row per turn -- filled it, crowding email and telegram out. Recall is now balanced, the recent N PER channel, so every channel the person used is represented (a named channel still gets a flat window). And the broken my_messages voice tool is gone: it read the agent's mailbox over a path core-api has refused since 0.18.0, returning a 403 the agent read out as "error reading my email". messages_search is the single recall tool.
Components: core-api 0.19.3, voice 1.0.4.
[1.12.3] - 2026-08-16
Voice is recorded as it is spoken
Voice was the one channel that reached the registry in a single batch at hangup: a crash, a restart or a core-api blip before the end lost the whole call, every turn shared one timestamp, and the current call was invisible to search until it ended. It is now written a turn at a time, the way every other channel already works -- keyed voice:<session>:<seq> and idempotent, with the end-of-call write kept only as a reconciliation that fills any turn a live write missed. A crash keeps what was said; timestamps are real; the current call is searchable as it goes. Verified on a live call (seq 0-6, distinct times, no duplicates).
Components: core-api 0.19.2, voice 1.0.3.
[1.12.2] - 2026-08-16
Recall is a tool every agent shares, and the voice line stops arguing with itself
The recall the last two releases wired into the prompt becomes what it should be: a core endpoint (POST /api/messages/search) exposed as a catalog tool (messages_search) with parameters -- look deeper, look at a day, look at one channel -- granted to every agent, so the voice line and the desk chat use the same tool from the DB catalogue rather than anything hardcoded. The dispatcher fills the person from the authenticated caller, so it always looks up the right person.
And the voice line stops confirming its own mistakes. Its start-of-call history block was being fed the agent's OWN past replies -- including wrong denials like "we did not talk this morning" -- and repeating them every call (the owner hit this across three morning calls). The block now carries what the CALLER said and the other channels, drops the agent's own voice turns and denials, and is framed as ground truth. A new new_conversation tool lets the caller wipe a thread that has gone wrong and start clean.
Components: core-api 0.19.1, voice 1.0.2.
[1.12.1] - 2026-08-16
The other door: the voice line recalls a person too
1.12.0 gave the office desk chat cross-channel recall, but the agent has two doors and the owner uses the other one: line.<domain>, the in-browser voice interface, is a separate runtime (the voice companion, not brin). It was still on the old cross-channel mechanism -- a static list of conversation ids read from the gateway store, unconfigured on the node -- so on the voice line the agent recalled nothing from other channels. This points the voice companion at the same cross-channel read side (GET /api/messages/by-contact, resolved by the authenticated caller), so foreman recalls the same person on the voice line as in the desk chat.
Component: voice 1.0.1.
[1.12.0] - 2026-08-16
Who is writing to us -- the person, across every channel
The first slice of the identity milestone, cut out of band because the owner hit the gap directly: an agent in the web chat could not recall the same person's telegram conversation, and the web chat -- the strongest identity the node has -- left no record in the registry at all. Every channel had been writing the same person under a different key (a telegram chat id, a mailbox, an account name), with nothing tying them together.
This release makes the person one record and the recall a query over that person, and lays the schema the trust model needs:
sn_core.message_identity-- the identity verdict recorded at arrival (message -> contact + trust + evidence), append-only besidemessages.users.contact_id(an account is a contact who can log in).contact_channelsbecomes the one handle map and records how each binding was proved (verified_by / verified_at / last_seen_at). Baked in B02; reference migration 026.- core-api
GET /api/messages/by-contactreturns a person's history across every channel, resolved by contact.POST /api/messages/record-webchatlands web-chat turns in the registry, pre-processed so an answered turn is not mistaken for work awaiting delivery. - brin folds a
[conversation with <person>]cross-channel block into a desk turn, so the agent recalls from context (~16s) instead of digging with eleven tool calls (81s measured). test_identity_across_channels.py(10 tests) -- and it earned its place: it caught the new table shipping with no grant to the app role before that could bite the stamp path.
Components: core-api 0.19.0, brin 1.7.0, communication 1.8.1.
NOT in this release, and the rest of the milestone: stamping message_identity at arrival per channel (email from Authentication-Results, telegram linked/unknown, web/voice session) and the inbound guard reading trust -- the four owner decisions for it are recorded in the design. user_channels retires into contact_channels there too.
[1.11.0] - 2026-08-15
A release tells the truth
The milestone this release is named for was mostly delivered in 1.10.4, 1.10.5 and 1.10.6, which is why this last entry is short: publication became part of the release path, installing from a release became one command, and eight component repositories were archived so a change has one place to land. What was left were the two things a node itself could not say.
A node can now say which release built it. The release has been stamped onto every node since 1.10.4, at /etc/smart-node/release, and nothing read it back: a search of the whole repository found one hit, the line that writes it. So the number was on the machine and invisible, and the install output read as a contradiction of itself -- "node built from canon release 1.10.6", then six lines later "node release 1.0.0".
They were never a contradiction. They are two numbers answering two questions, and sn-version now says so:
canon release: 1.10.6 (commit 934bf3d, installed 2026-08-15)
local changes: 1.0.0 (this node's own counter)
The first answers "what is installed on that machine" and "am I behind the latest published release", which is what updating a machine we do not own depends on. The second counts what has been touched on this node since; a fresh node reading 1.0.0 is correct, it has changed zero times. It is not the node's identity and never was, whatever the older docs said. A node with no stamp -- one hand-patched rather than installed -- reports unknown and says why, rather than substituting the other number.
Two smaller distinctions came with it. A component genuinely absent from a node now reports not installed instead of ?, so an absent thing stops looking like a broken reader. And check learned the difference between the node changing and the reader improving: without that, the moment mail began reporting "not installed", every node in the fleet would have answered "composition: CHANGED" and exited non-zero, which is what an update script keys off.
An update stops dying in silence. Under set -euo pipefail an assignment whose command substitution fails ends the script and prints nothing: the run stops on its last successful log line, naming no line, no variable and no file. Two companions read the dispatcher's address that way, so on a node whose configuration predated that key they died half-applied, silently -- and the nodes an update targets are exactly the ones written before the current assumption existed.
Eleven such assignments across five companions were found by sweeping all of them rather than fixing the two that were reported. Every one had a fallback written on the line below that had never once been reachable. One more was given a loud failure instead of a quiet one, because there is no sensible fallback for a missing key hash, but there is no excuse for not saying so.
Known and deliberately left: four vendored trees still report no version of their own. Every obvious way to give them one puts in a number that is wrong in a different way, and the gap is more honest than any of them.
[1.10.6] - 2026-08-15
One place to commit a change
Every component used to exist twice: here, and in a repository of its own. For a month every change landed here while the other place stood still and still looked like the primary one. Two sources for one program is not untidiness, it is a trap: the obvious maintenance action, refreshing this copy from "upstream", silently reverts every fix that only ever landed here, with no conflict and no warning, and the tests pass afterwards because reverted code is older code that used to work.
Eight repositories are archived, and for those components this tree is now the source: edit the file, commit it here, done. Archived means read-only and still clonable, not deleted -- each component's VENDORED marker names the repository and its last commit there, so the history stays findable, and a clone of one was performed to prove the claim rather than assume it.
Four components keep their own repositories, because they are separate products with a life outside a node: documents, memory, workflows and tracking. For those nothing changes and the re-vendoring rule still applies in full.
Rescued first, because they were the only copy: core-api's test suite (8 files and its conftest), admin-runner's three remaining tests, core-api's Dockerfile and requirements-dev.txt, and the panel's local nginx config. The test suites matter beyond tidiness: they are the precondition for ever running them.
tools/vendor-drift.sh says which is which rather than going quiet. A component whose source is this tree is reported as such, with the archived repository named. A checker that silently stopped covering eight of twelve components would be worse than one that fails.
NOTICE.md and CONTRIBUTING.md now describe the practice instead of an intention that stopped being true in July.
Nothing here changes what a node does.
[1.10.5] - 2026-08-15
Installing from a release is one command, and it refuses to install blind
A release has two halves. The repository at a tag is about 30 MB and carries the installer and every component's source. The component images are another gigabyte and are attached to the release, because building them wants 8 GB of RAM and a model download, which is not a thing to ask of the machine being installed onto. A clone without them stops halfway, and until now the second half was a paragraph of instructions rather than a command.
tools/install-from-release.sh reads the newest release, clones it, fetches the images, verifies them against the release's own SHA256SUMS, checks that every image the release's own companion scripts ask for is actually in it, and hands the result to the installer. Everything after -- is passed through unchanged, so every existing installer flag works.
It refuses rather than continues when the release has no assets, no checksums, a checksum that does not match, or is missing an image it asks for. An unverified image becomes every container the node runs, so that is the one place where saying nothing is worse than stopping. The refusal is not theoretical: a defect in this script's own asset listing made the first run fetch nothing, and it stopped at the checksum step rather than installing an empty tree.
A private repository is not a special case. Pass --token, and the clone and the downloads use it. The working copy's remote is rewritten to the plain URL afterwards, so a tree left on an operator's machine does not carry a credential.
New: docs/install-from-github.md, now the first install path the documentation offers; building from source stays as the longer road.
[1.10.4] - 2026-08-14
A release says what it is, and carries nothing it should not
The repository is published as a snapshot: the public tree is a chain of releases, never a mirror of the working history. The procedure for that was written down and then not run for seven consecutive releases, because it lived in a document rather than in the path a release takes. Four checks that a person had to remember are now four checks a release cannot skip.
The changelog is a gate, not a habit. The docs state, as a rule, that a release is not finished until its entry exists. Nothing enforced it and there was no aggregated changelog to enforce it against. This file is that changelog, and the release path refuses a version with no section here, naming it. Proved both ways: refused for a version with no entry, passed once the entry existed.
The pre-publication scan is a command with a self-test. It reads the tree a publication would actually carry rather than the working directory, counts matches instead of trusting a pipeline's exit status, and --self-test plants one violation of every kind and fails if any is missed. The first version of this scan, a year of good intentions ago, was written as grep ... | head || echo clean and reported clean whatever it found.
It draws the distinction the procedure draws: a node name in a comment recording where something was extracted from is provenance and stays; the same name in the panel, the office or the wizard is a defect.
What it found on its first real run, now fixed. The panel offered <agent>@<a reference node's name> as the example address for the email channel, so every operator on every installed node was shown a reference node's name as their own mail domain. It is derived from the hostname the panel is served on now. A vendored changelog named the private organisation twice and told one story using a real address on a domain we run; both are gone, and the same edit went upstream so the file did not become one more undeclared difference.
Nothing here changes what a node does. Update at your convenience.
[1.10.3] - 2026-08-14
Three things a node could get wrong without saying so
[1.10.2] - 2026-08-14
An update no longer stops on a node older than its own lib.sh
[1.10.1] - 2026-08-14
The owner is whoever signed in, on every node
[1.10.0] - 2026-08-14
A work area, and who may enter it
[1.9.21] - 2026-08-13
The node does no work nobody asked for, and loses nothing when it does
[1.9.20] - 2026-08-11
A connected mailbox is not an inbox of everything it holds
[1.9.19] - 2026-08-11
A failure stays a failure, and an agent has somewhere to work
[1.9.18] - 2026-08-06
The third composer is gone, and a fresh node keeps its prompt
[1.9.17] - 2026-08-06
The mailbox says when
[1.9.16] - 2026-08-06
One conversation thread per person AND agent
[1.9.15] - 2026-08-06
The timer runs the agent again, and a lease cannot outlive its run
[1.9.14] - 2026-08-06
An agent is told its own name
[1.9.13] - 2026-08-06
Thirteen rules, shorter than eleven, each with its reason
[1.9.12] - 2026-08-06
Nothing in the prompt is cut behind your back
[1.9.11] - 2026-08-06
Asked what is new, an agent answers
[1.9.10] - 2026-08-06
A call leaves a trace
[1.9.9] - 2026-08-06
The colleague has a name, and a recycled session picks up the prompt
[1.9.8] - 2026-08-06
One composition, so an agent knows the same things either way
[1.9.7] - 2026-08-06
An agent is told which memory is its own
[1.9.6] - 2026-08-06
A timer that asks whether the agent is already busy
[1.9.5] - 2026-08-06
Eleven rules, a line each
[1.9.4] - 2026-08-06
Four rules, in the registry, in the owner's words
[1.9.3] - 2026-08-06
A new node is born with what we had to add by hand
[1.9.2] - 2026-08-06
Work that is finished says so
[1.9.1] - 2026-08-06
"send me an email" now lands on the tool that sends
[1.9.0] - 2026-08-06
Prompts an agent can actually read
[1.8.8] - 2026-08-05
One person on the line, and nothing on the line that cannot be used there
[1.8.7] - 2026-08-05
The guard against a false claim now hears the tense the lie is told in
[1.8.6] - 2026-08-05
One person on the phone, and a mailbox they can actually read
[1.8.5] - 2026-08-05
An agent can be given something to READ
[1.8.4] - 2026-08-05
The answer comes back while the caller is still there
[1.8.3] - 2026-08-05
A caller hears the answer on the same call
[1.8.2] - 2026-08-05
The line answers with whoever this node put on the phone
[1.9.0] - 2026-08-05
A node no longer arrives believing it sells something
[1.8.0] - 2026-08-05
One agent, one toolset, whatever the channel
[1.7.2] - 2026-08-04
A new node's assistant can actually message the team
[1.7.1] - 2026-08-04
Voice remembers again: the extraction model had been withdrawn
[1.7.0] - 2026-08-04
A call is held in the caller's language, and voice remembers people again
[1.6.0] - 2026-08-04
A whole domain can be granted, and only by saying so
[1.5.0] - 2026-08-04
An agent knows its own address, manages the address book, and answers in your language
[1.4.1] - 2026-08-04
Forwarded mail routes to the box it landed in
[1.4.0] - 2026-08-04
An agent is woken only by a sender it was granted
[1.3.0] - 2026-08-04
An agent may write only to the contacts it was granted
[1.2.0] - 2026-08-04
The node has one exit for outbound
[1.1.0] - 2026-08-04
A node records which canon built it
1.0.1 · 2026-08-02
First numbered release. Version numbers start here; the work below predates them.