@integrity-labs/agt-cli 0.27.8 → 0.27.9-test.11

package/dist/{chunk-GN4XPQWJ.js → chunk-SJPAXXTW.js}

@@ -1,16 +1,16 @@
 import {
   claudeModelAlias,
   isClaudeFastMode
-} from "./chunk-YSBGIXJG.js";
+} from "./chunk-45I2X4M7.js";
 import {
   reapOrphanChannelMcps
 } from "./chunk-XWVM4KPK.js";
 
 // src/lib/persistent-session.ts
-import { spawn, execSync, execFileSync } from "child_process";
+import { spawn, execSync, execFileSync as execFileSync3 } from "child_process";
 import { join as join2, dirname } from "path";
 import { homedir as homedir2, platform, userInfo } from "os";
-import { existsSync as existsSync2, readFileSync as readFileSync3, readdirSync, writeFileSync as writeFileSync3, appendFileSync, mkdirSync as mkdirSync2, chmodSync, copyFileSync, rmSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync, writeFileSync as writeFileSync3, appendFileSync, mkdirSync as mkdirSync2, chmodSync, copyFileSync, rmSync } from "fs";
 import { fileURLToPath } from "url";
 
 // src/lib/mcp-sanitize.ts
@@ -56,18 +56,94 @@ function sanitizeMcpJson(mcpConfigPath, apiHost) {
 }
 
 // src/lib/claude-tools.ts
-var BASE_TOOLS = ["Bash", "Read", "Write", "Edit", "Grep", "Glob", "Agent", "Skill"];
+var BASE_TOOLS = ["Bash", "Read", "Write", "Edit", "Grep", "Glob", "Agent", "Skill", "ToolSearch"];
 function buildAllowedTools(mcpServerNames) {
   const mcpPatterns = mcpServerNames.map((name) => `mcp__${name.replace(/-/g, "_")}__*`);
   return [...mcpPatterns, ...BASE_TOOLS].join(",");
 }
 
