feat: Reliable slash-command initial prompt delivery

[parsakhaz]

---

type: feature-ticket
id: slash-command-submission
status: ready
zone: 2
pr:
github: #358

Feature: Reliable slash-command initial prompt delivery

Intent

Initial prompt handling has two ways to fail a slash command, and both fail silently:

1. Composer path: in a four-pane dogfood run (issue feat: add event-driven RunPane orchestration and reliable agent startup #353), /do TM-x was staged
   but never executed on 3 of 4 panes — the autocomplete menu consumed the bare \r
   the raw delivery path emits. Each pane was rescued manually with
   panels submit-composer --strategy auto --yes.
2. Argument path (discovered during capture): Codex creates always deliver the
   initial input as a CLI argument, and PTY probes prove argument delivery bypasses
   Codex's TUI command layer — codex "/status" goes to the model as literal text.
   Yet submitCreateInitialInput reports verifiedSubmitted: true unconditionally
   for Codex argument delivery (main/src/ipc/runpane.ts:690) — a false success: the
   skill/command never expands, the model improvises on the literal text.

Delivery must be chosen per agent × prompt shape, and "verified" must mean verified.
Staged is not submitted; delivered-as-text is not executed-as-command.

Peeled from #353 during capture of epic #356. Epic phase 4 (verified startup) prefers
this landed first. Probe evidence: refs/submission-probe-evidence.md.

Desired end state

• /do TM-x, ordinary prose, a multiline pasted prompt, or an unknown slash command
  supplied as initial input reliably executes on both agents — or returns a
  structured, actionable failure at creation time. Never silently staged text, never
  a false verifiedSubmitted.
• If a composer submit is swallowed by autocomplete, RunPane retries through the
  semantic strategy — only on positive evidence, never duplicating the command.

Key architecture directions

• D1 — Delivery mode is chosen per agent × prompt shape (probe-validated matrix):
  fresh Claude creates default to argument delivery (claude --session-id <id> "<prompt>" — verified to execute slash commands, eliminating the composer failure
  class); Codex non-slash input keeps today's argument delivery; Codex
  slash-command input and any composer-bound case (resumed Claude sessions, agents
  without argument support) route through the semantic submit-composer path — never
  a bare-\r assumption · rejected: composer-verify-retry as the universal fix
  (argument mode is strictly more reliable where it works); argument mode as the
  universal fix (bypasses Codex's TUI command layer, and resumed Claude sessions drop
  the prompt argument today).
• D2 — verifiedSubmitted is earned, never assumed: the unconditional
  verifiedSubmitted: true for Codex argument delivery is replaced by
  shape-aware reporting (argument delivery of a slash command on Codex is a routing
  decision per D1, not a verified success). Composer-path success requires the
  composer cleared AND activity/command execution begun.
• D3 — Retry is evidence-gated: re-submit only when the staged text is provably
  still present in the composer readback (the dogfood failure signature). Composer
  cleared without activity → structured submission_unverified blocker with attempt
  count and nextCommand — never a blind retry, never a hang, never a false success.
  Delayed verification therefore cannot produce a duplicate submission.
• D4 — Preserve the exact command text and arguments; never select or rewrite an
  autocomplete candidate.
• D5 — Additive and parity-kept: existing commands/JSON untouched, npm CLI /
  daemon schema / generated contracts / Python wrapper updated together, stdout stays
  machine-clean. (Matches epic feat: Event-driven RunPane orchestration #356 D7.)

Proposed approach

• The --wait-ready create path is already semantic (write +
  submitComposerForPanel(panel, 'auto'), main/src/ipc/runpane.ts:717-719) and
  suppresses the raw path via initialInputSentAt (runpane.ts:631-644); the raw
  bare-\r path (main/src/services/terminalPanelManager.ts:379) serves
  no-wait-ready creates, GUI-created sessions, and resumed Claude sessions.
• Claude argument delivery already exists (terminalPanelManager.ts:253-268) —
  fresh Claude creates need initialInputMode: 'argument' set the way
  runpane.ts:640 does for Codex, plus slash-shape detection for the Codex branch.
• Fix the false success at runpane.ts:690-701; reuse the submit-composer
  contract (shared/types/runpaneOrchestration.ts:389) and its verification
  heuristic (runpane.ts:1128) for the composer-bound cases, adding the
  evidence-gated retry (D3).
• Regression fixtures: prose, multiline, known slash (/do TM-x), unknown slash —
  per agent where the matrix differs (main/src/ipc/runpane.test.ts pattern);
  contract/parity via scripts/test-runpane-contract.js.

Verification criteria

• AC1 — WHEN a fresh Claude pane is created with a slash-command initial input,
  the spawned command line shall carry the prompt as a quoted argument
  (--session-id <id> "<prompt>") and the create result shall not report composer
  delivery.
• AC2 — WHEN a Codex pane is created with a slash-command initial input, delivery
  shall route through the semantic composer path and the create result's
  verifiedSubmitted shall be true only after verification — never the current
  unconditional true.
• AC3 — WHEN a composer submit is swallowed (staged text still present in the
  composer readback), the system shall re-submit via the semantic strategy and report
  verifiedSubmitted: true with the command executed exactly once.
• AC4 — IF the composer is cleared but verification has not completed, THEN the
  system shall not re-submit (no duplicate execution under delayed verification).
• AC5 — IF submission cannot be verified within the bounded retry budget, THEN
  the response shall be ok: false with prompt.staged: true,
  verifiedSubmitted: false, an attempt count, blocker.kind: "submission_unverified", and a nextCommand — within bounded time.
• AC6 — WHEN ordinary prose or a multiline pasted prompt is supplied on either
  agent, submission shall complete with verifiedSubmitted: true (no regression
  from the routing change).
• AC7 — WHEN an unknown slash command is supplied, the exact text shall be
  preserved (no autocomplete candidate selected or rewritten) and the outcome shall
  be verified submission or the AC5 blocker.

Criterion	Method	Command / flow	✓
AC1, AC2	automated	command-construction + delivery-routing tests (pattern: main/src/ipc/runpane.test.ts)	[ ]
AC3, AC4	automated	composer fixtures: staged-text-present vs composer-cleared-verification-lagging	[ ]
AC5	automated	verification forced to fail; assert payload + bounded duration	[ ]
AC6, AC7	automated	prose / multiline / unknown-slash fixtures per agent	[ ]
all	automated	scripts/test-runpane-contract.js npm/Python parity run	[ ]

Out of scope

• Interstitial detection/handling (update prompts, trust prompts, planning modals) —
  epic feat: Event-driven RunPane orchestration #356 phase 4.
• Event emission for prompt_staged/prompt_submitted — epic feat: Event-driven RunPane orchestration #356 phase 2.
• Changing submit-composer's public contract.
• Autocomplete candidate selection as a feature.

Justification

• Composer-verify-retry as the universal fix — rejected by probe: argument delivery
  executes Claude slash commands directly (claude 2.1.217, Status panel rendered, no
  model roundtrip), so fresh Claude creates default to argument mode and the composer
  failure class is eliminated where possible.
• Argument mode as the universal fix — rejected by probe: codex "/status" bypasses
  the TUI command layer (codex-cli 0.144.4, conversational reply), and resumed Claude
  sessions drop the prompt argument today (terminalPanelManager.ts:266-268); those
  cases stay composer-bound with semantic submit.
• "The initial-input path emits a raw Enter" — corrected during the gate: wait-ready
  is already semantic (runpane.ts:717-719); the true gap is threefold, including a
  newly discovered unconditional verifiedSubmitted: true for Codex argument
  delivery (runpane.ts:690) that this ticket now fixes.
• Duplicate-free retry — safe because retry is evidence-gated on staged text still
  visible in the composer readback; absence of verification alone never triggers a
  re-submit.

Open questions

• [NEEDS CLARIFICATION] Whether claude --resume <id> "<prompt>" accepts a prompt
  argument (the code drops it today, terminalPanelManager.ts:266-268) — check at
  plan time; if yes, resumed Claude sessions can ride the argument path too.

References (in refs/)

• refs/discussion.md — decision log from the 2026-07-21 discussion.
• refs/submission-probe-evidence.md — PTY probes proving argument-mode slash
  execution on Claude and bypass on Codex; code trace of the three delivery paths and
  the verifiedSubmitted: true false-success bug.

[parsakhaz]

Event-driven RunPane orchestration (issue #353) — decision log

Date: 2026-07-21
Participants: parsakhaz, Claude (code research via Codex code-researcher)

Context

Issue #353 specifies an event-driven, resumable orchestration surface for RunPane so a
long-lived Pane Chat orchestrator can sleep until meaningful agent transitions instead of
polling panels screen / panels wait. Follow-up to #277 / PR #278.

Key research findings (all file:line-verified)

• Push transport already exists. The daemon socket protocol defines event frames
  (shared/types/daemon.ts:27) and the server broadcasts session/panel/terminal events to
  all connected socket clients (main/src/daemon/server.ts:66, fanout at
  main/src/daemon/bootstrap.ts:245). Node/Python CLI clients discard event frames and
  close after one response (packages/runpane/src/daemonClient.ts:134,
  packages/runpane-py/src/runpane/daemon_client.py:62). panels watch is a client +
  semantics problem, not a new transport.
• activityStatus is a byte-silence heuristic: first PTY output → active, 30s silence
  → idle (main/src/services/terminalPanelManager.ts:1111). Not agent semantics.
• No canonical attention state exists to reuse. Activity lives in main, session status
  in sessionManager, unread + notification debounce (60s + focus gating) renderer-only
  (frontend/src/hooks/useNotifications.ts:20,166). Issue scope item 6 ("reuse the
  attention state powering human notifications") is not implementable as written — the
  semantic state must be created in main process as new canonical truth; renderer
  notifications can consume it later.
• No event cursors exist; only session_outputs.id is monotonic
  (main/src/database/schema.sql:33). Daemon event frames carry no sequence numbers.
• ready + active coexistence confirmed: isCliReady latches permanently after
  first CLI response (terminalPanelManager.ts:981), independent of activity.
• Pinning is nearly free: sessions.is_favorite + favorite_pinned_at exist in DB,
  startPinned exists on session creation (sessionManager.ts:322), and
  sessions:toggle-favorite is already in the shared daemon command registry
  (main/src/ipc/session.ts:1461) — the CLI just doesn't expose it.
• Slash-command hardening builds on existing submit-composer (verifiedSubmitted,
  blocker/nextCommand at shared/types/runpaneOrchestration.ts:389,
  main/src/ipc/runpane.ts:1128).
• Output-cursor gotcha: raw terminal scrollback is not 1:1 with session_outputs rows;
  panels output --since must pick which stream it reads.

Decisions

1. Split the issue (decided): peel two small, independent, dogfood-unblocking tickets
   out of feat: add event-driven RunPane orchestration and reliable agent startup #353 —

   • (a) declarative pane pinning (--pinned on create, pin/unpin mutation, pinned in
     list/status output);
   • (b) slash-command-aware initial prompt submission (semantic submit + verify +
     bounded retry for /do TM-x-style prompts).
     The remainder becomes an epic: phase 1 = semantic state model on byte-silence signal,
     phase 2 = event persistence + cursors + watch/await CLI, phase 3 = verified startup /
     interstitial handling + multi-target/pane watch. Milestone emission (events emit) and
     MCP-warning severity ride in later phases as specced.

2. agent_idle detection = byte-silence debounce only for phase 1 (decided; user
   rationale: it generalizes — works for any agent without per-agent adapters, keeping
   the base event contract agent-agnostic instead of privileging Claude/Codex).

   • Accepted limitation, to be stated in the epic contract: a TUI that repaints while
     semantically idle reads as active, and an agent thinking silently past the debounce
     emits a false agent_idle. The acceptance criterion "spinner frames never satisfy
     the wait" holds only to the extent the debounce absorbs them.
   • Upgrade path: optional per-agent screen-aware adapters (same bounded screen-scan
     machinery as blocker detection, main/src/ipc/runpane.ts:968) may later refine the
     signal but must never become load-bearing for base events.
   • Debounce should be longer/configurable than the current 30s.

3. Command shape (recommended, unobjected): panels watch (JSONL subscription over
   the existing event channel) as core primitive; panels await / await-any as
   exit-on-first-match sugar. panels wait frozen as legacy polling surface. No
   orchestrate command group; reconciliation is panes status --changed-since.

4. Cursor scope & retention (recommended, unobjected): one global daemon-scoped
   monotonic sequence, persisted in a new SQLite events table (survives app restart =
   daemon restart), bounded retention by count + age. Lifecycle-event and output cursors
   are separate namespaces (output already has session_outputs.id).

5. Attention source of truth (recommended, unobjected): promote semantic transitions
   into the main process as the new canonical layer (phase 1); renderer notification
   logic can migrate onto it later rather than the CLI borrowing renderer state.

Open questions

• Which stream panels output --since reads (session_outputs vs scrollback) — resolve in
  epic phase 2 planning.
• Exact debounce default/configurability for byte-silence idle.
• Whether feat: add event-driven RunPane orchestration and reliable agent startup #353 is edited down to the epic scope or superseded by new items linking back.

[parsakhaz]

Delivery-mode probes — argument-mode slash-command execution (2026-07-21)

Questions under test (Socratic gate Q1/Q2/Q3 on the slash-command submission ticket):
can argument-mode delivery replace composer submission (Q1), what is the actual gap
across creation paths (Q2), and what signal makes retry safe (Q3)?

Method

PTY probe: fork <cli> "/status" in a real PTY (120×40), capture all raw output for
40s. /status is a TUI command in both CLIs with recognizable non-conversational
output, so it distinguishes "command executed by the TUI layer" from "text handed to
the model".

Versions: claude 2.1.217, codex-cli 0.144.4.

Results

CLI	<cli> "/status" behavior	Verdict
claude	Rendered the actual Status settings panel (Version 2.1.217, Session ID, login method, model) — no model roundtrip	argument mode EXECUTES slash commands
codex	Model round-trip: Working (Ns) spinner for ~5s, then a conversational reply ("Ready. No task is currently in progress; workspace is …")	argument mode BYPASSES the TUI command layer — slash text goes to the model literally

Code-trace findings (Q2 — the actual gap)

• Codex creates always use argument delivery (main/src/ipc/runpane.ts:640 →
  codex "<prompt>" at main/src/services/terminalPanelManager.ts:298-311).
• Claude argument delivery exists (claude --session-id <id> "<prompt>",
  terminalPanelManager.ts:253-268) but nothing ever sets initialInputMode: 'argument' for Claude — Claude creates get composer delivery.
• With --wait-ready, the create path is already semantic: write input +
  submitComposerForPanel(panel, 'auto'), returning verifiedSubmitted
  (runpane.ts:717-719); shouldCreateSubmitInitialInput sets initialInputSentAt
  so the raw path is suppressed (runpane.ts:631-644).
• Without --wait-ready, the raw path fires: staged text + bare \r
  (terminalPanelManager.ts:379) — the autocomplete-swallow failure. This raw path
  also serves GUI-created sessions and resumed Claude sessions (the resume command
  drops the prompt argument, terminalPanelManager.ts:266-268).
• Discovered false-success bug: submitCreateInitialInput returns
  verifiedSubmitted: true unconditionally for Codex argument delivery
  (runpane.ts:690-701). Combined with the probe result, a Codex create with a
  slash-command initial input reports verified success while the command never
  executes as a command — the model receives the literal text instead.

Conclusions

• Q1: adopt argument delivery as the default for fresh Claude creates (verified to
  execute slash commands) — it eliminates the composer failure class there. It cannot
  replace composer submission for Codex slash commands (bypasses the TUI layer) or
  resumed Claude sessions (prompt arg dropped today).
• Q2: the gap is threefold — (a) Claude never rides the existing argument path,
  (b) the no-wait-ready raw path submits with a bare \r, (c) Codex argument
  delivery falsely reports verifiedSubmitted for slash commands. The wait-ready
  path already works.
• Q3: the safe retry signal is positive evidence — the staged text still visible
  in the composer readback (exactly the dogfood failure signature). Composer cleared
  without activity → report, never blind-retry; composer cleared with activity →
  success. Delayed verification therefore cannot cause a duplicate submission.

[parsakhaz]

<!doctype html>

<title>Reliable slash-command initial prompt delivery — Explainer</title> <style> :root { --paper: #FAF8F5; --ink: #1F2328; --ink-soft: #5A5F66; --line: #E4DFD7; --panel: #FFFFFF; --accent: #0E7569; --accent-soft: #E3F0EE; --warn: #B45309; --warn-soft: #F7EBDD; --out: #9F3A38; --out-soft: #F6E8E7; --mono: ui-monospace, "SF Mono", SFMono-Regular, Menlo, Consolas, monospace; --serif: Georgia, "Iowan Old Style", "Times New Roman", serif; --sans: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; } @media (prefers-color-scheme: dark) { :root { --paper: #15191D; --ink: #E8E6E1; --ink-soft: #9BA1A8; --line: #2C3237; --panel: #1C2126; --accent: #2FA79A; --accent-soft: #16302D; --warn: #D98E3D; --warn-soft: #32271A; --out: #CF6F6C; --out-soft: #33211F; } } * { margin: 0; padding: 0; box-sizing: border-box; } body { background: var(--paper); color: var(--ink); font-family: var(--sans); line-height: 1.6; font-size: 16px; } .page { max-width: 720px; margin: 0 auto; padding: 3rem 1.25rem 5rem; } header.masthead { border-bottom: 1px solid var(--line); padding-bottom: 1.75rem; margin-bottom: 2.5rem; } .meta-row { display: flex; flex-wrap: wrap; gap: .5rem .75rem; align-items: center; margin-bottom: 1rem; } .badge { font-family: var(--mono); font-size: .72rem; letter-spacing: .06em; padding: .2rem .55rem; border-radius: 3px; text-transform: uppercase; } .badge.type { background: var(--accent-soft); color: var(--accent); } .badge.status { border: 1px solid var(--line); color: var(--ink-soft); } .badge.zone { border: 1px solid var(--warn); color: var(--warn); background: var(--warn-soft); } h1 { font-family: var(--serif); font-weight: 500; font-size: 2.1rem; line-height: 1.2; letter-spacing: -.01em; text-wrap: balance; margin-bottom: .75rem; } .standfirst { color: var(--ink-soft); font-size: 1.05rem; max-width: 60ch; } .links { margin-top: 1rem; font-size: .85rem; display: flex; gap: 1.25rem; flex-wrap: wrap; } .links a { color: var(--accent); text-decoration: none; border-bottom: 1px solid var(--accent-soft); } section { margin-bottom: 2.75rem; } .eyebrow { font-family: var(--mono); font-size: .72rem; letter-spacing: .1em; text-transform: uppercase; color: var(--accent); margin-bottom: .6rem; } h2 { font-size: 1.25rem; margin-bottom: .75rem; letter-spacing: -.01em; } p { margin-bottom: .9rem; max-width: 65ch; } code { font-family: var(--mono); font-size: .85em; background: var(--panel); border: 1px solid var(--line); padding: .08em .35em; border-radius: 3px; } .before-after { display: grid; grid-template-columns: 1fr 1fr; gap: 1rem; margin: 1.25rem 0; } @media (max-width: 560px) { .before-after { grid-template-columns: 1fr; } } .panel { background: var(--panel); border: 1px solid var(--line); border-radius: 6px; padding: 1.1rem 1.2rem; } .panel h3 { margin-bottom: .6rem; font-size: .78rem; font-family: var(--mono); letter-spacing: .08em; text-transform: uppercase; color: var(--ink-soft); } .panel.after { border-color: var(--accent); } .panel.after h3 { color: var(--accent); } .panel ul { padding-left: 1.1rem; font-size: .92rem; } .panel li { margin-bottom: .4rem; } .diagram { margin: 1.5rem 0 2.5rem; } .diagram figcaption { margin-top: .5rem; font-size: .8rem; color: var(--ink-soft); } .matrix { width: 100%; border-collapse: collapse; font-size: .9rem; } .matrix th, .matrix td { text-align: left; padding: .55rem .7rem; border-bottom: 1px solid var(--line); vertical-align: top; } .matrix th { font-family: var(--mono); font-size: .68rem; letter-spacing: .05em; text-transform: uppercase; color: var(--ink-soft); } .matrix td.ok { color: var(--accent); font-weight: 600; } .matrix td.bad { color: var(--out); font-weight: 600; } .pipeline { display: flex; align-items: stretch; margin: 1.5rem 0; overflow-x: auto; padding-bottom: .5rem; } .stage { background: var(--panel); border: 1px solid var(--line); border-radius: 6px; padding: .75rem .9rem; min-width: 130px; flex: 1; } .stage .name { font-family: var(--mono); font-size: .78rem; font-weight: 600; margin-bottom: .25rem; } .stage .desc { font-size: .78rem; color: var(--ink-soft); line-height: 1.45; } .arrow { align-self: center; padding: 0 .5rem; color: var(--ink-soft); flex: none; } .strip-note { margin: -.5rem 0 0; font-size: .8rem; color: var(--ink-soft); } .decision { border-left: 3px solid var(--accent); padding: .2rem 0 .2rem 1.1rem; margin-bottom: 1.25rem; } .decision .tag { font-family: var(--mono); font-size: .78rem; font-weight: 700; color: var(--accent); } .decision p { margin: .3rem 0 0; font-size: .95rem; } .decision .rejected { color: var(--ink-soft); font-size: .85rem; } .decision .rejected::before { content: "rejected — "; font-style: italic; } .scope { display: grid; grid-template-columns: 1fr 1fr; gap: 1rem; } @media (max-width: 560px) { .scope { grid-template-columns: 1fr; } } .scope .panel.in { border-top: 3px solid var(--accent); } .scope .panel.outof { border-top: 3px solid var(--out); } .scope .panel.outof h3 { color: var(--out); } .vgroup { margin-bottom: 1.6rem; } .vgroup-head { font-family: var(--mono); font-size: .72rem; letter-spacing: .06em; text-transform: uppercase; color: var(--accent); margin-bottom: .7rem; } .vlist { list-style: none; } .vlist li { position: relative; padding-left: 1.9rem; margin-bottom: .55rem; font-size: .92rem; line-height: 1.45; max-width: 66ch; } .vlist li::before { content: ""; position: absolute; left: 0; top: .18em; width: 15px; height: 15px; border: 1.5px solid var(--ink-soft); border-radius: 4px; } .dials { border: 1px solid var(--line); border-radius: 8px; background: var(--panel); padding: 1.15rem 1.3rem; } .dial { display: grid; grid-template-columns: 118px 1fr; gap: 1rem; align-items: start; padding: .8rem 0; border-bottom: 1px solid var(--line); } .dial:last-child { border-bottom: none; } .dial-label { font-family: var(--mono); font-size: .72rem; letter-spacing: .05em; text-transform: uppercase; color: var(--ink-soft); padding-top: .3rem; } .dial-opts { display: flex; gap: .45rem; flex-wrap: wrap; align-items: center; } .pill { font-size: .82rem; padding: .32rem .72rem; border-radius: 999px; border: 1px solid var(--line); color: var(--ink-soft); } .pill.on { border-color: var(--accent); background: var(--accent-soft); color: var(--accent); font-weight: 600; } .dial-why { flex-basis: 100%; font-size: .8rem; color: var(--ink-soft); margin: .4rem 0 0; } .dials-note { font-size: .8rem; color: var(--ink-soft); margin: .9rem 0 0; } footer { border-top: 1px solid var(--line); margin-top: 3rem; padding-top: 1.25rem; font-size: .8rem; color: var(--ink-soft); } </style>

feature ready zone 2 — contained

Reliable slash-command initial prompt delivery

Choose the delivery path per agent × prompt shape, earn verifiedSubmitted instead of assuming it, and retry only on positive evidence — so /do TM-x executes or fails structurally, never silently.

epic #356 (phase 4 prefers this first) · origin: #353

Initial input	Claude (fresh)	Claude (resume)	Codex
Slash command	argument — probe-verified to execute	composer + semantic submit	argument today = model gets literal text, falsely "verified" → composer + semantic submit
Prose / multiline	argument	composer + semantic submit	argument (today's behavior, kept)

The probe-validated delivery matrix (D1). Red cell = the discovered false-success bug at runpane.ts:690; every composer cell gets verification + evidence-gated retry.

01 · Why

Two silent failure modes, one of them newly discovered

Composer path: the #353 dogfood run staged /do TM-x on four panes; three never executed — autocomplete ate the bare \r the raw path emits. Argument path: PTY probes during capture proved codex "/status" bypasses the TUI command layer entirely (the model answered conversationally), yet submitCreateInitialInput reports verifiedSubmitted: true unconditionally for Codex argument delivery — today a Codex create with a slash command claims verified success while the skill never expands. Conversely, claude "/status" does execute (real Status panel, no model roundtrip), so Claude can escape the composer entirely on fresh creates. Backend/CLI only — no UI touched.

Before

• Claude: staged text + bare \r; autocomplete swallows it silently
• Codex slash commands: model gets literal text, reported as verified
• Failures discovered later by reading screens

After

• Delivery matrix per agent × prompt shape (probe-validated)
• verifiedSubmitted earned, never assumed
• Swallowed submit → evidence-gated retry, executed exactly once
• Unprovable → structured submission_unverified + nextCommand

02 · Direction

Locked directions and shape of the work

D1 — delivery matrix, per agent × prompt shape

Fresh Claude → argument (probe-verified slash execution); Codex non-slash → argument (kept); Codex slash + resumed Claude + fallback → semantic composer path, never bare \r.

composer-verify-retry as the universal fix (argument is strictly better where it works); argument as the universal fix (bypasses Codex's TUI command layer; resume drops the prompt arg today).

D2 — verified means verified

The unconditional verifiedSubmitted: true for Codex argument delivery is replaced by shape-aware reporting; composer success requires composer cleared AND activity begun.

D3 — evidence-gated retry

Re-submit only when the staged text is provably still in the composer readback (the dogfood signature). Composer cleared without activity → structured blocker. Delayed verification can never duplicate a submission.

blind retry on unverified (duplicate risk); unbounded loops; false success on staged text.

D4 — exact text preserved

Never select or rewrite an autocomplete candidate; commands submit verbatim.

D5 — additive, npm/Python parity kept

Existing contracts untouched; both wrappers and the generated contract updated together. (Matches epic #356 D7.)

matrix routing

argument for Claude fresh; shape detection for Codex

→

honest verify

fix runpane.ts:690 false success

→

gated retry

staged-text evidence or structured blocker

→

proven

per-agent fixtures + parity green

Indicative sequence — /do's plan stage owns the real plan (including checking whether claude --resume <id> "<prompt>" can carry resumed sessions onto the argument path).

03 · Scope

In / out

In scope

• Delivery-mode matrix at pane/panel creation
• Fix the Codex argument false-success
• Evidence-gated, duplicate-free retry + structured blocker
• Per-agent regression fixtures; npm + Python parity

Out of scope

• Interstitial detection/handling (epic feat: Event-driven RunPane orchestration #356 phase 4)
• prompt_submitted events (epic feat: Event-driven RunPane orchestration #356 phase 2)
• Changing submit-composer's public contract
• Autocomplete candidate selection

04 · Verification

What we'll check

Backend / CLI (all automated)

• AC1 — fresh Claude + slash input: spawned command carries the quoted prompt argument; no composer delivery reported
• AC2 — Codex + slash input: routes through semantic composer path; verifiedSubmitted only after verification
• AC3 — swallowed submit (staged text still present): semantic re-submit, executed exactly once
• AC4 — composer cleared but verification lagging: no re-submit, no duplicate
• AC5 — unverifiable: ok: false, attempt count, submission_unverified, nextCommand, bounded time
• AC6 — prose/multiline on both agents: no regression
• AC7 — unknown slash command: text preserved verbatim; verified or AC5 blocker
• npm/Python contract parity run stays green

05 · Run config

How /do will run this

Zone

0123

Contained reliability fix in the CLI/daemon submission path, reusing shipped machinery; no zones.md escalator.

Derived

single lane — Codexcaps 1/1direct researchfrontend verifier: n/a

Estimated by /create-plan; dials derive from references/zones.md. You set the final zone at capture.

zone 2 — contained · Generated by /create-plan · This page is the alignment surface; item.md remains the contract /do executes against.

[parsakhaz]

Live reproduction during orchestration of this very ticket (2026-07-22, runpane 2.4.30, claude 2.1.217):

panes create --agent claude --wait-ready --initial-input-file <file containing "/do 358"> returned:

"initialInput": { "delivered": true, "submitted": true, "strategy": "enter", "sequenceName": "enter-cr", "verifiedSubmitted": true }

…but no Claude session ever started (no ~/.claude/projects/<worktree> transcript dir, agent idle at composer). The staged slash command sat unsubmitted on both panes created this way — verifiedSubmitted: true was a false positive from the create-path verification. Recovery was the known #353 fix, which worked first try on both panels:

runpane panels submit-composer --panel <id> --strategy auto --yes --json

After recovery, session transcripts appeared immediately with the /do command as the first user message. Two implementation notes from this repro: (1) the create path's verification accepted activity that was just startup output — verification needs the composer-cleared + execution-begun evidence this ticket specifies (D2/D3); (2) absence of a ~/.claude/projects session dir proved non-submission definitively — a useful oracle for the regression fixtures.

Also observed (relevant to #356, noted there): panels screen returned screen.text of 0 chars for a live, hidden background panel, so screen-based verification was blind; process-level and transcript-level evidence had to fill in.

[parsakhaz]

---

type: postmortem
item: 358 (slash-command-submission)
pr: #360
anchor: #360

Postmortem — 358 slash-command-submission (ops-only)

Run operations (always)

Wall-clock: 2026-07-21 22:53 → 2026-07-22 00:45 PDT (112 min, transcript-scripted).
Agent-active vs human-idle: human-idle 0 min — the run never waited on a human;
all 23 transcript gaps >60s (76 min, 71% of wall-clock) are legitimate waits on detached
Codex dispatches, bridged by task notifications and self-scheduled wakeups.
Post-completion idle: none (postmortem published at run end).

Per-step timing (starts exact from dispatch epochs; ends from the following transcript
event; tokens from Codex tokens used stdout and main-transcript usage dedup):

Step / dispatch	Start	Dur	Tokens	Note
Step 0 preflight + load + branch FF	22:53	~7m	(overseer)	branch fast-forwarded v2.4.5→v2.4.32
Step 1 direct research + plan write	23:00	~7m	(overseer)	zone 2: no dossier
plan-reviewer	23:07	~4m	62,566	3 MF + 1 SF → folded into plan
implementer (initial, full slice)	23:11	~13m	189,577	DONE, 381/381
backend-verifier #1	23:24	~3m	74,898	fail: 3 assertion-strength gaps
implementer fix 1 (tests)	23:27	~3m	94,632Δ	resume session
backend-verifier #2	23:30	~5m	41,143	pass
build gate + commit + rebase + PR open	23:43	~6m	(overseer)	PR #360
code-reviewer (aborted)	23:35	~5m	15,578	wasted: repo missing .claude/agents/code-reviewer.md
PR diagram author + host	23:45	~10m	(overseer)	overlapped with review lane
code-reviewer pass 1 (retry)	23:41	~30m	53,910	3 MF (1 security)
implementer fix 2 (3 MF)	00:14	~5m	88,044Δ	zone escalated 2→1
review pass 2 (scoped)	00:19	~3m	56,143	MF-2 fixed; MF-1/MF-3 persist, sharper
implementer fix 3	00:22	~5m	248,409Δ	output-only signal + race-safe handoff
review pass 3 (scoped)	00:27	~2m	45,822	MF-3 fixed; MF-1 narrowed to same-ms edge
implementer fix 4 (gen counter)	00:29	~3m	39,630Δ	post-cap, duplicate-safe direction
backend-verifier #3 (final QA)	00:32	~3m	58,013	pass, 388/388
body/QA comment + wrap-up + postmortem	00:36	~9m+	(overseer)

Phase aggregates: plan ≈16% of wall-clock, implement+verify ≈33%, post-PR review loop
≈43%, wrap-up ≈8%. Summed turnaround gaps (Overseer picking up completed dispatches):
small — the in-turn wait loops and notifications kept pickup within ~1 min of each
marker.

Ranked stalls (none needed a human nudge):

1. code-reviewer pass 1 ran ~30 min against low-effort expectations (~10 min) — the
   single biggest wall-clock block; partly queue/model variance, no action beyond noting.
2. Wasted code-reviewer dispatch (~5 min + 15.6k tokens): the repo's synced
   .claude/agents/ set lacks code-reviewer.md; the role charter correctly aborted.
   Preflight had verified the plan-reviewer file but not all roles the run would use.
3. Baseline pnpm --filter main test ran in Vitest watch mode and never exited
   (killed ~40 min later) — no wall-clock cost (backgrounded) but an occupied slot and a
   misleading "still running" signal; CI=1 was the known fix, applied everywhere after.
4. Node ABI mismatch (default Node 26 vs native modules built for Node 22) cost each
   fresh Codex dispatch a false-fail + re-run of the DB tests until it re-derived the
   PATH=/opt/homebrew/opt/node@22/bin recipe from AGENTS.md.

Blocker inventory: 0 AskUserQuestion gates, 0 rate-limit hits, 0 red gates; all
waits were background-dispatch waits. The single change that removes the biggest
avoidable stall: preflight-verify the instruction files for every role the run's
zone will dispatch (see proposals) — it converts the wasted reviewer dispatch and its
retry latency into a Step 0 one-liner.

What we asked for

Reliable slash-command initial prompt delivery for RunPane creates: per agent × shape
routing, earned verifiedSubmitted, evidence-gated duplicate-free retry, structured
submission_unverified blocker (item #358, AC1–AC7).

Outcome vs intended

On-target — no outcome gap known at wrap-up. All ACs carry quoted automated evidence;
the outcome half of this postmortem is deferred until the human's PR review.

Why the gap happened

N/A — operational-only postmortem.

What to change so it doesn't recur

1. claude/skills/codex/SKILL.md (orchestra) — path-resolution fallback. In
   "Path resolution", after "Confirm both files exist before dispatching", add:
   "When the repo-local .claude/agents/<role>.md is absent, fall back to the
   canonical ~/.claude/agents/<role>.md and note the sync gap in the wrap-up —
   never dispatch a role whose instructions resolve nowhere." (This run burned a
   dispatch exactly here.)
2. claude/skills/do/SKILL.md (orchestra) — preflight the full role roster. In
   Step 0 preflight, add: "Resolve the instruction + format file for every sub-agent
   role this run's zone will dispatch (plan-reviewer, implementer, verifiers,
   code-reviewer) and confirm each exists — a role file discovered missing at dispatch
   time burns the dispatch."
3. claude/skills/do/SKILL.md (orchestra) — baseline tests in CI mode. In Step 0's
   environment-readiness paragraph, add: "Any baseline or gate test run uses the
   repo's non-interactive invocation (CI=1 / vitest run / equivalent) — watch-mode
   scripts never exit and poison background-task signals."
4. references/zones.md (orchestra) — escalator addition. Add to the escalator
   list: "construction of shell command lines from user- or agent-supplied text"
   forces zone 1 minimum. This run's zone-2 cap of 1 post-PR pass would have shipped a
   command-injection bypass; only a discretionary in-run escalation bought the passes
   that caught and fixed it. Also sync the repo: add code-reviewer.md (and
   frontend-verifier.md, discussant.md) to the agent set synced into dcouple/Pane.

Dial record & right-sizing

(Full block in wrapup.md; key figures)

zone: 2 (escalated in-run to 1)
lanes: single-codex
passes: {plan: 1/1, post_pr: 3/3}
findings: {plan: {pass1: {codex: 3}}, post_pr: {pass1: {codex: 3}, later: {codex: 0 new}}}
verifiers: {frontend: skipped, qa_pass: trimmed}
qa_findings: 0
wall_clock: 1:52
pr_size: {files_changed: 13, additions: 1062, deletions: 88}
tokens: {codex: 1068365, overseer: 438500, claude_subagents: 0, total: 1506865}
spend_ratio: 1310.3

Judgment: underdone at the captured zone, right-sized after escalation. Every
review pass paid: plan pass caught 3 real MF pre-implement; post-PR pass 1 caught a
security bug plus two duplicate/loss mechanisms; passes 2–3 (scoped, ~50k tokens each)
each converted a "claimed fixed" into a sharper persisting finding before confirming.
The dial that mattered: the item's zone: 2 — the injection-adjacent surface
(prompt text → shell command line) warranted zone 1 at capture (proposal 4).

Acceptance

Still awaiting review (operations-only postmortem; PR labeled
awaiting-human-review).

System changes

Proposals 1–4 above — recorded, not applied; verdicts pending the human.
Comment URLs: filled after publishing (see below).