@team-agent/installer 0.3.24 → 0.3.25

package/crates/team-agent/src/tmux_backend.rs

@@ -927,6 +927,51 @@ fn capture_has_pasted_content_prompt(text: &str) -> bool {
 const PASTED_CONTENT_APPEAR_POLLS: u32 = 5;
 const PASTED_CONTENT_SUBMIT_ATTEMPTS: u32 = 3;
 
+/// E46 (0.3.24 bug#5): bounded resend cap for post-Enter consumption probe.
+/// Mirrors PASTED_CONTENT_SUBMIT_ATTEMPTS shape: try Enter then bounded
+/// re-checks of the pane's input region. Each iteration first re-checks that
+/// the input still has content before resending Enter — guards against double
+/// submission when the first Enter was consumed but our readback was slow.
+const POST_SUBMIT_CONSUMPTION_ATTEMPTS: u32 = 3;
+const POST_SUBMIT_CONSUMPTION_POLL_MS: u64 = 60;
+
+/// E46 (0.3.24 bug#5, C5 provider-agnostic detector): the pane's input region
+/// is "consumed" when the token text that was just visible BEFORE the Enter
+/// is no longer present in the captured tail. Structural signal — no
+/// provider-specific UI string. Works across claude / codex / copilot because
+/// every provider's composer clears the input area after a successful submit
+/// (the content scrolls into history, leaving the prompt empty).
+///
+/// Returns:
+///   * `Some(true)`  — token was visible BEFORE submit and is GONE from
+///     the visible input area now → consumption confirmed.
+///   * `Some(false)` — token still visible (or other reason to think not yet
+///     consumed).
+///   * `None` — payload has no token marker (peer message without token,
+///     empty payload) so we can't structurally check; caller treats this as
+///     non-blocking (the pre-existing `EnterSentWithoutPlaceholderCheck`
+///     path).
+fn post_submit_input_consumed(
+    backend: &TmuxBackend,
+    target: &Target,
+    payload: &InjectPayload,
+) -> Result<Option<bool>, TransportError> {
+    let Some(marker) = payload_token_marker(payload) else {
+        return Ok(None);
+    };
+    let captured = backend.capture(target, CaptureRange::Tail(30))?;
+    // The token may legitimately appear in scrollback (a successful submit
+    // pushes it into history). We only treat the BOTTOM-of-pane region (last
+    // few lines, where the input area lives) as the consumption signal. Tail
+    // 30 lines is small enough that the input area still dominates if the
+    // submit didn't go through, while a successful submit has pushed the
+    // token marker out of the bottom 5 lines by the time the response
+    // composer redraws.
+    let tail_lines: Vec<&str> = captured.text.lines().rev().take(5).collect();
+    let token_in_tail = tail_lines.iter().any(|line| line.contains(marker));
+    Ok(Some(!token_in_tail))
+}
+
 fn shell_command(
     argv: &[String],
     cwd: &Path,
@@ -1117,11 +1162,94 @@ impl Transport for TmuxBackend {
                 // downgrade to CaptureMissingToken.
                 token_visible_for_report =
                     pre_submit_token_visible(self, target, payload).unwrap_or(None);
+                // E46 (0.3.24 bug#5, demo-director卡 bracketed paste root cause):
+                // bracketed-paste-mode on a fresh provider TUI swallows the framework's
+                // Enter as paste content. Send `Escape` first to exit the paste bracket
+                // so the subsequent Enter is interpreted as submit. Safe across
+                // claude/codex/copilot: Escape on an empty composer is a no-op
+                // (cancel any pending mode), it only matters when bracketed-paste is
+                // actually open. Architect-approved + macmini real-machine verified.
+                // Only Enter benefits — explicit menu navigation (Key::Down etc.)
+                // should not pre-cancel mode.
+                if bracketed
+                    && matches!(payload, InjectPayload::Text(_))
+                    && matches!(submit, Key::Enter)
+                {
+                    let escape_argv = tmux_send_keys_argv(&pane, &[Key::Escape]);
+                    // We don't fail the whole inject on Escape error — Escape failure
+                    // would surface downstream as the same SubmitConsumptionUnverified
+                    // when post-Enter probe still sees the token in the input region.
+                    let _ = self.run_inject_stage(&escape_argv, InjectStage::Submit);
+                }
                 self.run_inject_stage(&submit_argv, InjectStage::Submit)?;
                 if matches!(token_visible_for_report, Some(false)) {
                     token_visible_for_report =
                         post_submit_token_visible(self, target, payload).unwrap_or(Some(false));
                 }
+                // E46 C2 + C3: post-Enter consumption gate with bounded resend cap.
+                // Only fires for:
+                //   - submit key == Enter (other keys like Down/Up are explicit
+                //     menu navigation; codex uses `Down Enter` to dismiss a
+                //     prompt — those carry their own verification semantics
+                //     via KeySentAfterVisibleToken),
+                //   - token-bearing Text payloads (the structural input-empty
+                //     signal needs a token marker to anchor on).
+                // Each iteration RE-CHECKS that the input still contains the
+                // token BEFORE resending Enter — guards against the C3
+                // double-submit hazard when the first Enter was consumed but
+                // our readback was slow to catch the empty-input state.
+                let mut consumption_attempts: u32 = 1;
+                let mut consumed = if matches!(submit, Key::Enter) {
+                    post_submit_input_consumed(self, target, payload).unwrap_or(None)
+                } else {
+                    None
+                };
+                if matches!(consumed, Some(false)) {
+                    for _ in 1..POST_SUBMIT_CONSUMPTION_ATTEMPTS {
+                        std::thread::sleep(Duration::from_millis(
+                            POST_SUBMIT_CONSUMPTION_POLL_MS,
+                        ));
+                        // C3 critical: re-check BEFORE resending. If the input
+                        // is now empty (= first Enter actually consumed, just
+                        // observable now), DO NOT resend — bumping a spurious
+                        // empty Enter would open an empty turn.
+                        consumed = post_submit_input_consumed(self, target, payload)
+                            .unwrap_or(None);
+                        if !matches!(consumed, Some(false)) {
+                            break;
+                        }
+                        consumption_attempts += 1;
+                        let _ = self.run_inject_stage(&submit_argv, InjectStage::Submit);
+                    }
+                }
+                let submit_verification = match consumed {
+                    // Consumption confirmed → MUST-10 path: keep the canonical
+                    // EnterSentWithoutPlaceholderCheck so the existing
+                    // provider_submit_verification_red contract holds.
+                    Some(true) => SubmitVerification::EnterSentWithoutPlaceholderCheck,
+                    // Consumption explicitly NOT observed (token still in tail
+                    // after resend cap) → E46's new variant. Delivery treats
+                    // as not delivered.
+                    Some(false) => SubmitVerification::SubmitConsumptionUnverified,
+                    // No structural anchor (non-token payload) → preserve the
+                    // historic non-checked variant; the pre-existing
+                    // pre/post-submit token readback + U1 #7 cover the other
+                    // false-positive (silent paste drop).
+                    None => submit_verification_for_key(submit),
+                };
+                return Ok(InjectReport {
+                    stage_reached: InjectStage::Submit,
+                    inject_verification: inject_verification_after_readback(
+                        payload,
+                        token_visible_for_report,
+                    ),
+                    submit_verification,
+                    turn_verification: match payload {
+                        InjectPayload::Empty => TurnVerification::NotRequired,
+                        InjectPayload::Text(_) => TurnVerification::NotYetObserved,
+                    },
+                    attempts: consumption_attempts,
+                });
             }
         }
         Ok(InjectReport {

package/crates/team-agent/src/transport.rs

@@ -157,6 +157,13 @@ pub enum Key {
     Char(char),
     /// `\x03`。
     CtrlC,
+    /// E46 (0.3.24 bug#5): pre-submit Escape to exit bracketed-paste mode on
+    /// fresh provider TUIs (claude). When a bracketed paste lands on a TUI
+    /// whose composer is still initialising, the framework's plain `Enter`
+    /// gets interpreted as paste content, not submit. Sending `Escape` first
+    /// closes the paste bracket so the subsequent `Enter` submits.
+    /// Real-machine truth source: macmini demo-director repro.
+    Escape,
     /// tmux `-X cancel` / `q` / `d`;非 tmux 后端无 copy-mode 概念 → no-op。
     CancelMode,
 }
@@ -287,7 +294,10 @@ pub enum InjectVerification {
 /// `{key}_sent_after_visible_token` 是模板 → 用携带 Key 的 variant 表达。
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum SubmitVerification {
-    /// `enter_sent_without_placeholder_check`。
+    /// `enter_sent_without_placeholder_check`。MUST-10:此 variant 代表 paste+Enter
+    /// 完成且无需 placeholder probe(纯 peer 消息路径)。**保留** ⇒ delivered 语义;
+    /// E46 后只有 post-Enter consumption 确认通过(input 清空 / Working 信号)才返回
+    /// 此 variant — fresh TUI 未消费走 [`Self::SubmitConsumptionUnverified`]。
     EnterSentWithoutPlaceholderCheck,
     /// `pasted_content_prompt_absent_after_submit`。
     PastedContentPromptAbsentAfterSubmit,
@@ -297,6 +307,14 @@ pub enum SubmitVerification {
     KeySentAfterVisibleToken { key: Key },
     /// `send_keys_failed`。
     SendKeysFailed,
+    /// E46 (0.3.24 bug#5, demo-director 卡 bracketed paste): Enter 已发但
+    /// post-Enter 接收侧消费信号(input 行清空 / provider 进 Working)在 bounded
+    /// resend 上限内未观察到。**delivery 不当作 delivered**;走 submitted_unverified /
+    /// failed 路径。区别于
+    /// [`Self::PastedContentPromptStillPresentAfterSubmit`](claude paste-prompt
+    /// 折叠场景)— 本 variant 是结构化 input-empty 检测,适配 demo-director
+    /// 直接渲染文本路径。
+    SubmitConsumptionUnverified,
 }
 
 /// turn-boundary 观测(tmux_io.py:224-260,09-transport.md 表 §40)。
@@ -621,6 +639,10 @@ pub fn tmux_key_name(key: Key) -> &'static str {
         Key::Char('8') => "8",
         Key::Char('9') => "9",
         Key::CtrlC => "C-c",
+        // E46 (0.3.24 bug#5): tmux supports `Escape` as a key name; sending
+        // it as a send-keys arg emits `\x1b` to the pane (closes bracketed
+        // paste mode on a stuck TUI composer).
+        Key::Escape => "Escape",
         Key::CancelMode | Key::Char(_) => "",
     }
 }
@@ -850,6 +872,9 @@ pub fn submit_verification_wire(v: SubmitVerification) -> String {
             format!("{}_sent_after_visible_token", tmux_key_name(key))
         }
         SubmitVerification::SendKeysFailed => "send_keys_failed".to_string(),
+        SubmitVerification::SubmitConsumptionUnverified => {
+            "submit_consumption_unverified".to_string()
+        }
     }
 }
 

package/npm/install.mjs

@@ -6,36 +6,104 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const modulePath = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(modulePath);
 const packageRoot = path.resolve(__dirname, "..");
 const require = createRequire(import.meta.url);
 const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
 const DOCTOR_TIMEOUT_MS = 5000;
 const VERSION_SMOKE_TIMEOUT_MS = 5000;
 
-const command = process.argv[2] || "install";
-const args = process.argv.slice(3);
-
-if (["-h", "--help", "help"].includes(command)) {
-  printHelp();
-  process.exit(0);
+if (isCliEntrypoint()) {
+  main();
 }
 
-try {
-  if (command === "install" || command === "update") {
-    install(args);
-  } else if (command === "doctor") {
-    runDoctor(args);
-  } else if (command === "uninstall") {
-    uninstall(args);
-  } else {
-    console.error(`unknown command: ${command}`);
+function main() {
+  const command = process.argv[2] || "install";
+  const args = process.argv.slice(3);
+
+  if (["-h", "--help", "help"].includes(command)) {
     printHelp();
-    process.exit(2);
+    process.exit(0);
+  }
+
+  try {
+    if (command === "install" || command === "update") {
+      install(args);
+    } else if (command === "doctor") {
+      runDoctor(args);
+    } else if (command === "uninstall") {
+      uninstall(args);
+    } else {
+      console.error(`unknown command: ${command}`);
+      printHelp();
+      process.exit(2);
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+function isCliEntrypoint() {
+  if (!process.argv[1]) {
+    return false;
+  }
+  try {
+    return fs.realpathSync(process.argv[1]) === fs.realpathSync(modulePath);
+  } catch {
+    return path.resolve(process.argv[1]) === modulePath;
+  }
+}
+
+export function doctorSelfCheckVerdict(doctorBody, spawnMeta = {}) {
+  if (spawnMeta.error || spawnMeta.signal) {
+    return { kind: "advisory", blockers: [] };
   }
-} catch (error) {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
+
+  let body;
+  try {
+    body = JSON.parse(doctorBody || "");
+  } catch {
+    return { kind: "advisory", blockers: [] };
+  }
+
+  const blockers = [];
+  // Doctor JSON source: crates/team-agent/src/cli/mod.rs:2739-2764.
+  if (body?.tmux?.installed === false) {
+    blockers.push("tmux not installed");
+  }
+  if (!body?.mcp?.server_command) {
+    blockers.push("MCP server command missing");
+  }
+  const profileSmokeStatus = body?.profile_smoke?.status;
+  const profileSmokeNonBlocking =
+    profileSmokeStatus === "legacy_team_invalid" || profileSmokeStatus === "not_required";
+  if (
+    body?.error === "profile_smoke_failed" ||
+    (body?.profile_smoke?.ok === false && !profileSmokeNonBlocking)
+  ) {
+    blockers.push("profile smoke failed");
+  }
+
+  if (blockers.length > 0) {
+    return { kind: "blockers", blockers };
+  }
+
+  const noContext =
+    body?.ok === false && body?.error === "workspace has no Team Agent spec or runtime context";
+  if (body?.ok === true || noContext) {
+    return { kind: "ok", blockers: [] };
+  }
+
+  return { kind: "advisory", blockers: [] };
+}
+
+export function doctorSelfCheckLine(verdict) {
+  if (verdict.kind === "blockers") {
+    return `doctor: found blockers (${verdict.blockers.join("; ")}); run team-agent doctor in your project for details`;
+  }
+  return "doctor: ok (run team-agent doctor inside a team workspace for a full report)";
 }
 
 function printHelp() {
@@ -116,11 +184,8 @@ function install(argv) {
       encoding: "utf8",
       timeout: DOCTOR_TIMEOUT_MS,
     });
-    if (doctor.status === 0) {
-      console.log("doctor: ok");
-    } else {
-      console.log("doctor: has blockers; run `team-agent doctor` after updating PATH");
-    }
+    const verdict = doctorSelfCheckVerdict(doctor.stdout, doctor);
+    console.log(doctorSelfCheckLine(verdict));
   } finally {
     fs.rmSync(doctorWorkspace, { recursive: true, force: true });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.24",
+  "version": "0.3.25",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.3.24",
-    "@team-agent/cli-darwin-x64": "0.3.24",
-    "@team-agent/cli-linux-x64": "0.3.24"
+    "@team-agent/cli-darwin-arm64": "0.3.25",
+    "@team-agent/cli-darwin-x64": "0.3.25",
+    "@team-agent/cli-linux-x64": "0.3.25"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",