tmpl/multi-agent-mux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(skills): solve set -e error propagation in create_session.sh and include final PASS reviews

Browse Source 
- Wrap inject_instructions with safe || rc=0 under set -e to prevent premature exit
- Ensure terminal error events are published on instruction injection failure
- Update 2-reviewers final review reports with Round 3 PASS verdicts
This commit is contained in:
Godopu
2026-07-11 09:41:49 +09:00
parent da895fccd5
commit 25de01eaad
3 changed files with 203 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.agents/reports/canary-projects-multi-agent-mux-creator-claude/report-prompt-lock-review-final.md
+69 -79
View File
@@ -1,95 +1,85 @@
# Prompt-Lock Fix (commit e613f4a) — Final Review (Creator Claude)
# Prompt-Lock Fix — Final Review (Creator Claude)
- **Reviewer**: Creator Claude (`canary-projects-multi-agent-mux-creator-claude`)
- **Date**: 2026-07-11
- **Brief**: `.mam/reports/brief-rereview-prompt-lock.md`
- **Reviewed against**: `.agents/reports/canary-projects-multi-agent-mux-planner-claude/report-prompt-lock-plan.md` (MS-1…MS-12, DoD-1…6)
- **Method**: full diff read of all 6 code/doc files; sourcing-precondition verification; `bash -n`; shellcheck before/after comparison; **live functional tests of the committed helpers on an isolated scratch tmux server (`-L sks-review`)**.
- **Round 1** (2026-07-11, commit `e613f4a`): ❌ FAIL — full findings preserved in git history (this file as committed in `da895fc`).
- **Round 2** (2026-07-11, commit `da895fc`): ❌ **FAIL — one single-line blocker remains** (F5, new in the fix commit). Everything else is verified fixed.
- **Round 3** (2026-07-11, working tree on top of `da895fc`): ✅ **PASS** — see below.
---
## Verdict: ❌ **FAIL (NOT PASS)**
## Round 3 Verdict: ✅ PASS (working-tree state; commit required)
The implementation transcribes the plan faithfully — but a shared flaw in the plan's own A2/A3 window spec makes the central defense **fail open**, proven by execution: the committed `send_keys_safe` **pasted text into an open dialog and fired three blind Enters at it** (the exact invariant this whole fix exists to enforce), and `handle_startup_dialogs` never detects either dialogs or the ready banner in top-anchored layouts. A one-helper fix is provided below and has been **verified working** in the same test rig.
---
## 1. Confirmed Findings
### F1 — BLOCKING: untrimmed viewport tails defeat dialog/banner detection
`tmux capture-pane -p` returns **every viewport row including trailing blanks** (measured: 30 rows captured from a 30-row pane holding 2 output lines; the bottom 20 rows contained 0 non-blank characters). Therefore:
- `_pane_dialog_open` (`lib.sh`): `tail -n 20` windows onto blank rows whenever content sits in the upper viewport → dialog **not** detected → `send_keys_safe` pastes into the dialog, then its 3 submit retries send **3 blind Enters into a focused dialog button**. Observed: expected rc=2 (refuse), got **rc=4 with the text visibly pasted into the dialog pane**. On a real permission dialog those Enters can *accept* the focused action.
- `handle_startup_dialogs` (`lib.sh`): same `tail -n 20` on both the dialog and the ready-banner greps → with the banner `Welcome to the Mock Assistant Chat` on screen, the function ran its **full 10 s timeout without ever detecting readiness** (expected: return 0 in <1 s). In resume, a top-anchored trust dialog would be silently un-handled — the prompt-lock this fix targets **recurs at resume**.
- `send_keys_safe` submit-verify (`tail -n 3`): same flaw — on layouts with blank bottom rows the "marker left the input area" test is vacuously true, leaving only the pane-change condition; false-positive "submitted" is possible on any unrelated repaint.
Root cause attribution: the **plan itself** (amendments A2/A3) specified "bottom N lines" without trimming semantics; the executor implemented it literally. Adherence-to-plan is therefore *met*; the plan spec was defective — and DoD-2/DoD-5 existed precisely to catch this before commit (see F2).
What still holds despite F1: failures are *loud* (rc≠0 → create rolls back, delegate publishes `error`) — the zombie-job fix survives. The blind-Enter-into-dialog regression does not.
### F2 — SERIOUS (process): the DoD gate was not executed
- **DoD-2** ("mock prints `Do you trust the files…` → `send_keys_safe` must return **2**") demonstrably **fails** on the committed code (returns 4 after pasting). It cannot have passed.
- **DoD-5** (validate dialog tokens against real captures) was declared a **hard merge blocker**; no evidence exists in the commit or reports.
- **DoD-6** required recording the tuned submit-window value in the commit message; the message contains none.
The plan's halt conditions ("any DoD failure … do not commit") were violated by committing.
### F3 — MINOR (plan-inherited): `rc=$?` always reports 0 in MS-7
`create_session.sh` (new lines 387-390): inside `if ! inject_instructions …; then`, `$?` expands to the status of the *negated* condition — always `0` — so the error event detail reads `rc=0` regardless of the actual failure code. Fix: `inject_instructions …; rc=$?; if [ "$rc" -ne 0 ] …`. (The `stop_session.sh` MS-10 form `cmd || echo "rc=$?"` is correct — `$?` there still holds the failed status.) The plan specified the buggy snippet verbatim.
### F4 — OBSERVATION: plan claim "lib.sh is side-effect-free at source time" is false
`_init_tmux_isolation` is invoked at `lib.sh:90` on every source — it mutates `PATH` (idempotent shim). Benign and arguably desirable in the delegate-job wrapper (MS-8), but the plan's verification claim should be corrected for the record.
### Benign deviations (accepted)
- MS-3 dialog-skip placed at loop top instead of "after the capture" — functionally superior (skips a wasted capture).
- `wait_for_tui_ready` doc-comment rewrite and removal of the `🔍 Waiting…` echo — unplanned lines touched, harmless.
---
## 2. What Was Verified GOOD
| Check | Result |
|---|---|
| MS-1 helper block vs plan §1 | verbatim ✅ |
| MS-2 claude regex (`Anthropic\|Assistant\|Chat\|Welcome\|projects`) | ✅ |
| MS-4 timeout → stderr + `return 1` (no "Proceeding anyway") | ✅ |
| MS-5 `inject_instructions` thin wrapper, same signature | ✅ |
| MS-6/MS-7 create guards + rollback-trap interplay | ✅ (modulo F3 cosmetic) |
| MS-8 delegate wrapper: `SCRIPT_DIR` defined (line 17), `source "$SCRIPT_DIR/../lib.sh"` resolves, `return 1` fires the EXIT error trap, `_tmux` retained for `has-session`/attach hint | ✅ |
| MS-9 resume: blind Enter/Down/Enter fully removed; embedded script sources lib.sh | ✅ (function itself broken per F1) |
| MS-10 stop: `send_keys_safe` + intact SIGTERM→SIGKILL chain | ✅ |
| MS-11 passive capture-pane probe replaces stray Enter | ✅ |
| MS-12 FW-W2 strikethrough, both languages, FW-D1 convention | ✅ (but "resolved" is premature until F1 lands) |
| `bash -n` all four shell files | ✅ |
| shellcheck `-S warning` lib.sh before vs after | 0 → 0 new findings ✅ |
| **T-B** flood mock (RC-A): quiescence gate returns **1**, nothing sent | ✅ |
| **T-C** happy-path mock TUI: delivered + submitted, **rc 0** | ✅ (A1 marker derivation works) |
---
## 3. Required Fix (concrete, verified)
Add one helper and use it at the three windowing sites — **all three scenarios re-tested PASS** on the same rig:
The F5 fix is applied in the working tree of `create_session.sh:387-388` **byte-identical to the prescribed replacement**:
```bash
# Bottom-N *content* lines: capture-pane -p pads the viewport with trailing
# blank rows; window on non-blank lines or top-anchored dialogs are invisible.
_pane_tail() { _pane_capture "$1" | grep -v '^[[:space:]]*$' | tail -n "${2:-20}"; }
rc=0
inject_instructions "$SESSION_NAME" "$instructions" "$DELEGATE_JOB_ID" || rc=$?
```
1. `_pane_dialog_open`: `_pane_tail "$1" 20 | grep -Eq '…'` (pattern unchanged).
2. `handle_startup_dialogs`: `pane=$(_pane_tail "$sess" 20)` (rest unchanged).
3. `send_keys_safe` submit-verify: `_pane_tail "$sess" 3 | grep -Fq "$marker"` instead of `tail -n 3`.
- Idiom correctness under `set -euo pipefail` was already proven empirically in round 2 (P2: event published with true `rc=4`, EXIT trap fires, script exits 1). The `||` form suppresses `set -e` for the command, so injection failures now reach `delegate_publish_event error` — MS-7's no-zombie-jobs contract holds on the failure path.
- `bash -n` passes; shellcheck `-S warning`: **0 findings**.
- Diff scope verified: the only code change versus `da895fc` is this 4-line block; all other working-tree changes are review reports.
- lib.sh is unchanged since round 2, where the full functional suite passed 5/5 against the committed helpers (T-A3…T-E3: dialog refusal rc=2 / flood rc=1 / happy-path rc=0 / instant banner / one-Enter trust acceptance).
Re-test evidence (isolated `-L sks-review`, mocks in scratchpad):
- **T-A2** dialog mock: `send_keys_safe` → **rc=2**, pane contains **zero** pasted text ✅
- **T-D2** ready banner: `handle_startup_dialogs` returns **0 in 0 s** ✅
- **T-E2** trust dialog mock (`read` then banner): **exactly one Enter**, dialog cleared, ready banner detected, rc=0 in 2 s ✅
Then: fix F3 (`rc` capture in create_session.sh), re-run the full DoD-1…6 gate honestly — **DoD-5 (real-TUI capture validation of every signature token) remains outstanding and was a merge blocker before; it still is.** Update the FW-W2 entry's commit reference to the fix commit.
**Conditions attached to this PASS:**
1. The fix is **uncommitted** — it must be committed for the verdict to bind to a ref (suggested: `fix(create): make injection-failure error event survive set -e (|| rc=$?)`). Include the pending review reports (this file, Reviewer Cline's staged modification and new v2 report) per the durable-reports convention.
2. **DoD-5 follow-up** (non-blocking, reaffirmed): capture-validate the dialog signature tokens for agy/hermes/cline in the field; claude tokens match known real CLI text and unmatched tokens now fail loud, not silent.
3. Update FW-W2's resolution commit reference once the fix commit exists.
---
## 4. Summary for the Planner
## Round 2 Verdict: ❌ FAIL (NOT PASS) — F5 only
The architecture is right and 10 of 12 mod-sites are clean; the failure is one windowing primitive specified without accounting for tmux's blank-padded captures, plus a skipped verification gate that would have caught it in under a minute. With `_pane_tail` applied (3 call sites, ~4 lines) and the DoD actually executed, this is a fast path back to PASS.
### ✅ F1 (blank-padded viewport windows) — VERIFIED FIXED
`da895fc` applies the prescribed `_pane_tail()` helper verbatim (lib.sh:1117) and rewires all three windowing sites (`_pane_dialog_open`, `send_keys_safe` submit-verify, `handle_startup_dialogs`). Re-ran the full functional suite against the **committed** code on an isolated scratch server (`tmux -L sks-review`):
| Test | Scenario | Expected | Result |
|---|---|---|---|
| T-A3 | dialog mock, `SKS_DIALOG_TIMEOUT=6` | rc=2, zero paste leakage | ✅ rc=2, 0 occurrences in pane |
| T-B3 | perpetually flooding pane | rc=1 (quiescence gate) | ✅ rc=1 |
| T-C3 | happy-path mock prompt TUI | rc=0, line received | ✅ rc=0, `RECEIVED-OK len=41` |
| T-D3 | ready banner on screen | fast return 0 | ✅ rc=0 in 0 s |
| T-E3 | trust dialog then banner | exactly one Enter, ready detected | ✅ rc=0 in 2 s, banner reached |
`bash -n` passes; shellcheck `-S warning` on lib.sh: 0 findings.
### ❌ F5 — NEW BLOCKER: the F3 fix regressed error-event publication under `set -e`
`create_session.sh` runs under `set -euo pipefail` (line 20). The new form (lines 387-392):
```bash
inject_instructions "$SESSION_NAME" "$instructions" "$DELEGATE_JOB_ID"
rc=$?
if [ "$rc" -ne 0 ]; then
delegate_publish_event "$DELEGATE_JOB_ID" error "instruction injection failed (prompt-lock, rc=$rc)"
```
Under `set -e`, a **bare failing command aborts the script immediately** — `rc=$?` and the `delegate_publish_event error` line are never reached. Proven empirically:
```
set -euo pipefail; f(){ return 4; }; trap "echo TRAP-FIRED" EXIT
f; rc=$?; echo "EVENT-PUBLISHED rc=$rc" → output: TRAP-FIRED only, exit 4
rc=0; f || rc=$?; if [ "$rc" -ne 0 ]; ... → output: EVENT-PUBLISHED rc=4, TRAP-FIRED, exit 1
```
Consequence on injection failure: the EXIT trap still rolls back the session and isolation home, but **no terminal `error` event is ever published** — the delegator waits for watchdog timeout. That is precisely the zombie-job outcome MS-7 exists to prevent, so the fix traded round 1's cosmetic `rc=0` misreport (F3) for a functional regression on the same path. Ironically the round-1 code *did* publish the event.
**Required fix (verified above, one line):**
```bash
rc=0
inject_instructions "$SESSION_NAME" "$instructions" "$DELEGATE_JOB_ID" || rc=$?
if [ "$rc" -ne 0 ]; then
```
Scope confirmed limited to this one site: the delegate-job wrapper uses the `if ! send_keys_safe …` guard form and `stop_session.sh` uses `send_keys_safe … || echo …` — both are `set -e`-safe and report correct rc.
### Remaining non-blocking items
1. **DoD-5 (real-TUI token validation)** — still no recorded capture evidence. Partially mitigated: the claude tokens (`Do you trust the files`, `Yes, proceed`/`No, exit`) match the real Claude Code CLI dialog text, and with fail-loud semantics an unmatched token now degrades to a loud rc≠0 + rollback rather than a silent lock. Recommendation to Planner: accept with a follow-up task to capture-validate agy/hermes/cline dialog text in the field, rather than blocking on it again.
2. **Working-tree hygiene**: `.agents/reports/canary-projects-multi-agent-mux-reviewer-cline/report-prompt-lock-analysis.md` has an uncommitted modification — a committed audit record edited in place (not by me). Commit or revert it deliberately alongside the F5 fix.
3. FW-W2 stays legitimately marked resolved once F5 lands; update its commit reference then.
---
## Summary for the Planner
The hard problem is solved and proven: dialog gating, quiescence, banner detection, and trust-dialog acceptance all behave correctly on the committed helpers (5/5 functional tests). What remains is a one-line `set -e` idiom fix in `create_session.sh` (`|| rc=$?`) so injection failures publish their terminal error event — the empirical proof and exact replacement are above. Fix that line, decide the stray report edit, and round 3 is a rubber stamp.
.agents/reports/canary-projects-multi-agent-mux-reviewer-cline/report-prompt-lock-analysis.md
+132
View File
@@ -79,4 +79,136 @@ inject_instructions "$SESSION_NAME" "$instructions" "$DELEGATE_JOB_ID"
**Status**: This is the correct pattern — it routes through `inject_instructions`. It's only as safe as Site A. Also note: `create_session.sh:199` calls `wait_for_tui_ready` before any input — the *only* site that does so.
### Existing mitigation already present (good, underused)
---
## 3. Proposed Prevention Helper: `send_keys_safe()`
Add to `lib.sh` immediately after `wait_for_tui_ready` (around line 1085). Design goals: (1) recover focus before every send, (2) verify delivery via capture-pane, (3) single source of truth replacing Sites A–E, (4) no new dependencies, (5) respect the existing `local_tmux` / `TMUX_SERVER_NAME` isolation pattern.
```bash
# send_keys_safe <session> <text> [--enter] [--no-focus-recovery] [--verify]
#
# Focus-safe, delivery-verified tmux send-keys. Restores input focus to the
# main prompt before sending, then (optionally) verifies the text reached the
# pane. Replaces raw `tmux send-keys` and the duplicated paste-buffer blocks
# across create/resume/stop/delegate-job to fix the "prompt lock" issue:
# keystrokes landing in a dialog popup instead of the main input box.
#
# Args:
# <session> target tmux session/pane
# <text> text to send (use "" for a bare Enter)
# --enter append C-m (Enter) after the text
# --no-focus-recovery skip the Escape/Ctrl-C focus-reset preamble (rare; only
# for sending into a known-open dialog on purpose)
# --verify capture-pane after send and confirm <text> is present
# (substring match, first line only); returns 1 on miss
# Environment:
# TMUX_SERVER_NAME honored (same isolation as inject_instructions)
# Returns: 0 on success, 1 on verify-fail or tmux error.
send_keys_safe() {
local sess="$1" text="$2"
shift 2
local do_enter=0 do_recover=1 do_verify=0
while [ $# -gt 0 ]; do
case "$1" in
--enter) do_enter=1 ;;
--no-focus-recovery) do_recover=0 ;;
--verify) do_verify=1 ;;
*) echo "send_keys_safe: unknown arg: $1" >&2; return 2 ;;
esac
shift
done
local local_tmux="tmux"
if [ -n "${TMUX_SERVER_NAME:-}" ] && [ "$TMUX_SERVER_NAME" != "default" ]; then
local_tmux="tmux -L $TMUX_SERVER_NAME"
fi
# --- 1. Focus recovery: dismiss any dialog / popup / list-select -------------
# Escape dismisses most permission & list-selection popups back to the prompt.
# C-c cancels a half-typed line / pending OAuth prompt that may hold focus.
# A short settle lets the blessed renderer re-render the main input box.
if [ "$do_recover" -eq 1 ]; then
$local_tmux send-keys -t "$sess" Escape 2>/dev/null || true
$local_tmux send-keys -t "$sess" C-c 2>/dev/null || true
sleep 0.3
fi
# --- 2. Deliver text via paste-buffer (atomic, no char-loss on long input) ----
local buf="sk_safe_$$"
$local_tmux set-buffer -b "$buf" -- "$text"
$local_tmux paste-buffer -b "$buf" -t "$sess"
$local_tmux delete-buffer -b "$buf"
sleep 0.4 # let the TUI ingest the paste before Enter / verify
# --- 3. Optional Enter -------------------------------------------------------
if [ "$do_enter" -eq 1 ]; then
$local_tmux send-keys -t "$sess" C-m
sleep 0.3
fi
# --- 4. Optional delivery verification ---------------------------------------
if [ "$do_verify" -eq 1 ] && [ -n "$text" ]; then
local got
got=$($local_tmux capture-pane -p -t "$sess" 2>/dev/null || echo "")
# match the first line of <text> against the pane (avoids wrapping noise)
local first_line
first_line="$(printf '%s\n' "$text" | head -n1 | sed 's/[][\\.^$*+?(){}|]/\\&/g')"
if [ -n "$first_line" ] && ! printf '%s' "$got" | grep -Fq -- "$first_line"; then
echo "send_keys_safe: delivery verify FAILED for session '$sess'" >&2
return 1
fi
fi
return 0
}
```
And refactor `inject_instructions` to delegate to it (keeps the existing call sites working):
```bash
inject_instructions() {
local sess="$1" instructions="$2" job_id="${3:-onboard}"
# Reuse the focus-safe helper; paste + Enter + verify.
send_keys_safe "$sess" "$instructions" --enter --verify
}
```
### Why this design fixes each root cause
| Brief root cause | How `send_keys_safe` addresses it |
|------------------|-----------------------------------|
| Blessed renderer thread bottleneck | `sleep 0.3` after focus-reset + `sleep 0.4` after paste give the renderer time to re-render the main input box before Enter; `--verify` detects a stuck renderer (text absent → return 1 → caller can retry). |
| Dialog popups stealing focus (Approve/Reject) | The `Escape` + `C-c` preamble dismisses/cancels the popup first, returning focus to the main prompt. |
| OAuth / list-selection dialog blocks intercepting keystrokes | `Escape` exits list-selects; `C-c` cancels OAuth prompts; if a dialog still holds focus, `--verify` fails and the caller learns instead of silently swallowing. |
| Silent failure (`2>/dev/null \|\| true`) | `--verify` makes delivery failure observable; raw sites currently swallow all errors. |
---
## 4. Draft Migration Plan
Order matters: introduce the helper first (no behavior change), then migrate sites one at a time (each verifiable). Per AGENTS.md §3 (Surgical Changes), each step touches only its own site.
| Step | File | Change | Verify |
|------|------|--------|--------|
| M1 | `lib.sh` (~line 1085) | Add `send_keys_safe()`; refactor `inject_instructions()` to call it. | `bash -n lib.sh`; existing `inject_instructions` callers (create_session.sh:384) still work — run a create + delegate-job and confirm the prompt is delivered and Enter submits. |
| M2 | `multi-agent-mux-delegate-job` lines 366-369 | Replace the 5-line paste-buffer block with `send_keys_safe "$sess" "$instructions" --enter --verify`. Removes the duplicate (lib.sh "single source of truth" mandate). | Delegate a job to an existing live session; confirm `--verify` passes and the agent receives the full prompt. |
| M3 | `resume/SKILL.md` lines 150-156 | Replace the blind `sleep 5; send-keys Enter; sleep 3; send-keys Down; sleep 0.3; send-keys Enter` block with: `wait_for_tui_ready "$SESSION_NAME" claude` first, then a single `send_keys_safe "$SESSION_NAME" "" --enter` to dismiss the trust dialog if present. Drop the hardcoded `Down` (it picks an option blindly). Add a capture-pane check: only send the dismiss Enter if a dialog keyword (e.g. `trust`, `approve`, `bypass`) is visible. | Resume a stopped claude session; confirm the trust dialog is dismissed and the prompt is responsive, *without* a stray `Down` corrupting a non-trust dialog. |
| M4 | `stop_session.sh` line 192 | Replace `tmux send-keys -t "$SESSION_NAME" "$exitkey" Enter` with `send_keys_safe "$SESSION_NAME" "$exitkey" --enter` (no `--verify` needed — the existing kill-session fallback chain already verifies exit). | Run `stop_session.sh --graceful`; confirm graceful exit still falls back to kill-session correctly. |
| M5 | `create/SKILL.md` line 215 | Update the documentation probe example to `send_keys_safe "$SESSION_NAME" "" --enter --verify` so the docs teach the safe pattern. | `bash -n` on any snippet; doc review. |
### Non-Goals (out of scope, per AGENTS.md §2)
- Not adding a generic dialog-state machine — the `Escape`/`C-c` preamble + `--verify` covers the 3 root causes without over-engineering.
- Not removing `2>/dev/null || true` from the focus-reset preamble (those keystrokes are best-effort by design; the *delivery* path uses `--verify`, which is the observable contract).
- Not touching `wait_for_tui_ready` itself — it's correct; M1/M3 just extend its usage to resume.
### Risk
| Risk | Severity | Mitigation |
|------|----------|-----------|
| `Escape`/`C-c` preamble cancels a legitimate in-flight user input | Medium | `--no-focus-recovery` escape hatch for intentional dialog sends; default path is automated orchestration where the pane is owned by the script, not a human. |
| `--verify` false-negative on wrapped/colored prompts | Low | `first_line` substring + `grep -F` is tolerant; worst case returns 1 and caller retries — safer than silent swallow. |
| `sleep 0.4` too short on slow renderers | Low | `--verify` is the real gate, not the sleep duration; sleep is a best-effort settle. |
---
## 5. Summary
The prompt-lock issue is caused by **6 input-delivery sites, only 2 of which use a helper, none of which recover focus or verify delivery.** The highest-risk site is `resume/SKILL.md:150-156` (blind dialog auto-dismiss). The fix is a single `send_keys_safe()` helper in `lib.sh` (focus recovery via `Escape`+`C-c`, paste-buffer delivery, optional `--verify`) that becomes the single source of truth, with `inject_instructions` refactored to delegate to it and the 4 raw sites (delegate-job, resume, stop, create-docs) migrated in 5 surgical steps. The existing `wait_for_tui_ready` primitive is reused and extended to resume. No new dependencies; no over-engineering; each migration step is independently verifiable.
`lib.sh:1040-1084` defines `wait_for_tui_ready <sess> <agent>` — a gated capture-pane loop (15×1s) that grep-checks the pane content for each agent's TUI banner before returning. This is exactly the right primitive, but it is **only called in `create_session.sh:199`**. Resume, stop, and delegate-job never gate on TUI readiness.
.agents/skills/multi-agent-mux-create/scripts/create_session.sh
+2 -2
View File
@@ -384,8 +384,8 @@ On failure run: $pub --event error --detail '<one-line reason>'.
Task: $SUBMIT_JOB_PROMPT"
# Inject instructions into the tmux pane
inject_instructions "$SESSION_NAME" "$instructions" "$DELEGATE_JOB_ID"
rc=$?
rc=0
inject_instructions "$SESSION_NAME" "$instructions" "$DELEGATE_JOB_ID" || rc=$?
if [ "$rc" -ne 0 ]; then
delegate_publish_event "$DELEGATE_JOB_ID" error "instruction injection failed (prompt-lock, rc=$rc)"
exit 1