v0.0.56 — the aitm typecheck:tests gate is on

CI's typecheck (tests) step now gates both workspace packages, so a test file that drifts from package source fails the build instead of rotting. Getting there took the aitm suite from 425 type errors to 0 (#132, PR #325).

Five shared test-support modules now live under packages/aitm/src/testing/ — build-excluded, consumed only by tests. They replace fixtures that had been copy-pasted and left to drift: emptyUsage existed in six files, every copy carrying a totalTokens field the SDK's usage type does not have.

Runtime surface is unchanged except two additive exports from credentials/llm-fetch.ts (isKeepAliveAgent, KeepAliveAgent), so a test can narrow through the module's own predicate instead of restating undici's Dispatcher surface.

Gates: typecheck, typecheck:tests, lint green on both packages; node --test 2328 pass / 0 fail.

v0.0.55 — coding style distilled from real source

Coding style now reads real code

Style detection read four things — CLAUDE.md/AGENTS.md, CONTRIBUTING.md, biome.json/tsconfig*.json, and package.json scripts — and never a line of source. The digest's job is the conventions the style file does not state, and it was inferring them from config files.

The sharpest consequence: a Rust, Python, or Go repo matched no config pattern, so signal gathering came back empty and the distiller returned before calling the model at all. Those repos got no style guide.

