code-mode: expose create and observe operations

[cconger]

Why

Cell admission and observation need separate protocol operations. Returning a started handle plus a second asynchronous response from one execute request is awkward across IPC and leaves cancellation ownership unclear.

At the wire boundary, each operation also needs its own result union so the serialized type cannot describe outcomes that operation cannot produce. This type narrowing is limited to the protocol/session layer: runtime-owned CellEvent/PausableCellEvent and Core's model/trace RuntimeResponse retain their existing roles.

What

• Replace session-level execute/wait with wire-facing create_cell(CreateCellRequest) and observe(ObserveRequest) operations.
• Keep the model-facing tools named exec and wait; only the host/Core session contract changes.
• Have the host assign and return CellId at admission in this layer.
• Define flat, explicitly tagged wire unions for operation results.
  • ObserveOutcome: yielded, completed, terminated, or missing.
  • TerminateOutcome: completed, terminated, or missing; yielded is not representable.
  • missing carries only the requested CellId.
• Convert those wire outcomes into RuntimeResponse after receipt instead of using RuntimeResponse as the session return type.
• Add a Core guard that terminates a created cell if its initial observation is canceled.
• Remove the exported pending-observation protocol surface; pausable execution remains a direct runtime API.
• Add exact serde coverage for requests, the tagged outcome shapes, tool definitions, output items, and image detail.

Host/Core wire sequence

sequenceDiagram
    participant Core
    participant Host
    Core->>Host: create_cell(CreateCellRequest)
    Host-->>Core: CellId
    Core->>Host: observe(ObserveRequest)
    alt cell yields
        Host-->>Core: ObserveOutcome::Yielded
    else cell completes
        Host-->>Core: ObserveOutcome::Completed
    else cell is terminated
        Host-->>Core: ObserveOutcome::Terminated
    else cell is absent
        Host-->>Core: ObserveOutcome::Missing
    end
    opt initial observe is canceled
        Core->>Host: terminate(CellId)
        alt cell completed first
            Host-->>Core: TerminateOutcome::Completed
        else termination wins
            Host-->>Core: TerminateOutcome::Terminated
        else cell is absent
            Host-->>Core: TerminateOutcome::Missing
        end
    end

Loading

All successful payloads above remain wrapped by the session's transport-level Result<T, String>.

Stack boundary

This PR defines the operation split and valid wire outcomes, but does not yet make observation delivery replayable after an ambiguous IPC response. #29397 adds caller-provided request identity and detached, replayable observations.

Validation

• just test -p codex-code-mode
• just test -p codex-code-mode-protocol
• Core regression for cancellation after create and before the initial observation completes.

Stack parent: #29403.

[jif-oai]

This allows impossible wire states such as MissingCell(Yielded) or Completed(Yielded)
Sounds like a design smell

[jif-oai]

These exact tests are locking the future wire format to serde's default Rust enum shape ({"LiveCell":{"Result":...}}).
That makes Rust variant names part of the protocol and is awkward to version or implement outside Rust...

[jif-oai]

(found by Codex)
terminate has the same ambiguous-response problem as create/observe, but no request identity or replay. Once the host tombstones the cell, a lost response retries as Missing, dropping the terminal content/outcome. Can we make termination replayable too, or retrieve its terminal result through observe?

[jif-oai]

This records a cancelled observation as a failed, already-ended runtime before terminate has succeeded