fix(tui): guarantee job/wake completion reports after review

Adversarial-panel findings: clean job exits must keep the alert-tier
completion note (the wake card depends on odek >= v1.40 and
wake_on_complete, so it may never fire), and a bg_wake during a busy
operator turn must note the pending wake because openWakeTurn opens
nothing then. Reworded stray subagent_log comment, updated
docs/INTEGRATIONS.md and AGENTS.md to the new contract.

Author: jkyberneees

.gitignore

@@ -13,3 +13,4 @@
 
 .plans/
 .odek-artifacts/
+.review-tui/

AGENTS.md

@@ -287,7 +287,8 @@ modifier routes to the composer), and `Alt+A`/`Alt+D`/`Alt+T`
   and diffs status transitions into transient notes. odek ≥ v1.40 also
   pushes `bg_job` frames on start/exit — `handleEvent` routes them through
   `kickJobsFetch()` for an immediate snapshot, watcher tick as fallback;
-  `bg_wake` frames become transient notes. Generation counters
+  `bg_wake` frames arm the wake marker only (an alert-tier note appears
+  just when a busy turn blocks the wake card). Generation counters
   (`jobsSeq`/`jobsWatchSeq`) drop stale ticks — keep both chains
   generation-guarded when touching the cadence. The same push-beats-poll
   pattern drives the other tabs: `subagent_state` and `memory_event` frames

docs/INTEGRATIONS.md

@@ -77,4 +77,4 @@ These workflows have no server endpoint; bodek cannot offer them:
 | `cancelled` | ← | — | clean cancel close-out |
 | `approval_request` / `approval_ack` | ← | — | approval queue |
 | `clarify_request` / `clarify_ack` / `clarify_expired` | ← | `clarify_response` | principal-channel question card |
-| `skill_event` / `memory_event` / `agent_signal` | ← | — | transient notes (+ suggestion card; `agent_signal:context_trimmed` / `trim` / `tool_running` stay silent) |
+| `skill_event` / `memory_event` / `agent_signal` | ← | — | silent (drawer tabs own the state); only the skill suggestion card renders |

internal/tui/events.go

@@ -496,8 +496,9 @@ func (m *Model) handleEvent(ev client.Event) (tea.Model, tea.Cmd) {
 		}
 		line += eventTail(ev)
 		// Nest the log under the in-flight sub-agent step when there is
-		// one; a stray (resumed turn, idle, unwrapped) belongs to the
-		// agents tab — not the strip.
+		// one; strays (resumed turn, idle, unwrapped) are dropped — the
+		// agents tab builds from card telemetry and state frames, not
+		// stray log lines.
 		if i := m.cur(); i >= 0 && m.attachSubLog(i, line) {
 			break
 		}
