Documentation Last reviewed 2026-10-30

Changelog: September 2026

Releases shipped in September 2026.

Releases shipped in September 2026, newest first. The current releases are on the changelog.


[1.12.48] - 2026-09-29

  • Long conversations keep the context of the last model request instead of counting repeated usage reports or the whole turn as one request. When the provider supplies only a cumulative total, the context is shown as unknown rather than ending the session on a misleading limit.
  • Concurrent agents and consecutive turns keep their own actions and memory. An answer can no longer inherit tool results from another agent or an earlier request through the dispatcher's shared executor.
  • A reviewer sees tasks awaiting their review in the planner's default reading queue, alongside work assigned to them. This changes reading only; it does not grant the reviewer permission to approve or advance someone else's work.
  • On an external channel, an agent that has already sent its answer with the messaging tool no longer sends its internal summary as a second reply. Ordinary final answers and failed send attempts still follow the normal reply path.
  • An agent's system prompt no longer appears in process arguments or sudo's audit log. The gateway passes it through a private in-memory file when starting the CLI runtime.
  • A newly created agent has its system user before the API reports success, so an internal message sent immediately afterwards can start it without an “unknown user” error. If admin-runner is unavailable or provisioning fails, creation returns an error and removes the new registry entries and directory.
  • A mailbox already received by an active agent cannot be bound to another agent; the refusal names the existing holder. If duplicate bindings already exist, incoming mail is blocked for both agents, the conflict is recorded, and the letter is left unprocessed for the owner to resolve.
  • A background answer to a voice call reaches the caller while the call is open, or is emailed to the owner after hang-up. Failed delivery tells the answering agent why; if the node lacks a sending mailbox or the owner's email, it records the undelivered answer instead of claiming it arrived.
  • The sysadmin's privileged work goes through sn-op, with a recorded operation and a fresh, single-use owner approval when required. The permission follows the sysadmin role across agent renames, and an update removes the old temporary grant instead of retaining wider access.
  • Existing John configurators receive the v6 onboarding instructions in the database and their regenerated CLAUDE.md during an update. John gathers the business needs before building an approved team, explains what still needs the owner's credentials or permission, and starts each new agent's first task by message while keeping one receiving agent per mailbox.
  • The source-install documentation now explains the supported path, its limits, and the interactive Claude authorization step. Public exports omit private release records and machine details, and checks reject accidental disclosure before publication.
  • Local component image builds stay local instead of contacting a registry, and the installer removes the staged privileged wrapper after installing it. Publication also verifies its author identity, limits GitHub credential use, and requires a verified empty target for a deliberate first public release.

[1.12.47] - 2026-09-26

  • An answer a colleague writes into another agent's chat reaches the person waiting instead of vanishing. An agent that answered by sending to desk:<id> of a chat it does not own was accepted, then denied by the watcher after the fact, and the sender saw success. Now, if that chat's agent has an open question to the sender, the send is turned into the reply to it and relayed into the chat; otherwise it is refused at send time with a reason the agent can act on.
  • A background turn woken by a colleague ends in an answer to that colleague. An agent on an HTTP model could answer in plain text and never call the reply tool, so the answer was lost. On the last tool rounds of a background turn the model is told to answer and offered only the messaging tools.
  • John (the configurator) is told how models work, on every node: model is <provider>/<model>, GPT and the rest go through openrouter, GET /api/models/providers shows what the node can run and which key is missing, POST /api/models adds one, and the key is the owner's to give. docs/node/entities.md says the same.
  • An agent on an HTTP model (HTTP-model agent, cli-agent) can read a planner task, its log, comment on it, move it and search tasks, like a CLI colleague. brin fills path parameters such as {task_id} into an api row; before, it sent them literally. Moving a task moves the task and nothing else: the five rows declare closed schemas and brin refuses an argument they do not name, so a model that emits assignee beside status is told no instead of having it applied to the task. The rows go to agents on an HTTP model only; a CLI agent already has the same five through the tracking MCP server. brin 1.8.0 (dispatcher stage 0.2.9), core-api 0.20.1 (stage 0.4.22), tracking stage 0.5.7.
  • The configurator can add a model and put an agent on it without psql: core-api /api/models gained create, edit and delete, and /api/models/providers shows in one call which providers the node can run, which lacks a key, and what runs on each. The gateway now reports its backends and accepts any model enabled in the catalog. core-api 0.20.0 (stage 0.4.21), gateway 2.7.0 (stage 0.2.9).
  • A turn runs to the node's ceiling instead of being cut at about five minutes. SN_TURN_MAX_SECONDS is the turn ceiling, but the callers on the same path carried literals: the runner's wake at 310 s, three httpx clients in brin and the MCP server's default at 300 s, and the gateway's own per-line wait at a flat 300 s. Whichever fired first ended the turn at five minutes however high the ceiling stood, and the caller reported a transport error rather than a reason, so an agent doing the long part of its work -- a rebase, a test suite, a push whose pre-push check takes minutes -- looked idle and stopped. Every caller now derives its wait from the one helper (core/turn_budget.py) and waits a little longer than the thing it calls, so the gateway is the layer that ends a turn and can say why.
  • Office: chat tabs are grouped by agent with a chevron for that agent's recent chats, and a document on a phone takes the full width. office 0.5.9 (stage 1.0.12). These changes were in main without a version move.
  • doci is re-vendored from upstream c57d6c1. documents stage 0.3.5 -> 0.3.6: the stage version names the doci image, so without the move an update would keep the old image.
  • A clean install starts again (the merge review). The planner rows for HTTP agents carry a foreign key to the planner integration, which the tracking stage registers after core-api is installed; on a fresh node seed-tools failed on that key and core-api never started. seed-tools now skips the rows until the integration exists and says so, and tracking restarts core-api once after it registers the integration, so the rows are there when the install ends.
  • An update no longer strips four grants from every agent (the merge review). messages_search, my_wakes, secrets_resolve and, for the configurator, node_summary are granted in the database only; the onboarding merge on every update read grants.json alone and deleted them, and the update's grants gate stopped on it. A merge now keeps what the agent holds in the database.

[1.12.46] - 2026-09-25

Everything below ran hot on example-node on 2026-09-23 first; the release carries the same code (every file checked byte-identical against the running node) so the update replaces the hot copies instead of wiping them, as the 1.12.45 update did.

  • An office chat shows a running turn step by step again: each tool call with a short detail ("Bash: <command>") and what the agent says, in a scrolling box in the pending bubble, also for turns the page did not start. Built 2026-09-20 hot only; the 1.12.45 update removed it and the owner saw "Thinking 301s" over forty commands. Gateway stage 0.2.8, dispatcher 0.2.8, office 1.0.11.
  • The agent page in the panel builds the prompt and never edits it: Instructions first; Specialist, Policies and Workflow removed; Preview shows the real composed prompt with Generate. Fixed: saving Settings wrote the composed prompt back into the agent's instructions. Documents replace the retired agent_knowledge card. Panel 0.6.4.
  • Agent documents: core-api serves list, text, upload, read and delete for owner attachments; the prompt lists only those, not every handoff and note in memory (it held up to 100 such lines per agent); a document change regenerates the agent and restarts its open sessions.
  • Security: a desk shows only what the delivery layer passed. Any agent could write into any office chat whose id it knew. core-api now decides each desk row (own agent, system or person: delivered; any other agent: blocked and recorded), a colleague's answer sent with send is treated as the reply it is, and the system relays it into the asking agent's desk with its author named. Core-api stage 0.4.20; dispatcher polls every 2 s.
  • The installer provisions /srv/tools/host-utils (markitdown 0.1.8), without which every document upload answered 503, and gives the office its mesh address, without which the agent Documents page never loaded.
  • Workflows start from the panel again. Every run through core-api died before its first block on PermissionError: its run directories belonged to the dispatcher, which never uses them, and the permissions stage had removed the group write the installer relied on. They now belong to core-api, which runs the wrapper; verify proves it by creating a run directory as that user. Workflows stage 0.2.1.
  • The planner overview in the office counts every task: its rings and counts came from the last 100 tasks only, so every older goal read 0/0. It also reaches the tasks on the first or second screen instead of the sixth: collapsible Strategies, Projects and Goals, live and freshest first, the task table in pages of 50 that fits the page, with a Created by column, and a task opens in a side drawer. The dashboard feed and "Needs your call" draw avatars cleanly and name the agent who brought each task.
  • The panel Database page opens a row in a modal on click: every column on its own line, the whole value, JSON indented. The table cuts each cell to one line, so a payload could only be read from the hover title. Panel 0.6.4.
  • An update no longer stops because the owner changed the context threshold in the panel. The installer's check asked for the seed value 120000 rather than for the setting itself, so example-node's 1.12.45 update failed at B02 over an owner-set 150000.
  • The office agent card has a Console: what the agent is doing right now on every channel, step by step (each tool call and what it touches, what it says), and its last turn when idle. Before, only a desk chat showed steps; a task or message the runner started showed "working now" and nothing else. Gateway, brin and office.
  • The sign-in no longer drops on its own. Authum kept sessions in /tmp inside its container, collected after 24 minutes idle and lost whenever the container was recreated, while the cookie claimed 12 hours. Sessions now live in the data volume; a session ends after 12 hours without use (renewed by use) or 30 days after sign-in. When one does end, office, panel and voice say so with a way back, and a chat message being typed or sent is kept instead of lost. Authum 1.0.6. At this update every signed-in user sees "You have been signed out" once: the 1.0.5 sessions lived in the container's /tmp and do not survive its recreation.

