fix(runtime): restore empty Codex and Claude session startup

Materialize new Codex threads through native metadata and verify durable history before publishing a usable session or attaching the native TUI, without submitting a model turn.

Allow transcript-free Claude recovery for positively empty jobs with zero output-token usage while retaining strict validation for existing or unknown history.

Add shared Actor/Analyst persistence regressions and offline native-terminal cold-resume probes; synchronize lifecycle fixtures and runtime contracts.

Author: ChesterRa

crates/cccc-daemon/src/ops/codex_voice_analyst/claude.rs

@@ -233,11 +233,13 @@ fn known_empty_session(config_dir: &Path, session_id: &str) -> io::Result<bool>
         found = true;
         // Positive empty-job evidence, not just a missing transcript. Any
         // prompt, output, consumed bytes or published path requires history.
+        // Agent View can initialize its output-token counter to zero; zero
+        // usage is not evidence of a conversation. Retain nonzero/unknown usage.
         if state["intent"].as_str() != Some("")
             || state["linkScanOffset"].as_u64() != Some(0)
             || !state["linkScanPath"].is_null()
             || state.get("output") != Some(&Value::Null)
-            || !state["tokens"].is_null()
+            || !(state["tokens"].is_null() || state["tokens"].as_f64() == Some(0.0))
         {
             return Ok(false);
         }
@@ -1580,12 +1582,19 @@ mod tests {
         cccc_core::fs::write_json(&job.join("state.json"), &empty).expect("empty state");
         assert!(known_empty_session(temp.path(), id).expect("empty"));
         assert!(!known_empty_session(temp.path(), "other").expect("unknown"));
+        let mut counted_empty = empty.clone();
+        counted_empty["tokens"] = json!(0);
+        cccc_core::fs::write_json(&job.join("state.json"), &counted_empty)
+            .expect("initialized empty counter");
+        assert!(known_empty_session(temp.path(), id).expect("zero usage is still empty"));
         for (field, value) in [
             ("intent", json!("first prompt")),
             ("linkScanOffset", json!(42)),
             ("linkScanPath", json!("missing-history.jsonl")),
             ("output", json!("answer")),
             ("tokens", json!(1)),
+            ("tokens", json!("0")),
+            ("tokens", json!(-1)),
         ] {
             let mut state = empty.clone();
             state[field] = value;

crates/cccc-daemon/src/ops/codex_voice_analyst/launch_codex.rs

@@ -128,6 +128,38 @@ impl AnalystSession {
                 "Codex app-server resumed a different thread",
             ));
         }
