@aibridge/cli 0.2.0 → 0.4.0

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

@@ -1,5 +1,5 @@
 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';
 
@@ -9,7 +9,7 @@ const fullDescription = [
   '',
   'Image-gen seats (canonical slug):',
   ...listModelHelpLines({ imageOnly: true }),
-  `Default: ${DEFAULT_IMAGE_GEN}.`,
+  'Recommended seat: openai-codex/gpt-5.6-sol.',
 ].join('\n');
 
 export const imageGen = buildCommand({
@@ -19,8 +19,7 @@ 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',

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

@@ -15,7 +15,6 @@ import type { ImageResult } from '../../driver.ts';
 import { getDriver } from '../../drivers.ts';
 import {
   backendModelId,
-  DEFAULT_IMAGE_GEN,
   formatImageGenModelError,
   formatUnknownModelError,
   imageFormatFor,
@@ -24,7 +23,7 @@ import {
 } from '../../models.ts';
 
 export interface ImageGenFlags {
-  readonly model?: string;
+  readonly model: string;
   readonly out: string;
   readonly aspectRatio?: string;
   readonly image?: string;
@@ -45,14 +44,14 @@ 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 (the image tool 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.`,
     );
   }
 

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/models/command.ts

@@ -0,0 +1,18 @@
+import { buildCommand } from '@stricli/core';
+import modelsImpl from './impl.ts';
+
+export const models = buildCommand({
+  func: modelsImpl,
+  parameters: {
+    flags: {
+      json: {
+        kind: 'boolean',
+        withNegated: false,
+        brief: 'Emit the registry as JSON',
+      },
+    },
+  },
+  docs: {
+    brief: 'List every model seat in the registry (slug, efforts, image format)',
+  },
+});

package/src/commands/models/impl.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest';
+import type { LocalContext } from '../../context.ts';
+import { MODELS } from '../../models.ts';
+import modelsImpl from './impl.ts';
+
+function createTestContext() {
+  let stdoutText = '';
+  const fakeProcess = {
+    stdout: {
+      write(chunk: string | Uint8Array) {
+        stdoutText += chunk.toString();
+        return true;
+      },
+    },
+    stderr: {
+      write() {
+        return true;
+      },
+    },
+    exitCode: 0,
+  } as unknown as NodeJS.Process;
+
+  return {
+    ctx: { process: fakeProcess } as LocalContext,
+    getStdout: () => stdoutText,
+  };
+}
+
+describe('modelsImpl', () => {
+  it('--json emits parseable JSON with one entry per key of MODELS, with seven documented fields', () => {
+    const { ctx, getStdout } = createTestContext();
+    modelsImpl.call(ctx, { json: true });
+
+    const raw = getStdout();
+    const data = JSON.parse(raw);
+
+    expect(Array.isArray(data)).toBe(true);
+    expect(data.length).toBe(Object.keys(MODELS).length);
+
+    for (const item of data) {
+      expect(item).toHaveProperty('slug');
+      expect(item).toHaveProperty('backend');
+      expect(item).toHaveProperty('backendModel');
+      expect(item).toHaveProperty('efforts');
+      expect(item).toHaveProperty('defaultEffort');
+      expect(item).toHaveProperty('image');
+      expect(item).toHaveProperty('brief');
+      expect(Object.keys(item)).toHaveLength(7);
+    }
+  });
+
+  it('reports efforts: ["low", "high"] and defaultEffort: "high" for gemini-3.1-pro in JSON', () => {
+    const { ctx, getStdout } = createTestContext();
+    modelsImpl.call(ctx, { json: true });
+
+    const data = JSON.parse(getStdout());
+    const geminiPro = data.find(
+      (item: { slug: string }) => item.slug === 'google-antigravity/gemini-3.1-pro',
+    );
+    expect(geminiPro).toBeDefined();
+    expect(geminiPro.efforts).toEqual(['low', 'high']);
+    expect(geminiPro.defaultEffort).toBe('high');
+  });
+
+  it('reports backendModel and image correctly for opus-5 and gpt-5.6-sol in JSON', () => {
+    const { ctx, getStdout } = createTestContext();
+    modelsImpl.call(ctx, { json: true });
+
+    const data = JSON.parse(getStdout());
+    const opus = data.find((item: { slug: string }) => item.slug === 'anthropic-claude/opus-5');
+    expect(opus).toBeDefined();
+    expect(opus.backendModel).toBe('claude-opus-5[1m]');
+    expect(opus.image).toBeNull();
+
+    const sol = data.find((item: { slug: string }) => item.slug === 'openai-codex/gpt-5.6-sol');
+    expect(sol).toBeDefined();
+    expect(sol.image).toBe('png');
+  });
+
+  it('human output (no --json) contains every slug in MODELS', () => {
+    const { ctx, getStdout } = createTestContext();
+    modelsImpl.call(ctx, { json: false });
+
+    const output = getStdout();
+    for (const slug of Object.keys(MODELS)) {
+      expect(output).toContain(slug);
+    }
+  });
+});

package/src/commands/models/impl.ts

@@ -0,0 +1,71 @@
+import type { LocalContext } from '../../context.ts';
+import { type Backend, imageFormatFor, MODELS } from '../../models.ts';
+
+export interface ModelsFlags {
+  readonly json: boolean;
+}
+
+const BACKEND_DISPLAY_NAMES: Record<Backend, string> = {
+  grok: 'grok (Grok CLI)',
+  agy: 'agy (Antigravity)',
+  codex: 'codex (Codex CLI)',
+  claude: 'claude (Claude Code CLI)',
+};
+
+export default function modelsImpl(this: LocalContext, flags: ModelsFlags): void {
+  const specs = Object.values(MODELS);
+
+  if (flags.json) {
+    const jsonOutput = specs.map(spec => ({
+      slug: spec.slug,
+      backend: spec.backend,
+      backendModel: spec.backendModel,
+      efforts: spec.efforts ? [...spec.efforts] : [],
+      defaultEffort: spec.defaultEffort ?? null,
+      image: imageFormatFor({ spec, effort: undefined }) ?? null,
+      brief: spec.brief,
+    }));
+    this.process.stdout.write(`${JSON.stringify(jsonOutput)}\n`);
+    return;
+  }
+
+  const backends: Backend[] = [];
+  for (const spec of specs) {
+    if (!backends.includes(spec.backend)) {
+      backends.push(spec.backend);
+    }
+  }
+
+  let firstBackend = true;
+  for (const backend of backends) {
+    if (!firstBackend) {
+      this.process.stdout.write('\n');
+    }
+    firstBackend = false;
+
+    this.process.stdout.write(`=== ${BACKEND_DISPLAY_NAMES[backend]} ===\n`);
+    const backendSpecs = specs.filter(spec => spec.backend === backend);
+    for (const spec of backendSpecs) {
+      this.process.stdout.write(`  ${spec.slug}\n`);
+
+      const segments: string[] = [];
+      if (spec.efforts) {
+        const formattedEfforts = spec.efforts
+          .map(e => (e === spec.defaultEffort ? `${e}*` : e))
+          .join(' | ');
+        segments.push(`efforts: ${formattedEfforts}`);
+      }
+      const img = imageFormatFor({ spec, effort: undefined });
+      segments.push(`image: ${img ?? '—'}`);
+      segments.push(`id: ${spec.backendModel}`);
+
+      this.process.stdout.write(`    ${segments.join(' · ')}\n`);
+      this.process.stdout.write(`    ${spec.brief}\n`);
+    }
+  }
+
+  const hasDefaultEffort = specs.some(spec => spec.defaultEffort !== undefined);
+  if (hasDefaultEffort) {
+    this.process.stdout.write('\n* = effort used when the slug has no -<effort> suffix\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/quota/command.ts

@@ -2,6 +2,8 @@ import { buildCommand } from '@stricli/core';
 import quotaImpl from './impl.ts';
 
 const fullDescription = [
+  'grok: reads ~/.grok/auth.json and asks the xAI billing endpoint for the',
+  'weekly credit usage percentage and per-product split.',
   'agy: reads its cached OAuth token (~/.gemini/antigravity-cli/) and asks the',
   'Cloud Code API for per-model remaining quota. EXHAUSTED means agy turns on',
   'that model fail with an empty answer until the reset time.',
@@ -24,7 +26,7 @@ export const quota = buildCommand({
     },
   },
   docs: {
-    brief: 'Show agy / codex / claude quota with reset times',
+    brief: 'Show grok / agy / codex / claude quota with reset times',
     fullDescription,
   },
 });

package/src/commands/quota/impl.ts

@@ -1,6 +1,7 @@
 import { type AgyQuotaSnapshot, fetchAgyQuota } from '@aibridge/driver-agy';
 import { type ClaudeQuotaSnapshot, fetchClaudeQuota } from '@aibridge/driver-claude';
 import { type CodexQuotaSnapshot, fetchCodexQuota } from '@aibridge/driver-codex';
+import { fetchGrokQuota, type GrokQuotaSnapshot } from '@aibridge/driver-grok';
 import type { LocalContext } from '../../context.ts';
 
 export interface QuotaFlags {
@@ -17,6 +18,20 @@ function formatReset(resetTime: string | undefined): string {
   return `${new Date(resetTime).toLocaleTimeString()} (in ${rel})`;
 }
 
+function renderGrok(ctx: LocalContext, snapshot: GrokQuotaSnapshot): void {
+  ctx.process.stdout.write('=== grok (xAI) — used this period ===\n');
+  ctx.process.stdout.write(`${'PERIOD'.padEnd(10)} ${'USED'.padEnd(10)} RESET\n`);
+  const usedPctStr = snapshot.usedPercent !== undefined ? `${snapshot.usedPercent}%` : '?';
+  const periodStr = snapshot.periodType ?? '-';
+  ctx.process.stdout.write(
+    `${periodStr.padEnd(10)} ${usedPctStr.padEnd(10)} ${formatReset(snapshot.periodEnd)}\n`,
+  );
+  if (snapshot.products.length > 0) {
+    const prods = snapshot.products.map(p => `${p.product} ${p.usedPercent}%`).join(' · ');
+    ctx.process.stdout.write(`  ${prods}\n`);
+  }
+}
+
 function renderAgy(ctx: LocalContext, snapshot: AgyQuotaSnapshot): void {
   ctx.process.stdout.write('=== agy (Antigravity) — remaining per model group ===\n');
   for (const group of snapshot.groups) {
@@ -75,19 +90,24 @@ function renderSection<T>(
 }
 
 export default async function quotaImpl(this: LocalContext, flags: QuotaFlags): Promise<void> {
-  const [agy, codex, claude] = await Promise.allSettled([
+  const [grok, agy, codex, claude] = await Promise.allSettled([
+    fetchGrokQuota(),
     fetchAgyQuota(),
     fetchCodexQuota(),
     fetchClaudeQuota(),
   ]);
 
   const allFailed =
-    agy.status === 'rejected' && codex.status === 'rejected' && claude.status === 'rejected';
+    grok.status === 'rejected' &&
+    agy.status === 'rejected' &&
+    codex.status === 'rejected' &&
+    claude.status === 'rejected';
 
   if (flags.json) {
     this.process.stdout.write(
       `${JSON.stringify(
         {
+          grok: grok.status === 'fulfilled' ? grok.value : { error: String(grok.reason) },
           agy: agy.status === 'fulfilled' ? agy.value : { error: String(agy.reason) },
           codex: codex.status === 'fulfilled' ? codex.value : { error: String(codex.reason) },
           claude: claude.status === 'fulfilled' ? claude.value : { error: String(claude.reason) },
@@ -100,6 +120,8 @@ export default async function quotaImpl(this: LocalContext, flags: QuotaFlags):
     return;
   }
 
+  renderSection(this, grok, 'grok (xAI)', renderGrok);
+  this.process.stdout.write('\n');
   renderSection(this, agy, 'agy (Antigravity)', renderAgy);
   this.process.stdout.write('\n');
   renderSection(this, codex, 'codex (ChatGPT)', renderCodex);

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,8 +8,8 @@ const fullDescription = [
   '',
   'Available models (canonical slug):',
   ...listModelHelpLines(),
-  `Default: ${DEFAULT_MODEL} (off-budget). The claude-backend slugs are FALLBACKS for`,
-  'when the off-budget CLIs are quota-exhausted — they bill your Claude subscription.',
+  'Recommended first choice: xai-grok/grok-4.5. Whichever seat runs on the same provider as the',
+  'agent you orchestrate from is your last resort — it spends the pool you are already burning.',
 ].join('\n');
 
 export const subagent = buildCommand({
@@ -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`);

package/src/driver.ts

@@ -1,6 +1,7 @@
 import type { AgyQuotaSnapshot } from '@aibridge/driver-agy';
 import type { ClaudeQuotaSnapshot } from '@aibridge/driver-claude';
 import type { CodexQuotaSnapshot } from '@aibridge/driver-codex';
+import type { GrokQuotaSnapshot } from '@aibridge/driver-grok';
 import type { Effort } from './models.ts';
 
 export type Availability =
@@ -28,7 +29,11 @@ export type DelegationResult =
       readonly exitCode: number | null;
     };
 
-export type QuotaSnapshot = AgyQuotaSnapshot | CodexQuotaSnapshot | ClaudeQuotaSnapshot;
+export type QuotaSnapshot =
+  | AgyQuotaSnapshot
+  | CodexQuotaSnapshot
+  | ClaudeQuotaSnapshot
+  | GrokQuotaSnapshot;
 
 export interface ImageGenRequest {
   readonly prompt: string;

package/src/drivers.ts

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

package/src/flagMapping.test.ts

@@ -35,7 +35,7 @@ describe('flag mapping & defaults lock', () => {
   it('plan command maps defaults correctly', async () => {
     mockPlanImpl.mockReset();
     const ctx = fakeCtx();
-    await runCli(ctx, ['plan', 'do something']);
+    await runCli(ctx, ['plan', '--model', 'xai-grok/grok-4.5', '--out', 'plan.md', 'do something']);
     expect(mockPlanImpl).toHaveBeenCalledTimes(1);
     const [call] = mockPlanImpl.mock.calls;
     expect(call).toBeDefined();
@@ -43,6 +43,8 @@ describe('flag mapping & defaults lock', () => {
     const [flags, prompt] = call;
     expect(prompt).toBe('do something');
     expect(flags).toEqual({
+      model: 'xai-grok/grok-4.5',
+      out: 'plan.md',
       preflight: true,
     });
   });
@@ -50,7 +52,17 @@ describe('flag mapping & defaults lock', () => {
   it('plan command handles --no-preflight and --timeout', async () => {
     mockPlanImpl.mockReset();
     const ctx = fakeCtx();
-    await runCli(ctx, ['plan', '--no-preflight', '--timeout', '120', 'task']);
+    await runCli(ctx, [
+      'plan',
+      '--model',
+      'xai-grok/grok-4.5',
+      '--out',
+      'plan.md',
+      '--no-preflight',
+      '--timeout',
+      '120',
+      'task',
+    ]);
     expect(mockPlanImpl).toHaveBeenCalledTimes(1);
     const [call] = mockPlanImpl.mock.calls;
     expect(call).toBeDefined();
@@ -58,6 +70,8 @@ describe('flag mapping & defaults lock', () => {
     const [flags, prompt] = call;
     expect(prompt).toBe('task');
     expect(flags).toEqual({
+      model: 'xai-grok/grok-4.5',
+      out: 'plan.md',
       preflight: false,
       timeout: 120,
     });
@@ -66,7 +80,7 @@ describe('flag mapping & defaults lock', () => {
   it('subagent command maps defaults correctly', async () => {
     mockSubagentImpl.mockReset();
     const ctx = fakeCtx();
-    await runCli(ctx, ['subagent', 'hello agent']);
+    await runCli(ctx, ['subagent', '--model', 'xai-grok/grok-4.5', 'hello agent']);
     expect(mockSubagentImpl).toHaveBeenCalledTimes(1);
     const [call] = mockSubagentImpl.mock.calls;
     expect(call).toBeDefined();
@@ -74,6 +88,7 @@ describe('flag mapping & defaults lock', () => {
     const [flags, prompt] = call;
     expect(prompt).toBe('hello agent');
     expect(flags).toEqual({
+      model: 'xai-grok/grok-4.5',
       tools: true,
       preflight: true,
       json: false,
@@ -83,7 +98,14 @@ describe('flag mapping & defaults lock', () => {
   it('subagent command handles --no-tools and --no-preflight', async () => {
     mockSubagentImpl.mockReset();
     const ctx = fakeCtx();
-    await runCli(ctx, ['subagent', '--no-tools', '--no-preflight', 'hello agent']);
+    await runCli(ctx, [
+      'subagent',
+      '--model',
+      'xai-grok/grok-4.5',
+      '--no-tools',
+      '--no-preflight',
+      'hello agent',
+    ]);
     expect(mockSubagentImpl).toHaveBeenCalledTimes(1);
     const [call] = mockSubagentImpl.mock.calls;
     expect(call).toBeDefined();
@@ -91,6 +113,7 @@ describe('flag mapping & defaults lock', () => {
     const [flags, prompt] = call;
     expect(prompt).toBe('hello agent');
     expect(flags).toEqual({
+      model: 'xai-grok/grok-4.5',
       tools: false,
       preflight: false,
       json: false,