@agent-idle/cli 0.1.0

package/index.js

@@ -0,0 +1,1382 @@
+#!/usr/bin/env node
+
+// src/daemon.ts
+import { randomUUID } from "crypto";
+import { createServer } from "http";
+
+// ../../packages/engine/dist/config.js
+var HOUR_MS = 60 * 60 * 1e3;
+var DAY_MS = 24 * HOUR_MS;
+var DECAY = {
+  /**
+   * Fraction of energy (0..1) lost per hour with no usage. 6/h ⇒ full→empty in ~10 min,
+   * so an idle session-pet visibly weakens (lively→weary→drained→fainted) and dies on a
+   * timescale you can actually watch. DEV-fast — raise it for a longer, gentler game.
+   */
+  energyLostPerHour: 6,
+  /** Energy ladder thresholds (inclusive lower bounds), high → low. */
+  thresholds: {
+    /** >= lively → "lively" */
+    lively: 0.66,
+    /** >= weary  → "weary" */
+    weary: 0.33
+    /** > 0       → "drained" */
+    // (drained is anything above 0 but below `weary`)
+  },
+  /**
+   * Once energy reaches 0 the pet is "fainted" (recoverable). After this many additional
+   * hours at zero it crosses the TERMINAL rung (death in hardcore, deep faint in normal).
+   * 1/60 h = 1 min: a session that ENDS (clean exit / detected kill empties energy at once)
+   * reads as DEAD within a minute. A naturally idle pet still drains first (~10 min) before
+   * this window starts. Tune up for a longer "fainted but not yet dead" grace.
+   */
+  terminalGraceHours: 1 / 60,
+  /**
+   * After the terminal rung, how many MORE hours before the pet is REMOVED from the
+   * menagerie entirely (despawned). A dead pet lingers only this long before it is "gone":
+   * filtered from reads and eligible for the sweep to hard-delete. 1/60 h = 1 min, so an
+   * ended/killed session is GONE ~2 min after it empties (1 min dead + 1 min more). Kept
+   * short so dead pets don't pile up — still revivable the whole time by using the session.
+   */
+  removalGraceHours: 1 / 60
+};
+var SCORING = {
+  includePromptQualityInScore: false,
+  weights: {
+    tokensFed: 1 / 1e3,
+    // 1 point per 1k tokens fed
+    avgPromptQuality: 0,
+    // intentionally 0 — see note above
+    survivalStreakDays: 25,
+    zoneAchievements: 50
+  }
+};
+
+// ../../packages/engine/dist/prompt.js
+var VAGUE_PHRASES = [
+  "make it pop",
+  "make it nice",
+  "make it better",
+  "make it good",
+  "make it cool",
+  "do the thing",
+  "fix it",
+  "clean it up",
+  "just do it",
+  "somehow",
+  "some stuff"
+];
+var SPECIFIC_WORDS = /* @__PURE__ */ new Set([
+  "should",
+  "must",
+  "expect",
+  "given",
+  "when",
+  "then",
+  "because",
+  "constraint",
+  "return",
+  "function",
+  "test",
+  "error",
+  "input",
+  "output",
+  "api",
+  "type",
+  "interface",
+  "edge"
+]);
+var round2 = (n) => Math.round(n * 100) / 100;
+function clamp012(n) {
+  if (n < 0)
+    return 0;
+  if (n > 1)
+    return 1;
+  return n;
+}
+function appraisePrompt(text) {
+  const raw = text ?? "";
+  const lower = raw.toLowerCase().trim();
+  const words = lower.length === 0 ? [] : lower.split(/\s+/);
+  const wordCount = words.length;
+  let vagueHits = 0;
+  for (const phrase of VAGUE_PHRASES) {
+    if (lower.includes(phrase))
+      vagueHits++;
+  }
+  let specificHits = 0;
+  for (const w of words) {
+    const bare = w.replace(/[^a-z]/g, "");
+    if (SPECIFIC_WORDS.has(bare))
+      specificHits++;
+  }
+  const hasCodeFence = raw.includes("```");
+  const hasFilePath = /[\w-]+\.[a-z]{1,5}\b/.test(lower) || /\/[\w-]+/.test(raw);
+  const hasNumbers = /\d/.test(raw);
+  let quality = 0.15;
+  quality += Math.min(wordCount / 40, 1) * 0.4;
+  quality += Math.min(specificHits / 4, 1) * 0.2;
+  if (hasCodeFence)
+    quality += 0.15;
+  if (hasFilePath)
+    quality += 0.1;
+  if (hasNumbers)
+    quality += 0.05;
+  quality -= vagueHits * 0.4;
+  if (wordCount > 0 && wordCount <= 4 && specificHits === 0)
+    quality -= 0.3;
+  quality = clamp012(quality);
+  const tier = quality >= 0.75 ? "gourmet" : quality >= 0.5 ? "balanced" : quality >= 0.25 ? "snack" : "junk";
+  const status2 = vagueHits > 0 || wordCount > 0 && wordCount <= 4 && specificHits === 0 ? "confused" : quality >= 0.7 ? "satisfied" : quality >= 0.45 ? "content" : "meh";
+  const fill = round2(quality * 0.7);
+  return { tier, fill, status: status2, quality: round2(quality) };
+}
+
+// src/daemon.ts
+import { ConvexHttpClient } from "convex/browser";
+import { makeFunctionReference } from "convex/server";
+
+// src/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var DAEMON_PORT = 47615;
+var DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
+var STATE_DIR = join(homedir(), ".agent-idle");
+var OUTBOX_PATH = join(STATE_DIR, "outbox.jsonl");
+var AUTH_TOKEN_PATH = join(STATE_DIR, "auth.json");
+var CLAUDE_SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+var CODEX_HOOKS_PATH = join(homedir(), ".codex", "hooks.json");
+var AGENTS = ["claude", "codex"];
+function parseAgent(arg2) {
+  return arg2 === "codex" ? "codex" : "claude";
+}
+function parseAgents(args) {
+  const tokens = args.flatMap((a) => a.split(",")).map((t) => t.trim().toLowerCase());
+  const wantAll = tokens.includes("all");
+  const selected = AGENTS.filter((agent) => wantAll || tokens.includes(agent));
+  return selected.length > 0 ? [...selected] : ["claude"];
+}
+var SOURCES = {
+  claude: "cli-daemon",
+  codex: "codex-daemon"
+};
+var CONVEX_URL_PATH = join(STATE_DIR, "convex-url");
+function persistedConvexUrl() {
+  try {
+    return existsSync(CONVEX_URL_PATH) ? readFileSync(CONVEX_URL_PATH, "utf8").trim() || null : null;
+  } catch {
+    return null;
+  }
+}
+var BUILD_CONVEX_URL = "https://handsome-camel-783.convex.cloud";
+var BUILD_AUTH_URL = "https://agent-idle-app.vercel.app";
+var LOCAL_CONVEX_URL = "http://127.0.0.1:3210";
+function resolveConvexUrl() {
+  return process.env.CONVEX_URL ?? persistedConvexUrl() ?? BUILD_CONVEX_URL ?? LOCAL_CONVEX_URL;
+}
+var DEFAULT_CONVEX_URL = resolveConvexUrl();
+var AUTH_URL = process.env.AGENT_IDLE_AUTH_URL ?? BUILD_AUTH_URL ?? "http://localhost:1420";
+function ensureDir(path, mode) {
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true, ...mode !== void 0 ? { mode } : {} });
+  if (mode !== void 0) {
+    try {
+      chmodSync(dir, mode);
+    } catch {
+    }
+  }
+}
+function readToken() {
+  if (!existsSync(AUTH_TOKEN_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(AUTH_TOKEN_PATH, "utf8")).token ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeToken(token) {
+  ensureDir(AUTH_TOKEN_PATH, 448);
+  writeFileSync(AUTH_TOKEN_PATH, JSON.stringify({ token }) + "\n", { mode: 384 });
+  try {
+    chmodSync(AUTH_TOKEN_PATH, 384);
+  } catch {
+  }
+}
+function clearToken() {
+  try {
+    if (existsSync(AUTH_TOKEN_PATH)) rmSync(AUTH_TOKEN_PATH);
+  } catch {
+  }
+}
+
+// src/outbox.ts
+import { appendFileSync, chmodSync as chmodSync2, existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+function tighten() {
+  try {
+    chmodSync2(OUTBOX_PATH, 384);
+  } catch {
+  }
+}
+function enqueue(item) {
+  ensureDir(OUTBOX_PATH, 448);
+  appendFileSync(OUTBOX_PATH, JSON.stringify(item) + "\n", { mode: 384 });
+  tighten();
+}
+function readOutbox() {
+  if (!existsSync2(OUTBOX_PATH)) return [];
+  return readFileSync2(OUTBOX_PATH, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+}
+function writeOutbox(items) {
+  ensureDir(OUTBOX_PATH, 448);
+  writeFileSync2(OUTBOX_PATH, items.map((i) => JSON.stringify(i)).join("\n") + (items.length ? "\n" : ""), {
+    mode: 384
+  });
+  tighten();
+}
+
+// src/proc.ts
+import { execFileSync } from "child_process";
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function processStartTime(pid) {
+  if (process.platform === "win32") return "";
+  try {
+    return execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 500
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+// src/transcript.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+function readTokenUsage(path, agent) {
+  if (!path || !existsSync3(path)) return { tokens: 0 };
+  try {
+    const text = readFileSync3(path, "utf8");
+    return { tokens: agent === "codex" ? codexTokens(text) : claudeTokens(text) };
+  } catch {
+    return { tokens: 0 };
+  }
+}
+function usageTotal(u) {
+  return (u.input_tokens ?? 0) + (u.output_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+}
+function isPrompt(e) {
+  if (e.type !== "user") return false;
+  const c = e.message?.content;
+  if (typeof c === "string") return true;
+  if (Array.isArray(c)) return !c.some((x) => typeof x === "object" && x !== null && x.type === "tool_result");
+  return false;
+}
+function claudeTokens(text) {
+  const entries = [];
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  let start = 0;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i];
+    if (e && isPrompt(e)) {
+      start = i;
+      break;
+    }
+  }
+  let tokens = 0;
+  for (let i = start; i < entries.length; i++) {
+    const u = entries[i]?.message?.usage;
+    if (u) tokens += usageTotal(u);
+  }
+  return tokens;
+}
+function codexTokens(text) {
+  const sum = (u) => u ? u.total_tokens ?? (u.input_tokens ?? 0) + (u.output_tokens ?? 0) : 0;
+  let tokens = 0;
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    try {
+      const obj = JSON.parse(line);
+      const p = obj.payload;
+      if (p?.type !== "token_count") continue;
+      const last = p.last_token_usage ?? p.info?.last_token_usage;
+      const total = p.total_token_usage ?? p.info?.total_token_usage;
+      tokens = last ? sum(last) : sum(total);
+    } catch {
+    }
+  }
+  return tokens;
+}
+
+// src/daemon.ts
+var FLUSH_INTERVAL_MS = 5e3;
+var RENEW_MS = 12e3;
+var HELPER_CREDIT_FLUSH_MS = 2e3;
+var HELPER_RETAIN_MS = 6e3;
+var LIVENESS_POLL_MS = 5e3;
+var DEBUG = Boolean(process.env.AGENT_IDLE_DEBUG) || process.argv.includes("--debug");
+function debug(...args) {
+  if (DEBUG) console.log("[agent-idle]", ...args);
+}
+var tag = (s) => s.slice(0, 8);
+function repoFromCwd(cwd) {
+  if (!cwd) return "";
+  const parts = cwd.replace(/[/\\]+$/, "").split(/[/\\]/);
+  return parts[parts.length - 1] ?? "";
+}
+var TOPIC_STOP = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "to",
+  "of",
+  "and",
+  "or",
+  "for",
+  "in",
+  "on",
+  "with",
+  "my",
+  "our",
+  "your",
+  "please",
+  "pls",
+  "can",
+  "could",
+  "would",
+  "should",
+  "i",
+  "we",
+  "it",
+  "this",
+  "that",
+  "these",
+  "is",
+  "are",
+  "be",
+  "do",
+  "make",
+  "add",
+  "fix",
+  "update",
+  "create",
+  "change",
+  "how",
+  "what",
+  "when",
+  "why",
+  "help",
+  "need",
+  "want",
+  "get",
+  "set",
+  "use",
+  "using",
+  "into",
+  "from",
+  "so",
+  "also",
+  "just",
+  "new",
+  "some",
+  "any",
+  "through",
+  "look",
+  "about",
+  "like",
+  "have",
+  "has"
+]);
+function topicWord(prompt) {
+  const words = (prompt ?? "").toLowerCase().match(/[a-z][a-z0-9+_-]{2,}/g) ?? [];
+  const meaningful = words.filter((w) => !TOPIC_STOP.has(w));
+  const pool = meaningful.length > 0 ? meaningful : words;
+  return pool.reduce((best, w) => w.length > best.length ? w : best, "");
+}
+var ingestEvent = makeFunctionReference("events:ingestEvent");
+function classifyToolAction(toolName) {
+  switch (toolName) {
+    case "Bash":
+    case "BashOutput":
+    case "KillShell":
+    case "KillBash":
+      return "shell";
+    case "Edit":
+    case "MultiEdit":
+    case "Write":
+    case "NotebookEdit":
+      return "edit";
+    case "Read":
+    case "Grep":
+    case "Glob":
+    case "LS":
+      return "read";
+    case "WebFetch":
+    case "WebSearch":
+      return "web";
+    default:
+      return "none";
+  }
+}
+function classifyNotification(message) {
+  const m = (message ?? "").toLowerCase();
+  if (m.includes("permission") || m.includes("approve") || m.includes("approval")) return "alert";
+  return "question";
+}
+var MAX_BODY_BYTES = 1e6;
+function readBody(req) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > MAX_BODY_BYTES) {
+        req.destroy();
+        resolve("");
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", () => resolve(""));
+  });
+}
+var ALLOWED_ORIGINS = (() => {
+  const out = /* @__PURE__ */ new Set([
+    "http://localhost:1420",
+    "http://127.0.0.1:1420",
+    // Vite dev / Tauri dev webview
+    "tauri://localhost",
+    "http://tauri.localhost",
+    "https://tauri.localhost"
+    // Tauri production webview schemes (platform-dependent)
+  ]);
+  try {
+    out.add(new URL(AUTH_URL).origin);
+  } catch {
+  }
+  for (const o of (process.env.AGENT_IDLE_APP_ORIGINS ?? "").split(",")) {
+    const trimmed = o.trim();
+    if (trimmed) out.add(trimmed);
+  }
+  return out;
+})();
+function hostOk(req) {
+  const host = req.headers.host;
+  return host === `127.0.0.1:${DAEMON_PORT}` || host === `localhost:${DAEMON_PORT}`;
+}
+function originOk(req) {
+  const origin = req.headers.origin;
+  return !origin || ALLOWED_ORIGINS.has(origin);
+}
+function corsHeaders(req) {
+  const origin = req.headers.origin;
+  if (!origin || !ALLOWED_ORIGINS.has(origin)) return {};
+  return {
+    "Access-Control-Allow-Origin": origin,
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type",
+    Vary: "Origin"
+  };
+}
+function startDaemon() {
+  const lastAppraisal = /* @__PURE__ */ new Map();
+  const registered = /* @__PURE__ */ new Set();
+  const workingSentAt = /* @__PURE__ */ new Map();
+  const waiting = /* @__PURE__ */ new Set();
+  const lastAction = /* @__PURE__ */ new Map();
+  const sessionMeta = /* @__PURE__ */ new Map();
+  const agentProc = /* @__PURE__ */ new Map();
+  const liveHelpers = /* @__PURE__ */ new Map();
+  const pendingHelperCredits = /* @__PURE__ */ new Map();
+  function helperBucket(session) {
+    let bucket = liveHelpers.get(session);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Map();
+      liveHelpers.set(session, bucket);
+    }
+    return bucket;
+  }
+  function pruneHelpers() {
+    const now = Date.now();
+    for (const [session, bucket] of liveHelpers) {
+      for (const [agentId, h] of bucket) {
+        if (h.finishedAt != null && now - h.finishedAt > HELPER_RETAIN_MS) bucket.delete(agentId);
+      }
+      if (bucket.size === 0) liveHelpers.delete(session);
+    }
+  }
+  function clearHelpers(session) {
+    liveHelpers.delete(session);
+  }
+  function queueHelperCredit(session, agent, tokens, action) {
+    if (tokens <= 0) return;
+    const prev = pendingHelperCredits.get(session);
+    pendingHelperCredits.set(session, {
+      agent,
+      tokens: (prev?.tokens ?? 0) + tokens,
+      action
+    });
+  }
+  function flushHelperCredits(session) {
+    const entries = session != null ? pendingHelperCredits.has(session) ? [[session, pendingHelperCredits.get(session)]] : [] : [...pendingHelperCredits.entries()];
+    for (const [parentSession, credit] of entries) {
+      pendingHelperCredits.delete(parentSession);
+      emit(parentSession, credit.agent, {
+        working: true,
+        action: lastAction.get(parentSession) ?? credit.action,
+        tokens: credit.tokens
+      });
+    }
+  }
+  function noteMeta(session, payload) {
+    const prev = sessionMeta.get(session) ?? { repo: "", topic: "", terminal: "" };
+    sessionMeta.set(session, {
+      repo: prev.repo || repoFromCwd(payload.cwd),
+      topic: prev.topic || topicWord(payload.prompt ?? ""),
+      terminal: prev.terminal || (payload.terminal ?? "")
+    });
+  }
+  let flushing = false;
+  function emit(session, agent, payload) {
+    enqueue({
+      type: "activity",
+      sessionId: session,
+      source: SOURCES[agent],
+      payload,
+      clientEventId: randomUUID(),
+      clientAt: Date.now()
+    });
+    void flush();
+  }
+  function register(session, agent) {
+    if (registered.has(session)) return;
+    registered.add(session);
+    enqueue({
+      type: "register",
+      sessionId: session,
+      source: SOURCES[agent],
+      payload: {},
+      clientEventId: randomUUID(),
+      clientAt: Date.now()
+    });
+  }
+  function working(session, agent, force, action = "none") {
+    const changed = action !== (lastAction.get(session) ?? "none");
+    if (!force && !changed && Date.now() - (workingSentAt.get(session) ?? 0) < RENEW_MS) return;
+    workingSentAt.set(session, Date.now());
+    lastAction.set(session, action);
+    emit(session, agent, { working: true, action });
+  }
+  function handleHook(payload, agent) {
+    const session = payload.session_id ?? "default";
+    if (typeof payload.agentPid === "number" && payload.agentStart) {
+      agentProc.set(session, { pid: payload.agentPid, start: payload.agentStart, agent });
+    }
+    switch (payload.hook_event_name) {
+      // A session opened / resumed / cleared → spawn-or-wake its pet so it's on screen before
+      // the first prompt. Server derives species/name and dedups by sessionId.
+      case "SessionStart": {
+        const firstStart = !sessionMeta.has(session);
+        noteMeta(session, payload);
+        register(session, agent);
+        if (firstStart) {
+          console.log(
+            `[agent-idle] session ${tag(session)} started in "${payload.terminal || "unknown terminal"}" (${repoFromCwd(payload.cwd) || "no repo"})`
+          );
+        }
+        debug(`hook SessionStart agent=${agent} session=${tag(session)} source=${payload.source ?? "?"} \u2192 spawn/wake`);
+        return;
+      }
+      // Context compaction is the agent "consolidating memory" mid-task — keep the pet busy at
+      // its current job so a long compaction doesn't lapse it to idle.
+      case "PreCompact": {
+        working(session, agent, false, lastAction.get(session) ?? "none");
+        debug(`hook PreCompact agent=${agent} session=${tag(session)} trigger=${payload.trigger ?? "?"} \u2192 keep working`);
+        return;
+      }
+      case "UserPromptSubmit": {
+        register(session, agent);
+        const firstSight = !sessionMeta.has(session);
+        noteMeta(session, payload);
+        if (firstSight) {
+          console.log(
+            `[agent-idle] session ${tag(session)} active in "${payload.terminal || "unknown terminal"}" (${repoFromCwd(payload.cwd) || "no repo"})`
+          );
+        }
+        lastAppraisal.set(session, appraisePrompt(payload.prompt ?? ""));
+        waiting.delete(session);
+        working(session, agent, true);
+        debug(`hook UserPromptSubmit agent=${agent} session=${tag(session)} \u2192 working`);
+        return;
+      }
+      // Tool activity DURING a turn renews the working window. When the agent stops (turn
+      // end OR a Ctrl-C interrupt), these stop firing and the pet lapses to idle.
+      case "PreToolUse":
+      case "PostToolUse": {
+        if (payload.agent_id) {
+          const h = liveHelpers.get(session)?.get(payload.agent_id);
+          if (h && h.finishedAt == null) h.action = classifyToolAction(payload.tool_name);
+          working(session, agent, false, lastAction.get(session) ?? "none");
+          return;
+        }
+        const wasWaiting = waiting.delete(session);
+        const action = classifyToolAction(payload.tool_name);
+        working(session, agent, wasWaiting, action);
+        return;
+      }
+      // A sub-agent (Task) finished. Credit its token output to the PARENT via one ordinary
+      // activity event (same additive path as the main Stop; no appraisal ⇒ the prompt-quality
+      // average is untouched), keeping the parent mining at its CURRENT job (action MUST be carried
+      // — apply() resets an omitted action to "none", which would yank the parent out of its room).
+      // Then mark the helper finished, retained briefly so the app can play its deliver→poof outro.
+      case "SubagentStop": {
+        const parentAction = lastAction.get(session) ?? "none";
+        const { tokens } = readTokenUsage(payload.agent_transcript_path, agent);
+        if (tokens > 0) queueHelperCredit(session, agent, tokens, parentAction);
+        working(session, agent, false, parentAction);
+        if (payload.agent_id) {
+          const h = liveHelpers.get(session)?.get(payload.agent_id);
+          if (h) {
+            h.finishedAt = Date.now();
+            h.tokens = tokens;
+          }
+          debug(`hook SubagentStop agent=${agent} session=${tag(session)} helper=${tag(payload.agent_id)} tokens=${tokens}`);
+        }
+        return;
+      }
+      // The session is gone (quit / logout / clear). The authoritative "agent stopped" signal —
+      // force the pet idle now instead of waiting out the freshness window, and drop any bubble.
+      case "SessionEnd": {
+        flushHelperCredits(session);
+        workingSentAt.delete(session);
+        waiting.delete(session);
+        lastAction.delete(session);
+        registered.delete(session);
+        agentProc.delete(session);
+        clearHelpers(session);
+        emit(session, agent, { working: false, ended: true });
+        debug(`hook SessionEnd agent=${agent} session=${tag(session)} \u2192 ended`);
+        return;
+      }
+      // Precise "the agent needs you" signals (richer than Notification): a permission dialog
+      // or an MCP input request blocks the turn → show the alert bubble, stop working.
+      case "PermissionRequest":
+      case "Elicitation": {
+        waiting.add(session);
+        emit(session, agent, { working: false, waiting: "alert" });
+        debug(`hook ${payload.hook_event_name} agent=${agent} session=${tag(session)} \u2192 waiting=alert`);
+        return;
+      }
+      // The ask was resolved (denied / MCP answered) → drop the bubble now; a later tool or
+      // prompt resumes work.
+      case "PermissionDenied":
+      case "ElicitationResult": {
+        waiting.delete(session);
+        emit(session, agent, { working: false });
+        return;
+      }
+      // Compaction finished → the agent is active; keep the pet busy at its current job (no
+      // tool_name on this event ⇒ reuse lastAction).
+      case "PostCompact": {
+        working(session, agent, false, lastAction.get(session) ?? "none");
+        return;
+      }
+      // A sub-agent spawned → the PARENT keeps mining at its current job, AND we start tracking the
+      // helper so the app can render it as a mini pet beside the parent (local visual only).
+      case "SubagentStart": {
+        working(session, agent, false, lastAction.get(session) ?? "none");
+        if (payload.agent_id) {
+          helperBucket(session).set(payload.agent_id, {
+            agentId: payload.agent_id,
+            agentType: payload.agent_type ?? "subagent",
+            action: "none",
+            startedAt: Date.now()
+          });
+          debug(`hook SubagentStart agent=${agent} session=${tag(session)} helper=${tag(payload.agent_id)} (${payload.agent_type ?? "subagent"})`);
+        }
+        return;
+      }
+      // A tool FAILED but the agent keeps going → stay working at the (failed) tool's job.
+      case "PostToolUseFailure": {
+        const wasWaiting = waiting.delete(session);
+        working(session, agent, wasWaiting, classifyToolAction(payload.tool_name));
+        return;
+      }
+      // The turn ended via an API error (no Stop fires) → the pet is "knocked out" (collapsed
+      // at camp) so a failed run is visible, until it recovers or the next turn starts.
+      case "StopFailure": {
+        flushHelperCredits(session);
+        workingSentAt.delete(session);
+        waiting.delete(session);
+        lastAction.delete(session);
+        clearHelpers(session);
+        emit(session, agent, { working: false, failed: true });
+        debug(`hook StopFailure agent=${agent} session=${tag(session)} \u2192 failed (knocked out)`);
+        return;
+      }
+      // The agent wants the human: a permission prompt or an idle wait-for-input. Mark the
+      // session waiting (not working) so the ?/! bubble shows; classify the kind locally.
+      case "Notification": {
+        const kind = classifyNotification(payload.message);
+        waiting.add(session);
+        emit(session, agent, { working: false, waiting: kind });
+        debug(`hook Notification agent=${agent} session=${tag(session)} \u2192 waiting=${kind}`);
+        return;
+      }
+      case "Stop": {
+        const { tokens } = readTokenUsage(payload.transcript_path, agent);
+        const appraisal = lastAppraisal.get(session) ?? appraisePrompt("");
+        flushHelperCredits(session);
+        lastAppraisal.delete(session);
+        workingSentAt.delete(session);
+        waiting.delete(session);
+        lastAction.delete(session);
+        clearHelpers(session);
+        emit(session, agent, { working: false, appraisal, tokens });
+        debug(`hook Stop agent=${agent} session=${tag(session)} \u2192 idle (tokens=${tokens}, fill=${appraisal.fill})`);
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  function checkLiveness() {
+    pruneHelpers();
+    for (const [session, proc] of agentProc) {
+      if (processAlive(proc.pid)) {
+        const start = processStartTime(proc.pid);
+        if (!start || start === proc.start) continue;
+      }
+      workingSentAt.delete(session);
+      waiting.delete(session);
+      lastAction.delete(session);
+      lastAppraisal.delete(session);
+      registered.delete(session);
+      agentProc.delete(session);
+      flushHelperCredits(session);
+      clearHelpers(session);
+      emit(session, proc.agent, { working: false, ended: true });
+      debug(`liveness: agent pid=${proc.pid} session=${tag(session)} gone \u2192 ended (killed)`);
+    }
+  }
+  async function flush() {
+    if (flushing) return;
+    const token = readToken();
+    const items = readOutbox();
+    if (items.length === 0) return;
+    if (!token) {
+      debug(`flush: ${items.length} event(s) queued but no auth token \u2014 sign in via the app`);
+      return;
+    }
+    flushing = true;
+    try {
+      const convexUrl = resolveConvexUrl();
+      debug(`flush: posting ${items.length} event(s) to ${convexUrl}`);
+      const client = new ConvexHttpClient(convexUrl);
+      client.setAuth(token);
+      const remaining = [];
+      for (const item of items) {
+        try {
+          const res = await client.mutation(ingestEvent, item);
+          debug(`  ${item.type} session=${tag(item.sessionId)} \u2192`, res);
+        } catch (err) {
+          remaining.push(item);
+          debug(`  ${item.type} session=${tag(item.sessionId)} FAILED:`, err?.message ?? err);
+        }
+      }
+      writeOutbox(remaining);
+    } finally {
+      flushing = false;
+    }
+  }
+  const server = createServer((req, res) => {
+    if (!hostOk(req)) {
+      res.writeHead(403).end();
+      return;
+    }
+    const cors = corsHeaders(req);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, cors).end();
+      return;
+    }
+    if (req.method === "GET" && req.url === "/token") {
+      if (req.headers.origin) {
+        res.writeHead(403).end();
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ token: readToken() }));
+      return;
+    }
+    if (req.method === "GET" && req.url === "/sessions") {
+      res.writeHead(200, { ...cors, "Content-Type": "application/json" });
+      res.end(JSON.stringify(Object.fromEntries(sessionMeta)));
+      return;
+    }
+    if (req.method === "GET" && req.url === "/subagents") {
+      pruneHelpers();
+      const out = {};
+      for (const [session, bucket] of liveHelpers) {
+        if (bucket.size > 0) out[session] = [...bucket.values()];
+      }
+      res.writeHead(200, { ...cors, "Content-Type": "application/json" });
+      res.end(JSON.stringify(out));
+      return;
+    }
+    if (!originOk(req)) {
+      res.writeHead(403, cors).end();
+      return;
+    }
+    if (req.method === "POST" && req.url === "/shutdown") {
+      res.writeHead(204, cors).end();
+      debug("shutdown requested via /shutdown \u2014 exiting");
+      setTimeout(() => process.exit(0), 50);
+      return;
+    }
+    if (req.method !== "POST") {
+      res.writeHead(404, cors).end();
+      return;
+    }
+    void readBody(req).then((body) => {
+      try {
+        if (req.url === "/auth-token") {
+          const { token: t } = JSON.parse(body || "{}");
+          if (t) {
+            writeToken(t);
+            debug("auth token received from app \u2014 will flush as the authenticated user");
+          }
+        } else if (req.url?.startsWith("/hook")) {
+          const agent = parseAgent(new URL(req.url, "http://127.0.0.1").searchParams.get("agent") ?? void 0);
+          handleHook(JSON.parse(body || "{}"), agent);
+        }
+      } catch {
+      }
+      res.writeHead(204, cors).end();
+    });
+  });
+  server.on("error", () => process.exit(0));
+  server.listen(DAEMON_PORT, "127.0.0.1", () => {
+    console.log(`agent-idle daemon listening on http://127.0.0.1:${DAEMON_PORT}`);
+    console.log(
+      readToken() ? "  shared auth token present." : "  no auth token yet \u2014 run `agent-idle setup` to sign in."
+    );
+  });
+  setInterval(() => void flush(), FLUSH_INTERVAL_MS);
+  setInterval(() => flushHelperCredits(), HELPER_CREDIT_FLUSH_MS);
+  setInterval(checkLiveness, LIVENESS_POLL_MS);
+}
+
+// src/hook.ts
+import { execFileSync as execFileSync2 } from "child_process";
+
+// src/daemonControl.ts
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+function spawnDaemon() {
+  const indexPath = fileURLToPath(new URL("./index.js", import.meta.url));
+  const child = spawn(process.execPath, [indexPath, "daemon"], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+async function pingDaemon() {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 500);
+    const res = await fetch(`${DAEMON_URL}/token`, { signal: controller.signal });
+    clearTimeout(timer);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function daemonToken() {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 800);
+    const res = await fetch(`${DAEMON_URL}/token`, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const { token } = await res.json();
+    return token ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/hook.ts
+var SHELL_COMMS = /* @__PURE__ */ new Set([
+  "sh",
+  "bash",
+  "zsh",
+  "dash",
+  "fish",
+  "ksh",
+  "tcsh",
+  "csh",
+  "-sh",
+  "-bash",
+  "-zsh",
+  "-dash",
+  "-fish",
+  "-ksh",
+  "-tcsh",
+  "-csh"
+]);
+function psField(pid, field) {
+  try {
+    return execFileSync2("ps", ["-o", `${field}=`, "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 500
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function resolveAgentProcess() {
+  let pid = process.ppid;
+  for (let hop = 0; hop < 5 && pid > 1; hop++) {
+    const comm = psField(pid, "comm");
+    if (!comm) return null;
+    const base = comm.split("/").pop() ?? comm;
+    if (!SHELL_COMMS.has(base)) {
+      const start = psField(pid, "lstart");
+      return start ? { pid, start } : null;
+    }
+    const ppid = Number.parseInt(psField(pid, "ppid"), 10);
+    if (!Number.isFinite(ppid) || ppid <= 1) return null;
+    pid = ppid;
+  }
+  return null;
+}
+function terminalName() {
+  const e = process.env;
+  return e.AGENT_IDLE_LABEL || e.TERM_PROGRAM || e.WT_SESSION || (e.TMUX_PANE ? `tmux ${e.TMUX_PANE}` : "") || e.TERM || "";
+}
+function tagPayload(body) {
+  try {
+    const obj = JSON.parse(body);
+    if (!obj || typeof obj !== "object") return body;
+    if (!obj.terminal) obj.terminal = terminalName();
+    const event = obj.hook_event_name;
+    if ((event === "SessionStart" || event === "UserPromptSubmit") && !obj.agentPid) {
+      const proc = resolveAgentProcess();
+      if (proc) {
+        obj.agentPid = proc.pid;
+        obj.agentStart = proc.start;
+      }
+    }
+    return JSON.stringify(obj);
+  } catch {
+    return body;
+  }
+}
+function readStdin() {
+  return new Promise((resolve) => {
+    const chunks = [];
+    process.stdin.on("data", (c) => chunks.push(c));
+    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    process.stdin.on("error", () => resolve(""));
+  });
+}
+async function postToDaemon(url, body) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 800);
+    await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function runHook(agentArg) {
+  const url = `${DAEMON_URL}/hook?agent=${parseAgent(agentArg)}`;
+  let body = "{}";
+  try {
+    body = await readStdin() || "{}";
+  } catch {
+  }
+  body = tagPayload(body);
+  if (await postToDaemon(url, body)) return;
+  spawnDaemon();
+  await sleep(600);
+  await postToDaemon(url, body);
+}
+
+// src/kill.ts
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function kill() {
+  if (!await pingDaemon()) {
+    console.log("No agent-idle daemon is running.");
+    return;
+  }
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1e3);
+    await fetch(`${DAEMON_URL}/shutdown`, { method: "POST", signal: controller.signal });
+    clearTimeout(timer);
+  } catch {
+  }
+  await sleep2(250);
+  if (await pingDaemon()) {
+    console.log(
+      "Asked the daemon to stop, but it's still responding. Re-run `agent-idle kill`, or kill whatever holds port 47615."
+    );
+  } else {
+    console.log("\u2713 Stopped the agent-idle daemon. The next hook will start a fresh one.");
+  }
+}
+
+// src/remove.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+
+// src/hooks.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function ourBinPath() {
+  return fileURLToPath2(new URL("./index.js", import.meta.url));
+}
+function isOurEntry(entry, binPath) {
+  const inner = entry?.hooks;
+  if (!Array.isArray(inner)) return false;
+  return inner.some((h) => {
+    const cmd = h?.command;
+    if (typeof cmd !== "string") return false;
+    return cmd.includes(binPath) || cmd.includes("agent-idle") && /\bhook\b/.test(cmd);
+  });
+}
+function countInstalledEvents(path) {
+  if (!existsSync4(path)) return 0;
+  let config;
+  try {
+    config = JSON.parse(readFileSync4(path, "utf8"));
+  } catch {
+    return 0;
+  }
+  const hooks = config.hooks;
+  if (!hooks || typeof hooks !== "object") return 0;
+  const binPath = ourBinPath();
+  let count = 0;
+  for (const event of Object.keys(hooks)) {
+    const arr = hooks[event];
+    if (Array.isArray(arr) && arr.some((entry) => isOurEntry(entry, binPath))) count++;
+  }
+  return count;
+}
+
+// src/remove.ts
+function stripHooks(path) {
+  if (!existsSync5(path)) return 0;
+  let config;
+  try {
+    config = JSON.parse(readFileSync5(path, "utf8"));
+  } catch {
+    return 0;
+  }
+  const hooks = config.hooks;
+  if (!hooks || typeof hooks !== "object") return 0;
+  const binPath = ourBinPath();
+  let removed = 0;
+  for (const event of Object.keys(hooks)) {
+    const arr = hooks[event];
+    if (!Array.isArray(arr)) continue;
+    const kept = arr.filter((entry) => !isOurEntry(entry, binPath));
+    if (kept.length === arr.length) continue;
+    removed++;
+    if (kept.length === 0) delete hooks[event];
+    else hooks[event] = kept;
+  }
+  if (removed === 0) return 0;
+  if (Object.keys(hooks).length === 0) delete config.hooks;
+  writeFileSync3(path, JSON.stringify(config, null, 2) + "\n");
+  return removed;
+}
+function remove() {
+  const claude = stripHooks(CLAUDE_SETTINGS_PATH);
+  const codex = stripHooks(CODEX_HOOKS_PATH);
+  const hadToken = existsSync5(AUTH_TOKEN_PATH);
+  clearToken();
+  console.log(`
+\u2713 agent-idle removed
+    Claude Code hooks: ${claude > 0 ? `cleared (${claude} events) \u2014 ${CLAUDE_SETTINGS_PATH}` : "none found"}
+    Codex hooks:       ${codex > 0 ? `cleared (${codex} events) \u2014 ${CODEX_HOOKS_PATH}` : "none found"}
+    session:           ${hadToken ? `cleared \u2014 ${AUTH_TOKEN_PATH}` : "none found"}
+
+  The daemon stops posting on its next tick. Re-run \`agent-idle setup\` to reinstall.
+`);
+}
+
+// src/setup.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { cancel, isCancel, multiselect } from "@clack/prompts";
+
+// src/auth.ts
+import { spawn as spawn2 } from "child_process";
+var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+function openBrowser(url) {
+  const [bin, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    spawn2(bin, args, {
+      stdio: "ignore",
+      detached: true
+    }).unref();
+  } catch {
+  }
+}
+async function signIn() {
+  if (readToken()) {
+    console.log(
+      "\u2713 Already signed in (shared session at ~/.agent-idle/auth.json)."
+    );
+    return;
+  }
+  if (!await pingDaemon()) {
+    spawnDaemon();
+    await sleep3(700);
+  }
+  console.log(`
+Opening ${AUTH_URL} to sign in (GitHub or email + password)\u2026`);
+  console.log(
+    "If it doesn't open, visit that URL manually. Waiting for sign-in\u2026 (Ctrl-C to cancel)"
+  );
+  openBrowser(AUTH_URL);
+  const deadline = Date.now() + 12e4;
+  while (Date.now() < deadline) {
+    await sleep3(1500);
+    if (await daemonToken() ?? readToken()) {
+      console.log(
+        "\u2713 Signed in \u2014 shared session established for the app, CLI, and daemon."
+      );
+      return;
+    }
+  }
+  console.log(
+    "Timed out waiting for sign-in. Re-run `agent-idle setup` once you've signed in."
+  );
+}
+
+// src/setup.ts
+var CLAUDE_HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "PermissionRequest",
+  "PermissionDenied",
+  "Notification",
+  "Elicitation",
+  "ElicitationResult",
+  "SubagentStart",
+  "SubagentStop",
+  "Stop",
+  "StopFailure",
+  "PreCompact",
+  "PostCompact",
+  "SessionEnd"
+];
+var CODEX_HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PermissionRequest",
+  "SubagentStart",
+  "SubagentStop",
+  "PreCompact",
+  "PostCompact",
+  "Stop"
+];
+function hookCommand(agent) {
+  const indexPath = fileURLToPath3(new URL("./index.js", import.meta.url));
+  const base = `"${process.execPath}" "${indexPath}" hook`;
+  return agent === "codex" ? `${base} codex` : base;
+}
+function requireNode22() {
+  const major = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
+  if (major >= 22) return;
+  console.error(`
+\u2717 agent-idle setup needs Node \u2265 22 \u2014 you're on Node ${process.versions.node} (${process.execPath}).
+
+  The hook command bakes in THIS Node binary, so installing now would freeze the wrong
+  version into your agent's hook config. Switch first, then re-run:
+
+    nvm use 22 && agent-idle setup${process.argv.length > 3 ? ` ${process.argv.slice(3).join(" ")}` : ""}
+`);
+  process.exit(1);
+}
+function setupClaude(command2) {
+  const settings = existsSync6(CLAUDE_SETTINGS_PATH) ? JSON.parse(readFileSync6(CLAUDE_SETTINGS_PATH, "utf8")) : {};
+  const hooks = settings.hooks ?? {};
+  for (const event of CLAUDE_HOOK_EVENTS) {
+    hooks[event] = [{ hooks: [{ type: "command", command: command2 }] }];
+  }
+  settings.hooks = hooks;
+  ensureDir(CLAUDE_SETTINGS_PATH);
+  writeFileSync4(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+  console.log(`
+\u2713 Registered Claude Code hook
+    file:   ${CLAUDE_SETTINGS_PATH}
+    events: ${CLAUDE_HOOK_EVENTS.join(", ")}
+    cmd:    ${command2}
+${privacyAndNext()}`);
+}
+function setupCodex(command2) {
+  const config = existsSync6(CODEX_HOOKS_PATH) ? JSON.parse(readFileSync6(CODEX_HOOKS_PATH, "utf8")) : {};
+  const hooks = config.hooks ?? {};
+  for (const event of CODEX_HOOK_EVENTS) {
+    hooks[event] = [{ hooks: [{ type: "command", command: command2 }] }];
+  }
+  config.hooks = hooks;
+  ensureDir(CODEX_HOOKS_PATH);
+  writeFileSync4(CODEX_HOOKS_PATH, JSON.stringify(config, null, 2) + "\n");
+  console.log(`
+\u2713 Registered Codex hook
+    file:   ${CODEX_HOOKS_PATH}
+    events: ${CODEX_HOOK_EVENTS.join(", ")}
+    cmd:    ${command2}
+
+  \u26A0 Codex requires you to TRUST a newly-installed command hook before it runs:
+    open Codex and run  /hooks  \u2192 review and trust the agent-idle hook.
+${privacyAndNext()}`);
+}
+function privacyAndNext() {
+  return `
+  PRIVACY: the daemon appraises your prompts LOCALLY to compute a coarse numeric
+  quality score. It sends COUNTS + that score to the server \u2014 never your prompt text
+  or source code. Nothing is written to any dotfile except the hook config above.
+
+  The sensor daemon starts AUTOMATICALLY the first time a hook fires (and stays
+  running). You don't need to start it by hand. The SAME daemon serves both Claude
+  Code and Codex.
+
+  (advanced: \`agent-idle daemon\` runs the sensor in the foreground for debugging.)
+`;
+}
+async function promptAgents() {
+  const selection = await multiselect({
+    message: "Which coding agents should feed Agent Idle?",
+    options: [
+      { value: "claude", label: "Claude Code" },
+      { value: "codex", label: "Codex" }
+    ],
+    initialValues: ["claude"],
+    required: true
+  });
+  if (isCancel(selection)) {
+    cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return parseAgents(selection);
+}
+async function setup(agentArgs) {
+  requireNode22();
+  const agents = agentArgs.length > 0 ? parseAgents(agentArgs) : await promptAgents();
+  for (const agent of agents) {
+    const command2 = hookCommand(agent);
+    if (agent === "codex") setupCodex(command2);
+    else setupClaude(command2);
+  }
+  await signIn();
+}
+
+// src/status.ts
+async function fetchSessions() {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 800);
+    const res = await fetch(`${DAEMON_URL}/sessions`, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function status() {
+  const running = await pingDaemon();
+  const signedIn = Boolean(readToken());
+  const claude = countInstalledEvents(CLAUDE_SETTINGS_PATH);
+  const codex = countInstalledEvents(CODEX_HOOKS_PATH);
+  const queued = readOutbox().length;
+  const lines = [
+    `Daemon:   ${running ? `running on 127.0.0.1:${DAEMON_PORT}` : "not running (a hook will auto-start it)"}`,
+    `Session:  ${signedIn ? "signed in" : "not signed in \u2014 run `agent-idle setup`"}`,
+    `Hooks:    Claude Code ${claude ? `\u2713 (${claude} events)` : "\u2717 not installed"}   \xB7   Codex ${codex ? `\u2713 (${codex} events)` : "\u2717 not installed"}`,
+    `Outbox:   ${queued} event(s) queued${queued && !signedIn ? " (waiting for sign-in)" : ""}`
+  ];
+  if (running) {
+    const sessions = await fetchSessions();
+    const ids = sessions ? Object.keys(sessions) : [];
+    if (ids.length === 0) {
+      lines.push("Active:   no live sessions");
+    } else {
+      lines.push(`Active:   ${ids.length} session(s)`);
+      for (const id of ids) {
+        const m = sessions?.[id] ?? {};
+        const label = [m.repo, m.topic].filter(Boolean).join(" \xB7 ") || "\u2014";
+        const term = m.terminal ? `  (${m.terminal})` : "";
+        lines.push(`            ${id.slice(0, 8)}  ${label}${term}`);
+      }
+    }
+  }
+  console.log(`
+${lines.join("\n")}
+`);
+}
+
+// src/index.ts
+var command = process.argv[2];
+var arg = process.argv[3];
+switch (command) {
+  case "setup":
+    await setup(process.argv.slice(3));
+    break;
+  case "status":
+    await status();
+    break;
+  case "remove":
+    remove();
+    break;
+  case "kill":
+    await kill();
+    break;
+  case "daemon":
+    startDaemon();
+    break;
+  case "hook":
+    await runHook(arg);
+    process.exit(0);
+    break;
+  default:
+    console.log("Usage: agent-idle <setup [claude] [codex] | status | remove | kill>");
+    process.exit(command ? 1 : 0);
+}