# Changelog All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ## [Unreleased] ### Added - `run.work` and the chart's `work: true`: a scheduled job may split into a work phase and a publish phase. The work phase (`sageox-agent job work --stage `) runs `run.work.command` with no secret resolved and no verdict path; the chart runs it as a `work` init container under UID 10002 with no secret volume, its own copy of the bundle, and the checkouts read-only. The `job` container (UID 10001) starts only once every work process is dead, is the only container with `secrets` and `jobSecrets`, reads the staged output read-only from `JOB_STAGE_DIR`, and folds the work phase's exit into the verdict as `job::work`. `run.work.wallClockMs` is carved out of `budget.wallClockMs`. Refused beside `trigger.onRequest`, `worker`, `serviceAccount.automountJobToken`, `persistence.jobHome`, and a `sharedVolumes` entry that reuses `job-work`/`job-stage` or overlaps `/stage`. Opt-in; jobs without it render and run as before. The work phase refuses to start its body when its container holds an AWS credential variable or an IRSA, EKS Pod Identity or cluster token file, so a webhook that injects into every container cannot hand it one. - Buzz: a `subscription_stalled channel= missed_event=` warning when one channel's live subscription stops delivering while the socket stays up. A configured channel that has heard nothing for five minutes (`stallCheckIntervalMs`) is asked about with a fresh read; anything the relay returns that the subscription never received is the stall. A channel that is merely quiet logs nothing. Before this, a stalled subscription looked healthy — process alive, pings answered — until someone noticed missed messages. A miss can still go unreported if it is timestamped at or before the newest message the channel did receive: that covers a second flooded past 100 messages, and a sender whose clock runs ahead. - **`doctor` warns when a Buzz agent's directory record and profile disagree on its name.** A rename that reached the kind-0 profile but not the record left the record's `display_name` binding to nobody, while `doctor` still called the agent mentionable. The warning names both values, the relay, and the fix: re-run `sageox-agent identity register buzz`, which publishes only the `BUZZ_NSEC` identity's record — for a surface on another identity the warning says so instead. A space in the name is not flagged — clients match multi-word names. ### Fixed - **Re-running `sageox-agent identity register buzz` now renames the agent's Buzz directory record.** The record kept the first `display_name` it was ever published with, so renaming an agent in `profile.json` updated its profile and left the record unchanged, so mentions by the new name did not match the record. Registration now writes the display name it was given (from `profile.json` or `--name`) over the record's, and publishes the record under the manifest's `name`, as `run` does, so the two no longer flip the field on every restart. `run`'s own reconcile still keeps whatever display name the record carries. ## [0.13.0] - 2026-11-17 Everything below shipped after `v0.12.1`. On publication, `ghcr.io/sageox/agent-base:0.13.0` takes `:latest` and starts `:0.13`. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. ### Added - Helm: an optional per-agent `authTag` value, injected as `BUZZ_AUTH_TAG` into the agent Deployment and its scheduled-job hosts. Carries a NIP-OA owner attestation so the running agent's authenticated connection binds it to its owner (the "managed by " badge). Give it as a YAML list or as the JSON string a minted tag prints as; the values schema refuses anything that is not the `["auth", , , ]` tuple, since the runtime drops a malformed tag without an error. The tag is public — minted with the owner secret, which never enters the pod. Omit it to leave an agent "owner unavailable" (the prior behavior). Values-only and backward compatible. ### Changed - **The agent base image ships `ox` 0.26.0.** `OX_VERSION` and both architecture checksums in `deploy/docker/Dockerfile` move up from 0.25.0. For a job that records its coding sessions, this release gives one complete session per run even when ox's hooks are wired twice, credits the job's Ledger commits to its AI coworker rather than to the harness's git identity, and no longer kills a large Team Context's first clone at 60 seconds. ox's [0.26.0 release notes](https://github.com/sageox/ox/releases/tag/v0.26.0) list what else changed. ## [0.12.1] - 2026-11-11 Everything below shipped after `v0.12.0`. On publication, `ghcr.io/sageox/agent-base:0.12.1` takes `:latest` and advances `:0.12`. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. - **A Buzz agent deployed with `BUZZ_AUTH_TAG` now sends its NIP-OA owner attestation when it signs in (#140).** The runtime signed in through nostr-tools and never read the variable, so only the `buzz` CLI sent the tag and agents showed "owner unavailable" in Buzz. `adapter-buzz` now adds it to every NIP-42 AUTH event, as Buzz's Rust harness does. An open relay records the tag's owner; a relay that requires membership records it only for an agent it admits through its owner's membership, not for a direct member. The runtime checks only the tag's shape and sends nothing when that fails, leaving the signature and conditions to the relay. Where the relay records an owner it keeps the first one and refuses a sign-in whose tag names another, so check an agent's current owner before giving it a tag. ## [0.12.0] - 2026-11-10 Everything below shipped after `v0.11.2`. On publication, `ghcr.io/sageox/agent-base:0.12.0` takes `:latest` and `:0.12`. `:0.11` stays on 0.11.2. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. A minor release for the opt-in persistent job home, with the tools ox needs to record Claude Code sessions added to the image. A chart that does not set `persistence.jobHome` renders as it did on 0.11.2. - **The agent base image can record Claude Code sessions with ox.** It now ships the `ox-adapter-*` binaries from the ox release tarball next to `ox`, `procps` for `ps`, and `@anthropic-ai/claude-code` 2.1.284 as a `claude` binary. ox finds the agent with `ps`, reads the session through the adapter, and its daemon runs `claude` to summarize a session before uploading it, so a job missing any of them records nothing. A job can now call `claude` directly instead of fetching it with `npx` on every run. The image's offline compatibility test checks all three, and that the agent user's `~/.npm` is not root-owned. - **A scheduled job can keep data in its home between runs.** `persistence.jobHome` (`size`, optional `storageClass` defaulting to `gp3`, the `jobs` it applies to and the `paths` under HOME to keep) renders a `ReadWriteOncePod` claim per agent, kept on uninstall, and mounts only those directories, for the named lanes only. Session transcripts, ox's Ledger clones and its upload queue then survive the Pod, while config such as `~/.gitconfig`, a harness's settings and `~/.config` starts clean every run; the chart refuses a path that would keep them, and turns off Claude Code's auto memory, which lives in `.claude/projects`, for a lane that keeps a `.claude/` path. The job host carries that setting from its own environment to the job body, ahead of the body's `run.env`. The chart also refuses a slug that no scheduled local command job carries, a shared volume that reuses the home's name, mounts or claim, and a home claim name another agent already uses. The chart README covers releasing the claim from a Pod stuck `Terminating`. ## [0.11.2] - 2026-11-08 Everything below shipped after `v0.11.1`. On publication, `ghcr.io/sageox/agent-base:0.11.2` takes `:latest` and advances `:0.11`. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. - **The agent base image ships `ox` 0.25.0.** `OX_VERSION` and both architecture checksums in `deploy/docker/Dockerfile` move up from 0.24.2. It is the first release with `ox session wait` and the `disposable_machine` setting, which an agent whose pod keeps only its home directory needs to publish its sessions before the pod goes away. The image's offline compatibility test now also sets `disposable_machine`, so an image with an older ox fails its build. ox's [0.25.0 release notes](https://github.com/sageox/ox/releases/tag/v0.25.0) list what else changed. - **Claude-hosted MCP services now enforce the tool policy on direct HTTP calls.** Every hosted service applies the gateway's allow/deny policy before dispatch, as Codex services already did, so a session's URL and bearer token cannot bypass denied tools. - **Host-side CLI setup protects `.env` before writing credentials.** Files are created with mode `0600` and permissions are enforced on the open file before appending, closing the write-then-chmod exposure window. Agent initialization also creates directories at mode `0700` and enforces that mode when reusing them. ## [0.11.1] - 2026-10-27 Everything below shipped after `v0.11.0`. On publication, `ghcr.io/sageox/agent-base:0.11.1` takes `:latest` and advances `:0.11`. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. - **A Slack agent now starts when Slack refuses to read one of its configured channels.** Starting from a saved cursor, the Slack adapter backfills every configured channel and open DM, and any failed read failed `start()`. An app never invited to one of its channels (`not_in_channel`, or `channel_not_found` for a private one) could not start again once it had a cursor. A refusal no restart changes (`not_in_channel`, `channel_not_found`, `thread_not_found`, `missing_scope`) now costs only the read it refused, a channel's gap or one thread's replies, with a `backfill_read_failed` warning naming it, and what was read before it still replays. Any other failure while reading channel history or thread replies, `invalid_cursor` or a network fault included, still fails `start()`, so the next start retries that gap. Invite the app to the channel to hear it. - **`doctor` no longer fails an agent whose tool policy narrows a brain on purpose.** A policy that allowed some of a brain's tools but not all, such as a private brain the agent may read but not write, failed with "the agent would have memory it cannot use". Only a brain the policy allows none of fails now. A partly allowed brain is a warning that names the withheld tools and exits 0, and that includes a tool a newer release adds, which used to fail until `memory add` re-synced the policy. ## [0.11.0] - 2026-10-27 Everything below shipped after `v0.10.0`. On publication, `ghcr.io/sageox/agent-base:0.11.0` takes `:latest` and `:0.11`. `:0.10` stays on 0.10.0. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. A minor release for the new rehearsal commands and opt-in MCP and Slack capabilities. MCP turn stamping and Slack wakeups in the agent's own threads are off by default; existing agents keep their configured behavior. The image updates Node.js to 22.23.4 and ox to 0.24.2. Helm chart 0.15.0 and `deploy/docker/compose.yaml` need no change: the chart's templates and values and the compose file are as they were in v0.10.0. - **The agent base image runs Node.js 22.23.4.** It ran 22.23.2, which the [October 2026 Node.js security release](https://nodejs.org/en/blog/vulnerability/october-2026-security-releases) patches. On the 22.x line that release fixes seven CVEs, three of them high: an out-of-bounds write in the Brotli decoder that can run code (CVE-2026-111497), a TLS certificate hostname bypass (CVE-2026-106069), and `dns.resolve` truncating a name that contains a NUL character (CVE-2026-105482). Both stages of `deploy/docker/Dockerfile` move to `node:22.23.4-slim`, pinned by digest. An agent keeps running 22.23.2 until it runs an image built from this change. `.mise.toml` selects Node 22.23.4 for a source checkout, up from 22.12.0; run `mise install` to get it. - **An MCP server can be told which message it is answering, and who sent it.** Set `stampTurn: true` on an `mcpServers` entry and every `tools/call` to that server carries the live turn under `params._meta["sageox.ai/turn"]`: the surface, the channel, the message and thread references, and the author's id. It comes from the gateway's live-turn registry, the one the reaction tool and the job door already read, so the brain cannot set it; a value the brain sends under that key is replaced. The value is `null` unless exactly one turn is live and the only brain work running is that turn's own: with none live, two channels mid-turn at once, a scheduled tick running, or a prompt still running after its turn timed out, a call cannot be told apart from another turn's, so it names nobody rather than the wrong person. Off by default. A server that does not set it receives each call exactly as the brain sent it, so no existing agent changes. `run` lists a stamped server as `stamped with the live turn`. - **A Slack agent can be woken by an untagged reply in a thread it has posted in.** Set `wakeInOwnThreads: true` on the Slack surface and subscribe the app to `message.channels` (and `message.groups`), and a person replying in a thread the bot started or answered in no longer has to tag it again. A reply in a thread the bot never posted in, one that tags somebody else or a user group, and one from another agent still need a tag. The adapter learns its threads from its own posts and its own messages as they arrive; after a restart, the first untagged reply in an unknown thread costs a `conversations.replies` read, which stops at the first page showing a post of the bot's and gives up after two seconds. Events behind the lookup in that channel can wait until it returns or reaches that deadline. It runs on a Slack client of its own that rejects a rate limit instead of waiting it out, so rate-limit retry delays do not extend the lookup, and after a timeout or a rate limit the channel asks Slack nothing more for 30 seconds. A read that fails or times out means the reply needs a tag, and is logged as `thread_owner_read_failed`. Off by default, so no existing agent changes. - **`run --rehearse` and `job run --rehearse` run the real agent with nobody listening.** Watching an agent with a private brain take a turn meant deploying it, because that brain needs a Buzz relay and the only one was the real one. A rehearsal points every Buzz surface at a relay inside the process and signs as a throwaway key, so replies, status posts, memory and the directory record reach nobody. It first empties its own environment down to `PATH`, `LANG`, `LC_ALL`, `TZ` and `TMPDIR`, and moves `HOME` to a directory of its own: a secret comes from `--secrets` or the agent's `.env`, never from your shell, and the Claude brain does not read your `~/.claude`. A declared secret it was not given no longer stops the launch: it is listed at the start, a job body runs without it, and an MCP server that needs it fails its calls. A job body is told `JOB_REHEARSAL=1`, so one that publishes on its own credential can skip that step. Kill switches are armed on the stand-in relay, vault memory moves to a fresh directory, and the resume cursor is neither read nor written. Under `run`, each line on stdin is a message from you, as the agent's owner, in its first Buzz channel; replies print, and the command exits once the input ends and the turns it started finish. Its directory, `HOME` included, is removed when it exits. What has no stand-in is refused rather than reached: a Slack surface, Buzz surfaces on more than one relay, and a job that runs on an external worker, whose dispatcher a rehearsal is never given. Every command but `run` and `job run` refuses `--rehearse` rather than acting on the real agent. - **The agent base image ships `ox` 0.24.2.** `OX_VERSION` and both architecture checksums in `deploy/docker/Dockerfile` move up from 0.23.0. The ox calls the toolkit makes — `status`, `team list`, `query`, `session list`, `glance`, `sync --read-only`, `index code`, `code status`, `code search` and `code insights` — take the same flags, exit with the same codes and return the same fields on 0.24.2, so nothing that reads them changes. A code index that 0.23.0 built is updated in place by the first warmup after the upgrade, and until then a job that reads it through `persistence.jobCodeIndex` still passes the readiness check in the chart's README. A job body that runs ox itself gets 0.24.2 too. The calls the job contract and the chart's README show a job making — `ox query`, `ox code status`, `ox code search` and `ox agent prime --agent claude-code` — exit as they did on 0.23.0, and the first three return the same fields. ox's [0.24.2 release notes](https://github.com/sageox/ox/releases/tag/v0.24.2) list what else changed. ## [0.10.0] - 2026-10-17 Everything below shipped after `v0.9.0`. On publication, `ghcr.io/sageox/agent-base:0.10.0` takes `:latest` and `:0.10`. `:0.9` stays on 0.9.0. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. A minor rather than a patch because an agent that moves from 0.9.0 without changing its configuration still behaves differently: a job body that runs ox itself gets ox 0.23.0's exit codes and output shapes, and a digest's items may run to 1000 characters. A digest that sets none of the new layout fields posts as before. Helm chart 0.15.0 and `deploy/docker/compose.yaml` need no change: the chart's templates and values and the compose file are as they were in v0.9.0. - **A digest job now lays out its own post.** The host posted every digest as `• text — authors`, so changing how one agent's digest read meant changing the toolkit. A `source` now takes `title`, `line` and `quiet`, written in the job's own words: the host fills in only `{text}` and the facts it checked — `{authors}` of the messages a line cites, and the authors a whole read gave no line. `byAuthor: true` holds the answer to one line per author, which a job's words alone cannot: one that asked for an item per pull request posted a flat list of them. With `quiet` set, an answer that gives no line to an author who posted a link is refused rather than posted with that author called quiet. A field the host does not fill is refused at load. `line` defaults to `• {text} — {authors}`, so a job that sets none of these posts as before. An item may hold 1000 characters instead of 500, and an answer 200 items instead of 50, so a full read can give every author a line. - **The agent base image ships `ox` 0.23.0.** `OX_VERSION` and both architecture checksums in `deploy/docker/Dockerfile` move up from 0.20.0. The ox calls the toolkit makes — `status`, `team list`, `query`, `session list`, `glance`, `sync --read-only`, `index code`, `code status`, `code search` and `code insights` — take the same flags and return the same fields on 0.23.0, so nothing that reads them changes. A code index that 0.20.0 built is updated in place by the first warmup after the upgrade. When a team-token ledger sync's 30-minute attempt ends while ox is checking the checkout's history, ox now reports `interrupted` instead of `incomplete_history` (sageox/ox#1071). A first sync stopped there now shows in `team_status` as initializing, like one stopped mid-transfer, and a refresh stopped there as a failed sync. Both showed as a checkout missing part of its history. A job body that runs ox itself gets 0.23.0 too. An unknown subcommand of a group with no action of its own, such as `ox code foo` or `ox plan foo`, now exits 1 where it printed the group's help and exited 0; `ox init` exits non-zero when ox is not signed in; and `ox plan feedback show --json` prints an object whose `items` field holds what was the whole array. Under a team token with no AI coworker attached, `ox murmur` refuses. ## [0.9.0] - 2026-10-08 Everything below shipped after `v0.8.0`. On publication, `ghcr.io/sageox/agent-base:0.9.0` takes `:latest` and `:0.9`. `:0.8` stays on 0.8.0. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. A minor rather than a patch because an agent that moves from 0.8.0 without changing its configuration still behaves differently. A Claude brain with no `brain.model` moves from Opus 5 to Opus 5.5. A built-in tool its tool policy allows by bare name, such as `Read`, is approved when Claude Code asks, where 0.8.0 refused it. The image's ox sends usage data to PostHog unless the gateway's environment sets `DO_NOT_TRACK=1`, which the chart has no setting for. A turn for a message posted in a thread carries the thread, including what people outside `respondTo` wrote there. A command line with an option no command reads exits 1 instead of running. Helm chart 0.15.0 and `deploy/docker/compose.yaml` need no change: they pass only options the CLI reads, and they keep the image's entrypoint, so the gateway runs under `tini`. - **A failed ledger sync names its failure in the gateway log, and a failure that repeats is retried less often (#128).** When a team-token ledger's sync failed, `team_status` said the gateway log named the cause. The `ledger_sync` line it pointed at carried ox's receipt cut at 2,000 characters, with the failure class near the end behind the checkout's coverage window. When ox printed no receipt, the line held no cause at all. Now the line names ox's failure class right after the status and keeps the receipt without its coverage window. When ox prints no receipt, the line gives ox's exit status, stdout and stderr instead, with the mounted token redacted. A change of class logs a new line even when `team_status` reads the same. Every attempt was also retried a minute after the last ended, including a failure no retry clears, such as a ledger path ox 0.17.0 cannot claim, which it reports as `interrupted` (sageox/ox#1045). Now each attempt that fails with the same class as the one before it doubles the wait, up to 30 minutes. A success, a different failure, or a first sync still resuming goes back to a minute, so a first sync keeps its pace and still reports `initializing`. A refused credential keeps its own rule: it is not offered again, and a replacement is tried within a minute of being mounted. After fixing a failure that repeated, the next attempt can be up to 30 minutes away; restart the gateway to sync at once. - **A failed `ox` call's output is logged and printed without the SageOx token the call was given (#130).** The gateway's `ox_failed` line quotes what ox wrote to stderr, and `doctor` prints the start of ox's error. Neither took out the token the call ran with, so if ox ever printed it, both would have carried it; no ox release is known to. The token is now replaced with `[REDACTED]` before the text is cut to length, and the rest of what ox wrote is kept, as #128 did for a failed ledger sync. - **`help`, `--help` and `-h` print the usage to stdout and exit zero, and `--help` after a command no longer runs that command.** All three printed the usage to stderr and exited 1, as a mistyped command does. No command refused either flag after its name, so most ran as if it were absent: with one agent in the home, `sageox-agent memory add local --help` added the memory. Now either flag, anywhere on the line, prints the usage and the command does not run. ` --help` shows the full usage, not one command's, and an unknown command still prints it to stderr and exits 1. - **The toolkit is licensed under MIT instead of Apache-2.0.** `LICENSE`, the `license` field of every package manifest, and the `agent-base` image's `org.opencontainers.image.licenses` label say MIT. Earlier releases were published under Apache-2.0. - **An option no command reads is refused before the command runs, instead of being passed over.** A guessed `--dry-run`, a typo such as `--privat`, or a short flag such as `-n` let the command run as if it were absent: with one agent in the home, `sageox-agent memory add local --dry-run` added the memory. Now the command exits 1 with `unknown option: --dry-run` and does not run. `--relay=wss://…` was passed over the same way, and is now refused with the spelling that works, `--relay wss://…`. The check covers every command's options at once, so an option that only another command reads still passes, but it cannot hide the word after it: one starting with `-` is checked as an option, so `--relay --dry-run` is refused too. `mcp add --command --args --stdio` still hands `--stdio` to the program. - **An agent mentioned in a thread is handed the thread, on Slack and on Buzz.** A turn carried only the message that mentioned the agent, so "summarize this thread" was answered without the thread, and a reply under someone else's question arrived without the question. Now, before the turn for a message posted in a thread, the gateway reads the thread up to that message: the message that started it, then every reply before this one. The brain gets it above the message, fenced as untrusted like the message, with the agent's own earlier replies marked as its own. A thread over 200 messages is cut to its first message and the most recent 199. A top-level message has no thread and gets none. Everyone who wrote in the thread reaches the brain, not only the people `respondTo` lets wake it. A read that fails, or has not finished in 10 seconds, costs the thread and not the answer: the brain is told the thread could not be read, and the log says `thread_read_failed` with the reason. A read that works logs `thread_read … messages=N`. Slack needs no new scope; the history scopes the setup guide asks for cover `conversations.replies`. Slack limits apps distributed commercially outside the Slack Marketplace to one such call a minute. That covers every installation made since 2025-05-29. For earlier ones Slack's pages disagree: its legacy changelog brings them under the limit from 2026-03-03, and its current rate-limit reference exempts them. The internal app the guide creates is not limited. On a limited installation, a second threaded mention inside the minute waits for the limit to clear. If that takes over 10 seconds, the turn goes ahead without the thread, and its reply still posts only once the limit clears, because Slack's client holds every call until then. - **A Claude brain can run Sonnet 5.5.** `claude-agent-acp` moves from 0.68.0 to 0.84.0 in the agent base image, the `npx` fallback and the setup guide, which takes the Claude Code it bundles from 2.1.232 to 2.1.284. 2.1.232 does not know Sonnet 5.5: it listed `brain.model: claude-sonnet-5-5` as a custom model named Sonnet 5. On 2.1.284 the same pin selects Sonnet 5.5. A full model ID such as `claude-sonnet-5` stays on its model, but the `sonnet` and `opus` aliases now mean Sonnet 5.5 and Opus 5.5, and an agent with no `brain.model` moves from Opus 5 to Opus 5.5. The brain's permission requests now carry the tool's name, which the gateway matches its tool policy against. 0.68.0 sent no name, so the gateway matched the title instead: the tool's name for an MCP tool, but the command for `Bash` and `Read ` for `Read`. An MCP tool is decided as before. A built-in tool the policy allows by its bare name, such as `Read`, is now approved when Claude Code asks the gateway about it, where before its title matched no rule and it was refused. - **The agent base image ships `ox` 0.20.0 and runs the gateway under `tini`, and each agent's ox calls report usage under one ID.** `OX_VERSION` and both architecture checksums in `deploy/docker/Dockerfile` move up from 0.17.0. The ox calls the toolkit makes — `status`, `team list`, `query`, `session list`, `glance`, `sync --read-only`, `index code`, `code status`, `code search` and `code insights` — take the same flags and return the same fields on 0.20.0, so nothing that reads them changes. A job body that runs ox itself gets 0.20.0 too: `ox doctor` now exits non-zero when a check fails, even with `--json`, and `--config` now names the user preferences file and stops the command when that file is missing or malformed. Since 0.19.0, ox sends usage data to PostHog by default, and the toolkit leaves it on. ox sends it from a process it detaches after a command. The image's PID 1 was Node, which never reaps such a process, so each ox call behind a code search, a code insights lookup or a repository warmup would have left a zombie until the container restarted. The entrypoint now starts the gateway under `tini`, which reaps them, as it does for a job body's own ox calls; a deployment that replaces the entrypoint needs an init that does the same. Every ox call the toolkit makes for an agent with a team brain now carries one ID, `SAGEOX_CLIENT_ID`, hashed from the team and the agent's name, so ox reports that agent's usage under the same ID across restarts, pods and token rotation. Two deployments of one name on one team share it. Without it, the team brain's calls would send nothing: ox sends only under an install ID it can keep, it keeps that ID under its config directory, and the gateway points that directory at the null device. The code-index calls would get a new ID in every new container. ox 0.20.0 still reports nothing for hosted ledger reads or read sync (sageox/ox#1089). Setting `DO_NOT_TRACK=1` in the gateway's environment turns telemetry off, because the gateway now passes it to every ox call it makes. The chart has no setting for it yet. Since 0.18.0, ox syncs a ledger path that holds only its own cache, which 0.17.0 refused as `interrupted` (sageox/ox#1045). A path that is not a checkout and holds anything else fails as `path_occupied`, which no retry clears until the path is emptied. `team_status` reports it as a failed sync, and the gateway log names the class. ## [0.8.0] - 2026-09-22 Everything below shipped after `v0.7.0`. On publication, `ghcr.io/sageox/agent-base:0.8.0` takes `:latest` and `:0.8`. `:0.7` stays on 0.7.0. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. - **The team brain authenticates only with its token, never a login on disk, and a manifest that sets `configHome` will not load.** `configHome` pointed ox at a mounted `auth.json`, which covered team search but never ledger reads, and with no token ox fell back to any `ox login` on the gateway's machine. Now no ox call the team brain makes gets a disk login, and the ones that authenticate get the secret `token` names (`SAGEOX_TOKEN` unless set): the gateway points ox's config directory at the null device, so no `auth.json` is ever read. Without the token, `doctor` reports ox as not authenticated, `memory add team` asks for it even where you are logged in, and team search fails as `not-authenticated`. Chat and the other tools keep working. If you mounted `auth.json` through `configHome`, mount a team access token (`oxt_`) as the `token` secret instead and remove the line. That token covers team search and, when a ledger reader is granted, the ledger of every configured repository bound to the team, except those listed under `ledgerSync`, which still sync from their own Git remote. - **Ledger readers sync over the team token, with no Git credential or ledger URL (#57).** `team_sessions` and `team_recent` read a ledger checkout that an operator had to supply, either through `ledgerSync` with the ledger's Git remote and a separate Git secret or with an ox daemon run beside the gateway. Now, when the policy grants either tool, the gateway syncs every configured repository bound to its team with `ox sync --read-only`, using the team brain's existing `token`, and reads through ox's guarded readers. Each read first asks SageOx whether the mounted credential may read that exact repository and serves nothing unless it confirms. A credential replaced during the read is checked again before the answer is returned. A large ledger's first sync takes most of an hour in resumable 30-minute attempts, and `team_status` reports the repository as `initializing` until that first sync finishes or an attempt fails with anything but a resumable interruption. Work updates on a ledger synced this way reach back at most 11 hours, because ox's read sync keeps them only for the hour of its last sync and the 11 before it: `team_recent` says where they start in a new `work_updates_since` field, and session activity still covers the whole window. This needs a team access token (`oxt_`; ox refuses a personal one for ledger reads), ox 0.17.0 or newer, which the base image already ships, and ledger reads enabled for the team on the SageOx endpoint. Without them `team_status` names the failure and the other team tools keep working. An agent that grants neither reader starts no team-token sync, so upgrading does not start a ledger transfer it has no use for. `ledgerSync` entries keep their behavior. The externally supervised mode is gone: without `ledgerSync` the gateway no longer reads an ox daemon's checkout, and `team_status` no longer reports `external` or `sync_owner`. If you ran such a daemon, stop it once it has pushed anything pending and delete its checkout under `workspace/ox-data`: ox does not take over a checkout it did not create. Moving a repository off `ledgerSync` likewise means deleting its checkout. ## [0.7.0] - 2026-09-21 Everything below shipped after `v0.6.1`. On publication, `ghcr.io/sageox/agent-base:0.7.0` takes `:latest` and `:0.7`. `:0.6` stays on 0.6.1. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. - **A scheduled digest proves it read its channel before anything counts as a digest (#111).** A prompt job's run passed whenever its turn finished. A digest that skipped its channel read, wrote that it could not reach the channel, and had that excuse posted for it therefore recorded `PASS`. A prompt job may now declare `source` — `read_channel`'s arguments with the window required, plus the `empty` notice — and the host does every step it can observe. It reads the window before any brain is woken, and posts `empty` itself, with no turn, for a whole window that held nothing. It hands the messages to a sealed turn — a session of its own, holding no tools at all, with the messages fenced as data. It posts that turn's answer only when it is JSON whose every line cites messages this read returned and carries no link those messages did not. The host renders the post and credits each line to the cited authors. The read, the summary and the post are separate gates, so a failure notice never counts as a digest, and a read that stopped early is marked partial rather than read as quiet. Operators with a digest should move it to `source` and drop the reading instructions from its skill. A prompt job without `source` behaves exactly as before. The host's read is granted by the `source` line, not by the brain's tool policy. `validate`, `doctor` and `run` refuse a `source` channel its surface does not list. - **The agent base image ships `ox` 0.17.0.** `OX_VERSION` and both architecture checksums in `deploy/docker/Dockerfile` move up from 0.15.0. The ox calls the toolkit makes — `status`, `team list`, `query`, `session list`, `glance`, `daemon status`, `index code`, `code status`, `code search` and `code insights` — take the same flags and return the same fields on 0.17.0, so nothing that reads them changes. A job body that runs ox itself gets 0.17.0 too: a plain `ox status` now exits non-zero when signed out or outside an initialized repository, while `ox status --json` still exits zero. ## [0.6.1] - 2026-09-16 Everything below shipped after `v0.6.0`. On publication, `ghcr.io/sageox/agent-base:0.6.1` takes `:latest` and advances `:0.6`. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. - **`job_run` waits only for a job that fits in what is left of the turn, and a turn says what it left running.** Both halves are the rest of #44, whose first half — the brain's MCP client giving up on its own shorter clock — was closed in 0.3.1 by setting that clock from `limits.turnTimeoutMs`. The tool weighed a job's deadline against `limits.turnTimeoutMs`, which is a *whole* turn. A `tools/call` always arrives partway into one, so a job that fits in a turn could still be waited for in the sliver of turn that remained — the same arithmetic, right about a number that no longer applied. A scheduled turn had it worse: one declaring `budget.wallClockMs` shortens its own tick, and `job_run` inside it was still comparing against the manifest's number, which that turn was never given. The gateway now publishes each turn's real deadline and the tool reads it, so a job is started rather than waited for whenever what is left cannot hold it. Nothing new to set; a job near the edge answers "running" where it used to answer with a verdict, and its answer no longer says the job is "longer than this turn" when what ran out was the turn. With two channels mid-turn at once the bound is the **tightest** of them, because a `tools/call` carries nothing that says which turn made it and the tightest is the only number every live turn satisfies. So a busy agent can start a job it would have waited for on a quiet one. That is the safe way to be wrong here: a job started still posts its verdict where `report` says and back into the conversation that asked, while a job waited for in a turn that cannot hold it loses its result outright, which is what #44 was. The second half is the one #44 called the worse one: a call still in flight when its turn stops listening is not cancelled, so it finishes and writes `tool_call outcome=ok`, and **nothing recorded that its answer reached nobody.** The gateway now writes `tool_call_stranded tool=… ms=…` for each call still running once every turn has ended, and each call is named at most once however many turns it outlives. The line carries no turn ids on purpose. A `tools/call` says nothing about the turn that made it, so naming the turn that happened to finish last would point an operator at a turn that never made the call. The claim it does make is checkable — this call is running and nothing is left to read its answer — at the cost of naming a call stranded during a busy stretch later than it happened, and not naming one that lands inside that window at all. Read it against the `turn_done` and `turn_failed` lines above it. - **A large `read_channel` result remains readable after a brain harness spills it to a file.** The response is still one valid `{messages, more}` JSON object, but each message now occupies its own physical line, so a line-oriented file reader can page through it instead of meeting one line larger than its token cap. Each line is compact `{from, text, ts}`: `from` uses the display name when known and an abbreviated id otherwise, replacing the per-message `author` object rather than repeating its full transport envelope. Callers can also pass `maxTextChars` to bound every message's text; a shortened message carries `truncated: true`, while `more` keeps its existing meaning of older messages omitted. ## [0.6.0] - 2026-09-14 Everything below shipped after `v0.5.2`. On publication, `ghcr.io/sageox/agent-base:0.6.0` takes `:latest` and `:0.6`. `:0.5` stays on 0.5.2. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. A minor rather than a patch because this adds a selectable Codex brain, a time window to `read_channel`, and an opt-in scheduled-job code-index mount. Existing Claude agents and valid manifests need no changes. Helm chart 0.15.0 pairs with this release; its new `persistence.jobCodeIndex` setting defaults off, and it now refuses `worker` beside `prompt: true`, a combination the runtime already refused. - **A Buzz reply no longer mentions the agent it answers, so one handoff is one ack.** Every reply `p`-tagged its author, and on Buzz that tag is the only thing that wakes an agent — so a sibling's one-line acknowledgement woke the agent that had handed off, whose "no reply needed" woke the sibling back, until `limits.maxAgentChainDepth` refused: six messages out of one handoff, five of them agents declining to speak. A reply to a person still carries the tag, so they are told their question was answered; a reply to an agent the relay's directory lists carries none, which is what design §8 has said an ack is. A sibling's answer under a post this agent addressed to it still comes home — the link matches on thread root and author, never on a mention. A sibling with no directory record is not known to be an agent and is still tagged — the same gap the chain-depth cap has there. - **A Slack agent no longer warns, on a healthy connection, about a ping that was never Slack's.** With a Slack surface up, stderr carried `[WARN] socket-mode:SlackWebSocket:1 Received unexpected ping diagnostics message format` every 30 seconds for as long as the socket lived, on a connection that was answering fine (#82). The ping was another surface's: `@slack/socket-mode` watches a diagnostics channel every undici WebSocket in the process publishes to and warns about any that is not an instance of its own copy of undici — and the Buzz relay connection is opened with Node's built-in `WebSocket`, which is a different copy (reported upstream as slackapi/node-slack-sdk#2743). The adapter now hands socket-mode a logger that drops that one warning. Socket-mode's other lines, including the one that says a stale Slack connection is being recycled, still reach stderr, now under the name `socket-mode`. - **The chart refuses `worker` beside `prompt: true`, as it already refused `budget`.** A prompt job renders no `CronJob`, so a `worker` block mirrored onto one was read by nothing: the values passed the schema and rendered clean, with no sign that the ServiceAccount, Secrets and resources it named applied nowhere. The runtime already refuses the pair at manifest load; the chart now refuses it at render. Chart 0.15.0, with the entry below; the runtime is untouched. - **Scheduled command jobs can share the agent's warm code index read-only.** Chart 0.15.0 adds `persistence.jobCodeIndex`, disabled by default, to mount the index and checkouts using the existing same-node affinity. The runtime now pins ox 0.15.0, which supports read-only search. Checkout-only deployments keep their existing behavior. External worker jobs retain their workspace isolation; scheduled prompt jobs already use the gateway's code tools. The job contract documents data-directory setup, readiness checks, and the explicit agent flag for non-interactive prime calls. - **The surface read tools refuse an argument they do not declare, instead of dropping it.** `read_channel` called with `withinhours`, or any other spelling the tool does not list, used to parse as a read with no window and hand the whole channel to a caller that believed it asked for a day, with nothing to say so. Every surface read tool now fails that call and names the key it did not recognise. - **`read_channel` takes a time window, and the gateway's clock cuts it.** Pass `withinHours: 24` and nothing older comes back: it becomes `Filter.since` on Buzz and `oldest` on Slack, so the surface does the cutting and the answer is the period rather than a count to be sifted. The brain names a duration and never an instant, which is where this failed silently — a digest job scheduled at 18:00 Pacific fires at 01:00 UTC on the *next* calendar day, so a turn given that date and told its own schedule placed "now" a day ahead, opened a window starting after the newest message in the channel, and reported the busiest day the channel had had as "nothing in the last 24h". Nothing flagged it: the read returned `ok`, the turn passed, and the post succeeded. Alongside it, `more` now answers the question a caller is asking — true means there are messages inside the window, older than the oldest one returned, that this read did not return. It was `false` on Buzz whenever a read filled its `limit`, because one REQ ends on EOSE and that was read as the whole channel, so a channel busier than `limit` reported as fully read and the authors it never paged back to read as quiet. - **Codex can run as an agent's brain over ACP, alongside Claude.** Select it with `sageox-agent brain codex [--model ]`; setup and doctor use the agent's `OPENAI_API_KEY`. Both providers share channel sessions, memory, MCP tools, and guarded replies. Codex uses an isolated home and gateway-enforced tool permissions. Switching providers clears the previous model pin unless a new one is supplied. The runtime image includes both ACP adapters; local fallbacks pin the same versions. ## [0.5.2] - 2026-09-11 Everything below shipped after `v0.5.1`. On publication, `ghcr.io/sageox/agent-base:0.5.2` takes `:latest` and advances `:0.5`. Pin the digest recorded on the GitHub Release in production. A patch rather than a minor because nothing about configuration moved: no manifest field, no chart setting, and no chart version — `deploy/helm` renders on 0.14.0 exactly as it did. **Every Slack reply reads differently, and there is nothing to turn on.** Emphasis, headings, list markers and links render now rather than arriving with their punctuation showing. The one thing to check before upgrading is an agent whose prompt was steered to write Slack's dialect itself: `*bold*` is Markdown for italic, so that steering now produces `_bold_`. Drop it; the adapter translates for every agent. Only `adapter-slack` changed, so Buzz and console egress is byte-identical. - **A brain's Markdown renders on Slack, because the adapter now writes Slack's dialect.** A reply left the gateway as the brain wrote it — `SlackAdapter.outboundText` escaped `&`, `<` and `>` and nothing else — so `**Agents logged solid work.**` and `[#305](https://github.example/org/repo/pull/305)` arrived with their asterisks and brackets showing, while the same text read correctly on a Markdown surface. Steering a persona per surface is not a fix: a fleet's reply contract is one prompt shared by every agent, so "write `*bold*` on Slack" cannot be said to one of them, and a contract that requires a Markdown link cannot be excepted at all. The dialect is a fact about the transport, so the transport applies it — `adapter-slack` is the only thing that knows the surface is Slack. On egress `**bold**` and `__bold__` become `*bold*`, `*italic*` becomes `_italic_`, `~~struck~~` becomes `~struck~`, `# Heading` becomes bold, `-` and `*` list markers become `•`, and `[text](url)` becomes ``; code spans and fenced blocks are copied untouched, and a bare URL is left bare because Slack links one itself. The pass runs **after** the escape, which is what keeps it safe: by then a `<`, `>` or `&` the brain typed is an entity, and a link is built only around an `http(s):` or `mailto:` URL — so `[page everyone](!channel)` is still text and `` still notifies nobody. ## [0.5.1] - 2026-09-11 Everything below shipped after `v0.5.0`. On publication, `ghcr.io/sageox/agent-base:0.5.1` takes `:latest` and advances `:0.5`. Pin the digest recorded on the GitHub Release in production. A patch rather than a minor because nothing here asks a running deployment to act: an `agent.yaml` that declares no `prompt` job loads and behaves exactly as it did on 0.5.0, so `:0.5` moving forward onto this is safe to pick up. Helm chart 0.14.0 pairs with this release, and only in that direction. A 0.5.0 gateway refuses an `agent.yaml` that declares a `prompt` job — `jobs[]` required `run` there and rejects unknown keys — so an upgrade that mirrors one in values must take `imageRef` to 0.5.1 in the same pass. - **A job's body may be a prompt, so an agent can do light scheduled work only its brain can do.** Work started in exactly two ways before this: a turn, when a message mentioned the agent, and a job, which spawns a process with no brain, no tool broker, and no second surface. So nothing could read channel A on surface X, summarize it, and post to channel B on surface Y — and nothing could happen at 18:00 unless somebody posted a mention at 18:00. Every workaround put the clock outside the agent, where its kill switch, `suspend`, `doctor` and work events cannot see it. A `jobs[]` entry now declares exactly one body: `run` for a process in a pod of its own, or the new `prompt` for a brain turn in the gateway process. Everything around it is the envelope that was already there — `slug`, `archetype`, `trigger.schedules` and `trigger.timezone`, `killSwitch`, `suspend`, `report`, `announce`, the work events, `doctor` and `validate` — which is why this is one list and not a second block. `prompt` takes either an inline string or `{ skill: }` — **a skill**, at `skills//SKILL.md` in the bundle, which is the layout every agent runtime already uses for a page of instructions an agent reads and follows. Inline is for something short and the schema does not enforce that; a page of prompt inside a YAML block scalar is a page nobody reviews. Named rather than pointed at, because a name is what a person says and what a tool argument carries: the day a skill can be invoked from the chat face, "run the digest now" resolves the same name through the same lookup, with no second declaration and no file moved. The frontmatter `name` must match the directory. The root is the bundle's own `skills/` rather than a harness's discovery directory, which is `docs/naming.md` applied to a layout. Read at load and refused there if the skill is missing, over 64 KiB, not UTF-8, not a regular file, or really lands outside the bundle's `skills/` tree — the words reach the brain as steering rather than as fenced data, and the reason they may is that they came out of the reviewed bundle. A name cannot be absolute, cannot traverse, and cannot reach the runtime's own `workspace/`, so those are not doors this closes one at a time. The tick admits in the job host's order — kill switch, `suspend`, then the gateway's own turn caps — and a refused tick is recorded and posts nothing. It then enters the turn path as a synthetic inbound event: the author is `schedule:`, an id no surface issues, so the author gate is skipped because there is nobody to weigh, and nothing else about the turn changes. The reply is a top-level post in `report.channel` through the same guarded chokepoint the brain's own `post_message` clears; an empty reply posts nothing. The prompt comes from the reviewed bundle and nowhere else — no channel text can start one of these turns, edit its prompt, or claim to be one. Ticks that fall while the gateway is down are not replayed, and the in-process clock computes the next fire in `trigger.timezone`: a local time a spring-forward deletes runs at the next real instant, and the hour a fall-back repeats fires once. `doctor` and `validate` print where each prompt job's words came from — a resolved path for a file-backed prompt, `inline` for a one-liner — their size, and its next fire time; `job run` refuses one, and `job park` still stops it. Chart 0.14.0 mirrors a prompt job as `{slug, suspend, trigger, prompt: true}` with no `budget`, renders no CronJob for it, and refuses a `sharedVolumes` claim mounted inside `/agents/` — the runtime cannot tell a mount point from a directory, so a target that can place one over the bundle owes that refusal. See [the job body contract](docs/job-contract.md#a-job-that-is-a-turn). - **An external worker deploys on a managed Kubernetes cluster again.** The 1.34 floor chart 0.13.0 introduced compared the server's version against `>=1.34.0`, and every managed distribution reports a GitVersion carrying a build suffix — `v1.34.9-eks-bca9cf6`, `v1.34.5-gke.1234` — which semver reads as a PRERELEASE and never matches a constraint without one. The floor therefore refused every cluster it was meant to admit, including ones well above it, and `helm upgrade` failed at render with `external worker requires Kubernetes 1.34 or newer`. The constraint is now `>=1.34.0-0`, which admits a prerelease-tagged version while still refusing a genuinely older cluster. The cases that let this ship used bare versions, so they could not tell a working floor from one that refuses everything; the suite now renders a suffixed version on both sides of the floor. Chart 0.13.1. The runtime is untouched — this is a template comparison, so the published image for 0.5.0 is already correct and no new one is needed. ## [0.5.0] - 2026-09-10 Everything below shipped after `v0.4.1`. On publication, `ghcr.io/sageox/agent-base:0.5.0` takes `:latest` and `:0.5`. `:0.4` stays on 0.4.1. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. **A `helm upgrade` has a window in which armed external jobs fail to dispatch, and the chart cannot order it away.** A host on this release sends `switch.value` on every armed external job, and the request schema is strict, so a dispatcher still on 0.4.1 rejects those requests. One `imageRef` covers the gateway, the dispatcher and the scheduled launchers, and their workloads roll independently — there is no values setting that takes the dispatcher to the new image first. Nothing is wedged by the window: it ends when the dispatcher Pod is replaced, a requested run that failed in it can be asked for again, and a scheduled one fails a tick and takes the next. To skip it, park each armed external job before the upgrade with `sageox-agent job park ` and arm it after. Deployments with no external jobs are unaffected. **Two values files that rendered under chart 0.12.1 now fail.** An external worker below Kubernetes 1.34 is refused at render rather than shipped to a cluster that cannot run it — 1.34 has been the documented floor since external workers shipped — and a worker Secret that an agent's `jobSecrets` already mounts is refused as a shared credential. Everything else is additive: existing manifests need no new fields, and `report.history`, the `admission` section on work events and `sageox-agent validate` are each opt-in. - **A job can announce something once without keeping any state.** A job that declares `report.history: true` beside `report.probe: true` gets a fourth verb on its per-run channel, `channel_history`: the recent messages in the one channel `report` names, oldest first, with the `more` flag the brain's `read_channel` carries. That is what a scheduled poller needs to be idempotent — the announcement already in the channel is the record of what was announced, so a run that died halfway through re-posts only what it missed, and nothing has to be written to a claim or back into the system being watched. A grant of its own rather than part of `probe`, because it is the one job-channel verb that hands back **a conversation this run did not start** — not replies under a root it published, but whatever was said in the room. A roll call keeps reading only the thread it rooted, and an existing `probe` job gains nothing it did not ask for. It reaches no further than `probe` already did — the channel is the declared one and there is no argument that could name another — and `history` without `probe` is refused at load. The text is untrusted on the same terms as every other channel read. See [the job contract](docs/job-contract.md#a-job-that-announces-something-once). - **A monitor can tell a deliberately parked job from one nobody meant to stop.** Every `run.completed` work event now carries a host-minted `admission` section: the switch reading this run took (`state`, `origin`, bounded `failure`), what its stored value was recognized as (`arming`, `parking`, `unrecognized`, or `unavailable` from a switch source that predates the classification), and `bypassed_switch` for a human's run of a parked job. `switch: null` means the record holds no reading — the job declares none, or the run was refused before one was read. Unrecognized values still park the job, and only `value: "parking"` is evidence anyone chose that: a scheduled job denied every run because its key was never written no longer reads the same as one somebody parked. No stored value, annotation, requester or backend error text is emitted. Existing manifests and custom `SwitchSource` implementations need no change; consumers must treat a missing `admission` as unknown, never as parked. External-dispatch requests gain the same optional field, which a dispatcher parses strictly. A request carries it whenever the switch key holds a value, which is every armed job: bring the dispatcher to this release before the gateway, or those jobs fail to dispatch while the gateway is ahead of it. See [the job contract](docs/job-contract.md#admission-diagnostics-on-the-terminal-record). - Chat replies keep the final ACP answer without replaying narration superseded by tool calls. Detached jobs reply to their requester in plain language; diagnostic IDs, timings, gate details and raw failure reports stay in operator records/reports. Tool guidance preserves outcome and uncertainty without requiring diagnostic prose to be repeated verbatim. Worker completion never claims an application side effect. - Repository Codex hooks now notify SageOx on `SessionEnd`, allowing active recordings to finalize when the session ends. - **Helm chart 0.13.0 keeps an external worker off every credential and cluster it must not reach.** Dispatcher bundle staging now excludes gateway shared volumes. Chart validation rejects a worker Secret already used by any agent's gateway, dispatcher, or `jobSecrets`, and refuses an external worker rendered for a cluster older than Kubernetes 1.34 — the floor [the external jobs guide](docs/external-jobs.md) already named. - **A repository that authors `agent.yaml` files can check them in CI.** `sageox-agent validate ` parses each file against the schema `run` loads at startup and exits non-zero if any is invalid, naming the field path and the expectation for each problem. It takes paths and nothing else: no agent home, no credentials, no network, and it writes nothing. Reachable without a checkout through the runtime image, whose entry point is the CLI — `docker run --rm -v "$PWD:/w" ghcr.io/sageox/agent-base: validate /w/agent.yaml`. `doctor` still answers the rest, and a parked job is still validated with the file it sits in. See [the deployment contract](docs/deployment-contract.md#validating-a-manifest-before-it-merges). ## [0.4.1] - 2026-09-08 On publication, `ghcr.io/sageox/agent-base:0.4.1` takes `:latest` and advances `:0.4`. Pin the digest recorded on the GitHub Release in production. Existing manifests need no new fields; structured answers and work events are opt-in. Upgrade the gateway, dispatcher and worker images to the same toolkit release before enabling structured answers. Producers must check `JOB_OUTPUT_SCHEMA_VERSION` or `JOB_WORK_SCHEMA_VERSION` before emitting new artifact sections; older hosts reject unknown fields. Local verdict artifacts now also have a 64 KiB limit and must be regular UTF-8 files, not symlinks. Oversized or invalid reports yield unproven gates. - **Helm chart 0.12.1 adds `agents..workEvents` to enable structured job logs.** Set it to `true` with toolkit 0.4.1 or newer to enable events on the Deployment and scheduled job hosts. Omitted or `false` preserves ordinary logging. Structured answers use the existing chart resources and need no new RBAC, Secrets or volumes. - Opt-in `AGENT_WORK_EVENTS=1` emits bounded, versioned job start/completion records from both scheduled and chat hosts. Job reports may include typed artifact, subject state, usage and health facts when `JOB_WORK_SCHEMA_VERSION=1` is present. Child diagnostics are isolated from host event envelopes; raw gate details, requester information and parameters are excluded. These are runtime reports, not independent provider confirmation. - **External jobs can return bounded structured JSON answers through `job_status`.** Reviewed jobs opt in with `output: {format: json}` and use a versioned section of the existing artifact. Answers persist for seven days, independently of diagnostics, and require an explicit read by the requesting author in the original conversation. Missing, invalid, blocked or unavailable output does not erase execution facts or valid gates, and delivery failures never rerun the job. See [the output contract](docs/external-jobs.md#structured-answers). ## [0.4.0] - 2026-09-07 Everything below shipped after `v0.3.1`. On publication, `ghcr.io/sageox/agent-base:0.4.0` takes `:latest` and `:0.4`. `:0.3` stays on 0.3.1. Before 1.0.0 a minor release may break configuration, so no `:0` tag is published. Pin the digest recorded on the GitHub Release in production. **Before upgrading, add top-level `killSwitchParkBy` to every `agent.yaml` with a job that declares `killSwitch`.** The new runtime refuses to load such a manifest without it. Use `killSwitchParkBy: []` to refuse parking requests from all recognized agents, or list the stable agent ids whose parking requests should be accepted, including any fleet supervisor that must retain that ability. Unidentified authors and calls without a single attributable live turn remain permitted; this field does not prove an author is human. Manifests without job kill switches need no change. Existing agents opt into the new tools by re-running `sageox-agent memory add team` for the ledger readers, `sageox-agent repos add ` for `code_insights`, and `sageox-agent mcp add jobs` for job status and cancellation. The ledger readers require a verified fresh repository ledger; code insights reports unknown tracker data until pull requests and issues have been indexed. **The Helm chart moves to 0.12.0** for the dispatcher and isolated workers. External jobs require Kubernetes 1.34 or newer, a separate worker ServiceAccount, a dispatcher authentication Secret, and a worker image built from the same toolkit release. Follow the [external jobs setup](docs/external-jobs.md), including its namespace and credential requirements. Existing local jobs need no worker configuration. - **Jobs can run on demand in their own digest-pinned runtime images on Kubernetes.** A shared dispatcher retains run IDs and bounded verdicts across restarts, serializes requested and scheduled workers, prevents duplicate body starts, and supports status retrieval and cancellation. Failed runs automatically post failure details and a redacted error excerpt to the configured report destination and original conversation; no manual diagnostic command is needed. Full redacted stdout/stderr tails and execution facts remain available for seven days through operator-only `job diagnostics`. Worker credentials use a separate identity; existing local jobs remain compatible. See [external jobs](docs/external-jobs.md). - **The team brain can report ledger readiness and list sessions from an operator-synced repository.** `team_status` checks search access and each repository's ledger separately; `team_sessions` lists bounded results only after current credential access, repository identity, ledger availability, and a refresh within five minutes have been verified. Missing or stale data is refused instead of appearing as an empty week. The gateway selects the cwd from `repos.conf`, isolates ox state, and exposes no raw status output or credential details. The ox subprocess inherits only basic process settings, ox paths, and SageOx authentication settings; unrelated gateway credentials are excluded. Re-run `sageox-agent memory add team` to add the tools to an existing policy. Malformed search responses also fail instead of becoming successful empty searches. - **The team brain can read recent coworker activity.** `team_recent` returns work updates and session activity from a configured repository's verified fresh ledger, newest first. It uses an explicit window (default 72 hours, maximum seven days), caps results at 20, and discloses truncation. Missing/stale sources, failed reads, and malformed output are refused instead of becoming an empty window. Long activity text is shortened; raw ox guidance and generated collision advice are omitted. Re-run `sageox-agent memory add team` to grant the tool to an existing policy. Live deployment credential validation remains under #24. - **Optional gateway-owned ledger sync reuses existing Git secrets.** A team brain's `ledgerSync` entries name configured repositories, HTTPS ledger remotes, and optional username/token secret references. The gateway clones and refreshes reader data without starting an ox daemon or pushing. It serializes refreshes with reads, refuses duplicate owners, stops Git on shutdown, and waits for a changed mounted credential after an authentication failure. No additional Kubernetes Secret is required. - **An agent with `repos.conf` can be asked what has been moving lately.** `code_insights` joins `code_search` and `code_status` on the code server: the most-changed files, recent commits, and open pull requests and issues, from the same one-shot index and the same read-only checkout. It takes `days` and `limit`, both capped by the gateway. Each displayed text field, including commit messages, is limited to 200 characters after whitespace is collapsed, so long commit messages cannot fill a turn. Run `sageox-agent repos add ` again on an existing agent to allow `mcp__code__code_insights`; `doctor` names it until you do. Insights responses are validated before rendering. Query diagnostics and error/status responses report unavailable data rather than no activity, even when `ox` exits successfully. The audit records argument shapes so invalid numeric arguments cannot write private text into the log. Its tracker sections report **`unknown`** when the repository has no indexed records of that type. When records exist, they list open items or report `none` among the indexed records. Fresh toolkit indexes have no tracker records: warmup runs only `ox index code`, while pull requests and issues come from `ox index github`, which needs a forge token. Counts from the warmup canary distinguish missing tracker data from a successful empty response. The tool runs `ox` in the gateway over the existing checkout. - **A job kill switch refuses parking requests from recognized agents outside `killSwitchParkBy`.** `brain_write` bounded the switch by value alone — every value that arms refused, every value that parks admitted, whoever asked — so a sibling agent could stop a lane by asking the agent that owns it. Usually that self-corrects, because a human notices a stopped lane and restarts it; for a lane whose own job is noticing, nothing downstream reports it missing. The gateway is the only thing that ever saw who sent the message, so it now passes the turn's author to the write operation: a park is refused when the turn being answered is from a recognized agent the manifest does not name. Arming and the tombstone are unchanged and still refused for everyone. It narrows, and it is not a boundary. The test is positive evidence of an agent, so a surface that cannot identify one admits the park — on Buzz that is a pubkey with no directory record — as does a call the gateway cannot place in a single live turn. Refusing those would refuse a human's park too, and a refusal to park is a kill switch that failed. Steering and `suspend` still carry the rest. - **`killSwitchParkBy` is required once any job declares a `killSwitch`, and a manifest without it will not load.** Add `killSwitchParkBy: []` to refuse parking requests from all recognized agents, or list the ids of the agents whose park this agent honours — a fleet supervisor that pulls an emergency brake is the case it exists for. Absent and empty are different answers and only one is a decision, so it is stated rather than defaulted, for the reason `failDirection` is: a release that enforced the rule while a manifest had not yet named its stopper would silence that stopper with nothing to say so. A pod that refuses to start is the louder half of that trade. Ids only, never names — a name is self-asserted in the surface's own directory record. The parking gate applies to the `private` brain; the manifest requirement applies to every job with a `killSwitch`. A job body holding its own credential writes engrams outside this path, as it always has. ## [0.3.1] - 2026-09-04 Published as `ghcr.io/sageox/agent-base:0.3.1`, which takes `:latest` and moves `:0.3` forward onto it. There is nothing new to set, and no `agent.yaml` that works today stops working. One behaviour changes without being asked for: `limits.turnTimeoutMs` now also bounds the brain's tool calls. At its default that is the more permissive of the two clocks, so a call the brain used to abandon inside a still-live turn now runs to the end of it. An agent that lowered `turnTimeoutMs` to bound a wedged channel has tightened its tool calls by the same move — those calls were already outliving the turn that would have used their result, so nothing that reaches a channel today stops reaching it, but the number now means both things. - **A job short enough to wait for is no longer abandoned partway through the wait.** There was a third clock nothing in the bundle named: the brain's MCP client gives up on a tool call on its own timeout, and whenever that was shorter than the turn it was the one that bound. `job_run` waits for exactly those jobs whose deadline fits inside `limits.turnTimeoutMs` — correct by its own arithmetic, against a number that never applied. The brain was handed a failing tool and told the channel the job had produced nothing; the job then finished and posted its own, correct result, and the only record the gateway kept of the dropped call read `outcome=ok`. The brain subprocess is now started with its tool-call timeout set from `limits.turnTimeoutMs`, so the number `job_run` weighs a job's deadline against is the number that applies. Raise `limits.turnTimeoutMs` and both bounds move together; there is nothing new to set. - **A passing gate's own sentence can render as written.** The host puts `PROVEN:` in front of every line a passing gate produces, which is right while the sentence after it is the host's own machine phrasing and wrong for a job whose gates are a shift report — a body that wrote *the bench is full, so I tended #3961 instead* composed something for a person to read, and the machine word in front of it is the one thing making it read as machinery. Declare `report.proven: verbatim` and that sentence posts as written. It reaches PASS alone, and only the lines a body wrote: a passing gate that said nothing still reads `PROVEN: …`, because the sentence there is the host's; FAIL and UNKNOWN keep their label under every value, since that label is the whole of what stops a body's reassuring prose from reading as a success. Nothing about how a verdict is derived or recorded moves, and the headline stays host-phrased — a combined verdict carries none of the body's words for `verbatim` to render. The default, `labelled`, is what every job posts today, so a job that declares nothing reads exactly as it did. ## [0.3.0] - 2026-09-03 Everything below shipped after `v0.2.0`. Published as `ghcr.io/sageox/agent-base:0.3.0`, which takes `:latest` and `:0.3`. `:0.2` stays on 0.2.0, and `:0` is not published at all — before 1.0.0 a minor bump may break you. Pin the digest recorded on the GitHub Release in production; the tags are for humans. Still pre-1.0: configuration format and CLI flags may move between minor versions. Three things a deployment already running 0.2.0 has to act on. **A long job started from chat now answers the thread it was asked in**, and its `report` channel post is then made or spared on the same terms a waited-for run has always been on — so under the default announce mode a clean verdict no longer posts there at all. A channel read as the record of every detached run is now a channel that has stopped hearing about the successful ones; the run records still hold them. **On Buzz, a channel event now waits for the directory subscription** (kind 10100) to answer on the same socket, which is what lets `limits.maxAgentChainDepth` recognise a sibling. Bounded at thirty seconds on a relay that sends no EOSE, and skipped entirely on one that refuses the kind — where the cap goes on not firing, as it did before. **A `token:` that names a non-default secretRef and resolves to nothing now leaves the `ox` child with no credential**, rather than letting it inherit whatever `SAGEOX_TOKEN` the gateway process happens to hold — which on a host running several agents is another agent's. Such an agent loses team memory and says so, where before it answered as somebody else. The default ref is unaffected: it resolves from that same variable. Two things want the new image before they are worth configuring: `surface-read` is not a server an older binary can be asked to add, and `mention` on `post_message` is dropped by one as an undeclared argument, leaving a post that wakes nobody. **The Helm chart moves to 0.11.0**, for the one entry here that is templates rather than code: `persistence.jobCheckouts` mounts an agent's repository checkouts into its CronJob Pods. It renders on 0.2.0's image, and it is the only entry that does not need the new one. `values.yaml` is unchanged, so there is nothing new to set unless you want it; the dependency pin in the chart's README moves with the version. ### Added - **An agent can read the surface it is already on.** `SurfaceAdapter` could post, react and — since v0.1.0 — read back a thread it rooted, and could not answer the three questions every agent eventually gets asked about its own surface: which channels am I in, who else is in this one, who is this id. An agent that needed any of them had to be handed a second client for the surface it was already connected to, with a second copy of the credential. Four optional adapter methods now answer them — `listChannels`, `listMembers`, `describeActor`, `readChannel` — over calls both adapters were already making internally, and the credential stays in the gateway. **`listChannels` answers from the surface rather than from `agent.yaml`**, which is the point of it: a channel the bot was never invited to, or a Buzz directory record that omits one, is an agent that connects, authenticates, subscribes and is never spoken to, with no error on either side. The two surfaces spell it differently and the guide says so — Slack lists every channel the bot joined, so the answer can be wider than the configuration; on Buzz being in a channel and being addressable in it are two facts, so it returns the overlap of the configured channels and the agent's own directory record and is never wider than the configured list. **`listMembers` is the surface's own roster on both**, `conversations.members` on Slack and the relay's channel-membership event on Buzz — never a directory record, which is its author's claim about itself and would confirm membership for a key that was never granted any. Where a surface can also say whether a mention of a member *in that channel* would reach them, the ref carries `mentionable`: `false` is somebody in the room who cannot be addressed there, which is the silence a roll call would otherwise grade as a dead agent. **Empty and cannot-answer never collapse** — a surface that cannot make a read refuses it by name, because zero members and no membership read look identical to anything handed `[]` for both. The brain reaches them through a new built-in `surface-read` server, four tools allowlisted separately (`sageox-agent mcp add surface-read`) and each capped. The two that name a channel, `list_members` and `read_channel`, resolve it against the configured list exactly as a post does, so no id the brain computes reaches a conversation the agent does not serve. The two that do not — `list_channels` and `describe_actor` — are surface-wide by design, and the guide says plainly what granting the second one means: the agent can resolve any id its surface will answer for. Nothing on it publishes, so nothing on it is egress; what comes back is other people's text and is untrusted exactly as an inbound message is. `read_channel` answers `more` beside its messages, because a short list and a quiet channel are otherwise the same list — Slack serves as few as fifteen records a request to an app distributed outside the Marketplace, so coming back short of what was asked for is ordinary there rather than exceptional, and the agent is told which kind of short it is holding. A probing job body gets the one read it was missing on its own per-run channel: `channel_members` takes no destination at all, and is what lets a roll call say whether an agent that did not answer was slow or was never in the room. - **The job body contract says what a body finds on disk.** A body never writes `workspace/` — the repository checkouts and the `ox` index there are built by `sageox-agent run`, in its own process, so what a body finds there depends on where it is running: a run the brain starts is inside that process and, on an agent whose brain has code tools, sees one — while every other run is a standalone `job run`, which builds no workspace whatever its trigger and reads one only where its target makes one visible. `docs/job-contract.md` has the rule, the test to make before looking, and what to do when the answer is no; `job run` is now held to it by a test that fails if it ever starts warming a workspace of its own. - **A scheduled job can read the agent's repository checkouts.** A job Pod's `/agents` is an `emptyDir`, so a body on its 3am tick started from nothing — no checkout, and no way to afford the clone inside its budget — while the agent Pod beside it held the same repositories, cloned once and fast-forwarded since, on its claim. The chart's new `persistence.jobCheckouts` mounts `workspace/repos` from that claim into the agent's CronJob Pods, read-only and `subPath`-narrowed, with a required pod affinity onto the agent's node — the price a `ReadWriteOnce` claim charges, and the reason a tick that cannot land there is lost as a `DeadlineExceeded` Job rather than run without the code it was written to read. The `ox` index does not come with them: `ox` opens its store read-write and reports one it cannot write as corrupt, so a shared index would answer a search from nothing rather than fail. Off by default, per agent, and [the chart's README](deploy/helm/README.md#a-job-that-reads-the-agents-checkouts) has the three things it deliberately does not do. - **A post can wake one person or agent.** `post_message` takes `mention` — one principal, by the id on a message's `from` line or a name the surface lists — and the adapter renders it as its own addressing primitive: a `p` tag on Buzz, `<@id>` on Slack. Until now a brain's post reached a channel and woke nobody in it: on Buzz the `p` tag is the only wake trigger, and on Slack the `<@…>` a brain writes into text is escaped, so a cross-post could inform a channel but never reach anyone. Whom the agent may address is bounded twice. The id must be one the manifest names in `owner` or `allowlist`, or one the surface itself vouches for — on Buzz, an agent with a directory record, which is also where the name comes from — and the recipient's own `respondTo` gate still decides whether being mentioned wakes them. One addressed post per turn, tied to the single conversation mid-turn, so one admitted message wakes at most one principal and a call with no turn behind it wakes nobody. The resolved id is written on an `addressed …` line beside the `tool_call` that asked for it. A `mentions` list stays a probing job's capability. - **What the addressed principal answers comes home to the conversation that asked.** A post that names someone opens a *link* from the post to the message it was made on behalf of, and for the next hour, or twenty lines, that principal's replies under that post are brought into the asking thread verbatim — `ida (buzz · hive): passed, 0 failures` — as this agent's own message. A person in Slack can ask an agent on Buzz a question and read the answer where they asked it, and an agent on Buzz can put a question to a person in Slack the same way. No brain is involved: the gateway relays deterministic text under a label it wrote, through the same guarded path a reply takes, so public consent and the leak scan apply on the home channel and the surface's own escaping keeps a mention inside the relayed text from addressing anyone. It is not a bridge, and every bound that keeps it from becoming one is stated in code: a link opens only from an addressed post, only the addressed principal's replies under that one root come home, a bystander's never, the agent's own never, and the link closes on its count and its clock. A reply that came home starts no turn, even when it mentions the agent: it was addressed to the person who asked. The kill switch silences relays too. `relay from=… home=… result=sent|refused|failed` is the log line. - **A job that outlasts the turn answers the conversation that asked.** `job_run` started such a job, said "running", and the verdict went to the job's `report` channel alone — the person who asked in a Slack thread had to go and look. The job door now keeps the message it was answering and, when the run settles, replies into it with the same text a waited-for call returns, through the gateway's guarded reply path. The status post is then made or spared as it is for a waited-for run, so a clean verdict no longer posts twice. Shutdown pays the same debt: a run the host gives up on tells the asker so, inside the grace it already had. A reply the home channel refuses, or a call the gateway could not pin to one conversation, leaves the status post as the answer, as before, and the tool says which of the two it promised. `job_answer … result=lost` is the log line. ### Changed - **A SageOx credential refreshed under the agent's secrets mount is picked up without a Deployment restart.** The team brain's token was resolved once, when the gateway started, and stamped onto every `ox` child for the life of the process — so a secrets-store CSI driver that refreshed the mounted file in place changed nothing, and the agent went on sending a revoked value until somebody restarted it. The gateway now reads the secret per `ox` child, which is a file read next to a process spawn, and the reading that a lookup latches clears itself the moment the new value is accepted. Rotation stops needing a human; a genuine revoke is still the case that does, which is the honest split. Every other credential still resolves at startup — each is held by a connection or a subprocess a rotation would have to re-establish anyway — and refreshing the mount remains opt-in: the bootstrap module leaves the CSI driver's rotation reconciler off, so on that path a restart is still the rotation step for this credential too. A configured token ref now also speaks for the agent when it reads as nothing: the `ox` child carries no credential and falls back to its auth file, rather than inheriting a `SAGEOX_TOKEN` from the gateway's own environment — which on a host running several agents is another agent's. `docs/deployment-contract.md` has the split. - **A GitHub Release leads with one line per entry here, not the whole section.** Quoting the section put a screen of *why* above the image digest — the one thing a deployment needs from the release — and above the pull-request list GitHub generates for the tag. The body is now each entry's lead sentence under its Added / Changed / Fixed heading, then the digest, then that generated list, with this file linked for the rest. Write an entry's first sentence to stand alone: it is what the release notes show. ### Fixed - **A dead SageOx credential no longer degrades an agent in silence.** Every `team_search` failed and the agent went on answering team-knowledge questions from the model alone — the confident wrong answer, reached from a direction nothing was watching. The only trace was one `ox_failed class=not-authenticated` line per turn in the gateway log. The team brain now latches what each lookup proved as a capability reading, `brain.team` / `cannot-reach`, so the turn prompt tells the agent not to answer as if team memory had worked and the launch prints a `note:` line naming the credential to rotate. An answered lookup clears the reading, so rotating the credential needs no restart. `run` also takes one reading at startup. `doctor` was the only thing that ever checked the credential and a deployment does not run `doctor`, so a credential already dead at deploy time was exactly as silent as one revoked later. It is a capability and not a precondition: an agent without team memory is less informed, not wrong, so it still comes up, works, and discloses. Two failure classes latch and only two — a rejected credential, and an `ox` that is not on `PATH`. A lookup that merely fell over does not: the next one may well answer, and announcing an outage a retry disproves is how people learn to skim announcements. - **The agent-to-agent chain cap now applies on Buzz.** The adapter marked only its own key as an agent, because recognising a sibling needs a roster the toolkit does not own — so `limits.maxAgentChainDepth` never fired there, and two agents that allowlist each other could answer one another until `maxTurnsPerThread`, since every reply `p`-tags the author it answers. The relay already holds the roster: every mentionable agent publishes a directory record (kind 10100), the record clients gate a mention on. The adapter now subscribes to that kind and delivers a channel event only once the directory has answered on the current socket — two REQs are two subscriptions a relay may interleave, and a sibling's message replayed ahead of the record naming it would slip past the cap as a person's; events that arrive early are held and released in order, on a reconnect as on the first connection, for at most thirty seconds on a relay that sends no EOSE and not at all on one that refuses the kind — and sets `isAgent` for any author it lists, so the cap the design spec promised (§8 rule 4) holds on Buzz as it does on Slack. Nothing is declared and nothing is pruned: a record that disappears does not make its author a person. ## [0.2.0] - 2026-09-02 Everything below shipped after `v0.1.0`. Published as `ghcr.io/sageox/agent-base:0.2.0`, which takes `:latest` and `:0.2`. `:0.1` stays on 0.1.0, and `:0` is not published at all — before 1.0.0 a minor bump may break you. Pin the digest recorded on the GitHub Release in production; the tags are for humans. Still pre-1.0: configuration format and CLI flags may move between minor versions. Two things a deployment already running 0.1.0 has to act on. **Slack needs the `users:read` scope** before an agent reads a mention as a name; a workspace that withholds it keeps rendering every mention as its id, which is what it did before. And **a job Pod's `/agents` no longer outlives the run** — a body that kept durable state beside its bundle needs a `sharedVolumes` claim whose access mode allows the placement. **The Helm chart moves to 0.10.0**, for the one entry here that is templates rather than code: `/agents` in a job Pod is an `emptyDir` instead of the agent's `ReadWriteOnce` claim. It renders on 0.1.0's image, and it is the only entry that does not need the new one. Two of the rest are keys an older binary will not honour, so roll the image before setting either: `jobs[].run.jobSecrets` is refused under `.strict()`, and `mentions` on `post_message` is dropped as an undeclared argument, leaving a roll call that addresses nobody — the silence that field exists to prevent. ### Added - **A Slack agent reads a mention as a name, not an id.** Slack's addressing primitive is in-band, so a mention of a third party arrived as `<@U0ALICE>` — which tells a brain that somebody was addressed and not who. It answered about an id, and could not tell that two mentions of one person were one person. The adapter now resolves member ids through `users.info` and renders them as `@alice`. The directory outranks any label the sending client embedded — `<@U0ALICE|bob>` reads as alice, because the two disagree after a rename and the id is who Slack will actually notify. Needs the **`users:read`** scope; without it the label is used where there is one, and otherwise every mention keeps rendering as its id, which is what it did before, and a refusal is remembered so a name Slack will not give is asked for once rather than once per message. An unnamed mention still reads as a mention: dropping it would lose the fact that somebody was named. The rendered form is text, not markup, so quoting it addresses nobody — the property `outboundText` already kept by escaping, now held one step earlier as well. **Inbound delivery is asynchronous as a result.** Resolving a name is a network call, so the adapter normalizes one message at a time *per conversation*, in arrival order: `ChannelQueue` preserves the order it is submitted in, so two messages racing on their lookups would have the agent answer the second question first, and a reply with no inbound context thread onto the wrong message. Ordering is kept per conversation rather than adapter-wide, since that is all `ChannelQueue` asks for and one message's lookups must not delay another channel. A message still resolving when `stop()` runs is discarded rather than finishing into a later `start()`. After the first mention of a person every lookup is a cache hit. An envelope that arrives before the connection is up waits for it rather than being dropped, and a start that then fails delivers none of what it heard — the caller's `start()` throwing and a turn having been spent answering would otherwise both be true at once. - **A probing job can read its thread back on Slack, so a roll call there has an answer.** `SlackAdapter.readThread` walks `conversations.replies` under a root the run posted and hands back the replies oldest first. Only Buzz implemented the verb, so a probe on a Slack-only agent posted its roll call, waited, and then died on *"the slack surface cannot read a thread back"* — the fleet-liveness job, unable to run on one of the two surfaces the toolkit ships. The endpoint was already in the adapter's API seam, used by backfill. Replies are normalized through the same `toSlackInboundEvent` a turn is, so a join notice or a hidden message is no more a reply than it is a turn, and the thread parent Slack returns is dropped by `ts` — it is not in its own thread. Every failure throws and none answers `[]`: an unstarted adapter, a root naming another surface, and a root in a conversation this agent does not serve are all findings a probe must not read as silence. - **A probing job body can address its post, so the agents it names actually wake.** `post_message` takes `mentions`, and the adapter renders them as its surface's addressing primitive — a `p` tag on Buzz, `<@id>` on Slack. Without it a probe posted into a channel and woke nobody: a `p` tag is Buzz's only wake trigger, a channel post deliberately carries none, and so a roll call read back an empty thread and reported the entire fleet silent — a failure indistinguishable from a total outage, on the one job whose output is consumed as fleet liveness. Recipients are **ids the surface resolves** (`npub…` or hex, a Slack member id) and never display names, which render and wake no one; the adapter refuses a name rather than publish a message that looks addressed and is not. At most 64 per message, and being addressed reaches no further than `jobs[].report` already did. The field is the probe's alone: a status post — this body's own `report`, and every non-probe job's — still addresses nobody, and the brain's `post_message` has no such field. - **A bundle can say which of a job's credentials the gateway's own process must not hold.** `jobs[].run.jobSecrets` takes the same env-var-to-`secretRef` map `run.secrets` does and resolves from the same directory list, so a one-directory deployment satisfies both. What it adds is a load-time refusal: a job declaring one **may not arm `trigger.onRequest`**, named ref and all. A target could already hand `job run` a second directory it does not give the gateway — `--job-secrets`, which chart 0.9.0 mounts as `agents..jobSecrets` — but nothing in the manifest recorded which ref lived there, so a job that was both scheduled and on-request resolved it on every tick and was refused by name the first time a person asked for it. `onRequest` is the only trigger the gateway serves; every other one enters through `job run`, a separate process. The gateway still gains no credential to fix it — the message names the three ways out instead: drop `onRequest`, keep the credential in `secrets` and take the weaker guarantee knowingly, or give the credentialed work a job of its own that nothing may ask for. A name declared in both maps is refused too, since the envelope merges them. `run.jobSecrets` is also left out of the inventory `run` checks before it opens a socket, which is what lets such an agent launch at all: a credential that moved but stayed spelled `secrets` refuses the launch, not just the run. Nothing that loads today stops loading — the key is new, and `run` was already `.strict()`. ### Changed - **The agent base image ships `ox` 0.14.3.** `OX_VERSION` and both architecture checksums in `deploy/docker/Dockerfile` move up from 0.13.0. The six ox calls the toolkit makes — `query`, `status`, `team list`, `index code`, `code status`, and `code search` — take the same flags and return the same fields on 0.14.3 that they did on 0.13.0, so nothing that reads them changes. ### Fixed - **A broadcast in a Slack message is escaped and logged instead of throwing, so the turn ends in an answer.** `SlackAdapter.outboundText` refused `` by throwing, and `SurfaceEgress.reply` does not catch around `send` — so the throw left `drive`, ended the turn, and the withdrawn acknowledgement left the channel watching the glyph appear and vanish with no reply. The brain was never told what happened. That refusal predates the outbound escaping this release also ships and was the only thing keeping a broadcast off the wire; `<!channel>` now renders as those characters and notifies nobody, so the refusal bought no reach and cost the turn. Every attempt still gets one line an operator can act on — `egress_escaped surface=slack channel=… rule=slackBroadcast`, the shape `egress_blocked` already logs. The sharper half was that `normalizeSlackText` un-escapes inbound text, so somebody *typing* the characters `` reached the brain as markup: quoting a message that merely discussed Slack broadcasts killed the turn over one nobody sent. The un-escape is unchanged, because the round trip is symmetric now — what the brain reads as characters goes back out as characters, and `mentions` remains the only way a Slack message addresses anyone. - **A scheduled job runs wherever the cluster puts it, instead of only on the agent's node.** The chart mounted the agent's `ReadWriteOnce` claim in every job Pod as well as the Deployment's, and RWO binds a volume to one node — so a job Pod the scheduler placed anywhere else could never attach it. It sat in `Init:0/1` behind a `Multi-Attach error for volume` until `activeDeadlineSeconds` killed it, with nothing in the job's own logs, because the body never started; the same job then completed in seconds on the ticks that landed beside the agent, and hung for the whole deadline on the ones that did not, which is what made it hard to recognise as a placement problem at all. Once the scheduler settled on another node, every tick hung. `/agents` in a job Pod is now an `emptyDir`, staged for that run by the same init container the agent Pod runs and gone with it — a run needed nothing that was on the claim: it stages its own bundle from `/config`, reads its kill switch through the relay, and writes its verdict under the container's own tmpdir. Two Pods writing one EBS volume was never safe on the ticks that *did* co-locate, either. **A job body that genuinely shares durable state with the agent now has to say so** — one `sharedVolumes` entry, on a claim whose access mode allows a second node, which is the same thing shared brains already ask for. One that silently relied on the agent's warm checkouts, index, or local vault gets an empty directory instead; on a claim it could only reach from one node, and only after the Deployment had gone first, it was already relying on luck. The deployment contract's job clause says this too: a target owes a run a writable bundle directory, not a durable one. - **The launch a job-only credential refuses now names the field that would let it start.** `sageox-agent run` resolves every `jobs[].run.secrets` ref against the directory this process was given, before it opens a socket, so a credential moved to a directory only `job run` is given — but left spelled `secrets` — takes the whole surface down: no mentions answered, no on-request runs, over a value nothing in that process would have read. The refusal stays right, since nothing there can tell a moved credential from a typo, and a scheduled job's unresolvable ref is otherwise a crashed 3am tick in a channel. What was missing is the way out. The two remedies the message offered — mount the file here, add it to `.env` — are both "put it back where the gateway reads it", which is the arrangement `run.jobSecrets` exists to avoid, and that map is deliberately left out of this inventory. Each job-declared ref now carries it as the hint, in `run` and in `doctor`. A job that also arms `trigger.onRequest` is still refused at load, naming the three ways out it always has. The remedy is withheld where the gateway itself also reads the ref — a job and a `private` checkout sharing `GITHUB_TOKEN` would have to move a token the clone needs — so `mergeByRef` now keeps a hint only where every declaration gives the same one, on the reasoning it already applies to `degraded`. Which declaration was pushed first no longer decides which advice an operator reads. - **A job a person asks for runs, even when its kill switch is parked.** `job_run` records the author of the message the agent is answering, so a request that arrives through a chat surface is the human on-request run the host has always described — it has refused with *"only a human's on-request run bypasses a parked job"* since jobs shipped, and nothing was ever classified as one. A `tools/call` carries this server's bearer token and the tool arguments and nothing at all about the turn that produced it, so the author is read off the gateway instead: the same live-turn registry the reaction tool reads to mark "the message you are answering". **A person is an author the manifest names in `owner`**, not one whose `isAgent` flag is false — only a surface can tell an agent from a person, and Buzz cannot yet: `toActorRef` flags this agent's own pubkey and nobody else's, because recognising a sibling needs a roster the relay does not serve, so a bypass keyed on that flag would reach every sibling in a fleet. Everyone else is automation for the purpose of the switch, including an allowlisted colleague — an allowlist says who may speak to this agent, and a fleet's names siblings — and so is a call arriving while two channels are mid-turn at once, where no one person can be named. `on-request` remains a trigger rather than an authorization. The record names the turn's author whichever kind it is, rather than this agent's name, and falls back to the brain only where there is no one turn to read it from. The bypass answers only whether the run starts: every gate governing what it may do is untouched, and it writes nothing, so a parked job is still parked afterwards and the run carries `bypassedSwitch: true` for whoever reads the record at 3am. Worst on a job with no schedule at all, where the switch parked no clock and its only effect was to refuse the request it exists to permit; the workaround it replaces is arming a posture switch for one run and remembering to disarm it. - **A DM sent to a Slack agent while it was down is answered when it comes back.** The backfill walked the configured `channels` and nothing else, so it could never reach a DM: a DM's conversation id does not exist until someone opens it, which is why no entry names one, and the adapter's live set of them is empty until an event arrives. A DM in that gap was therefore in neither set — nothing enumerated it, nothing replayed it, and the resume cursor moved past it the moment any channel message was accepted. The message was gone for good, and the person who sent it got silence from an agent that looked healthy. `users.conversations` now supplies the open DMs at backfill time, which is what `im:read` — already in the setup guide's scope list — is for. **Reading one is not permission to speak in one:** a DM still earns a reply by having sent something, so a conversation with nothing in the gap is enumerated and stays one the adapter may not post into. A workspace that withholds `im:read` loses the DM backfill and keeps everything else, rather than failing the launch over a scope a channel-only agent never needs. - **A Slack message says what the brain wrote, and addresses only whom `mentions` names.** The adapter escapes `&`, `<` and `>` in the brain's text, so `<@U0ALICE>` renders as those characters instead of notifying that member. Slack's addressing primitive is in-band — `<@id>` written into the text *is* the mention — while every other surface addresses in a field of its own, so `GuardedMessage`'s inability to represent a recipient was a claim the Slack surface did not keep. Inbound text is already un-escaped for the brain and a mention of a third party reaches it as live markup, which made quoting the message that woke the agent enough to page whoever it named: through none of the id validation `mentions` gets, and recorded on the audit line as `mentions=0`. The recipients the adapter builds from `mentions` are still markup — the one part of an outbound message it constructs itself. Escaping also takes the reach of ``, which is what let its refusal go. ## [0.1.0] - 2026-08-31 First full release of 0.1.0. It is `v0.1.0-rc.2` plus the two entries below — everything the two release-candidate sections describe is in it, and those sections stay as the record of when each part arrived. Published as `ghcr.io/sageox/agent-base:0.1.0`, and this is the first release to take the floating tags a candidate is refused: `:latest` and `:0.1`. `:0` is not published at all — before 1.0.0 a minor bump may break you, so a major-only alias would promise a stability that does not exist. Pin the digest recorded on the GitHub Release in production; the tags are for humans. Still pre-1.0: configuration format and CLI flags may move between minor versions. The Helm chart is 0.9.0, unchanged since rc.2. Both entries below are code rather than templates — `jobs[].report.probe` is a key an older binary refuses under `.strict()`, and `announce: reported` is a value outside that binary's enum — so roll the image before setting either, and no chart bump is needed to render an agent that does. ### Added - **A job body can post into its report channel, read the answers back, and mint its verdict from what it read.** `jobs[].report.probe: true` opens a per-run channel the body reaches over HTTP at `JOB_CHANNEL_URL` with `JOB_CHANNEL_TOKEN`, carrying two verbs: `post_message`, bounded to the one channel the job declared, and `thread_read`, bounded to a root that same run posted. Until now a body's only channel output was the terminal verdict the host mints — right for a job that *observes*, and unable to express a job that **probes**, where the reply set is knowable from the channel and from nowhere else. A fleet roll call is that job: a Deployment can be `Ready` and green while consuming no events at all. The listener is opened before the body is spawned and closed when it exits, its token is minted per run, and there is no field for a destination — the brain is not offered any of it, and a job body is still not an MCP client of the gateway. A surface with no thread model refuses the read rather than answering with an empty thread, because "nobody replied" and "this surface cannot tell you" are different findings. `SurfaceAdapter` gains an optional `readThread`, implemented on Buzz as one REQ on the socket it already holds; a job that declares no `probe` is spawned into exactly the envelope it had before. - **A job that is both scheduled and reporting can be heard only when it has something to say.** `jobs[].report.announce` gains a third mode, `reported`, which posts a run whose body wrote a `detail` on some gate, whatever the verdict, and behaves as `unproven` otherwise. Neither existing mode fits a job that ticks every half hour and finds something twice a month: `always` makes it a half-hourly "nothing to report" in a channel, and `unproven` is structurally silent on the runs that did the work, since a run whose gates all passed has nothing unproven to announce. Keying on `detail` is the distinction — gates without prose are outcomes the verdict already speaks for, while a `detail` is a sentence the body composed for a human. It buys no pass, because the status word in front of that sentence is still minted from the verdict, and it lowers no floor: a body that wrote no gates is still UNKNOWN and still posts. `unproven` and `always` are unchanged. ## [0.1.0-rc.2] - 2026-08-30 Second release candidate for 0.1.0. Everything below shipped after `v0.1.0-rc.1`, which was the first published image. Published as `ghcr.io/sageox/agent-base:0.1.0-rc.2` only. A release candidate takes no floating tag — not `:latest`, not `:0.1` — so nothing tracking those moves onto it. Two of these need this image and not only the chart, because they are code rather than templates: `jobs[].report.announce` is a manifest key an older binary refuses under `.strict()`, and `--job-secrets` is a flag an older binary ignores, leaving a mounted source unsearched. Roll the image before setting either. The Helm chart is 0.9.0; `networkPolicy` and the documented container names need no new image, and a release that sets none of the new keys renders byte for byte what 0.8.0 rendered. ### Fixed - **A single-surface agent can be served the top-level post tool.** `post_message` was offered only when two or more surfaces named a channel, on the reading that posting is always *cross*-posting. It is not: a job has no inbound turn to answer, so the tool is the only way it reaches a channel on its own initiative, and `jobs[].report` has always reached one through the same `SurfaceEgress.post` call from an egress built on a single adapter. The capability now follows the channels — any configured post target will do. Adding a surface still grants the tool automatically only at two, so a single-surface agent gets it by naming it, never as a side effect. The audit verb is `post_message` to match the tool, where it read `cross_post`; the internal `crossPost` flags are `postMessage`. ### Added - **The chart's container names are documented.** `agent`, `job`, and `stage-config`, in a table in the chart README, because a cluster add-on that acts on some containers needs their names and nothing else stated them. EKS's `eks.amazonaws.com/skip-containers` is the case spelled out — excluding `agent` keeps `AWS_ROLE_ARN` out of the container reading untrusted channel text — with `podAnnotations` being release-wide, so one value names the containers of both Pod kinds. Whether the webhook ignores a name matching no container in a given Pod is left explicitly unasserted. - **A credential only a job needs can be kept off the Pod that runs the brain.** `agents..jobSecrets` is a second secret source, mounted by that agent's CronJob Pods alongside `secrets` and searched ahead of it when a job body resolves `run.secrets`. A write token that pushes branches was previously a file in the container running an LLM over untrusted channel text — unreadable by policy, since the tool policy denies `Read(//mnt/secrets-store/**)` and the brain's environment is an allowlist, but a policy is a file that can be wrong. What is not in `secrets` is now not in that container at all. It adds rather than replaces: a job process resolves the agent's own credentials too, for the surface its report is signed with and the switch it is admitted past, and both of those swallow a failure to resolve — so swapping the mounts would answer a forgotten credential with a disarmed kill switch and a lost report. `resolveSecret`'s `dir` accepts a list for this, and `job run` takes `--job-secrets`. Scheduled runs only: a run started on request executes in the gateway's own process and fails such a ref by name, which is also what stops a prompt-injected turn reaching a write credential through a job it may ask for. Chart 0.9.0. - **A reporting job can be heard without claiming it failed.** `jobs[].report.announce` (default `unproven`) decides whether a run that proved itself is still posted. The default is today's behaviour exactly — a job that found nothing posts nothing — and is right for a job that hunts. It is wrong for a job whose successes are the point: with only the verdict to speak through, such a job had to claim it proved nothing to reach its channel, and its headline then read `FAILED` over words saying a fix had landed. `always` posts whatever the verdict is, so the job can exit 0 for "this went fine" and still be heard. It moves nothing else: the status word is still minted by the host, a body still cannot write one, and a combined verdict still carries none of the body's words into the headline. Neither mode announces a job the kill switch or a suspension refused. - **An agent can declare the traffic it is allowed.** A release-wide `networkPolicy` block renders one NetworkPolicy per agent, covering that agent's Deployment and CronJob Pods, with `ingress` and `egress` rules passed through verbatim the way a `bundle.volume` is. `policyTypes` is the switch and there is no `enabled` beside it: empty renders no object, because a policy that names no direction is a deny-all-ingress rule rather than an inert one, and rules written for a direction it does not name are refused at render rather than applied and ignored. Enforcement stays the cluster's — where the CNI does not implement NetworkPolicy the object applies cleanly and constrains nothing, so this is a declaration of intent until you have checked otherwise. Chart 0.8.0. - **A job may read the Kubernetes API.** `agents..serviceAccount.automountJobToken` (default `false`) mounts the projected ServiceAccount token on that agent's CronJob Pods, which is the only credential in-cluster API auth has. The Deployment Pod's `automountServiceAccountToken: false` stays unconditional — it runs an LLM over untrusted channel text — and the knob is named for the job so no single value can conflate the two. Mounting the token grants nothing on its own: bind the reads with your own `Role` and `RoleBinding`, which this chart still does not render. Chart 0.7.0. ## [0.1.0-rc.1] - 2026-08-28 First release candidate for 0.1.0, and the first published image. Pre-1.0: configuration format and CLI flags may still move between minor versions. Published as `ghcr.io/sageox/agent-base:0.1.0-rc.1` only. A release candidate takes no floating tag — not `:latest`, not `:0.1` — so nothing tracking those moves onto it. ### Added - **One agent across many chat surfaces.** A single process multiplexes Buzz/Nostr, Slack, and a local console into one brain and routes each reply back out the way it came in, so the agent keeps one identity, one memory, and one face everywhere. - **A brain that holds no transport or write credential.** The brain can only *request* actions, through one guarded chokepoint; the gateway decides and executes. A prompt-injected brain can only ask, and every ask meets the tool policy and the guard. - **MCP servers run inside the gateway**, spawned with the credential in the gateway's own process and published to the brain as brokered tools. `mcpServers[].scope` puts a fail-closed bound on any server's credential — name an argument and its allowed values, and every `tools/call` must carry it. A leak scan runs over every string argument of every call, reads included, and refuses on a hit. - **Memory with a private tier.** Markdown vaults, age encryption, and a shared/private split, with vault reads and appends opened `O_NOFOLLOW` so a planted symlink cannot reach outside the vault. - **Jobs.** Anyone may park a job; only a human may arm one, enforced on the write. - **`sageox-agent create`** — a guided, resumable interview that builds a coherent identity (purpose, approval boundary, voice, look) rather than just naming a bot, then offers a brain, chat surfaces, memory, and tools. `sageox-agent run` starts a console agent with a mock brain and no runtime account, key, or model spend. - **Deployment.** A Helm chart (`agent`) and Terraform for AWS EKS, against a multi-arch image published to `ghcr.io/sageox/agent-base` with a pinnable digest. ### Added - Jobs may declare `parameters` — typed, bounded values one run is given, for work that needs a **target**: which issue, which document, which environment. `mcp__jobs__job_run` advertises them on its input schema and refuses a value that does not match at the call; the host validates again, so the bound holds on every door, including `job run --param`. The body reads them as `JOB_PARAM_`, and they are on the run record, which is where "what did that run act on" gets answered. Environment, never argv — the command line is still `run.command` and `run.args`. `integer` (with `minimum`/`maximum`) and `string`, bounded by a closed list of `values` or by a `pattern`, exactly one of the two — an unbounded string is the free-form argument this tool spent its design avoiding. No boolean: "which" is not a question answered yes or no. A job that declares none is started by a slug and nothing else, exactly as before — its `job_run` schema does not grow a `params` field at all. A parameter needs `trigger.onRequest`, since nothing else can supply one, and a *required* parameter may not also arm a schedule or a webhook: neither has a target to give it. ### Changed - The repository is now `agent-toolkit`, renamed from `buzz-agent-toolkit`. Its packages were already `@sageox/agent-toolkit-*`, and no shipped artifact ever carried the old slug — the image is `ghcr.io/sageox/agent-base`, the CLI is `sageox-agent`, the chart is `agent` — so the cost is a redirect on the old GitHub URL, which keeps working. Existing clones need `git remote set-url origin https://github.com/sageox/agent-toolkit.git`; nothing in a deployment changes. `docs/naming.md` no longer exempts the repository slug, because there is no longer anything to exempt, and `test/naming.test.ts` now checks the slug like any other identifier. - `identity register buzz` no longer ends at a membership-gated relay. It prints **both** grants an administrator has to make — `buzz-admin add-member` for relay membership, on the relay host, and `buzz channels add-member --role bot` for the channel — then waits and re-reads the relay when you say they landed, finishing the registration in the same sitting instead of asking for the command to be run again. The wait is a keypress rather than a poll: what it is waiting for is a person in another terminal. Each retry is a real authenticated call, because a relay can accept the NIP-42 handshake from a key it will still not serve, so "the admin says it is done" is not evidence that it is. Non-interactive runs behave as before: the handoff is printed and setup continues. `doctor`'s membership failure now names the same `buzz-admin add-member --pubkey ` command, since the key to admit is the one thing the failure does not otherwise tell you. - The channel bot role is offered at the prompt, not only printed as a command. After the relay accepts the identity, registration asks `Add it to channel now?` and reads the channel owner or admin key through the same hidden, one-time prompt `--add-as-bot` uses — so the one credential setup asks for that is not the agent's own never reaches a shell history. Guided `create` gets it by driving the same command: it picks the channel off the relay's own menu, then makes the grant. Decline, or run without a terminal, and the complete command is printed exactly as before; a key the relay refuses reports and falls back to it rather than failing a registration that already published. - The channel-role command the handoff prints is now complete: `buzz channels add-member` carries neither the relay nor the signing key — both are global `buzz` options, and an omitted `--relay` is `http://localhost:3000` — so the bare command granted a role on whatever relay the admin's shell defaulted to, or none. It now names the relay and shows where the owner key goes, in the environment rather than in argv where `ps` would show it. The same command printed at the end of a successful registration was fixed with it. - Guided `create` offers the same grant and wait at the *surface* step, which is where it meets a gated relay one step before registration. It used to fall back to asking someone to type channel ids the relay had just refused to show them. Declining still falls back, so a relay that cannot be listed for any other reason is unchanged. - The membership refusal is recognized in the spelling the relay actually sends — `403 relay_membership_required`, forwarded verbatim by the `buzz` client — and not only in the prose a NIP-42 refusal carries. Unrecognized, it reached guided `create` as an ordinary step failure, which re-asked "Publish its profile and join a Buzz channel now?" for as long as anyone kept answering yes. ### Removed - The team brain's `team_kb_list` and `team_kb_show` tools, and the knowledge-bubble plumbing behind them — `ox kb` enumerates a feature nobody maintains, and the project config the gateway wrote under `.agent-toolkit-ox//` existed only to scope it. `team_search` is now the team brain's one tool; it is also the only one that works where an agent actually runs, because `ox query` is answered server-side from the token while `ox conversation`, `ox session list` and `ox glance` all need a locally synced checkout this toolkit does not keep. ### Fixed - A job body's per-gate `detail` reaches the status post. The field was declared on the verdict artifact schema, parsed, and then dropped by `verdictFromGate`, so every threaded line under a job's headline read as `FAILED: ci did not pass (gate ci exited 1).` no matter what the body wrote — and a linked reference the body put there never reached the channel at all. A gate that supplies no `detail` posts exactly what it posted before. The status word in front of the line is still the toolkit's, and the headline is still minted from the combined verdict, which carries no `detail`, so a body still cannot phrase its own PASS. - `memory add team` lists the teams on the machine again. It read them from `ox kb list --json`, which ignores `--json` and prints a table, so the parse threw on every call and the listing was silently always empty. It reads `ox team list --json` now, puts the primary team first, and leaves out the `.bak.` clones a restore leaves behind — `ox` reports those as teams, but their ids are directory names that no deployment can resolve. ### Added - `memory add team` offers to create a SageOx account when no teams are found on the machine, pointing at https://sageox.ai/register and waiting for the team to exist before asking for its id. Previously that branch told someone to find the id in an app they had no account for. ### Changed - `memory add team` now asks for the SageOx token even where `ox login` already authenticates the workstation. That login lives in the user's config directory rather than in the bundle, so a container built from the bundle had no credential and failed every `team_search` while still answering — the setup that collected every other credential was the one place the deployment's token was never asked for. A blank answer still skips it, and `doctor` keeps reporting the gap. ### Not included - **A separate-container tier.** The brain is a child process, so it shares the gateway's filesystem. Credentials are kept out of its *environment*, but that is not a filesystem boundary.