@ctrl-spc/cs 0.7.9 → 0.7.10

package/dist/codex-home.js

@@ -215,12 +215,6 @@ subagentsEnabled = true, persistentPanelOwner = false) {
     const lines = [
         '# Written by CTRL+SPC for ONE codex run. Not the user\'s config; never read',
         '# by anything but the worker this was written for.',
-        /* The Windows Desktop bundle can lag the account's server-selected default
-           model. When that default requires a newer client, every headless worker
-           exits before its first action. Pin the current broadly-supported model
-           only for that bundled runtime; other platforms keep Codex's own model
-           selection. */
-        ...(runtimePlatform === 'win32' ? ['model = "gpt-5.5"', ''] : []),
         ...(persistentPanelOwner ? [
             'sandbox_mode = "workspace-write"',
             '',
@@ -258,6 +252,9 @@ subagentsEnabled = true, persistentPanelOwner = false) {
     if (server) {
         const url = mcpUrl(server, runTodoId);
         lines.push('[mcp_servers.ctrl-spc]', `url = ${JSON.stringify(url)}`, 
+        // A missing product tool connection must fail startup, not leave a run
+        // producing answers without its dispatch and completion tools.
+        'required = true', 
         /* See the block comment above: without this every tool call is cancelled
            client-side before it leaves the worker. */
         'default_tools_approval_mode = "approve"', '');

package/dist/panel3/prompt.js

@@ -1165,3 +1165,14 @@ function respawnPrompt(opening, brief, report, children) {
         brief,
     ].join('\n');
 }
+/** Selection belongs to each dispatch, not to the card or its parent's model. */
+export function modelChoiceRules(harness) {
+    return [
+        'MODEL AND EFFORT FOR EACH DISPATCH',
+        `You run under ${harness}. Your dispatched children use the same harness.`,
+        'The dispatch tool accepts optional model and effort strings. Honor the user\'s exact stated model and effort for the work they apply to, including downstream workers. Copy each requested value byte-for-byte into the dispatch argument: do not expand aliases, normalize spelling or case, or replace it with a canonical provider identifier. Carry those wishes and their scope verbatim in every applicable responsibility and boundary.',
+        'When the user requests separate workers or assigns choices to separate parts, call dispatch for those parts. Doing their work yourself does not satisfy that request. If product tools are deferred, discover dispatch before starting; use the product ask_question and write_report tools for questions and completion.',
+        'When the user has not specified a value, choose for this child\'s task using your knowledge of this harness. Pass your choice in the tool arguments; a sentence alone does not select it. Different workers may use different choices.',
+        'Omitting a value chooses the harness default (or the machine-local model default), never the parent\'s model or effort. No product model catalog exists. Pass provider values unchanged; do not silently substitute after a rejection.',
+    ].join('\n');
+}

package/dist/panel3/run.js

@@ -748,6 +748,17 @@ async function setCardState(client, cardId, state) {
         .select('id'), 'set the state of', `card ${cardId}`);
 }
 // ---------------------------------------------------------------------------
+/** Each start reloads only this run's durable choices, including null defaults. */
+export async function settingsForRun(client, runId) {
+    const rows = await returned(client.from('panel3_runs').select('model, effort, harness').eq('id', runId), 'read', `model and effort for run ${runId}`);
+    const row = rows[0];
+    if (!row || (row.harness !== null && row.harness !== 'claude' && row.harness !== 'codex')
+        || (row.model !== null && typeof row.model !== 'string')
+        || (row.effort !== null && typeof row.effort !== 'string')) {
+        throw new Error('The run has no readable harness, model and effort selection.');
+    }
+    return { model: row.model, effort: row.effort, harness: row.harness ?? undefined };
+}
 /**
  * One card, from the turns the take handed over to the answer on its thread.
  *
@@ -804,9 +815,11 @@ async function answerCard(client, tools, machineId, cardId, turns) {
        no rules" — that is a different project than the one the person is on. So it
        joins the three reads above inside this ending rather than beside it. */
     let rules;
+    let settings;
     try {
         brief = briefFor(turns[0].card_title, turns, await receiptsFor(client, cardId), await attachmentsFor(client, cardId), await codebasesForRun(client, runId));
         rules = await standingRulesFor(client, runId);
+        settings = await settingsForRun(client, runId);
         where = await workingDirectory(client, runId, LEVEL, false);
     }
     catch (error) {
@@ -823,7 +836,7 @@ async function answerCard(client, tools, machineId, cardId, turns) {
     /* AN EMPTY DIRECTORY OF THE USER'S OWN, because level 1 has no code tool to
        use a real one with, and the daemon's inherited cwd under a launchd login
        item is the filesystem root. */
-    const started = startAgent(withStandingRules(rules, brief, where.block), LEVEL, tools.urlFor(runId), where.cwd);
+    const started = startAgent(withStandingRules(rules, brief, where.block), LEVEL, tools.urlFor(runId), where.cwd, undefined, settings);
     out(`run      ${runId}  level ${LEVEL}  ${started.pid ? `pid ${started.pid}` : 'no process'}`);
     try {
         /* THE BRIEF, NOT WHAT THE PROCESS WAS HANDED. The rules are current at the
@@ -1162,14 +1175,16 @@ async function workingDirectory(client, runId, level, isOwner, knownCodebase) {
  * Then the row, then the process, then the pid — constraint 8, in the only order
  * that satisfies it.
  */
-async function startChild(client, tools, machineId, parentRunId, brief, codebase, parentProcessToken) {
+async function startChild(client, tools, machineId, parentRunId, brief, codebase, parentProcessToken, choice = {}) {
     const { data, error } = await client.rpc('panel3_dispatch', {
         p_parent_run_id: parentRunId,
         p_brief: brief,
         p_machine_id: machineId,
         p_codebase_id: codebase?.id ?? null,
         p_codebase_label: codebase?.name ?? null,
-        ...(parentProcessToken === undefined ? {} : { p_process_token: parentProcessToken }),
+        p_process_token: parentProcessToken ?? null,
+        p_model: choice.model ?? null,
+        p_effort: choice.effort ?? null,
     });
     if (error)
         throw new Error(`could not start an agent under run ${parentRunId}: ${readableWriteError(error.message)}`);
@@ -1200,12 +1215,14 @@ async function startChild(client, tools, machineId, parentRunId, brief, codebase
        exists (`panel3_dispatch` wrote it above) and it carries this child's
        codebase, which is what decides which codebase-scoped rules it is under. */
     let rules;
+    let settings;
     try {
         where = await workingDirectory(client, row.run_id, level, level === 2, codebase);
         prompt = level === 2
             ? await initialOwnerPrompt(client, row.run_card_id, parentRunId, brief)
             : brief;
         rules = await standingRulesFor(client, row.run_id);
+        settings = await settingsForRun(client, row.run_id);
         /* Inside this site's own try, for `standingRulesFor`'s reason: a failure to
            assemble what the agent needs ends the run the way this path already ends
            runs, rather than starting a process that is missing it. */
@@ -1218,7 +1235,7 @@ async function startChild(client, tools, machineId, parentRunId, brief, codebase
     }
     const processToken = row.process_token ?? undefined;
     const isOwner = level === 2;
-    const started = startAgent(withStandingRules(rules, prompt, where.block, [], pictures), level, tools.urlFor(row.run_id, processToken), where.cwd, isOwner ? { ownerId: row.run_id } : undefined);
+    const started = startAgent(withStandingRules(rules, prompt, where.block, [], pictures), level, tools.urlFor(row.run_id, processToken), where.cwd, isOwner ? { ownerId: row.run_id } : undefined, settings);
     if (started.pid === null) {
         /* THERE IS A ROW AND THERE IS NO PROCESS, which is the one shape the record
            must never be left in quietly. The answer is already settled — nothing ran
@@ -1688,9 +1705,11 @@ async function resumeRun(client, tools, machineId, runId, afterPid) {
        is a `returned()` message naming tables and columns, which carries no local
        path and is therefore shareable. */
     let rules;
+    let settings;
     let pictures;
     try {
         rules = await standingRulesFor(client, runId);
+        settings = await settingsForRun(client, runId);
         /* ═══ WRITTEN AGAIN ON EVERY START, LIKE THE RULES. ═══ A resumed process is
            a NEW process with a new copy of the working directory, so the files a
            previous one was handed are not there any more, and the stored brief this
@@ -1709,7 +1728,7 @@ async function resumeRun(client, tools, machineId, runId, afterPid) {
        still running. See `retryPrompt`. */
     withStandingRules(rules, afterPid === null
         ? resumePrompt(claimed.run_brief, claimed.run_report, children)
-        : retryPrompt(claimed.run_brief, claimed.run_report, children), where.block, [], pictures), level, tools.urlFor(runId), where.cwd);
+        : retryPrompt(claimed.run_brief, claimed.run_report, children), where.block, [], pictures), level, tools.urlFor(runId), where.cwd, undefined, settings);
     if (started.pid === null) {
         /* THE CLAIM HAPPENED AND NO PROCESS DID, which is the one shape the record
            must never be left in quietly. Same handling as a dispatch that could not
@@ -1816,9 +1835,11 @@ async function startRearmed(client, tools, machineId, row) {
        same way: the re-arm's claim has already happened, so a failure here ends
        the run with its reason rather than leaving it claimed with no process. */
     let rules;
+    let settings;
     let pictures;
     try {
         rules = await standingRulesFor(client, row.run_id);
+        settings = await settingsForRun(client, row.run_id);
         pictures = await picturesOnDisk(client, row.run_card_id, where, level);
     }
     catch (error) {
@@ -1826,7 +1847,7 @@ async function startRearmed(client, tools, machineId, row) {
         await endRun(client, level, row.run_id, row.run_card_id, why);
         throw new Error(`NO AGENT IS RUNNING: ${why}`);
     }
-    const started = startAgent(withStandingRules(rules, prompt, where.block, [], pictures), level, tools.urlFor(row.run_id), where.cwd);
+    const started = startAgent(withStandingRules(rules, prompt, where.block, [], pictures), level, tools.urlFor(row.run_id), where.cwd, undefined, settings);
     if (started.pid === null) {
         const answer = await started.answered;
         const reason = answer.ok ? 'the process ended before it could be identified' : answer.reason;
@@ -2064,6 +2085,7 @@ async function activateOwner(client, tools, machineId, runId, afterProcessToken
        says what the product DID with the person's answer, and the landing needs
        the card's copy. Nothing in the prompt depended on it before. */
     let rules;
+    let settings;
     /* THE CARD'S COPY IS MADE IN THE SAME WINDOW AND UNDER THE SAME ENDING, for
        the reason the check above gives: it writes, so it happens after the claim,
        and a failure to make it is an activation that ends rather than one that
@@ -2087,6 +2109,7 @@ async function activateOwner(client, tools, machineId, runId, afterProcessToken
     try {
         where = await ownerDirectory(client, candidate);
         rules = await standingRulesFor(client, runId);
+        settings = await settingsForRun(client, runId);
         attached = whatWasAttached((await attachmentsFor(client, claimed.run_card_id))
             .filter((line) => !line.startsWith('codebase  ')));
         /* ═══ THE OWNER'S OWN ACTIVATION, WHICH IS WHERE MOST PICTURES ARRIVE. ═══
@@ -2119,7 +2142,7 @@ async function activateOwner(client, tools, machineId, runId, afterProcessToken
            are not the same event and `prompt.ts` exists to stop an agent being
            told an untrue reason for its own restart. */
         afterPid !== null, landing);
-    const started = startAgent(withStandingRules(rules, prompt, where.block, attached, pictures), 2, tools.urlFor(runId, claimed.process_token), where.cwd, { ownerId: runId, ...(resumeSessionId ? { resumeSessionId } : {}) });
+    const started = startAgent(withStandingRules(rules, prompt, where.block, attached, pictures), 2, tools.urlFor(runId, claimed.process_token), where.cwd, { ownerId: runId, ...(resumeSessionId ? { resumeSessionId } : {}) }, settings);
     if (started.pid === null) {
         const answer = await started.answered;
         const reason = answer.ok ? 'the process ended before it could be identified' : answer.reason;
@@ -3100,8 +3123,8 @@ export async function run(args, injected) {
        `tools` is referenced inside the callback it is being given, which is safe
        for the plain reason that the callback can only run once a request has
        arrived at a server that by then exists. */
-    const tools = await startToolsServer(current(), async (parentRunId, brief, codebase, processToken) => {
-        const child = await startChild(current(), tools, machineId, parentRunId, brief, codebase, processToken);
+    const tools = await startToolsServer(current(), async (parentRunId, brief, codebase, processToken, choice) => {
+        const child = await startChild(current(), tools, machineId, parentRunId, brief, codebase, processToken, choice);
         hold(child.runId, child.settled);
         return { runId: child.runId };
     });

package/dist/panel3/show.js

@@ -83,7 +83,7 @@ const read = (query, what) => returned(query, 'read', what);
 const CARD_COLUMNS = 'id, project_id, title, state, created_at, archived_at';
 const TURN_COLUMNS = 'id, card_id, role, body, created_at, addressed_at, run_id';
 const RUN_COLUMNS = 'id, card_id, codebase_id, branch, parent_run_id, level, state, brief, report, failed_because, '
-    + 'activity, machine_id, pid, started_at, resumed_at, read_back_at, ended_at';
+    + 'activity, machine_id, pid, started_at, resumed_at, read_back_at, ended_at, model, effort';
 const ASK_COLUMNS = `id, card_id, run_id, pending_run_id, answered_at, delivered_at, created_at, ${ASK_CONTENT_COLUMNS}`;
 const OUTPUT_COLUMNS = 'id, card_id, run_id, kind, ref_id, label, created_at';
 const ATTACHMENT_COLUMNS = 'id, card_id, kind, ref_id, label, created_at';
@@ -1125,6 +1125,10 @@ async function showRun(client, run) {
     out(`RUN  ${run.id}`);
     out(`  card     ${run.card_id}${card ? `  ${card.title}` : '  (card not readable)'}`);
     out(`  level    ${run.level}`);
+    if (run.model != null)
+        out(`  model    ${run.model}`);
+    if (run.effort != null)
+        out(`  effort   ${run.effort}`);
     out(`  state    ${run.state}${isLive(run) ? '  (live)' : ''}`);
     out(`  parent   ${run.parent_run_id ?? 'none, dispatched by the daemon'}`);
     out(`  machine  ${run.machine_id}${run.pid ? `  pid ${run.pid}` : '  no pid recorded'}`);

package/dist/panel3/spawn.js

@@ -124,6 +124,7 @@ import { randomUUID } from 'node:crypto';
 import { agentPath } from '../agents.js';
 import { ensureCodexRunHome, ensurePanel3CodexOwnerHome, removeCodexRunHome, } from '../codex-home.js';
 import { windowsSafeSpawn } from '../win-shell.js';
+import { modelChoiceRules } from './prompt.js';
 const AGENT_VAR = 'CTRL_SPC_V3_AGENT';
 /**
  * The harness named on this machine, or the reason the name is not one.
@@ -169,9 +170,9 @@ const allowedTools = (level) => [`mcp__${SERVER}__*`, ...(level === 1 ? [] : COD
  * checked without starting a process — which is how the allowlist is proved,
  * and how it stays provable after this task.
  */
-export function agentArgs(level, toolsUrl, agent = harness(), platform = process.platform, ownerSession) {
+export function agentArgs(level, toolsUrl, agent = harness(), platform = process.platform, ownerSession, choice = {}) {
     if (agent === 'codex')
-        return codexArgs(level, toolsUrl, platform, ownerSession);
+        return codexArgs(level, toolsUrl, platform, ownerSession, choice);
     const session = ownerSession
         ? ownerSession.resumeSessionId
             ? ['--resume', ownerSession.resumeSessionId]
@@ -187,6 +188,8 @@ export function agentArgs(level, toolsUrl, agent = harness(), platform = process
         '--tools', builtIns(level),
         '--allowedTools', allowedTools(level),
         ...session,
+        ...(choice.model == null ? [] : ['--model', choice.model]),
+        ...(choice.effort == null ? [] : ['--effort', choice.effort]),
         /* STATED WHERE THERE IS SOMETHING TO STATE. `acceptEdits` grants file edits
            to a headless process with nobody at a prompt to approve them, and it is
            passed only to the levels that have a file tool to use it with: at level 1
@@ -221,7 +224,7 @@ export function agentArgs(level, toolsUrl, agent = harness(), platform = process
  * `--json` makes the answer an `agent_message` item read out of the stream
  * rather than whatever prose happened to reach stdout (see `codexAnswer`).
  */
-function codexArgs(level, toolsUrl, platform, ownerSession) {
+function codexArgs(level, toolsUrl, platform, ownerSession, choice = {}) {
     const resume = ownerSession?.resumeSessionId;
     return [
         'exec',
@@ -229,6 +232,8 @@ function codexArgs(level, toolsUrl, platform, ownerSession) {
         // The prompt arrives on stdin, exactly as it does for claude: `codex exec`
         // reads it from there when no prompt argument is given.
         '--json',
+        ...(choice.model == null ? [] : ['-m', choice.model]),
+        ...(choice.effort == null ? [] : ['-c', `model_reasoning_effort=${JSON.stringify(choice.effort)}`]),
         // The level 1 scratch directory is not a repository, and neither need a
         // working copy be.
         '--skip-git-repo-check',
@@ -241,13 +246,13 @@ function codexArgs(level, toolsUrl, platform, ownerSession) {
            proven per-run home below. */
         ...(platform === 'win32' ? [
             '--ignore-user-config',
-            '-c', 'model="gpt-5.5"',
             '-c', 'features.apps=false',
             // The same closing `codex-home.ts` writes into the per-run config, and
             // for the same measured reason: `features.multi_agent=false` parses and
             // leaves the tool reachable.
             '-c', 'agents.enabled=false',
             '-c', `mcp_servers.${SERVER}.url=${JSON.stringify(toolsUrl)}`,
+            '-c', `mcp_servers.${SERVER}.required=true`,
             '-c', `mcp_servers.${SERVER}.default_tools_approval_mode="approve"`,
             '-c', 'windows.sandbox="unelevated"',
             '-c', 'windows.sandbox_private_desktop=false',
@@ -291,7 +296,7 @@ function runKey(toolsUrl) {
  * is the forbidden state ux.md is about, so the failure wins wherever both are
  * present.
  */
-export function codexAnswer(stdout) {
+export function codexAnswer(stdout, exitCode = 0, stderr = '') {
     let text = null;
     let failure = null;
     for (const line of stdout.split('\n')) {
@@ -319,6 +324,9 @@ export function codexAnswer(stdout) {
     if (failure !== null) {
         return { ok: false, reason: `codex could not finish the turn${failure ? `: ${failure}` : ''}` };
     }
+    if (exitCode !== 0) {
+        return { ok: false, reason: `codex exited ${exitCode}${tail(stderr) || tail(stdout)}` };
+    }
     if (text === null || text.trim() === '') {
         return { ok: false, reason: 'codex exited 0 without saying anything to the person' };
     }
@@ -377,7 +385,7 @@ function tail(text, chars = 500) {
  * process still alive" after the daemon that started it has been killed. So the
  * caller gets the pid immediately, writes it, and then waits.
  */
-export function startAgent(prompt, level, toolsUrl, cwd, ownerSession) {
+export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings = {}) {
     const failed = (reason) => ({
         pid: null,
         session: Promise.resolve(null),
@@ -385,7 +393,7 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession) {
     });
     let agent;
     try {
-        agent = harness();
+        agent = settings.harness ?? harness();
     }
     catch (err) {
         // A machine configured for a harness this build has never heard of. See
@@ -395,7 +403,10 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession) {
     const launchedOwnerSession = ownerSession && !ownerSession.resumeSessionId
         ? { ...ownerSession, freshSessionId: randomUUID() }
         : ownerSession;
-    const ARGS = agentArgs(level, toolsUrl, agent, process.platform, launchedOwnerSession);
+    // A local default applies only to an omitted choice; explicit run values always win.
+    const choice = { ...settings, model: settings.model ?? process.env[`CTRL_SPC_V3_${agent.toUpperCase()}_DEFAULT_MODEL`] };
+    const ARGS = agentArgs(level, toolsUrl, agent, process.platform, launchedOwnerSession, choice);
+    prompt = `${modelChoiceRules(agent)}\n\n${prompt}`;
     const bin = agentPath(agent);
     if (!bin) {
         return failed(`${agent} is not installed on this machine`);
@@ -531,6 +542,11 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession) {
                    respawn behind it is refused. Naming the signal is the whole fix. */
                 finish({ ok: false, reason: `${agent} was ended by ${signal}${tail(stderr) || tail(stdout)}` });
             }
+            else if (agent === 'codex') {
+                // Startup failures can put the real error in JSON stdout and only
+                // 'Reading prompt from stdin' on stderr, including on non-zero exits.
+                finish(codexAnswer(stdout, code ?? 1, stderr));
+            }
             else if (code !== 0) {
                 /* STDOUT WHEN STDERR IS EMPTY, because `claude -p` prints its own
                    failure on stdout and exits non-zero having written nothing to
@@ -541,11 +557,6 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession) {
             else if (stdout.trim() === '') {
                 finish({ ok: false, reason: `${agent} exited 0 and said nothing${tail(stderr)}` });
             }
-            else if (agent === 'codex') {
-                /* The stream, not the buffer. See `codexAnswer`: stdout here is
-                   protocol, and a failed turn that exited 0 is still a failure. */
-                finish(codexAnswer(stdout));
-            }
             else {
                 const text = stdout.trim();
                 finish({

package/dist/panel3/tools.js

@@ -1833,11 +1833,11 @@ const TOOLS = [
             const agents = await rows(client.from('panel3_runs')
                 // `resumed_at` is read because "how long it has been going" is about
                 // the attempt that is running now. See `elapsed`.
-                .select('id, level, parent_run_id, state, activity, started_at, resumed_at, ended_at')
+                .select('id, level, parent_run_id, state, activity, started_at, resumed_at, ended_at, model, effort')
                 .eq('card_id', cardId).order('started_at'), 'read', 'the agents on this card');
             return listed(agents.map((a) => {
                 const live = a.state === 'running' && !a.ended_at;
-                return line(a.id, `L${a.level}`, a.parent_run_id ? `parent ${a.parent_run_id}` : 'no parent, dispatched by the daemon', live ? 'still running' : a.state, a.activity ?? null, live
+                return line(a.id, `L${a.level}`, a.parent_run_id ? `parent ${a.parent_run_id}` : 'no parent, dispatched by the daemon', live ? 'still running' : a.state, a.activity ?? null, a.model == null ? null : `model ${a.model}`, a.effort == null ? null : `effort ${a.effort}`, live
                     ? `going ${elapsed(a.started_at, null, a.resumed_at)}`
                     : `went ${elapsed(a.started_at, a.ended_at, a.resumed_at)}`);
             }), 'Nothing has run on this card.');
@@ -1851,9 +1851,11 @@ const TOOLS = [
             + 'in your prompt; this is here for when you need to re-read them mid-run.',
         input: {},
         handler: async ({ client, runId }) => {
-            const run = await only(client.from('panel3_runs').select('level, brief, report, activity').eq('id', runId), 'read', 'your own run');
+            const run = await only(client.from('panel3_runs').select('level, brief, report, activity, model, effort').eq('id', runId), 'read', 'your own run');
             return [
                 `You are a level ${run.level} agent.`,
+                ...(run.model == null ? [] : [`MODEL  ${run.model}`]),
+                ...(run.effort == null ? [] : [`EFFORT  ${run.effort}`]),
                 '',
                 'BRIEF, written when you were dispatched and never changed',
                 run.brief,
@@ -1878,9 +1880,9 @@ const TOOLS = [
             + 'dispatch the same work twice.',
         input: {},
         handler: async ({ client, runId }) => {
-            const children = await rows(client.from('panel3_runs').select('id, level, state, activity, started_at, ended_at')
+            const children = await rows(client.from('panel3_runs').select('id, level, state, activity, started_at, ended_at, model, effort')
                 .eq('parent_run_id', runId).order('started_at'), 'read', 'the runs you dispatched');
-            return listed(children.map((c) => line(c.id, `L${c.level}`, c.state === 'running' && !c.ended_at ? 'still running' : c.state, c.activity ?? null)), 'You have dispatched nothing.');
+            return listed(children.map((c) => line(c.id, `L${c.level}`, c.state === 'running' && !c.ended_at ? 'still running' : c.state, c.activity ?? null, c.model == null ? null : `model ${c.model}`, c.effort == null ? null : `effort ${c.effort}`)), 'You have dispatched nothing.');
         },
     },
     {
@@ -2894,6 +2896,8 @@ const TOOLS = [
                 + 'context: what to find out or change, and in which part of the codebase.'),
             boundary: z.string().min(1).describe('What it must not touch, and where its work stops.'),
             work_item_id: z.string().optional().describe('The work item it is working, if there is one.'),
+            model: z.string().min(1).optional().describe('Exact model for this child. Copy the user\'s applicable value verbatim, including aliases; never expand or normalize it. Otherwise choose for the task. Omit for the harness or machine default, never parent inheritance.'),
+            effort: z.string().min(1).optional().describe('Exact effort for this child. Honor the user\'s applicable wish; otherwise choose independently. Passed unchanged to the harness.'),
             work_name: z.string().optional().describe(`A few words, ${WORK_NAME_WORDS} at most, naming the WORK this conversation is doing, such `
                 + 'as "Fix the sign-out checklist bug". Pass it when the conversation has NO work item '
                 + 'attached: the conversation is called this from now on, and the branch the work goes on is '
@@ -2901,7 +2905,7 @@ const TOOLS = [
                 + 'attached, because that item is already the name.'),
         },
         handler: async (caller, args) => {
-            const { codebase_id, responsibility, boundary, work_item_id, work_name } = args;
+            const { codebase_id, responsibility, boundary, work_item_id, work_name, model, effort } = args;
             if (caller.level === 2 && !codebase_id) {
                 throw new Error('A worker must be attached to a registered project codebase.');
             }
@@ -2964,7 +2968,7 @@ const TOOLS = [
             const attachments = attached.map(attachmentLine);
             const { runId } = await caller.dispatch(caller.runId, workBrief(childLevel, responsibility, boundary, work_item_id, attachments, codebase === null ? undefined : {
                 id: codebase.id, name: codebase.name, identity: codebase.gitRemoteUrl,
-            }), codebase, caller.processToken);
+            }), codebase, caller.processToken, { model, effort });
             /* ═══ WHERE ITS ANSWER GOES DEPENDS ON WHICH LEVEL THIS IS, AND THAT IS
                KNOWN HERE RATHER THAN GUESSED. ═══ The description above cannot say it,
                because it is registered once for both levels that hold the tool; this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctrl-spc/cs",
-  "version": "0.7.9",
+  "version": "0.7.10",
   "description": "CTRL+SPC — minimal, reliable per-machine agent presence. Sign-in, auto-start, agent detection, heartbeat presence, and ping acknowledgement.",
   "engines": {
     "node": ">=22"