itermbot 1.0.2 → 1.0.4

package/test/chat-flow.integration.test.mjs

@@ -0,0 +1,235 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { AgentContextTokens } from "@easynet/agent-common/context";
+import { tryHandleDirectTargetPanelCommand } from "../dist/iterm/direct-command-router.js";
+import { runWithTextToolCallRecovery } from "../dist/runtime/text-tool-call-recovery.js";
+
+function makeRuntime({ tools = [], model, runImpl }) {
+  return {
+    context: {
+      get(token) {
+        if (token === AgentContextTokens.Tools) return tools;
+        if (token === AgentContextTokens.ChatModel) return model;
+        return undefined;
+      },
+    },
+    run: runImpl,
+  };
+}
+
+test("integration: natural language does not execute as direct shell by default", async () => {
+  const prev = process.env.ITB_ENABLE_NL_DIRECT;
+  delete process.env.ITB_ENABLE_NL_DIRECT;
+
+  const runtime = makeRuntime({
+    tools: [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+        async invoke() {
+          throw new Error("should not invoke direct shell for natural language by default");
+        },
+      },
+    ],
+    model: {
+      async invoke() {
+        throw new Error("translator should not run when NL direct is disabled");
+      },
+    },
+    runImpl: async () => ({ text: "unused" }),
+  });
+
+  const out = await tryHandleDirectTargetPanelCommand("please continue the analysis", runtime);
+  assert.equal(out, null);
+
+  if (prev === undefined) delete process.env.ITB_ENABLE_NL_DIRECT;
+  else process.env.ITB_ENABLE_NL_DIRECT = prev;
+});
+
+test("integration: runtime -> tool-call recovery -> final answer", async () => {
+  const toolCalls = [];
+  const runtime = makeRuntime({
+    tools: [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.listDir",
+        async invoke(args) {
+          toolCalls.push(args);
+          return {
+            result: {
+              blockedTool: "npm.easynet.agent.tool.buildin.0.0.70.listDir",
+              redirected: true,
+              requestedPath: "sandbox",
+              resolvedPath: ".",
+              pathFallbackUsed: true,
+              output: { result: { output: "[itermbot] path not found: sandbox; fallback to .\n./README.md\n./src" } },
+            },
+          };
+        },
+      },
+    ],
+    model: null,
+    runImpl: async () => ({
+      text: "<tool-call>{\"name\":\"listDir\",\"arguments\":{\"path\":\"sandbox\",\"maxEntries\":10,\"recursive\":true}}</tool-call>",
+    }),
+  });
+
+  const out = await runWithTextToolCallRecovery(runtime, "list files and do analysis", () => {});
+  assert.equal(out.recovered, true);
+  assert.equal(toolCalls.length, 1);
+  assert.equal(toolCalls[0].path, "sandbox");
+  assert.equal(out.text.includes("### Recovered Tool Result"), true);
+  assert.equal(out.text.includes("pathFallbackUsed: true"), true);
+  assert.equal(out.text.includes("resolvedPath: ."), true);
+});
+
+test("integration: redirected listDir result exposes plain output text for downstream reasoning", async () => {
+  const toolCalls = [];
+  const runtime = makeRuntime({
+    tools: [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.listDir",
+        async invoke(args) {
+          toolCalls.push(args);
+          return {
+            result: {
+              blockedTool: "npm.easynet.agent.tool.buildin.0.0.70.listDir",
+              redirected: true,
+              requestedPath: ".",
+              resolvedPath: ".",
+              pathFallbackUsed: false,
+              outputText: "./README.md\n./src",
+              commandCompleted: true,
+              exitCode: 0,
+              output: { result: { output: "./README.md\n./src", commandCompleted: true, exitCode: 0 } },
+            },
+          };
+        },
+      },
+    ],
+    model: null,
+    runImpl: async () => ({
+      text: "<tool-call>{\"name\":\"listDir\",\"arguments\":{\"path\":\".\",\"maxEntries\":10,\"recursive\":true}}</tool-call>",
+    }),
+  });
+
+  const out = await runWithTextToolCallRecovery(runtime, "list files", () => {});
+  assert.equal(out.recovered, true);
+  assert.equal(toolCalls.length, 1);
+  assert.equal(out.text.includes("requestedPath: ."), true);
+});
+
+test("integration: no tool activity returns first-pass text without external recovery", async () => {
+  const calls = [];
+  const runtime = makeRuntime({
+    tools: [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+        async invoke(args) {
+          calls.push(args);
+          return { result: { output: "/workspace\nFilesystem  Size Used Avail Use%\n/dev/disk 100G 50G 50G 50%\n" } };
+        },
+      },
+    ],
+    model: null,
+    runImpl: async () => ({
+      text: "Please specify a path to continue.",
+      messages: [{ type: "ai", content: "Please specify a path to continue." }],
+    }),
+  });
+
+  const out = await runWithTextToolCallRecovery(runtime, "check disk usage", () => {}, {
+    windowId: 9,
+    tabIndex: 2,
+    sessionId: "target-session",
+  });
+  assert.equal(out.recovered, false);
+  assert.equal(calls.length, 0);
+  assert.equal(out.text, "Please specify a path to continue.");
+});
+
+test("integration: no tool activity does not trigger target-panel fallback execution", async () => {
+  const calls = [];
+  const runtime = makeRuntime({
+    tools: [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+        async invoke(args) {
+          calls.push(args);
+          return { result: { output: "/workspace\nFilesystem      Size Used Avail Use%\n/dev/disk 100G 30G 70G 30%\n" } };
+        },
+      },
+    ],
+    model: null,
+    runImpl: async () => ({
+      text: "Need more context",
+      messages: [{ type: "ai", content: "Need more context" }],
+    }),
+  });
+
+  const out = await runWithTextToolCallRecovery(runtime, "list tools", () => {}, {
+    windowId: 1,
+    tabIndex: 0,
+    sessionId: "target",
+  });
+  assert.equal(out.recovered, false);
+  assert.equal(calls.length, 0);
+  assert.equal(out.text, "Need more context");
+});
+
+test("integration: tool-activity first pass returns directly without bootstrap recovery", async () => {
+  const calls = [];
+  const runtime = makeRuntime({
+    tools: [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+        async invoke(args) {
+          calls.push(args);
+          return { result: { output: "/workspace\nFilesystem      Size Used Avail Use%\n/dev/disk 100G 70G 30G 70%\n" } };
+        },
+      },
+    ],
+    model: null,
+    runImpl: async () => ({
+      text: "The current tool output only includes a file list and does not include disk usage metrics.",
+      messages: [{ type: "tool", name: "listDir", content: "..." }],
+    }),
+  });
+
+  const out = await runWithTextToolCallRecovery(runtime, "check disk usage", () => {}, {
+    windowId: 3,
+    tabIndex: 1,
+    sessionId: "target-session",
+  });
+  assert.equal(out.recovered, false);
+  assert.equal(calls.length, 0);
+  assert.equal(out.text.includes("does not include disk usage metrics"), true);
+});
+
+test("integration: listDir-only first pass stays on main agent path without extra recovery", async () => {
+  const calls = [];
+  const runtime = makeRuntime({
+    tools: [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+        async invoke(args) {
+          calls.push(args);
+          return { result: { output: "/workspace\nFilesystem      Size Used Avail Use%\n/dev/disk 100G 80G 20G 80%\n" } };
+        },
+      },
+    ],
+    model: null,
+    runImpl: async () => ({
+      text: "The current tool output only includes a file list and does not include disk usage metrics. To inspect disk usage, adjust tool parameters.",
+      messages: [{ type: "tool", name: "listDir", content: "..." }],
+    }),
+  });
+
+  const out = await runWithTextToolCallRecovery(runtime, "check disk usage", () => {}, {
+    windowId: 6,
+    tabIndex: 2,
+    sessionId: "target-regression",
+  });
+
+  assert.equal(out.recovered, false);
+  assert.equal(calls.length, 0);
+  assert.equal(out.text.includes("does not include disk usage metrics"), true);
+});

