@bill10/agent-007 0.11.0 → 0.12.1000

package/README.md

@@ -13,7 +13,7 @@ Use it as far along as you need:
 
 1. **One task: one agent in a web terminal.** Start Claude Code, Codex or any CLI agent in the browser. Add a repo once; every agent gets its own git worktree and branch, so you never set one up by hand.
 2. **Many tasks across projects: many terminals, one window.** Every repo and every agent in one place, with live terminals, a file explorer, inline diffs, and a pixel office where each agent faces its screen while it works and turns to you when it needs you.
-3. **Stop watching them: a job board.** Put tasks on the board and Claude Code or Codex workers pick them up, each in its own worktree, and move them To do -> In progress -> Review on their own, landing as a pull request (or a summary, for work that isn't code). Cards can run on a cron schedule, and agents can post cards and message each other.
+3. **Stop watching them: a job board.** Put tasks on the board and Claude Code or Codex workers pick them up, each in its own worktree, and move them To do -> In progress -> Review on their own, landing as a pull request (or a summary, for work that isn't code). Cards can run on a cron schedule and pick their model (strong for hard code, fast for docs), from the models the board finds installed, and agents can post cards and message each other.
 4. **Stop posting jobs: give Billion a goal.** Billion is one always-on agent that plans, posts the jobs, reviews what comes back and merges the PRs. It only asks you about money, access or anything irreversible.
 
 Claude Code, Codex, any terminal agent is supported -- use your existing subscriptions, no extra charge.

package/VERSION

@@ -1 +1 @@
-0.11.0.0
+0.12.1.0

package/lib/jobs.js

@@ -395,17 +395,48 @@ export function isCodexSessionId(value) {
 // known — it is the board's current word. With neither, the CLI's own
 // default applies. Both go through their allowlists here, so this is the one
 // place that guarantees nothing but a permission reaches the argv.
-export function resumeCommand(agent, mode, flags, sessionId) {
+//
+// `model` is the card's model, so a worker picked for a strong model does not
+// come back on the CLI's default.
+export function resumeCommand(agent, mode, flags, sessionId, model = null) {
   const validMode = isValidPermissionMode(mode) ? mode : null;
   const own = validMode ? '' : normalizePermissionFlags(agent === 'codex' ? 'codex' : 'claude', flags).join(' ');
+  const m = modelFlag(agent === 'codex' ? 'codex' : 'claude', model);
   if (agent === 'codex') {
     const flag = validMode ? CODEX_MODE_FLAGS[validMode] : own;
     // The id reaches the argv, so only a real session id passes.
     const target = isCodexSessionId(sessionId) ? ` ${sessionId}` : '';
-    return `codex resume${target}${flag ? ` ${flag}` : ''}`;
+    return `codex resume${target}${flag ? ` ${flag}` : ''}${m ? ` ${m}` : ''}`;
   }
   const flag = validMode ? `--permission-mode ${validMode}` : own;
-  return `claude --continue${flag ? ` ${flag}` : ''}`;
+  return `claude --continue${flag ? ` ${flag}` : ''}${m ? ` ${m}` : ''}`;
+}
+
+// A card's model: a name its CLI's --model / -m takes. It reaches the argv, so
+// besides being one the server discovered (server/models.js) it must be a
+// single plain token — no space, quote or leading dash.
+export function isSafeModelName(model) {
+  return typeof model === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:\[\]-]{0,99}$/.test(model);
+}
+
+// Empty is null: the CLI's own default. `available` is the discovered list per
+// CLI; left out (a schedule's run, copying a model its schedule already
+// passed), only the shape is checked.
+export function resolveJobModel(model, agent, available) {
+  if (model === undefined || model === null || model === '') return { model: null };
+  const list = available ? (available[agent] || []) : null;
+  if (!isSafeModelName(model) || (list && !list.includes(model))) {
+    const shown = typeof model === 'string' ? `"${model.slice(0, 40)}"` : `a ${typeof model}`;
+    return { error: `Unknown model ${shown} for ${agent} \u2014 expected one of: ${list?.length ? list.join(', ') : '(none discovered; leave it empty for the CLI default)'}` };
+  }
+  return { model };
+}
+
+// The model flag for that CLI, or nothing for the default. Quoted though the
+// name is already a plain token, the same as every other value put on the argv.
+export function modelFlag(agent, model) {
+  if (!isSafeModelName(model)) return '';
+  return `${agent === 'codex' ? '-m' : '--model'} ${quote(model)}`;
 }
 
 export function resolveJobAgent(agent) {
@@ -468,7 +499,7 @@ export function newJobId() {
 export const MAX_TITLE_LEN = 200;
 export const MAX_DETAIL_LEN = 20000;
 
-export function createJob({ title, detail, repoPath, type, schedule, permissionMode, agent, requiresPr, postedBy, postedByName, postedByAgent, postedByBillion }) {
+export function createJob({ title, detail, repoPath, type, schedule, permissionMode, agent, model, availableModels, requiresPr, postedBy, postedByName, postedByAgent, postedByBillion }) {
   const cleanTitle = String(title || '').trim().slice(0, MAX_TITLE_LEN);
   if (!cleanTitle) return { error: 'Title is required' };
   if (!repoPath) return { error: 'Repository is required' };
@@ -481,6 +512,8 @@ export function createJob({ title, detail, repoPath, type, schedule, permissionM
   if (mode.error) return { error: mode.error };
   const cli = resolveJobAgent(agent);
   if (cli.error) return { error: cli.error };
+  const chosen = resolveJobModel(model, cli.agent, availableModels);
+  if (chosen.error) return { error: chosen.error };
   return {
     job: {
       id: newJobId(),
@@ -504,7 +537,8 @@ export function createJob({ title, detail, repoPath, type, schedule, permissionM
       // Which CLI is spawned for it. Cards written before this existed have no
       // field, which jobAgent reads as claude.
       agent: cli.agent,
-      // See jobRequiresPr. Only false when the poster said so.
+      // The model its CLI runs, or null for the CLI's default. See resolveJobModel.
+      model: chosen.model,
       // See jobRequiresPr. Unset takes the type's default.
       requiresPr: typeof requiresPr === 'boolean' ? requiresPr : defaultRequiresPr(resolved.type),
       detail: String(detail || '').trim().slice(0, MAX_DETAIL_LEN),
@@ -692,8 +726,8 @@ function oneTimePromptSuffix(agent = DEFAULT_JOB_AGENT, requiresPr = true, fromB
     ...(fromBillion ? [
       '',
       `${BILLION_NAME} posted this card. If you are blocked on a decision only it can`,
-      `make, ask it with the send_message tool (to: "${BILLION_NAME}") rather than waiting`,
-      'for a person; its answer arrives in this terminal.',
+      `make, ask it with the agent-007-board send_message tool (to: "${BILLION_NAME}") rather`,
+      'than waiting for a person; its answer arrives in this terminal.',
     ] : []),
     '',
     ...finish,
@@ -742,10 +776,11 @@ export function buildJobCommand(job, { permissionMode = DEFAULT_PERMISSION_MODE
   if (jobAgent(job) === 'codex') {
     // No --add-dir: every Codex sandbox, read-only included, reads anywhere
     // on disk and gates only writes, and attachments are only ever read.
-    const flags = permissionModeFlags('codex', mode).join(' ');
+    const flags = [...permissionModeFlags('codex', mode), modelFlag('codex', job.model)].filter(Boolean).join(' ');
     return `codex ${flags ? `${flags} ` : ''}${quote(buildJobPrompt(job))}`;
   }
-  return `claude ${permissionModeFlags('claude', mode).join(' ')} ${quote(buildJobPrompt(job))}${dirs.map(d => ` --add-dir ${quote(d)}`).join('')}`;
+  const m = modelFlag('claude', job.model);
+  return `claude ${permissionModeFlags('claude', mode).join(' ')}${m ? ` ${m}` : ''} ${quote(buildJobPrompt(job))}${dirs.map(d => ` --add-dir ${quote(d)}`).join('')}`;
 }
 
 // --- Live status (derived, never stored) ---
@@ -849,6 +884,7 @@ export function createRunJob(schedule) {
     type: 'one-time',
     permissionMode: schedule.permissionMode,
     agent: schedule.agent,
+    model: schedule.model,
     requiresPr: jobRequiresPr(schedule),
     postedBy: schedule.postedBy,
     postedByName: schedule.postedByName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bill10/agent-007",
-  "version": "0.11.0",
+  "version": "0.12.1000",
   "description": "From web terminals for your coding agents to a self-running agent company: Claude Code and Codex in parallel git worktrees, a job board they pick work from, and one agent that runs the board from a goal.",
   "license": "MIT",
   "repository": {

package/public/index.html

@@ -167,6 +167,11 @@
                   <option value="codex">Codex</option>
                 </select>
               </label>
+              <label title="Which model this job's agent runs. The list is what the board found for the chosen CLI on this computer; CLI default leaves the choice to the CLI.">Model
+                <select id="job-model">
+                  <option value="">CLI default</option>
+                </select>
+              </label>
               <label title="How much this job's agent may do without asking. Leave it on the board default unless this one job needs something different. A Codex card offers auto (Codex's own default) and bypassPermissions (--dangerously-bypass-approvals-and-sandbox); a board set to another mode maps onto Codex's nearest flag: plan is read-only, manual asks before every command, dontAsk never asks.">Permissions
                 <select id="job-permission-mode-field">
                   <option value="">Board default</option>

package/public/modules/jobs.js

@@ -284,6 +284,13 @@ function renderCard(job) {
     chip.title = 'Finishes with a summary from its agent instead of a pull request';
     title.appendChild(chip);
   }
+  if (job.model) {
+    const chip = document.createElement('span');
+    chip.className = 'job-card-type';
+    chip.textContent = job.model;
+    chip.title = `Runs on the ${job.model} model instead of the CLI's default`;
+    title.appendChild(chip);
+  }
   if (job.permissionMode) {
     // Only when the card overrides the board. The mode decides how much its
     // agent may do unasked, so a card carrying its own must say so on its face
@@ -730,6 +737,32 @@ function syncAgentField() {
     opt.textContent = codex ? opt.dataset.codexLabel : opt.dataset.claudeLabel;
   }
   markDangerousMode(permEl);
+  syncModelField();
+}
+
+// The discovered models for the chosen CLI (server/models.js), plus the one
+// the card already holds if discovery no longer lists it, so opening the form
+// never silently changes it.
+let models = { claude: [], codex: [] };
+let formModel = '';
+let formAgent = 'claude';
+function syncModelField() {
+  const el = document.getElementById('job-model');
+  if (!el) return;
+  const agent = document.getElementById('job-agent')?.value === 'codex' ? 'codex' : 'claude';
+  const list = [...(models[agent] || [])];
+  if (formModel && agent === formAgent && !list.includes(formModel)) list.push(formModel);
+  // The card's own value on open; after that, whatever is picked.
+  const keep = el.dataset.filled ? el.value : formModel;
+  el.dataset.filled = '1';
+  el.innerHTML = '<option value="">CLI default</option>';
+  for (const m of list) {
+    const opt = document.createElement('option');
+    opt.value = m;
+    opt.textContent = m;
+    el.appendChild(opt);
+  }
+  el.value = list.includes(keep) ? keep : '';
 }
 
 // A shape check only — five whitespace-separated fields, or a known @shorthand.
@@ -801,6 +834,12 @@ function openForm(jobId) {
   // which would silently freeze the card onto today's setting.
   if (permEl) permEl.value = job && job.permissionMode ? job.permissionMode : '';
   if (agentEl) agentEl.value = job && job.agent === 'codex' ? 'codex' : 'claude';
+  formModel = job && job.model ? job.model : '';
+  formAgent = agentEl ? agentEl.value : 'claude';
+  const modelEl = document.getElementById('job-model');
+  if (modelEl) delete modelEl.dataset.filled;
+  // The server looks again if its list is over 10 minutes old.
+  send({ type: 'models-refresh' });
   prPicked = false;
   prEl.value = job ? (job.requiresPr === false || (isScheduled(job) && job.requiresPr !== true) ? 'no' : 'yes') : 'yes';
   syncAgentField();   // also marks the danger colour on the permission select
@@ -849,7 +888,11 @@ function saveForm() {
   // The form always holds the complete list; an empty one on an edit means
   // "none left".
   const attachments = pendingAttachments.map(a => ({ name: a.name, data: a.data }));
+  const model = document.getElementById('job-model')?.value || '';
   const fields = { title, detail, repoPath, jobType, schedule, permissionMode, agent, requiresPr, attachments };
+  // An edit that leaves the model alone does not send it, so a card whose
+  // model discovery no longer lists can still be retitled.
+  if (!editingJobId || model !== formModel) fields.model = model;
   if (editingJobId) send({ type: 'job-update', jobId: editingJobId, ...fields });
   else send({ type: 'job-create', ...fields });
   closeForm();
@@ -899,6 +942,7 @@ export function handleJobsList(msg) {
   jobs.clear();
   for (const job of msg.jobs || []) jobs.set(job.id, job);
   if (msg.settings) setBoardSettings(msg.settings);
+  if (msg.models) { models = msg.models; syncModelField(); }
   renderToolbar();
   renderBoard();
   if (window._onBoardVisibilityChanged) window._onBoardVisibilityChanged();

package/server/http.js

@@ -18,6 +18,7 @@ import { requestApproval, answerApproval } from './approvals.js';
 import { agentSummaries, sendMessage, flushMessages, pendingMessages, readAgentScreen } from './messages.js';
 import { handleMcpMessage } from './mcp.js';
 import { notifyOwner } from './owner.js';
+import { availableModels } from './models.js';
 
 // --- Origin Check Middleware (B2) ---
 // Rejects cross-origin requests from disallowed origins. localhost is always
@@ -106,6 +107,7 @@ export function setupRoutes(app, staticDir, { broadcast, killSession, respawnAge
     try {
       reply = await handleMcpMessage(req.body, {
         session: req.agentSession,
+        models: availableModels(),
         postJob: (fields) => postJobForAgent({ ...fields, user: userById(req.agentSession.ownerId) }, broadcast),
         listJobs: listJobsForAgent,
         readJob: readJobForAgent,
@@ -195,6 +197,7 @@ export function setupRoutes(app, staticDir, { broadcast, killSession, respawnAge
       type: body.type,
       schedule: body.schedule,
       agent: body.agent,
+      model: body.model,
       requiresPr: body.requiresPr ?? body.requires_pr,
       session,
       user: req.user || (session ? userById(session.ownerId) : null),

package/server/jobs.js

@@ -27,8 +27,9 @@ import {
   MAX_TITLE_LEN, MAX_DETAIL_LEN, isScheduled, jobType, resolveJobType, jobRequiresPr,
   scheduleHold, supersededRuns, createRunJob, runsToPrune, defaultRequiresPr, isJobDue, STATE_LABELS,
   jobAgent, jobAgentFromCommand, resolveJobAgent, resumeCommand, isValidJobAgent, recordedPermissionFlags,
-  BILLION_NAME, envPermissionMode,
+  BILLION_NAME, envPermissionMode, resolveJobModel,
 } from '../lib/jobs.js';
+import { availableModels } from './models.js';
 import { nextCronIso } from '../lib/cron.js';
 
 // --- Board settings ---
@@ -127,7 +128,8 @@ export function jobsPayload() {
   // The .env defaults ride along, so the toolbar can show the mode workers
   // really start in while no mode has been picked there.
   const envModes = { claude: envPermissionMode('claude'), codex: envPermissionMode('codex') };
-  return { type: 'jobs-list', jobs, settings: { ...boardSettings(), envModes } };
+  // The models each CLI's dropdown offers (server/models.js).
+  return { type: 'jobs-list', jobs, settings: { ...boardSettings(), envModes }, models: availableModels() };
 }
 
 export function broadcastJobs(broadcast) {
@@ -303,8 +305,8 @@ function clearFinishedAttachments() {
 
 // --- CRUD ---
 
-export function addJob({ title, detail, repoPath, type, schedule, permissionMode, agent, requiresPr, postedBy, postedByName, postedByAgent, postedByBillion, attachments }, broadcast) {
-  const result = createJob({ title, detail, repoPath, type, schedule, permissionMode, agent, requiresPr, postedBy, postedByName, postedByAgent, postedByBillion });
+export function addJob({ title, detail, repoPath, type, schedule, permissionMode, agent, model, requiresPr, postedBy, postedByName, postedByAgent, postedByBillion, attachments }, broadcast) {
+  const result = createJob({ title, detail, repoPath, type, schedule, permissionMode, agent, model, availableModels: availableModels(), requiresPr, postedBy, postedByName, postedByAgent, postedByBillion });
   if (result.error) return result;
   const plan = planAttachments(result.job, attachments);
   if (plan?.error) return plan;
@@ -366,7 +368,7 @@ function scheduleTypeError(schedule) {
     : null;
 }
 
-export function postJobForAgent({ title, detail, repo, schedule, type, agent, requiresPr, session, user }, broadcast) {
+export function postJobForAgent({ title, detail, repo, schedule, type, agent, model, requiresPr, session, user }, broadcast) {
   // The repo the calling agent is working in is the overwhelmingly likely
   // answer, so an agent only names one when it means a different repo.
   const resolved = resolveRepoRef(repo || (session && session.repoPath) || '');
@@ -403,6 +405,9 @@ export function postJobForAgent({ title, detail, repo, schedule, type, agent, re
     // Unnamed, the card runs on the same CLI as the agent posting it; a person
     // at the HTTP door with no session gets the board default.
     agent: agent || (session ? jobAgentFromCommand(session.command) : undefined),
+    // Checked against the discovered list by createJob, and put on the argv
+    // as one token by buildJobCommand.
+    model,
     requiresPr,
     // No permissionMode: an agent posting a card must not be able to pick the
     // mode the board will spawn with, which would be a way around every gate
@@ -450,6 +455,7 @@ function jobSummary(job) {
     state: job.state,
     type: jobType(job),
     agent: jobAgent(job),
+    model: job.model || null,
     requiresPr: jobRequiresPr(job),
     schedule: job.schedule || null,
     nextRunAt: job.nextRunAt || null,
@@ -543,7 +549,7 @@ export function readJobForAgent(jobId) {
 // land says so out loud and leaves its name on the card, because the whole
 // hazard is an edit nobody sees. Reading stays board-wide — every browser
 // already sees every card — but writing does not.
-export function editJobForAgent({ id, title, detail, repo, schedule, requiresPr, session, user }, broadcast) {
+export function editJobForAgent({ id, title, detail, repo, schedule, model, requiresPr, session, user }, broadcast) {
   const job = allJobs().find(j => j.id === id);
   if (!job) return { error: `No job with id "${id}" — list the board to see the ids.` };
   const gate = editableInPlace(job);
@@ -593,6 +599,11 @@ export function editJobForAgent({ id, title, detail, repo, schedule, requiresPr,
     fields.type = text ? 'scheduled' : 'one-time';
     if (text !== (job.schedule || '')) changed.push('schedule');
   }
+  if (model !== undefined && (model || null) !== (job.model || null)) {
+    // updateJob validates it against the card's agent.
+    fields.model = model;
+    changed.push('model');
+  }
   if (requiresPr !== undefined) {
     if (typeof requiresPr !== 'boolean') return { error: 'requires_pr must be true or false' };
     // Always passed on, so a type change in the same call cannot swap it for
@@ -602,7 +613,7 @@ export function editJobForAgent({ id, title, detail, repo, schedule, requiresPr,
   }
 
   if (!changed.length) {
-    return { error: 'Nothing to change — pass a new title, detail, repo, schedule or requires_pr.' };
+    return { error: 'Nothing to change — pass a new title, detail, repo, schedule, model or requires_pr.' };
   }
   const result = updateJob(job.id, fields, broadcast);
   if (result.error) return result;
@@ -815,6 +826,16 @@ export function updateJob(jobId, fields, broadcast) {
     cli = resolveJobAgent(fields.agent);
     if (cli.error) return { error: cli.error };
   }
+  // Checked against the agent the card will have. A card switched to another
+  // CLI with no model named drops its old one, which belongs to the old CLI.
+  const nextAgent = cli ? cli.agent : jobAgent(job);
+  let chosen = null;
+  if (fields.model !== undefined) {
+    chosen = resolveJobModel(fields.model, nextAgent, availableModels());
+    if (chosen.error) return { error: chosen.error };
+  } else if (nextAgent !== jobAgent(job)) {
+    chosen = { model: null };
+  }
   // Type and schedule move together: "scheduled with no cron" and "one-time
   // carrying a cron" are both incoherent, so they are resolved as a pair and
   // rejected as a pair.
@@ -839,6 +860,7 @@ export function updateJob(jobId, fields, broadcast) {
   if (fields.repoPath) job.repoPath = fields.repoPath;
   if (mode) job.permissionMode = mode.permissionMode;
   if (cli) job.agent = cli.agent;
+  if (chosen) job.model = chosen.model;
   const typeChanged = !!resolved && resolved.type !== jobType(job);
   if (resolved) {
     job.type = resolved.type;
@@ -1327,7 +1349,10 @@ export function orphanResumePlan(orphan, homes) {
   const sessionId = agent !== 'codex' ? null
     : probed ? probed.codexSessionId
     : codexSessionIdFor(orphan.worktreePath, homes);
-  return { agent, mode, flags, command: resumeCommand(agent, mode, flags, sessionId) };
+  // The card's model, when the card is for this CLI: a worker picked for a
+  // strong model comes back on it, not the CLI's default.
+  const model = card && jobAgent(card) === agent ? card.model || null : null;
+  return { agent, mode, flags, command: resumeCommand(agent, mode, flags, sessionId, model) };
 }
 
 export function resumeCommandForOrphan(orphan, homes) {

package/server/mcp.js

@@ -36,6 +36,12 @@ export const SERVER_INFO = { name: 'agent-007-board', version: '1' };
 // for and — deliberately — when to reach for it. "When the user asks" is the
 // operative clause: a job board full of work an agent queued for itself is not
 // what this is for.
+// The model field's description. toolsFor appends the models discovered on
+// this machine right now, since those are the only values the board accepts.
+const MODEL_HELP = 'Optional. Which model the card\'s CLI runs, from the list below for its '
+  + 'agent; empty for the CLI\'s default. A strong model for core code, security and '
+  + 'debugging; a fast one for docs, mechanical edits and research.';
+
 export const POST_JOB_TOOL = {
   name: 'post_job',
   description:
@@ -84,6 +90,10 @@ export const POST_JOB_TOOL = {
           'Optional. Which CLI the board spawns for this card: claude (Claude Code) '
           + 'or codex. Defaults to the one you are running as.',
       },
+      model: {
+        type: 'string',
+        description: MODEL_HELP,
+      },
       requires_pr: {
         type: 'boolean',
         description:
@@ -152,7 +162,7 @@ export const EDIT_JOB_TOOL = {
   name: 'edit_job',
   description:
     'Change a card that is still in To do: its title, detail, repository, '
-    + 'schedule or whether it requires a pull request. Only To do cards can be edited — once the board has dispatched a '
+    + 'schedule, model or whether it requires a pull request. Only To do cards can be edited — once the board has dispatched a '
     + 'card its agent has already been handed the text, so a later edit would leave '
     + 'the card describing work nobody was asked to do. Pass only the fields that '
     + 'change; the rest are left alone. Ids come from list_jobs.',
@@ -177,6 +187,10 @@ export const EDIT_JOB_TOOL = {
           'Replaces the cron schedule (five fields, or an @shorthand). Pass an empty '
           + 'string to turn a scheduled card back into one that runs once.',
       },
+      model: {
+        type: 'string',
+        description: `${MODEL_HELP} Switching the card's agent without naming a model clears it.`,
+      },
       requires_pr: {
         type: 'boolean',
         description:
@@ -398,8 +412,21 @@ export const RESPAWN_AGENT_TOOL = {
 export const TOOLS = [POST_JOB_TOOL, LIST_JOBS_TOOL, READ_JOB_TOOL, EDIT_JOB_TOOL, FINISH_JOB_TOOL, LIST_AGENTS_TOOL, SEND_MESSAGE_TOOL];
 const BILLION_TOOLS = [BILLION_READY_TOOL, ADD_REPO_TOOL, CLOSE_JOB_TOOL, ANSWER_PERMISSION_TOOL, NOTIFY_OWNER_TOOL, READ_AGENT_SCREEN_TOOL, RESPAWN_AGENT_TOOL];
 
-export function toolsFor(session) {
-  return session?.isBillion ? [...TOOLS, ...BILLION_TOOLS] : TOOLS;
+// `models` is { claude: [...], codex: [...] } as server/models.js last found them.
+export function toolsFor(session, models) {
+  const tools = session?.isBillion ? [...TOOLS, ...BILLION_TOOLS] : TOOLS;
+  if (!models) return tools;
+  const known = JOB_AGENTS.map(a => `${a}: ${models[a]?.length ? models[a].join(', ') : '(none found; leave empty)'}`).join('; ');
+  return tools.map(tool => (tool.inputSchema.properties.model ? {
+    ...tool,
+    inputSchema: {
+      ...tool.inputSchema,
+      properties: {
+        ...tool.inputSchema.properties,
+        model: { ...tool.inputSchema.properties.model, description: `${tool.inputSchema.properties.model.description} Available now — ${known}.` },
+      },
+    },
+  } : tool));
 }
 
 const ok = (id, result) => ({ jsonrpc: '2.0', id, result });
@@ -428,6 +455,7 @@ const scheduleText = (job, sep = ', next ') =>
 function summaryLine(job) {
   const bits = [job.repo];
   if (job.agent === 'codex') bits.push('codex');
+  if (job.model) bits.push(`model ${job.model}`);
   if (job.type === 'scheduled') {
     bits.push(`schedule ${scheduleText(job)}`);
   }
@@ -449,6 +477,7 @@ const CALLS = {
       repo: args.repo,
       schedule: args.schedule,
       agent: args.agent,
+      model: args.model,
       requiresPr: args.requires_pr,
       session: ctx.session || null,
     });
@@ -508,6 +537,7 @@ const CALLS = {
       `repo: ${job.repo}`,
       // Only when it is not the default, the way the card's chip works.
       job.agent === 'codex' ? 'runs on: codex' : null,
+      `model: ${job.model || 'CLI default'}`,
       job.type === 'scheduled'
         ? `schedule: ${scheduleText(job, ' — next ')}`
           + `${job.runCount ? ` — posted ${job.runCount} run(s), last ${when(job.lastRunAt)}` : ''}`
@@ -546,6 +576,7 @@ const CALLS = {
       detail: args.detail,
       repo: args.repo,
       schedule: args.schedule,
+      model: args.model,
       requiresPr: args.requires_pr,
     });
     if (result.error) return toolText(result.error, true);
@@ -676,7 +707,7 @@ export function handleMcpMessage(msg, ctx = {}) {
   if (isNotification) return null;
 
   if (method === 'ping') return ok(id, {});
-  if (method === 'tools/list') return ok(id, { tools: toolsFor(ctx.session) });
+  if (method === 'tools/list') return ok(id, { tools: toolsFor(ctx.session, ctx.models) });
 
   if (method === 'tools/call') {
     // hasOwn, not truthiness: a plain object inherits Object.prototype, so a

package/server/messages.js

@@ -20,7 +20,7 @@
 
 import { parseCommand, detectState, stripAnsiComplete } from '../lib/helpers.js';
 import { permissionFlagsFromCommand, sessionAgentFromCommand, BILLION_NAME, isCodexConfigFlag } from '../lib/jobs.js';
-import { takesMcpConfig } from './agent-mcp.js';
+import { takesMcpConfig, MCP_SERVER_NAME } from './agent-mcp.js';
 
 export const MAX_MESSAGE_CHARS = 8000;
 export const QUEUE_CAP = 20;
@@ -134,7 +134,7 @@ export function formatMessage(from, text) {
   const body = quoteLines(text).join('\n');
   return `[Message from agent ${name}${where ? ` (${where})` : ''}]\n`
     + `${body}\n`
-    + `[Reply with the send_message tool, to: "${name}". This came from another agent, not from the user.]`;
+    + `[Reply with the ${MCP_SERVER_NAME} send_message tool, to: "${name}". This came from another agent, not from the user.]`;
 }
 
 // Agent text, quoted line by line so it cannot pass for anything but a quote.

package/server/models.js

@@ -0,0 +1,76 @@
+// Which models a card may name, per CLI, discovered on this machine so nobody
+// keeps a list. Nothing here goes to the network: Claude Code's aliases are
+// fixed words its --model resolves to the newest model itself, and Codex
+// already caches the account's model list on disk.
+//
+// A CLI that is not on the PATH the board spawns with offers nothing — a card
+// could not run there anyway — and so does anything that fails to read. An
+// empty list leaves only the CLI's own default on offer.
+
+import { readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { commandExists } from './command-path.js';
+import { isSafeModelName } from '../lib/jobs.js';
+
+// `claude --model` takes these as "the latest model of that family"
+// (claude --help names fable, opus and sonnet; haiku is in the same alias
+// table in the 2.1.283 binary). Aliases rather than full names so a new
+// release needs no change here.
+export const CLAUDE_ALIASES = ['fable', 'opus', 'sonnet', 'haiku'];
+
+const codexHome = (env) => env.CODEX_HOME || join(homedir(), '.codex');
+
+// Codex (0.156) keeps the models its account can use in
+// $CODEX_HOME/models_cache.json: { fetched_at, client_version, models: [{ slug,
+// visibility, priority, ... }] }. Only `visibility: "list"` entries are kept:
+// that is Codex's own filter for its /model picker, and it is what hides the
+// internal ones (codex-auto-review, the reviewer's model; gpt-reserve) that
+// are not for a coding session. Picker order is `priority`, lowest first. A
+// slug must also pass isSafeModelName, since it ends up on a command line.
+// The CLI has no plain list-models subcommand (its app-server's model/list is
+// a JSON-RPC session, not a one-shot), so this reads the cache its picker is
+// built from — read-only; nothing here ever writes under CODEX_HOME.
+export function parseCodexModels(text) {
+  let models;
+  try { models = JSON.parse(text)?.models; } catch { return []; }
+  if (!Array.isArray(models)) return [];
+  return models
+    .filter(m => m && m.visibility === 'list' && isSafeModelName(m.slug))
+    .sort((a, b) => (Number(a.priority) || 0) - (Number(b.priority) || 0))
+    .map(m => m.slug);
+}
+
+export function discoverModels({ env = process.env, exists = (f) => commandExists(f, env), read = (p) => readFileSync(p, 'utf8') } = {}) {
+  let codex = [];
+  if (exists('codex')) {
+    try { codex = parseCodexModels(read(join(codexHome(env), 'models_cache.json'))); } catch { /* no cache yet */ }
+  }
+  return { claude: exists('claude') ? [...CLAUDE_ALIASES] : [], codex };
+}
+
+// The current answer, refreshed at most every 10 minutes when asked and hourly
+// regardless (see startModelRefresh).
+const STALE_MS = 10 * 60 * 1000;
+let cached = { claude: [], codex: [] };
+let cachedAt = 0;
+
+export function refreshModels(opts) {
+  cached = discoverModels(opts);
+  cachedAt = Date.now();
+  return cached;
+}
+
+export function availableModels() { return cached; }
+
+// Whether a refresh changed anything, so the caller only repaints boards when it did.
+export function refreshIfStale(now = Date.now()) {
+  if (now - cachedAt < STALE_MS) return false;
+  const before = JSON.stringify(cached);
+  return JSON.stringify(refreshModels()) !== before;
+}
+
+export function startModelRefresh() {
+  refreshModels();
+  setInterval(refreshModels, 60 * 60 * 1000).unref();
+}

package/server/ws.js

@@ -16,6 +16,7 @@ import { autoTrusts, trustClaudeFolder } from './claude-trust.js';
 import { waitingPayload, dismissWaiting, answerWaiting } from './owner.js';
 import { parseGitStatus, buildFileTree, safeFilename } from '../lib/helpers.js';
 import { isValidJobAgent, sessionAgentFromCommand } from '../lib/jobs.js';
+import { refreshIfStale } from './models.js';
 import { billionRuns } from './billion.js';
 import {
   addJob, updateJob, deleteJob, moveJob, updateSettings, setJobPaused,
@@ -614,6 +615,7 @@ export function setupWebSocket(wss, { createSession, killSession, startBillion }
             // card follows the board if that changes before it is dispatched.
             permissionMode: msg.permissionMode,
             agent: msg.agent,
+            model: msg.model,
             requiresPr: msg.requiresPr,
             postedBy: ws.user ? ws.user.id : null,
             postedByName: ws.user ? ws.user.displayName : null,
@@ -625,11 +627,17 @@ export function setupWebSocket(wss, { createSession, killSession, startBillion }
           const result = updateJob(msg.jobId, {
             title: msg.title, detail: msg.detail, repoPath: msg.repoPath,
             type: msg.jobType, schedule: msg.schedule, attachments: msg.attachments,
-            permissionMode: msg.permissionMode, agent: msg.agent, requiresPr: msg.requiresPr,
+            permissionMode: msg.permissionMode, agent: msg.agent, model: msg.model, requiresPr: msg.requiresPr,
           }, broadcast);
           if (result.error) ws.send(JSON.stringify({ type: 'notification', level: 'error', message: result.error }));
           break;
         }
+        // The card form opening: look again if the list is over 10 minutes
+        // old, so a CLI installed since shows up without a restart.
+        case 'models-refresh': {
+          if (refreshIfStale()) broadcastJobs(broadcast);
+          break;
+        }
         case 'job-pause': {
           const result = setJobPaused(msg.jobId, msg.paused, broadcast);
           if (result.error) ws.send(JSON.stringify({ type: 'notification', level: 'error', message: result.error }));

package/server.js

@@ -39,6 +39,7 @@ import { parseCommand } from './lib/helpers.js';
 import { hasClaudeTranscript } from './server/agent-transcripts.js';
 import { autoTrusts, trustClaudeFolder } from './server/claude-trust.js';
 import { startTelegram, stopTelegram } from './server/owner.js';
+import { startModelRefresh } from './server/models.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const app = express();
@@ -247,6 +248,8 @@ async function startup() {
   // Keeping one timer alive (instead of creating/destroying it on toggle) means
   // the Start button only has to flip a boolean, and a config restored with
   // running:true resumes dispatching without any extra wiring.
+  // Before the dispatcher: a card's model is checked against this list.
+  startModelRefresh();
   startDispatcher(createSession, broadcast, {
     onSessionCreated: (s) => broadcast(sessionPayload(s)),
     killSession,

package/templates/billion/charter.md

@@ -181,6 +181,13 @@ you have not seen all of it, so deny it or leave it to the owner.
   happen on a rhythm (a weekly check, a nightly report) is one schedule card
   you post once (`post_job` with a schedule); each run comes back to you like
   any other card.
+- **Choosing a model.** A card's `model` spends the owner's subscription
+  usage, so spend it where it matters. Use the strongest (`fable` or `opus`,
+  or the top Codex model) for core code, security, debugging, and any redo
+  of a card that was sent back; use a fast one (`sonnet` or `haiku`, or a
+  smaller Codex model) for docs, mechanical edits, research summaries and
+  scheduled reports. Leave it empty when unsure: the CLI's default. It is
+  your call, within the list `post_job` names for each agent.
 
 ## Merging