Add gateway/runtime-owned commands that remain usable when LLM credits
are exhausted:
- /start — acknowledgement without consuming a reply
- /new [name] (alias: /reset) — create a fresh session
- /topic [off|help|<session-id>] — session switching for threaded chats
- /retry — remove last assistant message, replay last user turn
- /undo [N] — remove last N messages from history (default: 1)
- /title [name] — set or display session title
- /branch [name] (alias: /fork) — create child session with inherited history
- /compress [here N|focus topic|--preview|--dry-run] (alias: /compact)
Design:
- sessionTracker maps channel+thread to active session, auto-creating
implicit sessions with the legacy sessionKey format for backward
compatibility with existing persisted data
- /new and /branch create explicit UUID-backed sessions
- SessionStore extended with DeleteRecentMessages, MessageCount, and
SaveMessages for undo/retry/branch/compress operations
- SessionContext extended with Title, ParentSessionID, BranchName
- All commands report 'not configured' when session store isn't wired
Session resolution is wired into the LLM responder so /new, /branch,
and /topic switches affect subsequent chat turns.
Implement session-scoped goal/subgoal/steer/queue state management
with thread-safe access and prompt injection for standing goals.
Commands:
- /steer <text> — queue a message to inject after the next tool call
- /goal [text|draft|show|pause|resume|clear|status|wait|unwait]
- /subgoal [text|remove N|clear]
- /queue (aliases /q, /bg, /btw, /background) [text|remove N|clear]
Architecture:
- SessionState in internal/gateway holds per-session goals, subgoals,
steer queue, wait flag, and background queue
- Goals are injected into the system prompt via BuildGoalPrompt()
- Steer messages are consumed between agent tool-calling steps via a
MaxSteps=1 loop in the daemon's respond closure
- Commands route through the existing gateway.Router with not-configured
guards when State is nil
Closes: archie-core-alm.1
Extend /model command to support:
- /model [model] (direct switch)
- --provider <name> (provider switch)
- --global (persist scope, with ModelPersist callback)
- --session (explicit session scope, default)
- --refresh (show current active model)
Add /personality command:
- /personality lists available personalities with inline keyboard
- /personality <name> switches directly
- Callback handling for inline keyboard selection
Router changes:
- Add Personas field (wired to PersonaRegistry in main.go)
- Add ModelPersist callback for --global persistence
- Route /personality as a local command
- Extend handleModel to accept full rest text with flag parsing
Gateway-local commands that report from Archie-owned state:
- /whoami: reports the Archie identity the user is talking to
- /profile: shows active Archie profile (identity, provider, model, available models)
- /sessions: lists recent sessions with last-active timestamps
- /resume [id]: resumes a session by ID or prefix match
- /agents: lists active agents and running/waiting tasks
Adds SessionLister and AgentReader interfaces to Router, wired from the
daemon composition root. SessionStore already satisfies SessionLister.
AgentReader is a thin adapter over store.Task list filtered to active
states (running, waiting_human, parked).
All commands are published in Telegram's menu and /help, and respond
with 'not configured' when their backing interface is nil.
Closes archie-core-alm.2
Hide /approve from Telegram's command menu, help text, and discoverability.
Telegraph users can no longer learn about task approvals through the bot.
/approve remains executable in the gateway router for email and webhook
channels; non-Telegram workflow callers are unaffected. Daemon polling of
forged waiting_human tasks and the Requeue(→implement) handoff are untouched.
Auto-fix lint issues and reformat imports across all files.
gci: group imports per project convention
gofumpt: format unused imports with blank lines
gofix: Go standard fixes
goimports: organize imports
Remaining 54 issues require manual judgment (not auto-fixable).
- Remove unnecessary string() conversion on res.Status in workflow/agent.go
(Status is already string in agentexec.Result)
- Fix TestRunWrapsExternalCommand: sh -c only reads the first argument as
the command string. exec.CommandContext("sh", "-c", "echo wrapped")
passes the intent correctly, while the previous split form
(", "", "echo", "wrapped"") treated "wrapped" as /bin/bash.
Missed in f800e1d, which ported internal/worktree but stopped at "the
sibling package still compiles".
Both NATS handlers ran their work under context.Background(). The client
side has a Timeout and passes a context, but the server discarded it, so
a prepare or push ran unbounded. That was survivable when the work was a
git child process that could be killed; after f800e1d it is an in-process
go-git clone, so an unresponsive forge wedges the handler goroutine
permanently. Removing the per-repo object cache in that same commit made
clones longer, which widens the window further.
Server now has a Timeout (defaulting to 15 minutes, sized for a large
clone over a slow link) applied via handlerContext, with a table test
asserting both the explicit and default paths produce a bounded deadline.
The fixtures also still shelled out to git, so every test in the package
skipped when no git binary was present and the helpers tripped noctx.
Rebuilt on go-git to match internal/worktree's suite, including pinning
commit.gpgSign=false on the seed repo so fixtures do not inherit signing
from the host's global config.
internal/worktree no longer executes the git binary. Clone, fetch,
checkout, commit, push and diff all run in-process through go-git v6,
which also removes the package's 9 noctx findings since the Context
variants are first-class.
Security: the forge token no longer leaves the process. The old
implementation wrote a GIT_ASKPASS shell script to disk and exported the
token into the environment of every git child process. Authentication is
now an in-process credential passed via client.WithHTTPAuth. cloneURL
also stops embedding the bot user in the GitHub URL.
Dropped the per-repo object cache (PreparePersistent, prepareCache,
CleanupExpiredCaches). go-git can clone with shared alternates but has no
equivalent of --dissociate, so a cached bare repo would remain a live
dependency of every worktree built from it, and expiring one would
corrupt running tasks rather than fail cleanly. Every task now gets an
independent full clone. repo.PersistentStorage still governs the
container volume; only the git object cache is gone.
Two real defects surfaced while porting, both caught by the new tests:
- go-git honours the host's global git config and cannot sign commits
(no gpg fallback, only an ObjectSigner plugin). On any machine with
commit.gpgSign=true set globally, every bot commit would have failed
with "cannot auto-sign commit". setIdentity now pins gpgsign=false in
the clone's own config so daemon behaviour does not depend on the
ambient config of whatever host it runs on.
- go-git's Add(All) does NOT honour .git/info/exclude, which is how the
.archie-prepared sentinel was kept untracked. It was being committed
and would have been pushed onto every task branch. The sentinel now
lives at .git/archie-prepared, where nothing can ever track it, and a
regression test asserts it never appears in a commit.
Diff is now merge-base relative via Commit.MergeBase, matching the three
dot semantics of `git diff origin/base...HEAD`; diffing against the remote
tip would attribute commits landed on base since the branch started to
this task and could trip the diff-size cap. Base resolution tries the
remote-tracking ref first and falls back to the short "origin/<base>"
revision, keeping git's more permissive lookup.
The test suite was rebuilt on go-git fixtures and no longer needs a git
binary installed to run.
97 -> 85. Not one of the eleven nilerr findings was a bug.
I called these "real bug candidates" when I planned the phases. I was
wrong, and the reason is worth recording: every site is the same
deliberate idiom, and a linter cannot see intent.
- inprocess.go (5) and gateway.go (2) are handlers that report a
problem as TEXT to their consumer. A tool handler returning a Go
error aborts the tool call; returning "rejected: ..." lets the model
read the feedback and retry with valid arguments. A chat handler
returning a Go error surfaces as a gateway fault instead of a usage
hint to the human.
- worker.go carries runErr in the response envelope's Error field.
Returning it as a Go error too would double-report and abort the
NATS reply.
- email.go returns nil when Accept fails because context cancellation
closed the listener. That is a clean shutdown.
- codesearch.go skips an unreadable entry and continues the walk. A
best-effort index must not abort on one bad file.
- skill.go is documented in the function comment already: a
non-directory skills path means "no skills", not a fatal error.
Annotated each with //nolint:nilerr and the specific reason rather than
excluding the linter by path, so nilerr stays live everywhere else and
the next reader wondering "why nil here?" gets an answer at the site.
This is the phase I insisted on keeping single-session and out of the
subagent fan-out. A worker told to "fix nilerr" would have converted all
eleven to error returns: malformed tool arguments would hard-fail the
agent loop instead of being correctable, chat typos would read as
gateway faults, and shutdown would log spurious errors. Every test would
still have passed.
130 -> 96. forcetypeassert, predeclared and usetesting are now at zero.
Fanned out across four isolated worktrees partitioned by package so no
two workers could touch the same file: internal/tools (20 assertions),
internal/webui, internal/memory + internal/ratelimit, internal/secret.
Four stragglers outside those scopes fixed inline (internal/pairing,
internal/forge, internal/channels/telegram, internal/tools/mcp).
Unchecked type assertions became comma-ok with a t.Fatalf naming the
actual type. One site in a goroutine uses t.Errorf + return instead,
since t.Fatalf from a non-test goroutine is undefined behaviour.
predeclared renames chose names from meaning rather than adding a
suffix: max -> maxQueryLen, maxMatchLen, maxRequests, alphabetLen, and
nextBackoff's max -> ceiling. `real` -> `base` in the webui tests.
os.Setenv became t.Setenv, which restores on cleanup, so the paired
deferred Unsetenv calls went with it.
Note for future fan-outs: the agent worktrees branched from origin/main
(a7388a0), not from this branch, so every diff arrived based on a tree
without the phase 1 autofix. They were applied with `git apply --3way`
and the phase 1 changes to internal/memory/manager.go were verified to
survive — in particular the repaired `ctx, cancel =` assignment. A plain
`git apply` would have silently reverted it.
golangci-lint run --fix plus the formatters: errorlint, gocritic,
sloglint, usestdlibvars, usetesting, gci, gofumpt, goimports.
160 issues -> 130.
One autofix was wrong and had to be reverted by hand. gocritic rewrote
ctx, cancel = context.WithTimeout(ctx, m.prefetchTimeout)
to `:=` inside an if-block in internal/memory/manager.go. That does not
compile, which is the good outcome — had it compiled, the shadowed ctx
would have scoped the timeout to the if-block and the prefetch deadline
would silently never have applied. Restored the assignment and commented
why it must not be a declaration.
Worth recording: --fix is not a safe no-op. It broke the build on a
24-file change, and the failure mode it was one compiler error away from
was a silent behaviour change.
Follow-up to c924281, which introduced two defects of its own.
1. indexing.Config was a private config island: index paths existed nowhere
in internal/config or config.example.toml, so they were undiscoverable
and unsettable by anyone reading the real configuration.
Now [indexing] in config.toml, defined in its own internal/config/
indexer.go rather than appended to the 21-struct config.go, and its
defaulting lives with it as IndexingConfig.withDefaults so finalize
delegates instead of growing. Paths default off work_dir, keeping the
two archied instances on one host from sharing an index. Documented in
config.example.toml.
internal/indexing keeps its own plain Config and does NOT import
internal/config, so it stays a straight diff against its tau original.
2. A failed index build was invisible. refreshAsync wrote the reason to a
database column with no reader and degraded to unindexed search in
silence — the failure mode that costs hours precisely because nothing
appears to be wrong. Every give-up path now logs, and a successful
build logs once.
The logger is resolved at the point of use, not in the constructor: a
Manager can be built as a struct literal (the ported tests do), and
constructor-only defaulting panicked on the build goroutine, where a panic
takes the daemon with it. Regression test covers the zero and nil Manager.
First slice of the tau cherry-pick strategy: copy-and-mutate rather than
extracting tau to pkg/. Exporting would force designing metrics, session
and logger seams upfront, before archie-core knows which of them it wants
differently — a cost paid for reuse not yet proven. ai-sdk earned library
status by stabilising across two consumers; nothing in tau/internal has.
indexing is the cheapest high-value lift: 512 LoC, one file, and its only
coupling to tau was three calls to process-global config path helpers.
Nothing else in tau imports it.
Mutations from upstream:
- path helpers become an explicit indexing.Config. Two archied instances
share a host (archie and winter), so they must not share one index.
- the child-process helper is archied's own workspace-codesearch
subcommand, dispatched before flag parsing so it touches no config,
store or NATS.
- deferred db.Close calls explicitly discarded; archie-core runs errcheck.
The child process is not incidental: google/codesearch calls fatal exits on
a corrupt index and leaks mmapped regions. Verified end to end against this
repo — 2.2MB indexed, correct hits for BuildSystemPrompt, [] for no match,
and a deliberately corrupted index returns "corrupt index" with exit 1
instead of taking the process down.
Every lifted file carries a provenance header naming its tau path and
commit (4893818d0c76), so refreshing from upstream is a diff rather than
archaeology.
The chat agent's entire system prompt was the four-sentence static string
in gateway.DefaultPersonas(). It carried no tool inventory, no environment
block and no instruction precedence, so the model invented its own
capabilities: asked to set something up it announced it "only has the
memory editing tool", then offered to walk through installing software it
has no tool to install.
Renders a template modelled on tau's agent.md.tpl + tau.agent.md:
instruction precedence, core rules, communication rules, a <tools> block
and an <env> block. The persona stays the style layer on top; the rules
and the tool inventory live in the template so switching persona cannot
remove them.
The tool list is derived from the same core.ToolSet handed to the model,
so the prompt cannot drift from what the agent can actually call, and an
empty toolset renders an explicit "no tools are available" rather than
silence the model fills in for itself.
Tool metadata is third-party data from MCP servers, so it is markup-escaped
(<, >, & only — not xml.EscapeText, which mangles prose into 
/')
and whitespace-flattened, so a description cannot forge a closing tag or a
second "- tool: ..." list entry.