@developerz.ai/aitm 0.0.2 → 0.0.4

package/dist/github/github-client.js

@@ -1,5 +1,3 @@
-// docs/github-integration.md, docs/auth.md §"GitHub"
-// Only module allowed to shell out to gh. Uses execa (docs/runtime.md — Bun.$ forbidden in src/).
 import { ExecaError, execa } from 'execa';
 import { z } from 'zod';
 import { CiFailed, MergeConflict } from "./errors.js";
@@ -34,8 +32,6 @@ export class GitHubClient {
     cwd;
     runCmd;
     sleep;
-    // Capability matrix — docs/github-integration.md §"Capabilities".
-    // Backoff — docs/github-integration.md §"Rate limits" (1s, doubling, 60s cap).
     constructor(cwd, runCmd = defaultRunCmd, sleep = defaultSleep) {
         this.cwd = cwd;
         this.runCmd = runCmd;
@@ -94,9 +90,6 @@ export class GitHubClient {
             args.push('--draft');
         for (const label of labels)
             args.push('--label', label);
-        // `gh pr create --label X` fails if X doesn't exist yet — which it won't on a fresh repo the
-        // first time aitm opens a PR. Ensure each label exists first (idempotent via --force; the
-        // result is intentionally not checked so a labels-permission gap doesn't block PR creation).
         for (const label of labels) {
             await this.runCmd('gh', ['label', 'create', label, '--force'], { cwd: this.cwd });
         }
@@ -104,7 +97,6 @@ export class GitHubClient {
         if (r.exitCode !== 0) {
             throw new Error(`gh pr create failed: ${r.stderr.trim() || r.stdout.trim()}`);
         }
-        // gh prints the PR URL to stdout; we re-fetch to get the full typed shape.
         const pr = await this.getPrForBranch(input.head);
         if (!pr) {
             throw new Error(`gh pr create succeeded for ${input.head} but PR lookup returned null (stdout: ${r.stdout.trim()})`);
@@ -115,8 +107,6 @@ export class GitHubClient {
         let delay = CHECKS_INITIAL_DELAY_MS;
         while (true) {
             const r = await this.runCmd('gh', ['pr', 'checks', String(pr), '--json', 'bucket,name,state'], { cwd: this.cwd });
-            // `gh pr checks` exits 8 when any check fails but still emits JSON on stdout. Treat any
-            // exit code as "command ran" if stdout parses; otherwise propagate the failure.
             const rows = tryParseChecks(r.stdout);
             if (!rows) {
                 throw new Error(`gh pr checks failed: ${r.stderr.trim() || r.stdout.trim()}`);
@@ -131,10 +121,69 @@ export class GitHubClient {
             delay = Math.min(delay * 2, CHECKS_MAX_DELAY_MS);
         }
     }
+    async getFailedCiLogs(pr) {
+        const head = await this.runCmd('gh', ['pr', 'view', String(pr), '--json', 'headRefName,headRefOid'], { cwd: this.cwd });
+        if (head.exitCode !== 0)
+            return [];
+        const parsedHead = safeJson(head.stdout);
+        const branch = isRecord(parsedHead) ? parsedHead.headRefName : undefined;
+        const sha = isRecord(parsedHead) ? parsedHead.headRefOid : undefined;
+        if (typeof branch !== 'string')
+            return [];
+        const runIds = await this.failedRunIds(branch, typeof sha === 'string' ? sha : undefined);
+        if (runIds.length === 0)
+            return [];
+        const { owner, name } = await this.repoMeta();
+        const out = [];
+        for (const runId of runIds) {
+            for (const job of await this.failedJobs(owner, name, runId)) {
+                const logs = await this.jobLogs(owner, name, job.id);
+                if (logs.trim())
+                    out.push({ check: job.name, logs });
+            }
+        }
+        return out;
+    }
+    async failedRunIds(branch, sha) {
+        const r = await this.runCmd('gh', [
+            'run',
+            'list',
+            '--branch',
+            branch,
+            '--json',
+            'databaseId,headSha,conclusion',
+            '--limit',
+            '30',
+        ], { cwd: this.cwd });
+        if (r.exitCode !== 0)
+            return [];
+        const parsed = safeJson(r.stdout);
+        const rows = WorkflowRunsSchema.safeParse(parsed);
+        if (!rows.success)
+            return [];
+        const failed = rows.data.filter((run) => FAILED_CONCLUSIONS.has(run.conclusion ?? ''));
+        const forSha = sha ? failed.filter((run) => run.headSha === sha) : [];
+        return (forSha.length > 0 ? forSha : failed).map((run) => run.databaseId);
+    }
+    async failedJobs(owner, name, runId) {
+        const r = await this.runCmd('gh', ['api', `repos/${owner}/${name}/actions/runs/${runId}/jobs`], { cwd: this.cwd });
+        if (r.exitCode !== 0)
+            return [];
+        const parsed = JobsResponseSchema.safeParse(safeJson(r.stdout));
+        if (!parsed.success)
+            return [];
+        return parsed.data.jobs
+            .filter((job) => FAILED_CONCLUSIONS.has(job.conclusion ?? ''))
+            .map((job) => ({ id: job.id, name: job.name }));
+    }
+    async jobLogs(owner, name, jobId) {
+        const r = await this.runCmd('gh', ['api', `repos/${owner}/${name}/actions/jobs/${jobId}/logs`], {
+            cwd: this.cwd,
+        });
+        return r.exitCode === 0 ? r.stdout : '';
+    }
     async listUnresolvedThreads(pr) {
         const { owner, name } = await this.repoMeta();
-        // GitHub caps connections at 100 nodes per page — page through threads and
-        // their comments to avoid silently dropping data on large PRs.
         const threads = await this.paginateReviewThreads(owner, name, pr);
         const unresolved = threads.filter((t) => !t.isResolved);
         for (const thread of unresolved) {
@@ -256,19 +305,38 @@ export class GitHubClient {
         const r = await this.runCmd('gh', ['auth', 'status', '--hostname', 'github.com'], {
             cwd: this.cwd,
         });
-        // `gh auth status` writes its human-readable summary to stderr; stdout is usually empty.
         const text = `${r.stderr}\n${r.stdout}`;
         const scopes = parseScopes(text);
         return { ok: r.exitCode === 0, scopes };
     }
 }
-// `gh pr view` exits non-zero with messages like:
-//   "no pull requests found for branch <name>"
-//   "GraphQL: Could not resolve to a PullRequest..."
+const FAILED_CONCLUSIONS = new Set(['failure', 'timed_out', 'startup_failure', 'action_required']);
+const WorkflowRunsSchema = z.array(z.object({
+    databaseId: z.number(),
+    headSha: z.string().optional(),
+    conclusion: z.string().nullable().optional(),
+}));
+const JobsResponseSchema = z.object({
+    jobs: z.array(z.object({
+        id: z.number(),
+        name: z.string(),
+        conclusion: z.string().nullable().optional(),
+    })),
+});
+function safeJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(v) {
+    return typeof v === 'object' && v !== null;
+}
 function isPrNotFoundStderr(stderr) {
     return /no pull requests? found|could not resolve to a pullrequest|no open pull requests/i.test(stderr);
 }
-// `gh auth status` line shape: "  - Token scopes: 'repo', 'workflow', 'read:org'"
 function parseScopes(text) {
     const match = text.match(/Token scopes:\s*([^\n]+)/i);
     if (!match?.[1])
@@ -281,8 +349,6 @@ function parseScopes(text) {
     }
     return scopes;
 }
-// Wire shapes for `gh pr checks --json bucket,name,state`. The bucket field is the gh CLI's
-// normalized status across providers (Actions, Circle, etc.); CheckStatus is our domain.
 const CheckBucketSchema = z.enum(['pass', 'fail', 'pending', 'cancel', 'skipping']);
 const CheckRowSchema = z.object({
     bucket: CheckBucketSchema,
@@ -331,7 +397,6 @@ function summarizeFailures(rows) {
         return 'unknown';
     return bad.map((r) => `${r.name}=${r.bucket}`).join(', ');
 }
-// `gh repo view --json owner,name` returns `{ owner: { login }, name }`.
 const RepoOwnerNameSchema = z.object({
     owner: z.object({ login: z.string() }),
     name: z.string(),
@@ -414,4 +479,3 @@ const GqlThreadCommentsResponseSchema = z.object({
         }),
     }),
 });
-//# sourceMappingURL=github-client.js.map

package/dist/github/schema.js

@@ -1,4 +1,3 @@
-// docs/github-integration.md — JSON shapes returned by `gh` (parsed through Zod).
 import { z } from 'zod';
 export const PrStateSchema = z.enum(['OPEN', 'CLOSED', 'MERGED']);
 export const PullRequestSchema = z.object({
@@ -20,4 +19,3 @@ export const ReviewThreadSchema = z.object({
     path: z.string().nullable(),
     comments: z.array(ReviewCommentSchema),
 });
-//# sourceMappingURL=schema.js.map

package/dist/index.js

@@ -1,4 +1,3 @@
-// Public surface. Keep this list narrow — most internals are not stable yet.
 export { AgentConfigDetector } from "./agent-config/agent-config-detector.js";
 export { main } from "./cli/cli.js";
 export { Compactor } from "./compaction/compactor.js";
@@ -19,4 +18,3 @@ export { datetimeTool } from "./tools/datetime.js";
 export { DEFAULT_IMPERSONATE_TARGETS, fetchHtmlTool, isFetchHtmlAvailable, } from "./tools/fetch-html.js";
 export { DEFAULT_STEALTH_HEADERS, webFetchTool } from "./tools/web-fetch.js";
 export { WorktreePool } from "./workspace/worktree-pool.js";
-//# sourceMappingURL=index.js.map

package/dist/logger/logger.js

@@ -1,6 +1,3 @@
-// docs/state.md (logs dir), docs/auth.md §Security (redaction policy)
-// Structured logs to .ai-task-master/logs/run-{ts}.log; user-facing status to stdout.
-// Redact /key|token|secret|authorization/i before serializing.
 import { appendFile, mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 const LEVEL_RANK = {
@@ -42,7 +39,6 @@ export class Logger {
         const out = redactValue(fields);
         return out;
     }
-    // Flush pending file writes — tests and shutdown hooks await this.
     async flush() {
         await this.writeTail;
         if (this.lastError) {
@@ -86,7 +82,6 @@ export class Logger {
                 await appendFile(file, line);
             }
             catch (err) {
-                // Surface failures via flush() but never crash callers.
                 this.lastError = err instanceof Error ? err : new Error(String(err));
             }
         });
@@ -120,4 +115,3 @@ function redactValue(value, seen = new WeakSet()) {
 function bigintReplacer(_key, value) {
     return typeof value === 'bigint' ? value.toString() : value;
 }
-//# sourceMappingURL=logger.js.map

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

@@ -1,19 +1,5 @@
-// 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 { bashTool, composeSystemPrompt, editFileTool, globTool, grepTool, multiBashTool, multiEditTool, readFileTool, writeFileTool, } from '@developerz.ai/ai-claude-compat';
 import { tool } from 'ai';
 import { execa } from 'execa';
 import { z } from 'zod';
@@ -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 }),
@@ -38,9 +20,9 @@ export function localEditTools(cwd) {
         grep: grepTool({ cwd }),
         glob: globTool({ cwd }),
         bash: bashTool({ cwd }),
+        multiBash: multiBashTool({ cwd }),
     };
 }
-// Read-only subset for the Planner — survey the repo without write/edit/bash.
 export function localReadTools(cwd) {
     return {
         readFile: readFileTool({ cwd }),
@@ -50,8 +32,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 +44,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 +63,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 +75,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 +103,6 @@ export async function runLoopAdapter(input, seams = {}) {
         }
     }
 }
-// ---- Plan ------------------------------------------------------------------
 export function planToPrGroups(plan) {
     return plan.groups.map((g) => ({
         id: g.id,
@@ -159,7 +133,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 +145,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'),
@@ -186,20 +157,17 @@ function defaultMakeOrchestrator(ctx) {
                 baseBranch,
                 styleContents: style,
                 rollingContext,
+                ...(input.resolved.formatCommand ? { formatCommand: input.resolved.formatCommand } : {}),
             });
         },
         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 +183,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 {
@@ -229,15 +193,12 @@ function resolveWorkerTools(set, cwd) {
         grep: set.grep ?? local.grep,
         glob: set.glob ?? local.glob,
         bash: set.bash ?? local.bash,
+        multiBash: set.multiBash ?? local.multiBash,
     };
 }
 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 +207,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 +226,3 @@ export function githubThreadTool(github) {
         },
     });
 }
-//# sourceMappingURL=run-loop-adapter.js.map

package/dist/loop/take-over-flow.d.ts

@@ -11,6 +11,18 @@ export type TakeOverGithub = {
     mergePr(pr: number, method: MergeMethod): Promise<void>;
     replyToThread(threadId: string, body: string): Promise<void>;
     resolveThread(threadId: string): Promise<void>;
+    getFailedCiLogs?(pr: number): Promise<Array<{
+        check: string;
+        logs: string;
+    }>>;
+};
+export type PrContextPort = {
+    clear(pr: number): Promise<void>;
+    saveCiFailures(pr: number, failures: ReadonlyArray<{
+        check: string;
+        logs: string;
+    }>): Promise<string | null>;
+    saveComments(pr: number, threads: readonly ReviewThread[]): Promise<string | null>;
 };
 export type TakeOverSubagents = {
     reviewerModel: LanguageModel;
@@ -18,6 +30,7 @@ export type TakeOverSubagents = {
     workerModel: LanguageModel;
     workerTools: WorkerTools;
     styleContents: string;
+    formatCommand?: string;
     runReviewerOverride?: (input: {
         pr: number;
         threads: ReviewThread[];
@@ -38,6 +51,7 @@ export type TakeOverFlowInput = {
     baseBranch: string;
     github: TakeOverGithub;
     subagents: TakeOverSubagents;
+    prContext?: PrContextPort;
     mergeMethod: MergeMethod;
     maxIterations?: number;
     cooldownMs?: number;

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,26 +9,34 @@ 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 ciLogsDir = null;
+        if (input.prContext) {
+            await input.prContext.clear(input.pr);
+            if ((ciStatus === 'failure' || ciStatus === 'cancelled') && input.github.getFailedCiLogs) {
+                const failures = await input.github.getFailedCiLogs(input.pr);
+                ciLogsDir = await input.prContext.saveCiFailures(input.pr, failures);
+                log?.info('take-over: downloaded ci logs', {
+                    pr: input.pr,
+                    checks: failures.length,
+                    dir: ciLogsDir,
+                });
+            }
+            if (threads.length > 0)
+                await input.prContext.saveComments(input.pr, threads);
+        }
         let pushedSomething = false;
         if (ciStatus === 'failure' || ciStatus === 'cancelled') {
-            const fixed = await runWorkerCiFix(input);
+            const fixed = await runWorkerCiFix(input, ciLogsDir);
             if (fixed.kind === 'blocked') {
                 return { kind: 'blocked', reason: fixed.reason, iterations: iteration };
             }
@@ -69,7 +57,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 +65,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 +88,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,17 +119,14 @@ 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) {
+async function runWorkerCiFix(input, ciLogsDir) {
+    const readTask = ciLogsDir
+        ? `Read the downloaded CI failure logs in ${ciLogsDir} (one file per failed check, full untruncated logs) with your shell/read tools, then fix every failure those logs report.`
+        : `Read the CI logs (via gh) and fix every failing check on PR #${input.pr}.`;
     const group = {
         id: `takeover-ci-${input.pr}`,
         title: `Fix CI failures on PR #${input.pr}`,
-        tasks: [
-            `Read the CI logs (via gh) and fix every failing check on PR #${input.pr}.`,
-            'Run the project test/lint commands locally to verify, then stage fixes.',
-        ],
+        tasks: [readTask, 'Run the project test/lint commands locally to verify, then stage fixes.'],
         dependsOn: [],
         branch: null,
         pr: input.pr,
@@ -173,6 +152,7 @@ async function runWorkerCiFix(input) {
         baseBranch: input.baseBranch,
         styleContents: input.subagents.styleContents,
         rollingContext: '',
+        ...(input.subagents.formatCommand ? { formatCommand: input.subagents.formatCommand } : {}),
     });
 }
 function defaultSleep(ms) {
@@ -180,4 +160,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