+// src/lib/mcp-env-probe.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+var LATE_BOUND_VARS = /* @__PURE__ */ new Set([
+  "AGT_RUN_ID",
+  "AGT_TOKEN",
+  "ANCHOR_BROWSER_SESSION_ID"
+]);
+var TEMPLATE_VAR_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+function collectVarsFromValue(value, into) {
+  if (typeof value === "string") {
+    for (const m of value.matchAll(TEMPLATE_VAR_RE)) into.add(m[1]);
+  } else if (Array.isArray(value)) {
+    for (const v of value) collectVarsFromValue(v, into);
+  }
+}
+function findMissingSubstitutionVars(mcpConfig, env) {
+  const findings = [];
+  if (typeof mcpConfig !== "object" || mcpConfig === null) return findings;
+  const servers = mcpConfig.mcpServers;
+  if (typeof servers !== "object" || servers === null) return findings;
+  for (const [server, raw] of Object.entries(servers)) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const entry = raw;
+    const vars = /* @__PURE__ */ new Set();
+    collectVarsFromValue(entry["command"], vars);
+    collectVarsFromValue(entry["args"], vars);
+    collectVarsFromValue(entry["url"], vars);
+    for (const block of [entry["env"], entry["headers"]]) {
+      if (typeof block !== "object" || block === null) continue;
+      for (const v of Object.values(block)) collectVarsFromValue(v, vars);
+    }
+    for (const varName of vars) {
+      if (LATE_BOUND_VARS.has(varName)) continue;
+      const value = env[varName];
+      if (value === void 0) {
+        findings.push({ varName, server, state: "unset" });
+      } else if (value.trim() === "") {
+        findings.push({ varName, server, state: "empty" });
+      }
+    }
+  }
+  return findings;
+}
+function formatMissingVar(f) {
+  return `[mcp-env-substitution] missing var=${f.varName} server=${f.server} state=${f.state}`;
+}
+function parseEnvIntegrations(content) {
+  const out = {};
+  for (const line of content.split("\n")) {
+    if (!line || line.startsWith("#") || !line.includes("=")) continue;
+    const eqIdx = line.indexOf("=");
+    const key = line.slice(0, eqIdx);
+    let value = line.slice(eqIdx + 1);
+    if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1).replaceAll("'\\''", "'");
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function probeMcpEnvSubstitution(args) {
+  try {
+    const config = JSON.parse(readFileSync2(args.mcpConfigPath, "utf-8"));
+    let env = args.baseEnv;
+    if (args.envIntegrationsPath && existsSync(args.envIntegrationsPath)) {
+      env = {
+        ...args.baseEnv,
+        ...parseEnvIntegrations(readFileSync2(args.envIntegrationsPath, "utf-8"))
+      };
+    }
+    return findMissingSubstitutionVars(config, env);
+  } catch {
+    return [];
+  }
+}
+
 // src/lib/persistent-session.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/lib/daily-session.ts
 import { randomUUID } from "crypto";
-import { existsSync, mkdirSync, readFileSync as readFileSync2, renameSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, renameSync, statSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 var HISTORY_DAYS = 7;
@@ -97,9 +173,9 @@ function todayLocalIso(now = /* @__PURE__ */ new Date(), timezone) {
 }
 function readFile(codeName) {
   const path = dailySessionPath(codeName);
-  if (!existsSync(path)) return { current: null, history: [] };
+  if (!existsSync2(path)) return { current: null, history: [] };
   try {
-    const raw = readFileSync2(path, "utf-8");
+    const raw = readFileSync3(path, "utf-8");
     const parsed = JSON.parse(raw);
     return {
       current: parsed.current ?? null,
@@ -123,6 +199,25 @@ function trimHistory(history, now, timezone) {
   const cutoffIso = todayLocalIso(cutoff, timezone);
   return history.filter((h) => h.date >= cutoffIso).slice(0, HISTORY_DAYS);
 }
+function getOrCreateDailySession(codeName, now = /* @__PURE__ */ new Date(), timezone) {
+  const today = todayLocalIso(now, timezone);
+  const file = readFile(codeName);
+  if (file.current && file.current.date === today) {
+    return { sessionId: file.current.sessionId, isNew: false };
+  }
+  const next = {
+    date: today,
+    sessionId: randomUUID(),
+    startedAt: now.toISOString()
+  };
+  const history = trimHistory(
+    [...file.current ? [file.current] : [], ...file.history],
+    now,
+    timezone
+  );
+  writeFile(codeName, { current: next, history });
+  return { sessionId: next.sessionId, isNew: true };
+}
 function markDailySessionSpawn(codeName, sessionId, now = /* @__PURE__ */ new Date(), timezone) {
   const today = todayLocalIso(now, timezone);
   const file = readFile(codeName);
@@ -160,6 +255,16 @@ function rotateDailySession(codeName, now = /* @__PURE__ */ new Date(), timezone
 function encodeProjectPath(projectDir) {
   return "-" + projectDir.replace(/^\//, "").replace(/[/.]/g, "-");
 }
+function sessionFileExists(projectDir, sessionId) {
+  const path = join(
+    homedir(),
+    ".claude",
+    "projects",
+    encodeProjectPath(projectDir),
+    `${sessionId}.jsonl`
+  );
+  return existsSync2(path);
+}
 function sessionTranscriptDir(projectDir) {
   return join(homedir(), ".claude", "projects", encodeProjectPath(projectDir));
 }
@@ -168,7 +273,7 @@ function sessionFilePath(projectDir, sessionId) {
 }
 function isAgentIdle(projectDir, sessionId, idleSeconds = 60, now = /* @__PURE__ */ new Date()) {
   const path = sessionFilePath(projectDir, sessionId);
-  if (!existsSync(path)) return true;
+  if (!existsSync2(path)) return true;
   try {
     const mtimeMs = statSync(path).mtimeMs;
     return now.getTime() - mtimeMs >= idleSeconds * 1e3;
@@ -185,12 +290,287 @@ function peekCurrentSession(codeName) {
   return readFile(codeName).current;
 }
 
+// ../../packages/core/dist/runtime/session-probe.js
+import { execFileSync } from "child_process";
+function escapePgrepRegex(value) {
+  return value.replace(/[.[\]{}()*+?^$|\\]/g, "\\$&");
+}
+function probeClaudeProcessInTmux(tmuxSession) {
+  const escapedSession = escapePgrepRegex(tmuxSession);
+  const pattern = `(^|[[:space:]])--name ${escapedSession}([[:space:]]|$)`;
+  try {
+    const out = execFileSync("pgrep", ["-f", "--", pattern], {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    return out.length > 0 ? "alive" : "dead";
+  } catch (err) {
+    const e = err;
+    if (e?.code === "ENOENT")
+      return "unknown";
+    return e?.status === 1 ? "dead" : "unknown";
+  }
+}
+
+// src/lib/claude-dialogs.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function isLoginPickerVisible(screen) {
+  return screen.includes("Select login method") || screen.includes("Claude account with subscription") && screen.includes("Anthropic Console account");
+}
+function isResumeModeDialogVisible(screen) {
+  return screen.includes("Resume from summary") && screen.includes("Don't ask me again");
+}
+function isSessionFeedbackDialogVisible(screen) {
+  return screen.includes("How is Claude doing this session") && screen.includes("0: Dismiss");
+}
+function sweepDialogs(screen) {
+  if (screen.includes("Choose the text style") || screen.includes("Dark mode") && screen.includes("Light mode")) {
+    return {
+      kind: "theme-picker",
+      keys: ["Enter"],
+      interKeyDelayMs: 0,
+      logMessage: "Auto-accepted theme picker"
+    };
+  }
+  if (screen.includes("Yes, I trust this folder")) {
+    return {
+      kind: "folder-trust",
+      keys: ["Enter"],
+      interKeyDelayMs: 0,
+      logMessage: "Auto-accepted folder trust"
+    };
+  }
+  if (isResumeModeDialogVisible(screen)) {
+    return {
+      kind: "resume-mode",
+      keys: ["3", "Enter"],
+      interKeyDelayMs: 300,
+      logMessage: "Auto-dismissed resume-mode dialog (picked 'Don't ask me again')"
+    };
+  }
+  if (screen.includes("I am using this for local development")) {
+    return {
+      kind: "dev-channels",
+      keys: ["Enter"],
+      interKeyDelayMs: 0,
+      logMessage: "Auto-accepted dev channels"
+    };
+  }
+  if (screen.includes("Enter to confirm") && screen.includes("MCP")) {
+    return {
+      kind: "mcp-servers",
+      keys: ["Enter"],
+      interKeyDelayMs: 0,
+      logMessage: "Auto-accepted MCP servers"
+    };
+  }
+  if (screen.includes("Yes, I accept") && screen.includes("Bypass Permissions")) {
+    return {
+      kind: "bypass-permissions",
+      keys: ["2", "Enter"],
+      interKeyDelayMs: 300,
+      logMessage: "Auto-accepted bypass permissions"
+    };
+  }
+  if (isSessionFeedbackDialogVisible(screen)) {
+    return {
+      kind: "session-feedback",
+      keys: ["0"],
+      interKeyDelayMs: 0,
+      logMessage: "Auto-dismissed session-feedback dialog"
+    };
+  }
+  return null;
+}
+async function sendDialogKeys(tmuxSession, action) {
+  for (let i = 0; i < action.keys.length; i++) {
+    if (i > 0 && action.interKeyDelayMs > 0) {
+      await new Promise((r) => setTimeout(r, action.interKeyDelayMs));
+    }
+    execFileSync2("tmux", ["send-keys", "-t", tmuxSession, action.keys[i]], {
+      stdio: "ignore"
+    });
+  }
+}
+function simpleTextHash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = (h << 5) - h + s.charCodeAt(i) | 0;
+  }
+  return h.toString(16);
+}
+
+// src/lib/channel-input-watchdog.ts
+var STUCK_THRESHOLD_MS = 5e3;
+var MAX_ENTER_FIRES = 3;
+var DISTURB_HEAL_KEYS = ["x", "BSpace", "Enter"];
+var DISTURB_INTER_KEY_DELAY_MS = 200;
+var ATTACHED_STUCK_THRESHOLD_MS = 15e3;
+var INPUT_BOX_DIVIDER = /^[─━]{10,}/;
+var PROMPT_PREFIX = "\u276F ";
+function selectFireKeys(attempt, healMode = "disturb") {
+  if (healMode === "disturb" && attempt >= 2) return DISTURB_HEAL_KEYS;
+  return ["Enter"];
+}
+function decide(pane, prev, now, config = {}) {
+  const threshold = config.stuckThresholdMs ?? STUCK_THRESHOLD_MS;
+  const maxFires = config.maxEnterFires ?? MAX_ENTER_FIRES;
+  const dialogAction = sweepDialogs(pane);
+  if (dialogAction) {
+    return { fire: false, dialog: dialogAction, next: prev };
+  }
+  const inputText = extractInputBoxText(pane);
+  if (!inputText) {
+    return { fire: false, next: void 0 };
+  }
+  if (inputText === "\u2026") {
+    return { fire: false, next: void 0 };
+  }
+  const hash = simpleTextHash(inputText);
+  if (!prev || prev.lastInputHash !== hash) {
+    return {
+      fire: false,
+      next: { lastInputHash: hash, firstSeenAt: now, fires: 0, lastFireAt: 0, gaveUpLogged: false }
+    };
+  }
+  if (prev.fires >= maxFires) {
+    if (!prev.gaveUpLogged) {
+      return { fire: false, gaveUp: true, next: { ...prev, gaveUpLogged: true } };
+    }
+    return { fire: false, next: prev };
+  }
+  const sinceLastAttempt = prev.fires === 0 ? now - prev.firstSeenAt : now - prev.lastFireAt;
+  if (sinceLastAttempt < threshold) return { fire: false, next: prev };
+  return {
+    fire: true,
+    next: { ...prev, fires: prev.fires + 1, lastFireAt: now }
+  };
+}
+function extractInputBoxText(pane) {
+  const lines = pane.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (!line.startsWith(PROMPT_PREFIX)) continue;
+    let j = i - 1;
+    while (j >= 0 && (lines[j] ?? "").trim() === "") j--;
+    if (j < 0) continue;
+    if (!INPUT_BOX_DIVIDER.test((lines[j] ?? "").trim())) continue;
+    const text = line.slice(PROMPT_PREFIX.length).trim();
+    return text.length > 0 ? text : null;
+  }
+  return null;
+}
+var SPINNER_GLYPHS = ["\u273B", "\u273D", "\u2736", "\u2733", "\u2722"];
+function isActivelyProcessing(pane) {
+  const lines = pane.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = (lines[i] ?? "").trim();
+    if (!SPINNER_GLYPHS.some((g) => line.startsWith(g))) continue;
+    if (/\bfor\s+\d+s\s*$/.test(line)) return false;
+    if (/\b\w+ing[…\.]{0,3}(\s*\([^)]*\))?\s*$/i.test(line)) return true;
+    return false;
+  }
+  return false;
+}
+function checkChannelInputs(codeNames, io, config = {}, states = sharedStates) {
+  const live = new Set(codeNames);
+  for (const codeName of codeNames) {
+    try {
+      checkOne(codeName, io, config, states);
+    } catch (err) {
+      io.log(`[channel-input-watchdog] '${codeName}': ${err.message}`);
+    }
+  }
+  for (const key of [...states.keys()]) {
+    if (!live.has(key)) states.delete(key);
+  }
+  for (const key of [...giveUpCounts.keys()]) {
+    if (!live.has(key)) giveUpCounts.delete(key);
+  }
+}
+function checkOne(codeName, io, config, states) {
+  const pane = io.capturePane(codeName);
+  if (!pane) {
+    states.delete(codeName);
+    return;
+  }
+  const attached = io.isClientAttached(codeName);
+  const effectiveConfig = attached ? {
+    ...config,
+    stuckThresholdMs: config.attachedStuckThresholdMs ?? ATTACHED_STUCK_THRESHOLD_MS
+  } : config;
+  const prev = states.get(codeName);
+  const { fire, dialog, gaveUp, next } = decide(pane, prev, io.now(), effectiveConfig);
+  if (next === void 0) {
+    states.delete(codeName);
+    if (prev && prev.fires > 0) {
+      io.log(
+        `[channel-input-watchdog] '${codeName}': recovered after ${prev.fires} fire(s) \u2014 input submitted (input_hash=${prev.lastInputHash})`
+      );
+    }
+  } else {
+    states.set(codeName, next);
+  }
+  if (dialog) {
+    io.log(
+      `[channel-input-watchdog] '${codeName}': ${dialog.logMessage} (dialog was blocking the input box)`
+    );
+    io.sendKeys(codeName, dialog.keys, dialog.interKeyDelayMs);
+    return;
+  }
+  const text = extractInputBoxText(pane) ?? "";
+  const hash = next?.lastInputHash ?? simpleTextHash(text);
+  if (gaveUp) {
+    const maxFires = effectiveConfig.maxEnterFires ?? MAX_ENTER_FIRES;
+    io.log(
+      `[channel-input-watchdog] '${codeName}': GIVING UP after ${maxFires} Enter attempts \u2014 input remains unsubmitted (input_hash=${hash}, len=${text.length})`
+    );
+    giveUpCounts.set(codeName, (giveUpCounts.get(codeName) ?? 0) + 1);
+    try {
+      io.signalGiveUp?.(codeName);
+    } catch (err) {
+      io.log(
+        `[channel-input-watchdog] '${codeName}': give-up signal write failed: ${err.message}`
+      );
+    }
+    return;
+  }
+  if (fire) {
+    const maxFires = effectiveConfig.maxEnterFires ?? MAX_ENTER_FIRES;
+    const attempt = next?.fires ?? 1;
+    const busy = isActivelyProcessing(pane);
+    const keys = selectFireKeys(attempt, effectiveConfig.healMode);
+    if (keys.length === 1 && keys[0] === "Enter") {
+      io.log(
+        `[channel-input-watchdog] '${codeName}': stuck channel input \u2014 firing Enter (attempt ${attempt}/${maxFires}, busy=${busy}, input_hash=${hash}, len=${text.length})`
+      );
+      io.sendEnter(codeName);
+    } else {
+      io.log(
+        `[channel-input-watchdog] '${codeName}': stuck channel input \u2014 escalating to disturb sequence ${keys.join("\u2192")} (attempt ${attempt}/${maxFires}, busy=${busy}, input_hash=${hash}, len=${text.length})`
+      );
+      io.sendKeys(codeName, keys, DISTURB_INTER_KEY_DELAY_MS);
+    }
+  }
+}
+var sharedStates = /* @__PURE__ */ new Map();
+var giveUpCounts = /* @__PURE__ */ new Map();
+function takeWatchdogGiveUpCount(codeName) {
+  const count = giveUpCounts.get(codeName) ?? 0;
+  giveUpCounts.delete(codeName);
+  return count;
+}
+function creditWatchdogGiveUpCount(codeName, count) {
+  if (count <= 0) return;
+  giveUpCounts.set(codeName, (giveUpCounts.get(codeName) ?? 0) + count);
+}
+
 // src/lib/persistent-session.ts
 function syncClaudeCredsToRoot() {
   if (platform() !== "linux") return true;
   if (typeof process.getuid !== "function" || process.getuid() !== 0) return true;
   for (const filename of [".credentials.json", "credentials.json"]) {
-    if (existsSync2(join2("/root/.claude", filename))) return true;
+    if (existsSync3(join2("/root/.claude", filename))) return true;
   }
   let sourcePath = null;
   try {
@@ -199,7 +579,7 @@ function syncClaudeCredsToRoot() {
       if (!entry.isDirectory()) continue;
       for (const filename of [".credentials.json", "credentials.json"]) {
         const candidate = join2("/home", entry.name, ".claude", filename);
-        if (existsSync2(candidate)) {
+        if (existsSync3(candidate)) {
           sourcePath = candidate;
           break outer;
         }
@@ -212,7 +592,7 @@ function syncClaudeCredsToRoot() {
   const sourceFilename = sourcePath.endsWith("credentials.json") && !sourcePath.endsWith(".credentials.json") ? "credentials.json" : ".credentials.json";
   const targetPath = join2(targetDir, sourceFilename);
   try {
-    if (!existsSync2(targetDir)) mkdirSync2(targetDir, { recursive: true, mode: 448 });
+    if (!existsSync3(targetDir)) mkdirSync2(targetDir, { recursive: true, mode: 448 });
     copyFileSync(sourcePath, targetPath);
     chmodSync(targetPath, 384);
     return true;
@@ -224,13 +604,13 @@ var cachedClaudePath = null;
 function resolveClaudeBinary() {
   if (cachedClaudePath) return cachedClaudePath;
   const override = process.env.CLAUDE_PATH;
-  if (override && existsSync2(override)) {
+  if (override && existsSync3(override)) {
     cachedClaudePath = override;
     return override;
   }
   try {
     const out = execSync("which claude 2>/dev/null", { encoding: "utf-8" }).trim();
-    if (out && existsSync2(out)) {
+    if (out && existsSync3(out)) {
       cachedClaudePath = out;
       return out;
     }
@@ -242,7 +622,7 @@ function resolveClaudeBinary() {
     "/usr/local/bin/claude"
   ];
   for (const p of candidates) {
-    if (existsSync2(p)) {
+    if (existsSync3(p)) {
       cachedClaudePath = p;
       return p;
     }
@@ -260,7 +640,7 @@ function writePersistentClaudeWrapper(args) {
     // --dangerously-skip-permissions on dedicated EC2 hosts.
     "export IS_SANDBOX=1"
   ];
-  if (existsSync2(envIntegrationsPath)) {
+  if (existsSync3(envIntegrationsPath)) {
     wrapperLines.push(
       "set -a",
       `source ${JSON.stringify(envIntegrationsPath)}`,
@@ -277,9 +657,9 @@ function writePersistentClaudeWrapper(args) {
   return wrapperPath;
 }
 function collectMcpServerNames(mcpConfigPath) {
-  if (!existsSync2(mcpConfigPath)) return [];
+  if (!existsSync3(mcpConfigPath)) return [];
   try {
-    const data = JSON.parse(readFileSync3(mcpConfigPath, "utf-8"));
+    const data = JSON.parse(readFileSync4(mcpConfigPath, "utf-8"));
     const servers = data.mcpServers;
     return servers ? Object.keys(servers) : [];
   } catch {
@@ -293,7 +673,7 @@ function getAcpxBin() {
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
     const candidate = join2(dir, "node_modules", ".bin", "acpx");
-    if (existsSync2(candidate)) {
+    if (existsSync3(candidate)) {
       _acpxBin = candidate;
       return _acpxBin;
     }
@@ -311,7 +691,7 @@ function getAcpxBin() {
 }
 function defaultAcpxSessionProbe(acpxBin, projectDir) {
   try {
-    execFileSync(acpxBin, ["claude", "list-sessions"], {
+    execFileSync3(acpxBin, ["claude", "list-sessions"], {
       cwd: projectDir,
       timeout: 5e3,
       stdio: "ignore"
@@ -357,9 +737,9 @@ function setupPaneLog(tmuxSession, codeName, log) {
 }
 function readPaneLogTail(codeName, lines = PANE_TAIL_LINES) {
   const logPath = paneLogPath(codeName);
-  if (!existsSync2(logPath)) return null;
+  if (!existsSync3(logPath)) return null;
   try {
-    const raw = readFileSync3(logPath, "utf-8");
+    const raw = readFileSync4(logPath, "utf-8");
     if (!raw) return null;
     const stripped = raw.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
     const all = stripped.split("\n").filter((l) => l.length > 0);
@@ -377,7 +757,7 @@ function prepareForRespawn(codeName) {
   const session = sessions.get(codeName);
   if (!session) return null;
   const signature = detectFailureSignature(session.lastFailureTail);
-  if (signature === "session_id_in_use" && session.consecutiveSameUuidFailures >= 2) {
+  if (session.consecutiveSameUuidFailures >= 2) {
     const failureCount = session.consecutiveSameUuidFailures;
     const newId = rotateDailySession(
       codeName,
@@ -386,7 +766,7 @@ function prepareForRespawn(codeName) {
     );
     session.consecutiveSameUuidFailures = 0;
     session.lastFailureSessionId = null;
-    return `rotated daily-session UUID to ${newId} after ${failureCount}+ "Session ID already in use" failures`;
+    return `rotated daily-session UUID to ${newId} after ${failureCount} consecutive failures on the same UUID (signature=${signature})`;
   }
   return null;
 }
@@ -399,6 +779,27 @@ function getLastFailureContext(codeName) {
     restartCount: session?.restartCount ?? 0
   };
 }
+function resolveSessionSpawnDecision(args) {
+  const { codeName, projectDir, agentTimezone } = args;
+  const now = args.now ?? /* @__PURE__ */ new Date();
+  const disableFlag = process.env["AGT_DISABLE_SESSION_RESUME"];
+  const resumeDisabled = disableFlag === "1" || disableFlag?.toLowerCase() === "true";
+  if (resumeDisabled) {
+    return { flag: "--session-id", sessionId: randomUUID2(), reason: "resume-disabled" };
+  }
+  const daily = getOrCreateDailySession(codeName, now, agentTimezone);
+  if (!daily.isNew && sessionFileExists(projectDir, daily.sessionId)) {
+    return { flag: "--resume", sessionId: daily.sessionId, reason: "resume-today" };
+  }
+  if (daily.isNew) {
+    return { flag: "--session-id", sessionId: daily.sessionId, reason: "fresh-new-day" };
+  }
+  return {
+    flag: "--session-id",
+    sessionId: rotateDailySession(codeName, now, agentTimezone),
+    reason: "rotated-missing-transcript"
+  };
+}
 function startPersistentSession(config) {
   const existing = sessions.get(config.codeName);
   if (existing && existing.status === "running") {
@@ -447,7 +848,7 @@ function spawnSession(config, session) {
       const claudeDir = join2(homedir2(), ".claude");
       for (const filename of [".credentials.json", "credentials.json"]) {
         const p = join2(claudeDir, filename);
-        if (existsSync2(p)) {
+        if (existsSync3(p)) {
           try {
             rmSync(p, { force: true });
             log(`[persistent-session] Removed ${p} (api_key mode active \u2014 preventing OAuth fallback)`);
@@ -460,9 +861,17 @@ function spawnSession(config, session) {
       }
     }
     const args = [];
-    const sessionId = randomUUID2();
-    args.push("--session-id", sessionId);
-    log(`[persistent-session] Starting fresh session ${sessionId} for '${codeName}'`);
+    const decision = resolveSessionSpawnDecision({
+      codeName,
+      projectDir,
+      agentTimezone: config.agentTimezone ?? void 0
+    });
+    const sessionId = decision.sessionId;
+    const resuming = decision.flag === "--resume";
+    args.push(decision.flag, sessionId);
+    log(
+      `[persistent-session] ${resuming ? "Resuming" : "Starting"} session ${sessionId} for '${codeName}' (${decision.reason})`
+    );
     try {
       markDailySessionSpawn(codeName, sessionId, /* @__PURE__ */ new Date(), config.agentTimezone ?? void 0);
     } catch (err) {
@@ -473,7 +882,7 @@ function spawnSession(config, session) {
     if (channels.length > 0) args.push("--channels", ...channels);
     if (devChannels.length > 0) args.push("--dangerously-load-development-channels", ...devChannels);
     args.push("--mcp-config", mcpConfigPath);
-    if (existsSync2(claudeMdPath)) args.push("--system-prompt-file", claudeMdPath);
+    if (existsSync3(claudeMdPath)) args.push("--system-prompt-file", claudeMdPath);
     const modelAlias = claudeModelAlias(config.primaryModel);
     if (modelAlias) args.push("--model", modelAlias);
     args.push("--allow-dangerously-skip-permissions");
@@ -482,7 +891,7 @@ function spawnSession(config, session) {
     args.push("--name", tmuxSession);
     const mcpServerNames = collectMcpServerNames(mcpConfigPath);
     args.push("--allowedTools", buildAllowedTools(mcpServerNames));
-    const initPrompt = 'You are now online. Say "Ready." and wait for incoming messages. Do not run any tools or load any data until a message arrives.';
+    const initPrompt = resuming ? "" : 'You are now online. Say "Ready." and wait for incoming messages. Do not run any tools or load any data until a message arrives.';
     const claudeBin = resolveClaudeBinary();
     const claudeArgsJoined = args.map((a) => a.includes(" ") || a.includes("*") ? JSON.stringify(a) : a).join(" ");
     const wrapperPath = writePersistentClaudeWrapper({
@@ -507,6 +916,16 @@ function spawnSession(config, session) {
     if (config.runId) {
       tmuxEnv["AGT_RUN_ID"] = config.runId;
     }
+    for (const f of probeMcpEnvSubstitution({
+      mcpConfigPath,
+      envIntegrationsPath: join2(projectDir, ".env.integrations"),
+      baseEnv: {
+        ...tmuxEnv,
+        ...claudeAuthMode === "api_key" && config.anthropicApiKey ? { ANTHROPIC_API_KEY: config.anthropicApiKey } : {}
+      }
+    })) {
+      log(`[persistent-session] ${formatMissingVar(f)} agent=${codeName}`);
+    }
     const child = spawn("tmux", [
       "new-session",
       "-d",
@@ -551,12 +970,6 @@ function spawnSession(config, session) {
     session.restartCount++;
   }
 }
-function isLoginPickerVisible(screen) {
-  return screen.includes("Select login method") || screen.includes("Claude account with subscription") && screen.includes("Anthropic Console account");
-}
-function isResumeModeDialogVisible(screen) {
-  return screen.includes("Resume from summary") && screen.includes("Don't ask me again");
-}
 function hasMcpChildren(tmuxSession) {
   try {
     const claudePidOut = execSync(
@@ -606,40 +1019,10 @@ async function acceptDialogs(tmuxSession, codeName, log, primaryModel = null, se
         continue;
       }
       dialogIterations++;
-      if (screen.includes("Choose the text style") || screen.includes("Dark mode") && screen.includes("Light mode")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log(`[persistent-session] Auto-accepted theme picker for '${codeName}'`);
-        continue;
-      }
-      if (screen.includes("Yes, I trust this folder")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log(`[persistent-session] Auto-accepted workspace trust for '${codeName}'`);
-        continue;
-      }
-      if (isResumeModeDialogVisible(screen)) {
-        execFileSync("tmux", ["send-keys", "-t", tmuxSession, "3"], { stdio: "ignore" });
-        await new Promise((r) => setTimeout(r, 300));
-        execFileSync("tmux", ["send-keys", "-t", tmuxSession, "Enter"], { stdio: "ignore" });
-        log(
-          `[persistent-session] Auto-dismissed resume-mode dialog for '${codeName}' (picked 'Don't ask me again')`
-        );
-        continue;
-      }
-      if (screen.includes("I am using this for local development")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log(`[persistent-session] Auto-accepted dev channels for '${codeName}'`);
-        continue;
-      }
-      if (screen.includes("Enter to confirm") && screen.includes("MCP")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log(`[persistent-session] Auto-accepted MCP servers for '${codeName}'`);
-        continue;
-      }
-      if (screen.includes("Yes, I accept") && screen.includes("Bypass Permissions")) {
-        execSync(`tmux send-keys -t ${tmuxSession} 2`, { stdio: "ignore" });
-        await new Promise((r) => setTimeout(r, 300));
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log(`[persistent-session] Auto-accepted bypass permissions for '${codeName}'`);
+      const dialogAction = sweepDialogs(screen);
+      if (dialogAction) {
+        await sendDialogKeys(tmuxSession, dialogAction);
+        log(`[persistent-session] ${dialogAction.logMessage} for '${codeName}'`);
         continue;
       }
       if (screen.includes("\u276F") && !screen.includes("Enter to confirm")) {
@@ -690,7 +1073,7 @@ async function waitForPromptReady(tmuxSession) {
   const deadline = Date.now() + 1e4;
   while (Date.now() < deadline) {
     try {
-      const screen = execFileSync(
+      const screen = execFileSync3(
         "tmux",
         ["capture-pane", "-t", tmuxSession, "-p"],
         { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
@@ -709,11 +1092,11 @@ function sleepBlockingMs(ms) {
 }
 function defaultArmSender(tmuxSession, command) {
   try {
-    execFileSync("tmux", ["send-keys", "-t", tmuxSession, "-l", command], {
+    execFileSync3("tmux", ["send-keys", "-t", tmuxSession, "-l", command], {
       stdio: ["ignore", "ignore", "pipe"]
     });
     sleepBlockingMs(SEND_KEYS_ENTER_DELAY_MS);
-    execFileSync("tmux", ["send-keys", "-t", tmuxSession, "Enter"], {
+    execFileSync3("tmux", ["send-keys", "-t", tmuxSession, "Enter"], {
       stdio: ["ignore", "ignore", "pipe"]
     });
     return true;
@@ -722,6 +1105,50 @@ function defaultArmSender(tmuxSession, command) {
   }
 }
 var armSender = defaultArmSender;
+function defaultPaneCapture(tmuxSession) {
+  try {
+    return execFileSync3("tmux", ["capture-pane", "-t", tmuxSession, "-p"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    });
+  } catch {
+    return null;
+  }
+}
+var paneCapture = defaultPaneCapture;
+var defaultHygieneKeySender = async (tmuxSession, keys, interKeyDelayMs) => {
+  for (let i = 0; i < keys.length; i++) {
+    if (i > 0 && interKeyDelayMs > 0) {
+      await new Promise((r) => setTimeout(r, interKeyDelayMs));
+    }
+    execFileSync3("tmux", ["send-keys", "-t", tmuxSession, keys[i]], {
+      stdio: "ignore"
+    });
+  }
+};
+var hygieneKeySender = defaultHygieneKeySender;
+async function preSendPaneHygiene(tmuxSession, codeName, log) {
+  try {
+    let screen = paneCapture(tmuxSession);
+    if (screen === null) return;
+    const action = sweepDialogs(screen);
+    if (action) {
+      await hygieneKeySender(tmuxSession, action.keys, action.interKeyDelayMs);
+      log(`[inject] ${action.logMessage} for '${codeName}' before injection`);
+      await new Promise((r) => setTimeout(r, 300));
+      screen = paneCapture(tmuxSession) ?? "";
+    }
+    const orphan = extractInputBoxText(screen);
+    if (orphan) {
+      log(
+        `[inject] clearing orphaned input for '${codeName}' before injection (input_hash=${simpleTextHash(orphan)}, len=${orphan.length})`
+      );
+      await hygieneKeySender(tmuxSession, ["C-u"], 0);
+    }
+  } catch {
+  }
+}
 function sendToAgent(tmuxSession, command) {
   return armSender(tmuxSession, command);
 }
@@ -732,6 +1159,14 @@ var _internals = {
   isLoginPickerVisible,
   isResumeModeDialogVisible,
   detectFailureSignature,
+  // ENG-6039 test seams: seed/clear the module-private session map so
+  // prepareForRespawn's rotation gate can be exercised without tmux.
+  __seedSession(session) {
+    sessions.set(session.codeName, session);
+  },
+  __clearSessions() {
+    sessions.clear();
+  },
   isClaudeProcessAliveInTmux,
   waitForPromptReady,
   // ENG-5770: exported so the unit test in claude-model-alias.test.ts can
@@ -744,6 +1179,17 @@ var _internals = {
   __setArmSender(fn) {
     armSender = fn ?? defaultArmSender;
   },
+  // ENG-6017 test seam: swap the pane capture used by the inject-time
+  // hygiene so unit tests can simulate dialog overlays / orphaned input
+  // without a tmux server. null restores the real capture.
+  __setPaneCapture(fn) {
+    paneCapture = fn ?? defaultPaneCapture;
+  },
+  // ENG-6017 test seam: swap the hygiene key sender (dialog dismissal +
+  // C-u clear) so unit tests can assert keystrokes without tmux.
+  __setHygieneKeySender(fn) {
+    hygieneKeySender = fn ?? defaultHygieneKeySender;
+  },
   // ENG-5758 test seam: swap the acpx session probe so unit tests can
   // simulate "session present" / "no session" without spawning acpx.
   __setAcpxSessionProbe(fn) {
@@ -818,6 +1264,7 @@ async function injectMessageWithStatus(codeName, type, content, meta, log) {
     _log(`[inject] acpx binary not found \u2014 falling back to tmux send-keys`);
   }
   const singleLineText = text.replace(/\s*\n+\s*/g, " ").trim();
+  await preSendPaneHygiene(`agt-${codeName}`, codeName, _log);
   const sent = sendToAgent(`agt-${codeName}`, singleLineText);
   if (sent) {
     _log(`[inject] tmux send-keys sent for '${codeName}' \u2014 unverified (delivered=false, fallbackUsed=true)`);
@@ -838,7 +1285,7 @@ function stopPersistentSession(codeName, log) {
   try {
     const acpx = getAcpxBin();
     if (acpx) {
-      execFileSync(acpx, ["claude", "sessions", "close", `agt-${codeName}`], {
+      execFileSync3(acpx, ["claude", "sessions", "close", `agt-${codeName}`], {
         cwd: getProjectDir(codeName),
         timeout: 5e3,
         stdio: "ignore"
@@ -859,21 +1306,8 @@ var ZOMBIE_PROBE_TTL_MS = 3e4;
 var ZOMBIE_STARTUP_GRACE_MS = 6e4;
 var zombieProbeCache = /* @__PURE__ */ new Map();
 var pendingZombieDetections = /* @__PURE__ */ new Map();
-function escapePgrepRegex(value) {
-  return value.replace(/[.[\]{}()*+?^$|\\]/g, "\\$&");
-}
 function isClaudeProcessAliveInTmux(tmuxSession) {
-  try {
-    const escapedSession = escapePgrepRegex(tmuxSession);
-    const pattern = `(^|[[:space:]])--name ${escapedSession}([[:space:]]|$)`;
-    const out = execFileSync("pgrep", ["-f", "--", pattern], {
-      encoding: "utf-8",
-      timeout: 3e3
-    }).trim();
-    return out.length > 0;
-  } catch {
-    return false;
-  }
+  return probeClaudeProcessInTmux(tmuxSession) === "alive";
 }
 function takeZombieDetection(codeName) {
   const record = pendingZombieDetections.get(codeName);
@@ -928,7 +1362,7 @@ function isSessionHealthy(codeName) {
     if (!claudeAlive) {
       const paneTail = readPaneLogTail(codeName);
       try {
-        execFileSync("tmux", ["kill-session", "-t", tmuxSession], { stdio: "ignore" });
+        execFileSync3("tmux", ["kill-session", "-t", tmuxSession], { stdio: "ignore" });
       } catch {
       }
       session.status = "crashed";
@@ -968,13 +1402,13 @@ function collectDiagnostics(codeNames) {
     let launchArgs = null;
     let channelStatus = null;
     try {
-      execFileSync("tmux", ["has-session", "-t", tmuxSession], { stdio: "ignore" });
+      execFileSync3("tmux", ["has-session", "-t", tmuxSession], { stdio: "ignore" });
       tmuxAlive = true;
     } catch {
     }
     if (tmuxAlive) {
       try {
-        screenCapture = execFileSync("tmux", ["capture-pane", "-t", tmuxSession, "-p", "-S", "-30"], {
+        screenCapture = execFileSync3("tmux", ["capture-pane", "-t", tmuxSession, "-p", "-S", "-30"], {
           encoding: "utf-8",
           timeout: 3e3
         }).trim();
@@ -982,7 +1416,7 @@ function collectDiagnostics(codeNames) {
       }
     }
     try {
-      const psOutput = execFileSync("ps", ["aux"], { encoding: "utf-8", timeout: 3e3 });
+      const psOutput = execFileSync3("ps", ["aux"], { encoding: "utf-8", timeout: 3e3 });
       const line = psOutput.split("\n").find((l) => l.includes(`agt-${codeName}`) && !l.includes("grep"));
       if (line) {
         const match = line.match(/claude\s+.*/);
@@ -1052,7 +1486,7 @@ function writeAcpxConfig(config) {
   if (channels.length > 0) claudeArgs.push("--channels", ...channels);
   if (devChannels.length > 0) claudeArgs.push("--dangerously-load-development-channels", ...devChannels);
   claudeArgs.push("--mcp-config", mcpConfigPath);
-  if (existsSync2(claudeMdPath)) claudeArgs.push("--system-prompt-file", claudeMdPath);
+  if (existsSync3(claudeMdPath)) claudeArgs.push("--system-prompt-file", claudeMdPath);
   const acpModelAlias = claudeModelAlias(config.primaryModel);
   if (acpModelAlias) claudeArgs.push("--model", acpModelAlias);
   claudeArgs.push("--allow-dangerously-skip-permissions");
@@ -1064,7 +1498,7 @@ function writeAcpxConfig(config) {
   const envIntegrationsPath = join2(projectDir, ".env.integrations");
   const wrapperPath = join2(projectDir, ".claude", "acpx-agent.sh");
   const wrapperLines = ["#!/usr/bin/env bash"];
-  if (existsSync2(envIntegrationsPath)) {
+  if (existsSync3(envIntegrationsPath)) {
     wrapperLines.push(`set -a`, `source ${JSON.stringify(envIntegrationsPath)}`, `set +a`);
   }
   if (claudeAuthMode === "api_key" && anthropicApiKey) {
@@ -1087,18 +1521,25 @@ function writeAcpxConfig(config) {
 }
 
 export {
+  formatMissingVar,
+  parseEnvIntegrations,
+  probeMcpEnvSubstitution,
   sanitizeMcpJson,
   buildAllowedTools,
   sessionTranscriptDir,
   isAgentIdle,
   isStaleForToday,
   peekCurrentSession,
+  checkChannelInputs,
+  takeWatchdogGiveUpCount,
+  creditWatchdogGiveUpCount,
   resolveClaudeBinary,
   writePersistentClaudeWrapper,
   paneLogPath,
   readPaneLogTail,
   prepareForRespawn,
   getLastFailureContext,
+  resolveSessionSpawnDecision,
   startPersistentSession,
   SEND_KEYS_ENTER_DELAY_MS,
   sendToAgent,
@@ -1116,4 +1557,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-GN4XPQWJ.js.map
+//# sourceMappingURL=chunk-SJPAXXTW.js.map