Handle prompt-ready TTY completions

Author: Pyiner

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cctty"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 description = "Claude Agent SDK compatibility through the interactive Claude Code TTY"
 license = "MIT"

Cargo.toml

@@ -77,7 +77,7 @@ Download a release archive:
 
 ```sh
 curl -L -o cctty.tar.gz \
-  https://github.com/Pyiner/cctty/releases/download/v0.2.0/cctty-0.2.0-aarch64-apple-darwin.tar.gz
+  https://github.com/Pyiner/cctty/releases/download/v0.2.1/cctty-0.2.1-aarch64-apple-darwin.tar.gz
 tar -xzf cctty.tar.gz
 sudo install -m 0755 cctty /usr/local/bin/cctty
 ```
@@ -442,8 +442,8 @@ CCTTY_LIVE_SDK_GAME=1 cargo test --test sdk_integration live_typescript_sdk_buil
 The repository includes GitHub Actions for CI and tagged releases.
 
 ```sh
-git tag v0.2.0
-git push origin v0.2.0
+git tag v0.2.1
+git push origin v0.2.1
 ```
 
 The release workflow builds macOS and Linux archives and publishes SHA-256

README.md

@@ -85,7 +85,7 @@ brew install cctty
 
 ```sh
 curl -L -o cctty.tar.gz \
-  https://github.com/Pyiner/cctty/releases/download/v0.2.0/cctty-0.2.0-aarch64-apple-darwin.tar.gz
+  https://github.com/Pyiner/cctty/releases/download/v0.2.1/cctty-0.2.1-aarch64-apple-darwin.tar.gz
 tar -xzf cctty.tar.gz
 sudo install -m 0755 cctty /usr/local/bin/cctty
 ```
@@ -294,8 +294,8 @@ CCTTY_LIVE_SDK_GAME=1 cargo test --test sdk_integration live_typescript_sdk_buil
 仓库包含 GitHub Actions CI 和 tag release。发布新版本：
 
 ```sh
-git tag v0.2.0
-git push origin v0.2.0
+git tag v0.2.1
+git push origin v0.2.1
 ```
 
 Release workflow 会构建 macOS / Linux archive、生成 SHA-256，并在配置了

README.zh-CN.md

@@ -48,6 +48,7 @@ const MCP_PROXY_REQUEST_LINE_TIMEOUT: Duration = Duration::from_millis(250);
 const PTY_TERMINATE_TIMEOUT: Duration = Duration::from_secs(5);
 const TTY_SESSION_LOCK_RETRY_TIMEOUT: Duration = Duration::from_secs(8);
 const TTY_SESSION_LOCK_RETRY_DELAY: Duration = Duration::from_millis(300);
