diff --git a/backend/internal/adapters/agent/activitydispatch/dispatch.go b/backend/internal/adapters/agent/activitydispatch/dispatch.go
index 812e15e2..8464f941 100644
--- a/backend/internal/adapters/agent/activitydispatch/dispatch.go
+++ b/backend/internal/adapters/agent/activitydispatch/dispatch.go
@@ -61,7 +61,7 @@ func Derive(agent, event string, payload []byte) (domain.ActivityState, bool) {
 // SupportsHarness reports whether a harness has an activity pipeline at all:
 // a registered deriver here means its adapter installs `ao hooks <harness>`
 // callbacks that can reach the daemon. Status derivation uses this to decide
-// whether prolonged silence is suspicious (no_signal) or simply all a hook-less
+// whether prolonged silence is suspicious (a broken-pipeline stall) or simply all a hook-less
 // harness can ever report (idle). Harness names and `ao hooks` agent tokens are
 // the same strings by convention.
 func SupportsHarness(h domain.AgentHarness) bool {
diff --git a/backend/internal/daemon/lifecycle_wiring.go b/backend/internal/daemon/lifecycle_wiring.go
index 5d79ec31..f55d0288 100644
--- a/backend/internal/daemon/lifecycle_wiring.go
+++ b/backend/internal/daemon/lifecycle_wiring.go
@@ -107,8 +107,8 @@ func startSession(cfg config.Config, runtime *zellij.Runtime, store *sqlite.Stor
 		PRClaimer: store,
 		SCM:       scmProvider,
 		Telemetry: telemetry,
-		// no_signal only makes sense for harnesses whose adapters install
-		// activity hooks; the deriver registry is the source of truth for that.
+		// The broken-pipeline stall only makes sense for harnesses whose adapters
+		// install activity hooks; the deriver registry is the source of truth.
 		SignalCapable: activitydispatch.SupportsHarness,
 	})
 	// Triggering a review spawns a reviewer over the worker's worktree, resolved
diff --git a/backend/internal/domain/session.go b/backend/internal/domain/session.go
index 6cc639e5..6ea1a0ef 100644
--- a/backend/internal/domain/session.go
+++ b/backend/internal/domain/session.go
@@ -46,7 +46,7 @@ type SessionRecord struct {
 	// FirstSignalAt is when the FIRST agent hook callback arrived for the
 	// current spawn/restore: raw signal receipt, independent of the derived
 	// activity state. Zero means no hook has ever reported, which deriveStatus
-	// surfaces as StatusNoSignal after a grace period. Internal fact, not part
+	// surfaces as StatusStalled after a boot grace. Internal fact, not part
 	// of the API read model.
 	FirstSignalAt time.Time       `json:"-"`
 	IsTerminated  bool            `json:"isTerminated"`
diff --git a/backend/internal/domain/status.go b/backend/internal/domain/status.go
index 4b6cf254..8afaf399 100644
--- a/backend/internal/domain/status.go
+++ b/backend/internal/domain/status.go
@@ -2,25 +2,26 @@ package domain
 
 // SessionStatus is the single-word DISPLAY status the dashboard renders. It is
 // derived from persisted session facts plus PR facts and is never stored.
+//
+// There are five states, one per distinct move a human makes when scanning a
+// wall of agents: leave it alone, respond, act on a clean PR, get it moving, or
+// nothing. Finer PR detail (CI failing vs changes requested vs approved) lives
+// in the inspector, not in the glanceable status.
 type SessionStatus string
 
 // The display statuses the dashboard renders.
 const (
-	StatusWorking          SessionStatus = "working"
-	StatusPROpen           SessionStatus = "pr_open"
-	StatusDraft            SessionStatus = "draft"
-	StatusCIFailed         SessionStatus = "ci_failed"
-	StatusReviewPending    SessionStatus = "review_pending"
-	StatusChangesRequested SessionStatus = "changes_requested"
-	StatusApproved         SessionStatus = "approved"
-	StatusMergeable        SessionStatus = "mergeable"
-	StatusMerged           SessionStatus = "merged"
-	StatusNeedsInput       SessionStatus = "needs_input"
-	StatusIdle             SessionStatus = "idle"
-	StatusTerminated       SessionStatus = "terminated"
-	// StatusNoSignal marks a live session whose agent has never delivered a
-	// hook callback for the current spawn/restore: AO cannot tell whether the
-	// agent is working or stuck (broken hook pipeline, blocked interactive
-	// prompt). Rendered instead of a confident idle.
-	StatusNoSignal SessionStatus = "no_signal"
+	// StatusWorking — the agent is actively running. Leave it alone.
+	StatusWorking SessionStatus = "working"
+	// StatusNeedsInput — the agent is blocked on you. Respond.
+	StatusNeedsInput SessionStatus = "needs_input"
+	// StatusReady — a clean PR is waiting on you (mergeable, approved, or needs
+	// your review). Merge it / go review it.
+	StatusReady SessionStatus = "ready"
+	// StatusStalled — the agent will not finish on its own (hung, never booted,
+	// or stopped with unfinished work). Get it moving.
+	StatusStalled SessionStatus = "stalled"
+	// StatusIdle — nothing is happening, or the work is finished (also covers
+	// merged and terminated). Nothing to do.
+	StatusIdle SessionStatus = "idle"
 )
diff --git a/backend/internal/httpd/controllers/sessions_test.go b/backend/internal/httpd/controllers/sessions_test.go
index 1b588680..4b0dde33 100644
--- a/backend/internal/httpd/controllers/sessions_test.go
+++ b/backend/internal/httpd/controllers/sessions_test.go
@@ -92,7 +92,7 @@ func (f *fakeSessionService) Restore(_ context.Context, id domain.SessionID) (do
 func (f *fakeSessionService) Kill(_ context.Context, id domain.SessionID) (bool, error) {
 	s := f.sessions[id]
 	s.IsTerminated = true
-	s.Status = domain.StatusTerminated
+	s.Status = domain.StatusIdle
 	f.sessions[id] = s
 	return true, nil
 }
diff --git a/backend/internal/integration/lifecycle_sqlite_test.go b/backend/internal/integration/lifecycle_sqlite_test.go
index 9a0a9960..153e0076 100644
--- a/backend/internal/integration/lifecycle_sqlite_test.go
+++ b/backend/internal/integration/lifecycle_sqlite_test.go
@@ -123,8 +123,8 @@ func TestSpawnPRKillRoundTrip(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if got.Status != domain.StatusCIFailed {
-		t.Fatalf("want ci_failed, got %q", got.Status)
+	if got.Status != domain.StatusStalled {
+		t.Fatalf("want stalled, got %q", got.Status)
 	}
 	freed, err := st.sm.Kill(ctx, sess.ID)
 	if err != nil || !freed {
diff --git a/backend/internal/lifecycle/manager.go b/backend/internal/lifecycle/manager.go
index 6212d8eb..56b7bfe1 100644
--- a/backend/internal/lifecycle/manager.go
+++ b/backend/internal/lifecycle/manager.go
@@ -136,7 +136,7 @@ func (m *Manager) ApplyActivitySignal(ctx context.Context, id domain.SessionID,
 	act := domain.Activity{State: s.State, LastActivityAt: timeOr(s.Timestamp, now)}
 	// A same-state repeat is still a write when it is the FIRST signal for
 	// this spawn: the receipt itself is a durable fact (it clears the
-	// no_signal display status). Hook deliveries are best-effort, so the
+	// never-booted stalled status). Hook deliveries are best-effort, so the
 	// first to ARRIVE may match the seeded state — e.g. a turn's "active"
 	// POST is lost and its Stop hook lands idle on the idle-seeded row.
 	if sameActivity(rec.Activity, act) && !rec.FirstSignalAt.IsZero() {
@@ -243,8 +243,8 @@ func (m *Manager) MarkSpawned(ctx context.Context, id domain.SessionID, metadata
 	rec.IsTerminated = false
 	rec.Activity = domain.Activity{State: domain.ActivityIdle, LastActivityAt: now}
 	// Each spawn/restore must re-prove its hook pipeline: clear the receipt so
-	// a relaunch with broken hooks degrades to no_signal instead of inheriting
-	// a stale "signals worked once" fact.
+	// a relaunch with broken hooks degrades to a never-booted stall instead of
+	// inheriting a stale "signals worked once" fact.
 	rec.FirstSignalAt = time.Time{}
 	rec.Metadata = mergeMetadata(rec.Metadata, metadata)
 	rec.UpdatedAt = now
diff --git a/backend/internal/service/session/service.go b/backend/internal/service/session/service.go
index bbcb32c1..5f1e0b90 100644
--- a/backend/internal/service/session/service.go
+++ b/backend/internal/service/session/service.go
@@ -84,8 +84,8 @@ type Service struct {
 	telemetry ports.EventSink
 	// signalCapable reports whether a harness has a hook pipeline that can
 	// deliver activity signals at all. Only capable harnesses are eligible for
-	// the no_signal downgrade — a hook-less harness staying silent forever is
-	// normal, not a broken pipeline. nil means "unknown": never downgrade.
+	// the never-booted stall downgrade: a hook-less harness staying silent
+	// forever is normal, not a broken pipeline. nil means "unknown": never stall.
 	signalCapable func(domain.AgentHarness) bool
 }
 
@@ -104,9 +104,9 @@ type Deps struct {
 	SCM       scmProvider
 	Clock     func() time.Time
 	Telemetry ports.EventSink
-	// SignalCapable gates the no_signal status downgrade per harness; daemon
+	// SignalCapable gates the never-booted stall downgrade per harness; daemon
 	// wiring passes activitydispatch.SupportsHarness. Left nil, no session is
-	// ever downgraded to no_signal.
+	// ever stalled for silence.
 	SignalCapable func(domain.AgentHarness) bool
 }
 
@@ -484,7 +484,7 @@ func (s *Service) now() time.Time {
 
 // harnessSignals tolerates a zero-value Service the same way now does. Without
 // an injected capability predicate the service cannot tell a broken pipeline
-// from a hook-less harness, so it never claims no_signal.
+// from a hook-less harness, so it never stalls a session for silence.
 func (s *Service) harnessSignals(h domain.AgentHarness) bool {
 	if s.signalCapable == nil {
 		return false
diff --git a/backend/internal/service/session/service_test.go b/backend/internal/service/session/service_test.go
index ee114108..16b8bf18 100644
--- a/backend/internal/service/session/service_test.go
+++ b/backend/internal/service/session/service_test.go
@@ -104,14 +104,16 @@ func (f *fakeStore) GetProject(_ context.Context, id string) (domain.ProjectReco
 
 func TestSessionListDerivesStatusFromPRFacts(t *testing.T) {
 	st := newFakeStore()
-	st.sessions["mer-1"] = domain.SessionRecord{ID: "mer-1", ProjectID: "mer", Activity: domain.Activity{State: domain.ActivityActive}}
+	// Stopped agent on a failing-CI PR: it had the move and quit, so the
+	// session reads Stalled (PR facts drive the status, not the activity).
+	st.sessions["mer-1"] = domain.SessionRecord{ID: "mer-1", ProjectID: "mer", Activity: domain.Activity{State: domain.ActivityIdle}}
 	st.pr["mer-1"] = domain.PRFacts{URL: "pr1", CI: domain.CIFailing}
 
 	list, err := (&Service{store: st}).List(context.Background(), ListFilter{ProjectID: "mer"})
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(list) != 1 || list[0].Status != domain.StatusCIFailed {
+	if len(list) != 1 || list[0].Status != domain.StatusStalled {
 		t.Fatalf("got %+v", list)
 	}
 }
diff --git a/backend/internal/service/session/stack_test.go b/backend/internal/service/session/stack_test.go
index c2d2f0cc..be9787ff 100644
--- a/backend/internal/service/session/stack_test.go
+++ b/backend/internal/service/session/stack_test.go
@@ -42,59 +42,59 @@ func TestBuildStacksMergedParentUnblocksChild(t *testing.T) {
 	}
 }
 
-func TestDeriveStatusWorstWinsAcrossIndependentPRs(t *testing.T) {
-	// Two independent open PRs (both target main): mergeable vs ci_failed.
-	// CI failure is more urgent, so the session reports ci_failed.
+func TestDeriveStatusUnfinishedPRWinsAcrossIndependentPRs(t *testing.T) {
+	// Two independent open PRs: one mergeable (clean), one ci_failed
+	// (unfinished). Stopped on undone work outranks the clean PR → Stalled.
 	prs := []domain.PRFacts{
 		{URL: "a", SourceBranch: "ao/a", TargetBranch: "main", Mergeability: domain.MergeMergeable},
 		{URL: "b", SourceBranch: "ao/b", TargetBranch: "main", CI: domain.CIFailing},
 	}
-	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusCIFailed {
-		t.Fatalf("got %q want ci_failed", got)
+	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusStalled {
+		t.Fatalf("got %q want stalled", got)
 	}
 }
 
-func TestDeriveStatusAllMergeableReportsMergeable(t *testing.T) {
+func TestDeriveStatusAllCleanIsReady(t *testing.T) {
 	prs := []domain.PRFacts{
 		{URL: "a", SourceBranch: "ao/a", TargetBranch: "main", Mergeability: domain.MergeMergeable},
 		{URL: "b", SourceBranch: "ao/b", TargetBranch: "main", Mergeability: domain.MergeMergeable},
 	}
-	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusMergeable {
-		t.Fatalf("got %q want mergeable", got)
+	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusReady {
+		t.Fatalf("got %q want ready", got)
 	}
 }
 
-func TestDeriveStatusStackedChildExemptFromAggregation(t *testing.T) {
-	// Root mergeable; blocked child is pr_open. Child is exempt, so the session
-	// reports mergeable rather than being dragged down to pr_open.
+func TestDeriveStatusStackedChildExemptFromReadiness(t *testing.T) {
+	// Root mergeable (clean); blocked child is a bare open PR (neutral). The
+	// child contributes nothing, so the session reads Ready off the root.
 	prs := []domain.PRFacts{
 		{URL: "root", SourceBranch: "ao/abc", TargetBranch: "main", Mergeability: domain.MergeMergeable},
 		{URL: "child", SourceBranch: "ao/abc/x", TargetBranch: "ao/abc"},
 	}
-	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusMergeable {
-		t.Fatalf("got %q want mergeable (child exempt)", got)
+	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusReady {
+		t.Fatalf("got %q want ready (child neutral)", got)
 	}
 }
 
-func TestDeriveStatusMergedParentOpenChildStaysOnChild(t *testing.T) {
-	// Parent merged, child now unblocked and review_pending: still alive, status
-	// follows the open child.
+func TestDeriveStatusMergedParentOpenCleanChildIsReady(t *testing.T) {
+	// Parent merged, child now unblocked and review_required (clean): stopped on
+	// a clean PR reads Ready.
 	prs := []domain.PRFacts{
 		{URL: "root", SourceBranch: "ao/abc", TargetBranch: "main", Merged: true},
 		{URL: "child", SourceBranch: "ao/abc/x", TargetBranch: "main", Review: domain.ReviewRequired},
 	}
-	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusReviewPending {
-		t.Fatalf("got %q want review_pending", got)
+	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusReady {
+		t.Fatalf("got %q want ready", got)
 	}
 }
 
-func TestDeriveStatusAllMergedReportsMerged(t *testing.T) {
+func TestDeriveStatusAllMergedIsIdle(t *testing.T) {
 	prs := []domain.PRFacts{
 		{URL: "a", Merged: true},
 		{URL: "b", Merged: true},
 	}
-	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusMerged {
-		t.Fatalf("got %q want merged", got)
+	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusIdle {
+		t.Fatalf("got %q want idle", got)
 	}
 }
 
@@ -114,14 +114,15 @@ func TestDeriveStatusEmptyPRsUsesActivity(t *testing.T) {
 	}
 }
 
-func TestDeriveStatusDegenerateAllBlockedStillAggregates(t *testing.T) {
-	// Two PRs each targeting the other's source branch (no visible root). The
-	// fallback aggregates across all so the session never goes dark.
+func TestDeriveStatusDegenerateAllBlockedSurfacesUnfinished(t *testing.T) {
+	// Two PRs each targeting the other's source branch (no visible root). Both
+	// are blocked, but a failing-CI child surfaces as unfinished work, so the
+	// stopped session reads Stalled rather than going dark.
 	prs := []domain.PRFacts{
 		{URL: "a", SourceBranch: "x", TargetBranch: "y", CI: domain.CIFailing},
 		{URL: "b", SourceBranch: "y", TargetBranch: "x", Mergeability: domain.MergeMergeable},
 	}
-	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusCIFailed {
-		t.Fatalf("got %q want ci_failed (degenerate fallback)", got)
+	if got := deriveStatus(live(), prs, statusNow, true); got != domain.StatusStalled {
+		t.Fatalf("got %q want stalled (degenerate, unfinished surfaces)", got)
 	}
 }
diff --git a/backend/internal/service/session/status.go b/backend/internal/service/session/status.go
index 1bacbbde..f7c96752 100644
--- a/backend/internal/service/session/status.go
+++ b/backend/internal/service/session/status.go
@@ -6,55 +6,67 @@ import (
 	"github.com/aoagents/agent-orchestrator/backend/internal/domain"
 )
 
-// noSignalGrace is how long after spawn/restore a session may stay silent
-// before its idle reading is downgraded to StatusNoSignal. It covers the
-// agent's TUI boot plus the gap to the first activity-bearing hook callback
-// (for Codex that is UserPromptSubmit, seconds after the auto-submitted spawn
-// prompt — its SessionStart hook fires earlier but carries no activity state);
-// past it, a silent session is indistinguishable from one with a broken hook
-// pipeline, and the dashboard must not claim a confident "idle".
-const noSignalGrace = 90 * time.Second
+// bootGrace is how long after spawn/restore a signal-capable session may stay
+// silent before its silence reads as a broken pipeline (never booted) rather
+// than a normal boot gap. It covers the agent's TUI boot plus the gap to the
+// first activity-bearing hook callback.
+const bootGrace = 120 * time.Second
 
-// deriveStatus computes the display status. signalCapable says whether this
-// session's harness has an activity hook pipeline at all; only then can
-// prolonged silence mean the pipeline is broken (no_signal) rather than the
-// permanent, normal silence of a hook-less harness.
+// hangTimeout is how long an "active" session may go silent before it reads as
+// hung mid-run (wedged on a tool call or rate limit) instead of working. The
+// detector trades false positives for catching the hang, since a calmly
+// breathing "Working" on a wedged agent is the failure that actually costs you.
+// This is an open number that wants tuning against live sessions.
+const hangTimeout = 10 * time.Minute
+
+// deriveStatus computes the display status as one of five states. It reads the
+// raw activity state plus the PR buckets directly, never a pre-collapsed
+// status, so the active-vs-PR precedence below resolves the right way.
+//
+// Evaluated top to bottom, first match wins: a hung-or-never-booted session is
+// caught before it can read Working, and the whole silent case outranks "go
+// review". signalCapable says whether this harness has an activity hook
+// pipeline at all; only then can prolonged silence mean the pipeline is broken.
 //
-// A session may own several PRs at once (independent or stacked). The PR-derived
-// status is the worst-wins aggregate across its open PRs; stacked children whose
-// parent is still open are exempt from the aggregation since they cannot merge
-// until the parent does. Merged/closed PRs only matter once no open PR remains.
+// A session may own several PRs at once (independent or stacked). prMoves folds
+// them into two booleans: a clean PR with a real action waiting on you, and an
+// unfinished PR the agent left undone. A blocked stacked child's readiness is
+// suppressed (it cannot merge until its parent does), but its problems still
+// count as unfinished work.
 func deriveStatus(rec domain.SessionRecord, prs []domain.PRFacts, now time.Time, signalCapable bool) domain.SessionStatus {
-	if rec.IsTerminated {
-		if anyMerged(prs) {
-			return domain.StatusMerged
-		}
-		return domain.StatusTerminated
-	}
+	hasClean, hasUnfinished := prMoves(openPRs(prs))
 
-	if rec.Activity.State == domain.ActivityWaitingInput {
+	switch {
+	case rec.IsTerminated: // includes merged
+		return domain.StatusIdle
+	case rec.Activity.State == domain.ActivityWaitingInput:
 		return domain.StatusNeedsInput
-	}
-
-	open := openPRs(prs)
-	if len(open) > 0 {
-		return aggregatePRStatus(open)
-	}
-	if anyMerged(prs) {
-		return domain.StatusMerged
-	}
-
-	if rec.Activity.State == domain.ActivityActive {
+	case stalled(rec, now, signalCapable, hasUnfinished):
+		return domain.StatusStalled
+	case rec.Activity.State == domain.ActivityActive:
 		return domain.StatusWorking
+	case hasClean:
+		return domain.StatusReady
+	default:
+		return domain.StatusIdle
 	}
+}
 
-	// No hook callback has ever arrived for this spawn/restore even though the
-	// harness has a hook pipeline. The seeded LastActivityAt marks the launch,
-	// so once the grace passes the honest status is "no signal", not "idle".
-	if signalCapable && rec.FirstSignalAt.IsZero() && now.Sub(rec.Activity.LastActivityAt) > noSignalGrace {
-		return domain.StatusNoSignal
+// stalled reports whether the agent will not finish on its own: it never booted,
+// hung mid-run, or stopped leaving its PR undone.
+func stalled(rec domain.SessionRecord, now time.Time, signalCapable, hasUnfinished bool) bool {
+	active := rec.Activity.State == domain.ActivityActive
+	silence := now.Sub(rec.Activity.LastActivityAt)
+	switch {
+	case signalCapable && rec.FirstSignalAt.IsZero() && silence > bootGrace:
+		return true // never booted
+	case active && silence > hangTimeout:
+		return true // hung mid-run
+	case !active && hasUnfinished:
+		return true // stopped, work undone
+	default:
+		return false
 	}
-	return domain.StatusIdle
 }
 
 // openPRs returns the PRs that are neither merged nor closed, preserving order.
@@ -68,98 +80,56 @@ func openPRs(prs []domain.PRFacts) []domain.PRFacts {
 	return out
 }
 
-func anyMerged(prs []domain.PRFacts) bool {
-	for _, p := range prs {
-		if p.Merged {
-			return true
-		}
-	}
-	return false
-}
-
-// aggregatePRStatus is the worst-wins reduction over a session's open PRs.
-// A stacked child blocked by an open parent cannot merge yet, so its readiness
-// signals (mergeable/approved/review-pending/open) are not actionable for the
-// session and are suppressed. Its problem signals are still actionable: failing
-// CI, draft state, and requested-changes/unresolved-comments must stay visible
-// so a broken child is not hidden behind the stack. If no PR contributes any
-// signal (a degenerate stack with no visible root), it falls back to aggregating
-// the raw status across all open PRs so the session never goes dark.
-func aggregatePRStatus(open []domain.PRFacts) domain.SessionStatus {
+// prMoves folds a session's open PRs into whose move it is. hasClean is true
+// when some PR has a real action waiting on you; hasUnfinished is true when some
+// PR is work the agent left undone. A blocked stacked child cannot merge until
+// its parent does, so its clean signal is suppressed, but its unfinished signal
+// still surfaces so a broken child is not hidden behind the stack.
+//
+// A pathological all-blocked-clean stack (a cycle of mergeable PRs each targeting
+// the next's branch, with no root) yields neither move and reads Idle. The old
+// model force-aggregated such a set to avoid "going dark"; the new model treats
+// genuinely no-actionable-move PRs as Idle, which is honest, and the cycle cannot
+// arise from a real branch topology.
+func prMoves(open []domain.PRFacts) (hasClean, hasUnfinished bool) {
 	stacks := buildStacks(open)
-	candidates := make([]domain.SessionStatus, 0, len(open))
 	for _, p := range open {
-		s := prPipelineStatus(p)
-		if stacks[p.URL].Blocked && !isActionableChildSignal(s) {
-			continue
-		}
-		candidates = append(candidates, s)
-	}
-	if len(candidates) == 0 {
-		for _, p := range open {
-			candidates = append(candidates, prPipelineStatus(p))
-		}
-	}
-	worst := candidates[0]
-	for _, s := range candidates[1:] {
-		if statusSeverity(s) < statusSeverity(worst) {
-			worst = s
+		switch prBucket(p) {
+		case bucketUnfinished:
+			hasUnfinished = true
+		case bucketClean:
+			if !stacks[p.URL].Blocked {
+				hasClean = true
+			}
 		}
 	}
-	return worst
+	return hasClean, hasUnfinished
 }
 
-// isActionableChildSignal reports whether a blocked stacked child's pipeline
-// status is a problem the user can act on now, independent of the child's
-// inability to merge until its parent does.
-func isActionableChildSignal(s domain.SessionStatus) bool {
-	switch s {
-	case domain.StatusCIFailed, domain.StatusDraft, domain.StatusChangesRequested:
-		return true
-	default:
-		return false
-	}
-}
+type prBucketKind int
 
-// statusSeverity ranks PR pipeline statuses from most to least urgent so the
-// aggregate surfaces the PR that most needs attention. mergeable is least urgent
-// so a session only reports mergeable when every aggregated PR is mergeable.
-func statusSeverity(s domain.SessionStatus) int {
-	switch s {
-	case domain.StatusCIFailed:
-		return 0
-	case domain.StatusChangesRequested:
-		return 1
-	case domain.StatusDraft:
-		return 2
-	case domain.StatusReviewPending:
-		return 3
-	case domain.StatusPROpen:
-		return 4
-	case domain.StatusApproved:
-		return 5
-	case domain.StatusMergeable:
-		return 6
-	default:
-		return 7
-	}
-}
+const (
+	bucketNeutral    prBucketKind = iota // bare open PR, just sitting there
+	bucketClean                          // a clean action waits on you
+	bucketUnfinished                     // the agent has more to do
+)
 
-func prPipelineStatus(pr domain.PRFacts) domain.SessionStatus {
+// prBucket sorts one PR by whose move it is. Unfinished signals (failing CI,
+// draft, requested changes, unresolved comments, merge conflict) are checked
+// first so a PR that is both broken and otherwise mergeable reads as unfinished.
+func prBucket(pr domain.PRFacts) prBucketKind {
 	switch {
-	case pr.CI == domain.CIFailing:
-		return domain.StatusCIFailed
-	case pr.Draft:
-		return domain.StatusDraft
-	case pr.Review == domain.ReviewChangesRequest || pr.ReviewComments:
-		return domain.StatusChangesRequested
-	case pr.Mergeability == domain.MergeMergeable:
-		return domain.StatusMergeable
-	case pr.Review == domain.ReviewApproved:
-		return domain.StatusApproved
-	case pr.Review == domain.ReviewRequired:
-		return domain.StatusReviewPending
+	case pr.CI == domain.CIFailing,
+		pr.Draft,
+		pr.Review == domain.ReviewChangesRequest,
+		pr.ReviewComments,
+		pr.Mergeability == domain.MergeConflicting:
+		return bucketUnfinished
+	case pr.Mergeability == domain.MergeMergeable,
+		pr.Review == domain.ReviewApproved,
+		pr.Review == domain.ReviewRequired:
+		return bucketClean
 	default:
-		return domain.StatusPROpen
+		return bucketNeutral
 	}
 }
diff --git a/backend/internal/service/session/status_test.go b/backend/internal/service/session/status_test.go
index f989ed49..8de63b77 100644
--- a/backend/internal/service/session/status_test.go
+++ b/backend/internal/service/session/status_test.go
@@ -35,40 +35,57 @@ func TestServiceDerivesStatusFromSessionFactsAndPR(t *testing.T) {
 		rec  domain.SessionRecord
 		pr   []domain.PRFacts
 		// hookless marks a harness with no activity pipeline (signalCapable
-		// false): silence is its permanent normal state, never no_signal.
+		// false): silence is its permanent normal state, never stalled.
 		hookless bool
 		want     domain.SessionStatus
 	}{
-		{"terminated", statusRec(domain.ActivityExited, true), nil, false, domain.StatusTerminated},
-		{"merged-pr", statusRec(domain.ActivityIdle, true), statusPR(domain.PRFacts{Merged: true}), false, domain.StatusMerged},
+		// Terminated and merged both collapse to Idle.
+		{"terminated", statusRec(domain.ActivityExited, true), nil, false, domain.StatusIdle},
+		{"merged-pr", statusRec(domain.ActivityIdle, true), statusPR(domain.PRFacts{Merged: true}), false, domain.StatusIdle},
+
+		// waiting_input outranks every PR fact.
 		{"needs-input", statusRec(domain.ActivityWaitingInput, false), statusPR(domain.PRFacts{CI: domain.CIFailing}), false, domain.StatusNeedsInput},
-		{"ci-failed", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{CI: domain.CIFailing}), false, domain.StatusCIFailed},
-		{"draft", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Draft: true}), false, domain.StatusDraft},
-		{"changes-requested", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Review: domain.ReviewChangesRequest}), false, domain.StatusChangesRequested},
-		{"mergeable", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Mergeability: domain.MergeMergeable}), false, domain.StatusMergeable},
-		{"approved", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Review: domain.ReviewApproved}), false, domain.StatusApproved},
-		{"review-pending", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Review: domain.ReviewRequired}), false, domain.StatusReviewPending},
-		{"pr-open", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{}), false, domain.StatusPROpen},
+
+		// Stopped on an unfinished PR is Stalled, not Ready: the agent had the
+		// move and quit.
+		{"stopped-ci-failed", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{CI: domain.CIFailing}), false, domain.StatusStalled},
+		{"stopped-draft", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Draft: true}), false, domain.StatusStalled},
+		{"stopped-changes-requested", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Review: domain.ReviewChangesRequest}), false, domain.StatusStalled},
+		{"stopped-conflicting", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Mergeability: domain.MergeConflicting}), false, domain.StatusStalled},
+
+		// An active agent on top of any PR keeps Working (active-wins).
+		{"active-on-unfinished-pr", statusRec(domain.ActivityActive, false), statusPR(domain.PRFacts{CI: domain.CIFailing}), false, domain.StatusWorking},
+		{"active-on-clean-pr", statusRec(domain.ActivityActive, false), statusPR(domain.PRFacts{Mergeability: domain.MergeMergeable}), false, domain.StatusWorking},
+
+		// Stopped on a clean PR is Ready.
+		{"stopped-mergeable", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Mergeability: domain.MergeMergeable}), false, domain.StatusReady},
+		{"stopped-approved", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Review: domain.ReviewApproved}), false, domain.StatusReady},
+		{"stopped-review-required", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{Review: domain.ReviewRequired}), false, domain.StatusReady},
+
+		// Bare open PR behaves as no PR: stopped reads Idle.
+		{"stopped-bare-pr-open", statusRec(domain.ActivityIdle, false), statusPR(domain.PRFacts{}), false, domain.StatusIdle},
+
 		{"working", statusRec(domain.ActivityActive, false), nil, false, domain.StatusWorking},
 		{"idle", statusRec(domain.ActivityIdle, false), nil, false, domain.StatusIdle},
 
-		// A live session whose hook-capable agent never signaled is no_signal
-		// once the grace passes — never a confident idle.
-		{"no-signal-after-grace", silentRec(2 * noSignalGrace), nil, false, domain.StatusNoSignal},
-		// A hook-less harness can never signal: its silence stays idle forever
-		// instead of degrading into a false "needs you".
-		{"hookless-silent-stays-idle", silentRec(2 * noSignalGrace), nil, true, domain.StatusIdle},
+		// A live session whose hook-capable agent never signaled is Stalled
+		// once the boot grace passes — never a confident idle.
+		{"never-booted-after-grace", silentRec(2 * bootGrace), nil, false, domain.StatusStalled},
+		// A hook-less harness can never signal: its silence stays idle forever.
+		{"hookless-silent-stays-idle", silentRec(2 * bootGrace), nil, true, domain.StatusIdle},
 		// Right after spawn the agent legitimately hasn't called back yet.
 		{"silent-within-grace-is-idle", silentRec(10 * time.Second), nil, false, domain.StatusIdle},
-		// Termination and PR facts outrank the missing-signal downgrade.
+
+		// Termination outranks the never-booted downgrade.
 		{
-			"no-signal-terminated-wins",
-			domain.SessionRecord{Activity: domain.Activity{State: domain.ActivityExited, LastActivityAt: statusNow.Add(-2 * noSignalGrace)}, IsTerminated: true},
+			"terminated-outranks-never-booted",
+			domain.SessionRecord{Activity: domain.Activity{State: domain.ActivityExited, LastActivityAt: statusNow.Add(-2 * bootGrace)}, IsTerminated: true},
 			nil,
 			false,
-			domain.StatusTerminated,
+			domain.StatusIdle,
 		},
-		{"no-signal-pr-wins", silentRec(2 * noSignalGrace), statusPR(domain.PRFacts{}), false, domain.StatusPROpen},
+		// Never-booted silence outranks a bare open PR (neutral → idle anyway).
+		{"never-booted-bare-pr", silentRec(2 * bootGrace), statusPR(domain.PRFacts{}), false, domain.StatusStalled},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -79,10 +96,28 @@ func TestServiceDerivesStatusFromSessionFactsAndPR(t *testing.T) {
 	}
 }
 
+// An active session gone silent past hangTimeout is caught as Stalled instead
+// of reading a calm Working; within the timeout it stays Working.
+func TestDeriveStatusHungActiveSessionStalls(t *testing.T) {
+	hung := domain.SessionRecord{
+		Activity:      domain.Activity{State: domain.ActivityActive, LastActivityAt: statusNow.Add(-2 * hangTimeout)},
+		FirstSignalAt: statusNow.Add(-3 * hangTimeout),
+	}
+	if got := deriveStatus(hung, nil, statusNow, true); got != domain.StatusStalled {
+		t.Fatalf("got %q want stalled", got)
+	}
+	live := domain.SessionRecord{
+		Activity:      domain.Activity{State: domain.ActivityActive, LastActivityAt: statusNow.Add(-1 * time.Minute)},
+		FirstSignalAt: statusNow.Add(-1 * time.Hour),
+	}
+	if got := deriveStatus(live, nil, statusNow, true); got != domain.StatusWorking {
+		t.Fatalf("got %q want working", got)
+	}
+}
+
 // A blocked stacked child cannot merge until its parent does, so its readiness
-// signals are suppressed, but its problem signals (failing CI, draft,
-// requested-changes/unresolved-comments) must still surface for the session.
-func TestAggregateStackedChildSignals(t *testing.T) {
+// is suppressed, but its problem signals still surface as unfinished work.
+func TestStackedChildSignals(t *testing.T) {
 	parent := domain.PRFacts{URL: "parent", SourceBranch: "feat", Mergeability: domain.MergeMergeable}
 	child := func(f domain.PRFacts) domain.PRFacts {
 		f.URL = "child"
@@ -95,24 +130,15 @@ func TestAggregateStackedChildSignals(t *testing.T) {
 		prs  []domain.PRFacts
 		want domain.SessionStatus
 	}{
-		{"blocked-child-ci-failing-surfaces", []domain.PRFacts{parent, child(domain.PRFacts{CI: domain.CIFailing})}, domain.StatusCIFailed},
-		{"blocked-child-draft-surfaces", []domain.PRFacts{parent, child(domain.PRFacts{Draft: true})}, domain.StatusDraft},
-		{"blocked-child-changes-requested-surfaces", []domain.PRFacts{parent, child(domain.PRFacts{Review: domain.ReviewChangesRequest})}, domain.StatusChangesRequested},
-		{"blocked-child-unresolved-comments-surfaces", []domain.PRFacts{parent, child(domain.PRFacts{ReviewComments: true})}, domain.StatusChangesRequested},
-		// A blocked child's readiness signals stay hidden: only the parent's
-		// mergeable state drives the session.
-		{"blocked-child-mergeable-suppressed", []domain.PRFacts{parent, child(domain.PRFacts{Mergeability: domain.MergeMergeable})}, domain.StatusMergeable},
-		{"blocked-child-approved-suppressed", []domain.PRFacts{parent, child(domain.PRFacts{Review: domain.ReviewApproved})}, domain.StatusMergeable},
-		// Degenerate set where every open PR is blocked and none is actionable:
-		// fall back to the raw aggregate so the session never goes dark.
-		{
-			"all-blocked-no-actionable-falls-back",
-			[]domain.PRFacts{
-				{URL: "a", SourceBranch: "feat/a", TargetBranch: "feat/b", Mergeability: domain.MergeMergeable},
-				{URL: "b", SourceBranch: "feat/b", TargetBranch: "feat/a", Mergeability: domain.MergeMergeable},
-			},
-			domain.StatusMergeable,
-		},
+		// A blocked child's problem drags the stopped session to Stalled.
+		{"blocked-child-ci-failing-stalls", []domain.PRFacts{parent, child(domain.PRFacts{CI: domain.CIFailing})}, domain.StatusStalled},
+		{"blocked-child-draft-stalls", []domain.PRFacts{parent, child(domain.PRFacts{Draft: true})}, domain.StatusStalled},
+		{"blocked-child-changes-requested-stalls", []domain.PRFacts{parent, child(domain.PRFacts{Review: domain.ReviewChangesRequest})}, domain.StatusStalled},
+		{"blocked-child-unresolved-comments-stalls", []domain.PRFacts{parent, child(domain.PRFacts{ReviewComments: true})}, domain.StatusStalled},
+		// A blocked child's readiness stays hidden: the parent's clean state
+		// alone drives the session to Ready.
+		{"blocked-child-mergeable-suppressed", []domain.PRFacts{parent, child(domain.PRFacts{Mergeability: domain.MergeMergeable})}, domain.StatusReady},
+		{"blocked-child-approved-suppressed", []domain.PRFacts{parent, child(domain.PRFacts{Review: domain.ReviewApproved})}, domain.StatusReady},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -123,11 +149,11 @@ func TestAggregateStackedChildSignals(t *testing.T) {
 	}
 }
 
-// Without an injected capability predicate the service must never claim
-// no_signal; with one, capability follows the predicate per harness.
+// Without an injected capability predicate the service must never claim a
+// signal-driven stall; with one, capability follows the predicate per harness.
 func TestHarnessSignalsCapabilityGate(t *testing.T) {
 	if (&Service{}).harnessSignals(domain.HarnessCodex) {
-		t.Fatal("zero-value Service reports signal-capable; want incapable (never no_signal)")
+		t.Fatal("zero-value Service reports signal-capable; want incapable (never stalled on silence)")
 	}
 	s := NewWithDeps(Deps{SignalCapable: func(h domain.AgentHarness) bool { return h == domain.HarnessCodex }})
 	if !s.harnessSignals(domain.HarnessCodex) {
diff --git a/frontend/src/renderer/components/PullRequestsPage.test.tsx b/frontend/src/renderer/components/PullRequestsPage.test.tsx
index 90a770bb..a0fc2d0a 100644
--- a/frontend/src/renderer/components/PullRequestsPage.test.tsx
+++ b/frontend/src/renderer/components/PullRequestsPage.test.tsx
@@ -40,7 +40,7 @@ const session = (id: string, prs: PullRequestFacts[]): WorkspaceSession => ({
 	provider: "claude-code",
 	kind: "worker",
 	branch: "feat/ns",
-	status: "review_pending",
+	status: "ready",
 	updatedAt: "2026-06-15T00:00:00Z",
 	prs,
 });
diff --git a/frontend/src/renderer/components/SessionInspector.test.tsx b/frontend/src/renderer/components/SessionInspector.test.tsx
index bb517969..3a9c82c8 100644
--- a/frontend/src/renderer/components/SessionInspector.test.tsx
+++ b/frontend/src/renderer/components/SessionInspector.test.tsx
@@ -44,7 +44,7 @@ const session = (prs: PullRequestFacts[]): WorkspaceSession => ({
 	provider: "claude-code",
 	kind: "worker",
 	branch: "feat/ns",
-	status: "review_pending",
+	status: "ready",
 	updatedAt: "2026-06-15T00:00:00Z",
 	prs,
 });
diff --git a/frontend/src/renderer/components/SessionInspector.tsx b/frontend/src/renderer/components/SessionInspector.tsx
index 87edce1d..6fac93ae 100644
--- a/frontend/src/renderer/components/SessionInspector.tsx
+++ b/frontend/src/renderer/components/SessionInspector.tsx
@@ -6,7 +6,7 @@ import { apiClient, apiErrorMessage } from "../lib/api-client";
 import { workspaceQueryKey } from "../hooks/useWorkspaceQuery";
 import { formatTimeCompact } from "../lib/format-time";
 import type { PRState, PullRequestFacts, SessionStatus, WorkspaceSession } from "../types/workspace";
-import { sortedPRs, workerDisplayStatus } from "../types/workspace";
+import { sortedPRs, STATUS_META } from "../types/workspace";
 import { Badge } from "./ui/badge";
 import { cn } from "../lib/utils";
 
@@ -247,28 +247,17 @@ function activityDetail(status: SessionStatus): string | null {
 			return "Session idle";
 		case "needs_input":
 			return "Waiting for your input";
-		case "working":
-			return null;
+		case "ready":
+			return "Clean PR waiting on you";
+		case "stalled":
+			return "Not making progress; get it moving";
 		default:
 			return null;
 	}
 }
 
-const STATUS_PILL: Record<
-	ReturnType<typeof workerDisplayStatus> | "idle",
-	{ label: string; tone: string; breathe: boolean }
-> = {
-	working: { label: "Working", tone: "var(--orange)", breathe: true },
-	needs_you: { label: "Input needed", tone: "var(--amber)", breathe: false },
-	ci_failed: { label: "CI failed", tone: "var(--red)", breathe: false },
-	mergeable: { label: "Ready", tone: "var(--green)", breathe: false },
-	done: { label: "Done", tone: "var(--fg-muted)", breathe: false },
-	idle: { label: "Idle", tone: "var(--fg-muted)", breathe: false },
-};
-
 function InspectorStatusPill({ session }: { session: WorkspaceSession }) {
-	const key = session.status === "idle" ? "idle" : workerDisplayStatus(session);
-	const { label, tone, breathe } = STATUS_PILL[key];
+	const { label, tone, breathe } = STATUS_META[session.status];
 	return (
 		<span
 			className="inline-flex shrink-0 items-center gap-[7px] whitespace-nowrap rounded-[7px] px-[11px] py-[5px] text-[11.5px] font-semibold"
diff --git a/frontend/src/renderer/components/SessionsBoard.tsx b/frontend/src/renderer/components/SessionsBoard.tsx
index 673380d4..2e010d00 100644
--- a/frontend/src/renderer/components/SessionsBoard.tsx
+++ b/frontend/src/renderer/components/SessionsBoard.tsx
@@ -2,7 +2,14 @@ import { useState } from "react";
 import { useQueryClient } from "@tanstack/react-query";
 import { useNavigate } from "@tanstack/react-router";
 import { Plus } from "lucide-react";
-import { type AttentionZone, type WorkspaceSession, attentionZone, openPRs, workerSessions } from "../types/workspace";
+import {
+	type SessionStatus,
+	type WorkspaceSession,
+	STATUS_META,
+	openPRs,
+	statusOrder,
+	workerSessions,
+} from "../types/workspace";
 import { useWorkspaceQuery, workspaceQueryKey } from "../hooks/useWorkspaceQuery";
 import { DashboardSubhead } from "./DashboardSubhead";
 import { OrchestratorIcon } from "./icons";
@@ -15,51 +22,16 @@ type SessionsBoardProps = {
 	projectId?: string;
 };
 
-// The four kanban columns, left→right by flow (work → review → merge), ported
-// verbatim from agent-orchestrator (SIMPLE_KANBAN_LEVELS + AttentionZone +
-// mc-board.css). "done" is archived, not a column.
-type Column = {
-	level: AttentionZone;
-	label: string;
-	glow: string;
-	dot: string;
-	dotGlow: boolean;
-	titleClass: string;
-};
-const COLUMNS: Column[] = [
-	{
-		level: "working",
-		label: "Working",
-		glow: "color-mix(in srgb, var(--orange) 7%, transparent)",
-		dot: "var(--orange)",
-		dotGlow: true,
-		titleClass: "text-working",
-	},
-	{
-		level: "action",
-		label: "Needs you",
-		glow: "color-mix(in srgb, var(--amber) 6%, transparent)",
-		dot: "var(--amber)",
-		dotGlow: true,
-		titleClass: "text-warning",
-	},
-	{
-		level: "pending",
-		label: "In review",
-		glow: "var(--kanban-pending-glow)",
-		dot: "var(--fg-muted)",
-		dotGlow: false,
-		titleClass: "text-muted-foreground",
-	},
-	{
-		level: "merge",
-		label: "Ready to merge",
-		glow: "color-mix(in srgb, var(--green) 7%, transparent)",
-		dot: "var(--green)",
-		dotGlow: true,
-		titleClass: "text-success",
-	},
-];
+// The five kanban columns, left→right by human-action urgency, one per display
+// state ({@link statusOrder}). Each column reads its label and tone from the
+// shared STATUS_META so the board, pill, sidebar dot, and card badge never
+// disagree. Terminated sessions are archived in the done bar, not a column.
+type Column = { status: SessionStatus; label: string; tone: string };
+const COLUMNS: Column[] = statusOrder.map((status) => ({
+	status,
+	label: STATUS_META[status].label,
+	tone: STATUS_META[status].tone,
+}));
 
 export function SessionsBoard({ projectId }: SessionsBoardProps) {
 	const navigate = useNavigate();
@@ -69,17 +41,22 @@ export function SessionsBoard({ projectId }: SessionsBoardProps) {
 	const workspaces = projectId ? all.filter((w) => w.id === projectId) : all;
 	const sessions = workspaces.flatMap((w) => workerSessions(w.sessions));
 	const orchestrator = projectId
-		? workspaces[0]?.sessions.find((session) => session.kind === "orchestrator" && session.status !== "terminated")
+		? workspaces[0]?.sessions.find((session) => session.kind === "orchestrator" && !session.isTerminated)
 		: undefined;
 	const [isNewTaskOpen, setIsNewTaskOpen] = useState(false);
 	const [isSpawning, setIsSpawning] = useState(false);
 
-	const byZone = new Map<AttentionZone, WorkspaceSession[]>();
+	// Live sessions group into the five status columns; terminated ones archive
+	// into the done bar regardless of their (idle) display status.
+	const byStatus = new Map<SessionStatus, WorkspaceSession[]>();
+	const done: WorkspaceSession[] = [];
 	for (const session of sessions) {
-		const zone = attentionZone(session);
-		(byZone.get(zone) ?? byZone.set(zone, []).get(zone)!).push(session);
+		if (session.isTerminated) {
+			done.push(session);
+			continue;
+		}
+		(byStatus.get(session.status) ?? byStatus.set(session.status, []).get(session.status)!).push(session);
 	}
-	const done = byZone.get("done") ?? [];
 	// Collapsed by default, like agent-orchestrator's done-bar: finished and
 	// killed sessions cost one quiet line under the board until expanded.
 	const [doneExpanded, setDoneExpanded] = useState(false);
@@ -157,9 +134,9 @@ export function SessionsBoard({ projectId }: SessionsBoardProps) {
 				{workspaceQuery.isError ? (
 					<p className="py-10 text-center text-[12px] text-passive">Could not load sessions.</p>
 				) : (
-					<div className="grid h-full grid-cols-4 gap-2">
+					<div className="grid h-full grid-cols-5 gap-2">
 						{COLUMNS.map((col) => (
-							<ZoneColumn key={col.level} col={col} sessions={byZone.get(col.level) ?? []} onOpen={openSession} />
+							<ZoneColumn key={col.status} col={col} sessions={byStatus.get(col.status) ?? []} onOpen={openSession} />
 						))}
 					</div>
 				)}
@@ -228,20 +205,19 @@ function ZoneColumn({
 	sessions: WorkspaceSession[];
 	onOpen: (s: WorkspaceSession) => void;
 }) {
+	const glow = col.status === "idle" ? undefined : `0 0 7px color-mix(in srgb, ${col.tone} 60%, transparent)`;
 	return (
 		<section
 			className="flex min-w-0 flex-col overflow-hidden rounded-[13px]"
-			style={{ background: `linear-gradient(180deg, ${col.glow}, transparent 130px), var(--kanban-column-bg)` }}
+			style={{
+				background: `linear-gradient(180deg, color-mix(in srgb, ${col.tone} 7%, transparent), transparent 130px), var(--kanban-column-bg)`,
+			}}
 		>
 			<div className="flex shrink-0 items-center gap-[9px] px-[15px] pb-[11px] pt-[14px]">
-				<span
-					className="h-[7px] w-[7px] rounded-full"
-					style={{
-						background: col.dot,
-						boxShadow: col.dotGlow ? `0 0 7px color-mix(in srgb, ${col.dot} 60%, transparent)` : undefined,
-					}}
-				/>
-				<span className={cn("text-[11px] font-semibold uppercase tracking-[0.08em]", col.titleClass)}>{col.label}</span>
+				<span className="h-[7px] w-[7px] rounded-full" style={{ background: col.tone, boxShadow: glow }} />
+				<span className="text-[11px] font-semibold uppercase tracking-[0.08em]" style={{ color: col.tone }}>
+					{col.label}
+				</span>
 				<span className="ml-auto font-mono text-[11px] leading-none text-passive">{sessions.length}</span>
 			</div>
 			<div className="min-h-0 flex-1 overflow-y-auto px-[11px] pb-3">
@@ -279,8 +255,8 @@ function SessionCard({ session, onOpen }: { session: WorkspaceSession; onOpen: (
 			type="button"
 		>
 			<div className="flex items-center gap-2 px-[13px] pb-[9px] pt-3">
-				<span className={cn("inline-flex items-center gap-1.5 text-[11px] font-medium", badge.className)}>
-					<span className={cn("h-[7px] w-[7px] rounded-full bg-current")} />
+				<span className="inline-flex items-center gap-1.5 text-[11px] font-medium" style={{ color: badge.tone }}>
+					<span className="h-[7px] w-[7px] rounded-full bg-current" />
 					{badge.label}
 				</span>
 				<span className="ml-auto shrink-0 font-mono text-[10.5px] tracking-[0.04em] text-passive">
@@ -324,29 +300,7 @@ function agentLabel(provider: WorkspaceSession["provider"]): string {
 	}
 }
 
-function sessionBadge(session: WorkspaceSession): { label: string; className: string } {
-	switch (session.status) {
-		case "needs_input":
-			return { label: "Input needed", className: "text-warning" };
-		case "ci_failed":
-			return { label: "CI failed", className: "text-error" };
-		case "changes_requested":
-			return { label: "Changes requested", className: "text-warning" };
-		case "review_pending":
-			return { label: "Review pending", className: "text-muted-foreground" };
-		case "draft":
-			return { label: "Draft PR", className: "text-muted-foreground" };
-		case "pr_open":
-			return { label: "PR open", className: "text-muted-foreground" };
-		case "approved":
-			return { label: "Approved", className: "text-success" };
-		case "mergeable":
-			return { label: "Ready", className: "text-success" };
-		case "merged":
-			return { label: "Merged", className: "text-passive" };
-		case "terminated":
-			return { label: "Terminated", className: "text-passive" };
-		default:
-			return { label: "Working", className: "text-working" };
-	}
+function sessionBadge(session: WorkspaceSession): { label: string; tone: string } {
+	const meta = STATUS_META[session.status];
+	return { label: meta.label, tone: meta.tone };
 }
diff --git a/frontend/src/renderer/components/ShellTopbar.tsx b/frontend/src/renderer/components/ShellTopbar.tsx
index ff8285de..04adbe48 100644
--- a/frontend/src/renderer/components/ShellTopbar.tsx
+++ b/frontend/src/renderer/components/ShellTopbar.tsx
@@ -6,8 +6,7 @@ import {
 	findProjectOrchestrator,
 	isOrchestratorSession,
 	sessionIsActive,
-	workerDisplayStatus,
-	type WorkerDisplayStatus,
+	STATUS_META,
 	type WorkspaceSession,
 } from "../types/workspace";
 import { useWorkspaceQuery, workspaceQueryKey } from "../hooks/useWorkspaceQuery";
@@ -23,17 +22,6 @@ const isMac = typeof navigator !== "undefined" && /Mac|iPod|iPhone|iPad/.test(na
 const dragStyle = isMac ? ({ WebkitAppRegion: "drag" } as React.CSSProperties) : undefined;
 const noDragStyle = isMac ? ({ WebkitAppRegion: "no-drag" } as React.CSSProperties) : undefined;
 
-// Session status → pill tone, mirroring agent-orchestrator's StatusBadge
-// (working=orange & breathing, input=amber, fail=red, ready=green, done=neutral).
-// Tones are theme vars so the pill tracks the light/dark status palettes.
-const STATUS_PILL: Record<WorkerDisplayStatus, { label: string; tone: string; breathe: boolean }> = {
-	working: { label: "Working", tone: "var(--orange)", breathe: true },
-	needs_you: { label: "Needs input", tone: "var(--amber)", breathe: false },
-	ci_failed: { label: "CI failed", tone: "var(--red)", breathe: false },
-	mergeable: { label: "Ready", tone: "var(--green)", breathe: false },
-	done: { label: "Done", tone: "var(--fg-muted)", breathe: false },
-};
-
 // The one app topbar (.dashboard-app-header), rendered by the shell layout
 // across the full window width — above both the sidebar and the route outlet —
 // so the crumb and actions sit at identical offsets on every screen and the
@@ -313,7 +301,7 @@ export function TopbarKillButton({ session }: { session: WorkspaceSession }) {
 // StatusBadge --pill: tinted bordered pill (inset 25%-tone hairline + 7%-tone
 // fill) with a 6px dot that breathes while the agent is working.
 function SessionStatusPill({ session }: { session: WorkspaceSession }) {
-	const { label, tone, breathe } = STATUS_PILL[workerDisplayStatus(session)];
+	const { label, tone, breathe } = STATUS_META[session.status];
 	return (
 		<span
 			className="inline-flex shrink-0 items-center gap-[7px] whitespace-nowrap rounded-[7px] px-[11px] py-[5px] text-[11.5px] font-semibold leading-none"
diff --git a/frontend/src/renderer/components/Sidebar.tsx b/frontend/src/renderer/components/Sidebar.tsx
index dff79629..00c36cac 100644
--- a/frontend/src/renderer/components/Sidebar.tsx
+++ b/frontend/src/renderer/components/Sidebar.tsx
@@ -14,9 +14,9 @@ import {
 } from "lucide-react";
 import { useState } from "react";
 import {
-	attentionZone,
 	isOrchestratorSession,
 	sessionIsActive,
+	STATUS_META,
 	type WorkspaceSession,
 	type WorkspaceSummary,
 	workerSessions,
@@ -97,21 +97,15 @@ function useSelection() {
 	};
 }
 
-// 6px session dot: mirrors the board's status language so the sidebar can be
-// scanned without opening the project board.
+// 6px session dot: reads the shared STATUS_META tone so the sidebar mirrors the
+// board's status language and can be scanned without opening the project board.
 function SessionDot({ session }: { session: WorkspaceSession }) {
-	const zone = attentionZone(session);
+	const { tone, breathe } = STATUS_META[session.status];
 	return (
 		<span
 			aria-hidden="true"
-			className={cn(
-				"mt-px h-1.5 w-1.5 shrink-0 rounded-full",
-				zone === "working" && "animate-status-pulse bg-working",
-				zone === "action" && (session.status === "ci_failed" ? "bg-error" : "bg-warning"),
-				zone === "pending" && "bg-passive",
-				zone === "merge" && "bg-success",
-				zone === "done" && "bg-passive",
-			)}
+			className={cn("mt-px h-1.5 w-1.5 shrink-0 rounded-full", breathe && "animate-status-pulse")}
+			style={{ background: tone }}
 		/>
 	);
 }
diff --git a/frontend/src/renderer/components/TerminalPane.tsx b/frontend/src/renderer/components/TerminalPane.tsx
index 90bdb0d4..11cad1d1 100644
--- a/frontend/src/renderer/components/TerminalPane.tsx
+++ b/frontend/src/renderer/components/TerminalPane.tsx
@@ -58,7 +58,7 @@ function AttachedTerminal({ session, theme, daemonReady, terminalTarget }: Termi
 	const { attach, state, error } = useTerminalSession(attachSession, { daemonReady });
 	const handleId = attachSession?.terminalHandleId;
 	const hadAttachmentRef = useRef(false);
-	const canRestoreSession = terminalTarget?.kind !== "reviewer" && session?.status === "terminated";
+	const canRestoreSession = terminalTarget?.kind !== "reviewer" && Boolean(session?.isTerminated);
 
 	const handleReady = useCallback((handle: AttachableTerminal) => setTerminal(handle), []);
 	const handleInitError = useCallback((err: unknown) => {
diff --git a/frontend/src/renderer/hooks/useWorkspaceQuery.test.tsx b/frontend/src/renderer/hooks/useWorkspaceQuery.test.tsx
index 309e60ec..7c1be704 100644
--- a/frontend/src/renderer/hooks/useWorkspaceQuery.test.tsx
+++ b/frontend/src/renderer/hooks/useWorkspaceQuery.test.tsx
@@ -48,7 +48,7 @@ describe("useWorkspaceQuery", () => {
 							terminalHandleId: "term-1",
 							displayName: "fix-bug",
 							harness: "claude-code",
-							status: "mergeable",
+							status: "ready",
 							isTerminated: false,
 							updatedAt: "2026-06-10T16:15:04Z",
 						},
@@ -81,7 +81,7 @@ describe("useWorkspaceQuery", () => {
 			terminalHandleId: "term-1",
 			title: "fix-bug",
 			provider: "claude-code",
-			status: "mergeable",
+			status: "ready",
 		});
 		expect(workspace.sessions[1]).toMatchObject({
 			id: "sess-2",
@@ -149,7 +149,7 @@ describe("useWorkspaceQuery", () => {
 		expect(sessions[1].prs).toEqual([]);
 	});
 
-	it("marks terminated sessions regardless of their reported status", async () => {
+	it("carries isTerminated and renders the backend status verbatim", async () => {
 		respondWith({
 			projects: { data: { projects: [{ id: "proj-1", name: "my-app", path: "/p" }] }, error: undefined },
 			sessions: {
@@ -158,7 +158,7 @@ describe("useWorkspaceQuery", () => {
 						{
 							id: "sess-1",
 							projectId: "proj-1",
-							status: "working",
+							status: "idle",
 							isTerminated: true,
 							updatedAt: "2026-06-10T16:15:04Z",
 						},
@@ -171,7 +171,11 @@ describe("useWorkspaceQuery", () => {
 		const { result } = renderHook(() => useWorkspaceQuery(), { wrapper });
 		await waitFor(() => expect(result.current.isSuccess).toBe(true));
 
-		expect(result.current.data?.[0].sessions[0].status).toBe("terminated");
+		// The daemon already collapses terminated to the idle display status; the
+		// frontend renders it verbatim and keeps the separate isTerminated fact
+		// for liveness.
+		expect(result.current.data?.[0].sessions[0].status).toBe("idle");
+		expect(result.current.data?.[0].sessions[0].isTerminated).toBe(true);
 	});
 
 	it("surfaces a projects fetch error", async () => {
diff --git a/frontend/src/renderer/hooks/useWorkspaceQuery.ts b/frontend/src/renderer/hooks/useWorkspaceQuery.ts
index 0b6b4776..8dded2c7 100644
--- a/frontend/src/renderer/hooks/useWorkspaceQuery.ts
+++ b/frontend/src/renderer/hooks/useWorkspaceQuery.ts
@@ -51,7 +51,8 @@ async function fetchWorkspaces(): Promise<WorkspaceSummary[]> {
 				provider: toAgentProvider(session.harness),
 				kind: session.kind === "orchestrator" ? "orchestrator" : session.kind === "worker" ? "worker" : undefined,
 				branch: `session/${session.id}`,
-				status: toSessionStatus(session.status, session.isTerminated),
+				status: toSessionStatus(session.status),
+				isTerminated: session.isTerminated,
 				createdAt: session.createdAt,
 				updatedAt: session.updatedAt,
 				prs: (session.prs ?? []).map(toPullRequestFacts),
diff --git a/frontend/src/renderer/lib/mock-data.ts b/frontend/src/renderer/lib/mock-data.ts
index 5d3af952..2032c020 100644
--- a/frontend/src/renderer/lib/mock-data.ts
+++ b/frontend/src/renderer/lib/mock-data.ts
@@ -51,7 +51,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "auth stack",
 				provider: "claude-code",
 				branch: "feat/ns",
-				status: "review_pending",
+				status: "ready",
 				updatedAt: now,
 				createdAt: hoursAgo(2),
 				// One session owning a stack: open root, draft child, merged base.
@@ -95,7 +95,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "fix auth timeout retry loop",
 				provider: "codex",
 				branch: "fix/auth-timeouts",
-				status: "ci_failed",
+				status: "stalled",
 				updatedAt: hoursAgo(1),
 				createdAt: hoursAgo(6),
 				prs: [pr(184, "open", "failing")],
@@ -107,7 +107,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "add rate limit headers",
 				provider: "opencode",
 				branch: "feat/rate-limit-headers",
-				status: "review_pending",
+				status: "ready",
 				updatedAt: hoursAgo(2),
 				createdAt: hoursAgo(9),
 				prs: [pr(185, "open")],
@@ -154,7 +154,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "stop texture leak on scene reload",
 				provider: "codex",
 				branch: "fix/texture-leak",
-				status: "ci_failed",
+				status: "stalled",
 				updatedAt: hoursAgo(1.5),
 				createdAt: hoursAgo(7),
 				prs: [pr(51, "open", "failing")],
@@ -166,7 +166,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "smooth camera pan controls",
 				provider: "aider",
 				branch: "feat/camera-pan",
-				status: "review_pending",
+				status: "ready",
 				updatedAt: hoursAgo(3),
 				createdAt: hoursAgo(10),
 				prs: [pr(52, "open")],
@@ -178,7 +178,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "probe WebGPU support before init",
 				provider: "opencode",
 				branch: "feat/webgpu-probe",
-				status: "draft",
+				status: "stalled",
 				updatedAt: hoursAgo(5),
 				createdAt: hoursAgo(12),
 				prs: [pr(53, "draft")],
@@ -190,7 +190,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "ship frame statistics overlay",
 				provider: "codex",
 				branch: "feat/frame-stats",
-				status: "mergeable",
+				status: "ready",
 				updatedAt: hoursAgo(0.25),
 				createdAt: hoursAgo(14),
 				prs: [pr(54, "open")],
@@ -202,7 +202,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "respect device pixel ratio",
 				provider: "claude-code",
 				branch: "fix/device-pixel-ratio",
-				status: "approved",
+				status: "ready",
 				updatedAt: hoursAgo(2.5),
 				createdAt: hoursAgo(16),
 				prs: [pr(55, "open")],
@@ -214,7 +214,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "pointer lock escape handling",
 				provider: "codex",
 				branch: "fix/pointer-lock",
-				status: "changes_requested",
+				status: "stalled",
 				updatedAt: hoursAgo(4),
 				createdAt: hoursAgo(18),
 				prs: [pr(56, "open")],
@@ -245,7 +245,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "profile sheet accessibility pass",
 				provider: "claude-code",
 				branch: "fix/profile-sheet-a11y",
-				status: "mergeable",
+				status: "ready",
 				updatedAt: hoursAgo(1.25),
 				createdAt: hoursAgo(8),
 				prs: [pr(92, "open")],
@@ -264,7 +264,7 @@ export const mockWorkspaces: WorkspaceSummary[] = [
 				title: "invoice CSV export",
 				provider: "opencode",
 				branch: "feat/invoice-export",
-				status: "review_pending",
+				status: "ready",
 				updatedAt: hoursAgo(2.25),
 				createdAt: hoursAgo(11),
 				prs: [pr(117, "open")],
diff --git a/frontend/src/renderer/types/workspace.test.ts b/frontend/src/renderer/types/workspace.test.ts
index 729c88c9..2964f603 100644
--- a/frontend/src/renderer/types/workspace.test.ts
+++ b/frontend/src/renderer/types/workspace.test.ts
@@ -1,18 +1,15 @@
 import { describe, expect, it } from "vitest";
 import {
-	attentionZone,
 	findProjectOrchestrator,
 	sessionIsActive,
-	sessionNeedsAttention,
+	STATUS_META,
+	statusOrder,
 	toAgentProvider,
 	toSessionStatus,
-	workerDisplayStatus,
-	workerStatusPulses,
 	openPRs,
 	mergedPRCount,
 	primaryPR,
 	sortedPRs,
-	type AttentionZone,
 	type PRState,
 	type PullRequestFacts,
 	type SessionStatus,
@@ -46,12 +43,10 @@ const pr = (overrides: Partial<PullRequestFacts> & { number: number; state: PRSt
 });
 
 describe("toSessionStatus", () => {
-	it("passes through a known status", () => {
-		expect(toSessionStatus("mergeable")).toBe("mergeable");
-	});
-
-	it("overrides to terminated when the session is terminated", () => {
-		expect(toSessionStatus("working", true)).toBe("terminated");
+	it("passes through each of the five known states", () => {
+		for (const status of statusOrder) {
+			expect(toSessionStatus(status)).toBe(status);
+		}
 	});
 
 	it("falls back to working for an unknown status", () => {
@@ -63,36 +58,30 @@ describe("toSessionStatus", () => {
 	});
 });
 
-describe("workerDisplayStatus", () => {
-	it("prefers an explicit displayStatus override", () => {
-		expect(workerDisplayStatus(sessionWith({ status: "ci_failed", displayStatus: "done" }))).toBe("done");
-	});
-
-	it.each([
-		["needs_input", "needs_you"],
-		["changes_requested", "needs_you"],
-		["review_pending", "needs_you"],
-		["ci_failed", "ci_failed"],
-		["approved", "mergeable"],
-		["mergeable", "mergeable"],
-		["merged", "done"],
-		["terminated", "done"],
-		["working", "working"],
-		["idle", "working"],
-	] as const)("maps %s to %s", (status, expected) => {
-		expect(workerDisplayStatus(sessionWith({ status }))).toBe(expected);
+describe("STATUS_META", () => {
+	it("covers all five states and orders the board by urgency", () => {
+		expect(Object.keys(STATUS_META).sort()).toEqual(["idle", "needs_input", "ready", "stalled", "working"]);
+		expect(statusOrder).toEqual(["needs_input", "stalled", "ready", "working", "idle"]);
 	});
-});
 
-describe("sessionIsActive", () => {
-	it("is false for merged and terminated", () => {
-		expect(sessionIsActive(sessionWith({ status: "merged" }))).toBe(false);
-		expect(sessionIsActive(sessionWith({ status: "terminated" }))).toBe(false);
+	it("breathes only for working (the live state)", () => {
+		expect(STATUS_META.working.breathe).toBe(true);
+		for (const status of ["needs_input", "ready", "stalled", "idle"] as const) {
+			expect(STATUS_META[status].breathe).toBe(false);
+		}
+	});
+
+	it("flags attention for exactly needs_input and stalled", () => {
+		const attention = (statusOrder as SessionStatus[]).filter((s) => STATUS_META[s].attention).sort();
+		expect(attention).toEqual(["needs_input", "stalled"]);
 	});
+});
 
-	it("is true for in-progress statuses", () => {
-		expect(sessionIsActive(sessionWith({ status: "working" }))).toBe(true);
-		expect(sessionIsActive(sessionWith({ status: "pr_open" }))).toBe(true);
+describe("sessionIsActive", () => {
+	it("is false only for terminated sessions", () => {
+		expect(sessionIsActive(sessionWith({ isTerminated: true }))).toBe(false);
+		expect(sessionIsActive(sessionWith({ isTerminated: false }))).toBe(true);
+		expect(sessionIsActive(sessionWith({ status: "idle" }))).toBe(true);
 	});
 });
 
@@ -105,14 +94,14 @@ describe("findProjectOrchestrator", () => {
 		// Regression: the daemon lists sessions by spawn number, so a dead
 		// orchestrator (zellij session deleted) sorts before its live successor.
 		// Picking it sent the Orchestrator button to an instant "[process exited]".
-		const dead = sessionWith({ id: "skills-4", kind: "orchestrator", status: "terminated" });
+		const dead = sessionWith({ id: "skills-4", kind: "orchestrator", isTerminated: true });
 		const live = sessionWith({ id: "skills-5", kind: "orchestrator", status: "needs_input" });
 		const worker = sessionWith({ id: "skills-6", kind: "worker", status: "working" });
 		expect(findProjectOrchestrator([workspaceWith([dead, live, worker])], "skills")).toBe(live);
 	});
 
 	it("returns undefined when every orchestrator is terminated", () => {
-		const dead = sessionWith({ id: "skills-4", kind: "orchestrator", status: "terminated" });
+		const dead = sessionWith({ id: "skills-4", kind: "orchestrator", isTerminated: true });
 		expect(findProjectOrchestrator([workspaceWith([dead])], "skills")).toBeUndefined();
 	});
 
@@ -127,26 +116,6 @@ describe("findProjectOrchestrator", () => {
 	});
 });
 
-describe("sessionNeedsAttention", () => {
-	it.each(["needs_input", "changes_requested", "review_pending", "ci_failed"] as const)("is true for %s", (status) => {
-		expect(sessionNeedsAttention(sessionWith({ status }))).toBe(true);
-	});
-
-	it("is false for statuses that don't need the user", () => {
-		expect(sessionNeedsAttention(sessionWith({ status: "working" }))).toBe(false);
-		expect(sessionNeedsAttention(sessionWith({ status: "mergeable" }))).toBe(false);
-	});
-});
-
-describe("workerStatusPulses", () => {
-	it("pulses only for working and needs_you", () => {
-		expect(workerStatusPulses("working")).toBe(true);
-		expect(workerStatusPulses("needs_you")).toBe(true);
-		expect(workerStatusPulses("mergeable")).toBe(false);
-		expect(workerStatusPulses("done")).toBe(false);
-	});
-});
-
 describe("toAgentProvider", () => {
 	it("passes through a known provider", () => {
 		expect(toAgentProvider("opencode")).toBe("opencode");
@@ -192,29 +161,3 @@ describe("PR helpers", () => {
 		expect(primaryPR(sessionWith({ prs: [] }))).toBeUndefined();
 	});
 });
-
-describe("attentionZone", () => {
-	const cases: Array<[SessionStatus, AttentionZone]> = [
-		["mergeable", "merge"],
-		["approved", "merge"],
-		["needs_input", "action"],
-		["ci_failed", "action"],
-		["changes_requested", "action"],
-		["review_pending", "pending"],
-		["pr_open", "pending"],
-		["draft", "pending"],
-		["working", "working"],
-		["idle", "working"],
-		["merged", "done"],
-		["terminated", "done"],
-	];
-
-	it.each(cases)("buckets %s into the %s zone", (status, zone) => {
-		expect(attentionZone(sessionWith({ status }))).toBe(zone);
-	});
-
-	it("prioritizes merge as the highest-ROI zone", () => {
-		// merge is checked before action/pending so an approved PR always surfaces.
-		expect(attentionZone(sessionWith({ status: "approved" }))).toBe("merge");
-	});
-});
diff --git a/frontend/src/renderer/types/workspace.ts b/frontend/src/renderer/types/workspace.ts
index a5f1b466..9fbb14f6 100644
--- a/frontend/src/renderer/types/workspace.ts
+++ b/frontend/src/renderer/types/workspace.ts
@@ -1,37 +1,35 @@
-export type SessionStatus =
-	| "working"
-	| "pr_open"
-	| "draft"
-	| "ci_failed"
-	| "review_pending"
-	| "changes_requested"
-	| "approved"
-	| "mergeable"
-	| "merged"
-	| "needs_input"
-	| "idle"
-	| "terminated";
+/**
+ * The five display states the dashboard renders, derived server-side and sent
+ * verbatim. Each maps to one distinct move a human makes when scanning a wall
+ * of agents (see {@link STATUS_META}). Finer PR detail lives in the inspector,
+ * not in the glanceable status.
+ */
+export type SessionStatus = "working" | "needs_input" | "ready" | "stalled" | "idle";
 
-const sessionStatuses = new Set<SessionStatus>([
-	"working",
-	"pr_open",
-	"draft",
-	"ci_failed",
-	"review_pending",
-	"changes_requested",
-	"approved",
-	"mergeable",
-	"merged",
-	"needs_input",
-	"idle",
-	"terminated",
-]);
+const sessionStatuses = new Set<SessionStatus>(["working", "needs_input", "ready", "stalled", "idle"]);
 
-export function toSessionStatus(status?: string, isTerminated = false): SessionStatus {
-	if (isTerminated) return "terminated";
+export function toSessionStatus(status?: string): SessionStatus {
 	return status && sessionStatuses.has(status as SessionStatus) ? (status as SessionStatus) : "working";
 }
 
+/**
+ * The one shared status definition every surface reads from: the pill, the
+ * board columns, the sidebar dot, and the card badge. `tone` is a theme var so
+ * each state tracks the light/dark palette; `breathe` is whether it pulses
+ * (alive); `attention` is whether it needs a human to unblock progress.
+ */
+export const STATUS_META: Record<SessionStatus, { label: string; tone: string; breathe: boolean; attention: boolean }> =
+	{
+		working: { label: "Working", tone: "var(--orange)", breathe: true, attention: false },
+		needs_input: { label: "Needs input", tone: "var(--amber)", breathe: false, attention: true },
+		ready: { label: "Ready", tone: "var(--green)", breathe: false, attention: false },
+		stalled: { label: "Stalled", tone: "var(--red)", breathe: false, attention: true },
+		idle: { label: "Idle", tone: "var(--fg-muted)", breathe: false, attention: false },
+	};
+
+/** Board columns left→right by human-action urgency. */
+export const statusOrder: SessionStatus[] = ["needs_input", "stalled", "ready", "working", "idle"];
+
 export type AgentProvider =
 	| "codex"
 	| "claude-code"
@@ -97,7 +95,10 @@ export type WorkspaceSession = {
 	kind?: SessionKind;
 	branch: string;
 	status: SessionStatus;
-	/** ISO timestamp from the daemon — used for relative time in the inspector. */
+	/** Whether the session is torn down. Drives liveness, not the display status
+	 * (a terminated session reads {@link SessionStatus} `idle`). */
+	isTerminated?: boolean;
+	/** ISO timestamp from the daemon; used for relative time in the inspector. */
 	createdAt?: string;
 	/** ISO timestamp from the daemon. */
 	updatedAt: string;
@@ -111,36 +112,8 @@ export type WorkspaceSession = {
 	 * done server-side, so {@link status} already reflects all of these.
 	 */
 	prs: PullRequestFacts[];
-	/**
-	 * Display status as derived by the daemon at read time. Optional override; when
-	 * absent it is derived from {@link SessionStatus} via {@link workerDisplayStatus}.
-	 */
-	displayStatus?: WorkerDisplayStatus;
 };
 
-/** Glanceable worker status. Maps 1:1 to the accent colors in DESIGN.md. */
-export type WorkerDisplayStatus = "working" | "needs_you" | "mergeable" | "ci_failed" | "done";
-
-export function workerDisplayStatus(session: WorkspaceSession): WorkerDisplayStatus {
-	if (session.displayStatus) return session.displayStatus;
-	switch (session.status) {
-		case "needs_input":
-		case "changes_requested":
-		case "review_pending":
-			return "needs_you";
-		case "ci_failed":
-			return "ci_failed";
-		case "approved":
-		case "mergeable":
-			return "mergeable";
-		case "merged":
-		case "terminated":
-			return "done";
-		default:
-			return "working";
-	}
-}
-
 // Open PRs (actionable) sort above merged/closed; ties break by number.
 const prStateRank: Record<PRState, number> = { open: 0, draft: 1, merged: 2, closed: 3 };
 
@@ -170,9 +143,9 @@ export function isOrchestratorSession(session: WorkspaceSession): boolean {
 /**
  * The project's LIVE orchestrator, if any. Terminated orchestrator rows stay in
  * the session list (the daemon returns all sessions, ordered by spawn number),
- * so an earlier dead orchestrator must not shadow a live one — its zellij
+ * so an earlier dead orchestrator must not shadow a live one: its zellij
  * session is deleted and attaching to it dead-ends in an instant
- * "[process exited]". No live orchestrator → undefined, so the topbar offers
+ * "[process exited]". No live orchestrator means undefined, so the topbar offers
  * Spawn instead of navigating to a dead session.
  */
 export function findProjectOrchestrator(
@@ -187,79 +160,9 @@ export function workerSessions(sessions: WorkspaceSession[]): WorkspaceSession[]
 	return sessions.filter((s) => !isOrchestratorSession(s));
 }
 
+/** Whether the session is still live (not torn down). */
 export function sessionIsActive(session: WorkspaceSession): boolean {
-	return session.status !== "merged" && session.status !== "terminated";
-}
-
-export function sessionNeedsAttention(session: WorkspaceSession): boolean {
-	return (
-		session.status === "needs_input" ||
-		session.status === "changes_requested" ||
-		session.status === "review_pending" ||
-		session.status === "ci_failed"
-	);
-}
-
-export const workerStatusLabel: Record<WorkerDisplayStatus, string> = {
-	working: "working",
-	needs_you: "needs you",
-	mergeable: "mergeable",
-	ci_failed: "ci failed",
-	done: "done",
-};
-
-/** Whether a status should breathe (alive/working). */
-export function workerStatusPulses(status: WorkerDisplayStatus): boolean {
-	return status === "working" || status === "needs_you";
-}
-
-/**
- * Kanban attention zone, ordered by human-action urgency — ported from
- * agent-orchestrator's getAttentionLevel (packages/web/src/lib/types.ts),
- * collapsed to its default "simple" set and rebound to reverbcode's
- * {@link SessionStatus}. The board groups sessions into these columns so the
- * highest-ROrI work (a one-click merge) sits leftmost.
- */
-export type AttentionZone = "merge" | "action" | "pending" | "working" | "done";
-
-/** Columns left→right, most-urgent first. "done" is the archive column. */
-export const attentionZoneOrder: AttentionZone[] = ["merge", "action", "pending", "working", "done"];
-
-export const attentionZoneLabel: Record<AttentionZone, string> = {
-	merge: "Ready to merge",
-	action: "Needs you",
-	pending: "Pending",
-	working: "Working",
-	done: "Done",
-};
-
-export function attentionZone(session: WorkspaceSession): AttentionZone {
-	switch (session.status) {
-		// Terminal — archive.
-		case "merged":
-		case "terminated":
-			return "done";
-		// One click to clear — highest ROI, checked first.
-		case "approved":
-		case "mergeable":
-			return "merge";
-		// Agent waiting on a human (respond) or a problem to investigate (review);
-		// agent-orchestrator collapses these into one "action" zone by default.
-		case "needs_input":
-		case "ci_failed":
-		case "changes_requested":
-			return "action";
-		// Waiting on an external reviewer / CI — nothing to do right now.
-		case "review_pending":
-		case "pr_open":
-		case "draft":
-			return "pending";
-		// Agents doing their thing — don't interrupt.
-		case "working":
-		case "idle":
-		default:
-			return "working";
-	}
+	return !session.isTerminated;
 }
 
 export type WorkspaceSummary = {