@aibridge/cli 0.1.1 → 0.3.0

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { C as listModelHelpLines, S as formatUnknownModelError, T as supportsImageGen, _ as DEFAULT_IMPLEMENTER, a as readRunLogs, b as backendModelId, c as evaluateCodexPreflight, d as renderPreflightRefusal, f as delegate, g as DEFAULT_IMAGE_GEN, h as positiveIntSeconds, i as listRuns, l as preflightCodex, m as nonEmptyPrompt, n as app, o as startRun, p as getDriver, r as runCli, s as evaluateAgyPreflight, t as buildContext, u as preflightModel, v as DEFAULT_MODEL, w as resolveModel, x as formatImageGenModelError, y as MODELS } from "./context-8JjDzZBG.mjs";
-export { DEFAULT_IMAGE_GEN, DEFAULT_IMPLEMENTER, DEFAULT_MODEL, MODELS, app, backendModelId, buildContext, delegate, evaluateAgyPreflight, evaluateCodexPreflight, formatImageGenModelError, formatUnknownModelError, getDriver, listModelHelpLines, listRuns, nonEmptyPrompt, positiveIntSeconds, preflightCodex, preflightModel, readRunLogs, renderPreflightRefusal, resolveModel, runCli, startRun, supportsImageGen };
+import { S as supportsImageGen, _ as backendModelId, a as readRunLogs, b as listModelHelpLines, c as evaluateCodexPreflight, d as renderPreflightRefusal, f as delegate, g as MODELS, h as positiveIntSeconds, i as listRuns, l as preflightCodex, m as nonEmptyPrompt, n as app, o as startRun, p as getDriver, r as runCli, s as evaluateAgyPreflight, t as buildContext, u as preflightModel, v as formatImageGenModelError, x as resolveModel, y as formatUnknownModelError } from "./context-B6I4QI9z.mjs";
+export { MODELS, app, backendModelId, buildContext, delegate, evaluateAgyPreflight, evaluateCodexPreflight, formatImageGenModelError, formatUnknownModelError, getDriver, listModelHelpLines, listRuns, nonEmptyPrompt, positiveIntSeconds, preflightCodex, preflightModel, readRunLogs, renderPreflightRefusal, resolveModel, runCli, startRun, supportsImageGen };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aibridge/cli",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "CLI that bridges tasks to AI CLIs on your machine (plan / implement / review / subagent / image-gen)",
   "type": "module",
   "license": "MIT",