package/test/chat-progress.test.mjs

@@ -0,0 +1,83 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createChatProgressEventListener } from "../dist/chat/progress.js";
+
+function makeEvent(name, payload = {}, to = "tool") {
+  return {
+    id: "evt-1",
+    at: new Date().toISOString(),
+    from: "react-agent",
+    to,
+    name,
+    payload,
+  };
+}
+
+test("chat progress listener shows step lines and progress updates", () => {
+  const lines = [];
+  const listener = createChatProgressEventListener((line) => lines.push(line));
+
+  listener(makeEvent("agent.react.run.start"));
+  listener(makeEvent("agent.react.tool.invoke.start", { args: { command: "ls -la" } }, "bash"));
+  listener(makeEvent("agent.react.tool.invoke.done", { result: { output: "ok" } }, "bash"));
+  listener(makeEvent("agent.react.run.done"));
+
+  assert.ok(lines.some((line) => line.includes("Steps: analysis")));
+  assert.ok(lines.some((line) => line.includes("[01]") && line.includes("run command: ls -la")));
+  assert.ok(lines.some((line) => line.includes("reason: Because we need verifiable terminal evidence")));
+  assert.ok(lines.some((line) => line.includes("[01]") && line.includes("✓") && line.includes("run command: ls -la")));
+  assert.ok(lines.some((line) => line.includes("progress 1/1")));
+  assert.ok(lines.some((line) => line.includes("Steps complete: 1 step(s)")));
+});
+
+test("chat progress listener reports tool error from payload", () => {
+  const lines = [];
+  const listener = createChatProgressEventListener((line) => lines.push(line));
+
+  listener(makeEvent("agent.react.run.start"));
+  listener(makeEvent("agent.react.tool.invoke.start", { args: { command: "bad" } }, "bash"));
+  listener(makeEvent("agent.react.tool.invoke.done", { result: { result: { error: "permission denied" } } }, "bash"));
+
+  assert.ok(lines.some((line) => line.includes("✖")));
+  assert.ok(lines.some((line) => line.includes("error: permission denied")));
+});
+
+test("chat progress listener infers list directory action from args shape", () => {
+  const lines = [];
+  const listener = createChatProgressEventListener((line) => lines.push(line));
+
+  listener(makeEvent("agent.react.run.start"));
+  listener(makeEvent("agent.react.tool.invoke.start", {
+    args: { path: "sandbox", recursive: true, maxEntries: 10, maxDepth: 2, includeHidden: true },
+  }, "tool_1"));
+  listener(makeEvent("agent.react.tool.invoke.done", { result: { output: "ok" } }, "tool_1"));
+
+  assert.ok(lines.some((line) => line.includes("[01]") && line.includes("list directory: sandbox")));
+});
+
+test("chat progress listener shows explicit resultPreview when present", () => {
+  const lines = [];
+  const listener = createChatProgressEventListener((line) => lines.push(line));
+
+  listener(makeEvent("agent.react.run.start"));
+  listener(makeEvent("agent.react.tool.invoke.start", { args: { path: "." } }, "tool_1"));
+  listener(makeEvent("agent.react.tool.invoke.done", { resultPreview: "Directory listing for .: README.md src" }, "tool_1"));
+
+  assert.ok(lines.some((line) => line.includes("[01]") && line.includes("✓") && line.includes("read path: .")));
+});
+
+test("chat progress listener reports skill matched", () => {
+  const lines = [];
+  const listener = createChatProgressEventListener((line) => lines.push(line));
+
+  listener(makeEvent("agent.react.skill.matched", { skill: "coding" }, "skill"));
+  assert.ok(lines.some((line) => line.includes("skill: coding")));
+});
+
+test("chat progress listener shows ptc retry attempt from payload", () => {
+  const lines = [];
+  const listener = createChatProgressEventListener((line) => lines.push(line));
+
+  listener(makeEvent("agent.react.ptc.retry", { retry: 2, reason: "no_tool_activity" }));
+  assert.ok(lines.some((line) => line.includes("planning retry: attempt 2, reason=no_tool_activity")));
+});

