cawdev-cli 1.0.5-beta → 1.0.6-beta

package/runner/cawdev.mjs

@@ -29,8 +29,8 @@ import { attach, urlFrom, valueOf } from './attach.mjs';
 import { asker, askOne, mintForThisMachine, setUpThisMachine } from './bootstrap.mjs';
 import { liveSockets, probeSocket, socketPathFor } from './control.mjs';
 import {
-  addProject, addWorkspace, readConfigFile, reloadIfRunning, setAcceptsRulesFromConsole, setQuality,
-  setAgentEnabled,
+  addProject, addWorkspace, readConfigFile, reloadIfRunning, removeProject, setAcceptsRulesFromConsole,
+  setQuality, setAgentEnabled,
 } from './configure.mjs';
 import { restartNeededFor } from '../lib/runner-config.mjs';
 import { Select } from './select.mjs';
@@ -63,6 +63,8 @@ const USAGE = `
   cawdev config add-project              serve one more project you can write to
   cawdev config add-workspace            another checkout for a project you
                                           already serve — R47's concurrency
+  cawdev config remove-project <slug>    stop serving a project (its checkouts
+                                          stay on disk)
   cawdev config agent enable|disable <claude|agy|codex>
   cawdev config rules on|off             accept permission rules from the console
   cawdev config quality on|off <slug>    scan that project's branches with
@@ -422,6 +424,7 @@ async function runVersion(url, ink) {
 /**
  * `cawdev config` — R283's granular half of the setup walk, on a machine
  * already configured. A direct subcommand (`add-project`, `add-workspace`,
+ * `remove-project <slug>`,
  * `agent enable|disable <command>`, `rules on|off`, `quality on|off <slug>`,
  * `show`) or, with none, a
  * menu — the same `Select` widget everything that offers a choice uses.
@@ -463,6 +466,7 @@ export async function pickAction(ask, say, pick = askOne) {
     rows: [
       { id: 'add-project', label: 'Add a project' },
       { id: 'add-workspace', label: 'Add a workspace to a project' },
+      { id: 'remove-project', label: 'Stop serving a project' },
       { id: 'agent-enable', label: `Enable an agent (${KNOWN_AGENTS.join(' / ')})` },
       { id: 'agent-disable', label: 'Disable an agent' },
       { id: 'rules-on', label: 'Accept permission rules from the console' },
@@ -477,6 +481,9 @@ export async function pickAction(ask, say, pick = askOne) {
     const command = (await ask.line(`  Which agent — ${KNOWN_AGENTS.join(', ')}? `)).trim();
     return ['agent', id === 'agent-enable' ? 'enable' : 'disable', command];
   }
+  if (id === 'remove-project') {
+    return ['remove-project', (await ask.line('  Which project (slug)? ')).trim()];
+  }
   if (id === 'rules-on') return ['rules', 'on'];
   if (id === 'rules-off') return ['rules', 'off'];
   if (id === 'quality-on' || id === 'quality-off') {
@@ -507,6 +514,14 @@ export async function runAction([verb, ...rest], { configPath, file, url, sessio
     await reload(await addWorkspace({ configPath, file, url, session, ask, say, ink }));
     return;
   }
+  if (verb === 'remove-project') {
+    const [slug] = rest;
+    if (!slug) {
+      throw new Error('Name a project: cawdev config remove-project <slug>');
+    }
+    await reload(await removeProject({ file, configPath, ask, say, ink, slug }));
+    return;
+  }
   if (verb === 'agent') {
     const [sub, command] = rest;
     if (!KNOWN_AGENTS.includes(command)) {

package/runner/configure.mjs

@@ -345,6 +345,40 @@ export async function setAgentEnabled({
   return next;
 }
 
+/**
+ * Stop serving a project: its entry leaves the config, and nothing else moves.
+ * The checkouts stay on disk — they are somebody's working copies, and
+ * deleting a directory is not a config change — and the machine's token keeps
+ * its grant, which reaches nothing once the project is gone and reaches it
+ * again if it is added back. `projects` is read at boot, so the daemon serves
+ * it until a restart; the reload after this says so.
+ *
+ * The case it exists for: a project deleted in the console is still in this
+ * file, so the terminal kept offering it and the daemon kept polling for it.
+ */
+export async function removeProject({
+  file, configPath, slug,
+  ask, say, ink = painter(3),
+  write = writeRunnerConfig,
+} = {}) {
+  const projects = file.projects ?? {};
+  if (!slug || !(slug in projects)) {
+    throw new Error(`This machine does not serve ${slug || 'that project'}. `
+      + `It serves: ${Object.keys(projects).join(', ') || 'nothing yet'}.`);
+  }
+  const paths = pathsOf(projects[slug]);
+  const kept = paths.length ? ` Its checkout${paths.length === 1 ? '' : 's'} stay${paths.length === 1 ? 's' : ''} on disk: ${paths.join(', ')}.` : '';
+  if (!await confirm(ask, `Stop serving ${slug} on this machine?${kept}`)) {
+    throw new Error('Nothing changed.');
+  }
+  const { [slug]: _removed, ...rest } = projects;
+  const next = { ...file, projects: rest };
+  await write(configPath, next);
+  say(`  ${ink.success('✓')} ${ink.muted(`This machine no longer serves ${slug}.`)}`
+    + (paths.length ? ` ${ink.muted(`Delete ${paths.length === 1 ? 'its checkout' : 'its checkouts'} yourself if you no longer want ${paths.length === 1 ? 'it' : 'them'}.`)}` : ''));
+  return next;
+}
+
 /** Turn `acceptsRulesFromConsole` on or off — R126. */
 export async function setAcceptsRulesFromConsole({
   file, configPath, enabled,

package/runner/input.mjs

@@ -136,25 +136,38 @@ export class History {
     this.draft = '';
   }
 
-  /** Older. Returns null when there is nothing older, so the line is left alone. */
-  back(current = '') {
+  /**
+   * Older. Returns null when there is nothing older, so the line is left alone.
+   *
+   * @param keep which entries this line walks — a command line walks the
+   *   commands and skips the prompts sent to sessions, which it cannot send
+   */
+  back(current = '', keep = () => true) {
     if (this.at === this.entries.length) {
       this.draft = current;
     }
-    if (this.at === 0) {
+    let at = this.at;
+    do {
+      at -= 1;
+    } while (at >= 0 && !keep(this.entries[at]));
+    if (at < 0) {
       return null;
     }
-    this.at -= 1;
-    return this.entries[this.at];
+    this.at = at;
+    return this.entries[at];
   }
 
   /** Newer, ending at the draft you were writing. */
-  forward() {
+  forward(keep = () => true) {
     if (this.at >= this.entries.length) {
       return null;
     }
-    this.at += 1;
-    return this.at === this.entries.length ? this.draft : this.entries[this.at];
+    let at = this.at;
+    do {
+      at += 1;
+    } while (at < this.entries.length && !keep(this.entries[at]));
+    this.at = at;
+    return at === this.entries.length ? this.draft : this.entries[at];
   }
 
   reset() {

package/runner/prefs.mjs

@@ -0,0 +1,52 @@
+/**
+ * What this terminal remembers about how you like to work — beside history.mjs
+ * and in its shape: one file under ~/.cawdev, keyed by the platform's URL, 0600.
+ *
+ * One preference so far: the agent `/new` asks for when a command names none
+ * (`/agent codex`). Kept here and not on the platform, because it is a choice
+ * about THIS terminal — the project's default and your account's live in the
+ * console, and this sits in front of them without changing either.
+ *
+ * @author Claude Opus 5.5 (Claude Code)
+ * @author Moez Ben MBarka
+ */
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+export function prefsFile() {
+  return process.env.CAWDEV_PREFS_FILE ?? join(homedir(), '.cawdev', 'terminal.json');
+}
+
+function key(url) {
+  return String(url).replace(/\/+$/, '');
+}
+
+async function readAll() {
+  try {
+    const parsed = JSON.parse(await readFile(prefsFile(), 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/** This platform's preferences, `{}` when there are none or the file is unreadable. */
+export async function loadPrefs(url) {
+  const mine = (await readAll())[key(url)];
+  return mine && typeof mine === 'object' ? mine : {};
+}
+
+/** Merges `changes` into this platform's preferences; a null value removes the key. */
+export async function savePrefs(url, changes) {
+  const all = await readAll();
+  const mine = { ...(all[key(url)] ?? {}) };
+  for (const [name, value] of Object.entries(changes)) {
+    if (value === null || value === undefined) delete mine[name];
+    else mine[name] = value;
+  }
+  all[key(url)] = mine;
+  await mkdir(dirname(prefsFile()), { recursive: true, mode: 0o700 });
+  await writeFile(prefsFile(), `${JSON.stringify(all, null, 2)}\n`, { mode: 0o600 });
+  await chmod(prefsFile(), 0o600).catch(() => undefined);
+}

package/runner/runner.mjs

@@ -40,12 +40,13 @@ import {
 } from '../lib/stage-tools.mjs';
 import { capabilityIn, describeCall } from '../lib/tool-line.mjs';
 import { findSecret } from '../lib/secrets.mjs';
+import { BackgroundShells } from '../lib/background-shells.mjs';
 import { cliVersion, isBelow } from '../lib/version.mjs';
 import { reloadableFor, restartNeededFor } from '../lib/runner-config.mjs';
 import {
   createAutoWorkspace, discoverAutoWorkspaces, isAutoWorkspace,
 } from './auto-workspaces.mjs';
-import { agentOfCommand } from '../lib/agents.mjs';
+import { agentOfCommand, needsEverything } from '../lib/agents.mjs';
 import { cawdevToolNames, codexArgs, translateCodexEvent } from '../lib/codex.mjs';
 
 // --- configuration -----------------------------------------------------------
@@ -5182,21 +5183,60 @@ function argsForProfile(agentArgs, profile, run, expertAgents = [], skills = [])
  * re-derived the plan from a précis would be planning again, which is the one
  * thing the gate exists to stop it doing after somebody approved the first one.
  */
-function stagePrompt(stage, carried) {
+/** Longer than ask_user's own ten-minute wait — see the cawdev server of spawnCodex. */
+const CAWDEV_TOOL_TIMEOUT_SEC = 660;
+
+/**
+ * A decision that is the person's is ASKED, and the stage goes on with the
+ * answer. R19 and R24 (Codex) each met one — a plan the code had moved away
+ * from, a plan whose review left the scope open — and ended the stage saying
+ * so, the run FINISHED with nothing built and the question in a summary
+ * nobody was asked. Claude asked; the wording let Codex stop instead.
+ */
+const ASK_DONT_STOP = 'If a decision is genuinely the person\'s — a scope the card leaves open, '
+  + 'a plan that no longer matches the code, a trade-off with no right answer — ASK it with '
+  + '`ask_user` (a round of questions if there are several), wait for the answer, and carry on '
+  + 'with it. Never end this stage on an open question: a question left in your report is one '
+  + 'nobody was asked.';
+
+/**
+ * A stage is ONE turn, and it ends the moment the turn does — so a command left
+ * running in the background is a result lost (background-shells.mjs).
+ */
+const WAIT_FOR_COMMANDS = 'This stage ends when your turn ends: run every command in the '
+  + 'foreground and wait for it to finish — a build or a test suite left running in the '
+  + 'background is lost, and the stage is run again.';
+
+/**
+ * @param hasPlan whether the card has a plan of record — the same test
+ *   harnessPrompt uses to draw "The plan for this card" (`plan?.body`), so the
+ *   instruction and the block it points at cannot disagree
+ */
+function stagePrompt(stage, carried, hasPlan = true) {
   const asked = {
     PLAN: 'Work out what to do and WRITE THE PLAN. Do not change anything — you have no '
       + 'tool that can, so do not spend turns discovering that. Read what you need, then say, '
       + 'concretely: which files, what change in each, and how you will know it worked. '
       + 'What you report becomes the card\'s plan, and a DIFFERENT session — another '
       + 'process, with none of your context — will be handed it and told to carry it out. '
-      + 'Write it for them.',
+      + 'Write it for them — with every decision in it already made. ' + ASK_DONT_STOP,
     VERIFY: 'Check the plan against what is actually there. Does every file it names exist? '
       + 'Does every interface it assumes still look like that? You cannot change anything — '
       + 'say what is wrong with the plan, or say plainly that it holds.',
-    IMPLEMENT: 'Do the work in the plan — it is under "The plan for this card" above, '
-      + 'written by the plan phase and agreed. If it turns out to be wrong, say so and stop '
-      + 'rather than improvising a different change: somebody approved that plan, and a '
-      + 'different one has not been approved.',
+    // With a plan, the plan is the task. Without one — `/new dev R21` on a
+    // card nobody planned — the CARD is: the old wording pointed at a plan
+    // section that was not there, and a careful session read "stop rather than
+    // improvise" as "stop", ending R21 with nothing built and nothing to push.
+    IMPLEMENT: (hasPlan
+      ? 'Do the work in the plan — it is under "The plan for this card" above, '
+        + 'written by the plan phase and agreed. Do not quietly improvise a different change: '
+        + 'somebody approved that plan. If it turns out to be wrong or incomplete, ask what to '
+        + 'do instead of stopping — and stop only if the answer is to stop. '
+      : 'This card has no plan, and it does not need one: it was started straight into '
+        + 'development, so the CARD\'s text is the task. Work out what it asks — read the code '
+        + 'it touches first — build it, and commit it on this branch. Never stop because a plan '
+        + 'is missing. ')
+      + ASK_DONT_STOP + ' ' + WAIT_FOR_COMMANDS,
     // R129. Two honest ways to do this stage, and the project chose one. The
     // TESTBOOK wording says "you have no tool that could" for the PLAN
     // prompt's reason: a session that has to discover a refusal spends turns
@@ -5215,7 +5255,8 @@ function stagePrompt(stage, carried) {
         + 'failing test is a result, not a failure of this stage. The branch\'s SonarQube gate '
         + 'is one call away — `quality_get`, which reads this run\'s branch by default; a red '
         + 'gate with new vulnerabilities is a finding to report with the output, not a failure '
-        + 'to hide.',
+        + 'to hide. ' + WAIT_FOR_COMMANDS + ' Then commit the branch\'s changes — no stage '
+        + 'after this one writes code, and work left uncommitted is work nothing can push.',
     MEMORY: 'Write what the NEXT session on this branch needs to know: what was done, what was '
       + 'tried and rejected and why, and anything that turned out to matter and would not be '
       + 'obvious from the diff. Be brief and concrete. This is saved as this branch\'s '
@@ -6556,8 +6597,23 @@ async function walkLifecycle(config, run, runToken, cwd, baseCommit, workspace,
     return { tokensIn: Number(row?.tokensIn) || 0, tokensOut: Number(row?.tokensOut) || 0 };
   };
 
+  const storedRow = (name) => (Array.isArray(stored)
+    ? stored.find((each) => each?.stage === name) : null);
+
   for (let at = 0; at < lifecycle.length; at++) {
     const stage = lifecycle[at];
+    // Where a carried-on run resumes, and what its DONE stages said, is the
+    // platform's (R263, `WorkflowService.resumeFrom`): the claim's lifecycle
+    // starts at the first stage not DONE. What only the daemon knows is WHY
+    // the stage about to run stopped last time — so that is handed to it.
+    const before = storedRow(stage.stage);
+    if (before?.state === 'FAILED' && before.outcome) {
+      // The attempt that stopped, handed to the one about to run.
+      carried[`${stage.stage} (the attempt that stopped)`] = `${before.outcome}\n\n`
+        + 'This stage is being run again to finish that. Run the commands it left running '
+        + 'again IN THE FOREGROUND — not with run_in_background — wait for each one to end '
+        + 'and read its output, then finish the stage properly.';
+    }
     // R305. What THIS stage's processes have used, across its attempts. Outside
     // the attempt loop on purpose: `run_stage` is one row per stage and keeps
     // the larger reading, so a second attempt after a refused gate must report
@@ -6668,6 +6724,21 @@ async function walkLifecycle(config, run, runToken, cwd, baseCommit, workspace,
         return;
       }
 
+      // The turn ended, but with commands it started in the background still
+      // running, or finished and never read. Not done: the result is what the
+      // stage was for. FAILED keeps the checkout and the session (R80), so
+      // /continue picks the run up HERE — the stages behind it stay pending.
+      if (last?.unfinishedShells?.length) {
+        const listed = last.unfinishedShells.map((command) => `\`${command.slice(0, 120)}\``).join(', ');
+        const why = `The ${stage.stage} stage ended with ${last.unfinishedShells.length} command(s) `
+          + `still running in the background, or finished and never read: ${listed}. `
+          + 'Nothing they proved was recorded — /continue runs this stage again and waits for them.';
+        log(`  ${why}`);
+        await reportStage(config, run, stage.stage, 'report', { state: 'FAILED', outcome: why });
+        await finish(config, run, 'FAILED', `${why}\n\n${last.text ?? ''}`.trim());
+        return;
+      }
+
       await reportStage(config, run, stage.stage, 'report', {
         state: 'DONE',
         // The PLAN's text IS the plan — the artefact R109 exists to store, and
@@ -7300,7 +7371,7 @@ async function spawnAgent(config, run, runToken, cwd, baseCommit, workspace, res
     // sending it again is a repeat wearing a resume's clothes — R69's rule about
     // the opening prompt, applied to the thing that now travels with it.
     writeUserMessage(child, resume?.prompt
-      ?? (promptFor(run) + harness + (stage ? stagePrompt(stage, carried) : '')));
+      ?? (promptFor(run) + harness + (stage ? stagePrompt(stage, carried, Boolean(plan?.body)) : '')));
 
     let lastText = '';
     // R305. This child's own last reading, handed back to the walk so the next
@@ -7326,6 +7397,10 @@ async function spawnAgent(config, run, runToken, cwd, baseCommit, workspace, res
     // wait for it, which is exactly the shape that loses it when `endSession`
     // closes stdin below.
     const backgrounded = new Set();
+    // Shell commands this child started in the background and never saw end
+    // — the walk will not call a stage done with any of them left (see
+    // background-shells.mjs).
+    const shells = new BackgroundShells();
     // The last of what the CLI said on stderr, for the exit decision below.
     // The usage-limit notice is written there, and a decision made on stdout
     // alone would call every window a crash.
@@ -7487,6 +7562,7 @@ async function spawnAgent(config, run, runToken, cwd, baseCommit, workspace, res
         buffer = buffer.slice(newline + 1);
         if (!line) continue;
         const event = safeJson(line);
+        if (event) shells.observe(event);
 
         // i257. Read off the RAW event, before `linesOf` flattens it to a
         // string: `describeCall` (`../lib/tool-line.mjs`) never carries
@@ -7893,7 +7969,8 @@ async function spawnAgent(config, run, runToken, cwd, baseCommit, workspace, res
       // gate on it, and carry it into the next stage. A run with no lifecycle
       // resolves with nothing, exactly as it always did.
       resolvePromise(stage
-        ? { code, signal, text: lastText, turnEnded, usage: childTotals }
+        ? { code, signal, text: lastText, turnEnded, usage: childTotals,
+          unfinishedShells: shells.unfinished() }
         : undefined);
     });
   });
@@ -8188,14 +8265,36 @@ function inlinedSkillsFor(skills) {
  * tool a session delegates through — confirmed end-to-end by hand, a probe
  * agent installed, invoked by name, and its answer returned correctly.
  */
+/** This machine, as a refusal names it: what it is called, where its config and console are. */
+function thisMachine(config) {
+  return {
+    name: config.name,
+    acceptsConsoleRules: config.acceptsRulesFromConsole === true,
+    configPath: config.configPath ?? null,
+    consoleUrl: config.url,
+  };
+}
+
+/**
+ * A refusal said on the run's own transcript, where the terminal and the run
+ * page show it — the run's summary alone left a window reading "failed" and
+ * nothing else, with the reason one page away.
+ */
+async function sayOnTheRun(config, run, text) {
+  await api(config, `/api/projects/${run.projectSlug}/runs/${run.id}/output`, {
+    method: 'POST',
+    body: { lines: text.split('\n').filter((body) => body.trim()).map((body) => ({ kind: 'ERROR', body })) },
+  }).catch((failure) => log(`  could not say it on the run: ${failure.message}`));
+}
+
 async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume, projectServers,
     skills, stageExperts, cannotDelegate, instincts, briefing, plan, lifecycle, stage, carried,
     agyCmd, granted, usage = null) {
   if (!granted.everything) {
-    const summary = 'This machine has not allowed everything, and Antigravity has no narrower '
-      + 'permission mode — no per-tool allow-list exists on it, and even reading needs it. Turn '
-      + 'on "allow everything" for this machine, or use Claude Code for this run.';
-    log(`  refusing to spawn Antigravity: ${summary}`);
+    // Antigravity needs it even to read: no per-tool allow-list exists on it.
+    const summary = needsEverything('agy', thisMachine(config), run, { readsWithout: false });
+    log(`  refusing to spawn Antigravity: ${summary.split('\n')[0]}`);
+    await sayOnTheRun(config, run, summary);
     await finish(config, run, 'FAILED', summary);
     return stage ? { code: -1, signal: null, text: summary, turnEnded: false } : undefined;
   }
@@ -8285,7 +8384,7 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
   const promptText = resuming
     ? resume.prompt
     : (promptFor(run) + harness + skillsBlock + expertsBlock
-      + (stage ? stagePrompt(stage, carried) : ''));
+      + (stage ? stagePrompt(stage, carried, Boolean(plan?.body)) : ''));
 
   const args = ['-p', promptText, '--output-format', 'stream-json', '--dangerously-skip-permissions'];
   if (run.model) {
@@ -8334,6 +8433,12 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
     // Code one does, with no code of its own.
     running.set(run.id, child);
 
+    // What the console can see of the checkout, and the commits as they land —
+    // the same watcher as the Claude Code path. Without it the platform never
+    // hears of this run's commits, so the finish rules (R40) see a run that
+    // wrote nothing and queue no push and no pull request.
+    const workingCopy = watchWorkingCopy(config, run, cwd, baseCommit);
+
     // stream-json arrives in chunks that split mid-line, same as Claude
     // Code's — buffer until a full line rather than assuming one chunk is
     // one event.
@@ -8430,6 +8535,7 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
     });
 
     child.on('error', async (failure) => {
+      workingCopy.stop();
       running.delete(run.id);
       const summary = `Could not spawn Antigravity: ${failure.message}`;
       await transcript.flush();
@@ -8439,6 +8545,7 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
     });
 
     child.on('close', async (code) => {
+      workingCopy.stop();
       running.delete(run.id);
       await transcript.flush();
       const text = result?.response
@@ -8466,6 +8573,10 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
       if (!stage) {
         await settleActions(config, run, cwd);
       }
+      // The last reading, as on the Claude Code path: after the agent has
+      // stopped and after anything the rules did.
+      await reportCommits(config, run, cwd, baseCommit);
+
       resolvePromise(stage
         ? { code, signal: null, text, turnEnded, usage: childTotals }
         : undefined);
@@ -8535,17 +8646,18 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     skills, stageExperts, readOnlyStage, instincts, briefing, plan, lifecycle, stage, carried,
     codexCmd, granted, shield, usage = null) {
   const failedBeforeSpawn = async (summary) => {
-    log(`  ${summary}`);
+    log(`  ${summary.split('\n')[0]}`);
+    await sayOnTheRun(config, run, summary);
     await finish(config, run, 'FAILED', summary);
     return stage ? { code: -1, signal: null, text: summary, turnEnded: false } : undefined;
   };
 
   const mayWrite = writesCodeProfile(run) && !readOnlyStage;
   if (mayWrite && !granted.everything) {
-    return failedBeforeSpawn('This machine has not allowed everything, and a Codex session that '
-      + 'writes has no narrower mode — it must commit and push, which its sandbox refuses, and '
-      + 'there is no allow-list for its shell. Turn on "allow everything" for this machine, or use '
-      + 'Claude Code for this run. (Read-only runs and stages need nothing.)');
+    // It must commit and push, which its sandbox refuses, and there is no
+    // allow-list for its shell — so everything, or nothing. Read-only runs
+    // and stages need nothing.
+    return failedBeforeSpawn(needsEverything('codex', thisMachine(config), run));
   }
   if (mayWrite) {
     log('  !! this machine allows EVERYTHING: this Codex session runs without a sandbox');
@@ -8591,6 +8703,12 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     args: [serverPath],
     envVars: Object.keys(cawdevEnv),
     enabledTools: codexCawdevTools(run, stage, mayWrite),
+    // Codex cuts an MCP call off after 60 s unless told otherwise, and
+    // `ask_user` waits up to ten minutes for a person: a question asked from
+    // Codex died before anybody could answer it, so it did not ask — it
+    // stopped. Longer than ask_user's own wait (mcp/server.mjs), so the
+    // question is answered or handed back as pending, never cut off.
+    toolTimeoutSec: CAWDEV_TOOL_TIMEOUT_SEC,
   });
 
   const cannotDelegate = stageExperts.length
@@ -8612,7 +8730,7 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
       })
       + inlinedSkillsFor(skills)
       + expertsBlockFor([], cannotDelegate)