@@ -538,8 +539,14 @@ func (m *Model) handleEvent(ev client.Event) (tea.Model, tea.Cmd) {
 		// the stamped session frame that follows opens the card. The
 		// flag also arms the lazy marker (ensureWireTurn) so the wake keeps
 		// its identity even when the stamped frame is missed. No strip
-		// note: the wake card itself is the operator-visible signal.
+		// note only when the wake card cannot open (an operator turn is
+		// streaming — openWakeTurn opens nothing then, and the completion
+		// must still be reported). While idle, the card itself is the
+		// signal.
 		m.wakeArmed = true
+		if m.busy {
+			m.addNote("background job finished · agent will wake after this turn")
+		}
 
 	case "bg_job":
 		// Push notification of a job start/exit (≥ v1.40): refresh the

internal/tui/jobs_notify_test.go

@@ -34,35 +34,41 @@ func seedRunning(t *testing.T) *Model {
 	return m
 }
 
-// TestJobExitAlertTier pins J1: a FAILED terminal transition posts an
-// alert-tier note (dwell in (noticeTTL, alertTTL]); a clean exit 0 is
-// owned by the wake card and jobs tab and stays out of the strip.
+// TestJobExitAlertTier pins J1: every terminal transition — clean or
+// failed — posts an alert-tier completion note (dwell in (noticeTTL,
+// alertTTL]); the wake card is a bonus, not a guaranteed report.
 func TestJobExitAlertTier(t *testing.T) {
-	m := seedRunning(t)
-	m.applyJobs([]client.Job{exitedJob("exited", 0)}, nil)
-	if note, _ := lastNoteMatching(m, "bg_0000abcd"); note != "" {
-		t.Fatalf("clean exit must not post a note: %q", note)
-	}
-	m = seedRunning(t)
-	m.applyJobs([]client.Job{exitedJob("failed", 1)}, nil)
-
-	note, exp := lastNoteMatching(m, "bg_0000abcd")
-	if note == "" {
-		t.Fatal("failed exit transition posted no note")
-	}
-	if dwell := time.Until(exp); dwell <= noticeTTL || dwell > alertTTL {
-		t.Errorf("exit note dwell = %v, want alert tier (%v, %v]", dwell, noticeTTL, alertTTL)
+	for _, tc := range []struct {
+		name   string
+		status string
+		code   int
+	}{
+		{"clean exit", "exited", 0},
+		{"failed exit", "failed", 1},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			m := seedRunning(t)
+			m.applyJobs([]client.Job{exitedJob(tc.status, tc.code)}, nil)
+
+			note, exp := lastNoteMatching(m, "bg_0000abcd")
+			if note == "" {
+				t.Fatal("exit transition posted no note")
+			}
+			if dwell := time.Until(exp); dwell <= noticeTTL || dwell > alertTTL {
+				t.Errorf("exit note dwell = %v, want alert tier (%v, %v]", dwell, noticeTTL, alertTTL)
+			}
+		})
 	}
 }
 
 // TestJobExitNoteNamesCommand pins the command context: the exit note
 // carries the sanitized command head so the operator knows WHICH job.
 func TestJobExitNoteNamesCommand(t *testing.T) {
 	m := seedRunning(t)
-	m.applyJobs([]client.Job{exitedJob("failed", 2)}, nil)
+	m.applyJobs([]client.Job{exitedJob("exited", 0)}, nil)
 
 	note, _ := lastNoteMatching(m, "bg_0000abcd")
-	for _, want := range []string{"gh pr checks 63 --watch", "failed 2", "1m44s"} {
+	for _, want := range []string{"gh pr checks 63 --watch", "exited 0", "1m44s"} {
 		if !strings.Contains(note, want) {
 			t.Errorf("exit note missing %q: %q", want, note)
 		}

internal/tui/jobs_tab.go

@@ -114,11 +114,12 @@ func (m *Model) resetJobsState() {
 	m.jobsPrev = nil
 }
 
-// applyJobs stores a snapshot; watcher diffs become alert-tier notes — a
-// finished job is actionable, not housekeeping — and terminal transitions
-// fire the attention layer (bell / OSC 9). The first successful snapshot
-// baselines silently — jobs that predate the attach belong to the tab, not
-// the transcript. Returns the attention cmd (nil without a transition).
+// applyJobs stores a snapshot; terminal watcher diffs become alert-tier
+// notes — a finished job is a completion report the operator opted into,
+// not housekeeping — and fire the attention layer (bell / OSC 9). Job
+// starts stay on the tab. The first successful snapshot baselines
+// silently — jobs that predate the attach belong to the tab, not the
+// transcript. Returns the attention cmd (nil without a transition).
 func (m *Model) applyJobs(jobs []client.Job, err error) tea.Cmd {
 	if err != nil {
 		if errors.Is(err, client.ErrJobsUnavailable) {
@@ -154,13 +155,11 @@ func (m *Model) applyJobs(jobs []client.Job, err error) tea.Cmd {
 				// transcript state — the start is already visible where the
 				// job was launched (bg_start feedback).
 			case old == "running" && j.Status != "running":
-				// Alert tier + attention — but only when it demands a look:
-				// a clean exit (code 0) is reported by the wake card and
-				// the jobs tab; a failure (or an unreported code, which we
-				// cannot call clean) must survive a glance-away.
-				if j.ExitCode != nil && *j.ExitCode == 0 {
-					break
-				}
+				// Alert tier + attention: a finished job must survive a
+				// glance-away, and the operator opted into knowing. This is
+				// the guaranteed completion report — the wake card is a
+				// bonus that depends on odek ≥ v1.40 and wake_on_complete,
+				// so it may never fire; this note must.
 				m.addNote(jobExitNote(j))
 				attn = m.attentionCmd(m.attentionFor(jobAttentionKind(j)))
 			}

internal/tui/notice_quiet_test.go

@@ -35,17 +35,23 @@ func TestEngineChatterNeverSurfaces(t *testing.T) {
 	}
 }
 
-// TestBgWakeStillArmsIdentity pins that suppression is render-only: the
-// wake marker must still arm so the unprompted turn keeps its identity
-// even though no note announces it.
-func TestBgWakeStillArmsIdentity(t *testing.T) {
+// TestBgWakeIdleSilentBusyNoted: while idle the wake card is the signal
+// (no note); while an operator turn streams the card cannot open, so the
+// completion must be reported as an alert-tier note instead.
+func TestBgWakeIdleSilentBusyNoted(t *testing.T) {
 	m := newTestModel()
 	m.handleEvent(client.Event{Type: "bg_wake"})
 	if !m.wakeArmed {
 		t.Fatal("bg_wake suppression must not lose the wakeArmed identity marker")
 	}
 	if len(m.notices) != 0 {
-		t.Fatalf("bg_wake must not surface a note: %v", m.notices)
+		t.Fatalf("idle bg_wake must not surface a note: %v", m.notices)
+	}
+	m.notices = nil
+	m.busy = true
+	m.handleEvent(client.Event{Type: "bg_wake"})
+	if note, _ := lastNoteMatching(m, "background job finished"); note == "" {
+		t.Fatalf("bg_wake during a busy turn must report the completion: %v", m.notices)
 	}
 }
 
@@ -60,15 +66,16 @@ func TestJobStartDiffSilenced(t *testing.T) {
 	}
 }
 
-// TestJobCleanExitSilenced: a clean (exit 0) terminal transition is
-// reported by the wake card / tab; the strip stays out of it.
-func TestJobCleanExitSilenced(t *testing.T) {
+// TestJobCleanExitStillReports: clean exits keep the alert-tier
+// completion note — the wake card depends on odek ≥ v1.40 and
+// wake_on_complete, so this note is the guaranteed report.
+func TestJobCleanExitStillReports(t *testing.T) {
 	m := newTestModel()
 	m.applyJobs([]client.Job{{ID: "j1", Status: "running", Command: "make test"}}, nil)
 	zero := 0
 	m.applyJobs([]client.Job{{ID: "j1", Status: "exited", Command: "make test", ExitCode: &zero}}, nil)
-	if len(m.notices) != 0 {
-		t.Fatalf("clean job exit must not reach the strip: %v", m.notices)
+	if note, _ := lastNoteMatching(m, "j1"); note == "" {
+		t.Fatalf("clean job exit must still be reported: %v", m.notices)
 	}
 }
 

internal/tui/wake_turn_test.go

@@ -108,11 +108,11 @@ func TestWakeTurnLifecycleRendersMarker(t *testing.T) {
 
 // The bg_wake frame is the operator's context for the unprompted activity:
 // surface it as a transient note.
-// TestBgWakeFrameNotifies: the bg_wake frame no longer posts a strip note
-// (the wake card itself is the operator-visible signal) but must still
-// arm the wake identity so the unprompted turn is never mistaken for an
-// operator exchange.
-func TestBgWakeFrameNotifies(t *testing.T) {
+// TestBgWakeFrameArmsMarkerSilently: the bg_wake frame no longer posts a
+// strip note while idle (the wake card is the operator-visible signal)
+// but must still arm the wake identity so the unprompted turn is never
+// mistaken for an operator exchange.
+func TestBgWakeFrameArmsMarkerSilently(t *testing.T) {
 	m := newTestModel()
 	m.handleEvent(client.Event{Type: "bg_wake", SessionID: "s1"})
 	if !m.wakeArmed {