Found by the full e2e suite, run on the 1.12.46 stand with an ordinary agent beside foreman for the first time (the 1.12.45 e2e gate had been waived):

  • An agent created without a tenant can work. The panel sends none, and the agent and its identity were stored with tenant NULL, so every call it made answered 403 "has no tenant assignment", its own inbox included. A node with one tenant now uses it; a node with several refuses the create with 400 instead of guessing.
  • A new agent no longer shows as permission drift. Its logs/, state/ and work/ were made 2755 while the declared surface says 2750, so every agent created since the last permissions apply failed the surface check. Admin-runner 1.0.1.
  • A node without a channel has comm.sh. The communication companion ran only when Telegram or mail was given, so on a channel-less node every agent was told to use /srv/tools/comm/comm.sh and it did not exist; agents could not message each other through it. The installer now installs the CLI and its tool contract on every node (communication.sh --agent-cli).
  • Two tests that checked old behaviour now check the current one: the acceptance desk checks wait for delivery (up to 6 s) instead of reading after a fixed 1 s, which the earlier change's 2 s dispatcher poll outran; the planner owner-gate e2e reads the task cap the planner enforces (default 10 now) instead of assuming 2.

[1.12.45] - 2026-09-23

  • A task awaiting the signed-in reviewer now exposes Close-to-done and Send-back on its Office card, while Planner remains the authority that checks the reviewer identity. Office 0.5.8 (stage 1.0.10).
  • Office opens every non-Markdown document, including HTML and SVG, in a script-blocking sandboxed iframe instead of inserting active content into the application page. The DOCI MCP re-vendor from the broader work is deliberately not part of this release. Office 0.5.8 (stage 1.0.10).
  • tools/update-on.sh now refuses the unsupported --target selector before node preflight and explains that it deploys the currently checked-out tree. This prevents an operator from believing a different release was selected when the updater would actually ship its local checkout.
  • Mesh's first embedding-model load runs outside uvicorn's event-loop thread. The document write can complete after its durable insert while background indexing initializes the model, and concurrent workers still load it only once. Memory stage 0.3.4.
  • Validation still names companions intentionally omitted by an install, but stops calling one “not installed and not checked” after it was installed later from the panel. Its regression fixture now asserts every check rather than only the last one.
  • Secret writers among the agents are recognised by capability (sysadmin, configurator) instead of the old slugs sysadmin and foreman. After the agent rename, no agent could grant a secret ref. Core-api 0.19.14 (stage 0.4.19).
  • The panel and core-api changes shipped hot on example-node on 2026-09-22/23: host data through core-api only, timer-driven services judged by their last run, Overview switches for the agents and the gateway, Health (was Systems), live status on Integrations, MCP and Runtimes, and a set of panel fixes. Panel 0.6.3, core-api 0.19.14 (stage 0.4.19).
  • Agent sessions are handed off when their real context reaches the threshold, not when the sum of all requests in one turn does. Before, nearly every multi-step turn ended in a handoff and a fresh session. Gateway 2.6.11 (stage 0.2.7).

[1.12.44] - 2026-09-22

  • Node-owned service MCPs can be declared as secret-store operators with --secrets-operator-users. The installer renders both Unix-socket group membership and core-api's exact OS-user allow-list from that one value, preserves it on later updates, and refuses a named account that does not exist. Anonymous TCP remains denied; no service name is trusted merely because it is a service principal.
  • Files attached in an Office chat now reach the desk's agent. The durable transcript keeps its attachment handle, while the turn names one installed retrieval command; that command runs as the agent, fetches only an approved file it may access through core-api's Unix socket, materializes it under a correctly typed name in the gateway's private temporary directory, and hands that path to built-in Read. New stored files also carry a content-derived suffix. Images, PDFs and text-like files are readable without node-local ACL, settings or prompt edits; audio/video are refused explicitly rather than guessed. The dispatcher update removes the temporary broad store ACL and direct-read settings entry after the API-gated path is healthy.
  • A colleague's answer now returns to the Office desk that asked. Opaque Claude CLI sessions pass their desk conversation to the messaging MCP, which stamps it as the origin of new colleague requests; core-api can therefore expose the eventual answer as a pending to_relay duty instead of making it indistinguishable from ordinary internal mail. Explicit relay sends do not inherit the origin again. Voice uses the same {channel, conversation} contract as the consumer instead of the unread caller key.
  • Office no longer calls an unreachable node a working agent. Five seconds of failed liveness polls replace the activity shimmer with a plain node-down notice, a minute names the last sign of life, and a recovered node settles an orphaned turn from stored history or says that the restart lost it. Stop ends the browser wait immediately even when its best-effort server abort cannot get through; a failed chat request is never posted twice blindly.
  • An external-channel turn that already replied through the messaging tool no longer sends the model's closing summary as a second Telegram message. Fast-dispatch now requires both the explicit external send action and its newly committed outbound row before suppressing the final text; ordinary replies and internal colleague handoffs keep their existing delivery.
  • An uploaded agent avatar is node state now, not a file inside the Office package. Its custom/<file> database key and /avatars/custom/<file> URL do not change: Office serves the durable state directory read-only, while a principal-gated core-api endpoint is its only application writer. Updating migrates legacy files before replacing the package, refuses conflicting copies, and never lets package cleanup delete the legacy directory. This prevents the loss from recurring; an avatar already deleted by the 1.12.43 update and absent everywhere on the node, cannot be recovered by this release.
  • Updating a node no longer replaces the setup agent's grants with the release baseline. Ordinary onboarding seeding merges extra tools, wider modes and secret references, including when the owner renamed that agent; an exact reset is a separate explicit operation. The updater snapshots effective DB grants and rendered MCP servers before and after install, rejects an unacknowledged removal or narrowing, and records the real mutation actor instead of user:panel.
  • Acceptance A9 ("one conversation, any door") is restated. It planted its facts as web-chat rows in other desks, so after desks became separate conversations it measured the bleed that fix removed and went red. It now plants the fact through a real second channel (a voice call, the same write the voice backend makes) plus a decoy in a neighbouring desk, and requires both: the new desk carries the voice fact and never the decoy. Each half was shown red before the run went green. The wider model (other threads as an index, doorless messages routed before the turn) remains outside 1.12.44.

[1.12.43] - never published

Cut in this file and never tagged. Its three entries below ship inside 1.12.44, which is the first published release to carry them. Nothing here is missing from a node updated to 1.12.44.

  • An external tool can be registered as an MCP server, spawned through a wrapper that resolves its API token from the node secret store over the core-api unix socket, so the credential lives in neither the registry nor any agent's .mcp.json; an agent without secrets: r-- and the ref in its secret_refs is refused before a request goes out. The catalog row carries the usage contract, without which the grant is dropped silently and the tool never reaches the prompt.
  • Two office desks with the same agent are two conversations again. The cross-channel history block filled its ten slots from whichever desk was most recent, so a person with two chats open had the other one pasted into this one, tagged with a channel and an age but never a thread; the agent read it as the current conversation and answered a question asked elsewhere. A turn now names its thread, and on that channel only that thread comes back. Other channels are untouched, because meeting the same person arriving by mail and then by chat is what the block is for. Both blocks that quote the person back are scoped, the cross-channel one and the conversation block the ledger builds, which had the same defect one endpoint over.
  • A hard budget stop now queues exactly one email to the registered owner per budget row and period before recording notified_at; missing configuration, a missing owner channel, or a rejected outbox write leaves the row retryable. The communication installer publishes the email actor/channel and chooses only a mailbox with installed credentials. The operator names the sender at update time; there is no default, because an address the relay cannot authenticate as produces mail that is written, blocked and reported as sent.

[1.12.42] - 2026-09-18

An agent can run on a model that is not Claude, the model it runs on is written out in full, and the office chat stays usable while an agent works.

  • A node with an agent-sysadmin OS user can take updates again: the B01 check of that user's sudo scope could never pass on such a node, so every update stopped at the first stage.
  • The office chat never blocks: you type while an agent works, each message gets its own answer, a running reply has a Stop control, the tabs show which agents are working, and drafts survive switching chats.
  • An agent's model is always <runtime>/<model> (claude-cli/sonnet, gemini/gemini-flash-latest, openrouter/openai/...), models come only from the catalog, and the catalog and every AI session carry the model's vendor. Bare names are rewritten by the update and accepted for one more release with an agent.model_legacy_alias event.
  • The per-agent run.sh, a wake path that spent the model outside brin and the gateway, is retired; agents are woken only by the Runner.
  • The gemini runtime ships: an agent on it runs through brin's tool loop with Gemini function calling and can use messaging, memory, documents and fetch. Along with it: a question an HTTP agent passes to a colleague from the office keeps its origin, the check for "I sent it" without a send no longer makes it send twice, an HTTP agent's chat shows its context meter, and a reply into a desk is no longer logged as a refused wake.
  • The panel's AI data is rendered again on a node with a lot of conversation: the session list reached jq as one argument over Linux's 128 KB limit, the unit failed on every run and install validation failed with it.
  • Panel 0.6.2: the model selector is grouped by runtime with the vendor, and the agent card shows the model among its facts.

[1.12.41] - 2026-09-18

Secrets stop trusting where a call comes from, and a session says how full it is before it fills.

  • Secret reads now require the secrets capability AND an explicit secret_refs grant; writes and deletes are limited to signed-in owner sessions, root socket callers and the owner-designated sysadmin/foreman agents. Until this release any agent on the node could set or delete ANY secret over the core-api unix socket, because that door only asked where the call came from. Every refusal now emits secret.access_denied, and an operator mutation carries a real actor instead of unknown-peer.
  • A planner task filed by an agent is created inactive: it wakes nobody until the owner approves it, and an agent may not hold more than two open tasks of its own. The rule used to live in a prompt, and a prompt rule is not enforced.
  • A session that reaches its context threshold writes a handoff document to memory and continues in a clean session, instead of leaving the CLI to compact in silence. The threshold is configurable globally and per agent, owner-gated and audited. A gateway 409 session_reset no longer costs a person their message: brin resolves the clean session and sends the same text once more.
  • The office shows how full the current session is: a bar above the composer, a percentage on each chat tab and the highest active chat on the agent card, plus a confirmed "Start clean" that is deliberately not Reload. One canonical measurement serves everyone -- the latest completed provider request against the effective threshold -- and the node-local context monitor now consumes that same API instead of parsing private CLI transcripts.

Still open, and next: an office chat still blocks input while a turn is running. On a node updated to this release the local context monitor keeps its old, divergent formula until its deployment step is run.

