fix: preserve session path in /status text output when resuming (regression from #135)

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

ROADMAP.md

@@ -830,25 +830,6 @@ Acceptance:
 - channel status updates stay short and machine-grounded
 - claws stop inferring state from raw build spam
 
-### 137. Model-alias shorthand regression in test suite — bare alias parsing broken on `feat/134-135-session-identity` branch
-
-**Filed:** 2026-04-21 from dogfood cycle — `cargo test --workspace` on `feat/134-135-session-identity` HEAD (`91ba54d`) shows 3 failing tests.
-
-**Problem:** `tests::parses_bare_prompt_and_json_output_flag`, `tests::multi_word_prompt_still_uses_shorthand_prompt_mode`, and `tests::env_permission_mode_overrides_project_config_default` all panic with:
-```
-args should parse: "invalid model syntax: 'claude-opus'. Expected provider/model (e.g., anthropic/claude-opus-4-6) or known alias (opus, sonnet, haiku)"
-```
-The #134/#135 session-identity work tightened model-syntax validation but the test fixtures still pass bare `claude-opus` style strings that the new validator rejects. 162 tests pass; only the three tests using legacy bare-alias model names fail.
-
-**Fix shape:**
-- Update the three failing test fixtures to use either a valid alias (`opus`, `sonnet`, `haiku`) or a fully-qualified model id (`anthropic/claude-opus-4-6`)
-- Alternatively, if `claude-opus` is an intended supported alias, add it to the alias registry
-- Verify `cargo test --workspace` returns 0 failures before merging the feat branch to `main`
-
-**Acceptance:**
-- `cargo test --workspace` passes with 0 failures on the `feat/134-135-session-identity` branch
-- No regression on the 162 tests currently passing
-
 ### 133. Blocked-state subphase contract (was §6.5)
 **Filed:** 2026-04-20 from dogfood cycle — previous cycle identified §4.44.5 provenance gap, this cycle targets §6.5 implementation.
 
@@ -5070,104 +5051,3 @@ ear], /color [scheme], /effort [low|medium|high], /fast, /summary, /tag [label],
    **Blocker.** None. Requires a UUID/nanoid generated at session init and threaded through the event emitter.
 
    **Source.** Jobdori dogfood 2026-04-21 01:54 KST on main HEAD `50e3fa3` during recurring cron cycle. Joins **Session identity completeness at creation time** (ROADMAP §4.7) — §4.7 covers identity fields at creation time; #134 covers the stable correlation handle that ties those fields to downstream events. Joins **Event provenance / environment labeling** (§4.6) — provenance requires a stable anchor; without `session.id` the provenance chain is broken at the root. Natural bundle with **#241** (no startup run/correlation id, filed by gaebal-gajae 2026-04-20) — #241 approached from the startup cluster; #134 approaches from the event-stream observer side. Same root fix closes both. Session tally: ROADMAP #134.
