905 Commits

This Branch

This Branch

All Branches

Author	SHA1	Message	Date
Omar SobhandClaude Opus 5	cd59e4798d	feat(missions): collect the container tier's tool calls ... The hooks from the previous commit write a tap file that nothing reads — which is the same shape as the gate that is installed and inert: everything looks wired and no evidence ever appears. The microVM tier records its tools from inside the loop watching the VM. A container turn is driven asynchronously by topology_worker, so there is no such loop and something has to come and collect the file. `drain_finished_container_phases` does, on the same tick as the benchmark baseline and the security scan, reusing `record_vm_tools` so container tool calls land as the same TOOL_CALL / FILE_TOUCH events the World already renders. One shape, two tiers. Idempotent by TRUNCATION, not a marker or a cursor column: `drain` clears the file it read, so a second pass finds nothing. Read-then-clear happens in one exec, and only for phases that have FINISHED — the agent is no longer appending, so the gap between read and clear cannot lose an event. A cursor would have needed a migration and a column that means nothing to anyone else. Two tests exist because the failure is silent either way: the drain must clear what it read (otherwise every tick re-records the same calls and a phase's early files end up weighted by how long the sweep ran), and the tick must actually call the sweep (otherwise the hooks write a file nobody collects). Full workspace suite green: 107 binaries. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-21 05:53:37 -07:00
Omar SobhandClaude Opus 5	b89606fcf1	feat(missions): gate and observe tools on the container tier ... The container tier is the one that actually runs missions in production, and it had neither a tool gate nor tool telemetry. The microVM tier has had both since yesterday; the tier that matters had neither. Both gaps have one cause. `claude_cli` runs claude as a subprocess, claude runs its tools inside that subprocess, and those calls never pass through ZeroClaw's executor — the only thing that emits TurnEvent::ToolCall and therefore the only thing the gateway turns into a frame ClawMates can see. Recovering the calls from the CLI's stream-json output did not help: a real mission produced zero tool.call events with the parser working perfectly. The transport was never the problem. Hooks are the way in, and they are proven. Claude Code reads hooks.PreToolUse / PostToolUse from the document given to `--settings` and honours them under `-p` — measured yesterday against the real binary, where the gate blocked a Bash call, recorded the payload, and got its refusal reason back to the model. So the same hook scripts the microVM tier uses are now written into the mission's container, and the provider is pointed at the settings document (`--settings` added to claude_cli in the fork, be9c34b1c). Composed in ONE script for one document: two writers of one settings.json is a silent clobber, and the microVM tier already learned that expensively. Installed on BOTH container paths — created and reused. A hook that exists only on first creation quietly disappears after a server redeploy, and the container outlives the server process. Everything degrades to "no hooks", never to a failed mission: a phase that runs unobserved still delivers; one that fails to start because telemetry could not be installed delivers nothing. Four tests, including two that exist because the halves are inert alone: the installer and the provider prop must both be wired (hooks nobody reads, or a document nobody wrote), and nothing may be written under /mission/repo, where it would arrive as part of the agent's delivered diff. Full workspace suite green: 107 binaries. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-21 05:33:25 -07:00
Omar SobhandClaude Opus 5	930c7e0b67	docs: the PreToolUse gate is verified end to end ... Ran it against the real claude binary with the real settings document and the real hook script. Both halves. It blocks: asked to `curl -X POST`, the agent attempted the Bash call, the hook fired FROM --settings, the call was refused, and denied.jsonl recorded the payload with hook_event_name PreToolUse and the exact command. The agent relayed the reason accurately — the text from vm_tool_gate::RULES reached the model, which is the point of writing reasons rather than bare refusals. It allows: `echo` and a harmless `rm -rf ./scratch-nonexistent` both ran and denied.jsonl stayed empty. A gate that blocked everything would have passed the first test; this is the half that rules that out — and two of this gate's four bugs produced exactly that failure. So the last unproven link in the chain is closed, and the gate is real in production rather than plausibly real. One finding worth keeping: asked to `git push --force`, the model refused on its OWN before ever calling Bash, so the hook never fired and the test was inconclusive. A gate test must use a command the model will actually attempt. The model's judgement is not the gate, and testing against something it already refuses measures nothing. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-21 00:19:37 -07:00
Omar SobhandClaude Opus 5	0be932fd83	test(gate): a fixture emitter for the live PreToolUse check, and what it proved ... Tried to close the last open question — does the PreToolUse gate actually fire in a guest — and got most of the way. Established: - the generated script blocks and allows correctly under DASH, not just macOS sh: force-push and `cd /tmp && rm -rf /` return 2, while `grep -rn 'rm -rf /' docs/` and ordinary work return 0 - without node it allows and writes the `inert` marker, so a gate that cannot parse is distinguishable from one that matched nothing - `claude` in the runtime image supports `--settings` (SETTINGS-OK) - PreToolUse DOES fire under `claude -p` in this image — measured by an earlier session and recorded in vm_stop_gate.rs:36 Unproven, and now precisely scoped: whether Claude Code honours a PreToolUse hook supplied via `--settings <path>` specifically, with a real agent turn. The live attempt hit the weekly subscription rate limit, and `claude doctor` does not report hooks, so there is no non-LLM confirmation available. `emit_guest_assets` (ignored by default) writes the real hook script and the real settings document to /tmp so the check can be run against the actual binary in one docker command — no microVM, no fleet. The exact command is in docs/NEXT-SESSION.md. Worth stating plainly: if that link is broken, the gate is inert in production and looks exactly like a gate that found nothing — which is the failure mode this whole session has been about. Full workspace suite green: 107 binaries. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 14:45:48 -07:00
Omar SobhandClaude Opus 5	afb1e29bf3	docs: streamjson2 built but deliberately not deployed ... The corrected runtime image exists on gw-04 and stays there. It delivers no observability until TurnEvent::ToolCall can be emitted for observed calls, so deploying it alone would be a provider output-format change carrying risk for no benefit. Production stays on the known-good :v084. The harmful v1 image was deleted from both hosts so it cannot be redeployed by accident. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 09:55:33 -07:00
Omar SobhandClaude Opus 5	536adddd0f	docs: stream-json tested live — it does not deliver observability, and v1 was harmful ... Deployed the amd64 build to gw-04 and drove a real mission. The agent used Bash and the standard tools; no tool.call events appeared, and the gateway's unmatched-frame histogram still showed only session_start. The reason is structural: TurnEvent::ToolCall is emitted from tool_execution.rs, only for tools ZeroClaw itself runs. Claude Code runs its tools in its own subprocess, so the event never fires. A provider that knows about the calls changes nothing by itself. The first version was also harmful — it returned the observed calls as tool_calls, so the loop tried to execute Claude Code's tool names and fed "Unknown tool: Bash" back to the model. Fixed in the fork; both runtimes rolled back to the known-good image in the meantime. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 09:47:05 -07:00
Omar SobhandClaude Opus 5	ac4fa0b8f7	docs: CI green and deployed — record the verified production state ... Run 498 passed and deployed. Confirmed on gw-04: 53 skills, 11 templates, zero unresolved bindings, self-authoring announced ENABLED, the new gateway_preflight answering, and migration 0080 applied. Also records that run 497 was cancelled by the concurrency guard rather than failing, and that the stream-json runtime image is still NOT shipped by this pipeline. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 08:06:24 -07:00
Omar SobhandClaude Opus 5	689a5e14a3	docs: CI root cause was an apostrophe, not any of the three theories ... Records both real causes (run 490 stomped by an overlapping run; 491-496 killed by an apostrophe closing a single-quoted sh -c block), the guard that now catches the second class locally, and what to check when the in-flight run settles — including that a successful build is the FIRST time these commits reach production. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 07:45:02 -07:00
Omar SobhandClaude Opus 5	8f988739ec	fix(ci): an apostrophe in a comment killed six runs ... Runs 491 through 496 failed on one character. The Rust step is a `docker run … sh -c '…'`. A comment inside that single-quoted block read `cm-api's vm_tool_gate`, and the apostrophe closed the quote. Bash died with "unexpected EOF while looking for matching quote" BEFORE running anything — which is why no log ever appeared, why the breadcrumb showed the step entered and produced nothing, and why three separate theories were floated to explain an empty failure. I introduced it in the commit that installed nodejs, so the fix for run 490 broke every run after it. Run 490 itself was the stomping: it overlapped run 491, which began by removing the shared `cm-ci-pg` container out from under it. That is fixed too, and was a real defect — it was simply not the cause of 491+. `bash -n` answers this in milliseconds and nothing was running it: a workflow is not compiled, not linted, and its only feedback is a red build with a log this deployment cannot read. `tests/workflow_shell_syntax.rs` now extracts every `run:` block and syntax-checks it, so the failure shows up before the push rather than six runs later. Gitea's `${{ … }}` is replaced with a placeholder first — the point is to check OUR quoting, not to evaluate their templating. Negative control: restoring the apostrophe fails the test with the file and line. The block also carries a standing NO APOSTROPHES warning, because the next person to write a comment there will not be thinking about quoting. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 07:44:18 -07:00
Omar SobhandClaude Opus 5	d23f30e929	docs: record the CI investigation honestly, including what is still unknown ... Establishes what is verified (the code passes on the runner host, with cargo's real exit code), what is narrowed (493/494 die inside the Rust step before cargo starts; 495 died before step 1), the three theories that were wrong, and the cheapest next experiment. Also records the two things that made this expensive: the actions-log API returns 403 for our token, and my first reproduction piped cargo into `tail` and reported tail's exit code. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 07:33:10 -07:00
Omar SobhandClaude Opus 5	c02dbe2266	ci: capture the Rust step's own output, not just cargo's ... The breadcrumb narrowed run 494 to the Rust step, and rust.log did not exist — so cargo never started. Whatever failed (apt-get, git config, or docker itself) wrote to the job log, which the actions-log API will not give us. The docker run's stdout and stderr now land on the host too, and the step exits with docker's status. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 07:20:38 -07:00
Omar SobhandClaude Opus 5	24393819bd	ci: breadcrumb which step dies ... The host-log change proved the job never reaches `cargo test` — rust.log is absent while /tmp/ci-logs exists. But TWO steps create that directory, so "the directory exists" does not say how far the job got, and that ambiguity cost a debugging cycle on its own. Each step now overwrites /tmp/ci-logs/STEP on entry, so the last value names the step that died. The postgres step also runs under `set -x`. Verified manually on gw-04 in the meantime: the postgres step's exact commands succeed there (STEP_RC=0), as does the whole Rust container command with cargo's real exit code, as do the three frontend commands. So the failure is something the job does that running its steps by hand does not reproduce — which is precisely what a breadcrumb answers and guessing does not. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 07:19:29 -07:00
Omar SobhandClaude Opus 5	a864f2ccc7	ci: make a failed run readable, and stop laundering cargo's exit code ... Three runs failed and I debugged all three blind: Gitea's actions-log API returns 403 for the token we have, so the only evidence was the word "failure". I twice inferred a cause from that and was twice wrong — first node, then dash — and a third theory (two runs stomping each other) was right about a real defect but not about these failures. Worse, my own reproduction lied. It ran `cargo test ... | tail -80`, so the reported exit code was TAIL's. A green pipeline over a red suite is exactly the trap this repo already documents, and I walked into it while hunting a red build. - every step writes its full output to /tmp/ci-logs on the RUNNER HOST, which outlives the container, so a failure can be read afterwards - the Rust step captures cargo's status in a variable and exits with it, with the grep and tail in between — no pipe anywhere near the status - the frontend step runs npm ci / typecheck / vitest separately, keeps each status, prints all three tails, and fails if any is non-zero. Previously a `set -e` abort meant later steps produced no output at all What is now known, verified on the runner host itself with cargo's real exit code: `cargo test --workspace` PASSES on gw-04 in the CI container against a CI-shaped Postgres (CARGO_RC=0), and `npm ci`, `typecheck` and `vitest` all pass there too. So the failing step is not one of those, and the next run will say which it is instead of leaving it to be guessed. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 07:17:39 -07:00
Omar SobhandClaude Opus 5	72ba4ba523	fix(ci): two runs stomped each other, and the logs blamed the tests ... Runs 490 and 491 both failed `test`. Neither failure was in the code. Runs 490 and 491 started 16 minutes apart and a full suite takes longer than that, so they overlapped. The first thing a run does is `docker rm -fv cm-ci-pg` — a name every run shared — so the newer run deleted the older run's database mid-suite. Both failed, and the failures read as test failures. Verified before changing anything: the exact CI command, on gw-04, against the same warm cargo volumes and a Postgres started exactly as CI starts it, passes on 128b423 — as do `npm ci`, `typecheck` and `vitest` on that host. The code was never the problem. - `concurrency: deploy-${{ gitea.ref }}` with cancel-in-progress, so runs on a ref serialize. A superseded run tests a commit that is no longer the tip; finishing it costs 20 minutes to learn something that no longer matters. - the test Postgres is named per run, so overlap cannot corrupt a run even if the concurrency guard is later removed. Impossible rather than unlikely. - `--shm-size=1g` on it. Docker defaults /dev/shm to 64MB and cm-testkit creates a database per test; Postgres exhausts its parallel-query segments mid-run and reports `could not resize shared memory segment` DURING MIGRATIONS, which reads like a schema fault. Hit locally on 2026-08-19; scripts/test-server.sh already carries the same flag. The lesson is the session's own: I twice inferred a cause from a red build without reading the failure — first node, then dash — and both were wrong. The answer came from running the job on the runner's own host. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 07:00:10 -07:00
Omar SobhandClaude Opus 5	128b423205	fix(ci): the tool gate needs node, and an inert gate must say so ... The first push of the PreToolUse gate failed CI, and the reason is a property of the gate worth fixing rather than a CI quirk. The hook parses its JSON payload with `node` — no jq in the runtime image, and node is guaranteed there because Claude Code is a node program. CI runs `cargo test --workspace` inside `rust:1.96-slim`, which has no node. The extraction returned nothing, the gate allowed everything, and the two "blocks" tests failed. That is correct behaviour with a dangerous appearance. A gate that cannot read its input must not block the phase — failing closed on a parse error denies every tool call, which is what an earlier `case`-syntax bug did. But allowing silently makes an INERT gate indistinguishable from one that simply matched nothing, which is this codebase's recurring defect exactly. So the gate now records `inert` when node is absent, still allowing, and a test pins both halves: exit 0, and the marker written. The host can check for that file rather than infer a working gate from an absence of denials. CI installs nodejs so the shell tests exercise the gate instead of its inert path. Verified in a rust:1.96-slim container: without node the force-push payload returns 0, with node it returns 2. Also confirmed the generated script behaves under dash — Linux /bin/sh — not only under macOS sh. An earlier apparent dash failure was invalid JSON in the probe command, not the gate. Full workspace suite green: 106 binaries. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 06:04:56 -07:00
Omar SobhandClaude Opus 5	b653dbfe72	docs: hand-off note for the next session ... Records the state of the tree, the one step not taken (the stream-json runtime image is built and never deployed, so no mission has confirmed tool.call rows end to end), the ordered next steps, the decisions that are the operator's, and what was deliberately left undone with reasons. Also records the two corrections made this session — "missions can't call tools" was wrong, and raw test counts are a bad coverage metric — because both were confidently stated here before being checked. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-20 05:24:43 -07:00
Omar SobhandClaude Opus 5	547b5d9987	feat(missions): a pre-execution gate on mission tool calls ... The second half of the tool-call research. Until now a mission agent's Bash call was gated by nothing, anywhere. WHY THERE WAS NO GATE vm_tool_tap is a PostToolUse hook: it fires after the tool has already run and exit-0s unconditionally, because a non-zero PostToolUse talks back to the model. It is telemetry and says so. GatePolicy — the §15 door — has one enforcement site, the chat loop, and its approvals key on (session_id, message_id), which no mission phase can produce. Meanwhile the solo tiers run `claude -p --permission-mode acceptEdits` with Read, Edit, Write and Bash pre-approved. PreToolUse fires under `claude -p` in this image — measured by vm_stop_gate, which also proved the exit-2-plus-stderr contract — and had zero callers. This is that hook. WHAT IT IS, AND IS NOT A deterministic policy gate: a short deny list of actions with no legitimate form inside a mission, blocked before they run, with the reason handed back so the model can choose differently. It is NOT the §15 human approval gate, and the module says so. A hook blocks the agent's process while it runs and a human decision takes minutes to hours; waiting inside the hook would wedge the turn. This closes the gap between nothing and something. The deny list is short on purpose. A gate that blocks legitimate work is worse than none: the agent cannot ask a human, so it either works around the block — doing something stranger than what was denied — or burns the turn. FOUR BUGS THE TESTS FOUND, IN ORDER 1. Substring matching denied `grep -rn 'rm -rf /' docs/`. Searching for a string is not running it. Now rules anchor to the start of a shell segment, with a separate flag-style match that exempts text tools. 2. The `case` patterns were unquoted, so a needle containing a space made the whole script a SYNTAX ERROR — which as a PreToolUse hook exits non-zero and denies EVERY call. Every text assertion passed while the script was in that state; only running it under a real `sh` found it. 3. The hook receives JSON, not a command, so "starts with" could never match — `case` saw `{"tool_name":"bash",...` every time. Now extracts tool_name and tool_input.command with `node` (no jq in the image; node is guaranteed because Claude Code is a node program). 4. `IFS='\n'` in POSIX sh sets IFS to backslash and the letter n, not a newline. Nothing split, so only commands with no separator were ever tested and `cd /tmp && rm -rf /` sailed through. Now a literal newline. Every failure path allows. A gate that fails closed on a parse error blocks the whole phase, which is exactly what bug 2 did. Wired through vm_tool_tap::guest_settings, still the single writer of the guest settings document — a third hook makes the clobber it prevents more likely, not less, and a test asserts all three survive one document and that PreToolUse points at the gate's own script rather than the tap's. Honest limit, stated in the module: a determined agent defeats any string-matching gate. This is aimed at accidents and obvious cases; the real isolation is the container and microVM boundary. Full workspace suite green: 106 binaries, zero build errors. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 14:50:01 -07:00
Omar SobhandClaude Opus 5	ea0b989b3f	docs(research): missions DO call tools — the claim was wrong, and the truth is worse ... Deep research into "missions can't call tools at all", which I wrote and which is false. docs/TOOL-CALL-ARCHITECTURE.md has the full findings. WHAT IS ACTUALLY TRUE Three of the four mission paths end in `claude -p` with Claude Code's own toolset and permissions PRE-ACCEPTED: solo microVM Read Edit Write Bash Agent --permission-mode acceptEdits composed microVM same, per node same direct session Read Edit Write Bash acceptEdits So the position is not "no tools". It is: mission agents run Bash and Write with permissions pre-accepted, and nothing in this platform can gate them. That is a stronger finding than the one it replaces — "can't call tools" sounds like a missing feature; "calls tools freely, ungated, and mostly unobserved" is a security posture, and it is ours. Observe and gate are different and both are partial. vm_tool_tap is a PostToolUse hook: it fires AFTER the tool ran and exit-0s unconditionally, so it is telemetry and structurally cannot gate. The direct-session tier has no tap at all. GatePolicy has exactly one enforcement site — the chat loop — and its approvals key on (session_id, message_id), which no mission phase can produce. WHY THE CONTAINER TIER LOOKED TOOL-FREE `claude_cli` runs `claude -p --output-format json`, which returns a single final result object, and the provider hardcodes `tool_calls: Vec::new()`. The calls happen; the transport discards them. The comment reading that emptiness as "§15 by construction: agents are provisioned tool-free" was inferring a design property from a serialization choice. Verified against the deployed Claude Code 2.1.228 rather than assumed: `--output-format stream-json --verbose` emits `tool_use` blocks with the tool name and `tool_result` blocks. The calls are fully observable; we ask for the wrong format. THE DOOR WE ALREADY BUILT AND NEVER PLUGGED IN claude_cli.rs is OURS — upstream zeroclaw-labs/zeroclaw has no such file — and so is 88eef99d4 "claude_cli --mcp-config + allow/disallow tools (act via door)". The provider already accepts mcp_config (claude's own MCP client reaches our door), tools, and disallowed_tools (lock out the natives so the gated door is the ONLY actuator). agent.config.example.toml documents the whole shape. In the live runtime: clawmates-mcp.json does not exist, there is no [providers.*] block, and every mission claw binds to claude_cli.default which sets none of it. My earlier "claude_cli cannot reach MCP, therefore the skills server is unreachable" was wrong in its reasoning — the capability is built, documented by us, and never deployed. Related: we set `agents.<alias>.mcp_bundles`, which configures ZeroClaw's OWN MCP client for its native loop. A claude_cli agent's actuator is the claude subprocess, which reads `mcp_config` on the PROVIDER. We were turning a knob wired to a loop that does not run. UPSTREAM 218 commits behind. No upstream work on claude_cli (the file is ours). ACP already exists in the fork; the three new commits are workspace-default and localization fixes, not new capability. The one item worth pulling is "feat(plugins): add shared egress policy foundation (#9137)" — a network guard with DNS pinning and metadata-address blocking, defence for the egress problem we have not solved. Stale claims corrected in place, in topology_exec.rs and the runtime config, so the codebase stops asserting the thing that is false. Recommended order, cheapest first: stream-json for observability; the PreToolUse hook for a real gate (it FIRES under claude -p per vm_stop_gate, and has zero call sites); then deploy the door. The executor swap is NOT recommended — the blockers are structural, not wiring, and the cheap fixes deliver what it was wanted for. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 13:06:59 -07:00
Omar SobhandClaude Opus 5	771092b165	fix(skills): a pinned skill contradicted the platform inside the same prompt ... Extending the Skill-Use mechanical checks, per the baseline's own next step, found something bigger than a missing check. THE DEFECT `workspace-repo-commit-protocol` told agents that `/workspace/repo` was "the ONLY path where source-modifying edits belong". The platform mounts and advertises `/mission/repo` — 26 references in the code; `/workspace/repo` appears in none of them. The skill is bound on 29 role bindings and was delivered TWICE in the run already measured, so an agent received the real path in its tool preamble and a skill contradicting it a few hundred tokens later, in one prompt. An agent that obeyed the skill wrote source into a directory nothing collects — the phase then delivers nothing, and looks like an agent that did no work. The same skill instructed `file_read` / `file_write` / `shell`: ZeroClaw's names, the exact ones `phase_task_text` was fixed to stop advertising after five agents on a single mission spent 7.4k tokens describing the mismatch instead of working. The prompt was corrected and the skill kept saying it. Rewritten against what the code actually does, including the repo-less case (`/mission/repo` exists, is collected as artifacts, has nothing to push). THE CLASS, AND THE GUARD The skills were never checked against the platform they describe. Nothing compared them, so a skill could contradict the prompt it ships inside and stay that way indefinitely — the same shape as PLAN_COMPLETE being documented and never implemented. Two tests in `skills_loader::contradiction_tests` now hold it: no skill may name a repo path the platform does not mount, and none may instruct a tool the agent's subprocess does not expose. The second matches backticked instructions and skips corrective lines, so a skill may still WARN against the wrong names — as this one now does. Both negative-controlled by restoring the old wording. AND THE CHECK THAT STARTED IT `workspace-repo-commit-protocol` now has a Boundary check: writing outside `/mission/repo` fails, and the message names the consequence — a phase that delivers nothing — rather than just the wrong path. docs/SKILL-USE-BASELINE.md records this as the fourth defect the measurement found, and corrects the "next unit of work" note now that this one is done. Full workspace suite green: 106 binaries, zero build errors. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 12:51:43 -07:00
Omar SobhandClaude Opus 5	113de610ec	fix(security): a signed Slack request could be replayed forever ... Phase 5. The headline is not the coverage work — it is what looking for coverage found. A CAPTURED SLACK REQUEST AUTHENTICATED INDEFINITELY `slack_signature_valid` verified the HMAC correctly, and nothing anywhere checked how old the timestamp was. The timestamp is an input to the basestring, so an old request's signature verifies exactly as well as a fresh one — meaning anyone holding a single captured signed request (a proxy log, a mirrored packet, a leaked webhook body) could replay it forever, and every replay would authenticate. Slack's documented 5-minute window is now enforced IN THE BROKER, not the caller: the broker does not trust its caller (§15), and a check the caller can forget to make is one that will eventually be forgotten. Symmetric, so a far-future timestamp cannot mint a request valid for as long as the attacker chooses. Seven unit tests over the pure function with the clock injected, and the HTTP-level test now asserts an hour-old but validly signed request is refused. Negative control: removing the window fails the stale and future cases specifically. The existing slack_inbound test used the literal timestamp "12345" — a 1970 date — which passed only because nothing checked freshness. That is the shape of the whole finding: the fixture could not have failed, so it never told us anything. COVERAGE, RE-EXAMINED The review ranked crates by raw test count. That metric was misleading and found the wrong crates: cm-safety's seven tests already cover the decide CAS, grant double-consume, expiry and the approved/rejected split, and the audit_log immutability trigger is tested over in cm-db. Reading the API surface against the tests found the real gaps — verify_slack_signature above, and `credits_for_tokens`, pure pricing arithmetic that every existing billing test went through the database to reach without ever checking directly. Now pinned: the round-up contract, the deliberate one-credit floor, and that an absurd token count cannot wrap into a negative charge (a refund granted by an overflow). Still genuinely thin: cm-brain, where 6 of 9 tests need live clawbrainhub.com. Stubbing it means reproducing an external registry protocol we have no spec for — its own piece of work, not a coverage chore. Recorded rather than faked. GATEWAY PREFLIGHT ZEROCLAW_GATEWAY_URL and ZEROCLAW_TOKEN have no defaults and are read at FIRST USE, so a deployment missing them boots clean, serves every page, and fails the first time someone presses run. Third sibling of runtime_preflight and validator_preflight, same stance: a report, not a gate. The message names the consequence — "container-tier missions cannot run" — rather than only the unset variable. One process note: `cargo test -p cm-secrets` passed while the LIBRARY build was broken, because `time` is a dev-dependency there and my reference to it only resolved under cfg(test). Switched to std. Checking `cargo build --workspace` as well as the test profile is the guard. Full workspace suite green: 106 binaries, zero build errors. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 12:24:09 -07:00
Omar SobhandClaude Opus 5	5c2c63f8e8	feat(missions): a human can finally reach the plan/roster review gate ... Phase 4 of the plan, plus the PLAN_COMPLETE decision and the gitea_forge cleanup from Phase 5. THE REVIEW UI mission_plan and mission_roster have been complete and reachable by curl since they shipped, with zero frontend. That matters more than a missing screen usually would: the decide step is not a convenience, it IS the safety mechanism. Approving a plan replaces the mission's phases; approving a roster flips it to the composed engine. A gate nobody can reach is a gate that is always open or always shut. MissionProposalDrawer, modelled on LevelUpDrawer which already does load → review → decide. Reached from a mission's SETUP tab. Verified end to end against the live backend, not just compiled: a model proposed a roster, approval flipped the mission to `composed`, and approval on a non-draft mission was refused. The plan view shows each phase's done_when, and says plainly when one is absent — a phase without a completion condition is never judged and reports completed whatever it did, so its absence is the thing worth seeing. AND THE DEFECT BUILDING IT FOUND Every refusal path computed a precise reason — "the mission is running, not a draft", "no node can boot that backend any more" — logged it to stderr, and returned a bare {"error":"bad request"}. The person who needed the sentence was the one clicking Approve; they got two words, and the reason went to a server log they cannot read. ApiError::Refused(String) carries it now. Same argument ApiError::Unavailable was added for ("a 500 with 'internal error' sent them looking for a bug that was not there"), one status code down. Live: the 400 now reads "this mission is completed — a roster can only be approved while it is a draft, because approving one rewrites how the mission will run". PLAN_COMPLETE, decided The Skill-Use measurement found that int-xx-marker-protocol documents PLAN_COMPLETE and task_card_parser never implemented it, so an agent following the skill exactly was silently ignored. Implemented rather than removed from the skill: the planner needs a way to say it is done specifying, and agents already emit it. Marker ids are now strictly INT-<digits>. `starts_with("INT-")` accepted the range form `INT-01..02` — observed live — which parsed into an id matching no real item, so a task card appeared for something that did not exist while the two items it covered stayed open. Rejecting is right: an ignored marker is visible, a plausible row is not. GITEA_FORGE, REMOVED Named in nine places, defined in none. Harmless while provision_claw ignored the bundle list; once the list was honoured, an undefined name became a capability an agent is told it has and does not. Removed from seven team templates, a workflow recipe, the auto-provision path, and a dropdown a user could pick it from. A new test asserts every bundle a template names is defined in the runtime config — and it immediately found `web_fetch` in two templates I had missed removing by hand. Same shape as the skill-binding test, one layer up. Agents reach the forge through git over HTTPS with the ambient GITEA_TOKEN, which is why nothing ever broke. Full workspace suite green (106 binaries); frontend builds clean. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 11:56:54 -07:00
Omar SobhandClaude Opus 5	91a6b4e304	feat(skills): the first Skill-Use measurement, and the three defects it found ... Scored on the paper's three axes against two real missions on the local stack. docs/SKILL-USE-BASELINE.md has the numbers, the method, and the limits. Trigger is reported as NOT OBSERVABLE, never zero The paper measures progressive disclosure: the agent sees a name and description and must retrieve the body, and that retrieval is the Trigger event. We inline full bodies, because mission claws run on claude_cli which cannot surface a tool call — there is nothing to retrieve with. So the agent never reaches for a skill, it simply holds one. Scoring that zero would report a delivery-model property as an agent failure, which is the same confusion that kept 55 empty bindings invisible for months. The verdict type carries NotObservable(reason) as a distinct case from Fail for exactly this. Compliance is checked by running the REAL task_card_parser rather than a copy of its rules — a second implementation would drift, and then the score would pass while the mission loop still stalled. Skills without a machine-checkable consequence score not_applicable rather than a guess. WHAT THE MEASUREMENT FOUND 1. The prompt format made its own record unparseable. Skills were introduced with `## <name>` and skill bodies are markdown full of `##` headings, so run 1 scored "Sizing heuristic" and "The output shape" — subheadings inside decompose-int-items — as skills with no catalogue row. Now an unambiguous `--- SKILL: <name> ---` marker, with both writers sharing one renderer so the reader cannot drift from the writer. 2. A prompt was recorded that was never sent. My own Phase 1 work recorded the phase prompt at the dispatch fork, before the tier was chosen — and the container tier does not send that text, it sends the bare task and appends skills per turn. Every container mission logged a `solo` prompt that reached no agent. A provenance record of something that did not happen is worse than no record: it is the wrong answer, delivered confidently. Recording now happens inside each tier, with a test that every launcher records the prompt it actually sends. 3. int-xx-marker-protocol documents a marker the platform never implemented. PLAN_COMPLETE is in the skill's ladder and task_card_parser has no such kind and never has, so an agent following the skill exactly emits a marker that is silently ignored. Observed live: run 2's planner emitted `PLAN_COMPLETE: INT-01..02`, which is also the range form — on the kinds that ARE parsed that yields the id `INT-01..02`, a task card for an item that does not exist while the two real items stay open. This is a skill/implementation mismatch, not an agent failure, and it is exactly what the measurement exists to find: the agent did what it was told and what it was told was wrong. Both shapes now score as failures. The reconciliation — implement PLAN_COMPLETE or drop it from the skill — is left as a decision rather than guessed at. The boot log now shows what the plan asked for: 53 skills, 11 templates, every one `N role skills bound` with NO unresolved clause. Live missions confirm per-role delivery — the planner receives decompose-int-items, the coder receives write-rust-current-edition. GET /api/missions/{id}/skill-use exposes the scores, and says in its payload whether an empty result means "nothing delivered" or "the evidence was reaped" — those have very different causes and must not look the same. n = 2. No spread is reported because two runs cannot establish one, and the document says so rather than letting the number be quoted as a baseline it is not. Full workspace suite green: 106 binaries. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 10:54:58 -07:00
Omar SobhandClaude Opus 5	769e002bb3	feat(skills): deliver on every tier, record what agents receive, let them self-author ... Three phases of the approved plan, plus a correction to what the last one claimed. CORRECTION: skills reached ONE tier, not all of them The previous commit said "skills can now reach a mission agent". That was true only for the container/ZeroClaw tier — the fall-through that queues a topology_runs row for topology_worker, which drives the executor that was patched. compose_turn_prompt/pinned_skills_text had exactly one production caller, and phase_runner's three other paths (composed microVM, solo microVM, direct session) never called it. CAPABILITY-REVIEW.md said the broad thing too; both are corrected. Those three tiers share one task string and have no per-turn alias, so their skills resolve per PHASE from the mission's crew and are appended there. The container tier deliberately still injects per turn, with the running node's own role — appending in both places would put every crew member's skills in every turn twice. The behavioural tests prove phase_skills_text and compose_turn_prompt work. They cannot prove the three launch_* calls pass the composed string, and that substitution is a one-word edit that would silently return all three tiers to delivering nothing with every test still green. So there is also a source-level assertion on the call sites, following the precedent in mission_events::the_cap_is_enforced_in_one_statement. Its negative control names the exact tier. PROVENANCE: what an agent received, and what it said it did Both were unanswerable. The prompt was never stored anywhere on any tier — re-deriving it later re-runs the skill lookup against a catalogue that has since changed, and once agents author their own skills it certainly will have. The reasoning rows were durably write-only: pushed live once, then never read from the database again by anything except the GC that deletes them. - prompt.composed records the exact bytes, on all four tiers - the session tier writes its checkpoint record and a reasoning row, instead of eprintln! and nothing — the same defect the solo microVM path was fixed for, in the last tier that still had it - narrative_for_mission reads both back Found while doing it: the 400-event per-phase cap counted EVERY kind, so a busy phase could push out its own phase.completed and its own provenance. The cap now counts only the two unbounded kinds it was written for. Negative control confirms the old behaviour dropped the prompt. Retention is now a per-mission hold (0080) rather than a raised global — with a test asserting unheld missions are still reaped, because an exemption that applies to everything is not an exemption. SELF-AUTHORING: agents apply their own skill drafts, no human click By operator decision. level_up has generated complete drafts from a model since it shipped; only a checkbox stood between propose and apply. What replaces the gate is not another gate but four properties, each held by a test: - workspace-scoped, so a hand-authored skill can never be modified - a draft cannot take a hand-authored skill's name. Ids are scoped and bindings resolve by skill_id, so it could not overwrite or shadow one anyway — but two procedures under one name means nobody reading a transcript can tell which the agent followed, and that ambiguity is fatal in a system where the skill is the standard being graded against - every revision appends a skill_versions row, so it can be reverted and a past run can be read against the text it was actually judged under - approved_by = NULL. An agent's decision is never attributed to a person who did not make it Only skill_candidate applies autonomously. identity_refinement and brain_consolidation still wait for a human: they change what an agent IS rather than adding a procedure it can consult. State is announced at boot, because a safety gate that changes silently is one nobody notices changed. CLAWMATES_SKILL_SELF_AUTHORING=0 restores it. Also: the test Postgres ran out of /dev/shm mid-suite (Docker's 64MB default) and surfaced it during MIGRATIONS, which reads like a schema fault and is not one. --shm-size=1g, and a pointer to the `clean` subcommand that already existed for the 779 leaked test databases. Full workspace suite green: 106 binaries, no failures. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 10:24:35 -07:00
Omar SobhandClaude Opus 5	e3247fee4b	chore(runtime): define the skills MCP bundle the templates now ask for ... provision_claw honours the template's bundle list as of the previous commit, but a bundle an agent is assigned and the runtime config does not define resolves to nothing — so the assignment had to be made to mean something on the MCP side too. Carries the caveat that matters at the point of use: this channel only works for a provider that can surface tool calls, and mission claws run on claude_cli, which is text-only. Their skills arrive as prompt text instead. The entry is for tool-capable agents, and so that an assigned name resolves. gitea_forge is left UNDEFINED on purpose, with a note. Six templates name it and nothing defines it; a plausible-looking definition pointing at the wrong URL would turn a name that resolves to nothing into a server that fails at call time, which is harder to notice rather than easier. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 08:24:45 -07:00
Omar SobhandClaude Opus 5	e4942ce985	fix(missions): skills can now reach a mission agent at all ... Repairing the 55 broken skill bindings made the catalogue correct. This makes it reachable, which it was not — for any skill, on any mission, since the catalogue was built. The skills had exactly ONE delivery channel: the `clawmates_skills` MCP server. A mission claw could not reach it for three independent reasons: 1. `provision_claw` wrote the constant `["clawmates_door"]` and ignored the template's mcp_bundles — which mission_orchestrator had already resolved and stored on the team row. 2. The runtime config defines no `clawmates_skills` bundle. The live local config defines no bundles at all, not even the door. 3. Mission claws run on `claude_cli`, which the runtime's own config comments document as text-only: it cannot surface a tool call, so no MCP server is reachable from a mission turn regardless of bundles. And a mission turn's whole system context is two sentences synthesised from the role slot in topology_exec::build_prompt. The template's role prose is not used either — mission_orchestrator documents this, and it means the role prompts describing which procedures to follow were never read. Two doc comments in cm-runtime describe the mission path as already having the summary-and-fetch contract. It never did. The belief was written down twice and checked zero times, which is why nobody looked — and it is why the Skill-Use measurement this review planned could only ever have returned a trigger rate of zero. That would have read as a finding about the agents. - provision_claw takes the bundles, with clawmates_door always added: a template that forgets to list it must not get an ungated agent - all 11 templates now request clawmates_skills; web_fetch removed, since a list that is honoured must not name a bundle that does not exist - the re-provision sweep re-asserts the team's own stored bundles rather than a constant, which would have silently stripped a capability mid-mission - pinned skill BODIES are injected into the mission prompt, bounded and with truncation stated. Bodies, not an index: there is no `skills.read` tool on this path, so an index would advertise a capability that does not exist — the exact failure this whole change is about Three tests: the body reaches the prompt, an agent with no skills adds no heading (an empty "Your skills" section announces skills the agent does not have), and the composition is exercised separately from the lookup, because `pinned_skills_text` working and `run_turn` calling it are different claims and the second is the one that was false. Also adds the three review documents: CAPABILITY-REVIEW (inventory, what was repaired, what is deferred and why), PROVENANCE-ASSESSMENT (assess only, per decision — what each store answers and the two candidate paths), and RESEARCH-SWEEP (the fortnight's papers and what we did about each, including the ones we deliberately did nothing about). Full workspace suite green. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 08:24:02 -07:00
Omar SobhandClaude Opus 5	18dc0b964b	fix(missions): the security scan phase now scans, and task upserts work ... Four defects, found by checking the audit's claims instead of trusting them. Two of the audit's own findings turned out to be wrong, and the registry that exists to record which config keys are read was itself inaccurate — so the corrections are part of the change. upsert_task raised 42P10 on every call, for every caller `mission_tasks_external_uniq` is a PARTIAL unique index (WHERE external_id IS NOT NULL). Postgres will not match a partial index to an ON CONFLICT target unless the statement repeats the predicate, so the upsert failed on its first row. Both callers — the task-card parser that turns INT markers into tasks, and the security scanner — map the error to a string their caller logs. Two features were broken and nothing was red. Regression test in cm-db with a negative control: reverting the WHERE reproduces 42P10 exactly. the security scan never ran `security_scan::run` was reachable only from an operator button, so security_hardening.toml — a workflow whose entire first phase is a scan — ran an agent that was never told to scan and never fired the scanner either. phase_runner now sweeps finished security_scan phases, mirroring the benchmark baseline sweep that was added for the identical defect. Guarded on a new completion marker rather than on findings: a clean scan writes no findings, so a findings-guard would rescan forever. The marker also answers the question an operator actually asks, which is not "how many findings" but "was this looked at, by what, and when". two recipes could not fail security_hardening.toml and benchmark.toml carried no `task` and no `done_when` on any phase. A phase without done_when never enters evaluating, is never judged, and reports completed whatever it did — so a security mission could scan nothing and go green, and a benchmark mission could record no baseline that the next refactor would then compare against. Both now state the work and the condition, with inert keys annotated inline rather than deleted, so the gap between what a recipe asks for and what a phase receives stays visible. the config registry was wrong in both directions `harness` was listed NOT IMPLEMENTED while benchmark_runner reads it and phase_runner runs a baseline through it. `tools` was listed NOT IMPLEMENTED while security_scan::run reads it. A registry that exists so an operator can trust what a recipe does is worse than useless when it is inaccurate. Both corrected, `bench_name` and `cmd` added, and `test_command` deleted — it had neither a reader nor a writer, so it described a situation that could not arise. Also: CLAWMATES_JUDGE_MODEL had two different defaults (opus-4-8 in routes/topology.rs vs opus-5 in cm_runtime::judge_model) and a doc comment naming a third; topology now calls the one function. GITEA_TOKEN's absence in mission_plan is stated rather than degrading to the same "could not be read" string a private repo produces. BRAINHUB_API_KEY needed no change — hub::push already rejects an unset key with a named error. That half of the finding was overstated. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 08:08:27 -07:00
Omar SobhandClaude Opus 5	4358964c05	fix(skills): every team-template skill binding now resolves ... 55 of 85 role skill bindings pointed at skills that were never authored, so 10 of 11 team templates bound a smaller context bundle than their role prompts assumed. Three roles bound nothing at all (gpu.bench_engineer, threejs.shader_author, threejs.perf_engineer) while their prompts described procedures they had no way to read. The loader comment at team_template_loader.rs:167 already diagnosed this — snake_case slugs in TOML against kebab-case skill files — and it was half-fixed: the kebab names were corrected, the snake_case ones left. It was invisible because both existing tests assert authored ⊆ referenced (30/30, green) and the second explicitly declines to check the other direction. So the failing half was the half nobody asserted. Resolved every name by one of three explicit choices: - 23 skills authored where the role genuinely needed the procedure (gpu, threejs, research, analysis, frontend, mobile, backend, platform) - renames onto authored skills where one existed in substance, including the four-near-duplicate cases that collapse onto one real skill - 22 aspirational references deleted — a binding an agent cannot read is a promise, not a capability Two tests now hold it. The unit test checks referenced ⊆ authored against the files. The new integration test runs both loaders in boot order and asserts the bindings survive the trip through the database, which is a different question: resolution goes through skills_catalog rows, so a skill file that exists but fails to ingest still leaves the role empty. Negative controls: the unit test failed naming all 55; the integration test fails naming the exact role when one name is reverted. threejs.shader_author and .perf_engineer gained a second and third skill after the collapse — pin_in_context pins idx < 2, so a role left with one skill silently pins less than the policy intends. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-19 07:42:48 -07:00
Omar SobhandClaude Opus 5	ba98c29481	fix(podcast): the left rail showed the workforce, not the episodes ... The PODCAST tier had no branch in the left column, so it fell through to the default — the org/company/team roster. Opening the podcast page showed a list of agents, which is the one thing on that screen that has nothing to do with it. `PodcastList` now fills the rail with one card per episode (date, title, duration, size), the same shape `MissionsList` and `RepoList` give their tiers: objects in the rail, the selected one in the canvas. It selects the newest on first load so the canvas is never blank, and refreshes on the render sweep's own two-minute cadence so a new episode appears without a reload. `PodcastPanel` loses the duplicated list and becomes what a canvas should be: how to subscribe, and the selected episode with a player. The empty state points at the Continuous Research mission that produces one rather than just saying there is nothing. Verified on the served page: PODCAST renders between AGENT and REPOS. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-18 12:15:17 -07:00
Omar SobhandClaude Opus 5	fe45f72f09	feat(podcast): a PODCAST tier, a topics field, and a feed a phone can actually reach ... Three gaps between "the pipeline works" and "you can use it". **1. Topics could not be set.** The wizard never sent `config.topics`, so every mission created through the UI silently fell back to `library::default_topics()` — a hardcoded list that is somebody else's research interests. The card now takes one arXiv search per line, and the description field says plainly that for this template it IS the brief the agents judge relevance against. **2. There was nowhere to see or subscribe.** New PODCAST tier in the left rail, between AGENT and REPOS: the feed URL with a copy button, the episode list, and an inline player for checking one at a desk. `GET /api/podcast/episodes` and `/subscription` back it. The panel also reports how many missions produced no audio, so a missing day reads as a known gap rather than silence. **3. The feed 404'd for the only client that will ever request it.** Three layers each assumed a browser: - `resolveBearer` is server-only (`next/headers`), so a client component that imported it broke the build outright. The panel now goes through the same-origin proxy like every other panel, and the backend mints the feed URL because the session lives in an httpOnly cookie JavaScript cannot read. - The `/api` proxy demanded a session COOKIE. A podcast app has none and carries `?token=` instead — the same shape as the existing `hooks/` prefix, which is already exempt for exactly this reason. - The local autologin middleware 307'd it to `/auth/autologin`. A podcast app follows redirects blindly and would have stored an HTML page as the episode. Neither exemption weakens auth: the backend still validates the token and answers 401 to a bad one, verified. `episode_audio` accepts the token from either the query string or an Authorization header, because the app fetches it one way and the browser player the other, and refusing either breaks one of the two ways this is listened to. `CLAWMATES_PUBLIC_URL` matters and was wrong first: the tailnet root proxies to a different service on :18789, and this frontend is on :8443. A feed advertising an unreachable origin syncs silently forever, so `/subscription` returns a `reachable` flag and the panel warns when it is still localhost. Verified from a phone's point of view: feed 200 application/rss+xml over the tailnet, enclosure 200 with 6,739,582 bytes of audio at 421s, bad token 401. 367 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-18 11:55:19 -07:00
Omar SobhandClaude Opus 5	f4adc8d0f9	fix(podcast): stop reading identifiers aloud, and pitch the episode at a teenager ... Two things the operator found by listening to a real episode. **1. Identifiers were spoken as digit soup.** The script genuinely said "arxiv 2608.12888", which the voice reads as "two six zero eight point one two eight eight eight". Same for three-decimal values: "0.506" and "0.004" became long strings of spoken digits. A listener on a treadmill cannot write an identifier down and does not need a third decimal place. `speakable()` strips arXiv references and bare identifier-shaped numbers, and rounds decimals to two places — with a carve-out that matters: 0.004 rounds to 0.00, which would claim the value was ZERO when the whole point was that it collapsed to nearly nothing, so it says "under 0.01" instead. Deliberately narrow: it removes identifiers and shortens over-precise decimals, and does not paraphrase, reorder or summarise. The agents' words are still the episode. It also preserves the sentence's full stop — swallowing it turned "…financial retrieval, arxiv 2608.00183. This one's a catch." into one run-on sentence, and the pause is how a listener knows a thought ended. Note that `podcast-dialogue-writing.md` ALREADY said "no arXiv ids" and the writer included them anyway. That is this project's recurring lesson restated: an instruction is a request, and a listener deserves a guarantee. The prose asks and the code enforces. **2. It was written for someone who already knew the field.** The skill and the script phase's task now target a bright sixteen-year-old: define an acronym in the sentence that first uses it, describe the mechanism rather than naming it ("a road map with motorways and side streets" instead of "a hierarchical navigable small world graph"), one idea per sentence. The test offered is whether the listener could explain the finding to a friend afterwards. That is not dumbing down — it is the constraint that forces a writer to say what a thing actually does rather than what it is called. Tested against the exact lines from the episode that was listened to. 366 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-18 10:42:48 -07:00
Omar SobhandClaude Opus 5	1f39f642a3	feat(podcast): render finished missions into episodes, and serve them as a feed ... The renderer existed but nothing called it. This wires it to the missions and puts the result somewhere a phone can reach. **A sweep, not a phase step.** Rendering is not the agents' work and must not be able to fail a phase that succeeded; a transient API error simply retries next tick, and a mission already rendered is skipped because its episode row exists. `podcast_episodes` is that record — without it the sweep would re-render on every pass and re-bill for it, the same lesson `corpus_items` taught for papers. **It is racing a reaper.** script.md lives in the mission checkout, and `mission_runtime`'s sweeper deletes that tree 30 minutes after the mission reaches a terminal state. So the sweep runs every 2 minutes, leaving ~15 attempts inside the window. When it does lose — as it did for three missions that had completed hours before this shipped — it now SAYS so and records a marker rather than skipping in silence, which is how a feed ends up quietly missing a day. The feed filters those markers out: a zero-byte enclosure shows a broken episode in a podcast app, where showing nothing is honest. **Duration is read from the audio, not estimated from the script.** The feed advertises a length and that length should be the real one — and it is the check that catches a 6 MB file playing for six seconds. **The feed authenticates by query-string token**, because no podcast app can set headers. That is a real trade: the token lands in the app's database and any proxy log. It reuses `AuthService::authenticate`, so revoking the session revokes the feed with it rather than creating a second secret to forget to rotate. Titles are XML-escaped — one raw ampersand makes a client reject the WHOLE feed, not one episode. 363 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-18 10:25:24 -07:00
Omar SobhandClaude Opus 5	55b16f25c8	fix(podcast): the episode played for six seconds ... Concatenating whole MP3 files does not make a longer MP3. Each TTS clip is a standalone file: a small ID3v2 tag, then a first frame carrying an `Info`/`Xing` VBR header that declares THAT CLIP's frame count. Joined raw, a player reads clip one's header, believes the file is that long, and stops. The 6.1 MB "episode" played for 6.9 seconds. Caught by the operator listening to it. I had verified the byte count, the ID3 magic and a >100 KB size floor — every proxy for "this is audio" — and never that it plays. The assertion I needed was duration, and none of the ones I wrote could fail on this bug. Measured on two real clips of 4.86s and 4.68s: raw concat -> 4.86s only clip one plays strip second clip's ID3 -> 4.86s strip both clips' ID3 -> 4.86s the tag was never the problem strip ID3 *and* the Info frame -> 9.53s correct The ID3 tag is ~45 bytes and harmless. The header FRAME is what lies, and my first attempt at a fix — scanning the joined file for `ID3` — was worse than useless: it matched those bytes inside audio data and silently deleted half the stream. `strip_container` removes both from every clip, leaving pure frames a player times from the stream itself. Real ElevenLabs output is committed as a fixture so the test pins the actual wire format, not an approximation of it, and a junk-input case proves a malformed clip fails the render rather than panicking. Re-rendered the same script: 380.8s, up from 6.9s. 361 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-18 08:27:38 -07:00
Omar SobhandClaude Opus 5	656662850d	feat(podcast): render the episode from the agents' own script ... GenFM is unreachable. `GET /v1/studio/projects` and `POST /v1/studio/podcasts` both return 403 — "Access to the Studio API requires your account to be explicitly whitelisted to use it. Please contact our sales team." Measured with two different keys on the account, so it is an account restriction, not a key scope. Plain text-to-speech on the same key returns a valid MP3. That suits the operator's choice better than GenFM would have. GenFM always runs its own LLM over the source, so the agents' script would have been REWRITTEN; rendering each line ourselves speaks it verbatim. The agents did the reading and the judging, and the episode says what they wrote. `AudioBackend` is a trait because every candidate has a different shape: NotebookLM documents no programmatic retrieval at all, GenFM needs a sales conversation, Gemini TTS is a third form. The renderer hands over a `Script` and gets bytes. `parse_script` is a parser rather than a `read_to_string` because structure must not be spoken: headings, rules and block quotes are skipped, a wrapped paragraph stays ONE turn (splitting per line would stutter at the seam), and a colon mid sentence does not start a new speaker — "The finding: recall dropped" would otherwise be truncated to everything after the colon. Voices are assigned by order of appearance, so a script using names instead of HOST/GUEST still alternates, and an unexpected third speaker falls back rather than failing. `from_env` returns None without a key, so a deployment with none produces no audio instead of failing a mission that otherwise succeeded. Proven end to end on the real script this morning's mission wrote: 25 turns, 887 words, 5,614 billable characters, 6.1 MB of MP3 in 33 seconds. The live test drives `parse_script` + `ElevenLabs::render` — the production path — and is `#[ignore]`d because it spends credits. 359 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-18 08:19:26 -07:00
Omar SobhandClaude Opus 5	850f11838b	fix(research): the manifest belongs to the mission, and a brittle phrase must not mean silence ... Two defects from the first on-topic run. **1. The manifest could never be updated twice in a day.** It was written into the VAULT at a per-DATE path, but it is per-RUN data. A second mission the same day rewrites a file that already exists, and `auto_merge` correctly refused the whole branch: diff is not additive (1 non-add change(s), first: M ContinuousResearch/2026-08-18/harvest.jsonl); left for a human So `main` kept the FIRST run's manifest, the next mission cloned it, and the agents analysed yesterday's papers while every log line reported a successful harvest. The merge policy was right; the placement was wrong. The manifest now goes into the mission's own checkout after `ensure_checkout`, which keeps the vault additive and gives each mission exactly its own papers. The agents commit it alongside their analysis through the normal delivery path. **2. A quoted phrase that matches nothing looked like a quiet day.** Phrase search is precise and brittle: "hybrid retrieval BM25 dense" is a reasonable topic and appears verbatim in no paper on arXiv — measured, 0 hits — while the same four terms unquoted return exactly the hybrid-retrieval evaluations the topic asked for. Harvesting zero because of adjacency is indistinguishable from a genuinely quiet field, which is the distinction `Harvest::healthy()` vs `added_anything()` exists to preserve. `search` now retries unquoted when the phrase finds nothing, and says so in the log. Proven in one run, all three behaviours at once: "approximate nearest neighbor search" -> 5 candidates, 5 already held, 0 shelved "hybrid retrieval BM25 dense" -> no exact phrase match, retrying broad -> 5 candidates, 0 already held, 5 shelved "LLM as a judge evaluation" -> 5 candidates, 5 already held, 0 shelved wrote 5 paper(s) to .../ContinuousResearch/2026-08-18/harvest.jsonl The seen-set suppressing 10 of 15 is the whole point of a recurring mission, and the 5 that landed are on topic for the first time: RAG architecture evaluation, agent-controlled search over chat logs, compute-aware retrieval and reranking, hybrid retrieval in hyperbolic space, sparse-dense fusion limits. 353 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-18 07:18:11 -07:00
Omar SobhandClaude Opus 5	2cd0872e50	fix(papers): the arXiv topic was never actually searched for ... The operator's topic went RAW into `search_query=`, unfielded. arXiv matched essentially nothing, and `sortBy=submittedDate` then returned the newest submissions across the entire archive — so the library shelved whatever had been posted in the last few minutes and called it research. A real run for "agentic topology", "retrieval augmented generation" and "vector index pruning" shelved, among 13 papers: Galois extensions of geometric fixed point spectra, a bulk path integral for a quantum black hole microstate, blazar boosted dark matter in IceCube, and colloidal packing. Nothing was broken — every layer reported success, the notes were written, the seen-set was updated, the branch auto-merged. The papers were simply unrelated to anything asked for. Measured against the live API: speculative decoding -> pixel-space diffusion, simplicial actions all:"speculative decoding" -> S2-MoE self-speculative decoding, DARTree So a bare topic is quoted into `all:` and bound to `cat:cs.*`. The quotes make it a phrase (unquoted, "vector index pruning" matches any paper containing all three words anywhere, which is most of cs), and the category bound is needed because the archive's physics and maths volume dominates any recency sort. A topic that already starts with a field prefix passes through untouched, so an operator who knows arXiv syntax keeps control. The passthrough originally also accepted anything containing " AND "/" OR ", and the injection test caught it on the first run: `agent" OR cat:hep-th` escaped the phrase and rewrote the category bound. Only a LEADING field prefix counts now. 348 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-17 20:17:02 -07:00
Omar SobhandClaude Opus 5	d524107b37	fix(missions): harvest before the checkout, and stop an unreachable judge failing done work ... Two bugs from the first real Continuous Research run, both found by running it. **1. The harvest ran AFTER the checkout.** `on_launch` cloned the vault and then harvested, so the mission's working copy predated the manifest push. The reader agent found no `harvest.jsonl` and — being resourceful — queried arXiv itself and wrote its own. That is exactly what `skills/research/arxiv-daily.md` forbids: the papers it found are not checked off in `corpus_items`, so the next run re-offers them, while the 13 the real harvest DID shelve went unread. The harvest now runs first, so the clone contains the manifest. The analysis it produced was otherwise very good — it named `crates/clawhdf5-ann/src/hnsw.rs`, cited the ROADMAP's serial insert loop and proposed a concrete pre-build probe — which is the behaviour the whole design is for. It was reading the wrong papers. **2. An unreachable judge consumed a pass.** `Verdict.error` exists to distinguish "could not judge" from "judged incomplete" and nothing acted on it. glm-5.3 returned "transport error: error decoding response body", the phase counted it as a failed pass, and with two budgeted that single outage failed a phase whose work was done and committed. The evaluator was right to refuse a same-family fallback — that would trade independence for availability — so the fix belongs here: an unreachable judge no longer spends an iteration. Retrying forever would trade a wrong failure for an invisible hang, so the wait is bounded by `judge_blocked_since` (migration 0078), mirroring how `capacity_blocked_since` bounds a phase waiting on a VM slot. Thirty minutes is many sweep ticks, so a blip recovers inside it; past that the phase FAILS with the transport reason rather than requeueing, because re-running spends a container re-doing work that was never the problem. 346 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-17 18:14:29 -07:00
Omar SobhandClaude Opus 5	a02e0cba69	feat(missions): Continuous Research harvests at launch, and cards launch by clicking ... The card shipped in e20b321 could not actually be used. Three things were missing, each of which failed at a different distance from its cause. **1. `default_team_template` was parsed and never read.** Every recipe declares one; `WorkflowRecipe` carries the field; nothing consumed it. A mission created from a card with no explicitly chosen team was rejected at LAUNCH with "no team_id, no team_template_id, no config.phase_teams" — one step removed from the real cause, which is that creation ignored the recipe. Create now resolves it via `team_templates::get_by_key`, only when the caller named no team of any kind, so an explicit choice still wins. A test asserts every shipped recipe names a template that has a `templates/teams/<key>.toml`, because a mismatch there produces an unlaunchable card. **2. The harvest ran nowhere.** `harvest_for_mission` existed and nothing called it. `on_launch` now runs it for `continuous_research` missions, before the phases start, and threads the blob store through from `main` (the route already had it on `AppState`; the scheduler needed it). Deliberately non-fatal: a harvest that fails still starts the phases, because the phase is what reports whether today was quiet or broken and those must stay distinguishable — but never silent, so both outcomes log their counts. **3. Nothing wrote the manifest.** `templates/teams/continuous_research.toml` has pointed its reader role at `ContinuousResearch/<date>/harvest.jsonl` since it was authored, and the file did not exist — agents aimed at a path nothing produced. `run_to_vault` now writes it beside the notes and stages it, but only for a mission-attributed run. `Harvest` carries the shelved `Paper`s to build it; re-parsing the notes we had just written would have been a parse of our own output and one more place for the two to drift. Also: the blob root. `storage.data_dir` defaults to "./data" and the container's cwd is `/`, so the server tried to create `/data` as uid 65532 and EVERY shelve failed with "storage io: Permission denied". The image now creates /var/lib/clawmates-blobs owned by 65532 so a mounted volume inherits it rather than arriving root:root. Kept off /var/lib/clawmates-missions on purpose: that tree is swept, and a paper shelved there would be deleted out from under its own catalogue note. Proven end to end on a real mission: 15 candidates, 2 already held, 13 shelved, 0 failed; branch auto-merged as additive-only; manifest on vault `main` with every documented key. The "already held" counts are the seen-set deduping across topics within a single run, which is the behaviour the whole design exists for. The project brief now comes from the mission description — `phase_task_text` already places it under BRIEF verbatim, so no new field was needed. 346 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-17 15:05:37 -07:00
Omar SobhandClaude Opus 5	a2d7e3ea92	feat(skills): author the Continuous Research skills, and make its roles honest ... The boot log has said `continuous_research — 4 role skills bound, 8 unresolved` on every start. Those eight roles ran without the instructions their template promised them, silently: `skills_loader` reports the miss and carries on. Worse than the missing files was what the prompts described. v1 told the harvester to sweep "RSS feeds, GitHub trending, HN front page, YouTube / podcast RSS" — none of which exist. `harvest.rs` searches arXiv and nothing else. A role prompt describing a machine that was never built is the failure this codebase keeps paying for, so v2 describes the machine that exists. Roles now match the pipeline: paper_reader (the harvest already ran; read the manifest and the papers), signal_ranker (unchanged in spirit), script_writer (the podcast half, which had no role at all). Seven skills authored under skills/research/, kebab-case to match the loader — team_template_loader.rs:177-181 documents the snake_case/kebab-case trap that already unbinds skills elsewhere: arxiv-daily what the harvest guarantees, so an agent does NOT re-search arXiv and corrupt the seen-set paper-to-project-relevance name a file or roadmap item, or say "no bearing" duplicate-detection the seen-set catches identity; this catches the same work under a different id signal-to-noise-ranking novelty/relevance/depth, and the two biases to resist (recency up, inconvenience down) executive-summary-writing what it is / why it matters / what to do — decide, do not hedge obsidian-vault-conventions the vault is a human's live workspace; never main, never reorganise, hash the body not the file podcast-dialogue-writing write for someone on a treadmill; the 10-70 char highlight bound is the API's, not a style rule `web_fetch` dropped from mcp_bundles: runtime_provision.rs binds every mission claw to `["clawmates_door"]` and never reads that field, so declaring it instructed roles to use a tool that never arrived. The prompts say `curl` via Bash, which is what they actually have. Boot now reports `continuous_research — 11 role skills bound`, with no unresolved clause. 344 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-17 14:44:03 -07:00
Omar SobhandClaude Opus 5	e20b321055	feat(missions): Continuous Research is a mission type, not just a team checkbox ... `templates/teams/continuous_research.toml` has existed with three well-written roles since it was authored, but no workflow recipe pointed at it — every recipe in templates/workflows/ defaults `default_team_template = "rust_sdlc"`. So the only way to reach it was as a checkbox under Advanced. It is now a Step-1 card: the registry loads it at boot and `GET /api/workflows` serves it, with no frontend change (MissionWizard renders whatever the endpoint returns). Both phases are kind `research`, deliberately, rather than new `read`/`script` kinds. An unrecognised kind falls through `purposes_for`'s `_ => ["mission"]` and is absent from `PRODUCING_KINDS`, so it would get the generic directive AND be exempt from the empty-delivery rule — a phase that produces nothing and still passes. That is the shape this codebase keeps paying for; two `research` phases differentiated by `task` keep both guards. `commit_policy = "always"`, not `on_green_tests`: the vault is prose with no suite, so a test gate would find nothing to run and land every branch `-wip`. The harvest is NOT an agent phase. `continuous_research.rs` calls the existing `library::run_to_vault` — arXiv search, seen-set check, PDF shelf, vault note, attributed by `mission_id` — because that path is deterministic, takes seconds, and owns the `corpus_items` seen-set that is the whole reason a recurring mission knows what it already covered. An agent redoing it would be slower and would lose that. The manifest path is not invented either: the team template has told `signal_harvester` to write `ContinuousResearch/<date>/harvest.jsonl` all along. This makes the code produce what the prompt already promised, and a test pins the path and every documented key so the two cannot drift into an agent reading a file nothing writes. DEFAULT_CORPUS / DEFAULT_VAULT_URL exported rather than duplicated, so the route and the launch hook cannot disagree about which vault. 344 tests pass. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-17 14:18:35 -07:00
Omar SobhandClaude Opus 5	f87853ecf9	fix(missions): scheduled missions never fired — nothing read missions.schedule ... The wizard has collected a cron since `0047_missions.sql` ("schedule JSONB carries the trigger config (cron | one_shot | on_event)"), the frontend posts `{kind:"cron", cron}`, and the API persists it faithfully. Nothing has ever read it back: the only due-work enumerator in the codebase was `routines::claim_due`. So every scheduled mission ever created sat in `draft` forever while the UI reported it was on a schedule. Proven before fixing, on the shipped build: a mission with `* * * * *` sat in `draft` for 4m34s and started ZERO topology runs. After this change the same mission launched on its next occurrence and recorded one `fired` row. Two pieces were missing, and they are the two `routines` already had: - `missions.next_run_at` — schedule STATE. `schedule` is user intent and stays untouched; without somewhere to record which occurrence is owed there is nothing to put a `<= now()` predicate on, which is why no enumerator could be written against the JSONB alone. - `mission_fires` — one row per (mission, occurrence). 0063_routine_fires.sql called this exact case: "For a scheduled *mission* it costs a container, a repo checkout, and real money — which is why this lands before mission scheduling does." `mission_schedule.rs` deliberately mirrors `cm-scheduler`'s shape rather than inventing a second one: atomic `FOR UPDATE SKIP LOCKED` claim, reschedule BEFORE dispatch so a failing launch cannot stall the clock, claim the slot before launching so a crash mid-launch is retried rather than dropped, and a fan-out cap. The cap is 5, not the scheduler's 25, because a mission firing is a container and a checkout where a routine firing may be one turn. The claim skips `status = 'running'`: a daily cron on a mission that takes longer than a day must skip the occurrence, not stack a second crew on the same workspace. Launch goes through `mission_orchestrator::on_launch` + `missions::set_status`, the same path as the draft→running transition, so one code path mints a crew. An unattended launch acts as the workspace owner (`users::owner_of_workspace`) since missions carry no creator column; a workspace without one settles the occurrence `failed` with the reason rather than dropping it silently. Backfill blast radius was MEASURED, not assumed: prod has zero missions with a cron, this workstation had exactly one — the control created to prove the bug. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-17 14:10:39 -07:00
Omar SobhandClaude Opus 5	3cc65c22c4	feat(judge): room to analyse — and a panic in the evidence path ... Three changes, one of them a live bug. **The bug.** `phase_summarizer` truncated agent output with `&s[..remaining]`, a BYTE slice of arbitrary UTF-8. Agent turn output routinely carries arrows, box-drawing and emoji, so a cut landing mid-character panics — taking down the evaluation sweep for that phase, triggered by nothing more than an agent writing a long enough line with a non-ASCII character at the wrong offset. Replaced with `clamp_to_char_boundary`, tested across every cut offset of a pure-4-byte string. It is precisely the bug the clawhdf5 agents found and fixed in `clawhdf5-migrate/src/validate.rs` this week — in our own code, in the path that feeds the judge. **Evidence budget** 60 KB -> 120 KB. Output headroom is worthless if the judge cannot see the work: the verdict is only as good as what reaches it. **Judge max_tokens** 2048 -> 16384. glm-5.3 is a reasoning model that spends most of its budget on a `thinking` block before writing the verdict, and running out mid-thought truncates it. A truncated verdict parses as empty and FAILS CLOSED, burning one of the phase's passes on a judge that never answered — how mission 01a00bbb lost one. Measured ceiling: z.ai accepts max_tokens up to 131072 on both glm-5.1 and glm-5.3 (131073 -> 400, "限制数值范围[1,131072]"), so 16384 is chosen for cost and latency rather than capability, and only emitted tokens are billed. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-16 21:59:01 -07:00
Omar SobhandClaude Opus 5	9c4b0722e8	feat(judge): an independent GLM judge, on the newest model z.ai publishes ... Every phase verdict this session was Anthropic grading Anthropic, and the boot log said so on each start: validator_preflight: no CLAWMATES_VALIDATOR_MODEL — phase verdicts are judged by the house model, which is NOT an independent check `evaluator.rs` already preferred a cross-provider judge and refused to call a same-family one `independent`; the local stack simply had no non-Anthropic credential. It now carries the same `glm` provider gw-04 has had all along — `format = "anthropic"` is load-bearing, since z.ai's OpenAI-compatible endpoint is ToS-throttled for raw SDK access while its Anthropic-format one is not. Model: glm-5.3, the newest z.ai lists (4.5, 4.5-air, 4.6, 4.7, 5, 5-turbo, 5.1, 5.2, 5.3 as of 2026-08-17). gw-04 still runs glm-4.7. glm-5.3 is a REASONING model: it emits a `thinking` block before its JSON. Our SSE parser ignores `thinking_delta` and keeps the text, so the wire shape is compatible — but on a realistic phase-evidence prompt it spent 819 of the evaluator's 1024 output tokens. A longer phase would truncate the verdict, and a truncated verdict parses as empty and FAILS CLOSED, burning one of the phase's passes on a judge that never answered — precisely how mission 01a00bbb lost a pass. max_tokens raised to 2048. Measured before wiring: asked to judge 25 commits claiming INT-01..INT-25 with tests passing, glm-5.3 returned met=false because the evidence never established what the brief actually required. That skepticism is the point of an independent judge. Boot now reports: `validator_preflight: independent validator glm:glm-5.3 answered`. The key lives in .env (gitignored), never in this file. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-16 21:41:45 -07:00
Omar SobhandClaude Opus 5	b5032a732a	fix(phase_runner): collect the agent's work BEFORE judging it ... `Sandbox::for_mission` builds the judge's verification copy from the HOST checkout. In copy mode the agents write inside the container, and their work only reached the host when `sync_out` ran — in the capture sweep, AFTER the phase closed. So every phase was judged against a tree that did not yet contain the pass being judged, and the judge truthfully reported nothing there. Mission 01a00cfa is the proof. Research pass 2 wrote a 434-line IMPLEMENTATION_BRIEF.md, `cargo test` passed, and it was pushed to a clean branch (clawmates/mission-01a00cfa-c69f39fd-i2 at 563cdd21). Its verdict: failed after 2 pass(es) — met=false — research/IMPLEMENTATION_BRIEF.md does not exist anywhere logged one line BEFORE `captured (+434/-0 across 1 file(s))`. A phase that succeeded was failed because the evidence had not been collected yet. This hid because it only bites a phase judged on its OWN pass. The v2 coding verdict cited real commits (339a5bd, 167671f) — research had already synced that work to the host in an earlier phase. `evaluate_finished_phases` now runs `sync_out` first, and on failure leaves the phase `evaluating` for the next sweep rather than recording a verdict nobody could stand behind — the same policy the capture sweep already applies, for the same reason. microVM keeps its carve-out: `microvm_executor` collects out of the guest over this same path before the VM is destroyed. Research goes to 3 passes. On 01a00cfa it got no real attempts out of two: one spent on a fabricated commit claim the judge correctly rejected, one on this bug. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-16 17:09:05 -07:00
Omar SobhandClaude Opus 5	a582dea4fc	feat(workflow): research plans, coding builds — the split was a fiction ... `rust_sdlc` gives the research team coding roles and a writable /mission/repo, so research implemented what it found and the coding phase then opened a clean tree, produced +0/-0 and failed on the empty-delivery rule. Mission 01a00c57 ended exactly that way: research shipped both INT items itself (+276/-57), coding delivered nothing. Worse than the wasted phase is WHERE the code landed. Research ran under a gate that does not check tests, so its two source changes reached a branch with `tests_status: null` — never compiled by the gate, never run. Keeping implementation in the coding phase is what puts it behind `on_green_tests`. Research now carries a `task` that scopes it to the brief and says plainly that editing crates/ is not its job this phase, plus a `done_when` describing what the brief must CONTAIN. The no-source-edits constraint deliberately lives in the prose and NOT in `done_when`: "and nothing else" phrasings measurably make a judge invent requirements it was never given. Coding gets the counterpart `task`: implement the brief's items, one commit each, tests green. Stated explicitly because a phase that finds a clean tree and no instructions has historically written a REPORT about the work instead of doing it — four documentation commits and one implementation, on the run that became the haiku baseline branch. Research also gets `commit_policy = "on_green_tests"` as a safety net, so source it writes anyway still has to pass the suite. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-16 16:48:05 -07:00
Omar SobhandClaude Opus 5	d341640255	fix(mission_fs): drop build output when collecting work back from a container ... `pack_dir` (host -> container) skips `transport_excludes`; `copy_out` (container -> host) is the raw Docker archive API and carries the whole tree, `target/` included. The asymmetry was invisible for as long as the runtime image had no cmake — nothing could compile, so no `target/` existed. The moment missions could actually build, every collection died on a build artifact: failed to unpack `…/repo/target/debug/build/ahash-…/build_script_build-…` `phase_runner` then correctly refused to capture, rather than record a stale tree as an empty diff — so mission 01a00c57's coding phase, which had done the work, delivered nothing and retried forever. A fix that let missions compile created a delivery failure one layer down. `unpack_into` now skips excluded entries by NAME at any depth (a workspace has a `target/` per crate) and logs how many it dropped. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-16 15:09:24 -07:00
Omar SobhandClaude Opus 5	99dd29cc8a	fix(worker): the stuck-run reaper was killing healthy sonnet-5 turns ... REAP_STUCK_AFTER_SECS was 15 minutes; the runtime grants a single turn `timeout_secs = 3000` (50 minutes). A run journals its first step record when its first step COMPLETES, so a turn still legitimately in flight is indistinguishable from a wedged container — and with a window shorter than the turn timeout the reaper does not detect stuck runs, it kills slow healthy ones. The old value was calibrated on haiku, where "healthy first-step latency is typically 5-60s" held. Moving mission agents to sonnet-5 made first turns longer than the window: mission 01a00c41's research phase was reaped at 900s having already written +402/-39 across 13 files. We only know it was healthy because the delivery path captured and pushed that work anyway, to branch clawmates/mission-01a00c41-421200ee at b08df7b6. Raised to 60 minutes, above the turn timeout, with the invariant written down so the next person changing either number sees the relationship. Generalises: a liveness timeout calibrated against one model becomes a correctness bug when the model changes. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-16 13:48:03 -07:00
Omar SobhandClaude Opus 5	b31a79f650	fix(llm): the subscription 429s were a malformed request, not a rate limit ... On the OAuth path Anthropic requires the Claude Code identity to be its own first system BLOCK. We concatenated it with the caller's prompt into a single string, so EVERY server-side call that set a system prompt was rejected — and the rejection arrives as `429 {"type":"rate_limit_error","message":"Error"}`, which reads as throttling and is not. Measured on one token, seconds apart: "PREAMBLE" (string) -> 200 "PREAMBLE\n\nJudge the …" (string) -> 429 "PREAMBLE" (string) -> 200 (control) ["PREAMBLE"] (blocks) -> 200 ["PREAMBLE", "Judge the …"] (blocks) -> 200 while the account reported `5h utilization 0.07, 7d 0.11, overage 0.0`, every window `allowed`. A Max 20x subscription at 7% was being read as out of capacity. What this was breaking, silently, for as long as it has been there: - every `done_when` verdict on the subscription judge. Mission 01a00bbb pass 2 returned "could not evaluate the completion condition this pass" and BURNED one of the phase's three passes on it. - the boot preflight, which reported `claude-opus-4-8 throttled (configured, no capacity now)` on every start — a diagnostic that was itself the bug. - mission_refiner, phase_summarizer, swarm planning. The `claude` CLI was unaffected throughout, because it sends its system prompt as blocks. That divergence is what made this look like an account problem: the agents worked while everything server-side "throttled". After the fix the preflight reports opus-5, sonnet-5 and haiku all `ok`. The API-key path keeps sending a plain string — it never had this constraint. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-16 13:15:27 -07:00
Omar SobhandClaude Opus 5	69c294addc	fix(models): coding runs on sonnet-5, judging on opus-5, haiku only as last resort ... Operator model policy: haiku ONLY for genuine yes/no questions; anything requiring thinking is opus-5; coding is sonnet-5. The mission AGENTS were running haiku, and nothing in the product said so. `provider_alias_for` maps every `claude-*` binding onto the single alias `claude_cli.default`, so a crew whose `model_binding` reads `claude-sonnet-5` — as this deployment's does — still ran whatever that alias pointed at, which was `model = "haiku"` in the runtime config. The binding is cosmetic; the alias is the truth. Measured consequence on mission 01a00bbb: the coding agents claimed six INT items complete and had committed three, and the done_when judge caught it by auditing git history against the claims. Model assignments, by what the component actually does: evaluator (done_when judge) haiku -> opus-5 reads evidence, audits it against the repo, writes guidance. The verdict is a boolean; the work is not — and this is the one component whose failure mode is passing work that was never done. judge_model 4-8 -> opus-5 mission_refiner 4-8 -> opus-5 composition phase_summarizer 4-8 -> opus-5 composition swarm planner 4-8 -> opus-5 planning subscription preflight head 4-8 -> opus-5 fallback chain head 4-6 -> sonnet-5 haiku stays BELOW it as a last-resort link, never a peer Every value stays env-overridable; only the shipped defaults move. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-16 12:36:19 -07:00
Omar SobhandClaude Opus 5	53da4d7e6d	fix(runtime): a mission could not build the repo it was given ... `clawmates-runtime` shipped with `gcc` and `make` but no `cmake`, no `g++` and no `python3-dev`. Measured on clawhdf5, three probes: no cmake → "is `cmake` not installed?" exit 101 after 13s no python3-dev → "cannot find -lpython3.11" exit 101 at link with both → cargo test PASSES exit 0 after 69s This is not only the delivery gate. The AGENTS run in this image, so a coding phase was writing Rust it had no way to compile or test — which reframes the last run's 11 agent commits as unverifiable by construction. `images/agent-toolchain/Dockerfile` (the microVM path) has had `cmake build-essential` all along, and its own header warns about precisely this: "if `cargo` is present in one image and absent in another, the same mission passes or fails depending on which backend it landed on, and nothing says why." Both images now install the same set — it was missing `python3-dev` too. `images/runtime-toolchain.Dockerfile` is a thin local overlay so the laptop can run today without recompiling zeroclaw from the fork; it is meant to be deleted once a runtime image built from the corrected deploy/ Dockerfile is published. Also: a build failure is no longer reported as a red suite. Both are cargo exit 101, and `verify_tests` mapped every non-zero to `Failed(code)` — so a missing toolchain was recorded as the USER's tests failing. It now returns `CouldNotRun` with the reason when the output shows a compile or link failure. Deliberately narrow: a failing `assert!` still reads as red, because letting broken code past `on_green_tests` is the expensive direction to be wrong in. Both directions are pinned by tests built from today's two real samples. And the coding phase finally has a loop: `research_and_code.toml` declared `loop = "until_no_more_int_items"`, which `phase_config.rs` lists as DECLARED_BUT_UNREAD. Iteration is driven by `max_iterations` + `done_when`, and with `max_iterations = 1` and no `done_when` the phase ran ONCE and was never judged — reporting `completed` whatever it produced. Now 3 passes against a stated goal, wording per the measured rule (say what the tree must CONTAIN). Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-16 11:02:07 -07:00
Omar SobhandClaude Opus 5	10341cf7fe	fix(missions): a retry's work is no longer silently destroyed ... Two independent bugs, either of which loses everything a retried phase produced, and neither of which reports a failure. 1. Capture is suppressed forever on a retry. Both `capture_finished_coding_phases` and the sweeper's last-chance `capture_outstanding_phases` skip any phase that already has a `code_diff` artifact. That guard is right for a phase that ran once and catastrophic for a retried one: the artifact from the FAILED attempt suppresses capture of the new attempt, the container is reaped on its normal grace, and everything the agents committed inside it is gone. The UI keeps showing the old diff, so the mission reads as delivered. `retry_phase` now clears the reopened phases' captures in the same transaction that reopens them, which is what makes its own doc comment ("the phase card starts fresh on the retry") true of the artifacts too. 2. `git add` exits non-zero over a gitignored path while staging correctly. Measured: with a populated `target/`, `git add -- . :(exclude)target` exits 1 and stages the right files; `-c advice.addIgnoredFile=false`, `--ignore-errors`, `-A` and `:/` all behave identically. Propagating that with `?` aborted the commit AFTER a successful staging — no branch, no commit, no push — for every Rust repo an agent has built in. `capture_phase_diff_at` already treats the same command as advisory; the commit path now does too, and the staged index decides. Mission 01a00538 hit both: it completed research and coding on the retry, 11 agent commits and all, delivered a patch dated the previous day, and lost the commits when the container was reaped. The remote was never touched — its HEAD still equalled the mission's own base_sha. Covered by a test that drives real git and asserts the files are staged regardless of the exit code. Co-Authored-By: Claude Opus 5 <[email protected]>	2026-08-16 09:41:36 -07:00