The candidate was built from nothing (clean install, validation 206/206), then an N-1 node at 1.12.40 was seeded, updated to this candidate (validation 207/207, agent smoke turn ok) and put through the web-chat acceptance suite: 9 passed, 0 skipped, 0 failed, returning-user PASS.

[1.12.40] - 2026-09-16

Make blocked communication safe and observable, and make agent work visible.

  • Blocked inbound mail from an unapproved stranger is hidden from agent context; an agent's own blocked outbound attempt remains visible so it can report the refusal, while blocked rows cannot be dismissed, replied to, or reclassified.
  • AI gateway usage keeps a bounded per-request ledger and exposes it separately from cumulative session totals for the admin panel.
  • Every agent turn records start/end events and the Office shows which agent is working now.

The candidate passed N-1 validation (205/205), permissions (0 undeclared paths), and the live E2E suite (3 passed, one-agent communication scenario skipped).

[1.12.39] - 2026-09-13

Approve works from the office again, the office fits a phone, and three more fixes from the node in the field

Three of the six items came from the node in the field as pull requests against 1.12.38, each with its own test and its own run on that node. The other three are the office, found by its owner using it on a phone and by assigning faces to agents.

Approve in the office failed after it had already written half the decision. The approval panel posted a comment and then patched the task's status and approved_at. The planner refuses unknown fields on a patch and approved_at is not one it accepts, so the second call failed with 422 on every node: the comment existed, the task stayed where it was, and the owner was told the decision had not been recorded. The planner now has its own doors for the three decisions, POST /api/v1/tasks/{id}/approve, /modify and /reject. Modify and reject require a note. The status move, the comment and the decision tag commit in one transaction under the task's row lock, so a second decision on a task the first one already moved is refused with 409 instead of leaving two tags. A decision is recorded in one format, a first comment line DECISION: <what> and a tag decision:<what>, so a flow gate can route on the recorded decision instead of searching prose for the word "reject". The office shows Approve, Modify and Reject, and the last two ask for the note. The decision format and the endpoints came from field-operator feedback.

Every update of a node whose setup agent had been renamed seeded a task for nobody. 1.12.38 made the onboarding seed find the setup agent by role, so a renamed agent was no longer cloned, but every later step still addressed it as foreman: grants went to an agent that does not exist (404), a planner actor foreman was registered, another "Configure this business" task was seeded for it, and a desk was bound. The owner closed that task by hand after each update. The seed now keeps the slug it found, and a setup agent under any slug other than the canonical one ends the run before the first write: a renamed node is an established node and needs nothing from the seed. A fresh node whose seed died part-way still resumes.

An update skipped the communication companion on a node where it was running. The installer decides whether to re-run that companion by looking for its contract file under /etc/smart-node/companions.d. The probe ran over ssh without sudo, the directory is not searchable by an ordinary admin user, and so the file that existed was reported absent: the update logged "not installed", skipped a companion with four running units and exited 0, which also kept the partial-update exit code from 1.12.38 from firing. The probe now asks as root, like every other remote command in that step. The agent count the installer reports after seeding counts active agents only; it used to include archived ones.

An avatar picked in the office was never saved. The agent update in core-api did not accept an avatar field. The request validated, the field was dropped, and the answer was 200, so every face picked or uploaded on any node disappeared on the next reload. The same empty update still bumped the agent's version, wrote a changelog entry, recomposed its CLAUDE.md and emitted agent.updated. core-api now writes the avatar, refuses a path that tries to leave the avatar store, and an update that carries nothing it writes returns the agent unchanged with no version bump and no event. In the office, agent pictures are larger and fill their circles.

On a phone the chat composer was half hidden under the browser's toolbar. The office shell was 100vh tall, which on mobile browsers is the height with the toolbars retracted. It is now 100dvh, the composer clears the gesture bar and stays above the on-screen keyboard, and under 760px the sidebar is a full-screen panel behind a button instead of a rail. Checked by the owner on the phone that showed it.

One chat card instead of a header row, and closing a tab no longer deletes the chat. The row under the tabs spent a whole line on a single Profile button, and the cross on a tab deleted the chat without asking. The row is gone. The agent's picture on a tab opens one card: rename the chat, copy its link, open the agent's settings, start a new chat, see the last five chats with that agent. The cross asks first and only hides the tab, through a new tab_open flag on the desk; opening the chat again brings the tab back.

Written down rather than glossed over: the office changes are proved by source tests and by the owner looking at a live node, not by a browser test on a stand; there is none. The planner's own Python tests for the decision format were not run on the node because pytest is not installed there; the transaction behaviour is proved by a source test that records every statement the pipeline issues. The installer still reads each companion's contract file without sudo when it decides whether an update may run that companion in contracts-only mode, so that mode never switches on and every update runs companions in full. That blind read is left for its own change, because fixing it turns on a mode no node has run yet.

One more, found while proving this release: when an update restarts the runner while an agent is mid-turn, that agent stays marked busy until its lease expires, up to 30 minutes, and does not take new messages until then. On the acceptance stand the update's smoke check gave up after five minutes and the agent answered fifteen seconds later. The runner and the update path are unchanged since 1.12.38, so this is not new; it is written down here because this is where it was seen.

[1.12.38] - 2026-09-12

Three defects a node in the field hit while updating, and two that stopped a clean install from finishing at all

Every item in this release was reported or found by running the thing, not by reading it. Three came from the node in the field, which updated 1.12.35 to 1.12.37 and told us what broke. The other two were waiting in 1.12.37 for anyone who installed a node without a public domain, which is every stand we build.

The onboarding seed cloned the setup agent when its owner had renamed it. The seed looked the agent up by the slug foreman. Rename it in the panel and the next update finds nothing, provisions a second setup agent with its own grants and another "set up the business" task, and the database accepts the duplicate silently. The field node went into its update with 19 agents and came out with 20, the copy carrying the same identity as the original. The lookup is now by role, which is the system's invariant and survives a rename, and the abort names the agent it found so the operator can see why the seed did nothing. sn_config.agents also gains a unique partial index on actor_id for active rows, so a duplicate identity is now refused by the database rather than discovered later by whoever owns the node.

B02 died on a table it did not own, halfway through a migration. On a node old enough to have crossed an earlier migration boundary, a table in sn_core can still be owned by postgres while B02 runs as smartnode and cannot alter it. The failure arrived as a permission error deep inside a migration and cost the field operator an hour. B02 now runs a pre-flight before any migration: it enumerates every table in sn_core and sn_config not owned by smartnode, prints the exact ALTER TABLE ... OWNER TO smartnode for each one, and stops with a non-zero exit. A node whose tables are all correctly owned passes it without printing anything.

An update without --mail-host reported success and left the mail companion behind. Mail and telegram fixes in a release never reached the node and nobody was told. A communication companion that was configured on a previous run is now re-run even when this run carries no channel credentials, and it reads the mailbox credentials out of the node's own secret store rather than asking for the password file the node already holds. A companion that was never configured is named as not installed, and the installer distinguishes a complete run from a partial one in its exit code.

A clean install with no public domain could not finish. Two companions each decided a value was meaningless without a domain, and each was contradicted by the thing it started. The documents companion wrote DOCI_DOMAIN as an empty string, which defeats the default in its own compose file, and the DOCI container refused to start without it. The office companion wrote its AUTHUM_AUTH_URL drop-in only when a public domain existed, while the office service treats that variable as required and exits without it; the node knows its auth URL regardless, because B05 writes SMART_NODE_AUTH_URL into the identity contract from the node's own FQDN, and office now reads it from there. Both were fixed against a stand rather than a reading: a clean install with no --node-domain completes with validate 203/203, and one with a domain completes with 209/209, the six extra checks being the public routes that only exist when there is a domain to route.

Written down rather than glossed over: three of the checks reviewed for this release could not fail. One asserted the absence of a pattern that its command never prints, one asked the wrong database about tables that live in another, and one matched a secret-store key shape that has never existed. Each passed review and each was caught only when someone watched it in the presence of the condition it exists to detect. A check that has only ever been seen passing carries no information. The rule that follows from that is being written as its own decision record rather than left as a lesson.

[1.12.37] - 2026-09-10

Files in the office chat, and a mailbox that no longer stops on an attachment

Most of this release is the office chat catching up with how people already use it, plus four more fixes from the node in the field and one defect that stopped mail outright.

One email with a file attached stopped the whole mailbox. The email adapter stored an attachment with ON CONFLICT (message_id, content_hash, filename) DO NOTHING, but the unique index that statement meant is partial, and PostgreSQL matches a partial index only when the statement repeats its predicate. Every letter with a file raised an error and the mailbox did not move past it. The statement now carries the predicate.

Files in the office chat. "+" opens the file picker, and a pasted screenshot or a dropped file becomes a chip above the field. Each file is stored in the node's attachment store with the chat as its parent, not kept in the browser: sn_core.message_attachments gains desk_id and scan_reason, message_id becomes nullable, and a check requires exactly one parent. Only the chat's owner writes; the owner, the chat's agent and the operator seats read; anyone else gets the same 404 as a chat that does not exist. An image is shown inline only when its bytes prove the type, SVG never is, and everything else is a download. The x on a chip deletes the stored file, and deleting a chat deletes its files. Limits are 25 MB a file and 500 MB a chat. The agent is told each file's name, type and size; reading what is inside is the next step. There is one picker rather than a separate one for images: the owner found the file picker takes images anyway, and they get the same thumbnail.

The composer and the thread. The field grows with what is typed and a long paste becomes a removable chip. The agent's turn in flight is one shimmering line instead of bouncing dots and a counter. A new chat opens at its own address, and the address follows whichever chat is on screen.

Four more fixes from field use:

  • a reply keeps the room the letter was addressed to, and an email reply threads on the Message-ID that went over the wire rather than on our row id;
  • an agent reads the messages it is a party to, and a refusal says why;
  • the reply cap counts one speaker, not one room, so a roll call to several colleagues on one thread is no longer cut off after four answers;
  • a claim the Runner holds ends with the turn, not with the half-hour lease, so an agent whose turn outlived the gateway's synchronous window is no longer deaf until the lease runs out.