package/test/config.test.mjs

@@ -0,0 +1,22 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolve } from "node:path";
+import { loadAppConfig } from "../dist/config.js";
+
+test("loadAppConfig reads prompt templates from app config", async () => {
+  const configPath = resolve(process.cwd(), "config/app.yaml");
+  const config = await loadAppConfig(configPath);
+
+  assert.equal(typeof config, "object");
+  assert.equal(typeof config.promptTemplates?.systemPrompt, "string");
+  assert.equal(config.responseSafetyMode, "balanced");
+  assert.match(config.promptTemplates?.systemPrompt ?? "", /iTerm Operating Policy/);
+  assert.match(config.promptTemplates?.systemPrompt ?? "", /Skills are preferred/);
+  assert.match(config.promptTemplates?.systemPrompt ?? "", /\{\{targetSessionSection\}\}/);
+});
+
+test("loadAppConfig returns empty object when file does not exist", async () => {
+  const configPath = resolve(process.cwd(), "config/does-not-exist.yaml");
+  const config = await loadAppConfig(configPath);
+  assert.deepEqual(config, {});
+});

package/test/diagnostics.test.mjs

@@ -0,0 +1,45 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runLlmHealthCheck } from "../dist/startup/diagnostics.js";
+
+function makeRuntimeWithInvoke(invoke) {
+  return {
+    context: {
+      get() {
+        return { invoke };
+      },
+    },
+  };
+}
+
+test("runLlmHealthCheck returns trimmed text for string content", async () => {
+  const runtime = makeRuntimeWithInvoke(async () => ({ content: "  OK  " }));
+  const out = await runLlmHealthCheck(runtime);
+  assert.equal(out, "OK");
+});
+
+test("runLlmHealthCheck supports array content and truncates long output", async () => {
+  const runtime = makeRuntimeWithInvoke(async () => ({
+    content: [{ text: "0123456789012345678901234567890123456789" }],
+  }));
+  const out = await runLlmHealthCheck(runtime);
+  assert.equal(out.length <= 35, true);
+  assert.equal(out.endsWith("..."), true);
+});
+
+test("runLlmHealthCheck rejects on empty response", async () => {
+  const runtime = makeRuntimeWithInvoke(async () => ({ content: [] }));
+  await assert.rejects(() => runLlmHealthCheck(runtime), /empty response/i);
+});
+
+test("runLlmHealthCheck rejects on timeout", async () => {
+  const prev = process.env.ITERMBOT_LLM_HEALTHCHECK_TIMEOUT_MS;
+  process.env.ITERMBOT_LLM_HEALTHCHECK_TIMEOUT_MS = "20";
+  try {
+    const runtime = makeRuntimeWithInvoke(async () => await new Promise(() => {}));
+    await assert.rejects(() => runLlmHealthCheck(runtime), /timeout/i);
+  } finally {
+    if (prev === undefined) delete process.env.ITERMBOT_LLM_HEALTHCHECK_TIMEOUT_MS;
+    else process.env.ITERMBOT_LLM_HEALTHCHECK_TIMEOUT_MS = prev;
+  }
+});

