io.github.lvlrSajjad/sidecrew

What the local workers could not do, assembled for you to write yourself. Reads .sidecrew/runs/<id>/escalations.jsonl and returns each failed task with the exemplar and rules the worker had, plus both attempts' errors. Costs no worker tokens — it reads a finished run off disk. Two failures in here are NOT the test's fault and must not be rewritten as though they were: a stage_reached of 'mutation' means the mutation tool broke, and four mutation counts of zero mean nothing in that function could be mutated.

Run a whole change plan on this machine: workload #2a, behaviour-preserving changes — type errors, renames, null guards, API migrations, dead code. For each task the local model rewrites the listed files whole, and a gate a machine can run decides what you see: the diff stayed confined to the task's files, tsc is clean in them with none introduced elsewhere, and every test that passed before still passes. Generation is local and costs zero Claude tokens; only the FixResult comes back, so you see survivors and escalations rather than raw worker output. SLOW — the project's own suite runs per candidate, about 4–5 minutes each, so a 12-task plan is roughly an hour. Validate the plan first. Use --dry-run/dry_run to capture the baseline and stop before the first token, which is how you find out the tsconfig or the suite is the problem.

What the local workers could not change, assembled for you to do yourself. Reads a fix run's escalations.jsonl and returns each failed task with the files it was given and every attempt's verdict — which confinement rule fired, which tsc errors remain, which tests regressed. Costs no worker tokens; it reads a finished run off disk. TWO of these are NOT the worker's fault and must not be rewritten as though they were: machine_failure means the sandbox or the runner broke (exclude it from any rate you quote), and a non-null `refused` means the worker said the change cannot be made inside those files — which is usually a plan to fix rather than a change to write.

Check a change_plan.json before a run spends anything on it, and REFUSE the tasks no worker could ever pass: a file too large to return whole (a worker rewrites whole files, so ~8k completion tokens is the ceiling), a pre-existing tsc error the ask does not cover (the gate requires zero errors in the task's own files, so such a task is unsatisfiable at any temperature), a file outside the tsconfig's program, two tasks in one step sharing a file. Call it after writing or editing a plan. The expensive half is a real tsc over the project — tens of seconds — and it is the half that produces the refusals; compile: false is the fast structural pass. Worth it: the gate costs about 262 s per attempt, so one refused task saves nine minutes.

One WorkerTask -> one candidate test, generated by the MLX model running on this machine. Costs zero Claude tokens and touches no network: it is an HTTP call to http://localhost:<port>/v1. Raw worker output — verify it before showing it to anyone.

Check a test_plan.json before a run spends anything on it: it parses, its module and exemplars are on disk, every line range really is the function it names, and — unless verify_exemplars is false — every exemplar survives the verifier. Call it after writing or editing a plan. Verifying the exemplars is the expensive half: one verdict per shape, seconds on TypeScript and tens of seconds on Swift. A stale source_sha is a warning here and a refusal in sidecrew_run_batch.

Which survivors are worth reading, and in what batches. Survival is a filter, not an endorsement — a test that pins today's wrong answer kills every mutant — so this returns survivors below the mutation-score threshold plus a deterministic audit sample of the rest, batched under a token cap. The threshold is per language and defaults accordingly: a Swift score is computed over one or two mutants against TypeScript's six to twelve. Reads a finished run off disk; no worker tokens.

Run a whole plan on this machine: for every function x shape, generate -> verify -> retry once with the error appended -> escalate. Generation is local and costs zero Claude tokens; only the BatchResult comes back, so you see survivors and escalations rather than raw worker output. Minutes, not seconds — roughly 10 s per TypeScript candidate and 40 s per Swift one.

Is a local worker up, which model and revision it is serving, free RAM, and which verifier tools this project has. Call it before a run: everything else here needs a worker, and a missing stryker or muter is why a verdict would fail for a reason that is not the test's fault.

compile -> run -> mutate one candidate against the function its task_id names, and return a Verdict. Survive means it compiled, passed against the unmodified source, killed at least one mutant of that function, and was not tautological. Runs entirely on this machine.