@developerz.ai/aitm 0.0.2 → 0.0.4

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

package/dist/state/pr-context-store.d.ts

@@ -0,0 +1,20 @@
+import type { ReviewThread } from '../github/schema.ts';
+export type CiFailure = {
+    check: string;
+    logs: string;
+};
+export type PrContextSummary = {
+    prDir: string;
+    ciDir: string | null;
+    commentsDir: string | null;
+    ciCount: number;
+    commentCount: number;
+};
+export declare class PrContextStore {
+    private readonly stateDir;
+    constructor(stateDir: string);
+    prDir(pr: number): string;
+    clear(pr: number): Promise<void>;
+    saveCiFailures(pr: number, failures: readonly CiFailure[]): Promise<string | null>;
+    saveComments(pr: number, threads: readonly ReviewThread[]): Promise<string | null>;
+}

package/dist/state/pr-context-store.js

@@ -0,0 +1,60 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export class PrContextStore {
+    stateDir;
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+    }
+    prDir(pr) {
+        return join(this.stateDir, 'debugging', 'pr', String(pr));
+    }
+    async clear(pr) {
+        await rm(this.prDir(pr), { recursive: true, force: true });
+    }
+    async saveCiFailures(pr, failures) {
+        if (failures.length === 0)
+            return null;
+        const ciDir = join(this.prDir(pr), 'ci');
+        await mkdir(ciDir, { recursive: true });
+        const used = new Map();
+        for (const { check, logs } of failures) {
+            const base = sanitize(check);
+            const n = used.get(base) ?? 0;
+            used.set(base, n + 1);
+            const file = n === 0 ? `failed_${base}.txt` : `failed_${base}_${n}.txt`;
+            const header = `CI check failed: ${check}\nPR: #${pr}\n${'='.repeat(60)}\n\n`;
+            await writeFile(join(ciDir, file), header + logs);
+        }
+        await writeFile(join(ciDir, 'summary.txt'), [
+            `PR #${pr} — ${failures.length} failed check(s):`,
+            ...failures.map((f) => `  - ${f.check}`),
+        ].join('\n'));
+        return ciDir;
+    }
+    async saveComments(pr, threads) {
+        if (threads.length === 0)
+            return null;
+        const commentsDir = join(this.prDir(pr), 'comments');
+        await mkdir(commentsDir, { recursive: true });
+        let i = 0;
+        for (const thread of threads) {
+            i += 1;
+            const path = thread.path ?? 'general';
+            const body = thread.comments
+                .map((c) => `@${c.author}:\n${c.body}`)
+                .join(`\n${'-'.repeat(40)}\n`);
+            const header = `Review thread on ${path} (thread ${thread.id})\nPR: #${pr}\n${'='.repeat(60)}\n\n`;
+            await writeFile(join(commentsDir, `${String(i).padStart(3, '0')}_${sanitize(path)}.txt`), header + body);
+        }
+        const paths = [...new Set(threads.map((t) => t.path ?? 'general'))].sort();
+        await writeFile(join(commentsDir, 'summary.txt'), [
+            `PR #${pr} — ${threads.length} unresolved review thread(s).`,
+            'Files with comments:',
+            ...paths.map((p) => `  - ${p}`),
+        ].join('\n'));
+        return commentsDir;
+    }
+}
+function sanitize(s) {
+    return s.replace(/[^a-zA-Z0-9._-]+/g, '_').replace(/^_+|_+$/g, '') || 'unnamed';
+}

package/dist/state/schema.js