A person's history is read as somebody. /api/messages/search and /api/messages/by-contact answered any caller about anyone. They now need the caller's identity, and brin and voice send it through the service-acting-for proof.

[1.12.36] - 2026-09-10

Agents that can reach each other, and one journal instead of two

Most of this release came from one node in the field and one experiment on it: making agents talk to each other by email. That night turned up ten defects in the path from an inbound message to an agent's turn, on top of three reported earlier the same week. Every one arrived with a measurement. Every one was re-applied here as our own commit and judged against this tree rather than taken as a diff, and four of the ten proposed patches did not fix what they described and were reworked. The release also stops the installer from publishing routes to names that do not exist, and moves the install journal into the journal every reader uses.

No channel could be configured on a node built from the baked schema. sn_core.message_attachments existed only in companions/core-api/migrations/, a directory nothing executes. The communication companion grants on it, the email adapter writes to it and the attachments route reads from it, so configuring any channel stopped the companion. It stayed hidden because the companion is skipped when no channel is given. The table is now in B02-sn-core-schema.sql, in that file's own shape: the table block, its keys in the constraint lists, its indexes beside the other message indexes. Pasted inline, as first proposed, it fails on a fresh database, because sn_core.messages is created further down the file.

Every planner call an agent made went to a door that refuses agents. The tool contract in tracking.sh handed agents a TCP address for the planner, in two copies carrying two different wrong values, while core-api accepts an agent identity for the planner only over the unix socket. Every such call failed, so an agent asked for its open tasks answered that it had none. Both copies now name the socket and no longer ask for a Remote-User header. A refusal message in routes/secrets.py that named a socket path which does not exist now names the real one.

One turn per agent. The communication dispatcher never took the agent lock the Runner takes, so a wake and a chat turn could run the same agent at once. sn_core.claim_agent() and sn_core.release_agent() now hold one rule for both, and the dispatcher keeps the lock through delivery of the reply, not only through the model call.

Email is back office, and an agent can see its own mail. core-api never received FAST_CHANNELS, which the communication companion owns, so the pending-work query excluded nothing and every email produced two turns on one agent. The value is now published to /etc/smart-node/fast-channels.env (0644, no secret in it) by the companion that owns it and read by the core-api unit, so install order no longer matters. /api/messages/inbox matched the agent slug only, which showed an agent everything except the letters addressed to its own mailbox. It now matches the agent's addresses as well.

A letter keeps its room. One letter to three of the node's own mailboxes carries one Message-ID, and the unique index on (channel_type, external_id) kept one row out of three. external_id is now <receiving mailbox>|<Message-ID>, and the raw Message-ID moves into the row's metadata so replies still thread; rows written before this release thread through the old value. A reply now keeps its Cc. A mailbox of this node passes the contact gate in both directions, outbound and inbound, and the gate fails closed when the catalogue cannot be read.

The turn ran blind. brin could not read its own agent ledger. core-api answered 403, brin read that as "no rows", and turns ran with no inbox section and no tool ledger. brin is now a permitted service: brin: joins voice: in the default. The allow list used to be written once, together with the service secret, so a changed default never reached a node that already had the file. It is now reconciled on every run, and the reconciliation only adds, so a clause an operator narrowed is not widened again.

Who a message is from is recorded when it arrives. sn_core.message_identity had its table, its trust check and both foreign keys, and no writer. sn_core.stamp_message_identity() now stamps every inbound message, email included, and a second stamp returns the verdict already on record rather than the one it has just computed.

Smaller fixes from the same report. The person is recalled on every channel, not only at the desk. A channel's typing hint shows while a turn runs, and a hint that fails cannot break the turn. The agent roster returns the avatar, and the voice companion is told where the avatar store lives (SN_OFFICE_URL).

A voice line could not read the task list. routes/planner.py refused a verified service acting for an agent, although the resolver in auth.py accepts exactly that pair. It now accepts it when the service secret verifies and SN_SERVICE_AGENTS permits that service to act for that agent. A bare header, a wrong secret and an unlisted service are refused as before. routes/secrets.py has the same shape and is left alone on purpose: resolving a secret on an agent's behalf is a different grant, and that decision is open.

A log line became a Host rule, one file over from last release's fix. derive_doci_host() in documents.sh logged to stdout and returned its value the same way, so on a node with no domain the log text became the Traefik Host rule and the router was rejected on every reload since 1.12.33. 1.12.35 fixed the same defect in core-api.sh. This time the tree was swept for the shape, every function that logs unredirected and is captured by $( ), and two more were fixed. Both return secrets.

One event journal. The installer wrote its events without a schema, so they landed in public.events, while everything at runtime writes sn_core.events and every reader reads it. A node's whole install and validation history sat where nothing looks. The installer now writes sn_core.events. B02 copies every public.events row across and then drops the table, in one transaction, and the four B02 checks that asserted the public pair now assert the sn_core one. Migration 008a, which consolidated the other way, carries a note explaining the reversal.

A public route is written only for a name that resolves. Declaring SMART_NODE_DOMAIN made the installer derive six names and write a router for each, whether a record existed or not. A name with no record and a certResolver asked Let's Encrypt for a certificate it could never get, until the rate limit stopped it. One gate in bootstrap/lib.sh now decides for every writer and every check. No record while the parent domain resolves means skip, and retire the file. Neither resolving means write and warn, because a resolver that cannot answer must not be able to take down a node's front door. SMART_NODE_ROUTE_REQUIRE_DNS=0 turns the gate off.

Known, and not fixed here. A message an agent failed to handle never wakes anyone again. An empty wake costs a model call and can chain between agents with no mechanical brake. validate does not read Traefik, so a router Traefik rejects is still invisible to it. An update run upgrades the host's OS packages in Layer A, and needrestart then restarts PostgreSQL, sshd and the node's services in the middle of the run. SMART_NODE_ROUTE_REQUIRE_DNS is read from the install environment only and is not carried forward to the next run. A node installed without --node-domain still cannot start Office: office.sh writes AUTHUM_AUTH_URL only when SMART_NODE_DOMAIN is set, and Office refuses to start without it, so the service restarts in a loop. Every node in the field has a domain, which is why this has not bitten one; the no-domain path is still not fixed. An update does not re-run the communication companion, so a node with channels must re-run it once after updating to take this release's mail fixes; the upgrade notes say how.

[1.12.35] - 2026-09-09

A documents page that is not empty, and a release that says what it did

Every node running 1.12.33 or 1.12.34 served a blank documents page, and every install of either had to build the doci images itself because none had been published. Neither fact was visible from inside the release: the tags existed, validate passed, and the installer reported success. This release fixes the three independent causes of the empty page, publishes the images, lands the identity data 1.12.33 promised, closes the reporting holes that let a failed update look clean, and takes in two reviewed fixes that were sitting on branches: the preflight RAM floor and a durable home for the voice hostname.

The images are published. The registry token gained write:packages, and the doci companion images were built, scanned and pushed. Both digests are pinned in companions/IMAGE_DIGESTS, so an install resolves an exact image rather than a moving tag.

This is a reproducibility fix, not a rescue: 1.12.33 and 1.12.34 did install. obtain_image tries the registry first and falls back to a tarball and then to building the component on the node, which was added for a node installed straight from a published release. So every install of the last two releases spent about eight and a half minutes building doci on an LXC stand, and got whatever that node's build produced rather than the artifact we scanned. That is the gap this closes.

The documents page was empty, for three unrelated reasons.

companions/doci was taken from upstream on 2026-05-27, changed four times in place, and never refreshed. It shipped as 0.2.0-rc. Office has called GET /api/list.php since its Documents section shipped and that build has no such file, so the page rendered empty and every request 404d on a clean install as much as an updated one. The copy is now re-vendored from upstream 0.3.2. The debt went up first, so nothing is carried forward a second time: the handler-set HTTP status fix, which lived only here, and Dockerfile.mcp, whose mcp_server.py had always been upstream.

It could drift that far because doci was the one vendored companion with no VENDORED marker, so tools/vendor-drift.sh did not watch it. The marker now names the upstream, the commit, and the two differences this copy keeps deliberately.

companions/documents.sh returned early on docker image inspect "$tag", and a tag is not evidence of anything. It is keyed to the companion's STAGE_VERSION, while the contents come from companions/doci/, and the two move independently. Refresh the component without bumping the stage and every node holding the tag skips the load and keeps the old image indefinitely. The guard now compares the version the image carries against the version in the tree and reloads when they differ. It deliberately does not fingerprint the source tree: a hash cannot be checked against an image that arrived as a tarball or a registry digest. A missing or unreadable VERSION on either side is not a mismatch, so nothing becomes stricter by accident.

companions/office.sh wrote the DOCI_URL derivation as one inline ExecStartPre line with a command substitution in it. systemd performs no command substitution, and its own quote handling took the nested script apart, so %s was filled with $0:

DOCI_URL=http:///bin/bash

Nothing complained, because EnvironmentFile=- swallows a bad file by design and Office refused to start only on an EMPTY value. The derivation now lives in /opt/smart-node/ops/doci-url.sh, where the shell owns its own quoting, and the drop-in resets ExecStartPre= before setting it so a re-run replaces rather than appends. When doci is not up yet the helper writes an empty file rather than a wrong one. Office also now rejects an address with no host. Worth knowing for anyone writing the same check elsewhere: new URL() does not catch this. WHATWG parsing collapses the empty authority, so http:///bin/bash comes back as host bin, path /bash, and a hostname test passes it. The tell is in the raw string, scheme:///.

the identity layer landed as a schema and nothing else on any node that already existed. Measured on a long-running node after updating 1.12.29 to 1.12.33: no agent, user or contact had an actor_id, and no row in sn_core.actors carried a canonical id, alias, kind or relation. Every column, index, constraint and the v_actor_events view was present and no row carried a value, so the release's own headline was absent precisely on the nodes that had the problem it was written to solve. The cause is that the data steps never ran anywhere: companions/core-api/migrations/ is reference only, and nothing in bootstrap or the companions reads that directory. B02 now carries the backfill from migrations 036 and 034, guarded on actor_id IS NULL and NOT EXISTS, so re-running is a no-op and a fresh install is untouched. Deliberately left out: migration 033's alias mapping, which encodes one node's history and has no portable form; migration 037's contacts population, whose rule is WHERE id = 1, so contacts.actor_id is left NULL rather than guessed; and the NOT NULL steps, which apply a constraint to data nobody has reviewed. Verified on an LXD node carried across many releases: every agent and account resolves, no new actor rows created, validate PASS 223/223.