@@ -35,11 +35,11 @@
   ],
   "dependencies": {
     "@stricli/core": "1.3.0",
-    "@aibridge/proc": "0.1.1",
-    "@aibridge/driver-agy": "0.1.1",
-    "@aibridge/driver-grok": "0.1.1",
-    "@aibridge/driver-codex": "0.1.1",
-    "@aibridge/driver-claude": "0.1.1"
+    "@aibridge/proc": "0.3.0",
+    "@aibridge/driver-agy": "0.3.0",
+    "@aibridge/driver-grok": "0.3.0",
+    "@aibridge/driver-codex": "0.3.0",
+    "@aibridge/driver-claude": "0.3.0"
   },
   "devDependencies": {
     "tsdown": "0.22.14"

package/src/app.ts

@@ -14,7 +14,7 @@ const require = createRequire(import.meta.url);
 const { version } = require('../package.json') as { version: string };
 
 const BRIEF =
-  'Bridge tasks to non-Claude AI CLIs — a plan → implement → review workflow, task delegation, and image generation (codex gpt-image-2 / grok Imagine).';
+  'Bridge tasks to non-Claude AI CLIs — a plan → implement → review workflow, task delegation, and image generation (codex / agy / grok seats).';
 
 const routes = buildRouteMap({
   routes: {

package/src/commands/image-gen/command.ts

@@ -1,15 +1,15 @@
 import { buildCommand } from '@stricli/core';
-import { DEFAULT_IMAGE_GEN, listModelHelpLines } from '../../models.ts';
+import { listModelHelpLines } from '../../models.ts';
 import { nonEmptyPrompt, positiveIntSeconds } from '../../parsers.ts';
 import imageGenImpl from './impl.ts';
 
 const fullDescription = [
-  "Renders an image by driving the seat's CLI (codex → gpt-image-2, grok →",
-  'Imagine), then verifies the result is a real render before returning it.',
+  "Renders an image by driving the seat's own CLI, then verifies the result is",
+  'a real render before returning it.',
   '',
   'Image-gen seats (canonical slug):',
   ...listModelHelpLines({ imageOnly: true }),
-  `Default: ${DEFAULT_IMAGE_GEN} (gpt-image-2 via codex; historical default).`,
+  'Recommended seat: openai-codex/gpt-5.6-sol.',
 ].join('\n');
 
 export const imageGen = buildCommand({
@@ -19,21 +19,19 @@ export const imageGen = buildCommand({
       model: {
         kind: 'parsed',
         parse: String,
-        optional: true,
-        brief: `Model slug (default: ${DEFAULT_IMAGE_GEN})`,
+        brief: 'Model slug (required) — see the seat list above',
       },
       out: {
         kind: 'parsed',
         parse: String,
-        optional: true,
-        brief: 'Path to write the image (default: ./aibridge-image.png)',
+        brief:
+          'Path to write the image — extension must match the seat format (.png for codex, .jpg for agy/grok)',
       },
-      size: {
+      aspectRatio: {
         kind: 'parsed',
         parse: String,
         optional: true,
-        brief:
-          'WIDTHxHEIGHT (codex: each edge ÷16; grok: mapped to aspect_ratio, then optionally resized)',
+        brief: 'Aspect ratio N:M, e.g. 16:9 (agy/grok: real tool param; codex: prompt hint)',
       },
       image: {
         kind: 'parsed',
@@ -41,12 +39,6 @@ export const imageGen = buildCommand({
         optional: true,
         brief: 'Reference image path(s), comma-separated — visual reference',
       },
-      quality: {
-        kind: 'parsed',
-        parse: String,
-        optional: true,
-        brief: 'low | medium | high (codex/gpt-image-2; default high)',
-      },
       timeout: {
         kind: 'parsed',
         parse: positiveIntSeconds,

package/src/commands/image-gen/impl.ts

@@ -10,30 +10,29 @@ import {
 } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
-import { isNotFound, runCaptured } from '@aibridge/proc';
 import type { LocalContext } from '../../context.ts';
 import type { ImageResult } from '../../driver.ts';
 import { getDriver } from '../../drivers.ts';
 import {
-  DEFAULT_IMAGE_GEN,
+  backendModelId,
   formatImageGenModelError,
   formatUnknownModelError,
+  imageFormatFor,
   resolveModel,
   supportsImageGen,
 } from '../../models.ts';
 
 export interface ImageGenFlags {
-  readonly model?: string;
-  readonly out?: string;
-  readonly size?: string;
+  readonly model: string;
+  readonly out: string;
+  readonly aspectRatio?: string;
   readonly image?: string;
-  readonly quality?: string;
   readonly timeout?: number;
   readonly json: boolean;
 }
 
 const MIN_REAL_BYTES_CODEX = 100_000;
-const MIN_REAL_BYTES_GROK = 10_000;
+const MIN_REAL_BYTES_TOOL = 10_000;
 
 export default async function imageGen(
   this: LocalContext,
@@ -45,37 +44,39 @@ export default async function imageGen(
     this.process.exitCode = 1;
   };
 
-  const inputSlug = flags.model ?? DEFAULT_IMAGE_GEN;
+  const inputSlug = flags.model;
   const model = resolveModel(inputSlug);
   if (!model) return fail(formatUnknownModelError(inputSlug));
   if (!supportsImageGen(model)) return fail(formatImageGenModelError(inputSlug, model));
 
   if (model.spec.backend === 'codex' && model.effort) {
     return fail(
-      `effort "-${model.effort}" has no effect on image-gen (gpt-image-2 renders, not the seat model); use ${DEFAULT_IMAGE_GEN}.`,
+      `effort "-${model.effort}" has no effect on image-gen (the image tool renders, not the seat model); pass the un-suffixed slug "${model.spec.slug}" instead.`,
     );
   }
 
-  const quality = (flags.quality ?? 'high').toLowerCase();
-  if (!['low', 'medium', 'high'].includes(quality)) {
-    return fail(`invalid --quality "${flags.quality}" (use low | medium | high)`);
+  const expected = imageFormatFor(model);
+  if (expected === undefined) return fail(formatImageGenModelError(inputSlug, model));
+
+  const label = expected === 'png' ? 'PNG' : 'JPEG';
+  const extValid = expected === 'png' ? /\.png$/i.test(flags.out) : /\.jpe?g$/i.test(flags.out);
+  if (!extValid) {
+    return fail(
+      `--out "${flags.out}" must end in ${expected === 'png' ? '.png' : '.jpg or .jpeg'} — the ${model.spec.slug} seat renders ${label} and aibridge does not convert.`,
+    );
   }
 
-  let size: { w: number; h: number } | undefined;
-  if (flags.size !== undefined) {
-    const m = flags.size.match(/^(\d+)\s*x\s*(\d+)$/i);
-    if (!m) return fail(`invalid --size "${flags.size}" (expected e.g. 1024x1024)`);
-    size = { w: Number(m[1]), h: Number(m[2]) };
-    if (model.spec.backend === 'codex') {
-      const constraint = sizeConstraintError(size.w, size.h);
-      if (constraint) return fail(`invalid --size ${size.w}x${size.h}: ${constraint}`);
-    } else if (size.w < 1 || size.h < 1) {
-      return fail(`invalid --size ${size.w}x${size.h}: dimensions must be positive`);
+  let aspectRatio: string | undefined;
+  if (flags.aspectRatio !== undefined) {
+    const m = flags.aspectRatio.match(/^(\d+)\s*:\s*(\d+)$/);
+    if (!m || Number(m[1]) < 1 || Number(m[2]) < 1) {
+      return fail(`invalid --aspect-ratio "${flags.aspectRatio}" (expected e.g. 16:9)`);
     }
+    aspectRatio = `${Number(m[1])}:${Number(m[2])}`;
   }
 
   const timeoutSec = flags.timeout ?? 600;
-  const outPath = resolve(this.process.cwd(), flags.out ?? './aibridge-image.png');
+  const outPath = resolve(this.process.cwd(), flags.out);
 
   const imagePaths: string[] = [];
   if (flags.image !== undefined) {
@@ -94,17 +95,16 @@ export default async function imageGen(
     return fail(formatImageGenModelError(inputSlug, model));
   }
 
-  const minBytes = model.spec.backend === 'codex' ? MIN_REAL_BYTES_CODEX : MIN_REAL_BYTES_GROK;
+  const minBytes = model.spec.backend === 'codex' ? MIN_REAL_BYTES_CODEX : MIN_REAL_BYTES_TOOL;
   const work = mkdtempSync(join(tmpdir(), 'aibridge-imagegen-'));
 
   try {
     let outcome: ImageResult = await driver.generateImage({
       prompt,
       workDir: work,
-      backendModel: model.spec.backendModel,
+      backendModel: backendModelId(model),
       effort: model.effort,
-      quality,
-      size,
+      aspectRatio,
       imagePaths,
       timeoutSec,
       forceful: false,
@@ -115,10 +115,9 @@ export default async function imageGen(
       outcome = await driver.generateImage({
         prompt,
         workDir: work,
-        backendModel: model.spec.backendModel,
+        backendModel: backendModelId(model),
         effort: model.effort,
-        quality,
-        size,
+        aspectRatio,
         imagePaths,
         timeoutSec,
         forceful: true,
@@ -133,42 +132,29 @@ export default async function imageGen(
     if (outcome.kind === 'error') return fail(outcome.reason);
     if (outcome.kind === 'suspect') {
       return fail(
-        model.spec.backend === 'grok'
-          ? 'grok produced no usable image. Check SuperGrok image access and re-run with a simpler prompt.'
-          : 'codex produced only a tiny/code-drawn image, not a real gpt-image-2 render. ' +
-              'Try --quality high or a clearer, simpler prompt.',
+        model.spec.backend === 'agy'
+          ? 'agy produced no usable image. Re-run with a simpler prompt, or check Antigravity image access.'
+          : model.spec.backend === 'grok'
+            ? 'grok produced no usable image. Check SuperGrok image access and re-run with a simpler prompt.'
+            : 'codex produced only a tiny/code-drawn image, not a real render. ' +
+              'Try a clearer, simpler prompt.',
       );
     }
 
     const local = join(work, 'result.bin');
     copyFileSync(outcome.path, local);
 
-    let dims = imageSize(local);
-    if (size && dims && (dims.width !== size.w || dims.height !== size.h)) {
-      const resized = await magick([local, '-resize', `${size.w}x${size.h}!`, local]);
-      if (resized) {
-        dims = imageSize(local) ?? dims;
-      } else {
-        this.process.stderr.write(
-          `aibridge image-gen: rendered ${dims.width}x${dims.height}, wanted ${size.w}x${size.h}, ` +
-            'and ImageMagick (magick/convert) is unavailable to resize.\n',
-        );
-      }
-    }
+    const dims = imageSize(local);
+    const actual = pngSize(local) ? 'png' : jpegSize(local) ? 'jpg' : null;
 
-    const outExt = /\.png$/i.test(outPath) ? 'png' : /\.jpe?g$/i.test(outPath) ? 'jpg' : null;
-    const actualFmt = pngSize(local) ? 'png' : jpegSize(local) ? 'jpg' : null;
-    const needsConvert = outExt !== null && actualFmt !== null && outExt !== actualFmt;
-    if (!needsConvert || !(await magick([local, outPath]))) {
-      if (needsConvert) {
-        this.process.stderr.write(
-          `aibridge image-gen: render is ${actualFmt.toUpperCase()} but out path wants ` +
-            `${outExt.toUpperCase()}, and ImageMagick (magick/convert) is unavailable to convert; ` +
-            'writing the raw bytes as-is.\n',
-        );
-      }
-      copyFileSync(local, outPath);
+    // ponytail: guard for a backend changing formats in the future without throwing away a paid render
+    if (actual !== null && actual !== expected) {
+      this.process.stderr.write(
+        `aibridge image-gen: expected a ${label} render from this seat but got ${actual === 'png' ? 'PNG' : 'JPEG'}; wrote the raw bytes to ${outPath} anyway — the extension does not match the contents.\n`,
+      );
     }
+
+    copyFileSync(local, outPath);
     const bytes = statSync(outPath).size;
 
     if (flags.json) {
@@ -178,8 +164,7 @@ export default async function imageGen(
           bytes,
           width: dims?.width ?? null,
           height: dims?.height ?? null,
-          sizeRequested: flags.size ?? null,
-          quality: model.spec.backend === 'codex' ? quality : null,
+          aspectRatio: flags.aspectRatio ?? null,
           model: model.spec.slug,
           backend: model.spec.backend,
           real: true,
@@ -188,27 +173,13 @@ export default async function imageGen(
     } else {
       const kb = Math.round(bytes / 1024);
       const dimStr = dims ? `${dims.width}x${dims.height}, ` : '';
-      const qualityStr = model.spec.backend === 'codex' ? `, ${quality} quality` : '';
-      this.process.stdout.write(
-        `✓ Wrote ${outPath} (${dimStr}${kb} KB${qualityStr}, ${model.spec.slug})\n`,
-      );
+      this.process.stdout.write(`✓ Wrote ${outPath} (${dimStr}${kb} KB, ${model.spec.slug})\n`);
     }
   } finally {
     rmSync(work, { recursive: true, force: true });
   }
 }
 
-function sizeConstraintError(w: number, h: number): string | null {
-  if (w % 16 !== 0 || h % 16 !== 0) return 'each edge must be divisible by 16';
-  const long = Math.max(w, h);
-  const short = Math.min(w, h);
-  if (long / short > 3) return 'aspect ratio must be within 1:3–3:1';
-  if (long > 3840) return 'longest edge must be <= 3840px';
-  const px = w * h;
-  if (px < 655_360 || px > 8_294_400) return 'total pixels must be 655,360–8,294,400';
-  return null;
-}
-
 function imageSize(path: string): { width: number; height: number } | null {
   return pngSize(path) ?? jpegSize(path);
 }
@@ -254,15 +225,3 @@ function jpegSize(path: string): { width: number; height: number } | null {
     return null;
   }
 }
-
-async function magick(args: readonly string[]): Promise<boolean> {
-  for (const tool of ['magick', 'convert']) {
-    try {
-      const r = await runCaptured(tool, [...args], { timeoutMs: 60_000 });
-      if (!r.timedOut && r.code === 0) return true;
-    } catch (err) {
-      if (!isNotFound(err)) throw err;
-    }
-  }
-  return false;
-}

package/src/commands/implement/command.ts

@@ -1,5 +1,5 @@
 import { buildCommand } from '@stricli/core';
-import { DEFAULT_IMPLEMENTER, listModelHelpLines } from '../../models.ts';
+import { listModelHelpLines } from '../../models.ts';
 import { positiveIntSeconds } from '../../parsers.ts';
 import implementImpl from './impl.ts';
 
@@ -17,8 +17,7 @@ export const implement = buildCommand({
       model: {
         kind: 'parsed',
         parse: String,
-        optional: true,
-        brief: `Model slug (default: ${DEFAULT_IMPLEMENTER})`,
+        brief: 'Model slug (required) — see the seat list above',
       },
       timeout: {
         kind: 'parsed',

package/src/commands/implement/impl.ts

@@ -3,12 +3,12 @@ import { isAbsolute, resolve } from 'node:path';
 import { runCaptured } from '@aibridge/proc';
 import type { LocalContext } from '../../context.ts';
 import { delegate } from '../../delegate.ts';
-import { DEFAULT_IMPLEMENTER, formatUnknownModelError, resolveModel } from '../../models.ts';
+import { formatUnknownModelError, resolveModel } from '../../models.ts';
 import { preflightModel, renderPreflightRefusal } from '../../quotaPreflight.ts';
 import { startRun } from '../../runlog.ts';
 
 export interface ImplementFlags {
-  readonly model?: string;
+  readonly model: string;
   readonly timeout?: number;
   readonly preflight: boolean;
 }
@@ -18,7 +18,7 @@ export default async function implement(
   flags: ImplementFlags,
   planFile: string,
 ): Promise<void> {
-  const inputSlug = flags.model ?? DEFAULT_IMPLEMENTER;
+  const inputSlug = flags.model;
   const model = resolveModel(inputSlug);
   if (!model) {
     this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);

package/src/commands/plan/command.ts

@@ -1,5 +1,5 @@
 import { buildCommand } from '@stricli/core';
-import { DEFAULT_MODEL, listModelHelpLines } from '../../models.ts';
+import { listModelHelpLines } from '../../models.ts';
 import { nonEmptyPrompt, positiveIntSeconds } from '../../parsers.ts';
 import planImpl from './impl.ts';
 
@@ -17,14 +17,12 @@ export const plan = buildCommand({
       model: {
         kind: 'parsed',
         parse: String,
-        optional: true,
-        brief: `Model slug (default: ${DEFAULT_MODEL})`,
+        brief: 'Model slug (required) — see the seat list above',
       },
       out: {
         kind: 'parsed',
         parse: String,
-        optional: true,
-        brief: 'Where to write the plan (default: <run.dir>/plan.md)',
+        brief: 'Where to write the plan file (required)',
       },
       timeout: {
         kind: 'parsed',

package/src/commands/plan/impl.ts

@@ -3,13 +3,13 @@ import { isAbsolute, resolve } from 'node:path';
 import { runCaptured } from '@aibridge/proc';
 import type { LocalContext } from '../../context.ts';
 import { delegate } from '../../delegate.ts';
-import { DEFAULT_MODEL, formatUnknownModelError, resolveModel } from '../../models.ts';
+import { formatUnknownModelError, resolveModel } from '../../models.ts';
 import { preflightModel, renderPreflightRefusal } from '../../quotaPreflight.ts';
 import { startRun } from '../../runlog.ts';
 
 export interface PlanFlags {
-  readonly model?: string;
-  readonly out?: string;
+  readonly model: string;
+  readonly out: string;
   readonly timeout?: number;
   readonly preflight: boolean;
 }
@@ -63,7 +63,7 @@ export default async function plan(
   flags: PlanFlags,
   taskPrompt: string,
 ): Promise<void> {
-  const inputSlug = flags.model ?? DEFAULT_MODEL;
+  const inputSlug = flags.model;
   const model = resolveModel(inputSlug);
   if (!model) {
     this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);
@@ -86,11 +86,7 @@ export default async function plan(
   const promptSnippet = taskPrompt.replace(/\r?\n/g, ' ').slice(0, 80);
   const run = startRun('plan', `${model.spec.slug}: ${promptSnippet}`);
 
-  const absOutPath = flags.out
-    ? isAbsolute(flags.out)
-      ? flags.out
-      : resolve(cwd, flags.out)
-    : resolve(run.dir, 'plan.md');
+  const absOutPath = isAbsolute(flags.out) ? flags.out : resolve(cwd, flags.out);
 
   const beforePorcelain = await getPorcelainStatus(cwd);
 

package/src/commands/review/command.ts

@@ -1,5 +1,5 @@
 import { buildCommand } from '@stricli/core';
-import { DEFAULT_MODEL, listModelHelpLines } from '../../models.ts';
+import { listModelHelpLines } from '../../models.ts';
 import { positiveIntSeconds } from '../../parsers.ts';
 import reviewImpl from './impl.ts';
 
@@ -17,8 +17,7 @@ export const review = buildCommand({
       model: {
         kind: 'parsed',
         parse: String,
-        optional: true,
-        brief: `Model slug (default: ${DEFAULT_MODEL})`,
+        brief: 'Model slug (required) — see the seat list above',
       },
       plan: {
         kind: 'parsed',
@@ -35,8 +34,7 @@ export const review = buildCommand({
       out: {
         kind: 'parsed',
         parse: String,
-        optional: true,
-        brief: 'Where to write the review report (default: <run.dir>/review.md)',
+        brief: 'Where to write the review report (required)',
       },
       timeout: {
         kind: 'parsed',

package/src/commands/review/impl.ts

@@ -3,15 +3,15 @@ import { isAbsolute, resolve } from 'node:path';
 import { runCaptured } from '@aibridge/proc';
 import type { LocalContext } from '../../context.ts';
 import { delegate } from '../../delegate.ts';
-import { DEFAULT_MODEL, formatUnknownModelError, resolveModel } from '../../models.ts';
+import { formatUnknownModelError, resolveModel } from '../../models.ts';
 import { preflightModel, renderPreflightRefusal } from '../../quotaPreflight.ts';
 import { startRun } from '../../runlog.ts';
 
 export interface ReviewFlags {
-  readonly model?: string;
+  readonly model: string;
   readonly plan?: string;
   readonly base?: string;
-  readonly out?: string;
+  readonly out: string;
   readonly timeout?: number;
   readonly preflight: boolean;
 }
@@ -78,7 +78,7 @@ export function parseReviewVerdict(response: string): ReviewVerdictResult {
 }
 
 export default async function review(this: LocalContext, flags: ReviewFlags): Promise<void> {
-  const inputSlug = flags.model ?? DEFAULT_MODEL;
+  const inputSlug = flags.model;
   const model = resolveModel(inputSlug);
   if (!model) {
     this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);
@@ -140,11 +140,7 @@ export default async function review(this: LocalContext, flags: ReviewFlags): Pr
 
   const run = startRun('review', `${model.spec.slug}: ${modeDetail}`);
 
-  const absOutPath = flags.out
-    ? isAbsolute(flags.out)
-      ? flags.out
-      : resolve(cwd, flags.out)
-    : resolve(run.dir, 'review.md');
+  const absOutPath = isAbsolute(flags.out) ? flags.out : resolve(cwd, flags.out);
 
   let reviewPrompt: string;
   if (isDirty) {

package/src/commands/subagent/command.ts

@@ -1,5 +1,5 @@
 import { buildCommand } from '@stricli/core';
-import { DEFAULT_MODEL, listModelHelpLines } from '../../models.ts';
+import { listModelHelpLines } from '../../models.ts';
 import { nonEmptyPrompt, positiveIntSeconds } from '../../parsers.ts';
 import subagentImpl from './impl.ts';
 
@@ -8,7 +8,7 @@ const fullDescription = [
   '',
   'Available models (canonical slug):',
   ...listModelHelpLines(),
-  `Default: ${DEFAULT_MODEL} (off-budget). The claude-backend slugs are FALLBACKS for`,
+  'Recommended first choice: xai-grok/grok-4.5 (off-budget). The claude-backend slugs are FALLBACKS for',
   'when the off-budget CLIs are quota-exhausted — they bill your Claude subscription.',
 ].join('\n');
 
@@ -19,8 +19,7 @@ export const subagent = buildCommand({
       model: {
         kind: 'parsed',
         parse: String,
-        optional: true,
-        brief: `Model slug to delegate to (default: ${DEFAULT_MODEL})`,
+        brief: 'Model slug (required) — see the seat list above',
       },
       timeout: {
         kind: 'parsed',

package/src/commands/subagent/impl.ts

@@ -1,16 +1,11 @@
 import type { LocalContext } from '../../context.ts';
 import { delegate } from '../../delegate.ts';
-import {
-  backendModelId,
-  DEFAULT_MODEL,
-  formatUnknownModelError,
-  resolveModel,
-} from '../../models.ts';
+import { backendModelId, formatUnknownModelError, resolveModel } from '../../models.ts';
 import { preflightModel, renderPreflightRefusal } from '../../quotaPreflight.ts';
 import { startRun } from '../../runlog.ts';
 
 export interface SubagentFlags {
-  readonly model?: string;
+  readonly model: string;
   readonly timeout?: number;
   readonly tools: boolean;
   readonly preflight: boolean;
@@ -22,7 +17,7 @@ export default async function subagent(
   flags: SubagentFlags,
   prompt: string,
 ): Promise<void> {
-  const inputSlug = flags.model ?? DEFAULT_MODEL;
+  const inputSlug = flags.model;
   const model = resolveModel(inputSlug);
   if (!model) {
     this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);
@@ -72,10 +67,9 @@ export default async function subagent(
   }
 
   if (flags.json) {
-    const modelId = backendModelId(model) ?? null;
     this.process.stdout.write(
       `${JSON.stringify({
-        model: modelId,
+        model: backendModelId(model),
         slug: model.spec.slug,
         response: outcome.response,
         exitCode: outcome.exitCode,

package/src/delegate.ts

@@ -29,7 +29,7 @@ export async function delegate(
     tools: opts.tools,
     timeoutSec: opts.timeoutSec,
     cwd: opts.cwd,
-    backendModel: backendModelId(opts.model) ?? opts.model.spec.backendModel,
+    backendModel: backendModelId(opts.model),
     effort: opts.model.effort,
     onStdout: c => opts.run.stdout(c),
     onStderr: c => opts.run.stderr(c),

package/src/driver.ts

@@ -12,7 +12,7 @@ export interface DelegationTask {
   readonly tools: boolean;
   readonly timeoutSec: number;
   readonly cwd: string;
-  readonly backendModel: string | undefined;
+  readonly backendModel: string;
   readonly effort: Effort | undefined;
   readonly onStdout?: (chunk: string) => void;
   readonly onStderr?: (chunk: string) => void;
@@ -33,10 +33,9 @@ export type QuotaSnapshot = AgyQuotaSnapshot | CodexQuotaSnapshot | ClaudeQuotaS
 export interface ImageGenRequest {
   readonly prompt: string;
   readonly workDir: string;
-  readonly backendModel: string | undefined;
+  readonly backendModel: string;
   readonly effort: Effort | undefined;
-  readonly quality: string;
-  readonly size: { readonly w: number; readonly h: number } | undefined;
+  readonly aspectRatio: string | undefined;
   readonly imagePaths: readonly string[];
   readonly timeoutSec: number;
   readonly forceful: boolean;

package/src/drivers.ts

@@ -9,6 +9,7 @@ const agyDriver: AgentCliDriver = {
   probe: () => agy.probe(),
   run: task => agy.run(task),
   quota: () => agy.fetchAgyQuota(),
+  generateImage: req => agy.generateImage(req),
 };
 
 const grokDriver: AgentCliDriver = {