@@ -1,5 +1,3 @@
-// docs/state.md §"state.json schema" and §"PrGroup sub-schema"
-// Source of truth for run-state shape. Extended with PrGroup.dependsOn to support DAG planning.
 import { z } from 'zod';
 export const PrGroupStatusSchema = z.enum([
     'pending',
@@ -12,8 +10,6 @@ export const PrGroupSchema = z.object({
     id: z.string(),
     title: z.string(),
     tasks: z.array(z.string()),
-    // Group ids that must be merged before this group is runnable.
-    // Empty array means the group is in the initial ready set. See src/plan/plan-graph.ts.
     dependsOn: z.array(z.string()).default([]),
     branch: z.string().nullable(),
     pr: z.number().int().positive().nullable(),
@@ -50,4 +46,3 @@ export const RunStateSchema = z.object({
         concurrency: z.number().int().positive(),
     }),
 });
-//# sourceMappingURL=schema.js.map

package/dist/state/state-store.js

@@ -1,5 +1,3 @@
-// docs/state.md
-// Only module that reads or writes .ai-task-master/. Atomic writes via temp file + fsync + rename.
 import { appendFile, mkdir, readdir, readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { ZodError } from 'zod';
@@ -14,9 +12,6 @@ const CONTEXT_FILE = 'context.md';
 const LOGS_DIR = 'logs';
 export class StateStore {
     stateDir;
-    // Chained promise serializes concurrent update() calls so they observe linear semantics.
-    // Each caller awaits the prior in-flight update before its read → mutate → write runs,
-    // preventing lost updates when callers race via Promise.all.
     updateChain = Promise.resolve();
     constructor(stateDir) {
         this.stateDir = stateDir;
@@ -49,8 +44,6 @@ export class StateStore {
             await atomicWrite(this.path(STATE_FILE), `${JSON.stringify(validated, null, 2)}\n`);
             return validated;
         });
-        // Swallow rejection on the chain so a failed update doesn't poison subsequent callers.
-        // The original `next` promise still rejects for the caller that owns this update.
         this.updateChain = next.catch(() => undefined);
         return next;
     }
@@ -126,4 +119,3 @@ function isNotFound(err) {
 function formatZodError(err) {
     return err.issues.map((i) => `${i.path.join('.') || '<root>'}: ${i.message}`).join('; ');
 }
-//# sourceMappingURL=state-store.js.map

package/dist/subagents/factory.js

@@ -1,10 +1 @@
-// docs/subagents.md §"SRP + tested" — every subagent is a pure factory:
-//   (model, tools, systemPrompt) -> Agent
-// SDK reference: docs/vendor/ai-sdk/chunk-04.md §"ToolLoopAgent" (note: CLAUDE.md
-// still says experimental_Agent — that is the legacy AI SDK 5 name; v6 ships ToolLoopAgent).
-//
-// The ToolLoopAgent wrapper (`createSubagent`) and the system-prompt composer
-// (`composeSystemPrompt`) now live in @developerz.ai/ai-claude-compat; the concrete factories
-// (planner.ts/worker.ts/reviewer.ts) call createSubagent with their own tools + output type.
 export {};
-//# sourceMappingURL=factory.js.map

package/dist/subagents/planner.js

@@ -1,12 +1,6 @@
-// docs/subagents.md (Planner row), docs/task-groups.md, docs/agent-config-detection.md
-// Goal + repo survey → ordered PR groups (DAG) with Zod-validated output.
-// SDK reference: docs/vendor/ai-sdk/chunk-09.md §"Subagents" + chunk-05.md §"Generating Structured Data".
 import { createSubagent } from '@developerz.ai/ai-claude-compat';
 import { Output } from 'ai';
 import { PlanSchema } from "../plan/schema.js";
-// Inlined per CLAUDE.md "no premature abstraction". The Orchestrator builds the
-// caller-side system prompt as `styleContents + PLANNER_SYSTEM_PREFIX` so the
-// agent inherits the repo's house style alongside its role.
 export const PLANNER_SYSTEM_PREFIX = [
     '',
     'You are the Planner subagent. You receive a goal and an optional acceptance criteria.',
@@ -60,8 +54,6 @@ function buildUserPrompt(input) {
     lines.push('Survey the repo with the read-only tools, then emit the Plan JSON.');
     return lines.join('\n');
 }
-// Truncate to maxPrs groups; fold any overflow into a single remainder task on
-// the last kept group so no work is silently dropped.
 function capGroups(plan, maxPrs) {
     if (plan.groups.length <= maxPrs)
         return plan;
@@ -80,4 +72,3 @@ function capGroups(plan, maxPrs) {
 function summarizeGroup(g) {
     return `${g.id} (${g.tasks.length} tasks)`;
 }
-//# sourceMappingURL=planner.js.map

package/dist/subagents/reviewer.js

@@ -1,26 +1,6 @@
-// docs/subagents.md (Reviewer row), docs/commands/merge-pr.md
-// Input: unresolved review threads. Output: per-thread resolution (reply / push fix / mark stale).
-// Pushes go through Worker tools (FS write, bash); thread ops via a `github` tool that wraps a
-// subset of GitHubClient (replyToThread / resolveThread).
-//
-// Strategy:
-//   - One agent.generate call per thread, scoped to that thread's conversation.
-//   - Agent emits a structured ThreadResolutionOutput JSON describing the chosen outcome.
-//   - For "fixed", the runner — not the agent — performs the git commit so commit shas are
-//     deterministic and observable (worker pattern).
-//
-// SDK references:
-//   chunk-04.md §"ToolLoopAgent"
-//   chunk-05.md §"Generating Structured Data"
-//   chunk-09.md §"Subagents"
 import { createSubagent } from '@developerz.ai/ai-claude-compat';
 import { Output } from 'ai';
 import { z } from 'zod';
-// Per-thread structured output emitted by the model. A FLAT object (not a discriminatedUnion):
-// a discriminated union compiles to JSON-Schema `oneOf`, which several OpenRouter-routed
-// providers reject for structured output (`output_config.format.schema: Schema type 'oneOf' is
-// not supported` — seen on Anthropic, which is also aitm's default tier). `kind` selects the
-// outcome; `commitMessage` is expected for "fixed" and `reason` for "wontfix".
 export const ThreadResolutionOutputSchema = z.object({
     kind: z.enum(['fixed', 'replied', 'wontfix']),
     commitMessage: z.string().optional(),
@@ -48,8 +28,6 @@ export const REVIEWER_SYSTEM_PREFIX = [
     '- Resolve the thread for "fixed" and "wontfix" outcomes; "replied" leaves it open.',
     '- Return JSON that matches the ThreadResolutionOutput schema exactly.',
 ].join('\n');
-// Module-private link from agent to its init so runReviewer can drive bash commits with the
-// same tools without exposing them on the public agent surface (worker uses the same pattern).
 const reviewerInitRegistry = new WeakMap();
 export function createReviewerAgent(init) {
     const agent = createSubagent({
@@ -92,7 +70,6 @@ async function resolveOneThread(agent, init, input, thread) {
     const out = result.experimental_output;
     switch (out.kind) {
         case 'fixed': {
-            // commitMessage is optional on the flat schema; fall back to a generic subject.
             const message = out.commitMessage?.trim() || `fix: address review thread ${thread.id}`;
             const commitSha = await commitFix(init.tools.bash, input.worktreePath, message);
             return { threadId: thread.id, kind: 'fixed', commitSha };
@@ -152,8 +129,6 @@ async function execBash(exec, command) {
 function isAsyncIterable(v) {
     return v !== null && typeof v === 'object' && Symbol.asyncIterator in v;
 }
-// POSIX shell-quote: wrap in single quotes, escape embedded single quotes.
 function shQuote(s) {
     return `'${s.replace(/'/g, "'\\''")}'`;
 }
-//# sourceMappingURL=reviewer.js.map

package/dist/subagents/worker.d.ts

@@ -1,4 +1,4 @@
-import type { BashInput, BashOutput, EditFileInput, EditFileOutput, GlobInput, GlobOutput, GrepInput, GrepOutput, MultiEditInput, MultiEditOutput, ReadFileInput, ReadFileOutput, WriteFileInput, WriteFileOutput } from '@developerz.ai/ai-claude-compat';
+import type { BashInput, BashOutput, EditFileInput, EditFileOutput, GlobInput, GlobOutput, GrepInput, GrepOutput, MultiBashInput, MultiBashOutput, MultiEditInput, MultiEditOutput, ReadFileInput, ReadFileOutput, WriteFileInput, WriteFileOutput } from '@developerz.ai/ai-claude-compat';
 import { type DeepPartial, Output, type Tool, type ToolLoopAgent } from 'ai';
 import { z } from 'zod';
 import type { PrGroup } from '../state/schema.ts';
@@ -11,6 +11,7 @@ export type WorkerTools = {
     grep: Tool<GrepInput, GrepOutput>;
     glob: Tool<GlobInput, GlobOutput>;
     bash: Tool<BashInput, BashOutput>;
+    multiBash: Tool<MultiBashInput, MultiBashOutput>;
 };
 export declare const FileManifestEntrySchema: z.ZodObject<{
     path: z.ZodString;
@@ -43,6 +44,7 @@ export type WorkerInput = {
     baseBranch: string;
     styleContents: string;
     rollingContext: string;
+    formatCommand?: string;
 };
 export type FileChange = {
     path: string;

package/dist/subagents/worker.js

@@ -1,27 +1,6 @@
-// docs/subagents.md (Worker row), docs/task-groups.md, docs/commands/start.md
-// One PR group: produce file changes + commits on a dedicated branch. Does NOT open the PR
-// and does NOT finalize the commit message — those belong to the Orchestrator (more reliable
-// at composing global-context narration: PR title, body, squash commit message).
-//
-// Strategy for *really big PRs* (the explicit design goal) — two layers of parallelism:
-//
-//   Layer A (outer, across files): plan a file manifest via Output.object() that lists every
-//   file to create/modify/delete (docs/vendor/ai-sdk/chunk-09.md §"Orchestrator-Worker"),
-//   then Promise.all over per-file editor sub-subagents.
-//
-//   Layer B (inner, within one step): each editor enables `parallelToolCalls: true` (default
-//   in the SDK — chunk-02.md §"parallelToolCalls") so the model can issue multiple readFile /
-//   writeFile tool calls in a single step and the runtime executes them concurrently.
-//
-// SDK references:
-//   chunk-09.md §"Orchestrator-Worker" (manifest + per-file workers)
-//   chunk-09.md §"Subagents" §"Controlling What the Model Sees" (toModelOutput one-line summary)
-//   chunk-04.md §"ToolLoopAgent" (agent class)
-//   chunk-02.md §"Tool Calling" (parallelToolCalls)
 import { composeSystemPrompt, createSubagent } from '@developerz.ai/ai-claude-compat';
 import { generateText, Output, stepCountIs, } from 'ai';
 import { z } from 'zod';
-// File manifest — Phase 1 structured output. Each entry drives one editor in Phase 2.
 export const FileManifestEntrySchema = z.object({
     path: z.string().min(1),
     kind: z.enum(['create', 'modify', 'delete']),
@@ -49,8 +28,6 @@ export const WORKER_SYSTEM_PREFIX = [
     '- draftCommitMessage is a hint to the Orchestrator; keep the subject under 72 chars.',
     '- Return the FileManifest JSON exactly matching the schema.',
 ].join('\n');
-// Editor subagent prompt — applied to every per-file fanout. Kept here so the Worker
-// owns the contract its editors run under.
 const EDITOR_SYSTEM_PREFIX = [
     '',
     'You are a per-file editor subagent. You receive one file path and a purpose.',
@@ -59,13 +36,14 @@ const EDITOR_SYSTEM_PREFIX = [
     '  replacement) or `multiEdit` (several replacements applied atomically). Use `writeFile` only',
     '  for a full rewrite.',
     '- To DELETE a file, use `bash` with `rm -f <path>`.',
+    '- For a dependent sequence of shell steps (e.g. `mkdir … && generate && test`), prefer',
+    '  `multiBash` with an ordered `commands` array — it stops at the first failure, so you',
+    '  see exactly which step broke without chaining `&&` by hand.',
     'You may issue multiple tool calls in parallel.',
     '',
     "IMPORTANT: your final assistant message is returned to the outer Worker as this file's",
     'summary. Keep it to one line, present-tense, and specific.',
 ].join('\n');
-// Module-private link from a Worker agent back to its init, so runWorker can spawn editor
-// sub-agents with the same model + tool handles without exposing them on the public surface.
 const workerInitRegistry = new WeakMap();
 export function createWorkerAgent(init) {
     const agent = createSubagent({
@@ -90,7 +68,10 @@ export async function runWorker(agent, input) {
     try {
         const manifest = await planManifest(agent, input);
         if (manifest.files.length === 0) {
-            return { kind: 'blocked', reason: 'worker produced an empty file manifest' };
+            return {
+                kind: 'blocked',
+                reason: 'The Worker returned an empty file manifest — the configured coding model produced no files to change for this PR group. This usually means the model is not capable enough to plan the work; try a more capable coding model (set `models.coding` in .ai-task-master/config.json or pass a stronger --model).',
+            };
         }
         const changes = await Promise.all(manifest.files.map((file) => runEditor(init, file, input)));
         await commitOnBranch(init.tools.bash, input, branch, manifest.draftCommitMessage);
@@ -158,6 +139,9 @@ async function commitOnBranch(bash, input, branch, message) {
     }
     const wt = shQuote(input.worktreePath);
     await runBash(exec, `git -C ${wt} checkout -B ${shQuote(branch)}`);
+    if (input.formatCommand) {
+        await runBash(exec, `cd ${wt} && ${input.formatCommand}`);
+    }
     await runBash(exec, `git -C ${wt} add -A`);
     await runBash(exec, `git -C ${wt} commit -m ${shQuote(message)}`);
 }
@@ -173,8 +157,6 @@ async function runBash(exec, command) {
 function isAsyncIterable(v) {
     return v !== null && typeof v === 'object' && Symbol.asyncIterator in v;
 }
-// POSIX shell-quote: wrap in single quotes, escape embedded single quotes.
 function shQuote(s) {
     return `'${s.replace(/'/g, "'\\''")}'`;
 }
-//# sourceMappingURL=worker.js.map

package/dist/testing/temp-repo.js

@@ -1,6 +1,3 @@
-// Shared test helper: spin up a throwaway git repo in a tempdir.
-// Used by *.test.ts (unit) for filesystem-touching cases AND by test/integration/*.test.ts.
-// docs/runtime.md §Testing — integration tests run against real temp git repos.
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -18,4 +15,3 @@ export async function makeTempRepo(opts) {
     };
     return { path, cleanup };
 }
-//# sourceMappingURL=temp-repo.js.map