@integrity-labs/agt-cli 0.16.0 → 0.16.2

package/dist/{chunk-AFUG4KD3.js → chunk-EG5D3KUV.js}

@@ -1,8 +1,8 @@
 // src/lib/persistent-session.ts
 import { spawn, execSync, execFileSync } from "child_process";
-import { join, dirname } from "path";
-import { homedir, platform } from "os";
-import { existsSync, readFileSync as readFileSync2, readdirSync, writeFileSync as writeFileSync2, mkdirSync, chmodSync, copyFileSync, rmSync } from "fs";
+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 { fileURLToPath } from "url";
 
 // src/lib/mcp-sanitize.ts
@@ -46,12 +46,132 @@ function buildAllowedTools(mcpServerNames) {
   return [...mcpPatterns, ...BASE_TOOLS].join(",");
 }
 
+// src/lib/daily-session.ts
+import { randomUUID } from "crypto";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, renameSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var HISTORY_DAYS = 7;
+function profileDir(codeName) {
+  return join(homedir(), ".augmented", codeName);
+}
+function dailySessionPath(codeName) {
+  return join(profileDir(codeName), "daily-session.json");
+}
+function todayLocalIso(now = /* @__PURE__ */ new Date()) {
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function readFile(codeName) {
+  const path = dailySessionPath(codeName);
+  if (!existsSync(path)) return { current: null, history: [] };
+  try {
+    const raw = readFileSync2(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      current: parsed.current ?? null,
+      history: Array.isArray(parsed.history) ? parsed.history : []
+    };
+  } catch {
+    return { current: null, history: [] };
+  }
+}
+function writeFile(codeName, data) {
+  const dir = profileDir(codeName);
+  mkdirSync(dir, { recursive: true });
+  const finalPath = dailySessionPath(codeName);
+  const tmpPath = `${finalPath}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync2(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+  renameSync(tmpPath, finalPath);
+}
+function trimHistory(history, now) {
+  const cutoff = new Date(now);
+  cutoff.setDate(cutoff.getDate() - HISTORY_DAYS);
+  const cutoffIso = todayLocalIso(cutoff);
+  return history.filter((h) => h.date >= cutoffIso).slice(0, HISTORY_DAYS);
+}
+function getOrCreateDailySession(codeName, now = /* @__PURE__ */ new Date()) {
+  const today = todayLocalIso(now);
+  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
+  );
+  writeFile(codeName, { current: next, history });
+  return { sessionId: next.sessionId, isNew: true };
+}
+function rotateDailySession(codeName, now = /* @__PURE__ */ new Date()) {
+  const today = todayLocalIso(now);
+  const file = readFile(codeName);
+  const next = {
+    date: today,
+    sessionId: randomUUID(),
+    startedAt: now.toISOString()
+  };
+  const history = trimHistory(
+    [...file.current ? [file.current] : [], ...file.history],
+    now
+  );
+  writeFile(codeName, { current: next, history });
+  return next.sessionId;
+}
+function encodeProjectPath(projectDir) {
+  return "-" + projectDir.replace(/^\//, "").replace(/[/.]/g, "-");
+}
+function sessionFileExists(projectDir, sessionId) {
+  const path = join(
+    homedir(),
+    ".claude",
+    "projects",
+    encodeProjectPath(projectDir),
+    `${sessionId}.jsonl`
+  );
+  return existsSync(path);
+}
+function sessionFilePath(projectDir, sessionId) {
+  return join(
+    homedir(),
+    ".claude",
+    "projects",
+    encodeProjectPath(projectDir),
+    `${sessionId}.jsonl`
+  );
+}
+function isAgentIdle(projectDir, sessionId, idleSeconds = 60, now = /* @__PURE__ */ new Date()) {
+  const path = sessionFilePath(projectDir, sessionId);
+  if (!existsSync(path)) return true;
+  try {
+    const mtimeMs = statSync(path).mtimeMs;
+    return now.getTime() - mtimeMs >= idleSeconds * 1e3;
+  } catch {
+    return false;
+  }
+}
+function isStaleForToday(codeName, now = /* @__PURE__ */ new Date()) {
+  const file = readFile(codeName);
+  if (!file.current) return false;
+  return file.current.date !== todayLocalIso(now);
+}
+function peekCurrentSession(codeName) {
+  return readFile(codeName).current;
+}
+
 // 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 (existsSync(join("/root/.claude", filename))) return true;
+    if (existsSync2(join2("/root/.claude", filename))) return true;
   }
   let sourcePath = null;
   try {
@@ -59,8 +179,8 @@ function syncClaudeCredsToRoot() {
     outer: for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       for (const filename of [".credentials.json", "credentials.json"]) {
-        const candidate = join("/home", entry.name, ".claude", filename);
-        if (existsSync(candidate)) {
+        const candidate = join2("/home", entry.name, ".claude", filename);
+        if (existsSync2(candidate)) {
           sourcePath = candidate;
           break outer;
         }
@@ -71,9 +191,9 @@ function syncClaudeCredsToRoot() {
   if (!sourcePath) return false;
   const targetDir = "/root/.claude";
   const sourceFilename = sourcePath.endsWith("credentials.json") && !sourcePath.endsWith(".credentials.json") ? "credentials.json" : ".credentials.json";
-  const targetPath = join(targetDir, sourceFilename);
+  const targetPath = join2(targetDir, sourceFilename);
   try {
-    if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true, mode: 448 });
+    if (!existsSync2(targetDir)) mkdirSync2(targetDir, { recursive: true, mode: 448 });
     copyFileSync(sourcePath, targetPath);
     chmodSync(targetPath, 384);
     return true;
@@ -85,13 +205,13 @@ var cachedClaudePath = null;
 function resolveClaudeBinary() {
   if (cachedClaudePath) return cachedClaudePath;
   const override = process.env.CLAUDE_PATH;
-  if (override && existsSync(override)) {
+  if (override && existsSync2(override)) {
     cachedClaudePath = override;
     return override;
   }
   try {
     const out = execSync("which claude 2>/dev/null", { encoding: "utf-8" }).trim();
-    if (out && existsSync(out)) {
+    if (out && existsSync2(out)) {
       cachedClaudePath = out;
       return out;
     }
@@ -103,7 +223,7 @@ function resolveClaudeBinary() {
     "/usr/local/bin/claude"
   ];
   for (const p of candidates) {
-    if (existsSync(p)) {
+    if (existsSync2(p)) {
       cachedClaudePath = p;
       return p;
     }
@@ -111,9 +231,9 @@ function resolveClaudeBinary() {
   return "claude";
 }
 function collectMcpServerNames(mcpConfigPath) {
-  if (!existsSync(mcpConfigPath)) return [];
+  if (!existsSync2(mcpConfigPath)) return [];
   try {
-    const data = JSON.parse(readFileSync2(mcpConfigPath, "utf-8"));
+    const data = JSON.parse(readFileSync3(mcpConfigPath, "utf-8"));
     const servers = data.mcpServers;
     return servers ? Object.keys(servers) : [];
   } catch {
@@ -126,8 +246,8 @@ function getAcpxBin() {
   const moduleDir = dirname(fileURLToPath(import.meta.url));
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join(dir, "node_modules", ".bin", "acpx");
-    if (existsSync(candidate)) {
+    const candidate = join2(dir, "node_modules", ".bin", "acpx");
+    if (existsSync2(candidate)) {
       _acpxBin = candidate;
       return _acpxBin;
     }
@@ -144,6 +264,70 @@ function getAcpxBin() {
   }
 }
 var sessions = /* @__PURE__ */ new Map();
+var PANE_LOG_DIR = join2(homedir2(), ".augmented");
+var PANE_TAIL_LINES = 20;
+function paneLogPath(codeName) {
+  return join2(PANE_LOG_DIR, codeName, "pane.log");
+}
+function setupPaneLog(tmuxSession, codeName, log) {
+  const logPath = paneLogPath(codeName);
+  try {
+    mkdirSync2(dirname(logPath), { recursive: true });
+    appendFileSync(
+      logPath,
+      `
+--- spawn ${(/* @__PURE__ */ new Date()).toISOString()} (session ${tmuxSession}) ---
+`,
+      "utf-8"
+    );
+    execSync(
+      `tmux pipe-pane -o -t ${tmuxSession} 'cat >> ${logPath.replace(/'/g, `'\\''`)}'`,
+      { stdio: "ignore" }
+    );
+  } catch (err) {
+    log(`[persistent-session] pipe-pane setup failed for '${codeName}': ${err.message}`);
+  }
+}
+function readPaneLogTail(codeName, lines = PANE_TAIL_LINES) {
+  const logPath = paneLogPath(codeName);
+  if (!existsSync2(logPath)) return null;
+  try {
+    const raw = readFileSync3(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);
+    return all.slice(-lines).join("\n");
+  } catch {
+    return null;
+  }
+}
+function detectFailureSignature(tail) {
+  if (!tail) return "unknown";
+  if (/Session ID .* is already in use/i.test(tail)) return "session_id_in_use";
+  return "unknown";
+}
+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) {
+    const failureCount = session.consecutiveSameUuidFailures;
+    const newId = rotateDailySession(codeName);
+    session.consecutiveSameUuidFailures = 0;
+    session.lastFailureSessionId = null;
+    return `rotated daily-session UUID to ${newId} after ${failureCount}+ "Session ID already in use" failures`;
+  }
+  return null;
+}
+function getLastFailureContext(codeName) {
+  const session = sessions.get(codeName);
+  return {
+    tail: session?.lastFailureTail ?? null,
+    signature: detectFailureSignature(session?.lastFailureTail ?? null),
+    consecutiveSameUuid: session?.consecutiveSameUuidFailures ?? 0,
+    restartCount: session?.restartCount ?? 0
+  };
+}
 function startPersistentSession(config) {
   const existing = sessions.get(config.codeName);
   if (existing && existing.status === "running") {
@@ -160,7 +344,11 @@ function startPersistentSession(config) {
     codeName: config.codeName,
     startedAt: null,
     restartCount,
-    status: "starting"
+    status: "starting",
+    currentSessionId: existing?.currentSessionId ?? null,
+    lastFailureTail: existing?.lastFailureTail ?? null,
+    lastFailureSessionId: existing?.lastFailureSessionId ?? null,
+    consecutiveSameUuidFailures: existing?.consecutiveSameUuidFailures ?? 0
   };
   sessions.set(config.codeName, session);
   spawnSession(config, session);
@@ -184,10 +372,10 @@ function spawnSession(config, session) {
         log(`[persistent-session] No Claude Code credentials found under /root/.claude or /home/*. Pair via browser from the host page, or run 'claude /login' on the host.`);
       }
     } else {
-      const claudeDir = join(homedir(), ".claude");
+      const claudeDir = join2(homedir2(), ".claude");
       for (const filename of [".credentials.json", "credentials.json"]) {
-        const p = join(claudeDir, filename);
-        if (existsSync(p)) {
+        const p = join2(claudeDir, filename);
+        if (existsSync2(p)) {
           try {
             rmSync(p, { force: true });
             log(`[persistent-session] Removed ${p} (api_key mode active \u2014 preventing OAuth fallback)`);
@@ -200,10 +388,21 @@ function spawnSession(config, session) {
       }
     }
     const args = [];
+    const dailySession = getOrCreateDailySession(codeName);
+    const claudeWillResume = !dailySession.isNew && sessionFileExists(projectDir, dailySession.sessionId);
+    if (claudeWillResume) {
+      args.push("--resume", dailySession.sessionId);
+      log(`[persistent-session] Resuming today's session ${dailySession.sessionId} for '${codeName}'`);
+    } else {
+      args.push("--session-id", dailySession.sessionId);
+      log(
+        `[persistent-session] Starting fresh session ${dailySession.sessionId} for '${codeName}' (${dailySession.isNew ? "new day" : "no JSONL on disk yet"})`
+      );
+    }
     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 (existsSync(claudeMdPath)) args.push("--system-prompt-file", claudeMdPath);
+    if (existsSync2(claudeMdPath)) args.push("--system-prompt-file", claudeMdPath);
     args.push("--allow-dangerously-skip-permissions");
     args.push("--dangerously-skip-permissions");
     args.push("--strict-mcp-config");
@@ -211,10 +410,10 @@ function spawnSession(config, session) {
     const mcpServerNames = collectMcpServerNames(mcpConfigPath);
     args.push("--allowedTools", buildAllowedTools(mcpServerNames));
     let envPrefix = "IS_SANDBOX=1 ";
-    const envIntegrationsPath = join(projectDir, ".env.integrations");
-    if (existsSync(envIntegrationsPath)) {
+    const envIntegrationsPath = join2(projectDir, ".env.integrations");
+    if (existsSync2(envIntegrationsPath)) {
       try {
-        const envContent = readFileSync2(envIntegrationsPath, "utf-8");
+        const envContent = readFileSync3(envIntegrationsPath, "utf-8");
         const envVars = envContent.split("\n").filter((line) => line && !line.startsWith("#") && line.includes("=")).map((line) => {
           const eqIdx = line.indexOf("=");
           const key = line.slice(0, eqIdx);
@@ -232,6 +431,14 @@ function spawnSession(config, session) {
     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 claudeBin = resolveClaudeBinary();
     const claudeCmd = `${envPrefix}${JSON.stringify(claudeBin)} ${JSON.stringify(initPrompt)} ${args.map((a) => a.includes(" ") || a.includes("*") ? JSON.stringify(a) : a).join(" ")}`;
+    const tmuxEnv = {
+      ...process.env,
+      // Treat empty-string as missing too — `HOME=""` makes ~ resolve
+      // to cwd, which is the same broken outcome as no HOME, just
+      // better hidden.
+      HOME: process.env.HOME?.trim() || homedir2(),
+      USER: process.env.USER?.trim() || userInfo().username
+    };
     const child = spawn("tmux", [
       "new-session",
       "-d",
@@ -244,7 +451,7 @@ function spawnSession(config, session) {
     ], {
       cwd: projectDir,
       stdio: ["ignore", "pipe", "pipe"],
-      env: process.env
+      env: tmuxEnv
     });
     child.on("close", (code) => {
       if (code !== 0) {
@@ -255,6 +462,8 @@ function spawnSession(config, session) {
         return;
       }
       log(`[persistent-session] tmux session '${tmuxSession}' created for '${codeName}'`);
+      setupPaneLog(tmuxSession, codeName, log);
+      session.currentSessionId = dailySession.sessionId;
       acceptDialogs(tmuxSession, codeName, log).catch(() => {
       });
     });
@@ -274,11 +483,58 @@ 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 hasMcpChildren(tmuxSession) {
+  try {
+    const claudePidOut = execSync(
+      `pgrep -f -- "--name ${tmuxSession}" 2>/dev/null || true`,
+      { encoding: "utf-8" }
+    ).trim();
+    if (!claudePidOut) return false;
+    const pids = claudePidOut.split("\n").map((p) => Number(p)).filter((p) => p > 0);
+    if (pids.length === 0) return false;
+    const claudePid = Math.max(...pids);
+    const childrenOut = execSync(
+      `pgrep -P ${claudePid} 2>/dev/null || true`,
+      { encoding: "utf-8" }
+    ).trim();
+    if (!childrenOut) return false;
+    const childPids = childrenOut.split("\n").map((p) => p.trim()).filter(Boolean);
+    for (const cp of childPids) {
+      const cmdline = execSync(
+        `cat /proc/${cp}/cmdline 2>/dev/null | tr '\\0' ' ' || ps -p ${cp} -o args= 2>/dev/null || true`,
+        { encoding: "utf-8" }
+      );
+      if (/slack-channel\.js|telegram-channel\.js|direct-chat-channel\.js|composio_/i.test(cmdline)) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
 async function acceptDialogs(tmuxSession, codeName, log) {
-  for (let i = 0; i < 15; i++) {
+  let loginPickerReported = false;
+  let dialogIterations = 0;
+  const MAX_DIALOG_ITERATIONS = 15;
+  let loginPickerIterations = 0;
+  const MAX_LOGIN_PICKER_ITERATIONS = 450;
+  while (dialogIterations < MAX_DIALOG_ITERATIONS && loginPickerIterations < MAX_LOGIN_PICKER_ITERATIONS) {
     await new Promise((r) => setTimeout(r, 2e3));
     try {
       const screen = execSync(`tmux capture-pane -t ${tmuxSession} -p 2>/dev/null`, { encoding: "utf-8" });
+      if (isLoginPickerVisible(screen)) {
+        if (!loginPickerReported) {
+          log(`[persistent-session] CLAUDE LOGIN REQUIRED for '${codeName}' \u2014 agent cannot start until ~/.claude.json is provisioned. Pair via the Hosts page or run 'claude /login' on the host.`);
+          loginPickerReported = true;
+        }
+        loginPickerIterations++;
+        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}'`);
@@ -307,14 +563,17 @@ async function acceptDialogs(tmuxSession, codeName, log) {
         continue;
       }
       if (screen.includes("\u276F") && !screen.includes("Enter to confirm")) {
-        log(`[persistent-session] Session ready for '${codeName}' \u2014 no more dialogs`);
-        break;
+        if (hasMcpChildren(tmuxSession)) {
+          log(`[persistent-session] Session ready for '${codeName}' \u2014 MCP servers spawned`);
+          break;
+        }
       }
     } catch {
       break;
     }
   }
 }
+var _internals = { isLoginPickerVisible, detectFailureSignature };
 async function injectMessage(codeName, type, content, meta, log) {
   const _log = log ?? ((_) => {
   });
@@ -329,10 +588,10 @@ async function injectMessage(codeName, type, content, meta, log) {
   const acpx = getAcpxBin();
   if (acpx) {
     try {
-      const tmpDir = join(projectDir, ".claude");
-      mkdirSync(tmpDir, { recursive: true });
-      const tmpFile = join(tmpDir, ".agt-inject-prompt.txt");
-      writeFileSync2(tmpFile, text);
+      const tmpDir = join2(projectDir, ".claude");
+      mkdirSync2(tmpDir, { recursive: true });
+      const tmpFile = join2(tmpDir, ".agt-inject-prompt.txt");
+      writeFileSync3(tmpFile, text);
       _log(`[inject] acpx exec (fire-and-forget): cwd=${projectDir}, file=${tmpFile}`);
       const child = spawn(acpx, ["claude", "exec", "-f", tmpFile], {
         cwd: projectDir,
@@ -392,6 +651,14 @@ function isSessionHealthy(codeName) {
     const session2 = sessions.get(codeName);
     if (session2 && session2.status === "running") {
       session2.status = "crashed";
+      session2.lastFailureTail = readPaneLogTail(codeName);
+      const failedUuid = session2.currentSessionId;
+      if (failedUuid && failedUuid === session2.lastFailureSessionId) {
+        session2.consecutiveSameUuidFailures += 1;
+      } else {
+        session2.consecutiveSameUuidFailures = 1;
+      }
+      session2.lastFailureSessionId = failedUuid;
     }
     return false;
   }
@@ -400,7 +667,11 @@ function isSessionHealthy(codeName) {
       codeName,
       startedAt: Date.now(),
       restartCount: 0,
-      status: "running"
+      status: "running",
+      currentSessionId: null,
+      lastFailureTail: null,
+      lastFailureSessionId: null,
+      consecutiveSameUuidFailures: 0
     });
   }
   const session = sessions.get(codeName);
@@ -490,7 +761,7 @@ async function stopAllSessionsAndWait(log, opts) {
   await new Promise((resolve) => setTimeout(resolve, Math.min(opts.timeoutMs, 2e3)));
 }
 function getProjectDir(codeName) {
-  return join(homedir(), ".augmented", codeName, "project");
+  return join2(homedir2(), ".augmented", codeName, "project");
 }
 function writeAcpxConfig(config) {
   const {
@@ -506,25 +777,25 @@ 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 (existsSync(claudeMdPath)) claudeArgs.push("--system-prompt-file", claudeMdPath);
+  if (existsSync2(claudeMdPath)) claudeArgs.push("--system-prompt-file", claudeMdPath);
   claudeArgs.push("--allow-dangerously-skip-permissions");
   claudeArgs.push("--dangerously-skip-permissions");
   claudeArgs.push("--strict-mcp-config");
   const mcpServerNames2 = collectMcpServerNames(mcpConfigPath);
   claudeArgs.push("--allowedTools", buildAllowedTools(mcpServerNames2));
   const acpCmd = `npx -y @agentclientprotocol/claude-agent-acp ${claudeArgs.map((a) => a.includes(" ") || a.includes("*") ? JSON.stringify(a) : a).join(" ")}`;
-  const envIntegrationsPath = join(projectDir, ".env.integrations");
-  const wrapperPath = join(projectDir, ".claude", "acpx-agent.sh");
+  const envIntegrationsPath = join2(projectDir, ".env.integrations");
+  const wrapperPath = join2(projectDir, ".claude", "acpx-agent.sh");
   const wrapperLines = ["#!/usr/bin/env bash"];
-  if (existsSync(envIntegrationsPath)) {
+  if (existsSync2(envIntegrationsPath)) {
     wrapperLines.push(`set -a`, `source ${JSON.stringify(envIntegrationsPath)}`, `set +a`);
   }
   if (claudeAuthMode === "api_key" && anthropicApiKey) {
     wrapperLines.push(`export ANTHROPIC_API_KEY=${JSON.stringify(anthropicApiKey)}`);
   }
   wrapperLines.push(`exec ${acpCmd}`);
-  mkdirSync(join(projectDir, ".claude"), { recursive: true });
-  writeFileSync2(wrapperPath, wrapperLines.join("\n") + "\n", { mode: 493 });
+  mkdirSync2(join2(projectDir, ".claude"), { recursive: true });
+  writeFileSync3(wrapperPath, wrapperLines.join("\n") + "\n", { mode: 493 });
   const acpxConfig = {
     defaultAgent: "claude",
     defaultPermissions: "approve-all",
@@ -534,14 +805,20 @@ function writeAcpxConfig(config) {
       }
     }
   };
-  writeFileSync2(join(projectDir, ".acpxrc.json"), JSON.stringify(acpxConfig, null, 2));
+  writeFileSync3(join2(projectDir, ".acpxrc.json"), JSON.stringify(acpxConfig, null, 2));
 }
 
 export {
   sanitizeMcpJson,
   buildAllowedTools,
+  isAgentIdle,
+  isStaleForToday,
+  peekCurrentSession,
   resolveClaudeBinary,
+  prepareForRespawn,
+  getLastFailureContext,
   startPersistentSession,
+  _internals,
   injectMessage,
   stopPersistentSession,
   getSessionState,
@@ -552,4 +829,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-AFUG4KD3.js.map
+//# sourceMappingURL=chunk-EG5D3KUV.js.map