Manage background work without losing its state

Understand the approach

Background delegation means a child can work while the parent handles an independent activity. It does not establish completion, persistence through every interruption, recurring execution or resource cleanup. For this capstone, a worker can implement one bounded module while the parent prepares the integration checklist from CONTRACT.md. The parent must still wait for the required implementation output before accepting the combined candidate.

Current Codex clients expose subagent activity, and the CLI provides /subagents for inspecting and switching threads. App and IDE controls can differ. Use the actual client's controls and record only observed states. Do not import Claude background front matter, Ctrl+B behavior or environment flags. A child that needs a fresh approval in a non-interactive situation may fail rather than opening a dialog; report that concrete gap instead of inventing its result.

The local simulate.cjs program is deliberately different: it deterministically prints work-package handoffs and runs the supplied reference integration. Its actualAgentsSpawned field is false. Use it to understand ownership and dependencies, then label any optional real Codex run separately. If a worker finishes before you observe a running state, report dispatch and return only. Recheck the resulting code version, because an earlier completion message does not prove later files still meet the contract.

In the app, open the child thread shown in main-chat activity, inspect its latest file/result, then ask the main chat to steer or stop that named child if needed. CLI switches threads with /subagents; the IDE panel depends on the client. Try a concrete error: a worker starts editing report.cjs despite owning normalization. Stop the overlap, preserve useful work, assign report.cjs one owner and rerun combined checks on the final files. Stopping a conversation does not rewind file edits. This dispatch→inspection→steering→checked return uses actual Codex controls rather than Claude-specific background shortcuts.

Practice and acceptance

A local simulation can teach dependency states; actual agent dispatch, waiting and return need actual client observations.

Try it step by step

1. Read the simulation's explicit kind and actualAgentsSpawned fields before interpreting its output.
2. Use A and B's frozen work packages for an optional actual Codex run; keep the parent on an independent review task.
3. Record actual dispatch, observed status and returned artifact where the client exposes them, without artificial delays.
4. Wait for the required implementation outputs and run integration on those actual files.
5. If no real child was run, report only simulation and code-check evidence; do not invent a monitoring trace.

A useful starting example

Illustration · adapt before use.

In a disposable delegation-capstone copy, give one actual subagent package A and starter/normalize.cjs only. While it works, prepare the parent integration checklist from CONTRACT.md. Inspect its status using the controls this client actually exposes, then wait for its returned diff and checks before synthesizing. Record only observed states. Run the actual candidate checks after both modules are complete. Keep simulate.cjs output labelled deterministic and never describe it as a live child transcript.

Tell the normalization worker to stay in starter/normalize.cjs and cover null plus unsupported values. Do not change B’s file.
If it is editing report.cjs, stop it, preserve its useful diff and assign that file one owner.
After both outputs return, run node run.cjs starter and node --test candidate.test.cjs in the actual destination.

Check your result

• Simulation records are labelled deterministic and actualAgentsSpawned:false is preserved.
• Any claimed dispatch, running state, intervention or return has actual client evidence.
• The returned code is checked separately from an agent's completion status.

Common mistakes

• Calling a background task durable automation or promising completion after the computer becomes unavailable.
• Importing a Claude background shortcut and interpreting an unobserved action as successful.