A skipped route is retired, not left on disk. All four companions that write a Traefik file route -- office, voice, core-api and documents -- returned early without touching the file, so whatever the previous release wrote stayed there and Traefik kept serving it. Two ways that bit a live node: 1.12.29-era 70-office.yml and 70-voice.yml carrying the a hard-coded bridge gateway survived into a 1.12.33 node and failed the new bridge-literal check, and a 30-core-api.yml whose Host rule was a captured log line was preserved by this very guard on every run after the one that wrote it. Both had to be repaired by hand. manifest_retire_artifact, added in 1.12.32 for this exact shape, is now used in all four, and each site distinguishes "route retired" from "no route to write" in its log.

core-api was off the web, or pointed somewhere nothing could reach. Four fixes in the same area:

B03-routing.sh starts Traefik with --add-host host.docker.internal:host-gateway. companion file routes now use that name and run_traefik() never passed it, so the name did not resolve inside the container. On a node with a domain that took core-api off the web, and nothing reported it: the route file is syntactically valid and validate does not resolve names. core-api.sh no longer lets a log line become the router hostname. derive_panel_host() logs on the no-domain path and then echoes the empty string, and log() writes to stdout, so the log text landed in panel_host and the [[ -z ]] guard never fired. The existing 2>/dev/null could not help. dispatcher.sh registers core-api at 127.0.0.1, not host.docker.internal. Both readers are native: brin is a systemd unit running uvicorn, and tools/update-on.sh Phase 4 curls the endpoint from the node host. Measured on a 1.12.33 node host, host.docker.internal:8030 returns 000 and 127.0.0.1:8030 returns 200, which is what made Phase 4 smoke fail. 127.0.0.1 is equally stable against bridge renumbering, which was the point. seed-tools.py normalises the stored host ahead of its upsert. The upsert is deliberately conservative, COALESCE(NULLIF(existing, ''), EXCLUDED), so an already stored wrong value was never corrected by re-installing. The guard is the endpoint itself rather than a release number, so it is idempotent and runs from ExecStartPre on every core-api start.

A failed update reported itself as clean. tools/update-on.sh judged the synchronous install by the wrapper script's own exit status, and that script ends with echo ${PIPESTATUS[0]} > EXIT_CODE_FILE, so it exits with the echo's status: zero, always. On a live node install-on.sh exited 3, the exit file said 3, and Phase 2 printed install: ok -- installer exited 0. The run only turned red because validate independently failed. The synchronous branch now reads the exit file the way the tmux branch already did, and treats a missing file as a failure. Separately, Phase 3 ran validate with 2>/dev/null, which discarded the [VERIFY-FAIL] lines at the moment they were produced while the report told the reader to look for them in a log that never receives them. stderr now goes to a file on the node and up to twenty failure lines are printed under the failure.

Preflight refused a build that no longer happens. tools/preflight.sh held an 8192 MB floor whose comment named the mesh image build, and that build was removed. What build-images.sh builds today is doci and doci-mcp. Preparing the 1.12.33 clean install the gate refused this node at 8179 MB, then at 8188 MB after four idle stands were stopped: four megabytes short, defending a requirement deleted eleven tasks earlier. A gate that close to the line gets ignored, and ignoring a gate is the wrong habit to teach around an installer. The floor is now derived from what is actually built, labelled as an estimate from Dockerfile inspection, and the failure text names that build. Separately, run as a normal user, preflight reported LXD storage pool 'default' missing and LXD network 'lxdbr0' missing when both exist. The real error was one level down and got swallowed: the LXD unix socket is not readable without sudo. It now distinguishes "cannot reach the socket" from "the pool is not there", because the old remedy it printed, lxd init, is dangerous advice on a host already running containers.

The voice line's real name could not survive an update. voice.sh reads SMART_NODE_VOICE_HOSTNAME and the header explains why a node whose voice line is already known by another name should say so rather than have a second name invented for it. The design was right and there was nowhere to write it down: the variable came from the process environment and from nothing else, no companion wrote it, and no carry-forward restored it. So a name set on one install was silently replaced by voice.<SMART_NODE_DOMAIN> on the next update, and the only symptom was that the line stopped answering. This repeats a prior routing failure: an environment variable passed by hand is not a repair, it is a demonstration. The value now lives in /etc/smart-node/routing.env, written by B03-routing.sh with the same carry-forward the other routing values get, and voice.sh sources it there. Environment override still wins. Empty stays legal, unlike SMART_NODE_DOMAIN, because an unset voice hostname has a defined and correct meaning; set it to - to clear a stored value back to the default.

Known, and not fixed here. The route retirement above removes the stale-file half of 1.12.34's known issue, but the routing amendment and two stand runs remain open, with and without a domain, have not been done, and docs/repo-map.html does not yet describe the doci lineage.

[1.12.34] - 2026-09-08

Hotfix: the update path

1.12.33 could not update a node that already existed. This release fixes that and changes nothing else. A node installed from nothing on 1.12.33 is unaffected and does not need this.

B02 constrained a column that does not exist yet on an existing node. The baked schema creates sn_config.agents with actor_id, so on an empty target the foreign key it adds a few lines later has something to point at. On a node that already has the table the create is a no-op and the column arrives from core-api migration 036, which runs in Phase 2, after Layer C. So Layer C added a constraint for a column that did not exist until later, and the schema stage aborted:

psql: ERROR: column "actor_id" referenced in foreign key constraint does not exist
CONTEXT: ALTER TABLE sn_config.agents ADD CONSTRAINT agents_actor_id_fkey ...

The three actor_id foreign keys (agents, users, contacts) now sit in guards that check that the column exists and that the constraint does not, and the migrations delivering those columns add their own constraints. The actor_id indexes are guarded the same way: CREATE INDEX IF NOT EXISTS guards the index name, not the column, so it aborted the stage one statement later.

Proved on a node with a past, which is where the defect lived: existing-node, installed 2026-09-02, updated to this release with B02 passing and every companion completing.

Known, and not fixed here. On a node with NO domain, office.sh skips writing its Traefik route and leaves the previous release file in place, so a bridge literal from an older release survives an update and validate reports it, 2 checks of 208. A node with a domain is unaffected.

[1.12.33] - 2026-09-07

The identity layer arrives in four steps

The identity migration follows a fifteen-step plan to give every actor on the node a stable, canonical identity that survives renames, role changes and the passage of time. Four of those steps ship in this release: alias resolution, actor_id on user accounts, actor_id on agents, and actor_id on contacts.

Step 1 is housekeeping that makes steps 2 and 3 safe. The sn_core.actors table had accumulated rows from a period when the event-emitter used the raw actor string as the row ID, so the same person could appear as user:admin, admin, and user:<name> depending on which code path fired. This migration adds canonical_id and aliased_at to the table, provisions the canonical rows that were missing, and populates the alias pointers. It also adds a self-referential CHECK so no row can point to itself as its own canonical. The v_actor_events view is created: it adds a canonical_actor column to every event row so callers can group by identity rather than by whichever string happened to be written that day. Migration 033 also provisions component:claude and component:panel and aliases user:anonymous, user:unknown-peer, user:panel, user:claude and user:owner onto their canonical rows, so the prefix rule does not classify the operator, the panel and two placeholder identities as people.

Step 2 adds actor_id to sn_config.users. Every account -- owner, operator, or agent-backed -- now carries a foreign key into sn_core.actors. The migration provisions any missing actor rows, populates actor_id for every existing account using the canonical resolution from step 1, then applies NOT NULL if every row is populated. If any row remains null (unexpected on a clean node), the constraint is deferred with a NOTICE rather than stopping the migration.

Step 3 adds actor_id to sn_config.agents. Active agents receive the same treatment: actor row provisioned if absent, actor_id populated, then NOT NULL applied. Archived residue is intentionally excluded: agent rows with archived_at set do not receive an actor_id and are not required to have one. The NOT NULL check for step 3 is harder than step 2: the migration asserts zero nulls with RAISE EXCEPTION and stops the schema stage if any are found. See the upgrade notes for the one case where an existing node can trigger this.

Step 4 adds actor_id to sn_config.contacts. Two columns land on sn_core.actors first: kind and relation, the two classification axes. Every actor in the table is classified by prefix rule, then actor_id is populated on sn_config.contacts from the resolved canonical IDs. The practical result is that the owner's contacts row and users row now resolve to the same actor (user:admin), which is the join that failed on 2026-09-05 and produced two divergent records for the same person. Contacts outside the business can be provisioned as their own canonical actor (relation=external) and are not merged with the operator's own actor row.

Three bug fixes shipped in the same window. The planner no longer overwrites a reviewer that was set before work started. The brin runner holds its task claim for the duration of a long turn rather than releasing it on a 202 response and then re-acquiring it on the next wake, which was producing spurious re-runs. The planner's read-task instruction was being written twice into the agent briefing; it is written once now.

Routing writes less when less is set (B03 0.2.1). SMART_NODE_PUBLIC_DOMAIN and SMART_NODE_INTERNAL_DOMAIN are now written to routing.env only when they carry a non-empty value with a defined distinct meaning. When unset, they have no meaning distinct from SMART_NODE_DOMAIN and their presence in the file would only mislead. Carry-forward functions continue to restore previously-set values on update runs.

[1.12.32] - 2026-09-06

The one that actually installs

1.12.30 and 1.12.31 were both tagged and both withdrawn, neither published. This is the third attempt at the same release and the first that survives an update on a node with a history. What ships is unchanged from what 1.12.30's entry describes; what changed three times is the install path.

