docs/ is the archie-core VitePress site (Archie-branded, see index.md).
This README.md was a Tau reference manual that was never linked from the
site index and doesn't belong in this repo.
The tau references in internal/tools/builtin/ are legitimate attribution
headers — those files were deliberately lifted from tau with source
commit hashes.
SaveConfig's hermesHome parameter and HERMES_HOME references in comments
were copied from another project. The interface and its callers are
entirely internal to archie-core (no external call sites exist outside
tests), so renaming them is safe.
hermesHome -> dataHome
HERMES_HOME -> data directory
/tmp/hermes -> /tmp/archie-test
Test fixtures used 'sam', 'samcharles93', and 'sam/<repo>' as owner
names. These are personal and machine-specific — the repo should use
generic placeholders like 'acme' (matching the existing convention in
worktree_test.go).
config.example.toml: samcharles93 -> your-github-username
Test owner: sam -> acme
Repo refs: sam/archie-core -> acme/archie-core, etc.
Example skills: sam -> acme
CLAUDE.md now describes the host+container deployment model, release
workflow, and per-package traps agents need to know about (no sensors
package, WriteTaskJSON path, long-polling drop, MCP provider hard-fail,
.dockerignore, GOTMPDIR).
CI (deploy.yml) gains a gate job that runs before the image builds:
the quality gate (fmt, vet, build, test), then a check that every
release tag at HEAD has a matching [version] section in its changelog.
A tag without a changelog entry fails the build. No tags at HEAD prints
a warning — images get stamped 'dev'.
'always' against a private registry answers 401 because the daemon
calls ImagePull with no credentials. The live config already uses
'missing'. This just brings the template in line.
The chat agent's file tools operate on host paths, so the daemon has to
see the host filesystem. It keeps spawning agent containers through the
Docker socket and talking to NATS, so compose still carries the bus and
the network; archied and watchtower leave it.
Pins the network subnet: the daemon hands agent containers its own
nats.url verbatim, so that URL has to work from the host and from inside
a container. The gateway address does; a Docker-assigned subnet would
move it silently when the network is recreated.
The agent service created a container that exited 0 immediately while
compose reported it as "Started", which reads like a crash loop. A build
profile keeps it out of `up -d`; naming it still works for build and pull.
containers.pull_policy was "if-not-present", which is not a recognised
value -- the pool pulls only when it is "always" or "missing", so the
typo disabled pulling outright and the deployed agent image drifted a day
behind the daemon. Watchtower cannot cover for it: agent containers are
spawned per task, and it only restarts long-running ones.
The changelogs said 1.1.0 while 116 commits sat untagged on main, and
the deploy workflow stamps images 'dev' when no tag points at HEAD.
Two steps, so generated notes can be edited before a tag freezes them:
release:prepare writes them, release commits and tags. Which commits
land in which changelog is decided by each binary's package closure
(go list -deps), so a change to a package archied does not import
cannot show up in archied's changelog.
After the daemon was down ~9 hours it booted and answered every message
sent while it was gone -- 8 stale messages, 8 LLM turns, one burst.
Telegram holds undelivered updates for 24h and replays them on the first
getUpdates. launch()'s webhook branch already passes DropPendingUpdates;
the long-polling fallback had no equivalent, and polling is what this
deployment uses. deleteWebhook carries the flag even when no webhook is
registered -- the same call python-telegram-bot makes when it starts
polling -- and it doubles as a guard against a stale webhook, which
would otherwise fail getUpdates with 409.
Bounded by a 10s deadline so an unreachable Telegram cannot hold up
gateway startup.
None of these belong in the repo, and .gitignore already said so for
three of them -- adding a pattern does not untrack what is already
committed.
- .codex/: bd init's Codex hook wiring, local tooling
- .references/skills-implementation.md: one stray from an ignored dir
- task.json: a runtime artefact, not config. The daemon writes one per
task into the container's worktree mount; this was a leftover brief
for issue #57 that an agent committed from its own checkout.
- archie-agent: a 50MB host-built binary. /archied was ignored but
/archie-agent was not.
docker-compose.yml was never committed -- it only existed on the
deployment host. It bind-mounted ./config.docker.toml and passed
-config-overlay unconditionally, which made an untracked repo-root
file load-bearing: Docker creates a directory when a bind source is
missing, and the loader rejects a directory, so a fresh clone took the
daemon down at boot.
The stack now passes a single -config pointing at a path outside the
repo. Nothing in the working tree is required at runtime. The
docker-specific values move to deployments/docker-nats-stack.toml as a
reference config, alongside the other deployment guides.
Also drops the ./:/workspace mount, which existed only for
desktop-commander's work_dir.
These asserted on file contents rather than what the code does:
Dockerfile strings, deploy.yml YAML, CHANGELOG headings, and greps of
main.go for identifiers. Two also referenced config.docker.toml and
docker-compose.yml, which were never committed, so they could not pass
at all.
The worst compared strings.Index byte offsets in main.go to assert
startup ordering -- it would pass on code that never runs and fail on
a correct refactor that moved a line.
WriteTaskJSON wrote task.json to the worktree root -- the same worktree
the agent commits from. CommitAll stages with go-git's All option, and
go-git's Add does not honour .gitignore or .git/info/exclude, so the
brief was swept into the agent's commit and pushed onto every task
branch. That is how a task.json for issue #57 ended up committed in
the repo root.
This is the identical failure the prepared sentinel hit; worktree.go
already documents the fix. Nothing under .git can ever be tracked, so
put the brief there rather than papering over it with an exclude.
archie-agent 3.92GB -> 1.43GB, archied 475MB -> 251MB.
- rm -rf /go/pkg/mod/cache cleared the wrong thing: it left the
extracted module sources and the whole GOCACHE in the image, so that
layer was 2.23GB to deliver 168MB of binaries.
- /go/bin was never on PATH, so golangci-lint, gofumpt, buf and dlv
shipped as unreachable dead weight.
- Replace go install with pinned upstream release binaries. delve is
dropped: it publishes no prebuilt binary and was the only thing
forcing a compile step. go install it at runtime if needed.
- beads from its Go release rather than npm, and drop dolt entirely --
bd runs Dolt embedded.
- uv manages Python; no apt Python, no deadsnakes, one version.
- debian:trixie-slim base, Node copied from node:24-trixie-slim.
- archied drops Node: the builtin tools cover what desktop-commander
did, and archied registers MCP providers itself and hard-fails the
process when one cannot start.
Add .dockerignore: the build context was shipping .git, docs/, bin/
and two host-built binaries into every COPY.
The revert in ed61ce3 removed handleSensors but left the route
registration pointing at it, so cmd/archied did not compile. The
sensors package itself was left behind fully orphaned -- nothing in
the repo referenced it. There is no sensor monitoring in this app.
archied crash-looped on startup: mcp.desktop-commander failed with
"transport closed while waiting for response", which failed the whole
tool-provider family and exited the daemon.
The proximate cause was a missing unzip. desktop-commander depends on
puppeteer, whose postinstall extracts a downloaded browser and aborts
with "no zip archiver is available" without it, so npx exited before
writing a byte. Node also moves to 24 from nodesource, matching the
worker image: Ubuntu 24.04 ships Node 18 and several of the server's
transitive dependencies require >=20 or >=22.
Verified in the built image: npx now completes an MCP initialize
handshake and exits 0.
configtemplate's package comment explained the module-root placement by
naming the embed directive in prose, which staticcheck reads as a
malformed directive (SA9009). Reworded, with a note saying why.
Found by running golangci-lint repo-wide while auditing 6108fc5, which
also showed that archie-core-qa4 reports 4/4 phases complete and offers
to close while 56 findings remain. Filed as archie-core-qa4.5 so the
epic's completion count reflects the gate rather than the phase list;
qa4.5 depends on archie-core-ts9, because the nilerr findings in grep.go
are the same swallowed-error bug and fixing them mechanically would
change tool behaviour.
Groundwork for archied setup owning config generation (archie-core-ewk),
so install.sh stops emitting a second copy of the config that drifts from
the example operators actually read.
configtemplate lives at the module root because go:embed cannot reach
outside its own directory and config.example.toml is kept at the root
where it is easy to hand-edit. tomlwrite applies setup answers to that
template in place, preserving the comments that make the generated file
readable - BurntSushi/toml round-trips values but not comments, so
re-encoding a decoded document would strip them.
The nestif extraction in 712388d pulled --provider handling out of
parseModelRest into a helper that took modelParts by pointer and
appended every surviving field to it. The caller's own loop appended
the same fields again, so every model name was doubled: /model gpt-5.6
asked the router for "gpt-5.6 gpt-5.6" and SetActiveModel rejected it
as unknown. The index loop becoming a range loop also stopped the
space-separated "--provider openai" value being consumed with its flag,
so it landed in the name too. Direct model switching over Telegram was
broken for everything but --refresh and provider-only switches.
splitProviderFlag is now the sole accumulator and returns the surviving
fields, so the shared-slice shape that allowed the double append cannot
recur (archie-core-0d6).
Found while auditing the remaining hunks of 6108fc5 (archie-core-ifi):
the naked return in the same function could not be regression-tested
until the function produced correct values. That audit is complete and
the other seven hunks are behaviour-neutral. Notably shell.go's
errorlint rewrite is not a repeat of the grep failure - it had no
companion exit-code condition to drop, and the ctx.Err() timeout check
already runs first - and find.go's errors.Is rewrite is safe because
errors.Is(err, nil) is false for any non-nil err.
Tests cover the return order of parseModelRest (two strings and three
bools, so a transposed pair compiles silently), the field count of the
model name, and shell's exit-code branch, which had no coverage at all.
The find fallback's habit of reporting a cancelled walk as "no matches
found" is filed as archie-core-ts9.
An unresolvable forge token aborted startup with exit 1, denying the
operator chat, the gateway and every other subsystem over a capability
they may not use -- and under the installed unit (Restart=on-failure,
RestartSec=5s) it crash-looped where the error was never read.
Forge setup moves into resolveForge, shared by the primary forge and
each configured identity, and degrades to NoopForge with a warning.
Malformed config still fails fast in validation. The systemd unit gains
StartLimitIntervalSec/StartLimitBurst as a backstop for other failures.
- Render [forge] from the answers given: the generated-config path
hardcoded the GitHub token key and the Gitea host, so a Gitea install
read a key the installer never wrote and a GitHub install pointed at
gitea.example.com. Both config paths now share one renderer.
- Read tokens with -rs so they stay out of terminal scrollback, and
replace rather than append env keys so a re-run does not leave the
revoked token in the file.
- Exit early on non-Linux instead of failing later in a heredoc.
- Never abort the install because the shipped source tree has local
changes; build what is on disk.
An errorlint autofix rewrote the ExitError check to match any exit
code, so a search that never ran (bad pattern, unreadable path) was
reported as "no matches found". Keep errors.As, restore the exit-code
check, and add a regression test.
The communication rules were entirely prohibitions, with nothing
licensing warmth. On a social turn there is no answer to lead with, so
"lead with the answer, keep it short" collapsed into a demand that the
user justify getting in touch: "are you there?" drew "I'm here. What do
you need?"
/stop cancelled the chat turn but could not touch a task the daemon was
executing, and /cancel refused outright:
case statusRunning:
return fmt.Errorf("task is actively running; cannot cancel
until it reaches a waiting state")
So the one case worth interrupting was the one case neither command
would touch.
The daemon now holds a cancel function for every executing task,
registered in process() -- the single point every dispatch path reaches
-- so a task is stoppable for its whole life, including the slow clone,
worktree prepare and image pull that is exactly when someone realises
they asked for the wrong thing.
- /cancel <id> interrupts the work first, then records the terminal
state. That order matters: writing the state while the task still runs
invites it to write its own afterwards and win. A task the store calls
running that nothing is executing (crashed daemon) still gets its state
recorded, which is what unsticks it.
- bare /stop now stops the reply, the queue behind it, and every running
task for the identity, reporting which of those it actually did.
Nobody reaching for the brake should have to look up a task ID first.
- StopRunning deliberately writes no terminal state: a stopped task
unwinds to parked, which is resumable. Forcing rejected would discard
work worth keeping.
- Without a runtime wired, cancelling a running task is still refused --
recording it as cancelled while it carries on would be a lie.
Container teardown detaches from the task context. Release runs on the
way out, and the main reason a task is on its way out is cancellation --
at which point the graceful ContainerStop failed instantly and the
container was left to the forced remove. Cleanup gets its own deadline.
process() gained two statements and crossed the funlen limit, so the
container setup block is extracted rather than suppressed.
Add internal/tools/command: an always-on floor under the shell tool,
enforced in the provider adapter so the lifted tau files stay diffable.
This is not a security boundary and does not pretend to be one. Anything
with a shell has countless ways past a rule list. What it buys is that
the failures with no recovery -- where you cannot intervene afterwards
because the machine, the filesystem, or the gateway itself is gone --
are not reachable by an ordinary mistake.
Rules: recursive delete of / and system directories, mkfs, raw block
device writes, fork bombs, kill -1, shutdown/reboot/init/systemctl
power, and sudo -S with no SUDO_PASSWORD configured. Two more are
archie's own: an agent must not stop the daemon that hosts /stop
(pkill/systemctl/docker), nor start a second one outside the supervisor.
The parsing is the actual work. Patterns are anchored to command
position, so `git commit -m "revert the rm -rf / change"` and
`echo "rm -rf /"` are ordinary commands, while `echo x; rm -rf /` and
`$(rm -rf /)` are not. Quoting, separators, ${VAR} braces, environment
assignments and privilege wrappers are all parsed rather than matched.
Probing the first version found two bypasses that made every rule
optional, both of which a model writes unprompted rather than only an
attacker: `bash -c "rm -rf /"` and `xargs rm -rf /` hide the command in
an argument. Segments are now followed into shell -c payloads, eval, and
command wrappers (xargs, timeout, nice, env, nohup, ...), bounded by a
nesting limit. Tests cover both directions -- the refusals and, at equal
length, the ordinary commands that must not trip them.
shell.go relied on exec.CommandContext's default cancellation, which
kills only the process it started. A shell's real work is a child of
that shell, so cancelling `go test ./...` reaped the shell and left the
test binary running, and `nohup x &` was never touched at all.
That made /stop a lie for the case it exists to cover: the turn
unwound, the user was told it stopped, and the command carried on.
Worse than expected, and caught by writing the test first: without a
process group the tool does not merely fail to kill the command, it
hangs. The backgrounded grandchild inherits stdout, so cmd.Wait blocks
until the shell timeout regardless of cancellation. Verified by
reverting the fix -- the new test fails on a 30s hang, not on the
survival assertion.
Run the command as its own process group, signal the group on
cancellation, and bound Wait with WaitDelay so an inherited pipe cannot
hold the turn open. setProcessGroup/signalProcessGroup were already
present in the lifted set, used by tau's agent.go but not its shell
tool; this extends them to the shell and clears the unused-code lint
that was flagging them.
Recorded as a mutation in shell.go's provenance header.