+        if !thread_resumed {
+            // thread/start reserves an id/path but does not persist an empty
+            // rollout. Native TUI resume needs that rollout, even on the same
+            // app-server. Naming the new thread materializes it without a model
+            // turn or synthetic conversation item; never rename resumed history.
+            let name = match purpose {
+                SessionPurpose::Actor => "CCCC Actor",
+                SessionPurpose::VoiceAnalyst => "CCCC Voice Analyst",
+            };
+            protocol
+                .request(
+                    "thread/name/set",
+                    json!({"threadId":thread_id,"name":name}),
+                    Duration::from_secs(20),
+                )
+                .await?;
+            let persisted = protocol
+                .request(
+                    "thread/read",
+                    json!({"threadId":thread_id,"includeTurns":true}),
+                    Duration::from_secs(20),
+                )
+                .await?;
+            if persisted["thread"]["id"].as_str() != Some(thread_id.as_str())
+                || !persisted["thread"]["turns"].is_array()
+            {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "Codex did not expose the new thread's durable history for terminal resume",
+                ));
+            }
+        }
         Ok(Self {
             #[cfg(test)]
             binding,

crates/cccc-daemon/src/ops/codex_voice_analyst/tests/live_claude.rs

@@ -199,13 +199,21 @@ async fn live_claude_empty_session_resumes_without_a_prompt() {
     let config_dir = temp.path().join("claude");
     configure_isolated_claude(&config_dir);
     let mut thread_id = None;
+    let group_id = uuid::Uuid::new_v4().simple().to_string();
     for _ in 0..3 {
         let mut config = LaunchConfig::new(&root);
         config.runtime = ActorRuntime::Claude;
         config.environment.insert(
             "CLAUDE_CONFIG_DIR".into(),
             config_dir.to_string_lossy().into_owned(),
         );
+        config.environment.extend([
+            ("ANTHROPIC_BASE_URL".into(), "http://127.0.0.1:9".into()),
+            (
+                "ANTHROPIC_AUTH_TOKEN".into(),
+                "cccc-local-input-test".into(),
+            ),
+        ]);
         config.resume_thread_id = thread_id.clone();
         let session = AnalystSession::launch(&home, config)
             .await
@@ -214,10 +222,53 @@ async fn live_claude_empty_session_resumes_without_a_prompt() {
             assert_eq!(session.thread_id(), expected);
         }
         thread_id = Some(session.thread_id().to_owned());
+        let attached = cccc_runtime::start(cccc_runtime::LaunchSpec {
+            group_id: group_id.clone(),
+            actor_id: "empty-claude".into(),
+            runner: cccc_contracts::RunnerKind::Pty,
+            command: session.actor_tui_command(),
+            cwd: root.clone(),
+            env: session.tui_environment(),
+            cols: 120,
+            rows: 40,
+        });
+        let ready = if attached.is_ok() {
+            tokio::task::block_in_place(|| {
+                cccc_runtime::wait_for_input_ready(
+                    &group_id,
+                    "empty-claude",
+                    Duration::from_secs(10),
+                    &std::sync::atomic::AtomicBool::new(false),
+                )
+            })
+        } else {
+            Ok(false)
+        };
         session
             .stop(session.generation())
             .await
             .expect("stop empty session");
+        cccc_runtime::stop(&group_id, "empty-claude").expect("stop empty terminal");
+        attached.expect("attach empty native terminal");
+        assert!(ready.expect("terminal readiness"));
+        // The real worker need not publish its zero counter before stopping.
+        // Model that valid Agent View refresh in this isolated, stopped job so
+        // every cold resume exercises tokens=0, not just provisional null.
+        for job in std::fs::read_dir(config_dir.join("jobs")).expect("jobs") {
+            let job = job.expect("job");
+            if !job.file_type().expect("type").is_dir() {
+                continue;
+            }
+            let path = job.path().join("state.json");
+            let mut state: serde_json::Value = cccc_core::fs::read_json(&path).expect("state");
+            if state["sessionId"].as_str() == Some(session.thread_id()) {
+                assert!(state["tokens"].is_null() || state["tokens"] == 0);
+                assert!(state["linkScanPath"].is_null());
+                assert_eq!(state["intent"], "");
+                state["tokens"] = serde_json::json!(0);
+                cccc_core::fs::write_json(&path, &state).expect("zero-usage metadata");
+            }
+        }
     }
 }
 

crates/cccc-daemon/src/ops/codex_voice_analyst/tests/live_session.rs

@@ -4,6 +4,174 @@ use super::live_support::{
 };
 use cccc_core::HomeLayout;
 
+/// Offline real-CLI probe: no credentials, model request, or synthetic prompt.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn live_codex_empty_actor_and_analyst_resume_with_native_terminal() {
+    use futures_util::FutureExt as _;
+    use serde_json::json;
+    use std::time::Duration;
+
+    if std::env::var("CCCC_CODEX_EMPTY_LIVE").as_deref() != Ok("1") {
+        return;
+    }
+    let temp = tempfile::tempdir().expect("tempdir");
+    let home = HomeLayout::from_path(temp.path().join("home")).expect("home");
+    home.initialize().expect("initialize");
+    let root = temp.path().join("project");
+    let codex_home = temp.path().join("codex");
+    std::fs::create_dir_all(&root).expect("project");
+    std::fs::create_dir_all(&codex_home).expect("Codex home");
+    let group = cccc_core::GroupStore::new(home.clone())
+        .expect("store")
+        .create("Empty Codex startup probe", "")
+        .expect("group");
+    let environment = BTreeMap::from([
+        (
+            "CODEX_HOME".into(),
+            codex_home.to_string_lossy().into_owned(),
+        ),
+        ("TERM".into(), "xterm-256color".into()),
+    ]);
+    let command = vec![
+        std::env::var("CCCC_CODEX_EXECUTABLE").unwrap_or_else(|_| "codex".into()),
+        "-c".into(),
+        "model_provider=\"offline-probe\"".into(),
+        "-c".into(),
+        "model_providers.offline-probe.name=\"Offline probe\"".into(),
+        "-c".into(),
+        "model_providers.offline-probe.base_url=\"http://127.0.0.1:9\"".into(),
+        "-c".into(),
+        "model_providers.offline-probe.wire_api=\"responses\"".into(),
+    ];
+    for purpose in [SessionPurpose::Actor, SessionPurpose::VoiceAnalyst] {
+        let mut thread_id = None;
+        for cycle in 0..3 {
+            let session = match purpose {
+                SessionPurpose::Actor => {
+                    AnalystSession::launch_actor(
+                        &home,
+                        ActorLaunchConfig {
+                            workdir: root.clone(),
+                            group_id: group.group_id.clone(),
+                            actor_id: "empty-codex".into(),
+                            runtime: ActorRuntime::Codex,
+                            command: command.clone(),
+                            environment: environment.clone(),
+                        },
+                    )
+                    .await
+                }
+                SessionPurpose::VoiceAnalyst => {
+                    AnalystSession::launch(
+                        &home,
+                        LaunchConfig {
+                            workdir: root.clone(),
+                            runtime: ActorRuntime::Codex,
+                            command: command.clone(),
+                            environment: environment.clone(),
+                            resume_thread_id: thread_id.clone(),
+                        },
+                    )
+                    .await
+                }
+            }
+            .expect("launch empty managed session");
+            let observed = std::panic::AssertUnwindSafe(async {
+                if let Some(expected) = &thread_id {
+                    assert_eq!(session.thread_id(), expected);
+                    assert!(session.thread_resumed);
+                }
+                let ManagedProtocol::Codex(protocol) = &session.protocol else {
+                    unreachable!()
+                };
+                let read = protocol
+                    .request(
+                        "thread/read",
+                        json!({"threadId":session.thread_id(),"includeTurns":true}),
+                        Duration::from_secs(5),
+                    )
+                    .await?;
+                assert_eq!(read["thread"]["id"], session.thread_id());
+                assert_eq!(
+                    read["thread"]["turns"],
+                    json!([]),
+                    "startup must not run a model"
+                );
+                assert!(
+                    std::path::Path::new(read["thread"]["path"].as_str().expect("rollout path"))
+                        .is_file()
+                );
+                if cycle == 0 {
+                    protocol
+                        .request(
+                            "thread/name/set",
+                            json!({"threadId":session.thread_id(),"name":"User chosen name"}),
+                            Duration::from_secs(5),
+                        )
+                        .await?;
+                } else {
+                    assert_eq!(
+                        read["thread"]["name"], "User chosen name",
+                        "resume must not rename history"
+                    );
+                }
+                cccc_runtime::start(cccc_runtime::LaunchSpec {
+                    group_id: group.group_id.clone(),
+                    actor_id: "empty-codex".into(),
+                    runner: cccc_contracts::RunnerKind::Pty,
+                    command: session.actor_tui_command(),
+                    cwd: root.clone(),
+                    env: session.tui_environment(),
+                    cols: 120,
+                    rows: 40,
+                })
+                .map_err(io::Error::other)?;
+                let ready = tokio::task::block_in_place(|| {
+                    cccc_runtime::wait_for_input_ready(
+                        &group.group_id,
+                        "empty-codex",
+                        Duration::from_secs(10),
+                        &std::sync::atomic::AtomicBool::new(false),
+                    )
+                })
+                .map_err(io::Error::other)?;
+                assert!(ready, "native terminal did not initialize");
+                tokio::time::sleep(Duration::from_secs(1)).await;
+                let output = cccc_runtime::retained_history(&group.group_id, "empty-codex")
+                    .map_err(io::Error::other)?
+                    .data;
+                assert!(!output.contains("Failed to resume session"), "{output}");
+                assert!(!output.contains("no rollout found"), "{output}");
+                assert!(
+                    cccc_runtime::status(&group.group_id, "empty-codex")
+                        .map_err(io::Error::other)?
+                        .running
+                );
+                let read = protocol
+                    .request(
+                        "thread/read",
+                        json!({"threadId":session.thread_id(),"includeTurns":true}),
+                        Duration::from_secs(5),
+                    )
+                    .await?;
+                assert_eq!(read["thread"]["turns"], json!([]));
+                Ok::<(), io::Error>(())
+            })
+            .catch_unwind()
+            .await;
+            thread_id = Some(session.thread_id().to_owned());
+            let _ = cccc_runtime::stop(&group.group_id, "empty-codex");
+            session
+                .stop(session.generation())
+                .await
+                .expect("stop empty managed session");
+            observed
+                .expect("startup probe assertion")
+                .expect("durable empty session and native attach");
+        }
+    }
+}
+
 fn live_launch_config(root: &std::path::Path) -> LaunchConfig {
     let mut config = LaunchConfig::new(root);
     let model = std::env::var("CCCC_VOICE_ANALYST_MODEL").unwrap_or_else(|_| "gpt-5.6-sol".into());