• Config detection spans ecosystems — Cargo.toml, pyproject.toml, go.mod, Gemfile, .rubocop.yml, ruff.toml, Makefile, .editorconfig, and more.
• Real source and test files are sampled from the repo and fed to the same single distill call.
• The hardcoded **/*.test.ts glob is gone; the digest sees the repo's actual test files, whatever the ecosystem names them (_test.go, test_*.py, *_spec.rb).

Bounded, because it runs before every plan: 5 source + 3 test samples, 2500 chars each, files over 200 KB skipped (generated and minified files are the worst style exemplars and the most expensive reads), breadth-first walk capped at 4000 files and depth 8, vendor and hidden directories skipped. Sampling is deterministic.

Known limitation: config discovery is repo-root only, so a monorepo's nested Cargo.toml is not picked up — source sampling still covers those repos.

Also

Worker fanout prose compressed (~460 chars off the role guidance paid on every subagent spawn), with no rule dropped.

Full diff: #324

v0.0.54 — waves replace one-shot planning

Builds on v0.0.53, which stopped maxPrs from truncating work. This release stops the plan from being the run.

Wave re-planning

A plan was the whole run: plan once, drive the groups to exhaustion, exit. Nothing ever asked whether the goal was met, so a plan that under-covered it shipped a fraction and exited 0 — with no path by which the remainder would ever be built.

A plan is now one wave. When every group in a wave lands, a goal assessor reads the repo as it now is and either ends the run or names what remains, which the Planner plans as the next wave — against real code instead of a guess.

Bounded by cost, not counts, consistent with how step limits and subagent fan-out already behave:

• only a clean sweep earns another wave — blocked / cancelled / awaiting-pr / session-cap return exactly as before
• the assessor fails safe to complete: a broken or stalled check ends the run rather than planning work off no evidence
• remaining work identical to a goal an earlier wave already planned is a livelock, not progress, and stops the run
• maxCostUsd / maxTotalTokens still trip inside the work loop, and now span waves correctly

Planning-phase fixes

• Small repos skip the scout survey. Measured: an 11-file docs-only repo drew 2 rounds / 6 scouts over ~11 minutes, and the Planner then read the same files itself. Under 25 tracked files the wave is skipped and the Planner gets the repo map alone. A git failure (zero tracked files) still surveys — that means size unknown, not small.
• An over-cap plan is retried, not fatal. The cap is now a schema refinement, so the Planner is asked to regroup through the existing corrective loop instead of the run dying on the first over-cap submission.
• Compressed planner prose, paid on every subagent spawn.

Fixes found while reviewing the wave loop

• maxSessions had become a per-wave bound — each wave built a fresh work loop seeded from the run-start snapshot, restarting the session counter. It now accumulates across waves.
• The rolling PR context was likewise reset per wave, so a later wave's PR bodies were composed as though earlier PRs never happened.

Full diffs: #321 · #322 · #323

v0.0.53 — maxPrs caps PR packaging, never how much work a run does

Fixed

maxPrs defaulted to 5 and was injected into every Planner prompt as a budget, while the Planner's guidance argued only against splitting and never required the groups to span the goal. The result: aitm start "do full implementation" on a greenfield repo planned one PR group covering the first component and silently dropped the rest. Nothing re-plans the remainder, so what was left out was never built — and the run reported success.

• maxPrs now defaults to unbounded. The Planner sizes the plan to the goal. --max-prs 0 / AITM_MAX_PRS=0 are explicit unbounded.
• The maxPrs: prompt line is injected only when you set a cap, so an unbounded run never sees a PR budget to plan to.
• Coverage invariant added to the Planner prompt: the groups must together deliver the whole goal; a plan implementing a subset is invalid.
• An over-cap plan is now rejected with an actionable error, not truncated into the first N groups plus a remainder: task no Worker ever executes. capGroups() and its dangling-dep remapping are deleted.

A count cap now shapes packaging only — never total work, which matches how step limits and subagent fan-out already behave. Bound a run with maxCostUsd / maxTotalTokens.

Compatibility: state files written by older versions still parse (maxPrs accepts a number or null).

Full diff: #321

v0.0.52 — no directory grouping

Finishes applying the no legacy rule (0.0.51) to the editor fanout.

Deleted

groupManifestByDir — the rule the editor tag replaced, still running whenever a manifest arrived untagged. That's the shape the rule forbids: replaced behaviour firing on the one path nobody exercises deliberately.

An untagged manifest is now one editor. That's the "do less" net rather than the "run what we rejected" net, and it reads like the rest of the harness: a subagent is not rationed, so one big assignment is a normal outcome, not a degraded one. A Coordinator that did not divide the work has not divided it.

Falls out of it

• MAX_FILES_PER_EDITOR is gone. A per-leaf size cap only existed to chunk directory groups. Nothing mechanical assembles a leaf now, and capping a deliberate assignment would hand half a feature to an editor that can't see the other half.
• Leaf labels are the Coordinator's own names (auth, docs) instead of derived paths (src/auth/, README.md), so the roster and per-editor progress lines say what each leaf is for.
• Grouping no longer reads paths at all; dirOf survives only in the labeller.

Note for anyone tuning fanout

If you rely on wide parallel edits, the Coordinator must tag entries with editor. The prompt instructs it to, but an untagged manifest will now run as a single (unrationed) editor rather than being split for you.

v0.0.51 — no legacy

The rule

No legacy is now house style. When a design is replaced, the old one is deleted — not kept behind a flag, an optional field, a fallback branch, or a rename alias. A superseded path that still runs is worse than no path: it's untested in anger, it drags its assumptions into new code, and it fires exactly when something else already went wrong.

If a failure needs a safety net, the net is "do less" — skip the phase and let the caller proceed as it would have — never "run the thing we just rejected."

Two exceptions, both about data rather than code: an on-disk state/config file written by an older version must still parse, and a documented CLI/config key is renamed in one release rather than aliased forever.

Applied

• The pre-lead scout fallback is gone. The fixed four-lens survey the scout lead replaced in 0.0.49 was still there for the "lead died" case — meaning a provider hiccup could revive exactly the repo-blind behaviour the lead exists to eliminate. A dead lead now means no survey: the Planner keeps its own read-only tools and the deterministic repo map, which is what it had before the survey existed at all.
• experimental_Agent purged. That was the AI SDK 5 name; v6 ships ToolLoopAgent and the code moved long ago, but four docs and two skill files still named it — and a source comment existed only to flag that the docs were stale.
• SCOUT_CONCURRENCY removed from the docs; subagentLimit replaced it in 0.0.49.

No behavior change for a healthy run — this only removes what used to happen when something failed.

v0.0.50 — lead-sized teams for working and reviewing

Completes what 0.0.49 started: every fan-out is now a lead sizing its own team — planning, working, and reviewing.

Working: the Coordinator assigns its own editors

The editor fanout used to split a manifest by parent directory. That's a proxy for cohesion and it's wrong exactly when it matters — a route, its service and its test live in three directories and belong to one editor.

The Coordinator surveyed the code and wrote the manifest, so it is the lead. It now tags each entry with an editor label, and entries sharing a label go to one leaf whole — never chunked, because the lead named that group deliberately and an editor is not rationed. Untagged manifests fall back to directory grouping, unchanged.

After verify fails, the fix pass makes the same call again on what actually broke: a few failures in one area → fix inline; failures spread across independent areas → a second wave sized to the damage.

Reviewing: parallel investigation, serial writes

Reviewing is the one phase that cannot fan out and write — every fixed thread commits against the shared checkout, so two writers would sweep each other's work into one commit.

What parallelizes is everything before the write. A lead groups the unresolved threads (several comments on one file are ONE investigator's job) and a read-only wave works them out concurrently ahead of the sequential resolver. Briefs are leads, never verdicts: the Reviewer still decides the outcome and confirms anything it acts on. A single thread skips the team.

Investigators are read-only by construction — they never receive the edit/bash/github tools, and a test pins that.

Shared rules, wherever a lead appears

• One subagent is a good answer; splitting only pays when the ground genuinely divides.
• Size each assignment before sending it — too big if it spans work that doesn't inform itself, too small if it lands in a neighbour's files.
• Brief, don't script: what the lead hands over is a floor, never a ceiling.
• subagentLimit (default 10) caps concurrency across all three phases — never work.

v0.0.49 — lead-directed scout survey

Planning now runs a survey team that decides its own shape

The pre-planning survey used to send four hardcoded lenses at every repo, blind to whether it faced a twelve-package monorepo or a single src/. Each scout started from zero, so four of them paid for the same discovery before answering anything.

• A repo map, built without an LLM (workspace/repo-skeleton.ts) — git ls-files folded into a ranked directory tree plus root manifests, handed to every agent downstream.
• A scout lead decides how many scouts and where, then briefs each one with sub-questions, start paths, files to read whole, and the identifiers this codebase actually uses. One scout is a legitimate answer: a scout is unrationed, so splitting only pays when the ground genuinely divides.
• Scouts roam. The briefing is a floor, not a ceiling — cover it, correct it where the map misled, follow the code past it. Findings come back anchored to file:line and schema-capped, so raw reads stay out of the Planner's context.
• A gap round lets the lead close specific holes, bounded at two rounds.
• The tracked-file size gate is gone; the lead sizes the wave with actual information instead.

One fan-out knob

subagentLimit (default 10 — 1 main agent + 10 subagents) replaces editorConcurrency. Shared by scout waves and the Worker's editor fanout, and now per-run overridable:

aitm start "…" --subagents 20      # or AITM_SUBAGENTS=20

It caps concurrency, not work: each lead decides how much help it needs, and each subagent reads as much as it judges necessary.

Fixed

A planner transcript could be left open forever if anything threw between beginTranscript and the finally that closes it. The survey now runs before the transcript opens.

v0.0.48 — config env-var overrides, composition root, Deno fix

Changes since v0.0.47

• feat(config): env-var overrides for config layers + profile rename (#309)
• feat(testing): graded e2e benchmark harness with per-run usage JSONL + compare (#307)
• refactor: one composition root — run-input, cli/format, adapter wiring split (#311)
• refactor: domain type extraction & constant hoisting, plus a CI import-cycle check (#310)
• fix: explicit process import for Deno compatibility (#312)
• chore: tests, CI & docs closure (#313)

Published to npm as @developerz.ai/aitm@0.0.48 and @developerz.ai/ai-claude-compat@0.0.48.

v0.0.47

v0.0.47

Added

• aitm update — manual self-update command (bun install -g @developerz.ai/aitm@latest, npm fallback). --check only reports whether a newer version exists; nothing ever updates automatically.

Changed

• Default smart/coding tiers now use Claude Opus 5 (anthropic/claude-opus-5); generic (anthropic/claude-sonnet-5) and fast (anthropic/claude-haiku-4.5) unchanged.