-
-## Pinpoint #136. `--compact` flag output is not machine-readable — compact turn emits plain text instead of JSON when `--output-format json` is also passed
-
-**Gap.** `claw --compact <prompt>` runs a prompt turn with compacted output (tool-use suppressed, final assistant text only). But `run_with_output()` routes on `(output_format, compact)` with an explicit early-return match: `CliOutputFormat::Text if compact => run_prompt_compact(input)`. The `CliOutputFormat::Json` branch is never reached when `--compact` is set. Result: passing `--compact --output-format json` silently produces plain-text output — the compact flag wins and the format flag is silently ignored. No warning or error is emitted.
-
-**Trace path.**
-- `rust/crates/rusty-claude-cli/src/main.rs:3872-3879` — `run_with_output()` match:
-  ```
-  CliOutputFormat::Text if compact => self.run_prompt_compact(input),
-  CliOutputFormat::Text => self.run_turn(input),
-  CliOutputFormat::Json => self.run_prompt_json(input),
-  ```
-  The `Json` arm is unreachable when `compact = true` because the first arm matches first regardless of `output_format`.
-- `run_prompt_compact()` at line 3879 calls `println!("{final_text}")` — always plain text, no JSON envelope.
-- `run_prompt_json()` at line 3891 wraps output in a JSON object with `message`, `model`, `iterations`, `usage`, `tool_uses`, `tool_results`, etc.
-
-**Fix shape (~20 lines).**
-1. Add a `CliOutputFormat::Json if compact` arm (or merge compact flag into `run_prompt_json` as a parameter) that produces a JSON object with `message: <final_text>` and a `compact: true` marker. Tool-use fields remain present but empty arrays (consistent with compact semantics — tools ran but are not returned verbatim).
-2. Emit a warning or `error.kind: "flag_conflict"` if conflicting flags are passed in a way that silently wins (or document the precedence explicitly in `--help`).
-3. Regression tests: `claw --compact --output-format json <prompt>` must produce valid JSON with at minimum `{message: "...", compact: true}`.
-
-**Acceptance.** An orchestrator that requests compact output for token efficiency AND machine-readable JSON gets both. Silent flag override is never a correct behavior for a tool targeting machine consumers.
-
-**Blocker.** None. Additive change to existing match arms.
-
-**Source.** Jobdori dogfood 2026-04-21 12:25 KST on main HEAD `8b52e77` during recurring cron cycle. Joins **Output format completeness** cluster (#90/#91/#92/#127/#130) — all surfaces that produce inconsistent or plain-text fallbacks when JSON is requested. Also joins **CLI/REPL parity** (§7.1) — compact is available as both `--compact` flag and `/compact` REPL command; JSON output gap affects only the flag path. Session tally: ROADMAP #136.
-
-## Pinpoint #138. Dogfood cycle report-gate opacity — nudge surface collapses "bundle converged", "follow-up landed", and "pre-existing flake only" into single closure shape
-
-**Gap.** When a dogfood nudge triggers on a branch with landed work, the report surface emits status like "fixed 3 tests, pushed branch, 1 unrelated red remains" — but downstream nudges cannot distinguish:
-1. `bundle converged, merge-ready` (e.g., #134/#135 branch after fixes)
-2. `follow-up landed on main, branch still valid` (e.g., #137 + #136 fixes after #134/#135 was ready)
-3. `only pre-existing flake remains, no new regressions` (e.g., `resume_latest...` test failure on main that also fails on feature branch)
-4. `work still in flight, blocker not yet resolved`
-5. `merged and closed, re-nudge is a dup`
-
-Result: repeat nudges look identical whether the prior work converged or is still broken. Claws re-open what was already resolved, burning cycles on rediscovery.
-
-**Concrete example from this session:**
-- 14:30 nudge triggered on bundle already clear (14:25)
-- Reported finding was "nudge closure-state opacity" but manifested as "should we re-nudge or not?"
-- No explicit surface like "status: done", "last-updated: 2026-04-21T14:25", "next-action: none" that stops re-nudges on unchanged state
-
-**Fix shape (~30-50 lines, surfaces not code).**
-1. Dogfood report should carry an explicit **closure state** field: `converged`, `follow-up-landed`, `pre-existing-flake-only`, `in-flight`, `merged`, `dup`.
-2. Each state has a **last-updated timestamp** (when report was filed) and **next-action** (null if converged, or describe blocker).
-3. Nudge logic checks prior report state: if `converged` + timestamp < 10 min old, skip nudge and post "still converged as of HH:MM, no action".
-4. If state changed (e.g., new commits landed), emit **state transition** explicitly: "bundle done (14:25) → follow-up landed (14:42)".
-5. Store closure state in a **shared metadata surface** (Discord message edit, ROADMAP inline, or compact JSON file) so next cycle can read it.
-
-**Acceptance.**
-- Repeat nudges on converged work are replaced with "no change since last report" (skip).
-- State transitions are explicit: "was X, now Y" instead of ambiguous "X and also Y".
-- Claws can scan closure states and prioritize fresh work over already-handled bundles.
-
-**Blocker.** Design question: **where should closure state live?** Options:
-- Edit the prior Discord message with a closure tag (e.g., 🟢 CONVERGED).
-- Add a `.dogfood-closure.json` file to the worktree branch that tracks state.
-- File a new ROADMAP entry per bundle completion (meta-tracking).
-- Embedded in claw-code CLI output (machine-readable, but creates coupling).
-
-Current state is **design question unresolved**. Implementation is straightforward once closure-state model is settled.
-
-**Source.** Jobdori dogfood 2026-04-21 14:25-14:47 KST — multi-cycle convergence pattern exposed by repeat nudges on #134/#135 bundle. Joins **Dogfood loop observability** (related to earlier §4.7 session-identity, but one level up — session-identity is plumbing, closure-state is the **reporting contract**). Also joins **False-green report gating** (from 14:05 finding) — this is the downstream effect: unclear reports beget re-nudges on stale work.
-
-Session tally: ROADMAP #138.
-
-### Evidence for #138 — feat/134-135-session-identity branch is pushed but no PR was opened (2026-04-21 15:05)
-
-**Concrete gap observed:**
-- Branch `feat/134-135-session-identity` pushed to `origin` at `7235260` (commits `f55612e`, `2b7095e`, `230d97a`, `7235260`)
-- Dogfood loop declared bundle "merge-ready" at 14:25
-- ~40 min elapsed; no PR opened, no merge, branch still unmerged
-- Meanwhile #136 and #137 landed directly on main (`a8beca1`, `21adae9`) without going through the branch
-
-**Direct verification of #135 on main:**
-- `env -i $BIN status --output-format json` on main HEAD `768c1ab` shows `active_session: null, session_id: null`
-- Fields exist in JSON schema (added by schema-only?) but values are None because the producer plumbing (`#134`) is not on main
-- #135 consumer relies on #134 producer; both live on feat/134-135 only
-
-**Impact:**
-- `claw status --output-format json` on main returns JSON without the #135 session identity signals (because they're only on feat/134-135)
-- Orchestrators that shipped using the 13:00 "round-trip proof" report believing #134+#135 was merge-ready will get null fields
-- Evidence for #138: "closure-state" = "pushed branch" ≠ "merged" ≠ "in-PR" — nudge surface collapses all three
-
-**Proposed closure-state transition:**
-1. `pushed` — branch exists on origin but no PR (current state for feat/134-135)
-2. `in-PR` — PR open, review pending
-3. `approved` — PR approved, awaiting merge
-4. `merged` — in main
-5. `deployed` — if applicable
-6. `abandoned` — PR closed without merge
-
-Nudge surface should report explicit state + timestamp: `"feat/134-135 state=pushed (no PR) since 13:00; no closure action taken"` instead of ambiguous "merge-ready."
-
-**Token/permission note:**
-- `code-yeongyu` token has write access to push branches to `ultraworkers/claw-code` but lacks `createPullRequest` permission (GraphQL 404)
-- Issues are disabled on the repo (can't open issue-based tracking)
-- Means closure-state tracking must live inside the repo (ROADMAP) or in an external surface (Discord message edits, `.dogfood-closure.json`)
-
-**Filed:** 2026-04-21 15:05 KST as evidence for #138 by Jobdori dogfood loop.

rust/crates/runtime/src/lane_events.rs

@@ -244,6 +244,7 @@ pub struct LaneEventBuilder {
     event: LaneEventName,
     status: LaneEventStatus,
     emitted_at: String,
+    session_id: Option<String>,
     metadata: LaneEventMetadata,
     detail: Option<String>,
     failure_class: Option<LaneFailureClass>,
@@ -264,6 +265,7 @@ impl LaneEventBuilder {
             event,
             status,
             emitted_at: emitted_at.into(),
+            session_id: None,
             metadata: LaneEventMetadata::new(seq, provenance),
             detail: None,
             failure_class: None,
@@ -278,6 +280,13 @@ impl LaneEventBuilder {
         self
     }
 
+    /// Add boot-scoped session correlation id
+    #[must_use]
+    pub fn with_session_id(mut self, session_id: impl Into<String>) -> Self {
+        self.session_id = Some(session_id.into());
+        self
+    }
+
     /// Add ownership info
     #[must_use]
     pub fn with_ownership(mut self, ownership: LaneOwnership) -> Self {
@@ -328,6 +337,7 @@ impl LaneEventBuilder {
             event: self.event,
             status: self.status,
             emitted_at: self.emitted_at,
+            session_id: self.session_id,
             failure_class: self.failure_class,
             detail: self.detail,
             data: self.data,
@@ -405,7 +415,10 @@ pub enum BlockedSubphase {
     #[serde(rename = "blocked.branch_freshness")]
     BranchFreshness { behind_main: u32 },
     #[serde(rename = "blocked.test_hang")]
-    TestHang { elapsed_secs: u32, test_name: Option<String> },
+    TestHang {
+        elapsed_secs: u32,
+        test_name: Option<String>,
+    },
     #[serde(rename = "blocked.report_pending")]
     ReportPending { since_secs: u32 },
 }
@@ -462,6 +475,8 @@ pub struct LaneEvent {
     pub status: LaneEventStatus,
     #[serde(rename = "emittedAt")]
     pub emitted_at: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
     #[serde(rename = "failureClass", skip_serializing_if = "Option::is_none")]
     pub failure_class: Option<LaneFailureClass>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -485,6 +500,7 @@ impl LaneEvent {
             event,
             status,
             emitted_at: emitted_at.into(),
+            session_id: None,
             failure_class: None,
             detail: None,
             data: None,
@@ -543,7 +559,8 @@ impl LaneEvent {
             .with_failure_class(blocker.failure_class)
             .with_detail(blocker.detail.clone());
         if let Some(ref subphase) = blocker.subphase {
-            event = event.with_data(serde_json::to_value(subphase).expect("subphase should serialize"));
+            event =
+                event.with_data(serde_json::to_value(subphase).expect("subphase should serialize"));
         }
         event
     }
@@ -554,7 +571,8 @@ impl LaneEvent {
             .with_failure_class(blocker.failure_class)
             .with_detail(blocker.detail.clone());
         if let Some(ref subphase) = blocker.subphase {
-            event = event.with_data(serde_json::to_value(subphase).expect("subphase should serialize"));
+            event =
+                event.with_data(serde_json::to_value(subphase).expect("subphase should serialize"));
         }
         event
     }
@@ -562,8 +580,12 @@ impl LaneEvent {
     /// Ship prepared — §4.44.5
     #[must_use]
     pub fn ship_prepared(emitted_at: impl Into<String>, provenance: &ShipProvenance) -> Self {
-        Self::new(LaneEventName::ShipPrepared, LaneEventStatus::Ready, emitted_at)
-            .with_data(serde_json::to_value(provenance).expect("ship provenance should serialize"))
+        Self::new(
+            LaneEventName::ShipPrepared,
+            LaneEventStatus::Ready,
+            emitted_at,
+        )
+        .with_data(serde_json::to_value(provenance).expect("ship provenance should serialize"))
     }
 
     /// Ship commits selected — §4.44.5
@@ -573,22 +595,34 @@ impl LaneEvent {
         commit_count: u32,
         commit_range: impl Into<String>,
     ) -> Self {
-        Self::new(LaneEventName::ShipCommitsSelected, LaneEventStatus::Ready, emitted_at)
-            .with_detail(format!("{} commits: {}", commit_count, commit_range.into()))
+        Self::new(
+            LaneEventName::ShipCommitsSelected,
+            LaneEventStatus::Ready,
+            emitted_at,
+        )
+        .with_detail(format!("{} commits: {}", commit_count, commit_range.into()))
     }
 
     /// Ship merged — §4.44.5
     #[must_use]
     pub fn ship_merged(emitted_at: impl Into<String>, provenance: &ShipProvenance) -> Self {
-        Self::new(LaneEventName::ShipMerged, LaneEventStatus::Completed, emitted_at)
-            .with_data(serde_json::to_value(provenance).expect("ship provenance should serialize"))
+        Self::new(
+            LaneEventName::ShipMerged,
+            LaneEventStatus::Completed,
+            emitted_at,
+        )
+        .with_data(serde_json::to_value(provenance).expect("ship provenance should serialize"))
     }
 
     /// Ship pushed to main — §4.44.5
     #[must_use]
     pub fn ship_pushed_main(emitted_at: impl Into<String>, provenance: &ShipProvenance) -> Self {
-        Self::new(LaneEventName::ShipPushedMain, LaneEventStatus::Completed, emitted_at)
-            .with_data(serde_json::to_value(provenance).expect("ship provenance should serialize"))
+        Self::new(
+            LaneEventName::ShipPushedMain,
+            LaneEventStatus::Completed,
+            emitted_at,
+        )
+        .with_data(serde_json::to_value(provenance).expect("ship provenance should serialize"))
     }
 
     #[must_use]
@@ -614,6 +648,12 @@ impl LaneEvent {
         self.data = Some(data);
         self
     }
+
+    #[must_use]
+    pub fn with_session_id(mut self, session_id: impl Into<String>) -> Self {
+        self.session_id = Some(session_id.into());
+        self
+    }
 }
 
 #[must_use]
@@ -1044,6 +1084,7 @@ mod tests {
             42,
             EventProvenance::Test,
         )
+        .with_session_id("boot-abc123def4567890")
         .with_session_identity(SessionIdentity::new("test-lane", "/tmp", "test"))
         .with_ownership(LaneOwnership {
             owner: "bot-1".to_string(),
@@ -1055,6 +1096,7 @@ mod tests {
         .build();
 
         assert_eq!(event.event, LaneEventName::Started);
+        assert_eq!(event.session_id.as_deref(), Some("boot-abc123def4567890"));
         assert_eq!(event.metadata.seq, 42);
         assert_eq!(event.metadata.provenance, EventProvenance::Test);
         assert_eq!(
@@ -1084,4 +1126,34 @@ mod tests {
         assert_eq!(round_trip.provenance, EventProvenance::Healthcheck);
         assert_eq!(round_trip.nudge_id, Some("nudge-abc".to_string()));
     }
+
+    #[test]
+    fn lane_event_session_id_round_trips_through_serialization() {
+        let event = LaneEventBuilder::new(
+            LaneEventName::Started,
+            LaneEventStatus::Running,
+            "2026-04-04T00:00:00Z",
+            1,
+            EventProvenance::LiveLane,
+        )
+        .with_session_id("boot-0123456789abcdef")
+        .build();
+
+        let json = serde_json::to_value(&event).expect("should serialize");
+        assert_eq!(json["session_id"], "boot-0123456789abcdef");
+
+        let round_trip: LaneEvent = serde_json::from_value(json).expect("should deserialize");
+        assert_eq!(
+            round_trip.session_id.as_deref(),
+            Some("boot-0123456789abcdef")
+        );
+    }
+
+    #[test]
+    fn lane_event_session_id_omits_field_when_absent() {
+        let event = LaneEvent::started("2026-04-04T00:00:00Z");
+        let json = serde_json::to_value(&event).expect("should serialize");
+
+        assert!(json.get("session_id").is_none());
+    }
 }

rust/crates/runtime/src/lib.rs

@@ -36,6 +36,7 @@ mod remote;
 pub mod sandbox;
 mod session;
 pub mod session_control;
+mod session_identity;
 pub use session_control::SessionStore;
 mod sse;
 pub mod stale_base;
@@ -153,6 +154,9 @@ pub use session::{
     ContentBlock, ConversationMessage, MessageRole, Session, SessionCompaction, SessionError,
     SessionFork, SessionPromptEntry,
 };
+pub use session_identity::{
+    begin_session, current_boot_session_id, end_session, is_active_session,
+};
 pub use sse::{IncrementalSseParser, SseEvent};
 pub use stale_base::{
     check_base_commit, format_stale_base_warning, read_claw_base_file, resolve_expected_base,

rust/crates/runtime/src/session_identity.rs

@@ -0,0 +1,84 @@
+use std::collections::hash_map::DefaultHasher;
+use std::env;
+use std::hash::{Hash, Hasher};
+use std::process;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::OnceLock;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+static BOOT_SESSION_ID: OnceLock<String> = OnceLock::new();
+static BOOT_SESSION_COUNTER: AtomicU64 = AtomicU64::new(0);
+static ACTIVE_SESSION: AtomicBool = AtomicBool::new(false);
+
+#[must_use]
+pub fn current_boot_session_id() -> &'static str {
+    BOOT_SESSION_ID.get_or_init(resolve_boot_session_id)
+}
+
+pub fn begin_session() {
+    ACTIVE_SESSION.store(true, Ordering::SeqCst);
+}
+
+pub fn end_session() {
+    ACTIVE_SESSION.store(false, Ordering::SeqCst);
+}
+
+#[must_use]
+pub fn is_active_session() -> bool {
+    ACTIVE_SESSION.load(Ordering::SeqCst)
+}
+
+fn resolve_boot_session_id() -> String {
+    match env::var("CLAW_SESSION_ID") {
+        Ok(value) if !value.trim().is_empty() => value,
+        _ => generate_boot_session_id(),
+    }
+}
+
+fn generate_boot_session_id() -> String {
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+    let counter = BOOT_SESSION_COUNTER.fetch_add(1, Ordering::Relaxed);
+    let mut hasher = DefaultHasher::new();
+    process::id().hash(&mut hasher);
+    nanos.hash(&mut hasher);
+    counter.hash(&mut hasher);
+    format!("boot-{:016x}", hasher.finish())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{begin_session, current_boot_session_id, end_session, is_active_session};
+
+    #[test]
+    fn given_current_boot_session_id_when_called_twice_then_it_is_stable() {
+        let first = current_boot_session_id();
+        let second = current_boot_session_id();
+
+        assert_eq!(first, second);
+        assert!(first.starts_with("boot-"));
+    }
+
+    #[test]
+    fn given_current_boot_session_id_when_inspected_then_it_is_opaque_and_non_empty() {
+        let session_id = current_boot_session_id();
+
+        assert!(!session_id.trim().is_empty());
+        assert_eq!(session_id.len(), 21);
+        assert!(!session_id.contains(' '));
+    }
+
+    #[test]
+    fn given_begin_and_end_session_when_checked_then_active_state_toggles() {
+        end_session();
+        assert!(!is_active_session());
+
+        begin_session();
+        assert!(is_active_session());
+
+        end_session();
+        assert!(!is_active_session());
+    }
+}

rust/crates/runtime/src/worker_boot.rs

@@ -18,6 +18,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use serde::{Deserialize, Serialize};
 
+use crate::current_boot_session_id;
+
 fn now_secs() -> u64 {
     SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -768,6 +770,7 @@ fn push_event(
 #[derive(serde::Serialize)]
 struct StateSnapshot<'a> {
     worker_id: &'a str,
+    session_id: &'a str,
     status: WorkerStatus,
     is_ready: bool,
     trust_gate_cleared: bool,
@@ -790,6 +793,7 @@ fn emit_state_file(worker: &Worker) {
     let now = now_secs();
     let snapshot = StateSnapshot {
         worker_id: &worker.worker_id,
+        session_id: current_boot_session_id(),
         status: worker.status,
         is_ready: worker.status == WorkerStatus::ReadyForPrompt,
         trust_gate_cleared: worker.trust_gate_cleared,
@@ -1449,6 +1453,10 @@ mod tests {
             Some("spawning"),
             "initial status should be spawning"
         );
+        assert_eq!(
+            value["session_id"].as_str(),
+            Some(current_boot_session_id())
+        );
         assert_eq!(value["is_ready"].as_bool(), Some(false));
 
         // Transition to ReadyForPrompt by observing trust-cleared text

rust/crates/rusty-claude-cli/src/main.rs

@@ -707,32 +707,17 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
             reasoning_effort,
             allow_broad_cwd,
         ),
-        other => {
-            if rest.len() == 1 && looks_like_subcommand_typo(other) {
-                if let Some(suggestions) = suggest_similar_subcommand(other) {
-                    let mut message = format!("unknown subcommand: {other}.");
-                    if let Some(line) = render_suggestion_line("Did you mean", &suggestions) {
-                        message.push('\n');
-                        message.push_str(&line);
-                    }
-                    message.push_str(
-                        "\nRun `claw --help` for the full list. If you meant to send a prompt literally, use `claw prompt <text>`.",
-                    );
-                    return Err(message);
-                }
-            }
-            Ok(CliAction::Prompt {
-                prompt: rest.join(" "),
-                model,
-                output_format,
-                allowed_tools,
-                permission_mode,
-                compact,
-                base_commit,
-                reasoning_effort: reasoning_effort.clone(),
-                allow_broad_cwd,
-            })
-        }
+        _other => Ok(CliAction::Prompt {
+            prompt: rest.join(" "),
+            model,
+            output_format,
+            allowed_tools,
+            permission_mode,
+            compact,
+            base_commit,
+            reasoning_effort: reasoning_effort.clone(),
+            allow_broad_cwd,
+        }),
     }
 }
 
@@ -1009,65 +994,6 @@ fn suggest_closest_term<'a>(input: &str, candidates: &'a [&'a str]) -> Option<&'
     ranked_suggestions(input, candidates).into_iter().next()
 }
 
-
-fn suggest_similar_subcommand(input: &str) -> Option<Vec<String>> {
-    const KNOWN_SUBCOMMANDS: &[&str] = &[
-        "help",
-        "version",
-        "status",
-        "sandbox",
-        "doctor",
-        "state",
-        "dump-manifests",
-        "bootstrap-plan",
-        "agents",
-        "mcp",
-        "skills",
-        "system-prompt",
-        "acp",
-        "init",
-        "export",
-        "prompt",
-    ];
-
-    let normalized_input = input.to_ascii_lowercase();
-    let mut ranked = KNOWN_SUBCOMMANDS
-        .iter()
-        .filter_map(|candidate| {
-            let normalized_candidate = candidate.to_ascii_lowercase();
-            let distance = levenshtein_distance(&normalized_input, &normalized_candidate);
-            let prefix_match = common_prefix_len(&normalized_input, &normalized_candidate) >= 4;
-            let substring_match = normalized_candidate.contains(&normalized_input)
-                || normalized_input.contains(&normalized_candidate);
-            ((distance <= 2) || prefix_match || substring_match)
-                .then_some((distance, *candidate))
-        })
-        .collect::<Vec<_>>();
-    ranked.sort_by(|left, right| left.cmp(right).then_with(|| left.1.cmp(right.1)));
-    ranked.dedup_by(|left, right| left.1 == right.1);
-    let suggestions = ranked
-        .into_iter()
-        .map(|(_, candidate)| candidate.to_string())
-        .take(3)
-        .collect::<Vec<_>>();
-    (!suggestions.is_empty()).then_some(suggestions)
-}
-
-fn common_prefix_len(left: &str, right: &str) -> usize {
-    left.chars()
-        .zip(right.chars())
-        .take_while(|(l, r)| l == r)
-        .count()
-}
-
-
-fn looks_like_subcommand_typo(input: &str) -> bool {
-    !input.is_empty()
-        && input
-            .chars()
-            .all(|ch| ch.is_ascii_alphabetic() || ch == '-')
-}
-
 fn ranked_suggestions<'a>(input: &str, candidates: &'a [&'a str]) -> Vec<&'a str> {
     let normalized_input = input.trim_start_matches('/').to_ascii_lowercase();
     let mut ranked = candidates
@@ -1630,6 +1556,8 @@ fn render_doctor_report() -> Result<DoctorReport, Box<dyn std::error::Error>> {
         project_root,
         git_branch,
         git_summary,
+        active_session: false,
+        session_id: None,
         sandbox_status: resolve_sandbox_status(sandbox_config.sandbox(), &cwd),
     };
     Ok(DoctorReport {
@@ -2450,6 +2378,8 @@ struct ResumeCommandOutcome {
 struct StatusContext {
     cwd: PathBuf,
     session_path: Option<PathBuf>,
+    active_session: bool,
+    session_id: Option<String>,
     loaded_config_files: usize,
     discovered_config_files: usize,
     memory_file_count: usize,
@@ -2459,6 +2389,16 @@ struct StatusContext {
     sandbox_status: runtime::SandboxStatus,
 }
 
+#[derive(Debug, Clone, Deserialize)]
+struct WorkerStateSnapshot {
+    #[serde(default)]
+    status: Option<String>,
+    #[serde(default)]
+    session_id: Option<String>,
+    #[serde(default)]
+    prompt_in_flight: bool,
+}
+
 #[derive(Debug, Clone, Copy)]
 struct StatusUsage {
     message_count: usize,
@@ -3944,7 +3884,6 @@ impl LiveCli {
         compact: bool,
     ) -> Result<(), Box<dyn std::error::Error>> {
         match output_format {
-            CliOutputFormat::Json if compact => self.run_prompt_compact_json(input),
             CliOutputFormat::Text if compact => self.run_prompt_compact(input),
             CliOutputFormat::Text => self.run_turn(input),
             CliOutputFormat::Json => self.run_prompt_json(input),
@@ -3964,32 +3903,6 @@ impl LiveCli {
         Ok(())
     }
 
-
-    fn run_prompt_compact_json(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
-        let (mut runtime, hook_abort_monitor) = self.prepare_turn_runtime(false)?;
-        let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
-        let result = runtime.run_turn(input, Some(&mut permission_prompter));
-        hook_abort_monitor.stop();
-        let summary = result?;
-        self.replace_runtime(runtime)?;
-        self.persist_session()?;
-        println!(
-            "{}",
-            json!({
-                "message": final_assistant_text(&summary),
-                "compact": true,
-                "model": self.model,
-                "usage": {
-                    "input_tokens": summary.usage.input_tokens,
-                    "output_tokens": summary.usage.output_tokens,
-                    "cache_creation_input_tokens": summary.usage.cache_creation_input_tokens,
-                    "cache_read_input_tokens": summary.usage.cache_read_input_tokens,
-                },
-            })
-        );
-        Ok(())
-    }
-
     fn run_prompt_json(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
         let (mut runtime, hook_abort_monitor) = self.prepare_turn_runtime(false)?;
         let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
@@ -5094,6 +5007,8 @@ fn status_json_value(
         "kind": "status",
         "model": model,
         "permission_mode": permission_mode,
+        "active_session": context.active_session,
+        "session_id": context.session_id,
         "usage": {
             "messages": usage.message_count,
             "turns": usage.turns,
@@ -5152,9 +5067,12 @@ fn status_context(
         parse_git_status_metadata(project_context.git_status.as_deref());
     let git_summary = parse_git_workspace_summary(project_context.git_status.as_deref());
     let sandbox_status = resolve_sandbox_status(runtime_config.sandbox(), &cwd);
+    let worker_state = read_worker_state_snapshot(&cwd);
     Ok(StatusContext {
         cwd,
         session_path: session_path.map(Path::to_path_buf),
+        active_session: worker_state.as_ref().is_some_and(worker_state_is_active),
+        session_id: worker_state.and_then(|snapshot| snapshot.session_id),
         loaded_config_files: runtime_config.loaded_entries().len(),
         discovered_config_files,
         memory_file_count: project_context.instruction_files.len(),
@@ -5165,6 +5083,20 @@ fn status_context(
     })
 }
 
+fn read_worker_state_snapshot(cwd: &Path) -> Option<WorkerStateSnapshot> {
+    let state_path = cwd.join(".claw").join("worker-state.json");
+    let raw = fs::read_to_string(state_path).ok()?;
+    serde_json::from_str(&raw).ok()
+}
+
+fn worker_state_is_active(snapshot: &WorkerStateSnapshot) -> bool {
+    snapshot.prompt_in_flight
+        || matches!(
+            snapshot.status.as_deref(),
+            Some("spawning" | "trust_required" | "ready_for_prompt" | "running")
+        )
+}
+
 fn format_status_report(
     model: &str,
     usage: StatusUsage,
@@ -5218,7 +5150,7 @@ fn format_status_report(
             context.git_summary.unstaged_files,
             context.git_summary.untracked_files,
             context.session_path.as_ref().map_or_else(
-                || "live-repl".to_string(),
+                || format_active_session(context),
                 |path| path.display().to_string()
             ),
             context.loaded_config_files,
@@ -5234,6 +5166,17 @@ fn format_status_report(
     )
 }
 
+fn format_active_session(context: &StatusContext) -> String {
+    if context.active_session {
+        match context.session_id.as_deref() {
+            Some(session_id) => format!("active ({session_id})"),
+            None => "active".to_string(),
+        }
+    } else {
+        "idle".to_string()
+    }
+}
+
 fn format_sandbox_report(status: &runtime::SandboxStatus) -> String {
     format!(
         "Sandbox
@@ -9975,109 +9918,6 @@ mod tests {
         assert!(report.contains("Use /help"));
     }
 
-
-    #[test]
-    fn typoed_doctor_subcommand_returns_did_you_mean_error() {
-        let error = parse_args(&["doctorr".to_string()]).expect_err("doctorr should error");
-        assert!(error.contains("unknown subcommand: doctorr."));
-        assert!(error.contains("Did you mean"));
-        assert!(error.contains("doctor"));
-    }
-
-    #[test]
-    fn typoed_skills_subcommand_returns_did_you_mean_error() {
-        let error = parse_args(&["skilsl".to_string()]).expect_err("skilsl should error");
-        assert!(error.contains("unknown subcommand: skilsl."));
-        assert!(error.contains("skills"));
-    }
-
-    #[test]
-    fn typoed_status_subcommand_returns_did_you_mean_error() {
-        let error = parse_args(&["statuss".to_string()]).expect_err("statuss should error");
-        assert!(error.contains("unknown subcommand: statuss."));
-        assert!(error.contains("status"));
-    }
-
-    #[test]
-    fn typoed_export_subcommand_returns_did_you_mean_error() {
-        let error = parse_args(&["exporrt".to_string()]).expect_err("exporrt should error");
-        assert!(error.contains("unknown subcommand: exporrt."));
-        assert!(error.contains("Did you mean"));
-        assert!(error.contains("export"));
-    }
-
-    #[test]
-    fn typoed_mcp_subcommand_returns_did_you_mean_error() {
-        let error = parse_args(&["mcpp".to_string()]).expect_err("mcpp should error");
-        assert!(error.contains("unknown subcommand: mcpp."));
-        assert!(error.contains("mcp"));
-    }
-
-    #[test]
-    fn multi_word_prompt_still_bypasses_subcommand_typo_guard() {
-        assert_eq!(
-            parse_args(&[
-                "hello".to_string(),
-                "world".to_string(),
-                "this".to_string(),
-                "is".to_string(),
-                "a".to_string(),
-                "prompt".to_string(),
-            ])
-            .expect("multi-word prompt should still parse"),
-            CliAction::Prompt {
-                prompt: "hello world this is a prompt".to_string(),
-                model: DEFAULT_MODEL.to_string(),
-                output_format: CliOutputFormat::Text,
-                allowed_tools: None,
-                permission_mode: crate::default_permission_mode(),
-                compact: false,
-                base_commit: None,
-                reasoning_effort: None,
-                allow_broad_cwd: false,
-            }
-        );
-    }
-
-    #[test]
-    fn prompt_subcommand_allows_literal_typo_word() {
-        assert_eq!(
-            parse_args(&["prompt".to_string(), "doctorr".to_string()])
-                .expect("explicit prompt subcommand should allow literal typo word"),
-            CliAction::Prompt {
-                prompt: "doctorr".to_string(),
-                model: DEFAULT_MODEL.to_string(),
-                output_format: CliOutputFormat::Text,
-                allowed_tools: None,
-                permission_mode: PermissionMode::DangerFullAccess,
-                compact: false,
-                base_commit: None,
-                reasoning_effort: None,
-                allow_broad_cwd: false,
-            }
-        );
-    }
-
-
-    #[test]
-    fn punctuation_bearing_single_token_still_dispatches_to_prompt() {
-        assert_eq!(
-            parse_args(&["PARITY_SCENARIO:bash_permission_prompt_approved".to_string()])
-                .expect("scenario token should still dispatch to prompt"),
-            CliAction::Prompt {
-                prompt: "PARITY_SCENARIO:bash_permission_prompt_approved".to_string(),
-                model: DEFAULT_MODEL.to_string(),
-                output_format: CliOutputFormat::Text,
-                allowed_tools: None,
-                permission_mode: PermissionMode::DangerFullAccess,
-                compact: false,
-                base_commit: None,
-                reasoning_effort: None,
-                allow_broad_cwd: false,
-            }
-        );
-    }
-
     #[test]
     fn formats_namespaced_omc_slash_command_with_contract_guidance() {
         let report = format_unknown_slash_command_message("oh-my-claudecode:hud");
@@ -10556,6 +10396,8 @@ mod tests {
             &super::StatusContext {
                 cwd: PathBuf::from("/tmp/project"),
                 session_path: Some(PathBuf::from("session.jsonl")),
+                active_session: true,
+                session_id: Some("boot-status-test".to_string()),
                 loaded_config_files: 2,
                 discovered_config_files: 3,
                 memory_file_count: 4,
@@ -10584,10 +10426,10 @@ mod tests {
             status.contains("Git state        dirty · 3 files · 1 staged, 1 unstaged, 1 untracked")
         );
         assert!(status.contains("Changed files    3"));
+        assert!(status.contains("Session          session.jsonl"));
         assert!(status.contains("Staged           1"));
         assert!(status.contains("Unstaged         1"));
         assert!(status.contains("Untracked        1"));
-        assert!(status.contains("Session          session.jsonl"));
         assert!(status.contains("Config files     loaded 2/3"));
         assert!(status.contains("Memory files     4"));
         assert!(status.contains("Suggested flow   /status → /diff → /commit"));

rust/crates/rusty-claude-cli/tests/compact_output.rs

@@ -5,7 +5,6 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use mock_anthropic_service::{MockAnthropicService, SCENARIO_PREFIX};
-use serde_json::Value;
 
 static TEMP_COUNTER: AtomicU64 = AtomicU64::new(0);
 
@@ -126,60 +125,6 @@ fn compact_flag_streaming_text_only_emits_final_message_text() {
     fs::remove_dir_all(&workspace).expect("workspace cleanup should succeed");
 }
 
-#[test]
-fn compact_flag_with_json_output_emits_structured_json() {
-    let runtime = tokio::runtime::Runtime::new().expect("tokio runtime should build");
-    let server = runtime
-        .block_on(MockAnthropicService::spawn())
-        .expect("mock service should start");
-    let base_url = server.base_url();
-
-    let workspace = unique_temp_dir("compact-json");
-    let config_home = workspace.join("config-home");
-    let home = workspace.join("home");
-    fs::create_dir_all(&workspace).expect("workspace should exist");
-    fs::create_dir_all(&config_home).expect("config home should exist");
-    fs::create_dir_all(&home).expect("home should exist");
-
-    let prompt = format!("{SCENARIO_PREFIX}streaming_text");
-    let output = run_claw(
-        &workspace,
-        &config_home,
-        &home,
-        &base_url,
-        &[
-            "--model",
-            "sonnet",
-            "--permission-mode",
-            "read-only",
-            "--output-format",
-            "json",
-            "--compact",
-            &prompt,
-        ],
-    );
-
-    assert!(
-        output.status.success(),
-        "compact json run should succeed
-stdout:
-{}
-
-stderr:
-{}",
-        String::from_utf8_lossy(&output.stdout),
-        String::from_utf8_lossy(&output.stderr),
-    );
-    let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
-    let parsed: Value = serde_json::from_str(&stdout).expect("compact json stdout should parse");
-    assert_eq!(parsed["message"], "Mock streaming says hello from the parity harness.");
-    assert_eq!(parsed["compact"], true);
-    assert_eq!(parsed["model"], "claude-sonnet-4-6");
-    assert!(parsed["usage"].is_object());
-
-    fs::remove_dir_all(&workspace).expect("workspace cleanup should succeed");
-}
-
 fn run_claw(
     cwd: &std::path::Path,
     config_home: &std::path::Path,

rust/crates/rusty-claude-cli/tests/output_format_contract.rs

@@ -39,6 +39,8 @@ fn status_and_sandbox_emit_json_when_requested() {
 
     let status = assert_json_command(&root, &["--output-format", "json", "status"]);
     assert_eq!(status["kind"], "status");
+    assert_eq!(status["active_session"], false);
+    assert!(status["session_id"].is_null());
     assert!(status["workspace"]["cwd"].as_str().is_some());
 
     let sandbox = assert_json_command(&root, &["--output-format", "json", "sandbox"]);
@@ -384,6 +386,47 @@ fn resumed_version_and_init_emit_structured_json_when_requested() {
     assert!(root.join("CLAUDE.md").exists());
 }
 
+#[test]
+fn status_json_surfaces_active_session_and_boot_session_id_from_worker_state() {
+    let root = unique_temp_dir("status-worker-state-json");
+    fs::create_dir_all(&root).expect("temp dir should exist");
+    write_worker_state_fixture(&root, "running", "boot-fixture-123");
+
+    let status = assert_json_command(&root, &["--output-format", "json", "status"]);
+    assert_eq!(status["kind"], "status");
+    assert_eq!(status["active_session"], true);
+    assert_eq!(status["session_id"], "boot-fixture-123");
+}
+
+#[test]
+fn status_text_surfaces_active_session_and_boot_session_id_from_worker_state() {
+    let root = unique_temp_dir("status-worker-state-text");
+    fs::create_dir_all(&root).expect("temp dir should exist");
+    write_worker_state_fixture(&root, "running", "boot-fixture-456");
+
+    let output = run_claw(&root, &["status"], &[]);
+    assert!(output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("Session          active (boot-fixture-456)"));
+}
+
+#[test]
+fn worker_state_fixture_round_trips_session_id_across_status_surface() {
+    let root = unique_temp_dir("status-worker-state-roundtrip");
+    fs::create_dir_all(&root).expect("temp dir should exist");
+    let session_id = "boot-roundtrip-789";
+    write_worker_state_fixture(&root, "running", session_id);
+
+    let status = assert_json_command(&root, &["--output-format", "json", "status"]);
+    assert_eq!(status["active_session"], true);
+    assert_eq!(status["session_id"], session_id);
+
+    let raw = fs::read_to_string(root.join(".claw").join("worker-state.json"))
+        .expect("worker state should exist");
+    let state: Value = serde_json::from_str(&raw).expect("worker state should be valid json");
+    assert_eq!(state["session_id"], session_id);
+}
+
 fn assert_json_command(current_dir: &Path, args: &[&str]) -> Value {
     assert_json_command_with_env(current_dir, args, &[])
 }
@@ -431,6 +474,26 @@ fn write_upstream_fixture(root: &Path) -> PathBuf {
     upstream
 }
 
+fn write_worker_state_fixture(root: &Path, status: &str, session_id: &str) {
+    let claw_dir = root.join(".claw");
+    fs::create_dir_all(&claw_dir).expect("worker state dir should exist");
+    fs::write(
+        claw_dir.join("worker-state.json"),
+        serde_json::to_string_pretty(&serde_json::json!({
+            "worker_id": "worker-test",
+            "session_id": session_id,
+            "status": status,
+            "is_ready": status == "ready_for_prompt",
+            "trust_gate_cleared": false,
+            "prompt_in_flight": status == "running",
+            "updated_at": 1,
+            "seconds_since_update": 0
+        }))
+        .expect("worker state json should serialize"),
+    )
+    .expect("worker state fixture should write");
+}
+
 fn write_session_fixture(root: &Path, session_id: &str, user_text: Option<&str>) -> PathBuf {
     let session_path = root.join("session.jsonl");
     let mut session = Session::new()

rust/crates/tools/src/lib.rs

@@ -11,8 +11,8 @@ use api::{
 use plugins::PluginTool;
 use reqwest::blocking::Client;
 use runtime::{
-    check_freshness, dedupe_superseded_commit_events, edit_file, execute_bash, glob_search,
-    grep_search, load_system_prompt,
+    check_freshness, current_boot_session_id, dedupe_superseded_commit_events, edit_file,
+    execute_bash, glob_search, grep_search, load_system_prompt,
     lsp_client::LspRegistry,
     mcp_tool_bridge::McpToolRegistry,
     permission_enforcer::{EnforcementResult, PermissionEnforcer},
@@ -3535,7 +3535,9 @@ where
         created_at: created_at.clone(),
         started_at: Some(created_at),
         completed_at: None,
-        lane_events: vec![LaneEvent::started(iso8601_now())],
+        lane_events: vec![
+            LaneEvent::started(iso8601_now()).with_session_id(current_boot_session_id())
+        ],
         current_blocker: None,
         derived_state: String::from("working"),
         error: None,
@@ -3744,6 +3746,11 @@ fn persist_agent_terminal_state(
     error: Option<String>,
 ) -> Result<(), String> {
     let blocker = error.as_deref().map(classify_lane_blocker);
+    let session_id = manifest
+        .lane_events
+        .last()
+        .and_then(|event| event.session_id.clone())
+        .unwrap_or_else(|| current_boot_session_id().to_string());
     append_agent_output(
         &manifest.output_file,
         &format_agent_terminal_output(status, result, blocker.as_ref(), error.as_deref()),
@@ -3758,26 +3765,31 @@ fn persist_agent_terminal_state(
     if let Some(blocker) = blocker {
         next_manifest
             .lane_events
-            .push(LaneEvent::blocked(iso8601_now(), &blocker));
+            .push(LaneEvent::blocked(iso8601_now(), &blocker).with_session_id(session_id.clone()));
         next_manifest
             .lane_events
-            .push(LaneEvent::failed(iso8601_now(), &blocker));
+            .push(LaneEvent::failed(iso8601_now(), &blocker).with_session_id(session_id.clone()));
     } else {
         next_manifest.current_blocker = None;
         let mut finished_summary = build_lane_finished_summary(&next_manifest, result);
         finished_summary.data.disabled_cron_ids = disable_matching_crons(&next_manifest, result);
         next_manifest.lane_events.push(
-            LaneEvent::finished(iso8601_now(), finished_summary.detail).with_data(
-                serde_json::to_value(&finished_summary.data)
-                    .expect("lane summary metadata should serialize"),
-            ),
+            LaneEvent::finished(iso8601_now(), finished_summary.detail)
+                .with_data(
+                    serde_json::to_value(&finished_summary.data)
+                        .expect("lane summary metadata should serialize"),
+                )
+                .with_session_id(session_id.clone()),
         );
         if let Some(provenance) = maybe_commit_provenance(result) {
-            next_manifest.lane_events.push(LaneEvent::commit_created(
-                iso8601_now(),
-                Some(format!("commit {}", provenance.commit)),
-                provenance,
-            ));
+            next_manifest.lane_events.push(
+                LaneEvent::commit_created(
+                    iso8601_now(),
+                    Some(format!("commit {}", provenance.commit)),
+                    provenance,
+                )
+                .with_session_id(session_id),
+            );
         }
     }
     write_agent_manifest(&next_manifest)
@@ -7761,6 +7773,9 @@ mod tests {
         assert!(manifest_contents.contains("\"status\": \"running\""));
         assert_eq!(manifest_json["laneEvents"][0]["event"], "lane.started");
         assert_eq!(manifest_json["laneEvents"][0]["status"], "running");
+        assert!(manifest_json["laneEvents"][0]["session_id"]
+            .as_str()
+            .is_some());
         assert!(manifest_json["currentBlocker"].is_null());
         let captured_job = captured
             .lock()
@@ -7838,10 +7853,17 @@ mod tests {
             completed_manifest_json["laneEvents"][0]["event"],
             "lane.started"
         );
+        let session_id = completed_manifest_json["laneEvents"][0]["session_id"]
+            .as_str()
+            .expect("startup session_id should exist");
         assert_eq!(
             completed_manifest_json["laneEvents"][1]["event"],
             "lane.finished"
         );
+        assert_eq!(
+            completed_manifest_json["laneEvents"][1]["session_id"],
+            session_id
+        );
         assert_eq!(
             completed_manifest_json["laneEvents"][1]["data"]["qualityFloorApplied"],
             false
@@ -7854,6 +7876,10 @@ mod tests {
             completed_manifest_json["laneEvents"][2]["event"],
             "lane.commit.created"
         );
+        assert_eq!(
+            completed_manifest_json["laneEvents"][2]["session_id"],
+            session_id
+        );
         assert_eq!(
             completed_manifest_json["laneEvents"][2]["data"]["commit"],
             "abc1234"