@actwith-ai/pods 0.3.1

package/dist/index.js

@@ -0,0 +1,2021 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/docker-runtime.ts
+var docker_runtime_exports = {};
+__export(docker_runtime_exports, {
+  isDockerAvailable: () => isDockerAvailable,
+  runDockerQuery: () => runDockerQuery
+});
+function isDockerAvailable() {
+  try {
+    const { execSync } = require("child_process");
+    execSync("docker --version", { stdio: "ignore" });
+    execSync(`docker image inspect ${DOCKER_IMAGE}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runDockerQuery(options) {
+  const {
+    prompt,
+    identity,
+    config,
+    model,
+    maxTurns,
+    podIndex,
+    abortController,
+    onEvent
+  } = options;
+  return new Promise((resolve) => {
+    let stdout = "";
+    let killed = false;
+    const containerEnv = {
+      ANTHROPIC_API_KEY: config.anthropicApiKey,
+      ACTWITH_API_KEY: identity.apiKey,
+      ACTWITH_API_URL: config.apiUrl,
+      ACTWITH_SPACE_ID: config.spaceId
+    };
+    const dockerArgs = [
+      "run",
+      "--rm",
+      "-v",
+      "/dev/null:/workspace/.gitkeep",
+      // Minimal mount
+      "--network=host",
+      "--security-opt",
+      "no-new-privileges:true",
+      "--tmpfs",
+      "/tmp:size=500M"
+    ];
+    for (const [key, value] of Object.entries(containerEnv)) {
+      if (value) {
+        dockerArgs.push("-e", `${key}=${value}`);
+      }
+    }
+    dockerArgs.push(
+      DOCKER_IMAGE,
+      "-p",
+      prompt,
+      "--output-format",
+      "stream-json",
+      "--max-turns",
+      String(maxTurns),
+      "--model",
+      model,
+      "--dangerously-skip-permissions"
+    );
+    const child = (0, import_child_process.spawn)("docker", dockerArgs);
+    const onAbort = () => {
+      killed = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 5e3);
+    };
+    abortController.signal.addEventListener("abort", onAbort, { once: true });
+    let buffer = "";
+    child.stdout.on("data", (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        processStreamLine(line, podIndex, onEvent);
+      }
+    });
+    child.stderr.on("data", (data) => {
+      const text = data.toString().trim();
+      if (text && onEvent) {
+        onEvent({
+          type: "text_output",
+          podIndex,
+          text: `[docker] ${text.slice(0, 150)}`,
+          timestamp: Date.now()
+        });
+      }
+    });
+    child.on("error", (err) => {
+      abortController.signal.removeEventListener("abort", onAbort);
+      resolve({
+        success: false,
+        resultText: "",
+        costUsd: 0,
+        numTurns: 0,
+        sessionId: null,
+        errors: [err.message]
+      });
+    });
+    child.on("close", () => {
+      abortController.signal.removeEventListener("abort", onAbort);
+      if (killed) {
+        resolve({
+          success: false,
+          resultText: "",
+          costUsd: 0,
+          numTurns: 0,
+          sessionId: null,
+          errors: ["Aborted"]
+        });
+        return;
+      }
+      if (buffer.trim()) {
+        processStreamLine(buffer, podIndex, onEvent);
+      }
+      const result = parseStreamResult(stdout);
+      resolve(result);
+    });
+  });
+}
+function processStreamLine(line, podIndex, onEvent) {
+  if (!onEvent) return;
+  try {
+    const msg = JSON.parse(line);
+    if (msg.type === "assistant" && msg.message?.content) {
+      for (const block of msg.message.content) {
+        if (block.type === "tool_use" && block.name) {
+          onEvent({
+            type: "tool_use",
+            podIndex,
+            toolName: block.name,
+            timestamp: Date.now()
+          });
+        } else if (block.type === "text" && block.text?.trim()) {
+          const text = block.text.trim();
+          onEvent({
+            type: "text_output",
+            podIndex,
+            text: text.length > 200 ? text.slice(0, 200) + "..." : text,
+            timestamp: Date.now()
+          });
+        }
+      }
+    }
+    if (msg.type === "result" && msg.total_cost_usd !== void 0) {
+      onEvent({
+        type: "cost_update",
+        podIndex,
+        costUsd: msg.total_cost_usd,
+        timestamp: Date.now()
+      });
+    }
+  } catch {
+  }
+}
+function parseStreamResult(output) {
+  const lines = output.split("\n").filter((l) => l.trim());
+  let resultText = "";
+  let sessionId = null;
+  let numTurns = 0;
+  let costUsd = 0;
+  let errors = [];
+  let foundResult = false;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const msg = JSON.parse(lines[i]);
+      if (msg.type === "result") {
+        foundResult = true;
+        sessionId = msg.session_id ?? null;
+        numTurns = msg.num_turns ?? 0;
+        costUsd = msg.total_cost_usd ?? 0;
+        if (msg.subtype === "success" && msg.result) {
+          resultText = msg.result;
+        } else if (msg.errors) {
+          errors = msg.errors;
+        }
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!foundResult) {
+    try {
+      const parsed = JSON.parse(output);
+      return {
+        success: !parsed.is_error,
+        resultText: parsed.result || "",
+        costUsd: parsed.total_cost_usd || 0,
+        numTurns: parsed.num_turns || 0,
+        sessionId: parsed.session_id || null,
+        errors: parsed.is_error ? ["Docker execution failed"] : []
+      };
+    } catch {
+      errors = ["No result message in Docker output"];
+    }
+  }
+  return {
+    success: errors.length === 0,
+    resultText,
+    costUsd,
+    numTurns,
+    sessionId,
+    errors
+  };
+}
+var import_child_process, DOCKER_IMAGE;
+var init_docker_runtime = __esm({
+  "src/docker-runtime.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    DOCKER_IMAGE = "actwith/claude-test:latest";
+  }
+});
+
+// src/ui/Header.tsx
+function Header({ state, budgetGlobal, dockerMode }) {
+  const uptime = Math.round((Date.now() - state.startedAt) / 1e3);
+  const mins = Math.floor(uptime / 60);
+  const secs = uptime % 60;
+  const uptimeStr = `${mins}m ${secs}s`;
+  const activePods = state.pods.filter((p) => p.phase === "ACTIVE").length;
+  const budgetPct = budgetGlobal > 0 ? Math.round(state.globalCostUsd / budgetGlobal * 100) : 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Box, { flexDirection: "row", justifyContent: "space-between", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Text, { bold: true, color: "cyan", children: "actwith pods" }),
+    dockerMode && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Text, { color: "blue", children: "[docker]" }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { children: [
+      state.pods.length,
+      " pods (",
+      activePods,
+      " active)"
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { children: [
+      "$",
+      state.globalCostUsd.toFixed(4),
+      " / $",
+      budgetGlobal.toFixed(2),
+      " (",
+      budgetPct,
+      "%)"
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { dimColor: true, children: [
+      "up ",
+      uptimeStr
+    ] }),
+    state.shuttingDown && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Text, { color: "yellow", children: " SHUTTING DOWN" })
+  ] });
+}
+var import_ink, import_jsx_runtime;
+var init_Header = __esm({
+  "src/ui/Header.tsx"() {
+    "use strict";
+    import_ink = require("ink");
+    import_jsx_runtime = require("react/jsx-runtime");
+  }
+});
+
+// src/ui/PodRow.tsx
+function PodRow({ pod, selected }) {
+  const color = PHASE_COLORS[pod.phase] || "white";
+  const name = pod.identity?.agentName ?? `pod-${pod.index}`;
+  const isActive = pod.phase === "ACTIVE" || pod.phase === "INITIALIZING";
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Box, { flexDirection: "row", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: selected ? "cyan" : "white", children: [
+      selected ? ">" : " ",
+      " "
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { width: 20, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { bold: true, children: name }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { width: 14, children: isActive ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink_spinner.default, { type: "dots" }),
+      " ",
+      pod.phase
+    ] }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { color, children: pod.phase }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { width: 30, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { dimColor: true, children: pod.currentTaskDescription ? pod.currentTaskDescription.slice(0, 28) : pod.lastActivity }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { width: 12, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { children: [
+      "$",
+      pod.totalCostUsd.toFixed(4)
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { width: 8, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { dimColor: true, children: [
+      pod.workCount,
+      "t"
+    ] }) }),
+    pod.error && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "red", children: [
+      " ",
+      pod.error.slice(0, 30)
+    ] })
+  ] });
+}
+var import_ink2, import_ink_spinner, import_jsx_runtime2, PHASE_COLORS;
+var init_PodRow = __esm({
+  "src/ui/PodRow.tsx"() {
+    "use strict";
+    import_ink2 = require("ink");
+    import_ink_spinner = __toESM(require("ink-spinner"));
+    import_jsx_runtime2 = require("react/jsx-runtime");
+    PHASE_COLORS = {
+      INITIALIZING: "gray",
+      IDLE: "blue",
+      ACTIVE: "green",
+      COOLDOWN: "yellow",
+      SHUTTING_DOWN: "magenta",
+      STOPPED: "gray"
+    };
+  }
+});
+
+// src/ui/LogPane.tsx
+function LogPane({
+  logs,
+  maxLines,
+  filterByPod,
+  selectedPod
+}) {
+  const visible = logs.slice(-maxLines);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    import_ink3.Box,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: "gray",
+      paddingX: 1,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink3.Box, { flexDirection: "row", justifyContent: "space-between", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink3.Text, { bold: true, dimColor: true, children: "Log" }),
+          filterByPod && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink3.Text, { color: "cyan", children: [
+            "filtered: pod-",
+            selectedPod
+          ] })
+        ] }),
+        visible.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink3.Text, { dimColor: true, children: "No events yet" }) : visible.map((entry, i) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink3.Text, { wrap: "truncate", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink3.Text, { dimColor: true, children: entry.time }),
+          " ",
+          entry.text
+        ] }, i))
+      ]
+    }
+  );
+}
+var import_ink3, import_jsx_runtime3;
+var init_LogPane = __esm({
+  "src/ui/LogPane.tsx"() {
+    "use strict";
+    import_ink3 = require("ink");
+    import_jsx_runtime3 = require("react/jsx-runtime");
+  }
+});
+
+// src/ui/StatusBar.tsx
+function StatusBar({ shuttingDown, filterByPod }) {
+  if (shuttingDown) {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink4.Box, { paddingX: 1, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink4.Text, { color: "yellow", children: "Shutting down... (Ctrl+C again to force)" }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink4.Box, { paddingX: 1, gap: 2, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink4.Text, { dimColor: true, children: "j/k: select pod" }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink4.Text, { dimColor: true, children: [
+      "f: ",
+      filterByPod ? "show all" : "filter by pod"
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink4.Text, { dimColor: true, children: "a: show all" }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink4.Text, { dimColor: true, children: "Ctrl+C: shutdown" })
+  ] });
+}
+var import_ink4, import_jsx_runtime4;
+var init_StatusBar = __esm({
+  "src/ui/StatusBar.tsx"() {
+    "use strict";
+    import_ink4 = require("ink");
+    import_jsx_runtime4 = require("react/jsx-runtime");
+  }
+});
+
+// src/ui/Dashboard.tsx
+function Dashboard({
+  state,
+  logs,
+  selectedPod,
+  budgetGlobal,
+  filterByPod,
+  shuttingDown,
+  dockerMode
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink5.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      Header,
+      {
+        state,
+        budgetGlobal,
+        dockerMode
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink5.Box, { flexDirection: "column", paddingY: 1, children: state.pods.map((pod) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      PodRow,
+      {
+        pod,
+        selected: pod.index === selectedPod
+      },
+      pod.index
+    )) }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      LogPane,
+      {
+        logs,
+        maxLines: 10,
+        filterByPod,
+        selectedPod
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(StatusBar, { shuttingDown, filterByPod })
+  ] });
+}
+var import_ink5, import_jsx_runtime5;
+var init_Dashboard = __esm({
+  "src/ui/Dashboard.tsx"() {
+    "use strict";
+    import_ink5 = require("ink");
+    init_Header();
+    init_PodRow();
+    init_LogPane();
+    init_StatusBar();
+    import_jsx_runtime5 = require("react/jsx-runtime");
+  }
+});
+
+// src/ui/App.tsx
+var App_exports = {};
+__export(App_exports, {
+  renderDashboard: () => renderDashboard
+});
+function App({
+  orchestrator,
+  config
+}) {
+  const [state, setState] = (0, import_react.useState)(
+    orchestrator.getState()
+  );
+  const [logs, setLogs] = (0, import_react.useState)([]);
+  const [selectedPod, setSelectedPod] = (0, import_react.useState)(0);
+  const [filterByPod, setFilterByPod] = (0, import_react.useState)(false);
+  (0, import_ink6.useInput)(
+    (0, import_react.useCallback)(
+      (input, key) => {
+        const podCount = state.pods.length;
+        if (podCount === 0) return;
+        if (key.upArrow || input === "k") {
+          setSelectedPod((prev) => (prev - 1 + podCount) % podCount);
+        } else if (key.downArrow || input === "j") {
+          setSelectedPod((prev) => (prev + 1) % podCount);
+        } else if (input === "f") {
+          setFilterByPod((prev) => !prev);
+        } else if (input === "a") {
+          setFilterByPod(false);
+        }
+      },
+      [state.pods.length]
+    )
+  );
+  (0, import_react.useEffect)(() => {
+    const refreshInterval = setInterval(() => {
+      setState(orchestrator.getState());
+    }, 500);
+    const handleLog = (msg) => {
+      const time = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+      setLogs((prev) => [
+        ...prev.slice(-(MAX_LOGS - 1)),
+        { time, text: msg, podIndex: null }
+      ]);
+    };
+    const handleEvent = (event) => {
+      const time = new Date(event.timestamp).toISOString().slice(11, 19);
+      const prefix = `[pod-${event.podIndex}]`;
+      let text = null;
+      switch (event.type) {
+        case "phase_change":
+          text = `${prefix} ${event.from} -> ${event.to}`;
+          break;
+        case "poll_result":
+          text = event.foundWork ? `${prefix} Found: ${event.taskId}` : `${prefix} No work`;
+          break;
+        case "work_start":
+          text = `${prefix} Working: ${event.taskDescription?.slice(0, 40)}`;
+          break;
+        case "work_complete":
+          text = `${prefix} Done: ${event.taskId} ($${event.costUsd.toFixed(4)})`;
+          break;
+        case "work_error":
+          text = `${prefix} Error: ${event.error}`;
+          break;
+        case "tool_use":
+          text = `${prefix} -> ${event.toolName}`;
+          break;
+        case "error":
+          text = `${prefix} ERROR: ${event.error}`;
+          break;
+        case "budget_exceeded":
+          text = `${prefix} Budget exceeded!`;
+          break;
+      }
+      if (text) {
+        setLogs((prev) => [
+          ...prev.slice(-(MAX_LOGS - 1)),
+          { time, text, podIndex: event.podIndex }
+        ]);
+      }
+      setState(orchestrator.getState());
+    };
+    orchestrator.on("log", handleLog);
+    orchestrator.on("pod_event", handleEvent);
+    return () => {
+      clearInterval(refreshInterval);
+      orchestrator.off("log", handleLog);
+      orchestrator.off("pod_event", handleEvent);
+    };
+  }, [orchestrator]);
+  const visibleLogs = filterByPod ? logs.filter((l) => l.podIndex === null || l.podIndex === selectedPod) : logs;
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+    Dashboard,
+    {
+      state,
+      logs: visibleLogs,
+      selectedPod,
+      budgetGlobal: config.maxBudgetGlobal,
+      filterByPod,
+      shuttingDown: state.shuttingDown,
+      dockerMode: config.docker
+    }
+  );
+}
+function renderDashboard(orchestrator, config) {
+  (0, import_ink6.render)(/* @__PURE__ */ (0, import_jsx_runtime6.jsx)(App, { orchestrator, config }));
+}
+var import_react, import_ink6, import_jsx_runtime6, MAX_LOGS;
+var init_App = __esm({
+  "src/ui/App.tsx"() {
+    "use strict";
+    import_react = require("react");
+    import_ink6 = require("ink");
+    init_Dashboard();
+    import_jsx_runtime6 = require("react/jsx-runtime");
+    MAX_LOGS = 200;
+  }
+});
+
+// src/config.ts
+var import_arg = __toESM(require("arg"));
+var DEFAULTS = {
+  agentCount: 2,
+  apiUrl: "https://api.actwith.ai",
+  maxBudgetPerPod: 2,
+  maxBudgetGlobal: 5,
+  pollIntervalSec: 30,
+  cooldownSec: 2,
+  idleMaxTurns: 5,
+  activeMaxTurns: 50,
+  idleModel: "claude-haiku-4-5-20251001",
+  activeModel: "claude-sonnet-4-5-20250929",
+  podPrefix: "pod",
+  verbose: false,
+  docker: false,
+  tokenExpiryDays: 1,
+  activeChunkSize: 10,
+  synthesisCycleInterval: 10,
+  activityLogging: true
+};
+function resolveConfig(argv) {
+  const args = (0, import_arg.default)(
+    {
+      "--space": String,
+      "--agents": Number,
+      "--api-key": String,
+      "--api-url": String,
+      "--anthropic-key": String,
+      "--budget": Number,
+      "--budget-per-pod": Number,
+      "--poll-interval": Number,
+      "--cooldown": Number,
+      "--idle-turns": Number,
+      "--active-turns": Number,
+      "--idle-model": String,
+      "--active-model": String,
+      "--prefix": String,
+      "--verbose": Boolean,
+      "--docker": Boolean,
+      "--token-expiry": Number,
+      "--active-chunk": Number,
+      "--synthesis-interval": Number,
+      "--no-activity-log": Boolean,
+      // Aliases
+      "-s": "--space",
+      "-n": "--agents",
+      "-v": "--verbose",
+      "-b": "--budget"
+    },
+    { argv }
+  );
+  const spaceId = args["--space"] || process.env.ACTWITH_SPACE_ID || "";
+  const apiKey = args["--api-key"] || process.env.ACTWITH_API_KEY || "";
+  const anthropicApiKey = args["--anthropic-key"] || process.env.ANTHROPIC_API_KEY || "";
+  if (!apiKey) {
+    throw new Error(
+      "Actwith API key required: use --api-key <key> or set ACTWITH_API_KEY"
+    );
+  }
+  if (!anthropicApiKey) {
+    throw new Error(
+      "Anthropic API key required: use --anthropic-key <key> or set ANTHROPIC_API_KEY"
+    );
+  }
+  return {
+    spaceId,
+    apiKey,
+    anthropicApiKey,
+    apiUrl: args["--api-url"] || process.env.ACTWITH_API_URL || DEFAULTS.apiUrl,
+    agentCount: args["--agents"] ?? DEFAULTS.agentCount,
+    maxBudgetPerPod: args["--budget-per-pod"] ?? DEFAULTS.maxBudgetPerPod,
+    maxBudgetGlobal: args["--budget"] ?? DEFAULTS.maxBudgetGlobal,
+    pollIntervalSec: args["--poll-interval"] ?? DEFAULTS.pollIntervalSec,
+    cooldownSec: args["--cooldown"] ?? DEFAULTS.cooldownSec,
+    idleMaxTurns: args["--idle-turns"] ?? DEFAULTS.idleMaxTurns,
+    activeMaxTurns: args["--active-turns"] ?? DEFAULTS.activeMaxTurns,
+    idleModel: args["--idle-model"] ?? DEFAULTS.idleModel,
+    activeModel: args["--active-model"] ?? DEFAULTS.activeModel,
+    podPrefix: args["--prefix"] ?? DEFAULTS.podPrefix,
+    verbose: (args["--verbose"] ?? process.env.NO_UI === "1") || DEFAULTS.verbose,
+    docker: args["--docker"] ?? DEFAULTS.docker,
+    tokenExpiryDays: args["--token-expiry"] ?? DEFAULTS.tokenExpiryDays,
+    activeChunkSize: args["--active-chunk"] ?? DEFAULTS.activeChunkSize,
+    synthesisCycleInterval: args["--synthesis-interval"] ?? DEFAULTS.synthesisCycleInterval,
+    activityLogging: args["--no-activity-log"] ? false : DEFAULTS.activityLogging
+  };
+}
+async function resolveDefaultSpace(apiKey, apiUrl) {
+  const res = await fetch(`${apiUrl}/v1/contexts?limit=1`, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Failed to resolve default space (HTTP ${res.status}). Use --space <id> to specify explicitly.`
+    );
+  }
+  const body = await res.json();
+  const spaceId = body.data?.[0]?.id;
+  if (!spaceId) {
+    throw new Error(
+      "No spaces found for this API key. Use --space <id> to specify explicitly."
+    );
+  }
+  return spaceId;
+}
+
+// src/orchestrator.ts
+var import_events3 = require("events");
+
+// src/identity-manager.ts
+var IdentityManager = class {
+  constructor(config) {
+    this.identities = [];
+    this.config = config;
+  }
+  /**
+   * Create or find pod agents (idempotent via stableKey) and issue ephemeral tokens.
+   */
+  async createPodIdentities(count) {
+    const identities = [];
+    for (let i = 0; i < count; i++) {
+      const stableKey = `${this.config.podPrefix}-${i}`;
+      const identity = await this.createPodIdentity(i, stableKey);
+      identities.push(identity);
+    }
+    this.identities = identities;
+    return identities;
+  }
+  async createPodIdentity(index, stableKey) {
+    const agent = await this.request("POST", "/v1/agents", {
+      contextId: this.config.spaceId,
+      type: "ai",
+      stableKey
+    });
+    const token = await this.request(
+      "POST",
+      `/v1/agents/${agent.id}/tokens`,
+      {
+        name: `pod-${index}-ephemeral`,
+        description: `Ephemeral token for pod ${index}`,
+        expiresInDays: this.config.tokenExpiryDays
+      }
+    );
+    return {
+      agentId: agent.id,
+      agentName: agent.name,
+      apiKey: token.token,
+      tokenId: token.id,
+      stableKey
+    };
+  }
+  /**
+   * Revoke all ephemeral tokens created during this session.
+   */
+  async cleanup() {
+    const results = await Promise.allSettled(
+      this.identities.map(
+        (id) => this.request(
+          "DELETE",
+          `/v1/agents/${id.agentId}/tokens/${id.tokenId}`
+        ).catch(() => {
+        })
+      )
+    );
+    const failed = results.filter((r) => r.status === "rejected");
+    if (failed.length > 0) {
+      console.error(
+        `Warning: Failed to revoke ${failed.length}/${this.identities.length} tokens`
+      );
+    }
+    this.identities = [];
+  }
+  getIdentities() {
+    return [...this.identities];
+  }
+  async request(method, path, body) {
+    const response = await fetch(`${this.config.apiUrl}${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const data = await response.json();
+    if (!data.success || !data.data) {
+      throw new Error(
+        `API error ${path}: ${data.error?.message ?? "Unknown error"} (${data.error?.code ?? response.status})`
+      );
+    }
+    return data.data;
+  }
+};
+
+// src/pod.ts
+var import_events2 = require("events");
+
+// src/pod-runtime.ts
+var import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
+
+// src/events.ts
+function extractEvents(podIndex, message) {
+  const events = [];
+  const now = Date.now();
+  if (message.type === "assistant") {
+    const content = message.message.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === "tool_use") {
+          events.push({
+            type: "tool_use",
+            podIndex,
+            toolName: block.name,
+            timestamp: now
+          });
+        } else if (block.type === "text" && block.text) {
+          const text = block.text.trim();
+          if (text.length > 0) {
+            events.push({
+              type: "text_output",
+              podIndex,
+              text: text.length > 200 ? text.slice(0, 200) + "..." : text,
+              timestamp: now
+            });
+          }
+        }
+      }
+    }
+  }
+  if (message.type === "result") {
+    events.push({
+      type: "cost_update",
+      podIndex,
+      costUsd: message.total_cost_usd,
+      timestamp: now
+    });
+  }
+  return events;
+}
+
+// src/pod-runtime.ts
+init_docker_runtime();
+async function runPodQuery(options) {
+  if (options.config.docker) {
+    return runDockerPodQuery(options);
+  }
+  return runAgentSdkQuery(options);
+}
+async function runDockerPodQuery(options) {
+  if (!isDockerAvailable()) {
+    return {
+      success: false,
+      resultText: "",
+      costUsd: 0,
+      numTurns: 0,
+      sessionId: null,
+      errors: [
+        "Docker mode requested but Docker is not available or image 'actwith/claude-test:latest' not found. Build the image with: docker build -t actwith/claude-test -f e2e/docker/Dockerfile e2e/"
+      ]
+    };
+  }
+  return runDockerQuery(options);
+}
+async function runAgentSdkQuery(options) {
+  const {
+    prompt,
+    identity,
+    config,
+    model,
+    maxTurns,
+    podIndex,
+    abortController,
+    onEvent
+  } = options;
+  const errors = [];
+  let resultText = "";
+  let costUsd = 0;
+  let numTurns = 0;
+  let sessionId = null;
+  try {
+    const q = (0, import_claude_agent_sdk.query)({
+      prompt,
+      options: {
+        model,
+        maxTurns,
+        abortController,
+        systemPrompt: {
+          type: "preset",
+          preset: "claude_code",
+          append: `
+You are an autonomous pod agent. Your Actwith agent name is "${identity.agentName}". Work autonomously without asking the user questions.`
+        },
+        tools: { type: "preset", preset: "claude_code" },
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        settingSources: [],
+        mcpServers: {
+          actwith: {
+            command: "npx",
+            args: ["-y", "@actwith-ai/mcp-server"],
+            env: {
+              ACTWITH_API_KEY: identity.apiKey,
+              ACTWITH_SPACE_ID: config.spaceId,
+              ACTWITH_API_URL: config.apiUrl,
+              ACTWITH_HEADLESS: "1"
+            }
+          }
+        },
+        env: {
+          ...process.env,
+          ANTHROPIC_API_KEY: config.anthropicApiKey
+        }
+      }
+    });
+    for await (const message of q) {
+      if (abortController.signal.aborted) break;
+      const events = extractEvents(podIndex, message);
+      if (onEvent) {
+        for (const event of events) {
+          onEvent(event);
+        }
+      }
+      if (message.type === "result") {
+        sessionId = message.session_id;
+        costUsd = message.total_cost_usd;
+        numTurns = message.num_turns;
+        if (message.subtype === "success") {
+          resultText = message.result;
+        } else {
+          errors.push(...message.errors);
+        }
+      }
+    }
+    return {
+      success: errors.length === 0,
+      resultText,
+      costUsd,
+      numTurns,
+      sessionId,
+      errors
+    };
+  } catch (err) {
+    if (abortController.signal.aborted) {
+      return {
+        success: false,
+        resultText: "",
+        costUsd,
+        numTurns,
+        sessionId,
+        errors: ["Aborted"]
+      };
+    }
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      resultText: "",
+      costUsd,
+      numTurns,
+      sessionId,
+      errors: [errorMsg]
+    };
+  }
+}
+
+// src/prompts.ts
+function buildIdlePrompt(identity, spaceId) {
+  return `You are an autonomous AI worker pod in Actwith space "${spaceId}".
+Your agent name is "${identity.agentName}".
+
+Your job: Check if there is work available for you, then report back.
+
+Do these steps in order:
+1. Call "session_restore" to restore any previous session context.
+2. Call "whats_new" to see your dashboard.
+3. Call "find_work" to discover tasks matching your skills.
+
+After checking, respond with ONLY a JSON object (no markdown, no explanation):
+{"found_work": true/false, "task_id": "...", "task_description": "..."}
+
+If no work is found, respond with:
+{"found_work": false, "task_id": null, "task_description": null}
+
+Do NOT claim any tasks. Only check and report.
+
+## Communication
+
+When messaging teammates, ALWAYS use the "to" field in the "tell" tool with the recipient's name so they get notified.
+Example: tell(to: "patient-badger", topic: "general", message: "Checking in on task progress")
+Without "to", your message is a silent broadcast no one sees.`;
+}
+function buildActivePrompt(identity, spaceId, taskId, taskDescription) {
+  return `You are an autonomous AI worker pod in Actwith space "${spaceId}".
+Your agent name is "${identity.agentName}".
+
+You have been assigned a task to complete.
+
+Task ID: ${taskId}
+Task Description: ${taskDescription}
+
+Do these steps:
+1. Call "recall_expertise" to recall relevant skills and insights for this task.
+2. Call "claim_task" with task_id "${taskId}" to claim the task.
+3. Read the full task details with "task_details" for task_id "${taskId}".
+4. Do the work described in the task. Use all available tools as needed.
+5. When finished, call "submit_work" with task_id "${taskId}" and a summary of your work.
+6. Call "reflect" with a brief reflection on what you learned and what went well or poorly.
+7. Call "session_save" to save your progress.
+
+Work autonomously. Be thorough but efficient. If you encounter blockers, document them in your response.
+
+## Communication
+
+When messaging teammates, ALWAYS use the "to" field in the "tell" tool with the recipient's name so they get notified.
+Example: tell(to: "patient-badger", topic: "general", message: "Task completed, ready for review")
+Without "to", your message is a silent broadcast no one sees.
+
+## Subtask Decomposition
+
+For complex tasks, you can spawn subtasks to parallelize work:
+- Use "spawn_subtask" with parent_task_id="${taskId}" to create child tasks.
+- Other agents (or you) can claim and complete subtasks independently.
+- Maximum depth: 2 levels (subtasks cannot create their own subtasks).
+- Spawn when: work is parallelizable, different skills needed, divide-and-conquer helps.
+- Inline when: sequential dependency, small scope, you already have the skills.
+- Use "list_subtasks" to check on child task progress.`;
+}
+function buildContinuationPrompt(identity, spaceId, taskId, turnsUsed, totalTurns) {
+  return `You are an autonomous AI worker pod in Actwith space "${spaceId}".
+Your agent name is "${identity.agentName}".
+
+You are continuing work on a task. You have used ${turnsUsed} of ${totalTurns} available turns.
+
+Task ID: ${taskId}
+
+Steps:
+1. Call "session_restore" to reload your previous context.
+2. Continue working on the task from where you left off.
+3. If you finish the task, call "submit_work" with task_id "${taskId}" and a summary.
+4. Call "reflect" with a brief reflection on what you learned.
+5. Call "session_save" to save your progress.
+
+## Communication
+
+When messaging teammates, ALWAYS use the "to" field in the "tell" tool with the recipient's name so they get notified.
+Example: tell(to: "patient-badger", topic: "general", message: "Task completed, ready for review")
+Without "to", your message is a silent broadcast no one sees.
+
+Work autonomously. Be thorough but efficient.`;
+}
+function formatAge(seconds) {
+  if (seconds < 60) return `${seconds}s ago`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+function buildNotificationPrompt(identity, spaceId, notifications, totalUnread) {
+  const notifList = notifications.map(
+    (n, i) => `${i + 1}. [${formatAge(n.ageSeconds)}] From "${n.from}" in topic "${n.topic}": "${n.preview}"`
+  ).join("\n");
+  const total = totalUnread ?? notifications.length;
+  const moreNote = total > notifications.length ? `
+Note: You have ${total - notifications.length} more unread mention(s) that will arrive in subsequent heartbeats.` : "";
+  return `You are an autonomous AI worker pod in Actwith space "${spaceId}".
+Your agent name is "${identity.agentName}".
+
+You have been @mentioned in ${notifications.length} notification(s):
+${notifList}
+${moreNote}
+Respond to these mentions appropriately:
+1. Read the full conversation context using "listen" on the relevant topic(s).
+2. Take whatever action the mention is requesting (join a space, review something, answer a question, etc.).
+3. Reply using "tell" with the "to" field set to the sender's name, on the same topic. Example: tell(to: "patient-badger", topic: "general", message: "Here's what I found...")
+4. Call "session_save" to save your progress.
+
+IMPORTANT: When using "tell", ALWAYS set the "to" field with the recipient's name so they get notified. Without "to", your message is a silent broadcast no one sees.
+
+If a mention is more than a few hours old, check if the conversation has moved on before responding.
+Work autonomously. Be helpful and responsive.`;
+}
+function buildShutdownPrompt(identity) {
+  return `You are shutting down. Your agent name is "${identity.agentName}".
+
+Call "session_save" with a summary of your current session, including:
+- What tasks you completed
+- What you were working on
+- Any notes for next time
+
+Then respond with: "shutdown complete"`;
+}
+
+// src/pod.ts
+var MIN_POLL_SEC = 10;
+var MAX_POLL_SEC = 300;
+var DEFAULT_POLL_SEC = 30;
+var Pod = class extends import_events2.EventEmitter {
+  constructor(index, identity, config) {
+    super();
+    this.phase = "INITIALIZING";
+    this.shutdownRequested = false;
+    this.sleepTimer = null;
+    this.sleepResolve = null;
+    // Background poller
+    this.pollerTimer = null;
+    this.nextPollSec = DEFAULT_POLL_SEC;
+    this.pendingNotifications = null;
+    // Stats
+    this.totalCostUsd = 0;
+    this.totalTurns = 0;
+    this.pollCount = 0;
+    this.workCount = 0;
+    this.cycleCount = 0;
+    this.currentTaskId = null;
+    this.currentTaskDescription = null;
+    this.lastActivity = "initializing";
+    this.sessionId = null;
+    this.error = null;
+    this.index = index;
+    this.identity = identity;
+    this.config = config;
+    this.abortController = new AbortController();
+  }
+  getState() {
+    return {
+      index: this.index,
+      identity: this.identity,
+      phase: this.phase,
+      currentTaskId: this.currentTaskId,
+      currentTaskDescription: this.currentTaskDescription,
+      totalCostUsd: this.totalCostUsd,
+      totalTurns: this.totalTurns,
+      pollCount: this.pollCount,
+      workCount: this.workCount,
+      lastActivity: this.lastActivity,
+      sessionId: this.sessionId,
+      error: this.error,
+      cycleCount: this.cycleCount,
+      pendingNotifications: this.pendingNotifications
+    };
+  }
+  setPhase(newPhase) {
+    const from = this.phase;
+    this.phase = newPhase;
+    this.emitEvent({
+      type: "phase_change",
+      podIndex: this.index,
+      from,
+      to: newPhase,
+      timestamp: Date.now()
+    });
+  }
+  emitEvent(event) {
+    this.emit("event", event);
+  }
+  /**
+   * Main run loop. Polls for work, does work, repeats until shutdown.
+   */
+  async run() {
+    this.setPhase("IDLE");
+    this.startNotificationPoller();
+    this.postActivityLog("Pod started", "info");
+    while (!this.shutdownRequested) {
+      if (this.totalCostUsd >= this.config.maxBudgetPerPod) {
+        this.emitEvent({
+          type: "budget_exceeded",
+          podIndex: this.index,
+          costUsd: this.totalCostUsd,
+          limit: this.config.maxBudgetPerPod,
+          timestamp: Date.now()
+        });
+        this.postActivityLog("Budget exceeded, stopping", "warn");
+        break;
+      }
+      try {
+        const queued = this.consumePendingNotifications();
+        if (queued) {
+          this.setPhase("ACTIVE");
+          this.lastActivity = `responding to ${queued.notifications.length} notification(s)`;
+          this.postActivityLog(
+            `Handling ${queued.notifications.length} notification(s)`,
+            "info"
+          );
+          await this.handleNotifications(
+            queued.notifications,
+            queued.totalUnread
+          );
+          if (this.shutdownRequested) break;
+          this.setPhase("COOLDOWN");
+          this.lastActivity = "cooling down";
+          await this.sleep(this.config.cooldownSec * 1e3);
+          this.cycleCount++;
+          await this.maybeAutoSynthesize();
+          continue;
+        }
+        const { notifications, totalUnread } = await this.checkNotifications();
+        if (this.shutdownRequested) break;
+        if (notifications.length > 0) {
+          this.setPhase("ACTIVE");
+          this.lastActivity = `responding to ${notifications.length} notification(s)`;
+          this.postActivityLog(
+            `Handling ${notifications.length} notification(s)`,
+            "info"
+          );
+          await this.handleNotifications(notifications, totalUnread);
+          if (this.shutdownRequested) break;
+          this.setPhase("COOLDOWN");
+          this.lastActivity = "cooling down";
+          await this.sleep(this.config.cooldownSec * 1e3);
+          this.cycleCount++;
+          await this.maybeAutoSynthesize();
+          continue;
+        }
+        const preflight = await this.preflightCheck();
+        if (this.shutdownRequested) break;
+        if (!preflight.hasWork) {
+          this.emitEvent({
+            type: "preflight_skip",
+            podIndex: this.index,
+            reason: "no open tasks",
+            timestamp: Date.now()
+          });
+          this.lastActivity = "waiting for work (preflight: nothing to do)";
+          await this.sleep(this.config.pollIntervalSec * 1e3);
+          continue;
+        }
+        this.setPhase("IDLE");
+        this.lastActivity = "polling for work";
+        const poll = await this.idlePoll();
+        if (this.shutdownRequested) break;
+        if (poll.foundWork && poll.taskId && poll.taskDescription) {
+          this.setPhase("ACTIVE");
+          this.currentTaskId = poll.taskId;
+          this.currentTaskDescription = poll.taskDescription;
+          this.lastActivity = `working on ${poll.taskId}`;
+          this.postActivityLog(
+            `Starting work on task ${poll.taskId}: ${poll.taskDescription}`,
+            "info"
+          );
+          await this.activeWork(poll.taskId, poll.taskDescription);
+          this.currentTaskId = null;
+          this.currentTaskDescription = null;
+          if (this.shutdownRequested) break;
+          this.setPhase("COOLDOWN");
+          this.lastActivity = "cooling down";
+          await this.sleep(this.config.cooldownSec * 1e3);
+          this.cycleCount++;
+          await this.maybeAutoSynthesize();
+        } else {
+          this.lastActivity = "waiting for work";
+          await this.sleep(this.config.pollIntervalSec * 1e3);
+        }
+      } catch (err) {
+        if (this.shutdownRequested) break;
+        const msg = err instanceof Error ? err.message : String(err);
+        this.error = msg;
+        this.emitEvent({
+          type: "error",
+          podIndex: this.index,
+          error: msg,
+          timestamp: Date.now()
+        });
+        this.postActivityLog(`Error: ${msg}`, "error");
+        await this.sleep(this.config.pollIntervalSec * 2 * 1e3);
+      }
+    }
+    this.stopNotificationPoller();
+    this.postActivityLog("Pod shutting down", "info");
+    await this.runShutdown();
+  }
+  /**
+   * IDLE poll: use Haiku to check for work.
+   */
+  async idlePoll() {
+    this.pollCount++;
+    this.emitEvent({
+      type: "poll_start",
+      podIndex: this.index,
+      timestamp: Date.now()
+    });
+    const prompt = buildIdlePrompt(this.identity, this.config.spaceId);
+    const result = await runPodQuery({
+      prompt,
+      identity: this.identity,
+      config: this.config,
+      model: this.config.idleModel,
+      maxTurns: this.config.idleMaxTurns,
+      podIndex: this.index,
+      abortController: this.abortController,
+      onEvent: (e) => this.emitEvent(e)
+    });
+    this.totalCostUsd += result.costUsd;
+    this.totalTurns += result.numTurns;
+    if (result.sessionId) this.sessionId = result.sessionId;
+    const poll = parsePollResult(result.resultText);
+    this.emitEvent({
+      type: "poll_result",
+      podIndex: this.index,
+      foundWork: poll.foundWork,
+      taskId: poll.taskId ?? void 0,
+      taskDescription: poll.taskDescription ?? void 0,
+      timestamp: Date.now()
+    });
+    return poll;
+  }
+  /**
+   * ACTIVE work: use Sonnet to claim and complete a task.
+   * When chunking is enabled, splits work into chunks of activeChunkSize turns
+   * and checks for notifications between chunks.
+   */
+  async activeWork(taskId, taskDescription) {
+    this.workCount++;
+    this.emitEvent({
+      type: "work_start",
+      podIndex: this.index,
+      taskId,
+      taskDescription,
+      timestamp: Date.now()
+    });
+    const chunkSize = this.config.activeChunkSize;
+    const totalMaxTurns = this.config.activeMaxTurns;
+    if (chunkSize <= 0 || chunkSize >= totalMaxTurns) {
+      await this.runActiveChunk(taskId, taskDescription, totalMaxTurns, true);
+      return;
+    }
+    let turnsUsed = 0;
+    let chunkIndex = 0;
+    while (turnsUsed < totalMaxTurns && !this.shutdownRequested) {
+      const turnsRemaining = totalMaxTurns - turnsUsed;
+      const turnsThisChunk = Math.min(chunkSize, turnsRemaining);
+      const isFirstChunk = chunkIndex === 0;
+      const prompt = isFirstChunk ? buildActivePrompt(
+        this.identity,
+        this.config.spaceId,
+        taskId,
+        taskDescription
+      ) : buildContinuationPrompt(
+        this.identity,
+        this.config.spaceId,
+        taskId,
+        turnsUsed,
+        totalMaxTurns
+      );
+      const result = await runPodQuery({
+        prompt,
+        identity: this.identity,
+        config: this.config,
+        model: this.config.activeModel,
+        maxTurns: turnsThisChunk,
+        podIndex: this.index,
+        abortController: this.abortController,
+        onEvent: (e) => this.emitEvent(e)
+      });
+      this.totalCostUsd += result.costUsd;
+      this.totalTurns += result.numTurns;
+      turnsUsed += result.numTurns;
+      if (result.sessionId) this.sessionId = result.sessionId;
+      this.emitEvent({
+        type: "active_chunk_complete",
+        podIndex: this.index,
+        taskId,
+        chunkIndex,
+        turnsUsed: result.numTurns,
+        timestamp: Date.now()
+      });
+      chunkIndex++;
+      if (result.numTurns < turnsThisChunk) {
+        if (result.success) {
+          this.emitEvent({
+            type: "work_complete",
+            podIndex: this.index,
+            taskId,
+            costUsd: this.totalCostUsd,
+            numTurns: turnsUsed,
+            timestamp: Date.now()
+          });
+          this.postActivityLog(
+            `Completed task ${taskId} in ${turnsUsed} turns`,
+            "info"
+          );
+        } else {
+          this.emitEvent({
+            type: "work_error",
+            podIndex: this.index,
+            taskId,
+            error: result.errors.join("; "),
+            timestamp: Date.now()
+          });
+        }
+        return;
+      }
+      if (turnsUsed < totalMaxTurns && !this.shutdownRequested) {
+        const queued = this.consumePendingNotifications();
+        if (queued) {
+          this.postActivityLog(
+            `Pausing task to handle ${queued.notifications.length} notification(s)`,
+            "info"
+          );
+          await this.handleNotifications(
+            queued.notifications,
+            queued.totalUnread
+          );
+        }
+      }
+    }
+    this.emitEvent({
+      type: "work_complete",
+      podIndex: this.index,
+      taskId,
+      costUsd: this.totalCostUsd,
+      numTurns: turnsUsed,
+      timestamp: Date.now()
+    });
+    this.postActivityLog(
+      `Completed task ${taskId} (used all ${turnsUsed} turns)`,
+      "info"
+    );
+  }
+  /**
+   * Run a single active work chunk (non-chunked path).
+   */
+  async runActiveChunk(taskId, taskDescription, maxTurns, emitCompletion) {
+    const prompt = buildActivePrompt(
+      this.identity,
+      this.config.spaceId,
+      taskId,
+      taskDescription
+    );
+    const result = await runPodQuery({
+      prompt,
+      identity: this.identity,
+      config: this.config,
+      model: this.config.activeModel,
+      maxTurns,
+      podIndex: this.index,
+      abortController: this.abortController,
+      onEvent: (e) => this.emitEvent(e)
+    });
+    this.totalCostUsd += result.costUsd;
+    this.totalTurns += result.numTurns;
+    if (result.sessionId) this.sessionId = result.sessionId;
+    if (emitCompletion) {
+      if (result.success) {
+        this.emitEvent({
+          type: "work_complete",
+          podIndex: this.index,
+          taskId,
+          costUsd: result.costUsd,
+          numTurns: result.numTurns,
+          timestamp: Date.now()
+        });
+        this.postActivityLog(
+          `Completed task ${taskId} in ${result.numTurns} turns`,
+          "info"
+        );
+      } else {
+        this.emitEvent({
+          type: "work_error",
+          podIndex: this.index,
+          taskId,
+          error: result.errors.join("; "),
+          timestamp: Date.now()
+        });
+      }
+    }
+  }
+  /**
+   * Check for pending @mention notifications via heartbeat API.
+   * Also reads server-guided poll interval hint.
+   */
+  async checkNotifications() {
+    try {
+      const res = await fetch(
+        `${this.config.apiUrl}/v1/agents/${this.identity.agentId}/heartbeat`,
+        {
+          method: "POST",
+          headers: { Authorization: `Bearer ${this.config.apiKey}` }
+        }
+      );
+      if (!res.ok) return { notifications: [], totalUnread: 0 };
+      const body = await res.json();
+      if (body.data?.nextPollSec != null) {
+        this.nextPollSec = Math.max(
+          MIN_POLL_SEC,
+          Math.min(MAX_POLL_SEC, body.data.nextPollSec)
+        );
+      }
+      const notifs = body.data?.notifications ?? [];
+      const totalUnread = body.data?.totalUnread ?? notifs.length;
+      if (notifs.length > 0) {
+        this.emitEvent({
+          type: "notification_check",
+          podIndex: this.index,
+          count: notifs.length,
+          timestamp: Date.now()
+        });
+      }
+      return { notifications: notifs, totalUnread };
+    } catch {
+      return { notifications: [], totalUnread: 0 };
+    }
+  }
+  /**
+   * Pre-flight check: query the API for open tasks without invoking the LLM.
+   * Returns quickly and cheaply — if nothing to do, caller can skip the IDLE poll.
+   */
+  async preflightCheck() {
+    try {
+      const res = await fetch(
+        `${this.config.apiUrl}/v1/tasks?context=${this.config.spaceId}&status=open&limit=1`,
+        {
+          headers: { Authorization: `Bearer ${this.config.apiKey}` }
+        }
+      );
+      if (!res.ok) {
+        return { hasWork: true };
+      }
+      const body = await res.json();
+      return { hasWork: (body.data?.length ?? 0) > 0 };
+    } catch {
+      return { hasWork: true };
+    }
+  }
+  /**
+   * Handle @mention notifications using Sonnet.
+   */
+  async handleNotifications(notifications, totalUnread) {
+    this.workCount++;
+    this.emitEvent({
+      type: "work_start",
+      podIndex: this.index,
+      taskId: "notifications",
+      taskDescription: `Responding to ${notifications.length} @mention(s)`,
+      timestamp: Date.now()
+    });
+    const prompt = buildNotificationPrompt(
+      this.identity,
+      this.config.spaceId,
+      notifications,
+      totalUnread
+    );
+    const result = await runPodQuery({
+      prompt,
+      identity: this.identity,
+      config: this.config,
+      model: this.config.activeModel,
+      maxTurns: this.config.activeMaxTurns,
+      podIndex: this.index,
+      abortController: this.abortController,
+      onEvent: (e) => this.emitEvent(e)
+    });
+    this.totalCostUsd += result.costUsd;
+    this.totalTurns += result.numTurns;
+    if (result.sessionId) this.sessionId = result.sessionId;
+    if (result.success) {
+      this.emitEvent({
+        type: "work_complete",
+        podIndex: this.index,
+        taskId: "notifications",
+        costUsd: result.costUsd,
+        numTurns: result.numTurns,
+        timestamp: Date.now()
+      });
+    } else {
+      this.emitEvent({
+        type: "work_error",
+        podIndex: this.index,
+        taskId: "notifications",
+        error: result.errors.join("; "),
+        timestamp: Date.now()
+      });
+    }
+  }
+  // ── Background notification poller ──
+  /**
+   * Start background polling for notifications at server-guided intervals.
+   */
+  startNotificationPoller() {
+    if (this.pollerTimer) return;
+    this.scheduleNextPoll();
+  }
+  /**
+   * Stop the background notification poller.
+   */
+  stopNotificationPoller() {
+    if (this.pollerTimer) {
+      clearTimeout(this.pollerTimer);
+      this.pollerTimer = null;
+    }
+  }
+  scheduleNextPoll() {
+    if (this.shutdownRequested) return;
+    this.pollerTimer = setTimeout(async () => {
+      this.pollerTimer = null;
+      if (this.shutdownRequested) return;
+      try {
+        const { notifications, totalUnread } = await this.checkNotifications();
+        if (notifications.length > 0 && !this.pendingNotifications) {
+          this.pendingNotifications = {
+            notifications,
+            totalUnread,
+            detectedAt: Date.now()
+          };
+          this.emitEvent({
+            type: "notification_detected",
+            podIndex: this.index,
+            count: notifications.length,
+            duringPhase: this.phase,
+            timestamp: Date.now()
+          });
+          this.wakeSleep();
+        }
+      } catch {
+      }
+      this.scheduleNextPoll();
+    }, this.nextPollSec * 1e3);
+  }
+  /**
+   * Consume pending notifications, returning them and clearing the queue.
+   */
+  consumePendingNotifications() {
+    const queued = this.pendingNotifications;
+    this.pendingNotifications = null;
+    return queued;
+  }
+  // ── Sleep with interruption ──
+  /**
+   * Wake from sleep early (e.g. when notifications arrive).
+   */
+  wakeSleep() {
+    if (this.sleepResolve) {
+      this.sleepResolve();
+      this.sleepResolve = null;
+      if (this.sleepTimer) {
+        clearTimeout(this.sleepTimer);
+        this.sleepTimer = null;
+      }
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => {
+      if (this.shutdownRequested) {
+        resolve();
+        return;
+      }
+      this.sleepResolve = resolve;
+      this.sleepTimer = setTimeout(() => {
+        this.sleepTimer = null;
+        this.sleepResolve = null;
+        resolve();
+      }, ms);
+    });
+  }
+  // ── Activity logging ──
+  /**
+   * Post an activity log entry to the pod-log topic. Fire-and-forget.
+   */
+  postActivityLog(message, level) {
+    if (!this.config.activityLogging) return;
+    this.emitEvent({
+      type: "activity_log",
+      podIndex: this.index,
+      message,
+      level,
+      timestamp: Date.now()
+    });
+    const body = JSON.stringify({
+      topic: "pod-log",
+      message: `[${this.identity.agentName}] [${level.toUpperCase()}] ${message}`,
+      type: "activity"
+    });
+    fetch(`${this.config.apiUrl}/v1/topics/publish`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json",
+        "X-Agent-ID": this.identity.agentId
+      },
+      body
+    }).catch(() => {
+    });
+  }
+  // ── Auto-synthesis ──
+  /**
+   * Trigger deterministic synthesis if cycle count meets the interval.
+   */
+  async maybeAutoSynthesize() {
+    const interval = this.config.synthesisCycleInterval;
+    if (interval <= 0 || this.cycleCount % interval !== 0) return;
+    this.emitEvent({
+      type: "synthesis_start",
+      podIndex: this.index,
+      timestamp: Date.now()
+    });
+    this.postActivityLog(
+      `Auto-synthesis triggered (cycle ${this.cycleCount})`,
+      "info"
+    );
+    let success = false;
+    try {
+      const res = await fetch(`${this.config.apiUrl}/v1/insights/synthesize`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "Content-Type": "application/json",
+          "X-Agent-ID": this.identity.agentId
+        },
+        body: JSON.stringify({ mode: "deterministic" })
+      });
+      success = res.ok;
+    } catch {
+    }
+    this.emitEvent({
+      type: "synthesis_complete",
+      podIndex: this.index,
+      success,
+      timestamp: Date.now()
+    });
+  }
+  // ── Shutdown ──
+  /**
+   * Run the shutdown prompt to save session before stopping.
+   */
+  async runShutdown() {
+    this.setPhase("SHUTTING_DOWN");
+    this.emitEvent({
+      type: "shutdown_start",
+      podIndex: this.index,
+      timestamp: Date.now()
+    });
+    const shutdownAbort = new AbortController();
+    try {
+      const prompt = buildShutdownPrompt(this.identity);
+      await runPodQuery({
+        prompt,
+        identity: this.identity,
+        config: this.config,
+        model: this.config.idleModel,
+        // Use cheap model for shutdown
+        maxTurns: 3,
+        podIndex: this.index,
+        abortController: shutdownAbort,
+        onEvent: (e) => this.emitEvent(e)
+      });
+    } catch {
+    }
+    this.setPhase("STOPPED");
+    this.lastActivity = "stopped";
+    this.emitEvent({
+      type: "shutdown_complete",
+      podIndex: this.index,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Request graceful shutdown.
+   */
+  shutdown() {
+    this.shutdownRequested = true;
+    this.abortController.abort();
+    this.stopNotificationPoller();
+    this.wakeSleep();
+  }
+};
+function parsePollResult(text) {
+  const noWork = {
+    foundWork: false,
+    taskId: null,
+    taskDescription: null
+  };
+  if (!text) return noWork;
+  try {
+    const jsonMatch = text.match(/\{[\s\S]*"found_work"[\s\S]*\}/);
+    if (!jsonMatch) return noWork;
+    const parsed = JSON.parse(jsonMatch[0]);
+    return {
+      foundWork: Boolean(parsed.found_work),
+      taskId: parsed.task_id || null,
+      taskDescription: parsed.task_description || null
+    };
+  } catch {
+    return noWork;
+  }
+}
+
+// src/orchestrator.ts
+var Orchestrator = class extends import_events3.EventEmitter {
+  constructor(config) {
+    super();
+    this.pods = [];
+    this.shuttingDown = false;
+    this.startedAt = Date.now();
+    this.config = config;
+    this.identityManager = new IdentityManager(config);
+  }
+  getState() {
+    return {
+      pods: this.pods.map((p) => p.getState()),
+      globalCostUsd: this.getGlobalCost(),
+      startedAt: this.startedAt,
+      shuttingDown: this.shuttingDown
+    };
+  }
+  getGlobalCost() {
+    return this.pods.reduce((sum, p) => sum + p.totalCostUsd, 0);
+  }
+  /**
+   * Initialize identities, spawn pods, and run until shutdown.
+   */
+  async run() {
+    this.startedAt = Date.now();
+    this.emit("log", `Creating ${this.config.agentCount} pod identities...`);
+    const identities = await this.identityManager.createPodIdentities(
+      this.config.agentCount
+    );
+    for (const id of identities) {
+      this.emit(
+        "log",
+        `  Pod ${id.stableKey}: agent "${id.agentName}" (${id.agentId})`
+      );
+    }
+    this.pods = identities.map((identity, i) => {
+      const pod = new Pod(i, identity, this.config);
+      pod.on("event", (event) => {
+        this.emit("pod_event", event);
+        if (event.type === "cost_update") {
+          const globalCost = this.getGlobalCost();
+          if (globalCost >= this.config.maxBudgetGlobal && !this.shuttingDown) {
+            this.emit(
+              "log",
+              `Global budget reached ($${globalCost.toFixed(4)} >= $${this.config.maxBudgetGlobal.toFixed(2)}). Shutting down all pods.`
+            );
+            this.shutdown();
+          }
+        }
+      });
+      return pod;
+    });
+    this.emit("log", `Starting ${this.pods.length} pods...`);
+    try {
+      await Promise.allSettled(this.pods.map((pod) => pod.run()));
+    } finally {
+      this.emit("log", "Revoking ephemeral tokens...");
+      await this.identityManager.cleanup();
+      this.emit("log", "Shutdown complete.");
+    }
+  }
+  /**
+   * Gracefully shut down all pods.
+   */
+  shutdown() {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+    this.emit("log", "Shutting down all pods...");
+    for (const pod of this.pods) {
+      pod.shutdown();
+    }
+  }
+};
+
+// src/cli.ts
+function printHelp() {
+  console.log(`
+actwith-pods - Launch autonomous AI agent pods in your Actwith space
+
+Usage:
+  actwith-pods [options]
+
+Options:
+  --space, -s <id>          Actwith space ID (default: your personal space)
+  --agents, -n <count>      Number of pods to spawn (default: 2)
+  --budget, -b <usd>        Global budget limit in USD (default: 5.00)
+  --budget-per-pod <usd>    Per-pod budget limit in USD (default: 2.00)
+  --poll-interval <sec>     Seconds between idle polls (default: 30)
+  --cooldown <sec>          Seconds between tasks (default: 2)
+  --idle-turns <n>          Max turns for idle poll (default: 5)
+  --active-turns <n>        Max turns for active work (default: 50)
+  --idle-model <model>      Model for idle polls (default: claude-haiku-4-5-20251001)
+  --active-model <model>    Model for active work (default: claude-sonnet-4-5-20250929)
+  --prefix <name>           Stable key prefix (default: pod)
+  --verbose, -v             Use console output instead of dashboard
+  --docker                  Run pods in Docker containers (requires actwith/claude-test image)
+  --token-expiry <days>     Ephemeral token expiry (default: 1)
+
+Environment:
+  ACTWITH_API_KEY           Actwith API key
+  ACTWITH_SPACE_ID          Default space ID
+  ACTWITH_API_URL           API base URL
+  ANTHROPIC_API_KEY         Anthropic API key
+  NO_UI=1                   Force console mode
+`);
+}
+async function main(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printHelp();
+    process.exit(0);
+  }
+  let config;
+  try {
+    config = resolveConfig(argv);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : err}`);
+    console.error("Run with --help for usage information.");
+    process.exit(1);
+  }
+  if (!config.spaceId) {
+    try {
+      console.log("No space specified, resolving default space...");
+      config.spaceId = await resolveDefaultSpace(config.apiKey, config.apiUrl);
+      console.log(`Using space: ${config.spaceId}`);
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  }
+  if (config.docker) {
+    const { isDockerAvailable: isDockerAvailable2 } = await Promise.resolve().then(() => (init_docker_runtime(), docker_runtime_exports));
+    if (!isDockerAvailable2()) {
+      console.error(
+        "Error: Docker mode requested but Docker is not available or image 'actwith/claude-test:latest' not found."
+      );
+      console.error(
+        "Build the image with: docker build -t actwith/claude-test -f e2e/docker/Dockerfile e2e/"
+      );
+      process.exit(1);
+    }
+    console.log("Docker mode enabled.");
+  }
+  const orchestrator = new Orchestrator(config);
+  if (config.verbose) {
+    wireConsoleOutput(orchestrator);
+  } else {
+    try {
+      const { renderDashboard: renderDashboard2 } = await Promise.resolve().then(() => (init_App(), App_exports));
+      renderDashboard2(orchestrator, config);
+    } catch {
+      console.log("Ink dashboard unavailable, falling back to console mode.");
+      wireConsoleOutput(orchestrator);
+    }
+  }
+  let sigintCount = 0;
+  process.on("SIGINT", () => {
+    sigintCount++;
+    if (sigintCount === 1) {
+      console.log("\nGraceful shutdown requested (Ctrl+C again to force)...");
+      orchestrator.shutdown();
+    } else {
+      console.log("\nForce shutdown.");
+      process.exit(1);
+    }
+  });
+  try {
+    await orchestrator.run();
+  } catch (err) {
+    console.error(`Fatal: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+  const state = orchestrator.getState();
+  console.log("\n--- Session Summary ---");
+  console.log(`Total cost: $${state.globalCostUsd.toFixed(4)}`);
+  console.log(
+    `Duration: ${Math.round((Date.now() - state.startedAt) / 1e3)}s`
+  );
+  for (const pod of state.pods) {
+    console.log(
+      `  Pod ${pod.index} (${pod.identity?.agentName ?? "unknown"}): ${pod.workCount} tasks, $${pod.totalCostUsd.toFixed(4)}, ${pod.totalTurns} turns`
+    );
+  }
+}
+function wireConsoleOutput(orchestrator) {
+  orchestrator.on("log", (msg) => {
+    console.log(`[pods] ${msg}`);
+  });
+  orchestrator.on("pod_event", (event) => {
+    const prefix = `[pod-${event.podIndex}]`;
+    const time = new Date(event.timestamp).toISOString().slice(11, 19);
+    switch (event.type) {
+      case "phase_change":
+        console.log(`${time} ${prefix} ${event.from} -> ${event.to}`);
+        break;
+      case "notification_check":
+        console.log(
+          `${time} ${prefix} Received ${event.count} @mention notification(s)`
+        );
+        break;
+      case "poll_start":
+        console.log(`${time} ${prefix} Polling for work...`);
+        break;
+      case "poll_result":
+        if (event.foundWork) {
+          console.log(
+            `${time} ${prefix} Found work: ${event.taskId} - ${event.taskDescription}`
+          );
+        } else {
+          console.log(`${time} ${prefix} No work found`);
+        }
+        break;
+      case "work_start":
+        console.log(
+          `${time} ${prefix} Starting task ${event.taskId}: ${event.taskDescription}`
+        );
+        break;
+      case "work_complete":
+        console.log(
+          `${time} ${prefix} Completed ${event.taskId} ($${event.costUsd.toFixed(4)}, ${event.numTurns} turns)`
+        );
+        break;
+      case "work_error":
+        console.log(
+          `${time} ${prefix} Task ${event.taskId} failed: ${event.error}`
+        );
+        break;
+      case "tool_use":
+        console.log(`${time} ${prefix} Tool: ${event.toolName}`);
+        break;
+      case "cost_update":
+        break;
+      case "error":
+        console.error(`${time} ${prefix} ERROR: ${event.error}`);
+        break;
+      case "budget_exceeded":
+        console.log(
+          `${time} ${prefix} Budget exceeded: $${event.costUsd.toFixed(4)} >= $${event.limit.toFixed(2)}`
+        );
+        break;
+      case "shutdown_start":
+        console.log(`${time} ${prefix} Shutting down...`);
+        break;
+      case "shutdown_complete":
+        console.log(`${time} ${prefix} Stopped`);
+        break;
+    }
+  });
+}
+
+// src/index.ts
+main(process.argv.slice(2));