-      + (stage ? stagePrompt(stage, carried) : ''));
+      + (stage ? stagePrompt(stage, carried, Boolean(plan?.body)) : ''));
 
   const model = stage?.model ?? run.model;
   const args = codexArgs({
@@ -8651,6 +8769,13 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     child.cawdevModel = model ?? null;
     // `reapCancelled` SIGTERMs whatever is here, whichever CLI it is.
     running.set(run.id, child);
+
+    // What the console can see of the checkout, and the commits as they land —
+    // the same watcher as the Claude Code path. Without it the platform never
+    // hears of this run's commits, so the finish rules (R40) see a run that
+    // wrote nothing and queue no push and no pull request.
+    const workingCopy = watchWorkingCopy(config, run, cwd, baseCommit);
+
     child.stdin.on('error', () => {
       // A CLI that died before reading its prompt says why on stderr.
     });
@@ -8728,6 +8853,7 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     });
 
     child.on('error', async (failure) => {
+      workingCopy.stop();
       running.delete(run.id);
       const summary = `Could not spawn Codex: ${failure.message}`;
       await transcript.flush();
@@ -8736,6 +8862,7 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     });
 
     child.on('close', async (code) => {
+      workingCopy.stop();
       running.delete(run.id);
       await transcript.flush();
       const text = failed ?? lastSaid ?? lastError ?? (err.trim() || 'Codex produced no output.');
@@ -8750,6 +8877,10 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
       if (!stage) {
         await settleActions(config, run, cwd);
       }
+      // The last reading, as on the Claude Code path: after the agent has
+      // stopped and after anything the rules did.
+      await reportCommits(config, run, cwd, baseCommit);
+
       resolvePromise(stage
         ? { code, signal: null, text, turnEnded: ended && !failed, usage: childTotals }
         : undefined);