@developerz.ai/aitm 0.0.3 → 0.0.5

package/dist/config/profiles.js

@@ -0,0 +1,224 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ZodError } from 'zod';
+import { atomicWrite } from "../fs/atomic-write.js";
+import { PROVIDER_PRESETS } from "./provider-presets.js";
+import { ConfigFileSchema } from "./schema.js";
+const GLOBAL_FILE = '.aitm.json';
+export class ProfileManager {
+    homeDir;
+    constructor(homeDir) {
+        this.homeDir = homeDir;
+    }
+    async list() {
+        const validated = await this.readValidated();
+        return {
+            activeProfile: validated.activeProfile,
+            profiles: validated.profiles ?? {},
+        };
+    }
+    async use(name) {
+        const file = await this.readRaw();
+        const profiles = asObject(file.profiles);
+        if (!(name in profiles)) {
+            throw new Error(unknownProfileMessage(name, Object.keys(profiles)));
+        }
+        file.activeProfile = name;
+        await this.persist(file);
+    }
+    async add(name, input = {}) {
+        if (name.trim() === '')
+            throw new Error('Profile name must be non-empty.');
+        const file = await this.readRaw();
+        const profiles = ensureObject(file, 'profiles');
+        if (name in profiles) {
+            throw new Error(`Profile "${name}" already exists. Use \`aitm profile set ${name} <key> <value>\` to modify it.`);
+        }
+        const profile = input.preset
+            ? jsonClone(PROVIDER_PRESETS[input.preset])
+            : {};
+        if (input.baseURL !== undefined)
+            profile.baseURL = input.baseURL;
+        if (input.apiKey !== undefined)
+            profile.openrouterApiKey = input.apiKey;
+        profiles[name] = profile;
+        if (file.activeProfile === undefined)
+            file.activeProfile = name;
+        const validated = await this.persist(file);
+        return validated.profiles?.[name] ?? {};
+    }
+    async set(name, key, value) {
+        const file = await this.readRaw();
+        const profiles = asObject(file.profiles);
+        if (!(name in profiles)) {
+            throw new Error(unknownProfileMessage(name, Object.keys(profiles)));
+        }
+        const profile = asObject(profiles[name]);
+        setDotted(profile, splitKey(key), parseValue(value));
+        profiles[name] = profile;
+        file.profiles = profiles;
+        const validated = await this.persist(file);
+        return validated.profiles?.[name] ?? {};
+    }
+    async get(name, key) {
+        const { profiles } = await this.list();
+        const profile = profiles[name];
+        if (profile === undefined) {
+            throw new Error(unknownProfileMessage(name, Object.keys(profiles)));
+        }
+        return getDotted(profile, splitKey(key));
+    }
+    async remove(name) {
+        const file = await this.readRaw();
+        const profiles = asObject(file.profiles);
+        if (!(name in profiles)) {
+            throw new Error(unknownProfileMessage(name, Object.keys(profiles)));
+        }
+        delete profiles[name];
+        if (file.activeProfile === name)
+            delete file.activeProfile;
+        await this.persist(file);
+    }
+    async show(name) {
+        const { activeProfile, profiles } = await this.list();
+        const target = name ?? activeProfile;
+        if (target === undefined) {
+            throw new Error('No profile specified and no active profile set. Pass a name or run `aitm profile use <name>`.');
+        }
+        const profile = profiles[target];
+        if (profile === undefined) {
+            throw new Error(unknownProfileMessage(target, Object.keys(profiles)));
+        }
+        return { name: target, profile };
+    }
+    filePath() {
+        return join(this.homeDir, GLOBAL_FILE);
+    }
+    async readRaw() {
+        const path = this.filePath();
+        let raw;
+        try {
+            raw = await readFile(path, 'utf8');
+        }
+        catch (err) {
+            if (isNotFound(err))
+                return {};
+            throw err;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`${path}: invalid JSON — ${msg}`);
+        }
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error(`${path}: expected a JSON object at the top level`);
+        }
+        return parsed;
+    }
+    async readValidated() {
+        return this.validate(await this.readRaw());
+    }
+    validate(file) {
+        try {
+            return ConfigFileSchema.parse(file);
+        }
+        catch (err) {
+            if (err instanceof ZodError)
+                throw new Error(`${this.filePath()}: ${formatZodError(err)}`);
+            throw err;
+        }
+    }
+    async persist(file) {
+        const validated = this.validate(file);
+        await atomicWrite(this.filePath(), `${JSON.stringify(validated, null, 2)}\n`);
+        return validated;
+    }
+}
+function asObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function ensureObject(parent, key) {
+    const next = asObject(parent[key]);
+    parent[key] = next;
+    return next;
+}
+function jsonClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+const ALLOWED_PROFILE_ROOT_KEYS = new Set([
+    'openrouterApiKey',
+    'baseURL',
+    'models',
+]);
+const FORBIDDEN_KEY_SEGMENTS = new Set([
+    '__proto__',
+    'prototype',
+    'constructor',
+]);
+const KEY_SURFACE_HINT = 'Allowed keys: openrouterApiKey, baseURL, models.<tier>.';
+function splitKey(key) {
+    const parts = key.split('.');
+    if (parts.length === 0 || parts.some((p) => p === '')) {
+        throw new Error(`Invalid profile key: "${key}". ${KEY_SURFACE_HINT}`);
+    }
+    if (parts.some((p) => FORBIDDEN_KEY_SEGMENTS.has(p))) {
+        throw new Error(`Invalid profile key: "${key}" — reserved segment. ${KEY_SURFACE_HINT}`);
+    }
+    const [first, ...rest] = parts;
+    if (first === undefined || !ALLOWED_PROFILE_ROOT_KEYS.has(first)) {
+        throw new Error(`Invalid profile key: "${key}". ${KEY_SURFACE_HINT}`);
+    }
+    if (first === 'models' ? rest.length !== 1 : rest.length !== 0) {
+        throw new Error(`Invalid profile key: "${key}". ${KEY_SURFACE_HINT}`);
+    }
+    return [first, ...rest];
+}
+function setDotted(obj, parts, value) {
+    const [first, ...rest] = parts;
+    if (first === undefined)
+        return;
+    if (rest.length === 0) {
+        obj[first] = value;
+        return;
+    }
+    const sub = asObject(obj[first]);
+    obj[first] = sub;
+    setDotted(sub, rest, value);
+}
+function getDotted(obj, parts) {
+    let cur = obj;
+    for (const p of parts) {
+        if (cur === null || typeof cur !== 'object' || Array.isArray(cur))
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+function parseValue(v) {
+    if (typeof v !== 'string')
+        return v;
+    try {
+        return JSON.parse(v);
+    }
+    catch {
+        return v;
+    }
+}
+function unknownProfileMessage(name, available) {
+    const list = available.length > 0 ? available.slice().sort().join(', ') : '(none)';
+    return `Unknown profile "${name}". Available: ${list}. Create it with \`aitm profile add ${name}\`.`;
+}
+function isNotFound(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        'code' in err &&
+        err.code === 'ENOENT');
+}
+function formatZodError(err) {
+    return err.issues.map((i) => `${i.path.join('.') || '<root>'}: ${i.message}`).join('; ');
+}

package/dist/config/provider-presets.d.ts

@@ -0,0 +1,5 @@
+import type { Profile } from './schema.ts';
+export type PresetName = 'openrouter' | 'zai';
+export declare const PROVIDER_PRESETS: Readonly<Record<PresetName, Profile>>;
+export declare const PRESET_NAMES: readonly PresetName[];
+export declare function isPresetName(s: string): s is PresetName;

package/dist/config/provider-presets.js

@@ -0,0 +1,18 @@
+export const PROVIDER_PRESETS = {
+    openrouter: {
+        baseURL: 'https://openrouter.ai/api/v1',
+    },
+    zai: {
+        baseURL: 'https://api.z.ai/api/coding/paas/v4',
+        models: {
+            generic: 'glm-5.2',
+            smart: 'glm-5.2',
+            coding: 'glm-5.2',
+            fast: 'glm-5-turbo',
+        },
+    },
+};
+export const PRESET_NAMES = Object.keys(PROVIDER_PRESETS);
+export function isPresetName(s) {
+    return Object.hasOwn(PROVIDER_PRESETS, s);
+}

package/dist/config/schema.d.ts

@@ -18,8 +18,31 @@ export declare const MergeMethodSchema: z.ZodEnum<{
     merge: "merge";
     rebase: "rebase";
 }>;
+export declare const ProfileSchema: z.ZodObject<{
+    openrouterApiKey: z.ZodOptional<z.ZodString>;
+    baseURL: z.ZodOptional<z.ZodURL>;
+    models: z.ZodOptional<z.ZodObject<{
+        generic: z.ZodOptional<z.ZodString>;
+        smart: z.ZodOptional<z.ZodString>;
+        coding: z.ZodOptional<z.ZodString>;
+        fast: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type Profile = z.infer<typeof ProfileSchema>;
 export declare const ConfigFileSchema: z.ZodObject<{
     openrouterApiKey: z.ZodOptional<z.ZodString>;
+    activeProfile: z.ZodOptional<z.ZodString>;
+    profiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        openrouterApiKey: z.ZodOptional<z.ZodString>;
+        baseURL: z.ZodOptional<z.ZodURL>;
+        models: z.ZodOptional<z.ZodObject<{
+            generic: z.ZodOptional<z.ZodString>;
+            smart: z.ZodOptional<z.ZodString>;
+            coding: z.ZodOptional<z.ZodString>;
+            fast: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+    baseURL: z.ZodOptional<z.ZodURL>;
     models: z.ZodOptional<z.ZodObject<{
         generic: z.ZodOptional<z.ZodString>;
         smart: z.ZodOptional<z.ZodString>;
@@ -35,6 +58,7 @@ export declare const ConfigFileSchema: z.ZodObject<{
         rebase: "rebase";
     }>>;
     stylePath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    formatCommand: z.ZodOptional<z.ZodString>;
     logLevel: z.ZodOptional<z.ZodEnum<{
         debug: "debug";
         info: "info";
@@ -70,13 +94,16 @@ export type CliOverrides = {
 };
 export type ResolvedConfig = {
     openrouterApiKey: string;
-    apiKeySource: 'project' | 'global' | 'env';
+    apiKeySource: 'project' | 'global' | 'env' | 'profile';
+    activeProfile?: string | undefined;
+    baseURL?: string | undefined;
     models: Required<Pick<CapabilityModels, 'generic' | 'smart' | 'coding' | 'fast'>>;
     maxPrs: number;
     maxSessions: number | null;
     autoMerge: boolean;
     mergeMethod: 'squash' | 'merge' | 'rebase';
     stylePath: string | null;
+    formatCommand: string | null;
     logLevel: 'debug' | 'info' | 'warn' | 'error';
     concurrency: number;
     mcpServers: import('../mcp/schema.ts').McpServers;

package/dist/config/schema.js

@@ -10,15 +10,26 @@ export const CapabilityModelsSchema = z
     .passthrough();
 export const LogLevelSchema = z.enum(['debug', 'info', 'warn', 'error']);
 export const MergeMethodSchema = z.enum(['squash', 'merge', 'rebase']);
+export const ProfileSchema = z
+    .object({
+    openrouterApiKey: z.string().optional(),
+    baseURL: z.url().optional(),
+    models: CapabilityModelsSchema.optional(),
+})
+    .passthrough();
 export const ConfigFileSchema = z
     .object({
     openrouterApiKey: z.string().optional(),
+    activeProfile: z.string().optional(),
+    profiles: z.record(z.string(), ProfileSchema).optional(),
+    baseURL: z.url().optional(),
     models: CapabilityModelsSchema.optional(),
     maxPrs: z.number().int().positive().optional(),
     maxSessions: z.number().int().positive().nullable().optional(),
     autoMerge: z.boolean().optional(),
     mergeMethod: MergeMethodSchema.optional(),
     stylePath: z.string().nullable().optional(),
+    formatCommand: z.string().optional(),
     logLevel: LogLevelSchema.optional(),
     concurrency: z.number().int().positive().optional(),
     mcpServers: McpServersSchema.optional(),

package/dist/credentials/credentials.d.ts

@@ -3,6 +3,10 @@ import type { Capability, ResolvedConfig } from '../config/schema.ts';
 export type Role = 'planner' | 'worker' | 'reviewer' | 'orchestrator';
 export declare const ROLE_CAPABILITY: Readonly<Record<Role, Capability>>;
 export type ModelHandles = Record<Role, LanguageModel>;
+export declare function providerSettings(resolved: ResolvedConfig): {
+    apiKey: string;
+    baseURL?: string;
+};
 export declare class Credentials {
     private readonly resolved;
     private providerInstance;

package/dist/credentials/credentials.js

@@ -6,6 +6,12 @@ export const ROLE_CAPABILITY = {
     reviewer: 'smart',
     orchestrator: 'fast',
 };
+export function providerSettings(resolved) {
+    return {
+        apiKey: resolved.openrouterApiKey,
+        ...(resolved.baseURL ? { baseURL: resolved.baseURL } : {}),
+    };
+}
 export class Credentials {
     resolved;
     providerInstance;
@@ -37,7 +43,7 @@ export class Credentials {
     provider() {
         if (!this.providerInstance) {
             Credentials.assertApiKeyPresent(this.resolved);
-            this.providerInstance = createOpenRouter({ apiKey: this.resolved.openrouterApiKey });
+            this.providerInstance = createOpenRouter(providerSettings(this.resolved));
         }
         return this.providerInstance;
     }

package/dist/github/github-client.d.ts

@@ -33,6 +33,13 @@ export declare class GitHubClient {
     getPrForBranch(branch: string): Promise<PullRequest | null>;
     createPr(input: CreatePrInput): Promise<PullRequest>;
     waitForChecks(pr: number): Promise<CheckStatus>;
+    getFailedCiLogs(pr: number): Promise<Array<{
+        check: string;
+        logs: string;
+    }>>;
+    private failedRunIds;
+    private failedJobs;
+    private jobLogs;
     listUnresolvedThreads(pr: number): Promise<ReviewThread[]>;
     private paginateReviewThreads;
     private paginateThreadComments;

package/dist/github/github-client.js

@@ -121,6 +121,67 @@ 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();
         const threads = await this.paginateReviewThreads(owner, name, pr);
@@ -249,6 +310,30 @@ export class GitHubClient {
         return { ok: r.exitCode === 0, scopes };
     }
 }
+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);
 }

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

@@ -1,5 +1,5 @@
 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';
@@ -20,6 +20,7 @@ export function localEditTools(cwd) {
         grep: grepTool({ cwd }),
         glob: globTool({ cwd }),
         bash: bashTool({ cwd }),
+        multiBash: multiBashTool({ cwd }),
     };
 }
 export function localReadTools(cwd) {
@@ -156,6 +157,7 @@ function defaultMakeOrchestrator(ctx) {
                 baseBranch,
                 styleContents: style,
                 rollingContext,
+                ...(input.resolved.formatCommand ? { formatCommand: input.resolved.formatCommand } : {}),
             });
         },
         finalizeCommit: (group, delivery, worktreePath) => orch.finalizeCommit(group, delivery, worktreePath),
@@ -191,6 +193,7 @@ 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) {

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

@@ -19,9 +19,24 @@ export async function runTakeOverFlow(input) {
         if (ciStatus === 'success' && threads.length === 0) {
             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 };
             }
@@ -104,14 +119,14 @@ async function runReviewerThreads(input, threads) {
         styleContents: input.subagents.styleContents,
     });
 }
-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,
@@ -137,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) {

package/dist/orchestrator/orchestrator.js

@@ -1,4 +1,5 @@
-import { generateText, hasToolCall, Output, stepCountIs, ToolLoopAgent } from 'ai';
+import { submittedOutput } from '@developerz.ai/ai-claude-compat';
+import { generateText, hasToolCall, stepCountIs, ToolLoopAgent, tool } from 'ai';
 import { ExecaError, execa } from 'execa';
 import { z } from 'zod';
 import { makePlannerTool, makeReviewerTool, makeWorkerTool, } from "./subagent-tools.js";
@@ -133,15 +134,26 @@ export class Orchestrator {
         const result = await generateText({
             model: this.init.credentials.modelFor('orchestrator'),
             prompt: this.buildPrPrompt(group, delivery),
-            output: Output.object({ schema: PrCompositionSchema, name: 'PrComposition' }),
+            tools: {
+                submit: tool({
+                    description: 'Submit the composed pull-request title and body (the PrComposition schema).',
+                    inputSchema: PrCompositionSchema,
+                    execute: async (composition) => composition,
+                }),
+            },
+            toolChoice: { type: 'tool', toolName: 'submit' },
         });
-        return result.experimental_output;
+        const out = submittedOutput(result, PrCompositionSchema);
+        if (!out) {
+            throw new Error('orchestrator did not submit a PR composition');
+        }
+        return out;
     }
     buildPrPrompt(group, delivery) {
         return [
             this.buildSystemPrompt(),
             '',
-            'Compose the pull-request title and body for this PR group. Return JSON.',
+            'Compose the pull-request title and body for this PR group, then call the submit tool with it.',
             '- title: conventional-commit style, ≤72 chars',
             '- body: short summary + bulleted file changes + relevant rolling context',
             '',

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>;
+}