1.12.31 failed validation on any node that had ever run an earlier release. Two defects, both invisible on a clean stand, both found within four minutes of updating a real node.

The first: check_pg_listen_addresses split its input with an unquoted expansion, for addr in ${declared//,/ }. the installer writes listen_addresses = '*', so bash pathname-expanded it and the check asserted that postgres was listening on every filename in the working directory:

[VERIFY-FAIL] postgres: actually listening on snap:5432
[VERIFY-FAIL] postgres: actually listening on sn-stand-install.log:5432

The guard for '' sitting right below it never fired, because there was no left to match. It passed on the stand because an unmatched glob stays literal and the stand ran from an empty directory. Split with read -ra now, which does not expand.

The second: the installer deletes the postgres docker boot-order dropin on purpose, but the manifest row for it belongs to the memory stage, and manifest_retire_stale is stage-scoped and runs when a stage finishes. Memory finished at 09:45 with the file still present; the documents companion deleted it at 09:48; validate failed at 09:52 on a file the release had removed deliberately. This is a cross-stage version of the same manifest problem: one stage deletes another stage's artifact. bootstrap/lib.sh gains manifest_retire_artifact TYPE VALUE, called where the file is actually removed, so the code that deletes an artifact withdraws the claim in the same breath.

Both mattered more than a failed check. The installer exits 6 on a validation failure, so finalize never runs: the node came up healthy, twelve services up, core-api answering on loopback as required for native callers, and /etc/smart-node/release still named the previous version. A node running new code under an old stamp is worse than a node that refused the update.

And the lesson, which is not about either bug. Both need a node with a past to appear: one needs a non-empty working directory, the other a manifest written by an earlier release. A clean install cannot produce either, so "proved on a stand" is a weaker sentence than it reads. 1.12.30's blocker went the other way -- it needed a machine that had never seen the unit before -- so the pair of them together say the same thing from both ends: one stand is not a proof.

[1.12.31] - 2026-09-06

WITHDRAWN, never published -- superseded by 1.12.32, which carries everything below plus two further fixes. Kept because the reasoning still applies.

1.12.30 plus the directory it forgot to create

1.12.30 was tagged and never published. It could not start core-api on any node that did not already have /srv/data/attachments, which is every node. The attachment work in 1.12.30 added the path to the unit:

Environment=ATTACHMENT_DIR=/srv/data/attachments
ReadWritePaths=... /srv/data/attachments

and nothing created it. systemd refuses to start a unit whose ReadWritePaths entry is missing, and it refuses at step NAMESPACE -- before the process runs -- so the service cannot create the directory on first start the way a service normally would. The install stops with status=226/NAMESPACE and core-api down, which on this node is not a degraded feature but the write side of everything.

lay_srv_skeleton() creates the directory now, with the same ownership as the rest of the projection tree, and records it in the install manifest so validate.sh walks it.

Everything else in this release is 1.12.30 unchanged. Its entry below stands and describes what you are installing: native and container address rules, the image scanner that no longer refuses its own dependencies, the secrets URL that agents can actually call, inbound email attachments, and the release tooling that picks its own tier. Read that entry; this one only says why the number moved.

Worth recording, because the gates did not catch it. Every release gate passed on 1.12.30, twice. The tests passed, the image scan passed, the tree was clean. Nothing in the release path starts a unit, so nothing in the release path can catch a unit that will not start. What caught it was installing on a machine that had never seen the unit before, which took eleven seconds to provision from the golden image and four minutes to fail. A static check -- every ReadWritePaths, ReadOnlyPaths and StateDirectory in a companion-written unit must be a path that companion also creates -- would have failed at --check, and is filed.

[1.12.30] - 2026-09-06

The release that stops artifacts carrying an address at all

1.12.29 taught the node to derive its addresses at run time and reconcile every artifact against what it found. It worked, and it left the actual problem standing: the artifacts still CARRIED an address, so every install, every renumbering and every newly written file was another chance to carry a stale one. Reconciliation is a repair loop around a design that keeps breaking.

A service endpoint is now one of exactly two values. 127.0.0.1:PORT when a native process calls a native service, host.docker.internal:PORT when a container does. Nothing else SHOULD be written; two artifacts still are, and they are named below. The services those callers reach bind 0.0.0.0 and the access boundary moves to where it belongs: ufw rules written by each companion's open_firewall(), rather than a bind address doing security work it was never designed for. Eight services changed bind address (core-api 8030, dispatcher 8101, office 8050, voice 8001, the MCP bridges on 8100/8102/8300, postgres 5432), the doci container is invoked with --add-host=host.docker.internal:host-gateway, postgres listens on * with pg_hba.conf scoped to localhost and the bridge CIDR, and the mesh relay unit is deleted outright -- its entire job was forwarding an address that no longer needs forwarding.

Remaining bridge addresses on a clean install. Two files still carry the bridge address: /etc/smart-node/core-api.env, which every native caller reads, and /etc/smart-node/capabilities.md, whose line 20 tells every agent the base URL for core-api. Both are written by orchestrator/install-on.sh rather than by a companion, and the implementation swept companions/. Correcting them is not a substitution: the orchestrator writes that file before the first companion runs, when core-api has not rebound yet, so writing loopback there would break the memory companion's registration on an update. That update-order fix is outside this release. The rest of the address migration is proved on a clean install: loopback answers, the container path resolves, the relay unit is gone, postgres listens on *.

The scanner that read every image also refused every push. scan-images.sh shipped in this cycle and within an hour it was failing the release gate, and therefore the pre-push hook, on two findings that were not ours: a vendored cryptography file that parses SSH key formats and therefore contains the strings a credential scanner looks for, and pip's own build-host paths recorded inside site-packages. Dependency trees are excluded now and the self-test proves the exclusion rather than only the detection. This matters more than the noise it removed: a gate that must be walked past to do ordinary work stops being read, and the day it finds something real it is waved through with the same flag.

The secrets API is documented as the form that exists. The seeded tool contract said GET /api/secrets/{ref}/resolve. The route is GET /api/secrets/resolve?ref=<ref>; the documented form returns 405. An agent followed the contract it was given, was refused, concluded it had no git credentials, and asked the owner to push by hand three times. It had the grant and the secret resolved fine. Two characters, one night. The fix reaches an agent only when the installed seed-tools.py is the fixed one, which is why it is in a release rather than in a commit.

Inbound email attachments are stored and retrievable. Capture, storage under YYYY/MM/UUID.bin, message-level access checks, and configurable caps. The NDR on a cap breach and the retention sweep are deliberately not here; they remain separate work, as decided in review.

The release tooling chooses its own procedure. release.sh computes the tier from the diff -- bootstrap, orchestrator, top-level companion scripts, installers and migrations force tier 3 -- and refuses to be lowered, though it can be raised. A schema change can no longer ship as a hotfix because somebody picked the wrong number. config-supply-check gained a BLOCKING set, the e2e suite writes its evidence where the gate reads it, and versions.sh --check and the runbook agree on the doci companion's version.

Voice is in this release and is not a feature of it. The route publishes under the public name and the ufw rule Traefik needs exists. The owner reports the line does not connect and a call does not go through. The code ships because it is already on main; the capability is unproved and this entry will not claim otherwise. The voice key was waived into this release's scope.

[1.12.29] - 2026-09-05

The release that stops the node lying to itself about its own addresses

Its scope was chosen as four items and it did not stay there. The owner merged everything that was ready rather than holding at four, so this entry names all of it, and the evidence covers all of it. What follows is grouped by what it does for a node, not by task number.

Addresses are derived once and read at the point of use. 1.12.28 took seventy minutes and five install attempts to deliver a two-file change, and three of the four failures were the same root cause in different clothes: an address discovered at install time, baked into an artifact, and never revisited. The docker network is now created with an explicit subnet, so a renumbering cannot invalidate what was written; the gateway is derived at runtime and recorded in routing.env; the bootstrap reads that instead of a compiled constant; and validate.sh now scans the RUNNING node -- systemd units and drop-ins, /etc/smart-node including traefik's dynamic config, component .env files, MCP shims, and the database columns that compose an agent's prompt -- for bridge-address literals, naming every finding with its file and line. Source-only scanning let broken files survive: the cleanup covered shell and Python, while neither pre-publish.sh nor config-supply-check reads markdown.

The office publishes under the domain it was given, and nobody is sent to a retired hostname. office.sh derived its host from hostname -f and published the router under the internal name rather than the public one, so every path answered 404. It reads routing.env now and REFUSES rather than guessing: a plausible wrong answer is the defect. B05 supplies AUTHUM_DEFAULT_REDIRECT, which nothing had been supplying, so authum no longer falls back to a hostname we retired in August.

The schema stage yields to live traffic instead of deadlocking against it. Updating a working node died in B02 with a bare deadlock detected: the stage wanted an exclusive lock on sn_config.users while a live agent session held it and was waiting to read sn_config.contact_channels. The stand had taken the same release minutes earlier and passed, because the stand is idle. Both halves are in, because neither is enough alone. The schema files are applied under lock_timeout and statement_timeout and retried a bounded number of times, so the stage is never chosen as the victim of somebody else's cycle; a refusal names the relation, resolved from its oid, and the process holding it, with its query. And the wakers are paused around the stage and always restarted, under a trap, with the services and the duration written into the report -- an update that silently stops the agents is its own class of surprise.

An update is no longer a twenty-minute guess. The updater polls an exit-code file instead of timing out, and a companion can be run against its contracts only, which takes a run from twenty to thirty-five minutes down to about three. Every one of the twelve companions carries a written decision about what is in its fast half and what is not, because a contract write misfiled into the skippable half stops propagating and nothing goes red.

The tests that existed and never ran now run, and the gate can refuse. tests/run-source.sh is invoked by the release path, which is the first time those regression tests have executed since they were written. run-e2e.sh writes its evidence where the gate can see it. tests/schema-lock-yield.test.sh joins them, covering the deadlock behaviour with psql and systemctl stubbed so it needs no cluster.

The installer refuses instead of finishing an install nobody can use. It now fails when the seed provisioned no agents, rather than reporting success on a node with an empty roster. Companion uninstall paths carry destructive safeguards, and the --companions-only mode enters Phase 2 instead of stopping short.

The planner stops recording things that did not happen. completed_at is set on every done transition -- it had been NULL for every close; closing a task now requires a comment and the named reviewer; and an objective can be closed through the MCP, which previously had no such tool at all. Notifications guard the task link against an unset console URL on every channel, and the link now carries the public name, so it opens from a phone without the VPN.

Agents gained two capabilities. A node lifecycle toolset -- provision, destroy, status -- so an agent can stand up a throwaway node instead of waiting for the owner's hands, and the flow layer can set a status and assign a task through the planner API. The release includes both capabilities and the golden stand image builder.

PROVED BY RUNNING IT, twice, on a stand first and then on a node that was doing its job:

sn-stand    install exit 0 in 5 min, validate 207/207, smoke ok ($0.16)
live node   install exit 0 in 8 min, validate 217/217, smoke ok ($0.25),
            and the schema stage reported
            "smart-node-runner.service smart-node-communication-dispatch.service
             paused for 1s"

The stand run is not a formality: it caught a regression this release had already merged. Deleting the office's hostname fallback outright meant a node whose routing contract names no domain -- a supported, internal-only shape -- could not install its office at all. The order is now public domain, internal domain, then the host FQDN with a warning that names what it chose.

That matters more than usual here, because four acceptance runs of this release found three defects and not one of them was findable by reading. The branch was reviewed twice and all three were missed: a validate check that returned non-zero when it found nothing and so failed on a healthy node and passed on a dirty one; a source document carrying a dead address that the installer copied into an agent's prompt; and the office and authum defects above. Put the conclusion where it will be read: bash -n passing is not evidence. Put a run behind every acceptance claim.

[1.12.28] - 2026-09-05

An update that finishes

One defect, and it is the reason our own node spent two days running 1.12.27 while telling everyone it was 1.12.24.

Two verification checks asked whether a port was listening in the same second the service had been restarted. configure/configure-host.sh asked about :9100 after restarting prometheus-node-exporter, and companions/office.sh asked about the office port immediately after restarting it. Neither waited. Both services were healthy every time, and running the same command by hand a few seconds later passed. The checks were right about what they asserted and wrong about when they asked.

The cost was not a red line in a log. Both sit on the update path, and the release stamp is written at the very end of install-on.sh, so a run that stopped at either never reached it. Four attempts to update this node stopped that way, twice at each check, and the node ended up carrying every component at its 1.12.27 version under a file that said 1.12.24. A node that is updated and cannot say so.

Both now use the wait_healthy() shape that has been in companions/admin-runner.sh: thirty attempts, one second apart, returning as soon as the port answers. The assertion is unchanged and so is its severity. A service that has not bound its port in thirty seconds still fails the phase, and the message still names the port.

Proved on a stand before this was tagged, both halves. With the service up the check costs zero seconds, because the loop breaks on the first successful probe, so no node pays for the patience. With the service stopped the phase still fails, in 31 seconds, with [VERIFY-FAIL] office listening 8050 (not up after 30s) and a non-zero exit. The update itself reached the end and stamped: installer exit 0 in six minutes, validate 205/205.

And then the fixed check immediately caught a second defect, which is the point of fixing it. The office systemd unit shipped with Environment=HOST=172.18.0.1 written into it, a docker bridge gateway that happened to be right on the machine the unit was authored on. office.sh copied that unit verbatim, patching only ExecStart, while computing the LIVE gateway for the traefik route and for its own verify. On any node whose docker network was created after that one, the two disagree: the office binds an address nothing routes to, the route points at an address nothing listens on, and the check waits thirty seconds before saying so.

It is invisible on a fresh install, where the unit and the network are written in the same minute and cannot disagree. It appears on a node with history. This node had it: office was bound to 172.18.0.1 while the smart-node network gateway had become 172.19.0.1, so office.example-node.internal was reaching nothing behind its login redirect.

The unit's address is now substituted from the live gateway the same way ExecStart is, and the install refuses if the substitution did not take. The deeper cause, that docker network create is called with no --subnet so the gateway moves at all, is not fixed here.

[1.12.27] - 2026-09-04

A node that comes up with somebody on it

Three of the four defects in this release are the same defect. On 2026-09-02 a cleanup removed every hardcoded container-bridge address from the tree, 59 files, on the stated reasoning that "deployments always set the env var; an empty default fails obviously if not set". Neither half held. Nothing set three of those names, and none of the three failed obviously.

A clean install provisioned no agents at all. The onboarding seed reads the core-api address from SN_CORE_API, its own header says the installer supplies it, and the installer never passed it. Every call went to an empty URL, returned 000, printed a warning, and the seed exited 0 reporting success. The node came up and there was nobody on it to do work. The seed now reads the address from the node's own contract, refuses loudly if it is missing from all three places it could come from, and seeds the planner task through the proxied API instead of a container that stopped existing in 1.12.25. The installer reports the agent count after the seed, because a count of zero is a failure with a number on it.

Workflow launches were dead on every node. Same shape: SN_CORE_EVENTS was read with an empty default and supplied nowhere, so every launch failed at its first event. The installer writes it into core-api's service environment, and the spawned process inherits it.

An assigned task woke nobody. PLANNER_NOTIFY_URL the same, and worse to find: the call sits inside a best-effort try, so the failure became a log line and the task simply sat there with an assignee.

Every update reported FAILED on a healthy node. The smoke phase reads core-api's endpoint from sn_config.integrations, and the installer left that row empty, so the phase failed after install and validation had both passed. The endpoint is written now, the phase distinguishes an empty value from a missing row, and a node with no agents skips the phase with that reason stated rather than failing the update.

The release gate added in 1.12.26 refuses a tree that reads a required address nothing supplies. Its exemption list is three names shorter, and the release policy now defines when a known entry blocks publication rather than recording debt.

Security, and these can break tooling built against the node. The secrets endpoints are no longer reachable from the agent network: DELETE is unix-socket only, SET and /refs unix-socket or loopback. Agents that need a secret read it through a grant over the socket, and every write keeps an encrypted snapshot of the previous value for thirty days. Outbound messages that solicit credentials do not leave the node, and CONTACT_GATE is on by default for new nodes. cross-channel-history requires an agent parameter and is scoped to the agent and person pair, so one agent can no longer be handed another agent's conversation with the same human.

Also: agents can create and read planner objectives and record their own tags on a task, which a person had been transcribing by hand for every review. Core-api host discovery no longer falls back to a literal bridge address; if it cannot determine the host it refuses and names the override.

[1.12.26] - 2026-09-03

A release you can install with nothing but the code

What we publish is a source repository, and until now it could not build a node on its own. The documents companion is the only component that still needs a container image, and on finding no registry and no prebuilt tarball it stopped and printed instructions telling a person to run docker build and docker save | gzip by hand -- while the recipe sat in the next directory. A release carries companions/doci in full, Dockerfile included; only the built tarballs are left out, because they are build artefacts. The companion now builds what it needs, in order: registry digest, tarball, source.

The note that said a node must not build its own image blamed docker build for hanging under LXC. It is buildkit that hangs. With the legacy builder both images build in about eight and a half minutes on an LXC stand and come out the size of the ones we used to ship, under a thirty-minute ceiling so a hang is a failure with a time on it rather than an install wedged for ever.

And the fetcher stops refusing its own releases. install-from-release.sh rejected any release with no files attached to it, which now is every release: images moved to a registry and the check stayed behind. It refused on the operator's machine, before cloning, so the fix could not reach anyone by shipping inside the release they could not fetch. If you are on an older node, replace that one script by hand once.

A node that updates can finish. Two defects found by a customer node the day it took 1.12.25, both from one blind spot: our stands are always built from nothing, so the updating path is the one nobody proves.

The first stopped the install at the permissions gate with nineteen undeclared writable directories. tracking.sh and memory.sh copy their source with rsync -a, which carries the modes of the clone, and git does not track directory modes, so a checkout made under umask 002 arrives as 775 and the installer's own gate refuses it. voice.sh and workflows.sh have normalised modes after the copy now; when the task queue and memory stopped being containers in 1.12.25 they inherited the rsync and not the line beside it.

The second failed validation on three containers it is correct not to have. The install manifest only ever grew: 1.12.25 moved mesh, mesh-mcp and planner onto systemd, and their old docker-container rows stayed, so every updating node replayed three claims that the release had deliberately retired. It could not be cleared by re-running, because a run only appended. Now a stage withdraws what it has stopped creating: on the run that completes a stage, a row of that stage which the run did not re-record, and whose artifact is no longer there, is retired. Both halves are required. A row the stage still declares stays even when the artifact is down, because that is the failure validation exists to report, and a run that recorded nothing for a stage retires nothing, because it never looked. Retiring is annotation rather than deletion, so the manifest keeps its history.

And the update tells the truth at the end of it. Proving the two fixes above took the first update that ever reached the post-update smoke check, and the check could not have passed on any node: it read the core-api address from SN_CORE_API, which nothing in the source sets, and the script runs over ssh where no environment follows it. So curl was handed a URL with no host and every update, however clean, ended in HTTP 000 and the word FAILED. The address was never ours to guess: the node's own registry has carried it since core-api registered itself, and that is where the check now asks.

Both of those were invisible to every gate we had, because nothing about the source looks wrong, and both cost an hour of server time to learn something a grep answers in seconds. So the release now refuses a tree that reads a required address from a name nothing supplies, is not guarded, and is not declared as coming from outside.

Upgrading: nothing to do by hand, and nothing to download. A node that already carries the documents image keeps it; a node without one builds it, which adds about ten minutes to the install. If your node stopped at validation on smart-node-mesh, smart-node-mesh-mcp or smart-node-planner after taking 1.12.25, this update clears it by itself: manifest.jsonl never needs editing by hand.

[1.12.25] - 2026-09-03

Three components stop being containers, so a fix to them stops being a release

1.12.24 made the node say what it was doing. This one makes changing it cheap. Memory, the task queue and voice ran as Docker containers for no reason anyone had written down: their runtime is the Python the node already has. Each release therefore carried about 950 MB of image tarballs, and moving a button in any of them meant a full release cycle. They now run as ordinary systemd services. The release drops to roughly 300 MB, and a fix to one of the three is a pull and a restart -- under a minute instead of an afternoon.

Documents stays a container, deliberately: it is PHP with Apache, a runtime the node does not have and should not acquire for one component. That is the whole rule now written down -- a companion runs in a container if and only if its runtime is missing from the host.

An update stops reporting success as failure. update-on.sh abandoned the installer after twenty minutes and wrote FAIL, then skipped validation and the smoke check. The stand finished inside that window; a real node with real data did not, so on a customer machine the honest outcome was the wrong one. It now waits for the installer's own exit-code file and reports what actually happened.

An agent can no longer be silenced for ever by one dead session. A session the reaper had closed was still offered for reuse; the gateway refused it, the wake failed, and the agent was never woken again -- with no error, no broken mark, and nothing in the event journal. Terminal statuses are now a positive list, the reaper also closes sessions whose process is gone, and a failed wake reaches the journal.

An agent is no longer condemned for thinking too long. A turn that outlived the synchronous window returned HTTP 202, meaning "still working", and the runner counted anything that was not 200 or 5xx as a refusal and marked the agent broken. A broken agent is skipped when work is handed out, so the longer an agent worked the more certainly it stopped being asked. 202 is now a named outcome and the condemnable codes are listed explicitly.

The internal hostname survives a reinstall. The route that reaches the office over the VPN, bypassing the edge proxy's hundred-second cut, was a hand-written file in a directory the installer regenerates. It is now rendered by the installer, and the internal domain is carried forward like the public one.

Deployment addresses are gone from the source. Container addresses were baked in as defaults across the tree; a component installed anywhere else quietly talked to the wrong place. Every reader now takes the address from its environment and refuses at startup, naming the variable, if it is absent. The acceptance suite finds the address by asking the node which one its API is listening on.

And then nothing supplied them. Removing the baked-in defaults was right, but the installer never wrote the addresses it was now obliged to write, and on a fresh node the effect was invisible. The runner, which since the cron was retired is the only thing that wakes an agent, polled a relative URL and failed once every five seconds while the node reported healthy: no agent was ever woken by an inbound message. The gateway lost the same call and started agents on an empty system prompt, so they answered nothing while the log said the turn was fine. And the planner address fell back to a literal belonging to the machine this was written on, so a test stand spent forty minutes polling the PRODUCTION task queue and was stopped by nothing but a rejected credential. The address is now a node contract every service reads, under both names the tree uses; the planner and memory addresses come from the contracts their own companions write instead of being guessed from a container name; and an address that cannot be resolved is left empty, because one naming the wrong machine is worse than none.

The acceptance suite finds brin by itself. It documents brin's address as required and read it only from the caller's environment, so a run without that variable exported reported the agent unreachable and skipped eight of its nine criteria. It now asks the node which address brin is listening on, the same way it already asked for the core API's, and reads the credential from the file the office companion writes.

Office. The Recent column in Documents sorted nothing and read a field the API does not send, so it showed the same list for ever with no dates. And the markdown renderer ended a paragraph at every newline rather than at a blank line, which turned any hand-wrapped document into a column of one-line paragraphs; tables now fill the column too.

Upgrading: nothing to do by hand. The installer removes the three containers and their images and starts the services in their place; the databases are untouched, they were always in the node's own cluster. The memory API moves off the port the gateway owns, which mattered only while both were on one host.

[1.12.24] - 2026-09-01

The node stops hiding what it is doing, and stops losing a person's turn to its own housekeeping

1.12.23 fixed what the node forgot. This one fixes what it never said. Almost every item below started the same way: the node knew something had gone wrong, wrote it somewhere nobody reads, and presented the person with a symptom that pointed at the wrong cause.

A continuing conversation no longer breaks every agent turn. The gateway decided whether a session could resume by looking for a transcript directory it could not read, so on a node where any agent had ever spoken, the check said no and a fresh session was spawned every time. The database session record is now the primary oracle and the filesystem check is the narrow secondary; the installer sets mode 0750 on the agent's own directory on every reconcile tick so the gateway user can see the truth rather than a permission error. This is why this release exists.

An update stops deleting the certificate resolver it was not asked to touch. Omitting a flag meant "forget the domain" and took every HTTPS surface down twice in one morning. The node domain and the ACME address are now carried forward before the router config is written, and the address is persisted, so silence means keep.

A person's message no longer loses its slot to background work. With the concurrent CLI ceiling full of agents doing their own housekeeping, a message from a person was refused outright and the person was told the agent could not answer. Sessions are now typed, person facing or background, and the person facing pool is reserved.

A turn that outlives the request is no longer reported as a failure. The gateway answers "still working" once its synchronous window closes, and that answer was treated as an upstream error, so any reply longer than roughly three and a half thousand characters reached the person as an apology while the work completed and was filed. The dispatcher now understands it, and the chat polls for the answer instead of rendering a failure.

The chat shows what the agent is doing while it does it. A long turn was indistinguishable from a dead one: three dots, no signal, and the whole narration delivered in one lump at the end. The current tool call is tracked as the CLI stream passes through and the desk can ask what is happening right now. A turn that hangs no longer holds its session hostage either: there is a deadline and a stale lock is recoverable.

Running out of money looks like running out of money. A daily budget ceiling presented as three agents in a broken state and a silent node; the refusal is now a named outcome, the agent is suspended rather than marked broken, and the person who can do something about it is told before the wall rather than at it.

The journal records what it was already refusing to say. Tool calls that failed a gate left no trace, error bodies were dropped so a repeated 422 could not be diagnosed, disabled crons were reported as warnings, and the cron renderer wrote an event every five minutes to say it had done nothing. A desk turn wrote nothing at all, so an agent mid conversation with the owner was reported as idle.

The node can be asked whether it is alright. One endpoint answers for a window: what failed, what was refused, which crons are erring, which agents are running or idle and on which channel, and what the release scope looks like. It distinguishes an intentional state from a fault, because a monitor that cries wolf about the design is worse than no monitor; the panel shows the intended state.

The health probe stops accusing healthy tools. It dropped the MCP session between the handshake and the tool listing, so every HTTP MCP server answered 400 and was recorded as failing, and an API tool with no declared path was probed at the integration root and 404ed. Sixty five red rows, every fifteen minutes, for four days, none of them real.

Every conversation is in the chat list again. The list was built from an index that the message path never wrote, so twenty five of twenty six conversations were unreachable from the interface while their contents sat intact on the bus.

The release path refuses on the release, not on the project. The gate added in 1.12.23 asked whether anything in the whole project was unreviewed, which is never false, so it could only ever block or be switched off. The scope of a release is now an object the query can name, and the gate asks about that. Release evidence is guarded against a build from a commit no release points at, and the node can tell that a companion was reinstalled from a newer commit, which it previously reported as unchanged. The acceptance suite now checks this upgrade path.

A promise that was enforced by an instruction is now enforced by a mechanism. Outbound sending can be suppressed per agent or per channel by whoever runs the node, and an agent body cannot defeat it.

This machine stops leaking into the product. Our own domain and our own filesystem layout were embedded in shipped source; both are gone, the scan that finds them now looks for absolute machine paths as well, and it runs at commit time rather than only at publication.

[1.12.23] - 2026-09-01

Nothing new: the node stops losing what it was given, and stops deciding things it was not asked to decide

Every item below makes an existing capability honest. Proposals that added a capability were held back on purpose, including a Google Drive server that was written and works. The filter was the owner's and it was applied to finished code, which is the only place a filter like that costs anything.

The live model credential is out of the systemd journal. Every agent run printed the token in full, on a machine where anyone in adm or systemd-journal can read it. No sudoers directive suppresses it: !log_env does not exist in sudo 1.9.15p5, so the value had to leave the sudo boundary rather than be hidden inside it. The gateway now calls /opt/smart-node/gateway/claude-agent-wrapper, which reads the credential from /etc/smart-node/agent-runtime.env (root:smart-node-agents, 0640) and execves the CLI, so nothing in the logged environment ever carries it. Proved on the live node with both halves at once, because each had already passed alone while the other was broken: the journal went from 1032 occurrences to zero while an agent completed a real turn. Treat any token that ran before this as disclosed, not merely exposed.

A result that exists now reaches the person it was for. Four separate paths dropped work on the floor. A CLI turn that died with an empty error reached the person as silence, was never retried, and deleted their message from the agent's memory while leaving it on their screen. An answer the agent had already written was thrown away when the turn outlived the HTTP request, so the longer the thinking, the more certain its loss; the completed turn is now written to the bus regardless of who is still listening. The chat showed the internal context block as if the person had typed it, replacing their own question on screen with the clock, the identity line and a recap of the last dozen turns. A workflow that failed to launch reported nothing at all, because the launcher discarded stderr. And mail ingest silently dropped attachments it could not place, which it now says out loud.

The installer stops re-deciding identity, routing and firewall on a machine that already had them. Silence meant "rename" and now means "keep it": an update leaves hostname, domain, Host rules and certificates untouched by default Layer A no longer resets a firewall it did not create, takes --ssh-port instead of assuming 22, and steps aside when a WireGuard listener already holds its port instead of writing a second one that never starts. Two more defects came out of a throwaway stand built for this release: SSH_OPTS carried -p into every scp, which needs -P, so every clean install broke on a non-default port, and the voice companion's rsync -a carried the checkout's ownership into /opt/smart-node/voice and made the permissions stage refuse the install.

pending_review no longer waits on nobody. A task submitted for review kept its author as assignee, so it woke no one and sat until a person went looking; fourteen accumulated behind this release. Tasks now carry a reviewer, status transitions notify, and a scan reports what has gone stale. The node health scripts also stopped assuming a fixed install directory and now find their own.

Schema. The planner gains one migration, companions/planner/migrations/0006_reviewer_notifications.sql. It is the only schema change in this release.

Reviewed 2026-10-30. Older than 90 days counts as broken. Something here wrong? Tell me