@developerz.ai/aitm 0.0.4 → 0.0.5

package/README.md

@@ -76,8 +76,18 @@ aitm config set autoMerge true --project
 aitm config list
 ```
 
-- **Provider**: OpenRouter only (`OPENROUTER_API_KEY`). Any OpenRouter-routed
-  model id works per role — no Anthropic SDK involved.
+- **Provider**: any OpenAI-compatible endpoint via one credential — OpenRouter by
+  default, or set `baseURL` to run on z.ai GLM, a self-hosted gateway, etc. No
+  Anthropic SDK. **Profiles** switch the whole provider in one command:
+
+  ```bash
+  aitm profile add z.ai --preset zai --api-key "<your z.ai key>"
+  aitm profile use z.ai     # ✅ verified end-to-end on z.ai GLM (glm-5.2 / glm-5-turbo)
+  aitm profile use openrouter
+  ```
+
+  See [providers](https://github.com/developerz-ai/ai-task-master/blob/main/packages/aitm/docs/providers.md)
+  and [`aitm profile`](https://github.com/developerz-ai/ai-task-master/blob/main/packages/aitm/docs/commands/profile.md).
 - **Coding style**: `aitm` reads your repo's `CLAUDE.md` / `AGENTS.md` and feeds
   it to subagents as a style signal (the provider stays OpenRouter).
 - **MCP**: `aitm` is an MCP **client** — declare `mcpServers` in config and their

package/dist/cli/args.d.ts

@@ -1,3 +1,4 @@
+import { type PresetName } from '../config/provider-presets.ts';
 export type StartArgs = {
     kind: 'start';
     goal: string;
@@ -31,7 +32,34 @@ export type ConfigArgs = {
     kind: 'config-list';
     scope: 'global' | 'project';
 };
-export type ParsedArgs = StartArgs | MergePrArgs | ConfigArgs | {
+export type ProfileArgs = {
+    kind: 'profile-list';
+} | {
+    kind: 'profile-use';
+    name: string;
+} | {
+    kind: 'profile-add';
+    name: string;
+    preset?: PresetName;
+    baseURL?: string;
+    apiKey?: string;
+} | {
+    kind: 'profile-set';
+    name: string;
+    key: string;
+    value: string;
+} | {
+    kind: 'profile-get';
+    name: string;
+    key: string;
+} | {
+    kind: 'profile-remove';
+    name: string;
+} | {
+    kind: 'profile-show';
+    name?: string;
+};
+export type ParsedArgs = StartArgs | MergePrArgs | ConfigArgs | ProfileArgs | {
     kind: 'help';
 };
 export declare function parseArgs(argv: ReadonlyArray<string>): ParsedArgs;

package/dist/cli/args.js

@@ -1,3 +1,4 @@
+import { isPresetName } from "../config/provider-presets.js";
 const HELP = { kind: 'help' };
 export function parseArgs(argv) {
     const [command, ...rest] = argv;
@@ -12,6 +13,8 @@ export function parseArgs(argv) {
             return parseMergePr(rest);
         case 'config':
             return parseConfig(rest);
+        case 'profile':
+            return parseProfile(rest);
         default:
             return HELP;
     }
@@ -194,6 +197,116 @@ function parseConfig(args) {
             return HELP;
     }
 }
+function parseProfile(args) {
+    const sub = args[0];
+    if (sub === undefined)
+        return HELP;
+    const tail = args.slice(1);
+    switch (sub) {
+        case 'list':
+            return tail.length === 0 ? { kind: 'profile-list' } : HELP;
+        case 'use': {
+            const name = onlyName(tail);
+            return name === null ? HELP : { kind: 'profile-use', name };
+        }
+        case 'remove': {
+            const name = onlyName(tail);
+            return name === null ? HELP : { kind: 'profile-remove', name };
+        }
+        case 'show': {
+            if (tail.length === 0)
+                return { kind: 'profile-show' };
+            const name = onlyName(tail);
+            return name === null ? HELP : { kind: 'profile-show', name };
+        }
+        case 'get': {
+            if (tail.length !== 2)
+                return HELP;
+            const [name, key] = tail;
+            if (name === undefined ||
+                key === undefined ||
+                name.startsWith('--') ||
+                key.startsWith('--')) {
+                return HELP;
+            }
+            return { kind: 'profile-get', name, key };
+        }
+        case 'set': {
+            if (tail.length !== 3)
+                return HELP;
+            const [name, key, value] = tail;
+            if (name === undefined || key === undefined || value === undefined)
+                return HELP;
+            if (name.startsWith('--') || key.startsWith('--'))
+                return HELP;
+            return { kind: 'profile-set', name, key, value };
+        }
+        case 'add':
+            return parseProfileAdd(tail);
+        default:
+            return HELP;
+    }
+}
+function parseProfileAdd(tail) {
+    const positionals = [];
+    let preset;
+    let baseURL;
+    let apiKey;
+    let i = 0;
+    while (i < tail.length) {
+        const raw = tail[i];
+        if (raw === undefined)
+            break;
+        const { flag, inlineValue, consumed } = splitFlag(raw);
+        if (flag === '--preset') {
+            const v = takeValue(tail, i, inlineValue);
+            if (v === null || !isPresetName(v))
+                return HELP;
+            preset = v;
+            i += consumed(inlineValue !== null);
+        }
+        else if (flag === '--base-url') {
+            const v = takeValue(tail, i, inlineValue);
+            if (v === null || (inlineValue === null && v.startsWith('--')))
+                return HELP;
+            baseURL = v;
+            i += consumed(inlineValue !== null);
+        }
+        else if (flag === '--api-key') {
+            const v = takeValue(tail, i, inlineValue);
+            if (v === null || (inlineValue === null && v.startsWith('--')))
+                return HELP;
+            apiKey = v;
+            i += consumed(inlineValue !== null);
+        }
+        else if (raw.startsWith('--')) {
+            return HELP;
+        }
+        else {
+            positionals.push(raw);
+            i += 1;
+        }
+    }
+    const name = positionals[0];
+    if (name === undefined || positionals.length > 1)
+        return HELP;
+    const out = { kind: 'profile-add', name };
+    if (preset !== undefined)
+        out.preset = preset;
+    if (baseURL !== undefined)
+        out.baseURL = baseURL;
+    if (apiKey !== undefined)
+        out.apiKey = apiKey;
+    return out;
+}
+function onlyName(tail) {
+    if (tail.length !== 1)
+        return null;
+    const name = tail[0];
+    if (name === undefined || name.startsWith('--'))
+        return null;
+    return name;
+}
 function parseNonNegativeInt(s) {
     if (s === undefined || s === null)
         return null;

package/dist/cli/cli.js

@@ -2,7 +2,7 @@
 import { realpathSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { parseArgs } from "./args.js";
-import { runConfig, runMergePr, runStart } from "./commands.js";
+import { runConfig, runMergePr, runProfile, runStart } from "./commands.js";
 export async function main(argv, ctx = {}) {
     const stdout = ctx.stdout ?? ((chunk) => process.stdout.write(chunk));
     const stderr = ctx.stderr ?? ((chunk) => process.stderr.write(chunk));
@@ -17,6 +17,14 @@ export async function main(argv, ctx = {}) {
         case 'config-get':
         case 'config-list':
             return emit(await runConfig(parsed, buildConfigCtx(ctx, stdout)), stderr);
+        case 'profile-list':
+        case 'profile-use':
+        case 'profile-add':
+        case 'profile-set':
+        case 'profile-get':
+        case 'profile-remove':
+        case 'profile-show':
+            return emit(await runProfile(parsed, buildProfileCtx(ctx, stdout)), stderr);
         case 'help':
             stdout(`${HELP_TEXT}\n`);
             return 0;
@@ -60,6 +68,12 @@ function buildConfigCtx(ctx, stdout) {
         out.homeDir = ctx.homeDir;
     return out;
 }
+function buildProfileCtx(ctx, stdout) {
+    const out = { stdout };
+    if (ctx.homeDir !== undefined)
+        out.homeDir = ctx.homeDir;
+    return out;
+}
 function emit(exit, stderr) {
     if (exit.message !== undefined && exit.message !== '')
         stderr(`${exit.message}\n`);
@@ -76,6 +90,13 @@ Usage:
   aitm config unset <key>       [--project]
   aitm config get <key>         [--project]
   aitm config list              [--project]
+  aitm profile list
+  aitm profile use <name>
+  aitm profile add <name> [--preset openrouter|zai] [--base-url <url>] [--api-key <key>]
+  aitm profile set <name> <key> <value>
+  aitm profile get <name> <key>
+  aitm profile remove <name>
+  aitm profile show [<name>]
   aitm help | --help | -h
 
 Exit codes:
@@ -83,7 +104,7 @@ Exit codes:
   1  precondition failure or run blocked
   2  cancelled
 
-Docs: docs/commands/start.md, docs/commands/merge-pr.md, docs/commands/config.md`;
+Docs: docs/commands/start.md, docs/commands/merge-pr.md, docs/commands/config.md, docs/commands/profile.md`;
 if (isEntrypoint(import.meta.url, process.argv[1])) {
     main(process.argv.slice(2)).then((code) => {
         process.exit(code);

package/dist/cli/commands.d.ts

@@ -72,6 +72,10 @@ export type ConfigCtx = {
     homeDir?: string;
     stdout?: (chunk: string) => void;
 };
+export type ProfileCtx = {
+    homeDir?: string;
+    stdout?: (chunk: string) => void;
+};
 export declare function runStart(args: Extract<ParsedArgs, {
     kind: 'start';
 }>, ctx?: StartCtx): Promise<CommandExit>;
@@ -81,3 +85,6 @@ export declare function runMergePr(args: Extract<ParsedArgs, {
 export declare function runConfig(args: Extract<ParsedArgs, {
     kind: `config-${string}`;
 }>, ctx?: ConfigCtx): Promise<CommandExit>;
+export declare function runProfile(args: Extract<ParsedArgs, {
+    kind: `profile-${string}`;
+}>, ctx?: ProfileCtx): Promise<CommandExit>;

package/dist/cli/commands.js

@@ -3,6 +3,7 @@ import { join, resolve as resolvePath } from 'node:path';
 import { AgentConfigDetector } from "../agent-config/agent-config-detector.js";
 import { ConfigLoader } from "../config/config-loader.js";
 import { ConfigWriter } from "../config/config-writer.js";
+import { ProfileManager } from "../config/profiles.js";
 import { Credentials } from "../credentials/credentials.js";
 import { DEFAULT_MODELS } from "../credentials/defaults.js";
 import { GitHubClient } from "../github/github-client.js";
@@ -257,10 +258,7 @@ export async function runConfig(args, ctx = {}) {
             }
             case 'config-list': {
                 const file = await writer.list(args.scope);
-                const safe = file.openrouterApiKey
-                    ? { ...file, openrouterApiKey: maskSecret(file.openrouterApiKey) }
-                    : file;
-                stdout(`${JSON.stringify(safe, null, 2)}\n`);
+                stdout(`${JSON.stringify(redactConfigKeys(file), null, 2)}\n`);
                 return { code: 0 };
             }
             default:
@@ -274,6 +272,65 @@ export async function runConfig(args, ctx = {}) {
         return { code: 1, message: errMsg(err) };
     }
 }
+export async function runProfile(args, ctx = {}) {
+    const homeDir = ctx.homeDir ?? homedir();
+    const stdout = ctx.stdout ?? ((chunk) => process.stdout.write(chunk));
+    const manager = new ProfileManager(homeDir);
+    try {
+        switch (args.kind) {
+            case 'profile-list': {
+                const listing = await manager.list();
+                stdout(formatProfileList(listing.activeProfile, listing.profiles));
+                return { code: 0 };
+            }
+            case 'profile-use': {
+                await manager.use(args.name);
+                stdout(`Active profile is now "${args.name}".\n`);
+                return { code: 0 };
+            }
+            case 'profile-add': {
+                const input = {};
+                if (args.preset !== undefined)
+                    input.preset = args.preset;
+                if (args.baseURL !== undefined)
+                    input.baseURL = args.baseURL;
+                if (args.apiKey !== undefined)
+                    input.apiKey = args.apiKey;
+                await manager.add(args.name, input);
+                const activated = (await manager.list()).activeProfile === args.name;
+                stdout(activated
+                    ? `Created and activated profile "${args.name}".\n`
+                    : `Created profile "${args.name}". Run \`aitm profile use ${args.name}\` to activate it.\n`);
+                return { code: 0 };
+            }
+            case 'profile-set':
+                await manager.set(args.name, args.key, args.value);
+                return { code: 0 };
+            case 'profile-get': {
+                const value = await manager.get(args.name, args.key);
+                stdout(`${formatConfigValue(value)}\n`);
+                return { code: 0 };
+            }
+            case 'profile-remove':
+                await manager.remove(args.name);
+                stdout(`Removed profile "${args.name}".\n`);
+                return { code: 0 };
+            case 'profile-show': {
+                const { name, profile } = await manager.show(args.name);
+                stdout(`${name}\n${JSON.stringify(redactProfile(profile), null, 2)}\n`);
+                return { code: 0 };
+            }
+            default:
+                return {
+                    code: 1,
+                    message: `Unknown profile subcommand: ${args.kind}`,
+                };
+        }
+    }
+    catch (err) {
+        return { code: 1, message: errMsg(err) };
+    }
+}
 function toCliOverrides(args) {
     const out = {};
     if (args.maxPrs !== undefined)
@@ -362,6 +419,38 @@ function formatConfigValue(value) {
         return value;
     return JSON.stringify(value, null, 2);
 }
+function formatProfileList(active, profiles) {
+    const names = Object.keys(profiles).sort();
+    if (names.length === 0) {
+        return 'No profiles configured. Create one with `aitm profile add <name> --preset zai`.\n';
+    }
+    const lines = names.map((name) => {
+        const p = profiles[name] ?? {};
+        const marker = name === active ? '*' : ' ';
+        const base = p.baseURL ?? '(provider default)';
+        const key = p.openrouterApiKey ? maskSecret(p.openrouterApiKey) : '(no key)';
+        return `${marker} ${name}\t${base}\t${key}`;
+    });
+    return `${lines.join('\n')}\n`;
+}
+function redactProfile(profile) {
+    return profile.openrouterApiKey
+        ? { ...profile, openrouterApiKey: maskSecret(profile.openrouterApiKey) }
+        : profile;
+}
+function redactConfigKeys(file) {
+    const out = file.openrouterApiKey
+        ? { ...file, openrouterApiKey: maskSecret(file.openrouterApiKey) }
+        : { ...file };
+    if (out.profiles) {
+        const profiles = {};
+        for (const [name, profile] of Object.entries(out.profiles)) {
+            profiles[name] = redactProfile(profile);
+        }
+        out.profiles = profiles;
+    }
+    return out;
+}
 const defaultAuthStatus = (cwd) => new GitHubClient(cwd).authStatus();
 async function defaultRunLoop(input) {
     return runLoopAdapter(input);

package/dist/config/config-loader.d.ts

@@ -19,6 +19,8 @@ export declare class ConfigLoader {
     private readMcpEnvelope;
     private resolveMcpServers;
     private readConfigFile;
+    private resolveActiveProfile;
+    private resolveBaseURL;
     private resolveApiKey;
     private resolveModels;
 }

package/dist/config/config-loader.js

@@ -13,6 +13,9 @@ const CLAUDE_PROJECT_MCP_FILE = '.mcp.json';
 const CLAUDE_USER_FILE = '.claude.json';
 const KNOWN_KEYS = new Set([
     'openrouterApiKey',
+    'activeProfile',
+    'profiles',
+    'baseURL',
     'models',
     'maxPrs',
     'maxSessions',
@@ -50,10 +53,13 @@ export class ConfigLoader {
         const project = await this.readProject();
         const claudeUser = await this.readClaudeUserMcp();
         const claudeProject = await this.readClaudeProjectMcp();
-        const { apiKey, apiKeySource } = this.resolveApiKey(global, project);
+        const active = this.resolveActiveProfile(global);
+        const profile = active?.profile;
+        const { apiKey, apiKeySource } = this.resolveApiKey(global, project, profile);
         if (apiKey === undefined || apiKeySource === undefined) {
-            throw new Error('No OpenRouter API key found. Set OPENROUTER_API_KEY env, or add ' +
-                '"openrouterApiKey" to ~/.aitm.json or ./.ai-task-master/config.json.');
+            throw new Error('No OpenRouter API key found. Set OPENROUTER_API_KEY env, add ' +
+                '"openrouterApiKey" to ~/.aitm.json or ./.ai-task-master/config.json, or ' +
+                'create a profile with `aitm profile add <name> --api-key <key>`.');
         }
         const { mcpServers, mcpServerSources } = this.resolveMcpServers({
             aitmGlobal: global?.mcpServers,
@@ -64,7 +70,9 @@ export class ConfigLoader {
         return {
             openrouterApiKey: apiKey,
             apiKeySource,
-            models: this.resolveModels(global, project, cliOverrides),
+            ...(active ? { activeProfile: active.name } : {}),
+            baseURL: this.resolveBaseURL(global, project, profile),
+            models: this.resolveModels(global, project, profile, cliOverrides),
             maxPrs: pick(cliOverrides.maxPrs, project?.maxPrs, global?.maxPrs, DEFAULTS.maxPrs),
             maxSessions: pickNullable(cliOverrides.maxSessions, project?.maxSessions, global?.maxSessions, DEFAULTS.maxSessions),
             autoMerge: pick(cliOverrides.autoMerge, project?.autoMerge, global?.autoMerge, DEFAULTS.autoMerge),
@@ -178,27 +186,58 @@ export class ConfigLoader {
         }
         return validated;
     }
-    resolveApiKey(global, project) {
+    resolveActiveProfile(global) {
+        const name = global?.activeProfile;
+        if (!name)
+            return undefined;
+        const profile = global?.profiles?.[name];
+        if (!profile) {
+            this.warn(`activeProfile "${name}" is set in ~/.aitm.json but no such profile exists — ignoring it. ` +
+                'Run `aitm profile list` to see available profiles.');
+            return undefined;
+        }
+        return { name, profile };
+    }
+    resolveBaseURL(global, project, profile) {
+        if (project?.baseURL)
+            return project.baseURL;
+        if (global?.baseURL)
+            return global.baseURL;
+        if (profile?.baseURL)
+            return profile.baseURL;
+        const env = this.env.OPENROUTER_BASE_URL?.trim();
+        if (!env)
+            return undefined;
+        const parsed = z.url().safeParse(env);
+        if (!parsed.success) {
+            throw new Error(`OPENROUTER_BASE_URL is not a valid URL: ${JSON.stringify(env)}`);
+        }
+        return parsed.data;
+    }
+    resolveApiKey(global, project, profile) {
         if (project?.openrouterApiKey) {
             return { apiKey: project.openrouterApiKey, apiKeySource: 'project' };
         }
         if (global?.openrouterApiKey) {
             return { apiKey: global.openrouterApiKey, apiKeySource: 'global' };
         }
+        if (profile?.openrouterApiKey) {
+            return { apiKey: profile.openrouterApiKey, apiKeySource: 'profile' };
+        }
         const envKey = this.env.OPENROUTER_API_KEY;
         if (envKey) {
             return { apiKey: envKey, apiKeySource: 'env' };
         }
         return { apiKey: undefined, apiKeySource: undefined };
     }
-    resolveModels(global, project, cliOverrides) {
+    resolveModels(global, project, profile, cliOverrides) {
         const merged = {
             generic: DEFAULT_MODELS.generic,
             smart: DEFAULT_MODELS.smart,
             coding: DEFAULT_MODELS.coding,
             fast: DEFAULT_MODELS.fast,
         };
-        for (const src of [global?.models, project?.models]) {
+        for (const src of [profile?.models, global?.models, project?.models]) {
             if (!src)
                 continue;
             if (src.generic)

package/dist/config/config-writer.js

@@ -6,8 +6,10 @@ import { ConfigFileSchema } from "./schema.js";
 const GLOBAL_FILE = '.aitm.json';
 const PROJECT_DIR = '.ai-task-master';
 const PROJECT_FILE = 'config.json';
+const PROFILE_MANAGED_KEYS = new Set(['activeProfile', 'profiles']);
 const KNOWN_KEYS = new Set([
     'openrouterApiKey',
+    'baseURL',
     'models',
     'maxPrs',
     'maxSessions',
@@ -28,6 +30,7 @@ export class ConfigWriter {
     async set(scope, key, value) {
         const parts = splitKey(key);
         const top = parts[0];
+        assertNotProfileManaged(top);
         if (!KNOWN_KEYS.has(top)) {
             throw new Error(unknownKeyMessage(top));
         }
@@ -37,6 +40,7 @@ export class ConfigWriter {
     }
     async unset(scope, key) {
         const parts = splitKey(key);
+        assertNotProfileManaged(parts[0]);
         const file = await this.readRaw(scope);
         unsetDottedKey(file, parts);
         return this.validateAndPersist(scope, file);
@@ -158,6 +162,11 @@ function getDottedKey(obj, parts) {
     }
     return cur;
 }
+function assertNotProfileManaged(top) {
+    if (PROFILE_MANAGED_KEYS.has(top)) {
+        throw new Error(`"${top}" is managed by \`aitm profile …\`. Use the profile commands instead.`);
+    }
+}
 function unknownKeyMessage(top) {
     const allowed = [...KNOWN_KEYS].sort().join(', ');
     return `Unknown config key "${top}". Allowed top-level keys: ${allowed}`;

package/dist/config/profiles.d.ts

@@ -0,0 +1,30 @@
+import { type PresetName } from './provider-presets.ts';
+import { type Profile } from './schema.ts';
+export type AddProfileInput = {
+    preset?: PresetName;
+    baseURL?: string;
+    apiKey?: string;
+};
+export type ProfileListing = {
+    activeProfile: string | undefined;
+    profiles: Record<string, Profile>;
+};
+export declare class ProfileManager {
+    private readonly homeDir;
+    constructor(homeDir: string);
+    list(): Promise<ProfileListing>;
+    use(name: string): Promise<void>;
+    add(name: string, input?: AddProfileInput): Promise<Profile>;
+    set(name: string, key: string, value: unknown): Promise<Profile>;
+    get(name: string, key: string): Promise<unknown>;
+    remove(name: string): Promise<void>;
+    show(name?: string): Promise<{
+        name: string;
+        profile: Profile;
+    }>;
+    private filePath;
+    private readRaw;
+    private readValidated;
+    private validate;
+    private persist;
+}

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>;
@@ -71,7 +94,9 @@ 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;

package/dist/config/schema.js

@@ -10,9 +10,19 @@ 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(),

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/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/subagents/planner.d.ts

@@ -1,9 +1,8 @@
 import type { GlobInput, GlobOutput, GrepInput, GrepOutput, ReadFileInput, ReadFileOutput } from '@developerz.ai/ai-claude-compat';
-import { type DeepPartial, Output, type Tool, type ToolLoopAgent } from 'ai';
+import { type Tool, type ToolLoopAgent } from 'ai';
 import { type Plan } from '../plan/schema.ts';
 import type { SubagentInit } from './factory.ts';
-type PlannerOutput = Output.Output<Plan, DeepPartial<Plan>, never>;
-export type PlannerAgent = ToolLoopAgent<never, PlannerTools, PlannerOutput>;
+export type PlannerAgent = ToolLoopAgent<never, PlannerTools>;
 export type PlannerTools = {
     readFile: Tool<ReadFileInput, ReadFileOutput>;
     grep: Tool<GrepInput, GrepOutput>;
@@ -28,4 +27,3 @@ export type PlannerResult = {
 export declare const PLANNER_SYSTEM_PREFIX: string;
 export declare function createPlannerAgent(init: SubagentInit<PlannerTools>): PlannerAgent;
 export declare function runPlanner(agent: PlannerAgent, input: PlannerInput): Promise<PlannerResult>;
-export {};

package/dist/subagents/planner.js

@@ -1,5 +1,5 @@
-import { createSubagent } from '@developerz.ai/ai-claude-compat';
-import { Output } from 'ai';
+import { createSubagent, submittedOutput } from '@developerz.ai/ai-claude-compat';
+import { tool } from 'ai';
 import { PlanSchema } from "../plan/schema.js";
 export const PLANNER_SYSTEM_PREFIX = [
     '',
@@ -15,14 +15,18 @@ export const PLANNER_SYSTEM_PREFIX = [
     '- Prefer parallelizable siblings over a single linear chain.',
     '- Do not invent files. Do not propose work outside the repo.',
     '',
-    'Return JSON that matches the Plan schema exactly.',
+    'When the plan is ready, call the `submit` tool exactly once with the Plan (matching the Plan schema).',
 ].join('\n');
 export function createPlannerAgent(init) {
     return createSubagent({
         model: init.model,
         tools: init.tools,
         systemPrompt: init.systemPrompt,
-        output: plannerOutput(),
+        submit: tool({
+            description: 'Submit the finished plan as an ordered list of PR groups (the Plan schema).',
+            inputSchema: PlanSchema,
+            execute: async (plan) => plan,
+        }),
         ...(init.maxSteps !== undefined ? { maxSteps: init.maxSteps } : {}),
     }, 20);
 }
@@ -32,8 +36,8 @@ export async function runPlanner(agent, input) {
     }
     try {
         const result = await agent.generate({ prompt: buildUserPrompt(input) });
-        const raw = result.experimental_output;
-        if (!raw.groups || raw.groups.length === 0) {
+        const raw = submittedOutput(result, PlanSchema);
+        if (!raw || raw.groups.length === 0) {
             return { kind: 'blocked', reason: 'planner returned an empty group list' };
         }
         return { kind: 'ok', plan: capGroups(raw, input.maxPrs) };
@@ -42,16 +46,13 @@ export async function runPlanner(agent, input) {
         return { kind: 'error', error: err instanceof Error ? err.message : String(err) };
     }
 }
-function plannerOutput() {
-    return Output.object({ schema: PlanSchema, name: 'Plan' });
-}
 function buildUserPrompt(input) {
     const lines = [`Goal: ${input.goal}`];
     if (input.criteria?.trim()) {
         lines.push(`Acceptance criteria: ${input.criteria}`);
     }
     lines.push(`maxPrs: ${input.maxPrs}`);
-    lines.push('Survey the repo with the read-only tools, then emit the Plan JSON.');
+    lines.push('Survey the repo with the read-only tools, then call submit with the Plan.');
     return lines.join('\n');
 }
 function capGroups(plan, maxPrs) {

package/dist/subagents/reviewer.d.ts

@@ -1,4 +1,4 @@
-import { type DeepPartial, Output, type Tool, type ToolLoopAgent } from 'ai';
+import { type Tool, type ToolLoopAgent } from 'ai';
 import { z } from 'zod';
 import type { ReviewThread } from '../github/schema.ts';
 import type { SubagentInit } from './factory.ts';
@@ -24,8 +24,7 @@ export declare const ThreadResolutionOutputSchema: z.ZodObject<{
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ThreadResolutionOutput = z.infer<typeof ThreadResolutionOutputSchema>;
-type ReviewerAgentOutput = Output.Output<ThreadResolutionOutput, DeepPartial<ThreadResolutionOutput>, never>;
-export type ReviewerAgent = ToolLoopAgent<never, ReviewerTools, ReviewerAgentOutput>;
+export type ReviewerAgent = ToolLoopAgent<never, ReviewerTools>;
 export type ReviewerInput = {
     pr: number;
     threads: ReviewThread[];
@@ -57,4 +56,3 @@ export type ReviewerResult = {
 export declare const REVIEWER_SYSTEM_PREFIX: string;
 export declare function createReviewerAgent(init: SubagentInit<ReviewerTools>): ReviewerAgent;
 export declare function runReviewer(agent: ReviewerAgent, input: ReviewerInput): Promise<ReviewerResult>;
-export {};

package/dist/subagents/reviewer.js

@@ -1,5 +1,5 @@
-import { createSubagent } from '@developerz.ai/ai-claude-compat';
-import { Output } from 'ai';
+import { createSubagent, submittedOutput, } from '@developerz.ai/ai-claude-compat';
+import { tool } from 'ai';
 import { z } from 'zod';
 export const ThreadResolutionOutputSchema = z.object({
     kind: z.enum(['fixed', 'replied', 'wontfix']),
@@ -9,24 +9,24 @@ export const ThreadResolutionOutputSchema = z.object({
 export const REVIEWER_SYSTEM_PREFIX = [
     '',
     'You are the Reviewer subagent. You receive ONE unresolved PR review thread at a time and',
-    'decide between three outcomes, emitting a ThreadResolutionOutput JSON that names the choice.',
+    'decide between three outcomes, then call the `submit` tool with a ThreadResolutionOutput naming the choice.',
     '',
     '- "fixed": the reviewer is right and a code change is needed. Use your tools (grep/glob/',
     '  readFile to locate, editFile/multiEdit to change, writeFile to rewrite, bash for the rest)',
     '  to make the fix inside the worktree. DO NOT run `git commit` yourself — the runner commits',
     '  every staged change after you finish. Reply on the thread via the github tool explaining',
-    '  the fix and resolve the thread, then emit { kind: "fixed", commitMessage } where',
+    '  the fix and resolve the thread, then submit { kind: "fixed", commitMessage } where',
     '  commitMessage is the subject line the runner will pass to `git commit`.',
     '- "replied": the comment is a question or clarification request and no code change is needed.',
-    '  Answer it via github.replyToThread. Do not edit code. Emit { kind: "replied" }.',
+    '  Answer it via github.replyToThread. Do not edit code. Submit { kind: "replied" }.',
     '- "wontfix": the suggestion is stale, out of scope, or you disagree. Reply with the reason',
-    '  via github.replyToThread, resolve the thread via github.resolveThread, and emit',
+    '  via github.replyToThread, resolve the thread via github.resolveThread, and submit',
     '  { kind: "wontfix", reason }.',
     '',
     'Rules:',
     '- Stay inside the worktree. No work outside the repo.',
     '- Resolve the thread for "fixed" and "wontfix" outcomes; "replied" leaves it open.',
-    '- Return JSON that matches the ThreadResolutionOutput schema exactly.',
+    '- When done, call `submit` once with a value matching the ThreadResolutionOutput schema.',
 ].join('\n');
 const reviewerInitRegistry = new WeakMap();
 export function createReviewerAgent(init) {
@@ -34,9 +34,10 @@ export function createReviewerAgent(init) {
         model: init.model,
         tools: init.tools,
         systemPrompt: init.systemPrompt,
-        output: Output.object({
-            schema: ThreadResolutionOutputSchema,
-            name: 'ThreadResolution',
+        submit: tool({
+            description: 'Submit the resolution for this review thread (the ThreadResolutionOutput schema).',
+            inputSchema: ThreadResolutionOutputSchema,
+            execute: async (resolution) => resolution,
         }),
         ...(init.maxSteps !== undefined ? { maxSteps: init.maxSteps } : {}),
     }, 20);
@@ -67,7 +68,10 @@ export async function runReviewer(agent, input) {
 }
 async function resolveOneThread(agent, init, input, thread) {
     const result = await agent.generate({ prompt: buildThreadPrompt(input, thread) });
-    const out = result.experimental_output;
+    const out = submittedOutput(result, ThreadResolutionOutputSchema);
+    if (!out) {
+        return { threadId: thread.id, kind: 'wontfix', reason: 'reviewer did not submit a resolution' };
+    }
     switch (out.kind) {
         case 'fixed': {
             const message = out.commitMessage?.trim() || `fix: address review thread ${thread.id}`;
@@ -92,7 +96,7 @@ function buildThreadPrompt(input, thread) {
     for (const c of thread.comments) {
         lines.push(`  @${c.author}: ${c.body}`);
     }
-    lines.push('', 'Decide the outcome, take the action, then emit the ThreadResolutionOutput JSON.');
+    lines.push('', 'Decide the outcome, take the action, then call submit with the ThreadResolutionOutput.');
     return lines.join('\n');
 }
 async function commitFix(bash, worktreePath, message) {

package/dist/subagents/worker.d.ts

@@ -1,5 +1,5 @@
 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 { type Tool, type ToolLoopAgent } from 'ai';
 import { z } from 'zod';
 import type { PrGroup } from '../state/schema.ts';
 import type { SubagentInit } from './factory.ts';
@@ -36,8 +36,7 @@ export declare const FileManifestSchema: z.ZodObject<{
     draftCommitMessage: z.ZodString;
 }, z.core.$strip>;
 export type FileManifest = z.infer<typeof FileManifestSchema>;
-type WorkerOutput = Output.Output<FileManifest, DeepPartial<FileManifest>, never>;
-export type WorkerAgent = ToolLoopAgent<never, WorkerTools, WorkerOutput>;
+export type WorkerAgent = ToolLoopAgent<never, WorkerTools>;
 export type WorkerInput = {
     group: PrGroup;
     worktreePath: string;
@@ -70,4 +69,3 @@ export type WorkerResult = {
 export declare const WORKER_SYSTEM_PREFIX: string;
 export declare function createWorkerAgent(init: SubagentInit<WorkerTools>): WorkerAgent;
 export declare function runWorker(agent: WorkerAgent, input: WorkerInput): Promise<WorkerResult>;
-export {};

package/dist/subagents/worker.js

@@ -1,5 +1,5 @@
-import { composeSystemPrompt, createSubagent } from '@developerz.ai/ai-claude-compat';
-import { generateText, Output, stepCountIs, } from 'ai';
+import { composeSystemPrompt, createSubagent, submittedOutput, } from '@developerz.ai/ai-claude-compat';
+import { generateText, stepCountIs, tool } from 'ai';
 import { z } from 'zod';
 export const FileManifestEntrySchema = z.object({
     path: z.string().min(1),
@@ -16,8 +16,8 @@ export const WORKER_SYSTEM_PREFIX = [
     'land in a single pull request on a dedicated branch. Work in two phases.',
     '',
     'Phase 1 — manifest. Use your read-only tools (readFile with optional offset/limit, grep,',
-    'glob) to ground yourself in the existing code, then emit a FileManifest JSON listing every',
-    'file to create/modify/delete plus a one-line draft commit message. Do not edit yet.',
+    'glob) to ground yourself in the existing code, then call the `submit` tool with a FileManifest',
+    'listing every file to create/modify/delete plus a one-line draft commit message. Do not edit yet.',
     '',
     'Phase 2 — edits. Each manifest entry is handed to a dedicated editor subagent in',
     'parallel by the runtime; you do not execute Phase 2 yourself.',
@@ -26,7 +26,7 @@ export const WORKER_SYSTEM_PREFIX = [
     '- Stay inside the worktree provided. No work outside the repo.',
     '- One responsibility per file. If a file has multiple unrelated edits, split it.',
     '- draftCommitMessage is a hint to the Orchestrator; keep the subject under 72 chars.',
-    '- Return the FileManifest JSON exactly matching the schema.',
+    '- When the manifest is complete, call `submit` once with the FileManifest (matching the schema).',
 ].join('\n');
 const EDITOR_SYSTEM_PREFIX = [
     '',
@@ -50,7 +50,11 @@ export function createWorkerAgent(init) {
         model: init.model,
         tools: init.tools,
         systemPrompt: init.systemPrompt,
-        output: Output.object({ schema: FileManifestSchema, name: 'FileManifest' }),
+        submit: tool({
+            description: 'Submit the file manifest (the FileManifest schema) for this PR group.',
+            inputSchema: FileManifestSchema,
+            execute: async (manifest) => manifest,
+        }),
         ...(init.maxSteps !== undefined ? { maxSteps: init.maxSteps } : {}),
     }, 30);
     workerInitRegistry.set(agent, init);
@@ -91,7 +95,7 @@ export async function runWorker(agent, input) {
 }
 async function planManifest(agent, input) {
     const result = await agent.generate({ prompt: buildManifestPrompt(input) });
-    return result.experimental_output;
+    return submittedOutput(result, FileManifestSchema) ?? { files: [], draftCommitMessage: '' };
 }
 function buildManifestPrompt(input) {
     const lines = [
@@ -106,7 +110,7 @@ function buildManifestPrompt(input) {
     if (input.rollingContext.trim()) {
         lines.push('', 'Rolling context from prior PRs:', input.rollingContext);
     }
-    lines.push('', 'Survey the repo, then emit the FileManifest JSON.');
+    lines.push('', 'Survey the repo, then call submit with the FileManifest.');
     return lines.join('\n');
 }
 async function runEditor(init, file, input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@developerz.ai/aitm",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Autonomous task orchestrator. Goal in, merged PRs out.",
   "license": "MIT",
   "type": "module",
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@ai-sdk/mcp": "^1.0.42",
-    "@developerz.ai/ai-claude-compat": "0.0.4",
+    "@developerz.ai/ai-claude-compat": "0.0.5",
     "@openrouter/ai-sdk-provider": "^2.9.0",
     "ai": "^6.0.182",
     "execa": "^9.6.1",