package/test/direct-command-router.test.mjs

@@ -0,0 +1,149 @@
+import test, { beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { AgentContextTokens } from "@easynet/agent-common/context";
+import {
+  detectDirectTargetPanelCommand,
+  tryHandleDirectTargetPanelCommand,
+} from "../dist/iterm/direct-command-router.js";
+
+function makeRuntime(tools, model = null) {
+  return {
+    context: {
+      get(token) {
+        if (token === AgentContextTokens.Tools) return tools;
+        if (token === AgentContextTokens.ChatModel) return model;
+        return undefined;
+      },
+    },
+  };
+}
+
+beforeEach(() => {
+  delete process.env.ITB_ENABLE_NL_DIRECT;
+});
+
+test("detectDirectTargetPanelCommand recognizes raw shell command", () => {
+  const out = detectDirectTargetPanelCommand("ls -la");
+  assert.equal(out?.reason, "raw_shell_command");
+  assert.equal(out?.command, "ls -la");
+});
+
+test("detectDirectTargetPanelCommand ignores natural-language requests", () => {
+  const out = detectDirectTargetPanelCommand("list files in the repo");
+  assert.equal(out, null);
+});
+
+test("tryHandleDirectTargetPanelCommand invokes itermRunCommandInSession and returns summarized output by default", async () => {
+  const calls = [];
+  const runtime = makeRuntime([
+    {
+      name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+      async invoke(args) {
+        calls.push(args);
+        return { result: { output: "fileA\nfileB" } };
+      },
+    },
+  ]);
+
+  const out = await tryHandleDirectTargetPanelCommand("ls -la", runtime, {
+    windowId: 7,
+    tabIndex: 1,
+    sessionId: "target",
+  });
+  assert.equal(out.includes("### Command Result"), true);
+  assert.equal(out.includes("- Command: `ls -la`"), true);
+  assert.equal(out.includes("- Captured lines: **2**"), true);
+  assert.equal(out.includes("- Raw output: hidden by default"), true);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].command, "ls -la");
+  assert.equal(calls[0].windowId, 7);
+  assert.equal(calls[0].tabIndex, 1);
+  assert.equal(calls[0].sessionId, "target");
+});
+
+test("tryHandleDirectTargetPanelCommand returns null when command tool is missing", async () => {
+  const runtime = makeRuntime([]);
+  const out = await tryHandleDirectTargetPanelCommand("list files", runtime);
+  assert.equal(out, null);
+});
+
+test("tryHandleDirectTargetPanelCommand does not route natural-language requests", async () => {
+  const runtime = makeRuntime(
+    [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+        async invoke() {
+          throw new Error("should not run");
+        },
+      },
+    ],
+    {
+      async invoke() {
+        throw new Error("should not consult model");
+      },
+    },
+  );
+
+  const out = await tryHandleDirectTargetPanelCommand("show workspace tree", runtime);
+  assert.equal(out, null);
+});
+
+test("single-line output includes value in command summary", async () => {
+  const runtime = makeRuntime([
+    {
+      name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+      async invoke() {
+        return { result: { output: "42\n" } };
+      },
+    },
+  ]);
+  const out = await tryHandleDirectTargetPanelCommand("echo -n 42", runtime);
+  assert.equal(out.includes("- Value: `42`"), true);
+});
+
+test("direct shell command returns summary (not inline raw output by suffix text)", async () => {
+  const runtime = makeRuntime([
+    {
+      name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+      async invoke() {
+        return { result: { output: "line-a\nline-b" } };
+      },
+    },
+  ]);
+  const out = await tryHandleDirectTargetPanelCommand("ls -la show raw output", runtime);
+  assert.equal(out.includes("### Command Result"), true);
+  assert.equal(out.includes("Raw output: hidden by default"), true);
+});
+
+test("without raw shell syntax, direct execution stays off", async () => {
+  const runtime = makeRuntime(
+    [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+        async invoke() {
+          throw new Error("should not run");
+        },
+      },
+    ],
+    null,
+  );
+  const out = await tryHandleDirectTargetPanelCommand("show workspace tree", runtime);
+  assert.equal(out, null);
+});
+
+test("analysis-oriented mixed request falls back to agent (returns null)", async () => {
+  const runtime = makeRuntime(
+    [
+      {
+        name: "npm.easynet.agent.tool.buildin.0.0.70.itermRunCommandInSession",
+        async invoke() {
+          throw new Error("should not run");
+        },
+      },
+    ],
+    null,
+  );
+
+  const out = await tryHandleDirectTargetPanelCommand("list files and do analysis", runtime);
+  assert.equal(out, null);
+});

