@developerz.ai/aitm 0.0.2 → 0.0.3

package/dist/loop/run-loop-adapter.js

@@ -1,17 +1,3 @@
-// Production wiring for `aitm start`. Composes the WorkLoop's structural ports out of the
-// real Planner, Orchestrator, WorktreePool, PlanGraph, MCP tools and GitHubClient.
-//
-// Symmetric counterpart to the merge-pr flow: `runStart` injects this as its `runLoop` seam
-// (see src/cli/commands.ts `defaultRunLoop`). Every external dependency is reachable through
-// a seam so the four WorkLoopResult branches are unit-testable without spawning subagents,
-// git, or `gh` — the integration suite (test/integration/) covers the real stack.
-//
-// Flow:
-//   1. Resume detection — if state already holds prGroups, reuse them; else run the Planner.
-//   2. Persist the plan into RunState (status → working).
-//   3. Build a *live* PlanGraph that re-reads the mirrored prGroups on every ready()/isComplete()
-//      so status transitions written by the loop are visible (PlanGraph snapshots at construction).
-//   4. Bridge the Orchestrator/subagents into the WorkLoopOrchestrator port and run the loop.
 import { resolve as resolvePath } from 'node:path';
 import { bashTool, composeSystemPrompt, editFileTool, globTool, grepTool, multiEditTool, readFileTool, writeFileTool, } from '@developerz.ai/ai-claude-compat';
 import { tool } from 'ai';