+const TTY_VISIBLE_COMPLETION_IDLE: Duration = Duration::from_secs(3);
 const RUN_TIMEOUT: Duration = Duration::from_secs(3600);
 
 pub async fn run(invocation: Invocation) -> Result<i32> {
@@ -1108,6 +1109,7 @@ async fn tail_until_complete(
     let mut tty_debug = TtyDebugLogger::new("text");
     let mut tail_progress = TailProgressLogger::new("text");
     let mut questions = TtyQuestionBridge::new(false);
+    let mut visible_progress = TtyVisibleProgress::new(process);
 
     loop {
         if started.elapsed() > RUN_TIMEOUT {
@@ -1156,6 +1158,7 @@ async fn tail_until_complete(
         {
             last_activity = Instant::now();
         }
+        visible_progress.observe(process);
         if !state.assistant_text.is_empty() && last_activity.elapsed() >= COMPLETION_IDLE {
             if output_format == OutputFormat::StreamJson && !state.saw_result {
                 let value = synthetic_result(&state, started.elapsed());
@@ -1167,6 +1170,20 @@ async fn tail_until_complete(
             emit_idle_session_state_if_requested(&mut state, output_format)?;
             return Ok(state);
         }
+        if state.assistant_text.is_empty()
+            && visible_progress.completed_without_transcript(process)
+            && last_activity.elapsed() >= COMPLETION_IDLE
+        {
+            if output_format == OutputFormat::StreamJson && !state.saw_result {
+                let value = synthetic_prompt_ready_result(&state, started.elapsed());
+                logging::event("tail_result source=synthetic_prompt_ready");
+                println!("{}", serde_json::to_string(&value)?);
+                std::io::stdout().flush()?;
+                state.apply(&value);
+            }
+            emit_idle_session_state_if_requested(&mut state, output_format)?;
+            return Ok(state);
+        }
         tail_progress.maybe_log(process, tail, &state, started.elapsed());
         tty_debug.maybe_log(process, started.elapsed());
         tokio::time::sleep(TRANSCRIPT_POLL).await;
@@ -1189,6 +1206,7 @@ async fn tail_until_complete_stream(
     let mut questions = TtyQuestionBridge::new(permission_prompt_tool_stdio);
     let mut tty_debug = TtyDebugLogger::new("stream");
     let mut tail_progress = TailProgressLogger::new("stream");
+    let mut visible_progress = TtyVisibleProgress::new(process);
 
     loop {
         if started.elapsed() > RUN_TIMEOUT {
@@ -1243,6 +1261,7 @@ async fn tail_until_complete_stream(
             permission.mark_ask_user_question_handled();
             last_activity = Instant::now();
         }
+        visible_progress.observe(process);
 
         if state.saw_result {
             logging::event("tail_result source=transcript stream=true");
@@ -1271,6 +1290,21 @@ async fn tail_until_complete_stream(
             emit_idle_session_state_if_requested(&mut state, output_format)?;
             return Ok(state);
         }
+        if state.assistant_text.is_empty()
+            && !permission.denied_current_turn()
+            && visible_progress.completed_without_transcript(process)
+            && last_activity.elapsed() >= COMPLETION_IDLE
+        {
+            if output_format == OutputFormat::StreamJson && !state.saw_result {
+                let value = synthetic_prompt_ready_result(&state, started.elapsed());
+                logging::event("tail_result source=synthetic_prompt_ready stream=true");
+                println!("{}", serde_json::to_string(&value)?);
+                std::io::stdout().flush()?;
+                state.apply(&value);
+            }
+            emit_idle_session_state_if_requested(&mut state, output_format)?;
+            return Ok(state);
+        }
         tail_progress.maybe_log(process, tail, &state, started.elapsed());
         tty_debug.maybe_log(process, started.elapsed());
         tokio::time::sleep(TRANSCRIPT_POLL).await;
@@ -1496,6 +1530,39 @@ impl TailProgressLogger {
     }
 }
 
+struct TtyVisibleProgress {
+    last_snapshot: String,
+    last_change: Instant,
+    saw_model_activity: bool,
+}
+
+impl TtyVisibleProgress {
+    fn new(process: &PtyProcess) -> Self {
+        Self {
+            last_snapshot: tty_progress_snapshot(process),
+            last_change: Instant::now(),
+            saw_model_activity: false,
+        }
+    }
+
+    fn observe(&mut self, process: &PtyProcess) {
+        let snapshot = tty_progress_snapshot(process);
+        if snapshot != self.last_snapshot {
+            self.last_snapshot = snapshot;
+            self.last_change = Instant::now();
+        }
+        if tty_output_has_visible_model_activity(&process.recent_output()) {
+            self.saw_model_activity = true;
+        }
+    }
+
+    fn completed_without_transcript(&self, process: &PtyProcess) -> bool {
+        self.saw_model_activity
+            && tty_wait_class(&process.recent_output()) == "prompt_ready"
+            && self.last_change.elapsed() >= TTY_VISIBLE_COMPLETION_IDLE
+    }
+}
+
 struct PermissionBridge {
     enabled: bool,
     requested_tool_use_ids: HashSet<String>,
@@ -3428,6 +3495,29 @@ fn tty_wait_class(output: &str) -> &'static str {
     "other"
 }
 
+fn tty_progress_snapshot(process: &PtyProcess) -> String {
+    compact_tty_output(&plain_tty_output(&process.recent_output()))
+}
+
+fn tty_output_has_visible_model_activity(output: &str) -> bool {
+    let output = plain_tty_output(output);
+    let compact = compact_tty_output(&output);
+    output.contains("⏺")
+        || output.contains("⎿")
+        || output.contains("Bash (")
+        || output.contains("Fetch (")
+        || output.contains("Edit (")
+        || output.contains("Write (")
+        || output.contains("Read (")
+        || output.contains("Wrote ")
+        || output.contains("thinking with")
+        || output.contains("thought for")
+        || output.contains("running stop hook")
+        || compact.contains("thinkingwith")
+        || compact.contains("thoughtfor")
+        || compact.contains("runningstophook")
+}
+
 fn tty_plan_approval_prompt_has_feedback_choice(output: &str) -> bool {
     let output = plain_tty_output(output);
     let compact = compact_tty_output(&output);
@@ -3507,6 +3597,26 @@ fn synthetic_result(state: &TranscriptState, duration: Duration) -> Value {
     })
 }
 
+fn synthetic_prompt_ready_result(state: &TranscriptState, duration: Duration) -> Value {
+    json!({
+        "type": "result",
+        "subtype": "success",
+        "duration_ms": duration.as_millis() as i64,
+        "duration_api_ms": 0,
+        "is_error": false,
+        "num_turns": 1,
+        "session_id": state.session_id.clone().unwrap_or_default(),
+        "result": "Claude returned to the terminal prompt without writing a transcript result.",
+        "stop_reason": "end_turn",
+        "usage": zero_usage(),
+        "total_cost_usd": 0.0,
+        "modelUsage": {},
+        "permission_denials": [],
+        "terminal_reason": "prompt_ready_without_transcript",
+        "fast_mode_state": "off",
+    })
+}
+
 fn synthetic_permission_denied_result(state: &TranscriptState, duration: Duration) -> Value {
     json!({
         "type": "result",

src/runner.rs

@@ -1,6 +1,6 @@
 use assert_cmd::Command;
 use serde_json::Value;
-use std::io::{BufRead, BufReader, Write};
+use std::io::{BufRead, BufReader, Read, Write};
 use std::process::Stdio;
 use std::time::{Duration, Instant};
 use wait_timeout::ChildExt;
@@ -1630,6 +1630,80 @@ fn stream_json_synthetic_result_emits_idle_and_accepts_followup() {
     assert!(status.success());
 }
 
+#[test]
+fn stream_json_synthesizes_result_when_tty_finishes_without_transcript() {
+    let fixture = FakeClaude::new();
+    let workspace = tempfile::tempdir().unwrap();
+    let config_dir = tempfile::tempdir().unwrap();
+    let session_id = "00000000-0000-0000-0000-000000000024";
+    let mut child = std::process::Command::new(env!("CARGO_BIN_EXE_cctty"))
+        .env("CCTTY_CLAUDE_PATH", fixture.path())
+        .env("CLAUDE_CONFIG_DIR", config_dir.path())
+        .current_dir(workspace.path())
+        .args([
+            "--output-format",
+            "stream-json",
+            "--input-format",
+            "stream-json",
+            "--session-id",
+            session_id,
+        ])
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    let mut stdin = child.stdin.take().unwrap();
+
+    writeln!(
+        stdin,
+        r#"{{"type":"user","message":{{"role":"user","content":"STDOUT_ONLY_FAKE_RESULT"}}}}"#
+    )
+    .unwrap();
+    drop(stdin);
+
+    let status = child
+        .wait_timeout(Duration::from_secs(10))
+        .unwrap()
+        .unwrap_or_else(|| {
+            let _ = child.kill();
+            panic!("cctty did not synthesize a prompt-ready result");
+        });
+    let mut stdout = String::new();
+    child
+        .stdout
+        .take()
+        .unwrap()
+        .read_to_string(&mut stdout)
+        .unwrap();
+    let mut stderr = String::new();
+    child
+        .stderr
+        .take()
+        .unwrap()
+        .read_to_string(&mut stderr)
+        .unwrap();
+
+    assert!(status.success(), "stderr:\n{stderr}");
+    let values = stdout
+        .lines()
+        .map(|line| serde_json::from_str::<Value>(line).unwrap())
+        .collect::<Vec<_>>();
+    let result = values
+        .iter()
+        .find(|value| value.get("type").and_then(Value::as_str) == Some("result"))
+        .expect("expected synthetic result");
+    assert_eq!(result["terminal_reason"], "prompt_ready_without_transcript");
+    assert!(
+        values.iter().any(|value| {
+            value["type"] == "system"
+                && value["subtype"] == "session_state_changed"
+                && value["state"] == "idle"
+        }),
+        "stdout:\n{stdout}"
+    );
+}
+
 #[test]
 fn stream_json_permission_prompt_stdio_bridges_can_use_tool_request() {
     let fixture = FakeClaude::new();

tests/cctty_cli.rs

@@ -627,6 +627,16 @@ while True:
             after += 1
         buf = buf[after:]
         continue
+    if "STDOUT_ONLY_FAKE_RESULT" in prompt:
+        sys.stdout.write("⏺ I inspected the repo and wrote conductor.json\n")
+        sys.stdout.write("⎿ Wrote 5 lines to conductor.json\n")
+        sys.stdout.write("Context permissions /mcp\n")
+        sys.stdout.flush()
+        after = end + len(b"\x1b[201~")
+        while after < len(buf) and buf[after:after + 1] in (b"\r", b"\n"):
+            after += 1
+        buf = buf[after:]
+        continue
     with transcript.open("a", encoding="utf-8") as f:
         f.write(json.dumps({"type":"system","subtype":"init","session_id":session_id}) + "\n")
         f.write(json.dumps({"type":"user","message":{"role":"user","content":prompt}}) + "\n")