package/test/live-iterm-llm.integration.test.mjs

@@ -0,0 +1,153 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import {
+  createAgentEventBus,
+} from "@easynet/agent-common";
+import { resolveConfigPath } from "@easynet/agent-common/config";
+import { getDefaultAgentContext } from "@easynet/agent-common/context";
+import { createAgentModel } from "@easynet/agent-model";
+import { createAgentTools } from "@easynet/agent-tool";
+import { itermListCurrentWindowSessions } from "@easynet/agent-tool-buildin/iterm";
+import { runLlmHealthCheck } from "../dist/startup/diagnostics.js";
+import { tryHandleDirectTargetPanelCommand } from "../dist/iterm/direct-command-router.js";
+import { runWithTextToolCallRecovery } from "../dist/runtime/text-tool-call-recovery.js";
+
+const RUN_LIVE = process.env.RUN_LIVE_ITERM_LLM === "1";
+const isDarwin = process.platform === "darwin";
+
+function hasCommand(cmd) {
+  return spawnSync("which", [cmd], { stdio: "ignore" }).status === 0;
+}
+
+function hasIterm2Installed() {
+  const check = spawnSync("osascript", ["-e", 'id of app "iTerm"'], { encoding: "utf-8" });
+  return check.status === 0;
+}
+
+function pickTargetHintFromCurrentWindow(result) {
+  const sessions = Array.isArray(result?.sessions) ? result.sessions : [];
+  const nonCurrent = sessions.find((s) => !s?.isCurrentSession && (s?.sessionUniqueId || s?.sessionId));
+  const current = sessions.find((s) => s?.isCurrentSession && (s?.sessionUniqueId || s?.sessionId));
+  const target = nonCurrent ?? current ?? null;
+  if (!target) return null;
+  return {
+    windowId: result?.windowId ?? target.windowId,
+    tabIndex: target.tabIndex,
+    sessionId: target.sessionUniqueId ?? target.sessionId,
+  };
+}
+
+const liveGuardReason = !RUN_LIVE
+  ? "set RUN_LIVE_ITERM_LLM=1 to run live iTerm+LLM tests"
+  : !isDarwin
+    ? "live iTerm tests require macOS"
+    : !hasCommand("osascript")
+      ? "osascript not found"
+      : !hasIterm2Installed()
+        ? "iTerm2 is not installed or not discoverable"
+        : "";
+
+const shouldSkip = liveGuardReason.length > 0;
+let contextInitPromise = null;
+
+async function getLiveContext() {
+  if (!contextInitPromise) {
+    contextInitPromise = (async () => {
+      createAgentEventBus();
+      await createAgentModel({
+        configPath: resolveConfigPath("config/model.yaml", process.cwd()),
+      });
+      createAgentTools({
+        configFilePath: resolveConfigPath("config/tool.yaml", process.cwd()),
+        coreTools: { sandboxRoot: process.cwd() },
+      });
+      return getDefaultAgentContext();
+    })();
+  }
+  return contextInitPromise;
+}
+
+async function getTargetHint() {
+  const sessions = await itermListCurrentWindowSessions();
+  const hint = pickTargetHintFromCurrentWindow(sessions.result);
+  assert.ok(hint, "No target/current iTerm session found");
+  return hint;
+}
+
+test("live: real LLM health check", { timeout: 120_000, skip: shouldSkip ? liveGuardReason : false }, async () => {
+  const context = await getLiveContext();
+  const runtimeLike = { context };
+  const health = await runLlmHealthCheck(runtimeLike);
+  assert.equal(typeof health, "string");
+  assert.equal(health.trim().length > 0, true);
+});
+
+test("live: real iTerm direct command routing executes in target panel", { timeout: 120_000, skip: shouldSkip ? liveGuardReason : false }, async () => {
+  const context = await getLiveContext();
+  const runtimeLike = { context };
+  const hint = await getTargetHint();
+  const marker = "__ITB_LIVE_DIRECT__";
+  const output = await tryHandleDirectTargetPanelCommand(`echo ${marker} && pwd`, runtimeLike, hint);
+  assert.equal(typeof output, "string");
+  assert.equal((output ?? "").trim().length > 0, true);
+  assert.equal((output ?? "").includes(marker), true);
+  assert.equal((output ?? "").includes("__ITB_BEGIN_"), false);
+});
+
+test("live: no-tool-activity bootstrap uses real model planning + real iTerm execution", { timeout: 120_000, skip: shouldSkip ? liveGuardReason : false }, async () => {
+  const context = await getLiveContext();
+  const hint = await getTargetHint();
+  const runtimeLike = {
+    context,
+    async run() {
+      return {
+        text: "Please specify a path.",
+        messages: [{ type: "ai", content: "Please specify a path." }],
+      };
+    },
+  };
+  const out = await runWithTextToolCallRecovery(runtimeLike, "check disk usage", () => {}, hint);
+  assert.equal(out.recovered, true);
+  assert.equal(typeof out.text, "string");
+  assert.equal(out.text.includes("### Baseline Evidence"), true);
+  assert.equal(out.text.includes("Evidence Preview"), true);
+});
+
+test("live: literal tool-call text is recovered, executed, and finalized", { timeout: 120_000, skip: shouldSkip ? liveGuardReason : false }, async () => {
+  const context = await getLiveContext();
+  const hint = await getTargetHint();
+  const marker = "__ITB_LIVE_TOOLCALL__";
+  const runtimeLike = {
+    context,
+    async run() {
+      return {
+        text: `<tool-call>{"name":"itermRunCommandInSession","arguments":{"command":"echo ${marker} && pwd","maxOutputLines":120}}</tool-call>`,
+      };
+    },
+  };
+  const out = await runWithTextToolCallRecovery(runtimeLike, "execute one command and summarize output", () => {}, hint);
+  assert.equal(out.recovered, true);
+  assert.equal(typeof out.text, "string");
+  assert.equal(out.text.trim().length > 0, true);
+  assert.equal(out.text.includes("<tool-call>"), false);
+});
+
+test("live: multi-turn direct execution remains stable on same target hint", { timeout: 180_000, skip: shouldSkip ? liveGuardReason : false }, async () => {
+  const context = await getLiveContext();
+  const runtimeLike = { context };
+  const hint = await getTargetHint();
+  const markers = [
+    "__ITB_LIVE_MULTI_1__",
+    "__ITB_LIVE_MULTI_2__",
+    "__ITB_LIVE_MULTI_3__",
+  ];
+
+  for (const marker of markers) {
+    const output = await tryHandleDirectTargetPanelCommand(`echo ${marker} && pwd`, runtimeLike, hint);
+    assert.equal(typeof output, "string");
+    assert.equal((output ?? "").trim().length > 0, true);
+    assert.equal((output ?? "").includes(marker), true);
+    assert.equal((output ?? "").includes("__ITB_BEGIN_"), false);
+  }
+});