@@ -25,10 +11,6 @@ import { createReviewerAgent, REVIEWER_SYSTEM_PREFIX, runReviewer as runReviewer
 import { createWorkerAgent, runWorker as runWorkerSubagent, WORKER_SYSTEM_PREFIX, } from "../subagents/worker.js";
 import { WorktreePool } from "../workspace/worktree-pool.js";
 import { WorkLoop, } from "./work-loop.js";
-// Worktree-scoped Claude-Code-style tools the Worker/Reviewer fall back to when no MCP server
-// supplies them. aitm is MCP-first, but a bare `aitm start` (no `mcpServers` configured) must
-// still be able to read, search, edit, commit and open a PR — so it uses the compat lib's
-// tools, scoped to the active worktree.
 export function localEditTools(cwd) {
     return {
         readFile: readFileTool({ cwd }),
@@ -40,7 +22,6 @@ export function localEditTools(cwd) {
         bash: bashTool({ cwd }),
     };
 }
-// Read-only subset for the Planner — survey the repo without write/edit/bash.
 export function localReadTools(cwd) {
     return {
         readFile: readFileTool({ cwd }),
@@ -50,8 +31,6 @@ export function localReadTools(cwd) {
 }
 export async function runLoopAdapter(input, seams = {}) {
     const state = seams.state ?? input.state;
-    // MCP is only needed when a real Planner / Orchestrator default runs. When both are stubbed
-    // (unit tests), we never connect, so no transport is spawned.
     const usesMcp = !seams.planGroups || !seams.makeOrchestrator;
     const mcp = seams.makeMcp
         ? seams.makeMcp(input)
@@ -64,7 +43,6 @@ export async function runLoopAdapter(input, seams = {}) {
         }
         const current = await state.read();
         const rollingContext = (await state.readContext?.()) ?? '';
-        // ---- Plan (fresh) or resume (prior prGroups present) -------------------
         let groups;
         if (current.prGroups.length > 0) {
             groups = current.prGroups;
@@ -84,9 +62,6 @@ export async function runLoopAdapter(input, seams = {}) {
             groups = outcome.groups;
             await state.update((s) => ({ ...s, status: 'working', prGroups: groups }));
         }
-        // ---- Live graph + state proxy ------------------------------------------
-        // PlanGraph captures its groups at construction, so rebuild it per call against the
-        // mirror that workLoopState keeps in sync after every persisted update.
         let liveGroups = groups;
         const graph = {
             ready: () => new PlanGraph([...liveGroups]).ready(),
@@ -99,7 +74,6 @@ export async function runLoopAdapter(input, seams = {}) {
                 return next;
             },
         };
-        // ---- Remaining deps ----------------------------------------------------
         const pool = seams.makePool?.(input) ??
             new WorktreePool(input.cwd, resolvePath(input.cwd, '.ai-task-master'), input.resolved.concurrency);
         const github = seams.makeGithub?.(input) ?? input.github;
@@ -128,7 +102,6 @@ export async function runLoopAdapter(input, seams = {}) {
         }
     }
 }
-// ---- Plan ------------------------------------------------------------------
 export function planToPrGroups(plan) {
     return plan.groups.map((g) => ({
         id: g.id,
@@ -159,7 +132,6 @@ async function defaultPlanGroups(input, mcp) {
         return { kind: 'blocked', reason: result.reason };
     return { kind: 'error', error: result.error };
 }
-// ---- Orchestrator bridge ---------------------------------------------------
 function defaultMakeOrchestrator(ctx) {
     const { input, mcp, rollingContext } = ctx;
     const style = input.agentConfig.contents;
@@ -172,8 +144,6 @@ function defaultMakeOrchestrator(ctx) {
     });
     return {
         runWorker: async ({ group, worktree, baseBranch }) => {
-            // Prefer MCP-supplied tools; partial-fill any the server omits from the local set so a
-            // bare `aitm start` (no mcpServers configured) can still edit, commit and open a PR.
             const tools = resolveWorkerTools(mcp.toolsForRole('worker'), worktree.path);
             const agent = createWorkerAgent({
                 model: input.credentials.modelFor('worker'),
@@ -190,16 +160,12 @@ function defaultMakeOrchestrator(ctx) {
         },
         finalizeCommit: (group, delivery, worktreePath) => orch.finalizeCommit(group, delivery, worktreePath),
         openPr: async (group, delivery, baseBranch) => {
-            // The Worker's commits live on the group branch in a linked worktree (shared object
-            // store). Push it to origin first — `gh pr create` won't open a PR for a branch that
-            // isn't on the remote ("No commits between … / Head ref must be a branch").
             const head = group.branch ?? `aitm/${group.id}`;
             await execa('git', ['push', '-u', 'origin', head], { cwd: input.cwd });
             return orch.openPr(group, delivery, baseBranch);
         },
         runReviewer: async ({ pr, threads, worktree }) => {
             const github = githubThreadTool(input.github);
-            // Same partial-fill as the Worker, plus the local `github` thread tool.
             const tools = resolveReviewerTools(mcp.toolsForRole('reviewer'), worktree.path, github);
             const agent = createReviewerAgent({
                 model: input.credentials.modelFor('reviewer'),
@@ -215,10 +181,6 @@ function defaultMakeOrchestrator(ctx) {
         },
     };
 }
-// MCP exposes a dynamically-typed ToolSet. The subagents need a statically-shaped tool record.
-// Rather than fail closed when a server only exports the legacy readFile/writeFile/bash, we
-// partial-fill: prefer the MCP tool for each name, falling back to the local worktree-scoped
-// tool for any the server omits. The shape is asserted once at this boundary.
 function resolveWorkerTools(set, cwd) {
     const local = localEditTools(cwd);
     return {
@@ -234,10 +196,6 @@ function resolveWorkerTools(set, cwd) {
 function resolveReviewerTools(set, cwd, github) {
     return { ...resolveWorkerTools(set, cwd), github };
 }
-// The Planner gets only the read-only subset, partial-filled the same way. This is also the fix
-// for the latent no-MCP bug: previously the Planner was handed the raw MCP ToolSet with no local
-// fallback, so a bare `aitm start` left it with zero tools despite its prompt promising
-// readFile/grep/glob.
 function resolvePlannerTools(set, cwd) {
     const local = localReadTools(cwd);
     return {
@@ -246,8 +204,6 @@ function resolvePlannerTools(set, cwd) {
         glob: set.glob ?? local.glob,
     };
 }
-// Flat object, not a discriminatedUnion → no `oneOf` in the tool params (rejected by some
-// OpenRouter-routed providers). `body` applies to replyToThread only.
 const githubToolInputSchema = z.object({
     action: z.enum(['replyToThread', 'resolveThread']),
     threadId: z.string().min(1),
@@ -267,4 +223,3 @@ export function githubThreadTool(github) {
         },
     });
 }
-//# sourceMappingURL=run-loop-adapter.js.map

package/dist/loop/take-over-flow.js

@@ -1,23 +1,3 @@
-// Take-over merge flow. Drives an externally-built PR (Claude Code, gh pr create, etc.)
-// to merge: waits for CI, runs Reviewer to address unresolved review threads (CodeRabbit
-// + human reviewers), pushes fixes, and merges. Mirrors the claude-task-master
-// `merge_pr()` shape from src/claude_task_master/cli_commands/fix_pr.py:
-//
-//   for iteration in 0..maxIterations:
-//     status   = waitForChecks(pr)
-//     threads  = listUnresolvedThreads(pr)
-//     if status == success and threads.empty: break
-//     if status == failure: runWorker (CI-fix path, optional)
-//     if threads.any: runReviewer per thread, push commits
-//     sleep(cooldown)  # let CI restart
-//   mergePr(pr)
-//
-// Unlike WorkLoop.autoMergeFlow, this does NOT acquire a `git worktree`. The user is
-// expected to be on the PR branch in their cwd; everything happens in-place. That's
-// the simpler model and matches how a human reviewer would handle it.
-//
-// docs/vendor/ai-sdk/chunk-09.md §"Subagents" — Reviewer/Worker are built ad-hoc per loop
-// iteration because their tool bindings (worktree, threads) change each iteration.
 import { composeSystemPrompt } from '@developerz.ai/ai-claude-compat';
 import { CiFailed } from "../github/errors.js";
 import { createReviewerAgent, REVIEWER_SYSTEM_PREFIX, runReviewer, } from "../subagents/reviewer.js";
@@ -29,21 +9,14 @@ export async function runTakeOverFlow(input) {
     const cooldownMs = input.cooldownMs ?? DEFAULT_COOLDOWN_MS;
     const sleep = input.sleep ?? defaultSleep;
     const log = input.logger;
-    // Hoisted so the post-loop merge can report how many iterations actually ran: on an
-    // early `break` it holds the break index, on natural exhaustion it equals maxIterations.
     let iteration = 0;
     for (; iteration < maxIterations; iteration++) {
         log?.info('take-over: iteration start', { pr: input.pr, iteration });
-        // 1. Wait for CI to settle. waitForChecks throws CiFailed on hard failure; we treat
-        //    that as "Worker should try to fix" rather than a fatal error.
         const ciStatus = await observeCheckStatus(input.github, input.pr);
         log?.info('take-over: ci status', { pr: input.pr, ciStatus });
-        // 2. Pull review threads. Always runs — even on CI failure, threads may exist and
-        //    fixing them might happen to fix CI too.
         const threads = await input.github.listUnresolvedThreads(input.pr);
         log?.info('take-over: threads', { pr: input.pr, count: threads.length });
         if (ciStatus === 'success' && threads.length === 0) {
-            // Happy path: nothing left to do. Merge.
             break;
         }
         let pushedSomething = false;
@@ -69,7 +42,6 @@ export async function runTakeOverFlow(input) {
                     iterations: iteration,
                 };
             }
-            // Reviewer commits per-thread fixes via the bash tool; we still need to push them.
             if (reviewed.resolutions.some((r) => r.kind === 'fixed')) {
                 pushedSomething = true;
             }
@@ -78,12 +50,9 @@ export async function runTakeOverFlow(input) {
             await input.push(input.worktreePath);
             log?.info('take-over: pushed fixes', { pr: input.pr });
         }
-        // Sleep so the next iteration's waitForChecks sees fresh CI state, not the stale
-        // success/failure from before our push triggered a new run.
         if (cooldownMs > 0)
             await sleep(cooldownMs);
     }
-    // Final state check — make sure we didn't fall through the loop with a hung iteration.
     const finalStatus = await observeCheckStatus(input.github, input.pr);
     const finalThreads = await input.github.listUnresolvedThreads(input.pr);
     if (finalStatus !== 'success') {
@@ -104,8 +73,6 @@ export async function runTakeOverFlow(input) {
     log?.info('take-over: merged', { pr: input.pr });
     return { kind: 'merged', pr: input.pr, iterations: iteration };
 }
-// Convert waitForChecks' throw-on-failure semantics into a status return so the loop can
-// treat CI failure as a recoverable state.
 async function observeCheckStatus(github, pr) {
     try {
         return await github.waitForChecks(pr);
@@ -137,9 +104,6 @@ async function runReviewerThreads(input, threads) {
         styleContents: input.subagents.styleContents,
     });
 }
-// Worker CI-fix path. Build a synthetic PR group whose only task is "fix CI on this PR",
-// then run the regular Worker. Worker emits a FileManifest and runs per-file editors —
-// suitable for "test failed, fix it" if Worker has enough context from the worktree.
 async function runWorkerCiFix(input) {
     const group = {
         id: `takeover-ci-${input.pr}`,
@@ -180,4 +144,3 @@ function defaultSleep(ms) {
         setTimeout(resolve, ms);
     });
 }
-//# sourceMappingURL=take-over-flow.js.map

package/dist/loop/work-loop.js

@@ -1,21 +1,5 @@
-// docs/architecture.md (WorkLoop row), docs/commands/start.md §Flow
-// Drives the Orchestrator group-by-group. Extended for concurrent execution:
-//
-//   while !plan.isComplete():
-//     ready = planGraph.ready()
-//     batch = ready.slice(0, free worker slots)
-//     await Promise.all(batch.map(g => runGroup(g)))
-//
-// Each runGroup acquires a WorktreePool slot, runs Worker, and on PR open hands off to
-// the merge-pr flow (CI wait + Reviewer + GitHubClient.mergePr).
-//
-// Deps are structural ports — concrete classes (Orchestrator, GitHubClient, StateStore,
-// WorktreePool, PlanGraph) satisfy them at runtime; tests pass literal stubs.
 import { CiFailed } from "../github/errors.js";
 const DEFAULT_MERGE_METHOD = 'squash';
-// Thrown when a state-write fails *after* an external side effect (openPr/mergePr) already
-// succeeded. Carries the real outcome so runGroup doesn't roll the group back to 'blocked'
-// and cause a retry to reopen/re-merge work that already landed.
 class StateWriteAfterSuccess extends Error {
     outcome;
     cause;
@@ -52,7 +36,6 @@ export class WorkLoop {
         }
         return this.finalResult();
     }
-    // Run a single group end-to-end: worktree → Worker → (optionally) merge-pr inline.
     async runGroup(group) {
         const branch = group.branch ?? `aitm/${group.id}`;
         let acquired = false;
@@ -71,18 +54,13 @@ export class WorkLoop {
         }
         catch (err) {
             if (acquired) {
-                // best-effort release if processGroup itself threw before the inner finally ran;
-                // the inner finally would have run already in normal flow, so this is defensive.
                 try {
                     await this.deps.pool.release(group.id);
                 }
                 catch {
-                    /* swallow */
                 }
             }
             if (err instanceof StateWriteAfterSuccess) {
-                // External side effect (openPr/mergePr) already succeeded; persist failed.
-                // Keep the real outcome so a retry doesn't reopen or re-merge.
                 this.outcomes.push(err.outcome);
                 return;
             }
@@ -91,7 +69,6 @@ export class WorkLoop {
                 await this.markStatus(group.id, 'blocked');
             }
             catch {
-                /* swallow secondary failures */
             }
             this.outcomes.push({ groupId: group.id, status: 'blocked', reason });
         }
@@ -108,20 +85,15 @@ export class WorkLoop {
         const delivery = workerResult.delivery;
         await orchestrator.finalizeCommit(group, delivery, worktree.path);
         const pr = await orchestrator.openPr(group, delivery, baseBranch);
-        // openPr already landed externally; if persistence fails here, surface the real
-        // outcome via StateWriteAfterSuccess so the outer catch doesn't flip us to 'blocked'.
         await this.persistAfterSideEffect({ groupId: group.id, status: 'awaiting-pr', pr: pr.number }, () => this.markStatus(group.id, 'awaiting-pr', { pr: pr.number }));
         if (!this.deps.autoMerge) {
             this.outcomes.push({ groupId: group.id, status: 'awaiting-pr', pr: pr.number });
             return;
         }
         await this.autoMergeFlow(group, pr, worktree, baseBranch);
-        // mergePr already landed externally; same guard as above.
         await this.persistAfterSideEffect({ groupId: group.id, status: 'merged', pr: pr.number }, () => this.markStatus(group.id, 'merged'));
         this.outcomes.push({ groupId: group.id, status: 'merged', pr: pr.number });
     }
-    // Run a state write that follows a successful external side effect. If the write throws,
-    // wrap the error in StateWriteAfterSuccess so callers don't roll the outcome back.
     async persistAfterSideEffect(outcome, write) {
         try {
             await write();
@@ -132,7 +104,6 @@ export class WorkLoop {
     }
     async autoMergeFlow(group, pr, worktree, baseBranch) {
         const { orchestrator, github } = this.deps;
-        // CI: wait for checks. On failure, ask Worker to fix and re-check.
         try {
             await github.waitForChecks(pr.number);
         }
@@ -147,7 +118,6 @@ export class WorkLoop {
             await orchestrator.finalizeCommit(group, fix.delivery, worktree.path);
             await github.waitForChecks(pr.number);
         }
-        // Review: resolve any unresolved threads via Reviewer.
         const threads = await github.listUnresolvedThreads(pr.number);
         if (threads.length > 0) {
             const review = await orchestrator.runReviewer({ pr: pr.number, threads, worktree });
@@ -166,16 +136,11 @@ export class WorkLoop {
         return Math.min(concurrency, readyCount, remaining);
     }
     async markStatus(id, status, patch = {}) {
-        // Status transitions do not bump sessionCount — that's owned by incrementSessionCount,
-        // which fires once per batch dispatch so the in-memory and persisted counters agree.
         await this.deps.state.update((s) => ({
             ...s,
             prGroups: s.prGroups.map((g) => (g.id === id ? { ...g, ...patch, status } : g)),
         }));
     }
-    // Single source of truth for session counting: bump both the in-memory counter (used by
-    // run() to enforce maxSessions) and the persisted counter (used by reporting/resume) in
-    // one call. Drops in-memory if persistence fails so the two stay aligned.
     async incrementSessionCount(by) {
         if (by <= 0)
             return;
@@ -208,4 +173,3 @@ export class WorkLoop {
         return { kind: 'success', outcomes: this.outcomes.slice() };
     }
 }
-//# sourceMappingURL=work-loop.js.map

package/dist/mcp/mcp-client.js

@@ -1,13 +1,3 @@
-// Connects to every MCP server declared in `mcpServers` (config) and exposes the
-// union of their tools to subagents. The Vercel AI SDK's @ai-sdk/mcp client gives
-// us tool-conversion; we wire transport per entry and merge the tool maps.
-//
-// docs/vendor/ai-sdk/chunk-15.md §"Initializing an MCP Client"
-// docs/mcp.md
-//
-// Lifecycle: connectAll() at run start, toolsForRole() during agent build, close() on exit
-// (success / blocked / SIGINT). Failures on individual servers are logged + skipped — a
-// broken MCP server should not block the whole run.
 import { experimental_createMCPClient } from '@ai-sdk/mcp';
 import { Experimental_StdioMCPTransport } from '@ai-sdk/mcp/mcp-stdio';
 export class McpClientManager {
@@ -20,8 +10,6 @@ export class McpClientManager {
     }
     async connectAll() {
         for (const [name, server] of Object.entries(this.init.servers)) {
-            // Track the client outside the try so a failure during tools() can still
-            // close the spawned process / socket instead of leaking it.
             let client;
             try {
                 const transport = transportKind(server);
@@ -120,4 +108,3 @@ function clientNameFor(name) {
 function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }
-//# sourceMappingURL=mcp-client.js.map

package/dist/mcp/schema.js

@@ -1,23 +1,9 @@
-// MCP *client* config — aitm consumes external MCP servers as additional tool surfaces
-// for subagents. aitm is NOT exposed as an MCP server (banned by CLAUDE.md §"Out of scope").
-//
-// Shape mirrors Claude Code's `mcpServers` config — three transports, same keys.
-// Refs:
-//   https://code.claude.com/docs/en/mcp                    (Claude Code reference)
-//   https://modelcontextprotocol.io/                       (spec)
-//   docs/vendor/ai-sdk/chunk-15.md §"Model Context Protocol" (Vercel AI SDK client)
-//
-// Transports:
-//   stdio — local binary launched as a child process. Default when `type` omitted.
-//   sse   — HTTP server-sent events. URL + optional headers.
-//   http  — Streamable HTTP transport. URL + optional headers. Preferred for production.
 import { z } from 'zod';
 export const McpStdioServerSchema = z.object({
     type: z.literal('stdio').optional(),
     command: z.string(),
     args: z.array(z.string()).optional(),
     env: z.record(z.string(), z.string()).optional(),
-    // Working directory for the spawned process. Defaults to repo root.
     cwd: z.string().optional(),
 });
 export const McpSseServerSchema = z.object({
@@ -36,4 +22,3 @@ export const McpServerSchema = z.union([
     McpHttpServerSchema,
 ]);
 export const McpServersSchema = z.record(z.string(), McpServerSchema);
-//# sourceMappingURL=schema.js.map

package/dist/openrouter/client.js

@@ -1,6 +1,3 @@
-// Thin OpenRouter API client. Only the endpoints we actually need:
-//   GET /api/v1/models — model catalog including context length / pricing.
-// docs/auth.md §"LLM provider", docs/runtime.md (web fetch, not Bun.fetch).
 import { z } from 'zod';
 export const OpenRouterModelSchema = z
     .object({
@@ -37,4 +34,3 @@ export class OpenRouterClient {
         return OpenRouterModelsResponseSchema.parse(json).data;
     }
 }
-//# sourceMappingURL=client.js.map

package/dist/openrouter/model-limits.js

@@ -1,6 +1,3 @@
-// Exposes per-model limits (context window, pricing hints) used by the Compactor.
-// Cached per-run after first fetch — model catalog changes slowly.
-// docs/auth.md, src/compaction/compactor.ts
 export class ModelNotFound extends Error {
     modelId;
     name = 'ModelNotFound';
@@ -36,4 +33,3 @@ export class ModelLimitsRegistry {
         this.cache = next;
     }
 }
-//# sourceMappingURL=model-limits.js.map

package/dist/openrouter/server-tools.js

@@ -1,25 +1,9 @@
-// OpenRouter server tools — model-decides tools executed on OpenRouter's side.
-// These are NOT Vercel AI SDK function tools; they ride in `providerOptions.openrouter`
-// (or equivalent extraBody) so OpenRouter sees them in the request `tools[]` array verbatim.
-//
-// Refs:
-//   https://openrouter.ai/docs/guides/features/server-tools/web-search
-//   https://openrouter.ai/docs/guides/features/server-tools/web-fetch
-//
-// Web search → citations land as annotations[].url_citation on the assistant message,
-// plus usage.server_tool_use.web_search_requests for cost accounting. No round-trip.
-// Web fetch → standard tool_call round-trip with { url, title, content, status, retrieved_at }.
 export function webSearchTool(options = {}) {
     return { type: 'openrouter:web_search', parameters: options };
 }
-// Renamed from webFetchTool — the canonical webFetchTool is now the local variant in
-// src/tools/web-fetch.ts. This one is the explicit "delegate to OpenRouter" opt-in.
 export function webFetchServerTool(options = {}) {
     return { type: 'openrouter:web_fetch', parameters: options };
 }
-// Build the providerOptions.openrouter fragment to be merged into an AI SDK call.
-// Usage at the model handle layer (src/credentials/credentials.ts) — see Credentials.modelFor.
 export function providerOptionsWithServerTools(tools) {
     return { openrouter: { tools: [...tools] } };
 }
-//# sourceMappingURL=server-tools.js.map

package/dist/orchestrator/orchestrator.js

@@ -1,17 +1,3 @@
-// docs/architecture.md §Flow, docs/subagents.md §Composition
-// Top-level agent. Owns:
-//   - prompt composition (style payload + role prefix + rolling context)
-//   - routing between Planner / Worker / Reviewer (each exposed as a tool)
-//   - **PR creation** — title, body, commit message: docs say Worker opens the PR,
-//     but the Worker can be inconsistent on global-context narration. Orchestrator
-//     re-composes the commit message and opens the PR via GitHubClient, taking the
-//     Worker's draft as input. This is the reliability win: one place that knows
-//     the whole plan writes the PR-level prose.
-//
-// SDK references:
-//   docs/vendor/ai-sdk/chunk-04.md §"ToolLoopAgent"
-//   docs/vendor/ai-sdk/chunk-09.md §"Subagents" §"Controlling What the Model Sees"
-//   docs/vendor/ai-sdk/chunk-09.md §"Loop Control" — stopWhen: [stepCountIs(N), hasToolCall('done')]
 import { generateText, hasToolCall, Output, stepCountIs, ToolLoopAgent } from 'ai';
 import { ExecaError, execa } from 'execa';
 import { z } from 'zod';
@@ -36,8 +22,6 @@ export const defaultRunCmd = async (file, args, options) => {
         throw err;
     }
 };
-// Inlined per CLAUDE.md "no premature abstraction". Full system prompt is
-// `agentConfig.contents + ORCHESTRATOR_ROLE_PREFIX + rollingContext`.
 export const ORCHESTRATOR_ROLE_PREFIX = [
     '',
     '## Role: Orchestrator',
@@ -56,16 +40,11 @@ export const ORCHESTRATOR_ROLE_PREFIX = [
     '  - Be specific and terse. No marketing prose.',
     '  - Conventional commit subjects, ≤72 chars.',
 ].join('\n');
-// Structured-output schema for PR composition. Title cap reinforces conventional-commit
-// brevity; body is free-form markdown.
 const PrCompositionSchema = z.object({
     title: z.string().min(1).max(72),
     body: z.string().min(1),
 });
-// Fallback session cap when caller passes null / 0 / negative `maxSessions`.
 export const DEFAULT_MAX_STEPS = 50;
-// Resolve the agent step cap from caller-provided `maxSessions`. Falls back to the
-// default when the value is null, zero, or negative. Exported for unit testing.
 export function resolveMaxSteps(maxSessions) {
     return typeof maxSessions === 'number' && maxSessions > 0 ? maxSessions : DEFAULT_MAX_STEPS;
 }
@@ -111,8 +90,6 @@ export class Orchestrator {
             this.init.rollingContext,
         ].join('\n');
     }
-    // Re-write the Worker's draft commit message via the orchestrator model, then
-    // `git commit --amend` on the active worktree. Returns the new HEAD SHA.
     async finalizeCommit(group, delivery, worktreePath) {
         const refined = await this.refineCommitMessage(group, delivery);
         const runCmd = this.init.runCmd ?? defaultRunCmd;
@@ -126,8 +103,6 @@ export class Orchestrator {
         }
         return sha.stdout.trim();
     }
-    // Compose PR title + body via the orchestrator model, then open the PR through the github
-    // client. Falls back to `aitm/<group.id>` when `group.branch` is unset.
     async openPr(group, delivery, baseBranch) {
         const { title, body } = await this.composePr(group, delivery);
         const head = group.branch ?? `aitm/${group.id}`;
@@ -177,4 +152,3 @@ export class Orchestrator {
         ].join('\n');
     }
 }
-//# sourceMappingURL=orchestrator.js.map

package/dist/orchestrator/subagent-tools.js

@@ -1,16 +1,3 @@
-// Wrap each subagent as a tool consumable by the Orchestrator agent.
-// Pattern verbatim from docs/vendor/ai-sdk/chunk-09.md §"Subagents" and §"Controlling What the
-// Model Sees" — `toModelOutput` keeps the Orchestrator context lean by collapsing the full
-// subagent result to a one-line `<role> [<status>]: <summary>`.
-//
-// Note: AI SDK 6 names the field `toModelOutput` (the SDK-5 name was
-// `experimental_toToolResultContent`; the task brief uses the older spelling).
-//
-// Each wrapper:
-//   - inputSchema  — Zod schema; the Orchestrator's model fills it in per call
-//   - execute      — builds the subagent via its factory using `credentials.modelFor(role)` and
-//                    runs the matching runner; returns the full structured result
-//   - toModelOutput — collapses that result to a single status line for the Orchestrator
 import { tool } from 'ai';
 import { z } from 'zod';
 import { createPlannerAgent, PLANNER_SYSTEM_PREFIX, runPlanner, } from "../subagents/planner.js";
@@ -21,8 +8,6 @@ const plannerInputSchema = z.object({
     criteria: z.string().optional().describe('Optional acceptance criteria'),
     maxPrs: z.number().int().positive().describe('Cap on PR-group count'),
 });
-// Worker + Reviewer have all state bound in deps — the Orchestrator's model invokes them with
-// no arguments, signalling "process the currently-active group / review threads".
 const emptyInputSchema = z.object({});
 export function makePlannerTool(deps) {
     return tool({
@@ -85,13 +70,7 @@ export function makeReviewerTool(deps) {
         toModelOutput: ({ output }) => ({ type: 'text', value: summarizeReviewerResult(output) }),
     });
 }
-// Cap per-line summary length so a verbose subagent reply (long IDs, multiline draft
-// commit messages, error payloads) can't bloat the orchestrator's context. 220 chars
-// is enough for a status line + a few tens of chars of free text.
 const MAX_SUMMARY_CHARS = 220;
-// Show only the first N planner group IDs, then `+M more` — the count alone is what
-// matters to the orchestrator; the orchestrator can re-read the plan if it needs the
-// full ID list.
 const MAX_PREVIEW_IDS = 8;
 function compactOneLine(text, max = MAX_SUMMARY_CHARS) {
     return text.replace(/\s+/g, ' ').trim().slice(0, max);
@@ -130,4 +109,3 @@ function summarizeReviewerResult(r) {
         return compactOneLine(`reviewer [blocked]: ${r.reason}`);
     return compactOneLine(`reviewer [error]: ${r.error}`);
 }
-//# sourceMappingURL=subagent-tools.js.map

package/dist/orchestrator/system-prompts.js

@@ -1,5 +1,3 @@
-// Role system-prompt prefixes for each agent. Inlined per CLAUDE.md "no premature abstraction".
-// Appended after `agentConfig.contents` (house style) to form the full instructions string.
 export const ORCHESTRATOR_PREFIX = [
     '',
     '## Role: Orchestrator',
@@ -75,4 +73,3 @@ export const REVIEWER_PREFIX = [
     '  - Resolve the thread for "fixed" and "wontfix"; leave it open for "replied".',
     '  - Return JSON that matches the ThreadResolutionOutput schema exactly.',
 ].join('\n');
-//# sourceMappingURL=system-prompts.js.map

package/dist/plan/plan-graph.js

@@ -1,6 +1,3 @@
-// Dependency DAG over PR groups. Drives concurrent execution in src/loop/work-loop.ts.
-// Why a graph and not a list — docs/task-groups.md (extended): large goals split into
-// independent PRs that can run in parallel. A linear list serializes work needlessly.
 export class PlanGraph {
     groups;
     index;
@@ -9,12 +6,10 @@ export class PlanGraph {
         PlanGraph.validate(groups);
         this.index = new Map(groups.map((g) => [g.id, g]));
     }
-    // Groups currently ready to run: status === 'pending' AND all deps merged.
     ready() {
         return this.groups.filter((g) => g.status === 'pending' &&
             g.dependsOn.every((dep) => this.index.get(dep)?.status === 'merged'));
     }
-    // Groups blocked on at least one unmerged dep.
     blocked() {
         return this.groups.filter((g) => g.status === 'pending' &&
             g.dependsOn.some((dep) => this.index.get(dep)?.status !== 'merged'));
@@ -22,12 +17,9 @@ export class PlanGraph {
     byId(id) {
         return this.index.get(id);
     }
-    // True when every group is in a terminal state (merged or blocked).
     isComplete() {
         return this.groups.every((g) => g.status === 'merged' || g.status === 'blocked');
     }
-    // Static: detect cycles + dangling deps at plan-acceptance time.
-    // DFS coloring — white=unvisited, gray=on stack, black=fully explored.
     static validate(groups) {
         const ids = new Set();
         for (const g of groups) {
@@ -66,4 +58,3 @@ export class PlanGraph {
             visit(g.id, []);
     }
 }
-//# sourceMappingURL=plan-graph.js.map

package/dist/plan/schema.js

@@ -1,19 +1,12 @@
-// Plan-time output of Planner subagent — see docs/subagents.md §Roster (Planner row).
-// PrGroup is persisted via src/state/schema.ts; the plan schema below is what
-// Planner returns to the Orchestrator before that persistence step.
 import { z } from 'zod';
 export const PlannedTaskSchema = z.object({
     description: z.string(),
-    // Optional file hint helps Worker plan its parallel file-edit fanout.
-    // See docs/vendor/ai-sdk/chunk-09.md §"Orchestrator-Worker" — Worker uses this
-    // to emit a file manifest, then Promise.all over per-file editor subagents.
     filesHint: z.array(z.string()).optional(),
 });
 export const PlannedGroupSchema = z.object({
     id: z.string(),
     title: z.string(),
     tasks: z.array(PlannedTaskSchema),
-    // Group ids that must merge before this group runs. Empty = root of DAG.
     dependsOn: z.array(z.string()).default([]),
 });
 export const PlanSchema = z.object({
@@ -21,4 +14,3 @@ export const PlanSchema = z.object({
     criteria: z.string().optional(),
     groups: z.array(PlannedGroupSchema),
 });
-//# sourceMappingURL=schema.js.map