ax-agents 0.0.1-alpha.1 → 0.0.1-alpha.10

package/ax.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
-// ax.js - CLI for interacting with AI agents (Codex, Claude) via tmux
+// ax - CLI for interacting with AI agents (Codex, Claude) via `tmux`.
+// Usage: ax --help
 //
 // Exit codes:
 //   0 - success / ready
@@ -8,17 +9,34 @@
 //   2 - rate limited
 //   3 - awaiting confirmation
 //   4 - thinking
-//
-// Usage: ./ax.js --help
-//        ./axcodex.js --help  (symlink)
-//        ./axclaude.js --help (symlink)
 
 import { execSync, spawnSync, spawn } from "node:child_process";
-import { fstatSync, statSync, readFileSync, readdirSync, existsSync, appendFileSync, mkdirSync, writeFileSync, renameSync, realpathSync, watch } from "node:fs";
-import { randomUUID } from "node:crypto";
+import {
+  fstatSync,
+  statSync,
+  readFileSync,
+  readdirSync,
+  existsSync,
+  appendFileSync,
+  mkdirSync,
+  writeFileSync,
+  renameSync,
+  realpathSync,
+  watch,
+  openSync,
+  readSync,
+  closeSync,
+} from "node:fs";
+import { randomUUID, createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import os from "node:os";
+import { parseArgs } from "node:util";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageJson = JSON.parse(readFileSync(path.join(__dirname, "package.json"), "utf-8"));
+const VERSION = packageJson.version;
 
 /**
  * @typedef {'claude' | 'codex'} ToolName
@@ -27,12 +45,12 @@ import os from "node:os";
 /**
  * @typedef {Object} ParsedSession
  * @property {string} tool
- * @property {string} [daemonName]
+ * @property {string} [archangelName]
  * @property {string} [uuid]
  */
 
 /**
- * @typedef {Object} DaemonConfig
+ * @typedef {Object} ArchangelConfig
  * @property {string} name
  * @property {ToolName} tool
  * @property {string[]} watch
@@ -105,8 +123,9 @@ import os from "node:os";
  */
 
 /**
+ * @typedef {{matcher: string, hooks: Array<{type: string, command: string, timeout?: number}>}} ClaudeHookEntry
  * @typedef {Object} ClaudeSettings
- * @property {{UserPromptSubmit?: Array<{matcher: string, hooks: Array<{type: string, command: string, timeout?: number}>}>}} [hooks]
+ * @property {{UserPromptSubmit?: ClaudeHookEntry[], PostToolUse?: ClaudeHookEntry[], Stop?: ClaudeHookEntry[], [key: string]: ClaudeHookEntry[] | undefined}} [hooks]
  */
 
 const DEBUG = process.env.AX_DEBUG === "1";
@@ -216,7 +235,9 @@ function tmuxKill(session) {
  */
 function tmuxNewSession(session, command) {
   // Use spawnSync to avoid command injection via session/command
-  const result = spawnSync("tmux", ["new-session", "-d", "-s", session, command], { encoding: "utf-8" });
+  const result = spawnSync("tmux", ["new-session", "-d", "-s", session, command], {
+    encoding: "utf-8",
+  });
   if (result.status !== 0) throw new Error(result.stderr || "tmux new-session failed");
 }
 
@@ -225,7 +246,9 @@ function tmuxNewSession(session, command) {
  */
 function tmuxCurrentSession() {
   if (!process.env.TMUX) return null;
-  const result = spawnSync("tmux", ["display-message", "-p", "#S"], { encoding: "utf-8" });
+  const result = spawnSync("tmux", ["display-message", "-p", "#S"], {
+    encoding: "utf-8",
+  });
   if (result.status !== 0) return null;
   return result.stdout.trim();
 }
@@ -237,9 +260,13 @@ function tmuxCurrentSession() {
  */
 function isYoloSession(session) {
   try {
-    const result = spawnSync("tmux", ["display-message", "-t", session, "-p", "#{pane_start_command}"], {
-      encoding: "utf-8",
-    });
+    const result = spawnSync(
+      "tmux",
+      ["display-message", "-t", session, "-p", "#{pane_start_command}"],
+      {
+        encoding: "utf-8",
+      },
+    );
     if (result.status !== 0) return false;
     const cmd = result.stdout.trim();
     return cmd.includes("--dangerously-");
@@ -259,9 +286,15 @@ const POLL_MS = parseInt(process.env.AX_POLL_MS || "200", 10);
 const DEFAULT_TIMEOUT_MS = parseInt(process.env.AX_TIMEOUT_MS || "120000", 10);
 const REVIEW_TIMEOUT_MS = parseInt(process.env.AX_REVIEW_TIMEOUT_MS || "900000", 10); // 15 minutes
 const STARTUP_TIMEOUT_MS = parseInt(process.env.AX_STARTUP_TIMEOUT_MS || "30000", 10);
-const DAEMON_STARTUP_TIMEOUT_MS = parseInt(process.env.AX_DAEMON_STARTUP_TIMEOUT_MS || "60000", 10);
-const DAEMON_RESPONSE_TIMEOUT_MS = parseInt(process.env.AX_DAEMON_RESPONSE_TIMEOUT_MS || "300000", 10); // 5 minutes
-const DAEMON_HEALTH_CHECK_MS = parseInt(process.env.AX_DAEMON_HEALTH_CHECK_MS || "30000", 10);
+const ARCHANGEL_STARTUP_TIMEOUT_MS = parseInt(
+  process.env.AX_ARCHANGEL_STARTUP_TIMEOUT_MS || "60000",
+  10,
+);
+const ARCHANGEL_RESPONSE_TIMEOUT_MS = parseInt(
+  process.env.AX_ARCHANGEL_RESPONSE_TIMEOUT_MS || "300000",
+  10,
+); // 5 minutes
+const ARCHANGEL_HEALTH_CHECK_MS = parseInt(process.env.AX_ARCHANGEL_HEALTH_CHECK_MS || "30000", 10);
 const STABLE_MS = parseInt(process.env.AX_STABLE_MS || "1000", 10);
 const APPROVE_DELAY_MS = parseInt(process.env.AX_APPROVE_DELAY_MS || "100", 10);
 const MAILBOX_MAX_AGE_MS = parseInt(process.env.AX_MAILBOX_MAX_AGE_MS || "3600000", 10); // 1 hour
@@ -269,9 +302,35 @@ const CLAUDE_CONFIG_DIR = process.env.AX_CLAUDE_CONFIG_DIR || path.join(os.homed
 const CODEX_CONFIG_DIR = process.env.AX_CODEX_CONFIG_DIR || path.join(os.homedir(), ".codex");
 const TRUNCATE_USER_LEN = 500;
 const TRUNCATE_THINKING_LEN = 300;
-const DAEMON_GIT_CONTEXT_HOURS = 4;
-const DAEMON_GIT_CONTEXT_MAX_LINES = 200;
-const DAEMON_PARENT_CONTEXT_ENTRIES = 10;
+const ARCHANGEL_GIT_CONTEXT_HOURS = 4;
+const ARCHANGEL_GIT_CONTEXT_MAX_LINES = 200;
+const ARCHANGEL_PARENT_CONTEXT_ENTRIES = 10;
+const ARCHANGEL_PREAMBLE = `## Guidelines
+
+- If you have nothing to report, you MUST respond with ONLY "EMPTY_RESPONSE".
+- Investigate before speaking. If uncertain, read more code and trace the logic until you're confident.
+- Explain WHY something is an issue, not just that it is.
+- Focus on your area of expertise.
+- Calibrate to the task or plan. Don't suggest refactors during a bug fix.
+- Be clear. Brief is fine, but never sacrifice clarity.
+- For critical issues, request for them to be added to the todo list.
+- Don't repeat observations you've already made unless you have more to say or better clarity.
+- Make judgment calls - don't ask questions.`;
+
+/**
+ * @param {string} session
+ * @param {(screen: string) => boolean} predicate
+ * @param {number} [timeoutMs]
+ * @returns {Promise<string>}
+ */
+class TimeoutError extends Error {
+  /** @param {string} [session] */
+  constructor(session) {
+    super("timeout");
+    this.name = "TimeoutError";
+    this.session = session;
+  }
+}
 
 /**
  * @param {string} session
@@ -286,7 +345,7 @@ async function waitFor(session, predicate, timeoutMs = STARTUP_TIMEOUT_MS) {
     if (predicate(screen)) return screen;
     await sleep(POLL_MS);
   }
-  throw new Error("timeout");
+  throw new TimeoutError(session);
 }
 
 // =============================================================================
@@ -299,7 +358,9 @@ async function waitFor(session, predicate, timeoutMs = STARTUP_TIMEOUT_MS) {
 function findCallerPid() {
   let pid = process.ppid;
   while (pid > 1) {
-    const result = spawnSync("ps", ["-p", pid.toString(), "-o", "ppid=,comm="], { encoding: "utf-8" });
+    const result = spawnSync("ps", ["-p", pid.toString(), "-o", "ppid=,comm="], {
+      encoding: "utf-8",
+    });
     if (result.status !== 0) break;
     const parts = result.stdout.trim().split(/\s+/);
     const ppid = parseInt(parts[0], 10);
@@ -312,6 +373,38 @@ function findCallerPid() {
   return null;
 }
 
+/**
+ * Find orphaned claude/codex processes (PPID=1, reparented to init/launchd)
+ * @returns {{pid: string, command: string}[]}
+ */
+function findOrphanedProcesses() {
+  const result = spawnSync("ps", ["-eo", "pid=,ppid=,args="], { encoding: "utf-8" });
+
+  if (result.status !== 0 || !result.stdout.trim()) {
+    return [];
+  }
+
+  const orphans = [];
+  for (const line of result.stdout.trim().split("\n")) {
+    // Parse: "  PID  PPID  command args..."
+    const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.+)$/);
+    if (!match) continue;
+
+    const [, pid, ppid, args] = match;
+
+    // Must have PPID=1 (orphaned/reparented to init)
+    if (ppid !== "1") continue;
+
+    // Command must START with claude or codex (excludes tmux which also has PPID=1)
+    const cmd = args.split(/\s+/)[0];
+    if (cmd !== "claude" && cmd !== "codex") continue;
+
+    orphans.push({ pid, command: args.slice(0, 60) });
+  }
+
+  return orphans;
+}
+
 // =============================================================================
 // Helpers - stdin
 // =============================================================================
@@ -340,6 +433,86 @@ async function readStdin() {
 }
 
 // =============================================================================
+// =============================================================================
+// Helpers - CLI argument parsing
+// =============================================================================
+
+/**
+ * Parse CLI arguments using Node.js built-in parseArgs.
+ * @param {string[]} args - Command line arguments (without node and script path)
+ * @returns {{ flags: ParsedFlags, positionals: string[] }}
+ *
+ * @typedef {Object} ParsedFlags
+ * @property {boolean} wait
+ * @property {boolean} noWait
+ * @property {boolean} yolo
+ * @property {boolean} fresh
+ * @property {boolean} reasoning
+ * @property {boolean} follow
+ * @property {boolean} all
+ * @property {boolean} orphans
+ * @property {boolean} force
+ * @property {boolean} version
+ * @property {boolean} help
+ * @property {string} [tool]
+ * @property {string} [session]
+ * @property {number} [timeout]
+ * @property {number} [tail]
+ * @property {number} [limit]
+ * @property {string} [branch]
+ */
+function parseCliArgs(args) {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      // Boolean flags
+      wait: { type: "boolean", default: false },
+      "no-wait": { type: "boolean", default: false },
+      yolo: { type: "boolean", default: false },
+      fresh: { type: "boolean", default: false },
+      reasoning: { type: "boolean", default: false },
+      follow: { type: "boolean", short: "f", default: false },
+      all: { type: "boolean", default: false },
+      orphans: { type: "boolean", default: false },
+      force: { type: "boolean", default: false },
+      version: { type: "boolean", short: "V", default: false },
+      help: { type: "boolean", short: "h", default: false },
+      // Value flags
+      tool: { type: "string" },
+      session: { type: "string" },
+      timeout: { type: "string" },
+      tail: { type: "string" },
+      limit: { type: "string" },
+      branch: { type: "string" },
+    },
+    allowPositionals: true,
+    strict: false, // Don't error on unknown flags
+  });
+
+  return {
+    flags: {
+      wait: Boolean(values.wait),
+      noWait: Boolean(values["no-wait"]),
+      yolo: Boolean(values.yolo),
+      fresh: Boolean(values.fresh),
+      reasoning: Boolean(values.reasoning),
+      follow: Boolean(values.follow),
+      all: Boolean(values.all),
+      orphans: Boolean(values.orphans),
+      force: Boolean(values.force),
+      version: Boolean(values.version),
+      help: Boolean(values.help),
+      tool: /** @type {string | undefined} */ (values.tool),
+      session: /** @type {string | undefined} */ (values.session),
+      timeout: values.timeout !== undefined ? Number(values.timeout) : undefined,
+      tail: values.tail !== undefined ? Number(values.tail) : undefined,
+      limit: values.limit !== undefined ? Number(values.limit) : undefined,
+      branch: /** @type {string | undefined} */ (values.branch),
+    },
+    positionals,
+  };
+}
+
 // Helpers - session tracking
 // =============================================================================
 
@@ -354,14 +527,18 @@ function parseSessionName(session) {
   const tool = match[1].toLowerCase();
   const rest = match[2];
 
-  // Daemon: {tool}-daemon-{name}-{uuid}
-  const daemonMatch = rest.match(/^daemon-(.+)-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i);
-  if (daemonMatch) {
-    return { tool, daemonName: daemonMatch[1], uuid: daemonMatch[2] };
+  // Archangel: {tool}-archangel-{name}-{uuid}
+  const archangelMatch = rest.match(
+    /^archangel-(.+)-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i,
+  );
+  if (archangelMatch) {
+    return { tool, archangelName: archangelMatch[1], uuid: archangelMatch[2] };
   }
 
   // Partner: {tool}-partner-{uuid}
-  const partnerMatch = rest.match(/^partner-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i);
+  const partnerMatch = rest.match(
+    /^partner-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i,
+  );
   if (partnerMatch) {
     return { tool, uuid: partnerMatch[1] };
   }
@@ -378,6 +555,16 @@ function generateSessionName(tool) {
   return `${tool}-partner-${randomUUID()}`;
 }
 
+/**
+ * Quick hash for change detection (not cryptographic).
+ * @param {string | null | undefined} str
+ * @returns {string | null}
+ */
+function quickHash(str) {
+  if (!str) return null;
+  return createHash("md5").update(str).digest("hex").slice(0, 8);
+}
+
 /**
  * @param {string} cwd
  * @returns {string}
@@ -394,9 +581,13 @@ function getClaudeProjectPath(cwd) {
  */
 function getTmuxSessionCwd(sessionName) {
   try {
-    const result = spawnSync("tmux", ["display-message", "-t", sessionName, "-p", "#{pane_current_path}"], {
-      encoding: "utf-8",
-    });
+    const result = spawnSync(
+      "tmux",
+      ["display-message", "-t", sessionName, "-p", "#{pane_current_path}"],
+      {
+        encoding: "utf-8",
+      },
+    );
     if (result.status === 0) return result.stdout.trim();
   } catch (err) {
     debugError("getTmuxSessionCwd", err);
@@ -420,7 +611,9 @@ function findClaudeLogPath(sessionId, sessionName) {
   if (existsSync(indexPath)) {
     try {
       const index = JSON.parse(readFileSync(indexPath, "utf-8"));
-      const entry = index.entries?.find(/** @param {{sessionId: string, fullPath?: string}} e */ (e) => e.sessionId === sessionId);
+      const entry = index.entries?.find(
+        /** @param {{sessionId: string, fullPath?: string}} e */ (e) => e.sessionId === sessionId,
+      );
       if (entry?.fullPath) return entry.fullPath;
     } catch (err) {
       debugError("findClaudeLogPath", err);
@@ -442,9 +635,13 @@ function findCodexLogPath(sessionName) {
   // For Codex, we need to match by timing since we can't control the session ID
   // Get tmux session creation time
   try {
-    const result = spawnSync("tmux", ["display-message", "-t", sessionName, "-p", "#{session_created}"], {
-      encoding: "utf-8",
-    });
+    const result = spawnSync(
+      "tmux",
+      ["display-message", "-t", sessionName, "-p", "#{session_created}"],
+      {
+        encoding: "utf-8",
+      },
+    );
     if (result.status !== 0) return null;
     const createdTs = parseInt(result.stdout.trim(), 10) * 1000; // tmux gives seconds, we need ms
     if (isNaN(createdTs)) return null;
@@ -478,7 +675,11 @@ function findCodexLogPath(sessionName) {
       // Log file should be created shortly after session start
       // Allow small negative diff (-2s) for clock skew, up to 60s for slow starts
       if (diff >= -2000 && diff < 60000) {
-        candidates.push({ file, diff: Math.abs(diff), path: path.join(dayDir, file) });
+        candidates.push({
+          file,
+          diff: Math.abs(diff),
+          path: path.join(dayDir, file),
+        });
       }
     }
 
@@ -491,6 +692,92 @@ function findCodexLogPath(sessionName) {
   }
 }
 
+/**
+ * @typedef {Object} SessionMeta
+ * @property {string | null} slug - Plan identifier (if plan is active)
+ * @property {Array<{content: string, status: string, id?: string}> | null} todos - Current todos
+ * @property {string | null} permissionMode - "default", "acceptEdits", "plan"
+ * @property {string | null} gitBranch - Current git branch
+ * @property {string | null} cwd - Working directory
+ */
+
+/**
+ * Get metadata from a Claude session's JSONL file.
+ * Returns null for Codex sessions (different format, no equivalent metadata).
+ * @param {string} sessionName - The tmux session name
+ * @returns {SessionMeta | null}
+ */
+function getSessionMeta(sessionName) {
+  const parsed = parseSessionName(sessionName);
+  if (!parsed) return null;
+
+  // Only Claude sessions have this metadata
+  if (parsed.tool !== "claude") return null;
+  if (!parsed.uuid) return null;
+
+  const logPath = findClaudeLogPath(parsed.uuid, sessionName);
+  if (!logPath || !existsSync(logPath)) return null;
+
+  try {
+    const content = readFileSync(logPath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+
+    // Read from end to find most recent entry with metadata
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        // User entries typically have the metadata fields
+        if (entry.type === "user" || entry.slug || entry.gitBranch) {
+          return {
+            slug: entry.slug || null,
+            todos: entry.todos || null,
+            permissionMode: entry.permissionMode || null,
+            gitBranch: entry.gitBranch || null,
+            cwd: entry.cwd || null,
+          };
+        }
+      } catch {
+        // Skip malformed lines
+      }
+    }
+    return null;
+  } catch (err) {
+    debugError("getSessionMeta", err);
+    return null;
+  }
+}
+
+/**
+ * Read a plan file by its slug.
+ * @param {string} slug - The plan slug (e.g., "curious-roaming-pascal")
+ * @returns {string | null} The plan content or null if not found
+ */
+function readPlanFile(slug) {
+  const planPath = path.join(CLAUDE_CONFIG_DIR, "plans", `${slug}.md`);
+  try {
+    if (existsSync(planPath)) {
+      return readFileSync(planPath, "utf-8");
+    }
+  } catch (err) {
+    debugError("readPlanFile", err);
+  }
+  return null;
+}
+
+/**
+ * Format todos for display in a prompt.
+ * @param {Array<{content: string, status: string, id?: string}>} todos
+ * @returns {string}
+ */
+function formatTodos(todos) {
+  if (!todos || todos.length === 0) return "";
+  return todos
+    .map((t) => {
+      const status = t.status === "completed" ? "[x]" : t.status === "in_progress" ? "[>]" : "[ ]";
+      return `${status} ${t.content || "(no content)"}`;
+    })
+    .join("\n");
+}
 
 /**
  * Extract assistant text responses from a JSONL log file.
@@ -537,6 +824,130 @@ function getAssistantText(logPath, index = 0) {
   }
 }
 
+/**
+ * Read new complete JSON lines from a log file since the given offset.
+ * @param {string | null} logPath
+ * @param {number} fromOffset
+ * @returns {{ entries: object[], newOffset: number }}
+ */
+function tailJsonl(logPath, fromOffset) {
+  if (!logPath || !existsSync(logPath)) {
+    return { entries: [], newOffset: fromOffset };
+  }
+
+  const stats = statSync(logPath);
+  if (stats.size <= fromOffset) {
+    return { entries: [], newOffset: fromOffset };
+  }
+
+  const fd = openSync(logPath, "r");
+  const buffer = Buffer.alloc(stats.size - fromOffset);
+  readSync(fd, buffer, 0, buffer.length, fromOffset);
+  closeSync(fd);
+
+  const text = buffer.toString("utf-8");
+  const lines = text.split("\n");
+
+  // Last line may be incomplete - don't parse it yet
+  const complete = lines.slice(0, -1).filter(Boolean);
+  const incomplete = lines[lines.length - 1];
+
+  const entries = [];
+  for (const line of complete) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  // Offset advances by complete lines only
+  const newOffset = fromOffset + text.length - incomplete.length;
+  return { entries, newOffset };
+}
+
+/**
+ * @typedef {{command?: string, file_path?: string, path?: string, pattern?: string}} ToolInput
+ */
+
+/**
+ * Format a JSONL entry for streaming display.
+ * @param {{type?: string, message?: {content?: Array<{type?: string, text?: string, name?: string, input?: ToolInput, tool?: string, arguments?: ToolInput}>}}} entry
+ * @returns {string | null}
+ */
+function formatEntry(entry) {
+  // Skip tool_result entries (they can be very verbose)
+  if (entry.type === "tool_result") return null;
+
+  // Only process assistant entries
+  if (entry.type !== "assistant") return null;
+
+  const parts = entry.message?.content || [];
+  const output = [];
+
+  for (const part of parts) {
+    if (part.type === "text" && part.text) {
+      output.push(part.text);
+    } else if (part.type === "tool_use" || part.type === "tool_call") {
+      const name = part.name || part.tool || "tool";
+      const input = part.input || part.arguments || {};
+      let summary;
+      if (name === "Bash" && input.command) {
+        summary = input.command.slice(0, 50);
+      } else {
+        const target = input.file_path || input.path || input.pattern || "";
+        summary = target.split("/").pop() || target.slice(0, 30);
+      }
+      output.push(`> ${name}(${summary})`);
+    }
+    // Skip thinking blocks - internal reasoning
+  }
+
+  return output.length > 0 ? output.join("\n") : null;
+}
+
+/**
+ * Extract pending tool from confirmation screen.
+ * @param {string} screen
+ * @returns {string | null}
+ */
+function extractPendingToolFromScreen(screen) {
+  const lines = screen.split("\n");
+
+  // Check recent lines for tool confirmation patterns
+  for (let i = lines.length - 1; i >= Math.max(0, lines.length - 15); i--) {
+    const line = lines[i];
+    // Match tool confirmation patterns like "Bash: command" or "Write: /path/file"
+    const match = line.match(
+      /^\s*(Bash|Write|Edit|Read|Glob|Grep|Task|WebFetch|WebSearch|NotebookEdit|Skill|TodoWrite|TodoRead):\s*(.{1,40})/,
+    );
+    if (match) {
+      return `${match[1]}: ${match[2].trim()}`;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Format confirmation output with helpful commands
+ * @param {string} screen
+ * @param {Agent} _agent
+ * @returns {string}
+ */
+function formatConfirmationOutput(screen, _agent) {
+  const pendingTool = extractPendingToolFromScreen(screen);
+  const cli = path.basename(process.argv[1], ".js");
+
+  let output = pendingTool || "Confirmation required";
+  output += "\n\ne.g.";
+  output += `\n  ${cli} approve        # for y/n prompts`;
+  output += `\n  ${cli} reject`;
+  output += `\n  ${cli} select N       # for numbered menus`;
+
+  return output;
+}
+
 /**
  * @returns {string[]}
  */
@@ -562,15 +973,15 @@ function resolveSessionName(partial) {
   // Exact match
   if (agentSessions.includes(partial)) return partial;
 
-  // Daemon name match (e.g., "reviewer" matches "claude-daemon-reviewer-uuid")
-  const daemonMatches = agentSessions.filter((s) => {
+  // Archangel name match (e.g., "reviewer" matches "claude-archangel-reviewer-uuid")
+  const archangelMatches = agentSessions.filter((s) => {
     const parsed = parseSessionName(s);
-    return parsed?.daemonName === partial;
+    return parsed?.archangelName === partial;
   });
-  if (daemonMatches.length === 1) return daemonMatches[0];
-  if (daemonMatches.length > 1) {
-    console.log("ERROR: ambiguous daemon name. Matches:");
-    for (const m of daemonMatches) console.log(`  ${m}`);
+  if (archangelMatches.length === 1) return archangelMatches[0];
+  if (archangelMatches.length > 1) {
+    console.log("ERROR: ambiguous archangel name. Matches:");
+    for (const m of archangelMatches) console.log(`  ${m}`);
     process.exit(1);
   }
 
@@ -599,25 +1010,25 @@ function resolveSessionName(partial) {
 }
 
 // =============================================================================
-// Helpers - daemon agents
+// Helpers - archangels
 // =============================================================================
 
 /**
- * @returns {DaemonConfig[]}
+ * @returns {ArchangelConfig[]}
  */
 function loadAgentConfigs() {
   const agentsDir = AGENTS_DIR;
   if (!existsSync(agentsDir)) return [];
 
   const files = readdirSync(agentsDir).filter((f) => f.endsWith(".md"));
-  /** @type {DaemonConfig[]} */
+  /** @type {ArchangelConfig[]} */
   const configs = [];
 
   for (const file of files) {
     try {
       const content = readFileSync(path.join(agentsDir, file), "utf-8");
       const config = parseAgentConfig(file, content);
-      if (config && 'error' in config) {
+      if (config && "error" in config) {
         console.error(`ERROR: ${file}: ${config.error}`);
         continue;
       }
@@ -633,7 +1044,7 @@ function loadAgentConfigs() {
 /**
  * @param {string} filename
  * @param {string} content
- * @returns {DaemonConfig | {error: string} | null}
+ * @returns {ArchangelConfig | {error: string} | null}
  */
 function parseAgentConfig(filename, content) {
   const name = filename.replace(/\.md$/, "");
@@ -648,7 +1059,9 @@ function parseAgentConfig(filename, content) {
       return { error: `Missing frontmatter. File must start with '---'` };
     }
     if (!normalized.includes("\n---\n")) {
-      return { error: `Frontmatter not closed. Add '---' on its own line after the YAML block` };
+      return {
+        error: `Frontmatter not closed. Add '---' on its own line after the YAML block`,
+      };
     }
     return { error: `Invalid frontmatter format` };
   }
@@ -669,9 +1082,13 @@ function parseAgentConfig(filename, content) {
     const fieldName = line.trim().match(/^(\w+):/)?.[1];
     if (fieldName && !knownFields.includes(fieldName)) {
       // Suggest closest match
-      const suggestions = knownFields.filter((f) => f[0] === fieldName[0] || fieldName.includes(f.slice(0, 3)));
+      const suggestions = knownFields.filter(
+        (f) => f[0] === fieldName[0] || fieldName.includes(f.slice(0, 3)),
+      );
       const hint = suggestions.length > 0 ? ` Did you mean '${suggestions[0]}'?` : "";
-      return { error: `Unknown field '${fieldName}'.${hint} Valid fields: ${knownFields.join(", ")}` };
+      return {
+        error: `Unknown field '${fieldName}'.${hint} Valid fields: ${knownFields.join(", ")}`,
+      };
     }
   }
 
@@ -689,7 +1106,9 @@ function parseAgentConfig(filename, content) {
     const rawValue = intervalMatch[1].trim();
     const parsed = parseInt(rawValue, 10);
     if (isNaN(parsed)) {
-      return { error: `Invalid interval '${rawValue}'. Must be a number (seconds)` };
+      return {
+        error: `Invalid interval '${rawValue}'. Must be a number (seconds)`,
+      };
     }
     interval = Math.max(10, Math.min(3600, parsed)); // Clamp to 10s - 1hr
   }
@@ -701,16 +1120,22 @@ function parseAgentConfig(filename, content) {
     const rawWatch = watchLine[1].trim();
     // Must be array format
     if (!rawWatch.startsWith("[") || !rawWatch.endsWith("]")) {
-      return { error: `Invalid watch format. Must be an array: watch: ["src/**/*.ts"]` };
+      return {
+        error: `Invalid watch format. Must be an array: watch: ["src/**/*.ts"]`,
+      };
     }
     const inner = rawWatch.slice(1, -1).trim();
     if (!inner) {
-      return { error: `Empty watch array. Add at least one pattern: watch: ["**/*"]` };
+      return {
+        error: `Empty watch array. Add at least one pattern: watch: ["**/*"]`,
+      };
     }
     watchPatterns = inner.split(",").map((p) => p.trim().replace(/^["']|["']$/g, ""));
     // Validate patterns aren't empty
     if (watchPatterns.some((p) => !p)) {
-      return { error: `Invalid watch pattern. Check for trailing commas or empty values` };
+      return {
+        error: `Invalid watch pattern. Check for trailing commas or empty values`,
+      };
     }
   }
 
@@ -718,11 +1143,11 @@ function parseAgentConfig(filename, content) {
 }
 
 /**
- * @param {DaemonConfig} config
+ * @param {ArchangelConfig} config
  * @returns {string}
  */
-function getDaemonSessionPattern(config) {
-  return `${config.tool}-daemon-${config.name}`;
+function getArchangelSessionPattern(config) {
+  return `${config.tool}-archangel-${config.name}`;
 }
 
 // =============================================================================
@@ -826,7 +1251,9 @@ function gcMailbox(maxAgeHours = 24) {
 /** @returns {string} */
 function getCurrentBranch() {
   try {
-    return execSync("git branch --show-current 2>/dev/null", { encoding: "utf-8" }).trim();
+    return execSync("git branch --show-current 2>/dev/null", {
+      encoding: "utf-8",
+    }).trim();
   } catch {
     return "unknown";
   }
@@ -835,7 +1262,9 @@ function getCurrentBranch() {
 /** @returns {string} */
 function getCurrentCommit() {
   try {
-    return execSync("git rev-parse --short HEAD 2>/dev/null", { encoding: "utf-8" }).trim();
+    return execSync("git rev-parse --short HEAD 2>/dev/null", {
+      encoding: "utf-8",
+    }).trim();
   } catch {
     return "unknown";
   }
@@ -859,7 +1288,9 @@ function getMainBranch() {
 /** @returns {string} */
 function getStagedDiff() {
   try {
-    return execSync("git diff --cached 2>/dev/null", { encoding: "utf-8" }).trim();
+    return execSync("git diff --cached 2>/dev/null", {
+      encoding: "utf-8",
+    }).trim();
   } catch {
     return "";
   }
@@ -884,20 +1315,18 @@ function getRecentCommitsDiff(hoursAgo = 4) {
     const since = `--since="${hoursAgo} hours ago"`;
 
     // Get list of commits in range
-    const commits = execSync(
-      `git log ${mainBranch}..HEAD ${since} --oneline 2>/dev/null`,
-      { encoding: "utf-8" }
-    ).trim();
+    const commits = execSync(`git log ${mainBranch}..HEAD ${since} --oneline 2>/dev/null`, {
+      encoding: "utf-8",
+    }).trim();
 
     if (!commits) return "";
 
     // Get diff for those commits
     const firstCommit = commits.split("\n").filter(Boolean).pop()?.split(" ")[0];
     if (!firstCommit) return "";
-    return execSync(
-      `git diff ${firstCommit}^..HEAD 2>/dev/null`,
-      { encoding: "utf-8" }
-    ).trim();
+    return execSync(`git diff ${firstCommit}^..HEAD 2>/dev/null`, {
+      encoding: "utf-8",
+    }).trim();
   } catch {
     return "";
   }
@@ -912,7 +1341,10 @@ function truncateDiff(diff, maxLines = 200) {
   if (!diff) return "";
   const lines = diff.split("\n");
   if (lines.length <= maxLines) return diff;
-  return lines.slice(0, maxLines).join("\n") + `\n\n... (truncated, ${lines.length - maxLines} more lines)`;
+  return (
+    lines.slice(0, maxLines).join("\n") +
+    `\n\n... (truncated, ${lines.length - maxLines} more lines)`
+  );
 }
 
 /**
@@ -945,9 +1377,9 @@ function buildGitContext(hoursAgo = 4, maxLinesPerSection = 200) {
 // Helpers - parent session context
 // =============================================================================
 
-// Environment variables used to pass parent session info to daemons
-const AX_DAEMON_PARENT_SESSION_ENV = "AX_DAEMON_PARENT_SESSION";
-const AX_DAEMON_PARENT_UUID_ENV = "AX_DAEMON_PARENT_UUID";
+// Environment variables used to pass parent session info to archangels
+const AX_ARCHANGEL_PARENT_SESSION_ENV = "AX_ARCHANGEL_PARENT_SESSION";
+const AX_ARCHANGEL_PARENT_UUID_ENV = "AX_ARCHANGEL_PARENT_UUID";
 
 /**
  * @returns {ParentSession | null}
@@ -957,7 +1389,7 @@ function findCurrentClaudeSession() {
   const current = tmuxCurrentSession();
   if (current) {
     const parsed = parseSessionName(current);
-    if (parsed?.tool === "claude" && !parsed.daemonName && parsed.uuid) {
+    if (parsed?.tool === "claude" && !parsed.archangelName && parsed.uuid) {
       return { session: current, uuid: parsed.uuid };
     }
   }
@@ -974,7 +1406,7 @@ function findCurrentClaudeSession() {
   for (const session of sessions) {
     const parsed = parseSessionName(session);
     if (!parsed || parsed.tool !== "claude") continue;
-    if (parsed.daemonName) continue;
+    if (parsed.archangelName) continue;
     if (!parsed.uuid) continue;
 
     const sessionCwd = getTmuxSessionCwd(session);
@@ -997,18 +1429,23 @@ function findCurrentClaudeSession() {
   const claudeProjectDir = path.join(CLAUDE_CONFIG_DIR, "projects", projectPath);
   if (existsSync(claudeProjectDir)) {
     try {
-      const files = readdirSync(claudeProjectDir).filter(f => f.endsWith(".jsonl"));
+      const files = readdirSync(claudeProjectDir).filter((f) => f.endsWith(".jsonl"));
       for (const file of files) {
         const uuid = file.replace(".jsonl", "");
         // Skip if we already have this from tmux sessions
-        if (candidates.some(c => c.uuid === uuid)) continue;
+        if (candidates.some((c) => c.uuid === uuid)) continue;
 
         const logPath = path.join(claudeProjectDir, file);
         try {
           const stat = statSync(logPath);
           // Only consider logs modified in the last hour (active sessions)
           if (Date.now() - stat.mtimeMs < MAILBOX_MAX_AGE_MS) {
-            candidates.push({ session: null, uuid, mtime: stat.mtimeMs, logPath });
+            candidates.push({
+              session: null,
+              uuid,
+              mtime: stat.mtimeMs,
+              logPath,
+            });
           }
         } catch (err) {
           debugError("findCurrentClaudeSession:logStat", err);
@@ -1030,15 +1467,15 @@ function findCurrentClaudeSession() {
  * @returns {ParentSession | null}
  */
 function findParentSession() {
-  // First check if parent session was passed via environment (for daemons)
-  const envUuid = process.env[AX_DAEMON_PARENT_UUID_ENV];
+  // First check if parent session was passed via environment (for archangels)
+  const envUuid = process.env[AX_ARCHANGEL_PARENT_UUID_ENV];
   if (envUuid) {
     // Session name is optional (may be null for non-tmux sessions)
-    const envSession = process.env[AX_DAEMON_PARENT_SESSION_ENV] || null;
+    const envSession = process.env[AX_ARCHANGEL_PARENT_SESSION_ENV] || null;
     return { session: envSession, uuid: envUuid };
   }
 
-  // Fallback to detecting current session (shouldn't be needed for daemons)
+  // Fallback to detecting current session (shouldn't be needed for archangels)
   return findCurrentClaudeSession();
 }
 
@@ -1080,7 +1517,9 @@ function getParentSessionContext(maxEntries = 20) {
           if (typeof c === "string" && c.length > 10) {
             entries.push({ type: "user", text: c });
           } else if (Array.isArray(c)) {
-            const text = c.find(/** @param {{type: string, text?: string}} x */ (x) => x.type === "text")?.text;
+            const text = c.find(
+              /** @param {{type: string, text?: string}} x */ (x) => x.type === "text",
+            )?.text;
             if (text && text.length > 10) {
               entries.push({ type: "user", text });
             }
@@ -1088,7 +1527,10 @@ function getParentSessionContext(maxEntries = 20) {
         } else if (entry.type === "assistant") {
           /** @type {{type: string, text?: string}[]} */
           const parts = entry.message?.content || [];
-          const text = parts.filter((p) => p.type === "text").map((p) => p.text || "").join("\n");
+          const text = parts
+            .filter((p) => p.type === "text")
+            .map((p) => p.text || "")
+            .join("\n");
           // Only include assistant responses with meaningful text
           if (text && text.length > 20) {
             entries.push({ type: "assistant", text });
@@ -1100,7 +1542,7 @@ function getParentSessionContext(maxEntries = 20) {
     }
 
     // Format recent conversation
-    const formatted = entries.slice(-maxEntries).map(e => {
+    const formatted = entries.slice(-maxEntries).map((e) => {
       const preview = e.text.slice(0, 500).replace(/\n/g, " ");
       return `**${e.type === "user" ? "User" : "Assistant"}**: ${preview}`;
     });
@@ -1143,10 +1585,16 @@ function extractFileEditContext(logPath, filePath) {
 
   // Parse all entries
   /** @type {any[]} */
-  const entries = lines.map((line, idx) => {
-    try { return { idx, ...JSON.parse(line) }; }
-    catch (err) { debugError("extractFileEditContext:parse", err); return null; }
-  }).filter(Boolean);
+  const entries = lines
+    .map((line, idx) => {
+      try {
+        return { idx, ...JSON.parse(line) };
+      } catch (err) {
+        debugError("extractFileEditContext:parse", err);
+        return null;
+      }
+    })
+    .filter(Boolean);
 
   // Find Write/Edit tool calls for this file (scan backwards, want most recent)
   /** @type {any} */
@@ -1159,9 +1607,10 @@ function extractFileEditContext(logPath, filePath) {
 
     /** @type {any[]} */
     const msgContent = entry.message?.content || [];
-    const toolCalls = msgContent.filter((/** @type {any} */ c) =>
-      (c.type === "tool_use" || c.type === "tool_call") &&
-      (c.name === "Write" || c.name === "Edit")
+    const toolCalls = msgContent.filter(
+      (/** @type {any} */ c) =>
+        (c.type === "tool_use" || c.type === "tool_call") &&
+        (c.name === "Write" || c.name === "Edit"),
     );
 
     for (const tc of toolCalls) {
@@ -1212,8 +1661,9 @@ function extractFileEditContext(logPath, filePath) {
 
     /** @type {any[]} */
     const msgContent = entry.message?.content || [];
-    const readCalls = msgContent.filter((/** @type {any} */ c) =>
-      (c.type === "tool_use" || c.type === "tool_call") && c.name === "Read"
+    const readCalls = msgContent.filter(
+      (/** @type {any} */ c) =>
+        (c.type === "tool_use" || c.type === "tool_call") && c.name === "Read",
     );
 
     for (const rc of readCalls) {
@@ -1228,9 +1678,10 @@ function extractFileEditContext(logPath, filePath) {
     if (entry.type !== "assistant") continue;
     /** @type {any[]} */
     const msgContent = entry.message?.content || [];
-    const edits = msgContent.filter((/** @type {any} */ c) =>
-      (c.type === "tool_use" || c.type === "tool_call") &&
-      (c.name === "Write" || c.name === "Edit")
+    const edits = msgContent.filter(
+      (/** @type {any} */ c) =>
+        (c.type === "tool_use" || c.type === "tool_call") &&
+        (c.name === "Write" || c.name === "Edit"),
     );
     for (const e of edits) {
       const input = e.input || e.arguments || {};
@@ -1245,11 +1696,11 @@ function extractFileEditContext(logPath, filePath) {
     toolCall: {
       name: editEntry.toolCall.name,
       input: editEntry.toolCall.input || editEntry.toolCall.arguments,
-      id: editEntry.toolCall.id
+      id: editEntry.toolCall.id,
     },
     subsequentErrors,
     readsBefore: [...new Set(readsBefore)].slice(0, 10),
-    editSequence
+    editSequence,
   };
 }
 
@@ -1343,10 +1794,11 @@ function watchForChanges(patterns, callback) {
     }
   }
 
-  return () => { for (const w of watchers) w.close(); };
+  return () => {
+    for (const w of watchers) w.close();
+  };
 }
 
-
 // =============================================================================
 // State
 // =============================================================================
@@ -1368,7 +1820,7 @@ const State = {
  * @param {string} config.promptSymbol - Symbol indicating ready state
  * @param {string[]} [config.spinners] - Spinner characters indicating thinking
  * @param {RegExp} [config.rateLimitPattern] - Pattern for rate limit detection
- * @param {string[]} [config.thinkingPatterns] - Text patterns indicating thinking
+ * @param {(string | RegExp | ((lines: string) => boolean))[]} [config.thinkingPatterns] - Text patterns indicating thinking
  * @param {(string | ((lines: string) => boolean))[]} [config.confirmPatterns] - Patterns for confirmation dialogs
  * @param {{screen: string[], lastLines: string[]} | null} [config.updatePromptPatterns] - Patterns for update prompts
  * @returns {string} The detected state
@@ -1381,31 +1833,12 @@ function detectState(screen, config) {
   // Larger range for confirmation detection (catches dialogs that scrolled slightly)
   const recentLines = lines.slice(-15).join("\n");
 
-  // Rate limited - check full screen (rate limit messages can appear anywhere)
-  if (config.rateLimitPattern && config.rateLimitPattern.test(screen)) {
+  // Rate limited - check recent lines (not full screen to avoid matching historical output)
+  if (config.rateLimitPattern && config.rateLimitPattern.test(recentLines)) {
     return State.RATE_LIMITED;
   }
 
-  // Thinking - spinners (full screen, they're unique UI elements)
-  const spinners = config.spinners || [];
-  if (spinners.some((s) => screen.includes(s))) {
-    return State.THINKING;
-  }
-  // Thinking - text patterns (last lines)
-  const thinkingPatterns = config.thinkingPatterns || [];
-  if (thinkingPatterns.some((p) => lastLines.includes(p))) {
-    return State.THINKING;
-  }
-
-  // Update prompt
-  if (config.updatePromptPatterns) {
-    const { screen: sp, lastLines: lp } = config.updatePromptPatterns;
-    if (sp && sp.some((p) => screen.includes(p)) && lp && lp.some((p) => lastLines.includes(p))) {
-      return State.UPDATE_PROMPT;
-    }
-  }
-
-  // Confirming - check recent lines (not full screen to avoid history false positives)
+  // Confirming - check before THINKING because "Running…" in tool output matches thinking patterns
   const confirmPatterns = config.confirmPatterns || [];
   for (const pattern of confirmPatterns) {
     if (typeof pattern === "function") {
@@ -1418,13 +1851,14 @@ function detectState(screen, config) {
     }
   }
 
-  // Ready - only if prompt symbol is visible AND not followed by pasted content
-  // "[Pasted text" indicates user has pasted content and Claude is still processing
+  // Ready - check BEFORE thinking to avoid false positives from timing messages like "✻ Worked for 45s"
+  // If the prompt symbol is visible, the agent is ready regardless of spinner characters in timing messages
   if (lastLines.includes(config.promptSymbol)) {
     // Check if any line has the prompt followed by pasted content indicator
+    // "[Pasted text" indicates user has pasted content and Claude is still processing
     const linesArray = lastLines.split("\n");
     const promptWithPaste = linesArray.some(
-      (l) => l.includes(config.promptSymbol) && l.includes("[Pasted text")
+      (l) => l.includes(config.promptSymbol) && l.includes("[Pasted text"),
     );
     if (!promptWithPaste) {
       return State.READY;
@@ -1432,6 +1866,31 @@ function detectState(screen, config) {
     // If prompt has pasted content, Claude is still processing - not ready yet
   }
 
+  // Thinking - spinners (check last lines only)
+  const spinners = config.spinners || [];
+  if (spinners.some((s) => lastLines.includes(s))) {
+    return State.THINKING;
+  }
+  // Thinking - text patterns (last lines) - supports strings, regexes, and functions
+  const thinkingPatterns = config.thinkingPatterns || [];
+  if (
+    thinkingPatterns.some((p) => {
+      if (typeof p === "function") return p(lastLines);
+      if (p instanceof RegExp) return p.test(lastLines);
+      return lastLines.includes(p);
+    })
+  ) {
+    return State.THINKING;
+  }
+
+  // Update prompt
+  if (config.updatePromptPatterns) {
+    const { screen: sp, lastLines: lp } = config.updatePromptPatterns;
+    if (sp && sp.some((p) => screen.includes(p)) && lp && lp.some((p) => lastLines.includes(p))) {
+      return State.UPDATE_PROMPT;
+    }
+  }
+
   return State.STARTING;
 }
 
@@ -1452,12 +1911,13 @@ function detectState(screen, config) {
 /**
  * @typedef {Object} AgentConfigInput
  * @property {string} name
+ * @property {string} displayName
  * @property {string} startCommand
  * @property {string} yoloCommand
  * @property {string} promptSymbol
  * @property {string[]} [spinners]
  * @property {RegExp} [rateLimitPattern]
- * @property {string[]} [thinkingPatterns]
+ * @property {(string | RegExp | ((lines: string) => boolean))[]} [thinkingPatterns]
  * @property {ConfirmPattern[]} [confirmPatterns]
  * @property {UpdatePromptPatterns | null} [updatePromptPatterns]
  * @property {string[]} [responseMarkers]
@@ -1467,6 +1927,8 @@ function detectState(screen, config) {
  * @property {string} [approveKey]
  * @property {string} [rejectKey]
  * @property {string} [safeAllowedTools]
+ * @property {string | null} [sessionIdFlag]
+ * @property {((sessionName: string) => string | null) | null} [logPathFinder]
  */
 
 class Agent {
@@ -1477,6 +1939,8 @@ class Agent {
     /** @type {string} */
     this.name = config.name;
     /** @type {string} */
+    this.displayName = config.displayName;
+    /** @type {string} */
     this.startCommand = config.startCommand;
     /** @type {string} */
     this.yoloCommand = config.yoloCommand;
@@ -1486,7 +1950,7 @@ class Agent {
     this.spinners = config.spinners || [];
     /** @type {RegExp | undefined} */
     this.rateLimitPattern = config.rateLimitPattern;
-    /** @type {string[]} */
+    /** @type {(string | RegExp | ((lines: string) => boolean))[]} */
     this.thinkingPatterns = config.thinkingPatterns || [];
     /** @type {ConfirmPattern[]} */
     this.confirmPatterns = config.confirmPatterns || [];
@@ -1506,6 +1970,10 @@ class Agent {
     this.rejectKey = config.rejectKey || "n";
     /** @type {string | undefined} */
     this.safeAllowedTools = config.safeAllowedTools;
+    /** @type {string | null} */
+    this.sessionIdFlag = config.sessionIdFlag || null;
+    /** @type {((sessionName: string) => string | null) | null} */
+    this.logPathFinder = config.logPathFinder || null;
   }
 
   /**
@@ -1523,12 +1991,9 @@ class Agent {
     } else {
       base = this.startCommand;
     }
-    // Claude supports --session-id for deterministic session tracking
-    if (this.name === "claude" && sessionName) {
-      const parsed = parseSessionName(sessionName);
-      if (parsed?.uuid) {
-        return `${base} --session-id ${parsed.uuid}`;
-      }
+    // Some agents support session ID flags for deterministic session tracking
+    if (this.sessionIdFlag && sessionName) {
+      return `${base} ${this.sessionIdFlag} ${sessionName}`;
     }
     return base;
   }
@@ -1540,7 +2005,7 @@ class Agent {
     }
 
     const cwd = process.cwd();
-    const childPattern = new RegExp(`^${this.name}-[0-9a-f-]{36}$`, "i");
+    const childPattern = new RegExp(`^${this.name}-(partner-)?[0-9a-f-]{36}$`, "i");
 
     // If inside tmux, look for existing agent session in same cwd
     const current = tmuxCurrentSession();
@@ -1585,13 +2050,8 @@ class Agent {
    * @returns {string | null}
    */
   findLogPath(sessionName) {
-    const parsed = parseSessionName(sessionName);
-    if (this.name === "claude") {
-      const uuid = parsed?.uuid;
-      if (uuid) return findClaudeLogPath(uuid, sessionName);
-    }
-    if (this.name === "codex") {
-      return findCodexLogPath(sessionName);
+    if (this.logPathFinder) {
+      return this.logPathFinder(sessionName);
     }
     return null;
   }
@@ -1635,7 +2095,12 @@ class Agent {
       if (/^(run|execute|create|delete|modify|write)/i.test(line)) return line;
     }
 
-    return lines.filter((l) => l && !l.match(/^[╭╮╰╯│─]+$/)).slice(0, 2).join(" | ") || "action";
+    return (
+      lines
+        .filter((l) => l && !l.match(/^[╭╮╰╯│─]+$/))
+        .slice(0, 2)
+        .join(" | ") || "action"
+    );
   }
 
   /**
@@ -1711,7 +2176,9 @@ class Agent {
 
     // Fallback: extract after last prompt
     if (filtered.length === 0) {
-      const lastPromptIdx = lines.findLastIndex((/** @type {string} */ l) => l.startsWith(this.promptSymbol));
+      const lastPromptIdx = lines.findLastIndex((/** @type {string} */ l) =>
+        l.startsWith(this.promptSymbol),
+      );
       if (lastPromptIdx >= 0 && lastPromptIdx < lines.length - 1) {
         const afterPrompt = lines
           .slice(lastPromptIdx + 1)
@@ -1725,14 +2192,14 @@ class Agent {
       // This handles the case where Claude finished and shows a new empty prompt
       if (lastPromptIdx >= 0) {
         const lastPromptLine = lines[lastPromptIdx];
-        const isEmptyPrompt = lastPromptLine.trim() === this.promptSymbol ||
-                              lastPromptLine.match(/^❯\s*$/);
+        const isEmptyPrompt =
+          lastPromptLine.trim() === this.promptSymbol || lastPromptLine.match(/^❯\s*$/);
         if (isEmptyPrompt) {
           // Find the previous prompt (user's input) and extract content between
           // Note: [Pasted text is Claude's truncated output indicator, NOT a prompt
-          const prevPromptIdx = lines.slice(0, lastPromptIdx).findLastIndex(
-            (/** @type {string} */ l) => l.startsWith(this.promptSymbol)
-          );
+          const prevPromptIdx = lines
+            .slice(0, lastPromptIdx)
+            .findLastIndex((/** @type {string} */ l) => l.startsWith(this.promptSymbol));
           if (prevPromptIdx >= 0) {
             const betweenPrompts = lines
               .slice(prevPromptIdx + 1, lastPromptIdx)
@@ -1753,23 +2220,25 @@ class Agent {
    * @returns {string}
    */
   cleanResponse(response) {
-    return response
-      // Remove tool call lines (Search, Read, Grep, etc.)
-      .replace(/^[⏺•]\s*(Search|Read|Grep|Glob|Write|Edit|Bash)\([^)]*\).*$/gm, "")
-      // Remove tool result lines
-      .replace(/^⎿\s+.*$/gm, "")
-      // Remove "Sautéed for Xs" timing lines
-      .replace(/^✻\s+Sautéed for.*$/gm, "")
-      // Remove expand hints
-      .replace(/\(ctrl\+o to expand\)/g, "")
-      // Clean up multiple blank lines
-      .replace(/\n{3,}/g, "\n\n")
-      // Original cleanup
-      .replace(/^[•⏺-]\s*/, "")
-      .replace(/^\*\*(.+)\*\*/, "$1")
-      .replace(/\n  /g, "\n")
-      .replace(/─+\s*$/, "")
-      .trim();
+    return (
+      response
+        // Remove tool call lines (Search, Read, Grep, etc.)
+        .replace(/^[⏺•]\s*(Search|Read|Grep|Glob|Write|Edit|Bash)\([^)]*\).*$/gm, "")
+        // Remove tool result lines
+        .replace(/^⎿\s+.*$/gm, "")
+        // Remove "Sautéed for Xs" timing lines
+        .replace(/^✻\s+Sautéed for.*$/gm, "")
+        // Remove expand hints
+        .replace(/\(ctrl\+o to expand\)/g, "")
+        // Clean up multiple blank lines
+        .replace(/\n{3,}/g, "\n\n")
+        // Original cleanup
+        .replace(/^[•⏺-]\s*/, "")
+        .replace(/^\*\*(.+)\*\*/, "$1")
+        .replace(/\n  /g, "\n")
+        .replace(/─+\s*$/, "")
+        .trim()
+    );
   }
 
   /**
@@ -1810,6 +2279,7 @@ class Agent {
 
 const CodexAgent = new Agent({
   name: "codex",
+  displayName: "Codex",
   startCommand: "codex --sandbox read-only",
   yoloCommand: "codex --dangerously-bypass-approvals-and-sandbox",
   promptSymbol: "›",
@@ -1829,6 +2299,7 @@ const CodexAgent = new Agent({
   chromePatterns: ["context left", "for shortcuts"],
   reviewOptions: { pr: "1", uncommitted: "2", commit: "3", custom: "4" },
   envVar: "AX_SESSION",
+  logPathFinder: findCodexLogPath,
 });
 
 // =============================================================================
@@ -1837,12 +2308,15 @@ const CodexAgent = new Agent({
 
 const ClaudeAgent = new Agent({
   name: "claude",
+  displayName: "Claude",
   startCommand: "claude",
   yoloCommand: "claude --dangerously-skip-permissions",
   promptSymbol: "❯",
-  spinners: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  // Claude Code spinners: ·✢✳✶✻✽ (from cli.js source)
+  spinners: ["·", "✢", "✳", "✶", "✻", "✽"],
   rateLimitPattern: /rate.?limit/i,
-  thinkingPatterns: ["Thinking"],
+  // Claude uses whimsical verbs like "Wibbling…", "Dancing…", etc. Match any capitalized -ing word + ellipsis (… or ...)
+  thinkingPatterns: ["Thinking", /[A-Z][a-z]+ing(…|\.\.\.)/],
   confirmPatterns: [
     "Do you want to make this edit",
     "Do you want to run this command",
@@ -1852,12 +2326,28 @@ const ClaudeAgent = new Agent({
   ],
   updatePromptPatterns: null,
   responseMarkers: ["⏺", "•", "- ", "**"],
-  chromePatterns: ["↵ send", "Esc to cancel", "shortcuts", "for more options", "docs.anthropic.com", "⏵⏵", "bypass permissions", "shift+Tab to cycle"],
+  chromePatterns: [
+    "↵ send",
+    "Esc to cancel",
+    "shortcuts",
+    "for more options",
+    "docs.anthropic.com",
+    "⏵⏵",
+    "bypass permissions",
+    "shift+Tab to cycle",
+  ],
   reviewOptions: null,
-  safeAllowedTools: "Bash(git:*) Read Glob Grep",  // Default: auto-approve read-only tools
+  safeAllowedTools: "Bash(git:*) Read Glob Grep", // Default: auto-approve read-only tools
   envVar: "AX_SESSION",
   approveKey: "1",
   rejectKey: "Escape",
+  sessionIdFlag: "--session-id",
+  logPathFinder: (sessionName) => {
+    const parsed = parseSessionName(sessionName);
+    const uuid = parsed?.uuid;
+    if (uuid) return findClaudeLogPath(uuid, sessionName);
+    return null;
+  },
 });
 
 // =============================================================================
@@ -1878,7 +2368,11 @@ async function waitUntilReady(agent, session, timeoutMs = DEFAULT_TIMEOUT_MS) {
   const initialState = agent.getState(initialScreen);
 
   // Already in terminal state
-  if (initialState === State.RATE_LIMITED || initialState === State.CONFIRMING || initialState === State.READY) {
+  if (
+    initialState === State.RATE_LIMITED ||
+    initialState === State.CONFIRMING ||
+    initialState === State.READY
+  ) {
     return { state: initialState, screen: initialScreen };
   }
 
@@ -1891,30 +2385,38 @@ async function waitUntilReady(agent, session, timeoutMs = DEFAULT_TIMEOUT_MS) {
       return { state, screen };
     }
   }
-  throw new Error("timeout");
+  throw new TimeoutError(session);
 }
 
 /**
- * Wait for agent to process a new message and respond.
- * Waits for screen activity before considering the response complete.
+ * Core polling loop for waiting on agent responses.
  * @param {Agent} agent
  * @param {string} session
- * @param {number} [timeoutMs]
+ * @param {number} timeoutMs
+ * @param {{onPoll?: (screen: string, state: string) => void, onStateChange?: (state: string, lastState: string | null, screen: string) => void, onReady?: (screen: string) => void}} [hooks]
  * @returns {Promise<{state: string, screen: string}>}
  */
-async function waitForResponse(agent, session, timeoutMs = DEFAULT_TIMEOUT_MS) {
+async function pollForResponse(agent, session, timeoutMs, hooks = {}) {
+  const { onPoll, onStateChange, onReady } = hooks;
   const start = Date.now();
   const initialScreen = tmuxCapture(session);
 
   let lastScreen = initialScreen;
+  let lastState = null;
   let stableAt = null;
   let sawActivity = false;
 
   while (Date.now() - start < timeoutMs) {
-    await sleep(POLL_MS);
     const screen = tmuxCapture(session);
     const state = agent.getState(screen);
 
+    if (onPoll) onPoll(screen, state);
+
+    if (state !== lastState) {
+      if (onStateChange) onStateChange(state, lastState, screen);
+      lastState = state;
+    }
+
     if (state === State.RATE_LIMITED || state === State.CONFIRMING) {
       return { state, screen };
     }
@@ -1929,6 +2431,7 @@ async function waitForResponse(agent, session, timeoutMs = DEFAULT_TIMEOUT_MS) {
 
     if (sawActivity && stableAt && Date.now() - stableAt >= STABLE_MS) {
       if (state === State.READY) {
+        if (onReady) onReady(screen);
         return { state, screen };
       }
     }
@@ -1936,26 +2439,86 @@ async function waitForResponse(agent, session, timeoutMs = DEFAULT_TIMEOUT_MS) {
     if (state === State.THINKING) {
       sawActivity = true;
     }
+
+    await sleep(POLL_MS);
   }
-  throw new Error("timeout");
+  throw new TimeoutError(session);
 }
 
 /**
- * Auto-approve loop that keeps approving confirmations until the agent is ready or rate limited.
- * Used by callers to implement yolo mode on sessions not started with native --yolo.
+ * Wait for agent response without streaming output.
  * @param {Agent} agent
  * @param {string} session
  * @param {number} [timeoutMs]
  * @returns {Promise<{state: string, screen: string}>}
  */
-async function autoApproveLoop(agent, session, timeoutMs = DEFAULT_TIMEOUT_MS) {
+async function waitForResponse(agent, session, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  return pollForResponse(agent, session, timeoutMs);
+}
+
+/**
+ * Wait for agent response with streaming output to console.
+ * @param {Agent} agent
+ * @param {string} session
+ * @param {number} [timeoutMs]
+ * @returns {Promise<{state: string, screen: string}>}
+ */
+async function streamResponse(agent, session, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  let logPath = agent.findLogPath(session);
+  let logOffset = logPath && existsSync(logPath) ? statSync(logPath).size : 0;
+  let printedThinking = false;
+
+  const streamNewEntries = () => {
+    if (!logPath) {
+      logPath = agent.findLogPath(session);
+      if (logPath && existsSync(logPath)) {
+        logOffset = statSync(logPath).size;
+      }
+    }
+    if (logPath) {
+      const { entries, newOffset } = tailJsonl(logPath, logOffset);
+      logOffset = newOffset;
+      for (const entry of entries) {
+        const formatted = formatEntry(entry);
+        if (formatted) console.log(formatted);
+      }
+    }
+  };
+
+  return pollForResponse(agent, session, timeoutMs, {
+    onPoll: () => streamNewEntries(),
+    onStateChange: (state, lastState, screen) => {
+      if (state === State.THINKING && !printedThinking) {
+        console.log("[THINKING]");
+        printedThinking = true;
+      } else if (state === State.CONFIRMING) {
+        const pendingTool = extractPendingToolFromScreen(screen);
+        console.log(pendingTool ? `[CONFIRMING] ${pendingTool}` : "[CONFIRMING]");
+      }
+      if (lastState === State.THINKING && state !== State.THINKING) {
+        printedThinking = false;
+      }
+    },
+    onReady: () => streamNewEntries(),
+  });
+}
+
+/**
+ * Auto-approve loop that keeps approving confirmations until the agent is ready or rate limited.
+ * @param {Agent} agent
+ * @param {string} session
+ * @param {number} timeoutMs
+ * @param {Function} waitFn - waitForResponse or streamResponse
+ * @returns {Promise<{state: string, screen: string}>}
+ */
+async function autoApproveLoop(agent, session, timeoutMs, waitFn) {
   const deadline = Date.now() + timeoutMs;
 
   while (Date.now() < deadline) {
     const remaining = deadline - Date.now();
     if (remaining <= 0) break;
 
-    const { state, screen } = await waitForResponse(agent, session, remaining);
+    const { state, screen } = await waitFn(agent, session, remaining);
 
     if (state === State.RATE_LIMITED || state === State.READY) {
       return { state, screen };
@@ -1967,11 +2530,10 @@ async function autoApproveLoop(agent, session, timeoutMs = DEFAULT_TIMEOUT_MS) {
       continue;
     }
 
-    // Unexpected state - log and continue polling
     debugError("autoApproveLoop", new Error(`unexpected state: ${state}`));
   }
 
-  throw new Error("timeout");
+  throw new TimeoutError(session);
 }
 
 /**
@@ -2030,125 +2592,158 @@ function cmdAgents() {
 
   if (agentSessions.length === 0) {
     console.log("No agents running");
+    // Still check for orphans
+    const orphans = findOrphanedProcesses();
+    if (orphans.length > 0) {
+      console.log(`\nOrphaned (${orphans.length}):`);
+      for (const { pid, command } of orphans) {
+        console.log(`  PID ${pid}: ${command}`);
+      }
+      console.log(`\n  Run 'ax kill --orphans' to clean up`);
+    }
     return;
   }
 
+  // Get default session for each agent type
+  const claudeDefault = ClaudeAgent.getDefaultSession();
+  const codexDefault = CodexAgent.getDefaultSession();
+
   // Get info for each agent
   const agents = agentSessions.map((session) => {
     const parsed = /** @type {ParsedSession} */ (parseSessionName(session));
     const agent = parsed.tool === "claude" ? ClaudeAgent : CodexAgent;
     const screen = tmuxCapture(session);
     const state = agent.getState(screen);
-    const logPath = agent.findLogPath(session);
-    const type = parsed.daemonName ? "daemon" : "-";
+    const type = parsed.archangelName ? "archangel" : "-";
+    const isDefault =
+      (parsed.tool === "claude" && session === claudeDefault) ||
+      (parsed.tool === "codex" && session === codexDefault);
+
+    // Get session metadata (Claude only)
+    const meta = getSessionMeta(session);
 
     return {
       session,
       tool: parsed.tool,
       state: state || "unknown",
+      target: isDefault ? "*" : "",
       type,
-      log: logPath || "-",
+      plan: meta?.slug || "-",
+      branch: meta?.gitBranch || "-",
     };
   });
 
-  // Print table
+  // Print sessions table
   const maxSession = Math.max(7, ...agents.map((a) => a.session.length));
   const maxTool = Math.max(4, ...agents.map((a) => a.tool.length));
   const maxState = Math.max(5, ...agents.map((a) => a.state.length));
+  const maxTarget = Math.max(6, ...agents.map((a) => a.target.length));
   const maxType = Math.max(4, ...agents.map((a) => a.type.length));
+  const maxPlan = Math.max(4, ...agents.map((a) => a.plan.length));
 
   console.log(
-    `${"SESSION".padEnd(maxSession)}  ${"TOOL".padEnd(maxTool)}  ${"STATE".padEnd(maxState)}  ${"TYPE".padEnd(maxType)}  LOG`
+    `${"SESSION".padEnd(maxSession)}  ${"TOOL".padEnd(maxTool)}  ${"STATE".padEnd(maxState)}  ${"TARGET".padEnd(maxTarget)}  ${"TYPE".padEnd(maxType)}  ${"PLAN".padEnd(maxPlan)}  BRANCH`,
   );
   for (const a of agents) {
     console.log(
-      `${a.session.padEnd(maxSession)}  ${a.tool.padEnd(maxTool)}  ${a.state.padEnd(maxState)}  ${a.type.padEnd(maxType)}  ${a.log}`
+      `${a.session.padEnd(maxSession)}  ${a.tool.padEnd(maxTool)}  ${a.state.padEnd(maxState)}  ${a.target.padEnd(maxTarget)}  ${a.type.padEnd(maxType)}  ${a.plan.padEnd(maxPlan)}  ${a.branch}`,
     );
   }
+
+  // Print orphaned processes if any
+  const orphans = findOrphanedProcesses();
+  if (orphans.length > 0) {
+    console.log(`\nOrphaned (${orphans.length}):`);
+    for (const { pid, command } of orphans) {
+      console.log(`  PID ${pid}: ${command}`);
+    }
+    console.log(`\n  Run 'ax kill --orphans' to clean up`);
+  }
 }
 
 // =============================================================================
-// Command: daemons
+// Command: summon/recall
 // =============================================================================
 
 /**
  * @param {string} pattern
  * @returns {string | undefined}
  */
-function findDaemonSession(pattern) {
+function findArchangelSession(pattern) {
   const sessions = tmuxListSessions();
   return sessions.find((s) => s.startsWith(pattern));
 }
 
 /**
- * @param {DaemonConfig} config
+ * @param {ArchangelConfig} config
  * @returns {string}
  */
-function generateDaemonSessionName(config) {
-  return `${config.tool}-daemon-${config.name}-${randomUUID()}`;
+function generateArchangelSessionName(config) {
+  return `${config.tool}-archangel-${config.name}-${randomUUID()}`;
 }
 
 /**
- * @param {DaemonConfig} config
+ * @param {ArchangelConfig} config
  * @param {ParentSession | null} [parentSession]
  */
-function startDaemonAgent(config, parentSession = null) {
-  // Build environment with parent session info if available
+function startArchangel(config, parentSession = null) {
   /** @type {NodeJS.ProcessEnv} */
   const env = { ...process.env };
   if (parentSession?.uuid) {
-    // Session name may be null for non-tmux sessions, but uuid is required
     if (parentSession.session) {
-      env[AX_DAEMON_PARENT_SESSION_ENV] = parentSession.session;
+      env[AX_ARCHANGEL_PARENT_SESSION_ENV] = parentSession.session;
     }
-    env[AX_DAEMON_PARENT_UUID_ENV] = parentSession.uuid;
+    env[AX_ARCHANGEL_PARENT_UUID_ENV] = parentSession.uuid;
   }
 
-  // Spawn ax.js daemon <name> as a detached background process
-  const child = spawn("node", [process.argv[1], "daemon", config.name], {
+  const child = spawn("node", [process.argv[1], "archangel", config.name], {
     detached: true,
     stdio: "ignore",
     cwd: process.cwd(),
     env,
   });
   child.unref();
-  console.log(`Starting daemon: ${config.name} (pid ${child.pid})${parentSession ? ` [parent: ${parentSession.session}]` : ""}`);
+  console.log(
+    `Summoning: ${config.name} (pid ${child.pid})${parentSession ? ` [parent: ${parentSession.session}]` : ""}`,
+  );
 }
 
 // =============================================================================
-// Command: daemon (runs as the daemon process itself)
+// Command: archangel (runs as the archangel process itself)
 // =============================================================================
 
 /**
  * @param {string | undefined} agentName
  */
-async function cmdDaemon(agentName) {
+async function cmdArchangel(agentName) {
   if (!agentName) {
-    console.error("Usage: ./ax.js daemon <name>");
+    console.error("Usage: ./ax.js archangel <name>");
     process.exit(1);
   }
   // Load agent config
   const configPath = path.join(AGENTS_DIR, `${agentName}.md`);
   if (!existsSync(configPath)) {
-    console.error(`[daemon:${agentName}] Config not found: ${configPath}`);
+    console.error(`[archangel:${agentName}] Config not found: ${configPath}`);
     process.exit(1);
   }
 
   const content = readFileSync(configPath, "utf-8");
   const configResult = parseAgentConfig(`${agentName}.md`, content);
   if (!configResult || "error" in configResult) {
-    console.error(`[daemon:${agentName}] Invalid config`);
+    console.error(`[archangel:${agentName}] Invalid config`);
     process.exit(1);
   }
   const config = configResult;
 
   const agent = config.tool === "claude" ? ClaudeAgent : CodexAgent;
-  const sessionName = generateDaemonSessionName(config);
+  const sessionName = generateArchangelSessionName(config);
 
   // Check agent CLI is installed before trying to start
   const cliCheck = spawnSync("which", [agent.name], { encoding: "utf-8" });
   if (cliCheck.status !== 0) {
-    console.error(`[daemon:${agentName}] ERROR: ${agent.name} CLI is not installed or not in PATH`);
+    console.error(
+      `[archangel:${agentName}] ERROR: ${agent.name} CLI is not installed or not in PATH`,
+    );
     process.exit(1);
   }
 
@@ -2158,7 +2753,7 @@ async function cmdDaemon(agentName) {
 
   // Wait for agent to be ready
   const start = Date.now();
-  while (Date.now() - start < DAEMON_STARTUP_TIMEOUT_MS) {
+  while (Date.now() - start < ARCHANGEL_STARTUP_TIMEOUT_MS) {
     const screen = tmuxCapture(sessionName);
     const state = agent.getState(screen);
 
@@ -2169,7 +2764,7 @@ async function cmdDaemon(agentName) {
 
     // Handle bypass permissions confirmation dialog (Claude Code shows this for --dangerously-skip-permissions)
     if (screen.includes("Bypass Permissions mode") && screen.includes("Yes, I accept")) {
-      console.log(`[daemon:${agentName}] Accepting bypass permissions dialog`);
+      console.log(`[archangel:${agentName}] Accepting bypass permissions dialog`);
       tmuxSend(sessionName, "2"); // Select "Yes, I accept"
       await sleep(300);
       tmuxSend(sessionName, "Enter");
@@ -2178,7 +2773,7 @@ async function cmdDaemon(agentName) {
     }
 
     if (state === State.READY) {
-      console.log(`[daemon:${agentName}] Started session: ${sessionName}`);
+      console.log(`[archangel:${agentName}] Started session: ${sessionName}`);
       break;
     }
 
@@ -2200,6 +2795,13 @@ async function cmdDaemon(agentName) {
   let isProcessing = false;
   const intervalMs = config.interval * 1000;
 
+  // Hash tracking for incremental context updates
+  /** @type {string | null} */
+  let lastPlanHash = null;
+  /** @type {string | null} */
+  let lastTodosHash = null;
+  let isFirstTrigger = true;
+
   async function processChanges() {
     clearTimeout(debounceTimer);
     clearTimeout(maxWaitTimer);
@@ -2210,16 +2812,32 @@ async function cmdDaemon(agentName) {
     isProcessing = true;
 
     const files = [...changedFiles];
-    changedFiles = new Set();  // atomic swap to avoid losing changes during processing
+    changedFiles = new Set(); // atomic swap to avoid losing changes during processing
 
     try {
       // Get parent session log path for JSONL extraction
       const parent = findParentSession();
       const logPath = parent ? findClaudeLogPath(parent.uuid, parent.session) : null;
 
+      // Get orientation context (plan and todos) from parent session
+      const meta = parent?.session ? getSessionMeta(parent.session) : null;
+      const planContent = meta?.slug ? readPlanFile(meta.slug) : null;
+      const todosContent = meta?.todos?.length ? formatTodos(meta.todos) : null;
+
+      // Check if plan/todos have changed since last trigger
+      const planHash = quickHash(planContent);
+      const todosHash = quickHash(todosContent);
+      const includePlan = planHash !== lastPlanHash;
+      const includeTodos = todosHash !== lastTodosHash;
+
+      // Update tracking for next trigger
+      lastPlanHash = planHash;
+      lastTodosHash = todosHash;
+
       // Build file-specific context from JSONL
       const fileContexts = [];
-      for (const file of files.slice(0, 5)) { // Limit to 5 files
+      for (const file of files.slice(0, 5)) {
+        // Limit to 5 files
         const ctx = extractFileEditContext(logPath, file);
         if (ctx) {
           fileContexts.push({ file, ...ctx });
@@ -2227,7 +2845,18 @@ async function cmdDaemon(agentName) {
       }
 
       // Build the prompt
-      let prompt = basePrompt;
+      // First trigger: include intro, guidelines, and focus (archangel has memory)
+      let prompt = isFirstTrigger
+        ? `You are the archangel of ${agentName}.\n\n${ARCHANGEL_PREAMBLE}\n\n## Focus\n\n${basePrompt}\n\n---`
+        : "";
+
+      // Add orientation context (plan and todos) only if changed since last trigger
+      if (includePlan && planContent) {
+        prompt += (prompt ? "\n\n" : "") + "## Current Plan\n\n" + planContent;
+      }
+      if (includeTodos && todosContent) {
+        prompt += (prompt ? "\n\n" : "") + "## Current Todos\n\n" + todosContent;
+      }
 
       if (fileContexts.length > 0) {
         prompt += "\n\n## Recent Edits (from parent session)\n";
@@ -2246,26 +2875,33 @@ async function cmdDaemon(agentName) {
           }
 
           if (ctx.readsBefore.length > 0) {
-            const reads = ctx.readsBefore.map(f => f.split("/").pop()).join(", ");
+            const reads = ctx.readsBefore.map((f) => f.split("/").pop()).join(", ");
             prompt += `**Files read before:** ${reads}\n`;
           }
         }
 
         prompt += "\n\n## Files Changed\n  - " + files.slice(0, 10).join("\n  - ");
 
-        const gitContext = buildGitContext(DAEMON_GIT_CONTEXT_HOURS, DAEMON_GIT_CONTEXT_MAX_LINES);
+        const gitContext = buildGitContext(
+          ARCHANGEL_GIT_CONTEXT_HOURS,
+          ARCHANGEL_GIT_CONTEXT_MAX_LINES,
+        );
         if (gitContext) {
           prompt += "\n\n## Git Context\n\n" + gitContext;
         }
 
-        prompt += '\n\nReview these changes in the context of what the user is working on. Report any issues found. Keep your response concise.\nIf there are no significant issues, respond with just "No issues found."';
+        prompt += "\n\nReview these changes.";
       } else {
         // Fallback: no JSONL context available, use conversation + git context
-        const parentContext = getParentSessionContext(DAEMON_PARENT_CONTEXT_ENTRIES);
-        const gitContext = buildGitContext(DAEMON_GIT_CONTEXT_HOURS, DAEMON_GIT_CONTEXT_MAX_LINES);
+        const parentContext = getParentSessionContext(ARCHANGEL_PARENT_CONTEXT_ENTRIES);
+        const gitContext = buildGitContext(
+          ARCHANGEL_GIT_CONTEXT_HOURS,
+          ARCHANGEL_GIT_CONTEXT_MAX_LINES,
+        );
 
         if (parentContext) {
-          prompt += "\n\n## Main Session Context\n\nThe user is currently working on:\n\n" + parentContext;
+          prompt +=
+            "\n\n## Main Session Context\n\nThe user is currently working on:\n\n" + parentContext;
         }
 
         prompt += "\n\n## Files Changed\n  - " + files.slice(0, 10).join("\n  - ");
@@ -2274,13 +2910,12 @@ async function cmdDaemon(agentName) {
           prompt += "\n\n## Git Context\n\n" + gitContext;
         }
 
-        prompt += '\n\nReview these changes in the context of what the user is working on. Report any issues found. Keep your response concise.\nIf there are no significant issues, respond with just "No issues found."';
+        prompt += "\n\nReview these changes.";
       }
 
-
       // Check session still exists
       if (!tmuxHasSession(sessionName)) {
-        console.log(`[daemon:${agentName}] Session gone, exiting`);
+        console.log(`[archangel:${agentName}] Session gone, exiting`);
         process.exit(0);
       }
 
@@ -2289,12 +2924,12 @@ async function cmdDaemon(agentName) {
       const state = agent.getState(screen);
 
       if (state === State.RATE_LIMITED) {
-        console.error(`[daemon:${agentName}] Rate limited - stopping`);
+        console.error(`[archangel:${agentName}] Rate limited - stopping`);
         process.exit(2);
       }
 
       if (state !== State.READY) {
-        console.log(`[daemon:${agentName}] Agent not ready (${state}), skipping`);
+        console.log(`[archangel:${agentName}] Agent not ready (${state}), skipping`);
         isProcessing = false;
         return;
       }
@@ -2304,38 +2939,37 @@ async function cmdDaemon(agentName) {
       await sleep(200); // Allow time for large prompts to be processed
       tmuxSend(sessionName, "Enter");
       await sleep(100); // Ensure Enter is processed
+      isFirstTrigger = false;
 
       // Wait for response
-      const { state: endState, screen: afterScreen } = await waitForResponse(agent, sessionName, DAEMON_RESPONSE_TIMEOUT_MS);
+      const { state: endState, screen: afterScreen } = await waitForResponse(
+        agent,
+        sessionName,
+        ARCHANGEL_RESPONSE_TIMEOUT_MS,
+      );
 
       if (endState === State.RATE_LIMITED) {
-        console.error(`[daemon:${agentName}] Rate limited - stopping`);
+        console.error(`[archangel:${agentName}] Rate limited - stopping`);
         process.exit(2);
       }
 
-
       const cleanedResponse = agent.getResponse(sessionName, afterScreen) || "";
 
-      // Sanity check: skip garbage responses (screen scraping artifacts)
-      const isGarbage = cleanedResponse.includes("[Pasted text") ||
-        cleanedResponse.match(/^\+\d+ lines\]/) ||
-        cleanedResponse.length < 20;
+      const isSkippable = !cleanedResponse || cleanedResponse.trim() === "EMPTY_RESPONSE";
 
-      if (cleanedResponse && !isGarbage && !cleanedResponse.toLowerCase().includes("no issues found")) {
+      if (!isSkippable) {
         writeToMailbox({
           agent: /** @type {string} */ (agentName),
           session: sessionName,
           branch: getCurrentBranch(),
           commit: getCurrentCommit(),
           files,
-          message: cleanedResponse.slice(0, 1000),
+          message: cleanedResponse,
         });
-        console.log(`[daemon:${agentName}] Wrote observation for ${files.length} file(s)`);
-      } else if (isGarbage) {
-        console.log(`[daemon:${agentName}] Skipped garbage response`);
+        console.log(`[archangel:${agentName}] Wrote observation for ${files.length} file(s)`);
       }
     } catch (err) {
-      console.error(`[daemon:${agentName}] Error:`, err instanceof Error ? err.message : err);
+      console.error(`[archangel:${agentName}] Error:`, err instanceof Error ? err.message : err);
     }
 
     isProcessing = false;
@@ -2343,7 +2977,10 @@ async function cmdDaemon(agentName) {
 
   function scheduleProcessChanges() {
     processChanges().catch((err) => {
-      console.error(`[daemon:${agentName}] Unhandled error:`, err instanceof Error ? err.message : err);
+      console.error(
+        `[archangel:${agentName}] Unhandled error:`,
+        err instanceof Error ? err.message : err,
+      );
     });
   }
 
@@ -2364,16 +3001,16 @@ async function cmdDaemon(agentName) {
   // Check if session still exists periodically
   const sessionCheck = setInterval(() => {
     if (!tmuxHasSession(sessionName)) {
-      console.log(`[daemon:${agentName}] Session gone, exiting`);
+      console.log(`[archangel:${agentName}] Session gone, exiting`);
       stopWatching();
       clearInterval(sessionCheck);
       process.exit(0);
     }
-  }, DAEMON_HEALTH_CHECK_MS);
+  }, ARCHANGEL_HEALTH_CHECK_MS);
 
   // Handle graceful shutdown
   process.on("SIGTERM", () => {
-    console.log(`[daemon:${agentName}] Received SIGTERM, shutting down`);
+    console.log(`[archangel:${agentName}] Received SIGTERM, shutting down`);
     stopWatching();
     clearInterval(sessionCheck);
     tmuxSend(sessionName, "C-c");
@@ -2384,7 +3021,7 @@ async function cmdDaemon(agentName) {
   });
 
   process.on("SIGINT", () => {
-    console.log(`[daemon:${agentName}] Received SIGINT, shutting down`);
+    console.log(`[archangel:${agentName}] Received SIGINT, shutting down`);
     stopWatching();
     clearInterval(sessionCheck);
     tmuxSend(sessionName, "C-c");
@@ -2394,48 +3031,33 @@ async function cmdDaemon(agentName) {
     }, 500);
   });
 
-  console.log(`[daemon:${agentName}] Watching: ${config.watch.join(", ")}`);
+  console.log(`[archangel:${agentName}] Watching: ${config.watch.join(", ")}`);
 
   // Keep the process alive
   await new Promise(() => {});
 }
 
 /**
- * @param {string} action
- * @param {string | null} [daemonName]
+ * @param {string | null} [name]
  */
-async function cmdDaemons(action, daemonName = null) {
-  if (action !== "start" && action !== "stop" && action !== "init") {
-    console.log("Usage: ./ax.js daemons <start|stop|init> [name]");
-    process.exit(1);
-  }
-
-  // Handle init action separately
-  if (action === "init") {
-    if (!daemonName) {
-      console.log("Usage: ./ax.js daemons init <name>");
-      console.log("Example: ./ax.js daemons init reviewer");
-      process.exit(1);
-    }
-
-    // Validate name (alphanumeric, dashes, underscores only)
-    if (!/^[a-zA-Z0-9_-]+$/.test(daemonName)) {
-      console.log("ERROR: Daemon name must contain only letters, numbers, dashes, and underscores");
-      process.exit(1);
-    }
+async function cmdSummon(name = null) {
+  const configs = loadAgentConfigs();
 
-    const agentPath = path.join(AGENTS_DIR, `${daemonName}.md`);
-    if (existsSync(agentPath)) {
-      console.log(`ERROR: Agent config already exists: ${agentPath}`);
-      process.exit(1);
-    }
+  // If name provided but doesn't exist, create it
+  if (name) {
+    const exists = configs.some((c) => c.name === name);
+    if (!exists) {
+      if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+        console.log("ERROR: Name must contain only letters, numbers, dashes, and underscores");
+        process.exit(1);
+      }
 
-    // Create agents directory if needed
-    if (!existsSync(AGENTS_DIR)) {
-      mkdirSync(AGENTS_DIR, { recursive: true });
-    }
+      if (!existsSync(AGENTS_DIR)) {
+        mkdirSync(AGENTS_DIR, { recursive: true });
+      }
 
-    const template = `---
+      const agentPath = path.join(AGENTS_DIR, `${name}.md`);
+      const template = `---
 tool: claude
 watch: ["**/*.{ts,tsx,js,jsx,mjs,mts}"]
 interval: 30
@@ -2443,75 +3065,76 @@ interval: 30
 
 Review changed files for bugs, type errors, and edge cases.
 `;
+      writeFileSync(agentPath, template);
+      console.log(`Created: ${agentPath}`);
+      console.log(`Edit the file to customize, then run: ax summon ${name}`);
+      return;
+    }
+  }
 
-    writeFileSync(agentPath, template);
-    console.log(`Created agent config: ${agentPath}`);
-    console.log(`Edit the file to customize the daemon, then run: ./ax.js daemons start ${daemonName}`);
+  if (configs.length === 0) {
+    console.log(`No archangels found in ${AGENTS_DIR}/`);
     return;
   }
 
+  const targetConfigs = name ? configs.filter((c) => c.name === name) : configs;
+
+  ensureMailboxHookScript();
+
+  const parentSession = findCurrentClaudeSession();
+  if (parentSession) {
+    console.log(`Parent session: ${parentSession.session || "(non-tmux)"} [${parentSession.uuid}]`);
+  }
+
+  for (const config of targetConfigs) {
+    const sessionPattern = getArchangelSessionPattern(config);
+    const existing = findArchangelSession(sessionPattern);
+
+    if (!existing) {
+      startArchangel(config, parentSession);
+    } else {
+      console.log(`Already running: ${config.name} (${existing})`);
+    }
+  }
+
+  gcMailbox(24);
+}
+
+/**
+ * @param {string | null} [name]
+ */
+async function cmdRecall(name = null) {
   const configs = loadAgentConfigs();
 
   if (configs.length === 0) {
-    console.log(`No agent configs found in ${AGENTS_DIR}/`);
+    console.log(`No archangels found in ${AGENTS_DIR}/`);
     return;
   }
 
-  // Filter to specific daemon if name provided
-  const targetConfigs = daemonName
-    ? configs.filter((c) => c.name === daemonName)
-    : configs;
+  const targetConfigs = name ? configs.filter((c) => c.name === name) : configs;
 
-  if (daemonName && targetConfigs.length === 0) {
-    console.log(`ERROR: daemon '${daemonName}' not found in ${AGENTS_DIR}/`);
+  if (name && targetConfigs.length === 0) {
+    console.log(`ERROR: archangel '${name}' not found in ${AGENTS_DIR}/`);
     process.exit(1);
   }
 
-  // Ensure hook script exists on start
-  if (action === "start") {
-    ensureMailboxHookScript();
-  }
+  for (const config of targetConfigs) {
+    const sessionPattern = getArchangelSessionPattern(config);
+    const existing = findArchangelSession(sessionPattern);
 
-  // Find current Claude session to pass as parent (if we're inside one)
-  const parentSession = action === "start" ? findCurrentClaudeSession() : null;
-  if (action === "start") {
-    if (parentSession) {
-      console.log(`Parent session: ${parentSession.session || "(non-tmux)"} [${parentSession.uuid}]`);
+    if (existing) {
+      tmuxSend(existing, "C-c");
+      await sleep(300);
+      tmuxKill(existing);
+      console.log(`Recalled: ${config.name} (${existing})`);
     } else {
-      console.log("Parent session: null (not running from Claude or no active sessions)");
+      console.log(`Not running: ${config.name}`);
     }
   }
-
-  for (const config of targetConfigs) {
-    const sessionPattern = getDaemonSessionPattern(config);
-    const existing = findDaemonSession(sessionPattern);
-
-    if (action === "stop") {
-      if (existing) {
-        tmuxSend(existing, "C-c");
-        await sleep(300);
-        tmuxKill(existing);
-        console.log(`Stopped daemon: ${config.name} (${existing})`);
-      } else {
-        console.log(`Daemon not running: ${config.name}`);
-      }
-    } else if (action === "start") {
-      if (!existing) {
-        startDaemonAgent(config, parentSession);
-      } else {
-        console.log(`Daemon already running: ${config.name} (${existing})`);
-      }
-    }
-  }
-
-  // GC mailbox on start
-  if (action === "start") {
-    gcMailbox(24);
-  }
 }
 
 // Version of the hook script template - bump when making changes
-const HOOK_SCRIPT_VERSION = "2";
+const HOOK_SCRIPT_VERSION = "4";
 
 function ensureMailboxHookScript() {
   const hooksDir = HOOKS_DIR;
@@ -2529,34 +3152,54 @@ function ensureMailboxHookScript() {
     mkdirSync(hooksDir, { recursive: true });
   }
 
-  // Inject absolute paths into the generated script
-  const mailboxPath = path.join(AI_DIR, "mailbox.jsonl");
-  const lastSeenPath = path.join(AI_DIR, "mailbox-last-seen");
-
   const hookCode = `#!/usr/bin/env node
 ${versionMarker}
-// Auto-generated hook script - do not edit manually
-
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AI_DIR = join(__dirname, "..");
 const DEBUG = process.env.AX_DEBUG === "1";
-const MAILBOX = "${mailboxPath}";
-const LAST_SEEN = "${lastSeenPath}";
-const MAX_AGE_MS = 60 * 60 * 1000; // 1 hour (matches MAILBOX_MAX_AGE_MS)
+const MAILBOX = join(AI_DIR, "mailbox.jsonl");
+const MAX_AGE_MS = 60 * 60 * 1000;
 
-if (!existsSync(MAILBOX)) process.exit(0);
+// Read hook input from stdin
+let hookInput = {};
+try {
+  const stdinData = readFileSync(0, "utf-8").trim();
+  if (stdinData) hookInput = JSON.parse(stdinData);
+} catch (err) {
+  if (DEBUG) console.error("[hook] stdin parse:", err.message);
+}
+
+const sessionId = hookInput.session_id || "";
+const hookEvent = hookInput.hook_event_name || "";
 
-// Note: commit filtering removed - age + lastSeen is sufficient
+if (DEBUG) console.error("[hook] session:", sessionId, "event:", hookEvent);
 
-// Read last seen timestamp
-let lastSeen = 0;
+// NO-OP for archangel or partner sessions
+if (sessionId.includes("-archangel-") || sessionId.includes("-partner-")) {
+  if (DEBUG) console.error("[hook] skipping non-parent session");
+  process.exit(0);
+}
+
+// Per-session last-seen tracking (single JSON file, self-cleaning)
+const sessionHash = sessionId ? createHash("md5").update(sessionId).digest("hex").slice(0, 8) : "default";
+const LAST_SEEN_FILE = join(AI_DIR, "mailbox-last-seen.json");
+
+if (!existsSync(MAILBOX)) process.exit(0);
+
+let lastSeenMap = {};
 try {
-  if (existsSync(LAST_SEEN)) {
-    lastSeen = parseInt(readFileSync(LAST_SEEN, "utf-8").trim(), 10) || 0;
+  if (existsSync(LAST_SEEN_FILE)) {
+    lastSeenMap = JSON.parse(readFileSync(LAST_SEEN_FILE, "utf-8"));
   }
 } catch (err) {
   if (DEBUG) console.error("[hook] readLastSeen:", err.message);
 }
+const lastSeen = lastSeenMap[sessionHash] || 0;
 
 const now = Date.now();
 const lines = readFileSync(MAILBOX, "utf-8").trim().split("\\n").filter(Boolean);
@@ -2567,11 +3210,7 @@ for (const line of lines) {
     const entry = JSON.parse(line);
     const ts = new Date(entry.timestamp).getTime();
     const age = now - ts;
-
-    // Only show observations within max age and not yet seen
-    // (removed commit filter - too strict when HEAD moves during a session)
     if (age < MAX_AGE_MS && ts > lastSeen) {
-      // Extract session prefix (without UUID) for shorter log command
       const session = entry.payload.session || "";
       const sessionPrefix = session.replace(/-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "");
       relevant.push({ agent: entry.payload.agent, sessionPrefix, message: entry.payload.message });
@@ -2582,22 +3221,39 @@ for (const line of lines) {
 }
 
 if (relevant.length > 0) {
-  console.log("## Background Agents");
-  console.log("");
-  console.log("Background agents watching your files found:");
-  console.log("");
   const sessionPrefixes = new Set();
+  let messageLines = [];
+  messageLines.push("## Background Agents");
+  messageLines.push("");
+  messageLines.push("Background agents watching your files found:");
+  messageLines.push("");
   for (const { agent, sessionPrefix, message } of relevant) {
     if (sessionPrefix) sessionPrefixes.add(sessionPrefix);
-    console.log("**[" + agent + "]**");
-    console.log("");
-    console.log(message);
-    console.log("");
+    messageLines.push("**[" + agent + "]**");
+    messageLines.push("");
+    messageLines.push(message);
+    messageLines.push("");
   }
   const sessionList = [...sessionPrefixes].map(s => "\\\`./ax.js log " + s + "\\\`").join(" or ");
-  console.log("> For more context: \\\`./ax.js mailbox\\\`" + (sessionList ? " or " + sessionList : ""));
-  // Update last seen timestamp
-  writeFileSync(LAST_SEEN, now.toString());
+  messageLines.push("> For more context: \\\`./ax.js mailbox\\\`" + (sessionList ? " or " + sessionList : ""));
+
+  const formattedMessage = messageLines.join("\\n");
+
+  // For Stop hook, return blocking JSON to force acknowledgment
+  if (hookEvent === "Stop") {
+    console.log(JSON.stringify({ decision: "block", reason: formattedMessage }));
+  } else {
+    // For other hooks, just output the context
+    console.log(formattedMessage);
+  }
+
+  // Update last-seen and prune entries older than 24 hours
+  const PRUNE_AGE_MS = 24 * 60 * 60 * 1000;
+  lastSeenMap[sessionHash] = now;
+  for (const key of Object.keys(lastSeenMap)) {
+    if (now - lastSeenMap[key] > PRUNE_AGE_MS) delete lastSeenMap[key];
+  }
+  writeFileSync(LAST_SEEN_FILE, JSON.stringify(lastSeenMap));
 }
 
 process.exit(0);
@@ -2609,22 +3265,12 @@ process.exit(0);
   // Configure the hook in .claude/settings.json at the same time
   const configuredHook = ensureClaudeHookConfig();
   if (!configuredHook) {
-    const hookScriptPath = path.join(HOOKS_DIR, "mailbox-inject.js");
     console.log(`\nTo enable manually, add to .claude/settings.json:\n`);
     console.log(`{
   "hooks": {
-    "UserPromptSubmit": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node ${hookScriptPath}",
-            "timeout": 5
-          }
-        ]
-      }
-    ]
+    "UserPromptSubmit": [{ "matcher": "", "hooks": [{ "type": "command", "command": "node .ai/hooks/mailbox-inject.js", "timeout": 5 }] }],
+    "PostToolUse": [{ "matcher": "", "hooks": [{ "type": "command", "command": "node .ai/hooks/mailbox-inject.js", "timeout": 5 }] }],
+    "Stop": [{ "matcher": "", "hooks": [{ "type": "command", "command": "node .ai/hooks/mailbox-inject.js", "timeout": 5 }] }]
   }
 }`);
   }
@@ -2633,8 +3279,8 @@ process.exit(0);
 function ensureClaudeHookConfig() {
   const settingsDir = ".claude";
   const settingsPath = path.join(settingsDir, "settings.json");
-  const hookScriptPath = path.join(HOOKS_DIR, "mailbox-inject.js");
-  const hookCommand = `node ${hookScriptPath}`;
+  const hookCommand = "node .ai/hooks/mailbox-inject.js";
+  const hookEvents = ["UserPromptSubmit", "PostToolUse", "Stop"];
 
   try {
     /** @type {ClaudeSettings} */
@@ -2653,33 +3299,41 @@ function ensureClaudeHookConfig() {
 
     // Ensure hooks structure exists
     if (!settings.hooks) settings.hooks = {};
-    if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
-
-    // Check if our hook is already configured
-    const hookExists = settings.hooks.UserPromptSubmit.some(
-      /** @param {{hooks?: Array<{command: string}>}} entry */
-      (entry) => entry.hooks?.some(/** @param {{command: string}} h */ (h) => h.command === hookCommand)
-    );
 
-    if (hookExists) {
-      return true; // Already configured
+    let anyAdded = false;
+
+    for (const eventName of hookEvents) {
+      if (!settings.hooks[eventName]) settings.hooks[eventName] = [];
+
+      // Check if our hook is already configured for this event
+      const hookExists = settings.hooks[eventName].some(
+        /** @param {{hooks?: Array<{command: string}>}} entry */
+        (entry) =>
+          entry.hooks?.some(/** @param {{command: string}} h */ (h) => h.command === hookCommand),
+      );
+
+      if (!hookExists) {
+        // Add the hook for this event
+        settings.hooks[eventName].push({
+          matcher: "",
+          hooks: [
+            {
+              type: "command",
+              command: hookCommand,
+              timeout: 5,
+            },
+          ],
+        });
+        anyAdded = true;
+      }
     }
 
-    // Add the hook
-    settings.hooks.UserPromptSubmit.push({
-      matcher: "",
-      hooks: [
-        {
-          type: "command",
-          command: hookCommand,
-          timeout: 5,
-        },
-      ],
-    });
+    if (anyAdded) {
+      // Write settings
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      console.log(`Configured hooks in: ${settingsPath}`);
+    }
 
-    // Write settings
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-    console.log(`Configured hook in: ${settingsPath}`);
     return true;
   } catch {
     // If we can't configure automatically, return false so manual instructions are shown
@@ -2689,9 +3343,31 @@ function ensureClaudeHookConfig() {
 
 /**
  * @param {string | null | undefined} session
- * @param {{all?: boolean}} [options]
+ * @param {{all?: boolean, orphans?: boolean, force?: boolean}} [options]
  */
-function cmdKill(session, { all = false } = {}) {
+function cmdKill(session, { all = false, orphans = false, force = false } = {}) {
+  // Handle orphaned processes
+  if (orphans) {
+    const orphanedProcesses = findOrphanedProcesses();
+
+    if (orphanedProcesses.length === 0) {
+      console.log("No orphaned processes found");
+      return;
+    }
+
+    const signal = force ? "-9" : "-15"; // SIGKILL vs SIGTERM
+    let killed = 0;
+    for (const { pid, command } of orphanedProcesses) {
+      const result = spawnSync("kill", [signal, pid]);
+      if (result.status === 0) {
+        console.log(`Killed: PID ${pid} (${command.slice(0, 40)})`);
+        killed++;
+      }
+    }
+    console.log(`Killed ${killed} orphaned process(es)${force ? " (forced)" : ""}`);
+    return;
+  }
+
   // If specific session provided, kill just that one
   if (session) {
     if (!tmuxHasSession(session)) {
@@ -2751,7 +3427,9 @@ function cmdAttach(session) {
   }
 
   // Hand over to tmux attach
-  const result = spawnSync("tmux", ["attach", "-t", resolved], { stdio: "inherit" });
+  const result = spawnSync("tmux", ["attach", "-t", resolved], {
+    stdio: "inherit",
+  });
   process.exit(result.status || 0);
 }
 
@@ -2810,13 +3488,15 @@ function cmdLog(sessionName, { tail = 50, reasoning = false, follow = false } =
 
     if (newLines.length === 0) return;
 
-    const entries = newLines.map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    }).filter(Boolean);
+    const entries = newLines
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
 
     const output = [];
     if (isInitial) {
@@ -2829,7 +3509,10 @@ function cmdLog(sessionName, { tail = 50, reasoning = false, follow = false } =
         const ts = entry.timestamp || entry.ts || entry.createdAt;
         if (ts && ts !== lastTimestamp) {
           const date = new Date(ts);
-          const timeStr = date.toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
+          const timeStr = date.toLocaleTimeString("en-GB", {
+            hour: "2-digit",
+            minute: "2-digit",
+          });
           if (formatted.isUserMessage) {
             output.push(`\n### ${timeStr}\n`);
           }
@@ -2879,7 +3562,10 @@ function formatLogEntry(entry, { reasoning = false } = {}) {
   if (type === "user" || type === "human") {
     const text = extractTextContent(content);
     if (text) {
-      return { text: `**User**: ${truncate(text, TRUNCATE_USER_LEN)}\n`, isUserMessage: true };
+      return {
+        text: `**User**: ${truncate(text, TRUNCATE_USER_LEN)}\n`,
+        isUserMessage: true,
+      };
     }
   }
 
@@ -2895,10 +3581,12 @@ function formatLogEntry(entry, { reasoning = false } = {}) {
     // Extract tool calls (compressed)
     const tools = extractToolCalls(content);
     if (tools.length > 0) {
-      const toolSummary = tools.map((t) => {
-        if (t.error) return `${t.name}(${t.target}) ✗`;
-        return `${t.name}(${t.target})`;
-      }).join(", ");
+      const toolSummary = tools
+        .map((t) => {
+          if (t.error) return `${t.name}(${t.target}) ✗`;
+          return `${t.name}(${t.target})`;
+        })
+        .join(", ");
       parts.push(`> ${toolSummary}\n`);
     }
 
@@ -2920,7 +3608,10 @@ function formatLogEntry(entry, { reasoning = false } = {}) {
     const error = entry.error || entry.is_error;
     if (error) {
       const name = entry.tool_name || entry.name || "tool";
-      return { text: `> ${name} ✗ (${truncate(String(error), 100)})\n`, isUserMessage: false };
+      return {
+        text: `> ${name} ✗ (${truncate(String(error), 100)})\n`,
+        isUserMessage: false,
+      };
     }
   }
 
@@ -2957,7 +3648,8 @@ function extractToolCalls(content) {
       const name = c.name || c.tool || "tool";
       const input = c.input || c.arguments || {};
       // Extract a reasonable target from the input
-      const target = input.file_path || input.path || input.command?.slice(0, 30) || input.pattern || "";
+      const target =
+        input.file_path || input.path || input.command?.slice(0, 30) || input.pattern || "";
       const shortTarget = target.split("/").pop() || target.slice(0, 20);
       return { name, target: shortTarget, error: c.error };
     });
@@ -3002,8 +3694,14 @@ function cmdMailbox({ limit = 20, branch = null, all = false } = {}) {
 
   for (const entry of entries) {
     const ts = new Date(entry.timestamp);
-    const timeStr = ts.toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
-    const dateStr = ts.toLocaleDateString("en-GB", { month: "short", day: "numeric" });
+    const timeStr = ts.toLocaleTimeString("en-GB", {
+      hour: "2-digit",
+      minute: "2-digit",
+    });
+    const dateStr = ts.toLocaleDateString("en-GB", {
+      month: "short",
+      day: "numeric",
+    });
     const p = entry.payload || {};
 
     console.log(`### [${p.agent || "unknown"}] ${dateStr} ${timeStr}\n`);
@@ -3032,7 +3730,7 @@ function cmdMailbox({ limit = 20, branch = null, all = false } = {}) {
  * @param {string} message
  * @param {{noWait?: boolean, yolo?: boolean, timeoutMs?: number}} [options]
  */
-async function cmdAsk(agent, session, message, { noWait = false, yolo = false, timeoutMs } = {}) {
+async function cmdAsk(agent, session, message, { noWait = false, yolo = false, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
   const sessionExists = session != null && tmuxHasSession(session);
   const nativeYolo = sessionExists && isYoloSession(/** @type {string} */ (session));
 
@@ -3044,20 +3742,31 @@ async function cmdAsk(agent, session, message, { noWait = false, yolo = false, t
   }
 
   /** @type {string} */
-  const activeSession = sessionExists ? /** @type {string} */ (session) : await cmdStart(agent, session, { yolo });
+  const activeSession = sessionExists
+    ? /** @type {string} */ (session)
+    : await cmdStart(agent, session, { yolo });
 
   tmuxSendLiteral(activeSession, message);
   await sleep(50);
   tmuxSend(activeSession, "Enter");
 
-  if (noWait) return;
+  if (noWait) {
+    const parsed = parseSessionName(activeSession);
+    const shortId = parsed?.uuid?.slice(0, 8) || activeSession;
+    const cli = path.basename(process.argv[1], ".js");
+    console.log(`Sent to: ${shortId}
+
+e.g.
+  ${cli} status --session=${shortId}
+  ${cli} output --session=${shortId}`);
+    return;
+  }
 
-  // Yolo mode on a safe session: auto-approve until done
   const useAutoApprove = yolo && !nativeYolo;
 
   const { state, screen } = useAutoApprove
-    ? await autoApproveLoop(agent, activeSession, timeoutMs)
-    : await waitForResponse(agent, activeSession, timeoutMs);
+    ? await autoApproveLoop(agent, activeSession, timeoutMs, streamResponse)
+    : await streamResponse(agent, activeSession, timeoutMs);
 
   if (state === State.RATE_LIMITED) {
     console.log(`RATE_LIMITED: ${agent.parseRetryTime(screen)}`);
@@ -3065,14 +3774,9 @@ async function cmdAsk(agent, session, message, { noWait = false, yolo = false, t
   }
 
   if (state === State.CONFIRMING) {
-    console.log(`CONFIRM: ${agent.parseAction(screen)}`);
+    console.log(`CONFIRM: ${formatConfirmationOutput(screen, agent)}`);
     process.exit(3);
   }
-
-  const output = agent.getResponse(activeSession, screen);
-  if (output) {
-    console.log(output);
-  }
 }
 
 /**
@@ -3087,9 +3791,10 @@ async function cmdApprove(agent, session, { wait = false, timeoutMs } = {}) {
   }
 
   const before = tmuxCapture(session);
-  if (agent.getState(before) !== State.CONFIRMING) {
-    console.log("ERROR: not confirming");
-    process.exit(1);
+  const beforeState = agent.getState(before);
+  if (beforeState !== State.CONFIRMING) {
+    console.log(`Already ${beforeState}`);
+    return;
   }
 
   tmuxSend(session, agent.approveKey);
@@ -3104,7 +3809,7 @@ async function cmdApprove(agent, session, { wait = false, timeoutMs } = {}) {
   }
 
   if (state === State.CONFIRMING) {
-    console.log(`CONFIRM: ${agent.parseAction(screen)}`);
+    console.log(`CONFIRM: ${formatConfirmationOutput(screen, agent)}`);
     process.exit(3);
   }
 
@@ -3123,6 +3828,13 @@ async function cmdReject(agent, session, { wait = false, timeoutMs } = {}) {
     process.exit(1);
   }
 
+  const before = tmuxCapture(session);
+  const beforeState = agent.getState(before);
+  if (beforeState !== State.CONFIRMING) {
+    console.log(`Already ${beforeState}`);
+    return;
+  }
+
   tmuxSend(session, agent.rejectKey);
 
   if (!wait) return;
@@ -3145,7 +3857,13 @@ async function cmdReject(agent, session, { wait = false, timeoutMs } = {}) {
  * @param {string | null | undefined} customInstructions
  * @param {{wait?: boolean, yolo?: boolean, fresh?: boolean, timeoutMs?: number}} [options]
  */
-async function cmdReview(agent, session, option, customInstructions, { wait = true, yolo = true, fresh = false, timeoutMs = REVIEW_TIMEOUT_MS } = {}) {
+async function cmdReview(
+  agent,
+  session,
+  option,
+  customInstructions,
+  { wait = true, yolo = false, fresh = false, timeoutMs = REVIEW_TIMEOUT_MS } = {},
+) {
   const sessionExists = session != null && tmuxHasSession(session);
 
   // Reset conversation if --fresh and session exists
@@ -3171,7 +3889,11 @@ async function cmdReview(agent, session, option, customInstructions, { wait = tr
 
   // AX_REVIEW_MODE=exec: bypass /review command, send instructions directly
   if (process.env.AX_REVIEW_MODE === "exec" && option === "custom" && customInstructions) {
-    return cmdAsk(agent, session, customInstructions, { noWait: !wait, yolo, timeoutMs });
+    return cmdAsk(agent, session, customInstructions, {
+      noWait: !wait,
+      yolo,
+      timeoutMs,
+    });
   }
   const nativeYolo = sessionExists && isYoloSession(/** @type {string} */ (session));
 
@@ -3183,7 +3905,9 @@ async function cmdReview(agent, session, option, customInstructions, { wait = tr
   }
 
   /** @type {string} */
-  const activeSession = sessionExists ? /** @type {string} */ (session) : await cmdStart(agent, session, { yolo });
+  const activeSession = sessionExists
+    ? /** @type {string} */ (session)
+    : await cmdStart(agent, session, { yolo });
 
   tmuxSendLiteral(activeSession, "/review");
   await sleep(50);
@@ -3205,12 +3929,11 @@ async function cmdReview(agent, session, option, customInstructions, { wait = tr
 
   if (!wait) return;
 
-  // Yolo mode on a safe session: auto-approve until done
   const useAutoApprove = yolo && !nativeYolo;
 
   const { state, screen } = useAutoApprove
-    ? await autoApproveLoop(agent, activeSession, timeoutMs)
-    : await waitForResponse(agent, activeSession, timeoutMs);
+    ? await autoApproveLoop(agent, activeSession, timeoutMs, streamResponse)
+    : await streamResponse(agent, activeSession, timeoutMs);
 
   if (state === State.RATE_LIMITED) {
     console.log(`RATE_LIMITED: ${agent.parseRetryTime(screen)}`);
@@ -3218,12 +3941,9 @@ async function cmdReview(agent, session, option, customInstructions, { wait = tr
   }
 
   if (state === State.CONFIRMING) {
-    console.log(`CONFIRM: ${agent.parseAction(screen)}`);
+    console.log(`CONFIRM: ${formatConfirmationOutput(screen, agent)}`);
     process.exit(3);
   }
-
-  const response = agent.getResponse(activeSession, screen);
-  console.log(response || "");
 }
 
 /**
@@ -3254,7 +3974,7 @@ async function cmdOutput(agent, session, index = 0, { wait = false, timeoutMs }
   }
 
   if (state === State.CONFIRMING) {
-    console.log(`CONFIRM: ${agent.parseAction(screen)}`);
+    console.log(`CONFIRM: ${formatConfirmationOutput(screen, agent)}`);
     process.exit(3);
   }
 
@@ -3266,6 +3986,8 @@ async function cmdOutput(agent, session, index = 0, { wait = false, timeoutMs }
   const output = agent.getResponse(session, screen, index);
   if (output) {
     console.log(output);
+  } else {
+    console.log("READY_NO_CONTENT");
   }
 }
 
@@ -3288,7 +4010,7 @@ function cmdStatus(agent, session) {
   }
 
   if (state === State.CONFIRMING) {
-    console.log(`CONFIRM: ${agent.parseAction(screen)}`);
+    console.log(`CONFIRM: ${formatConfirmationOutput(screen, agent)}`);
     process.exit(3);
   }
 
@@ -3296,6 +4018,10 @@ function cmdStatus(agent, session) {
     console.log("THINKING");
     process.exit(4);
   }
+
+  // READY (or STARTING/UPDATE_PROMPT which are transient)
+  console.log("READY");
+  process.exit(0);
 }
 
 /**
@@ -3409,7 +4135,7 @@ async function cmdSelect(agent, session, n, { wait = false, timeoutMs } = {}) {
   }
 
   if (state === State.CONFIRMING) {
-    console.log(`CONFIRM: ${agent.parseAction(screen)}`);
+    console.log(`CONFIRM: ${formatConfirmationOutput(screen, agent)}`);
     process.exit(3);
   }
 
@@ -3422,20 +4148,43 @@ async function cmdSelect(agent, session, n, { wait = false, timeoutMs } = {}) {
 // =============================================================================
 
 /**
- * @returns {Agent}
+ * Resolve the agent to use based on (in priority order):
+ * 1. Explicit --tool flag
+ * 2. Session name (e.g., "claude-archangel-..." → ClaudeAgent)
+ * 3. CLI invocation name (axclaude, axcodex)
+ * 4. AX_DEFAULT_TOOL environment variable
+ * 5. Default to CodexAgent
+ *
+ * @param {{toolFlag?: string, sessionName?: string | null}} options
+ * @returns {{agent: Agent, error?: string}}
  */
-function getAgentFromInvocation() {
+function resolveAgent({ toolFlag, sessionName } = {}) {
+  // 1. Explicit --tool flag takes highest priority
+  if (toolFlag) {
+    if (toolFlag === "claude") return { agent: ClaudeAgent };
+    if (toolFlag === "codex") return { agent: CodexAgent };
+    return { agent: CodexAgent, error: `unknown tool '${toolFlag}'` };
+  }
+
+  // 2. Infer from session name (e.g., "claude-archangel-..." or "codex-partner-...")
+  if (sessionName) {
+    const parsed = parseSessionName(sessionName);
+    if (parsed?.tool === "claude") return { agent: ClaudeAgent };
+    if (parsed?.tool === "codex") return { agent: CodexAgent };
+  }
+
+  // 3. CLI invocation name
   const invoked = path.basename(process.argv[1], ".js");
-  if (invoked === "axclaude" || invoked === "claude") return ClaudeAgent;
-  if (invoked === "axcodex" || invoked === "codex") return CodexAgent;
+  if (invoked === "axclaude" || invoked === "claude") return { agent: ClaudeAgent };
+  if (invoked === "axcodex" || invoked === "codex") return { agent: CodexAgent };
 
-  // Default based on AX_DEFAULT_TOOL env var, or codex if not set
+  // 4. AX_DEFAULT_TOOL environment variable
   const defaultTool = process.env.AX_DEFAULT_TOOL;
-  if (defaultTool === "claude") return ClaudeAgent;
-  if (defaultTool === "codex" || !defaultTool) return CodexAgent;
+  if (defaultTool === "claude") return { agent: ClaudeAgent };
+  if (defaultTool === "codex" || !defaultTool) return { agent: CodexAgent };
 
   console.error(`WARNING: invalid AX_DEFAULT_TOOL="${defaultTool}", using codex`);
-  return CodexAgent;
+  return { agent: CodexAgent };
 }
 
 /**
@@ -3444,23 +4193,30 @@ function getAgentFromInvocation() {
  */
 function printHelp(agent, cliName) {
   const name = cliName;
-  const backendName = agent.name === "codex" ? "OpenAI Codex" : "Claude";
+  const backendName = agent.displayName;
   const hasReview = !!agent.reviewOptions;
 
-  console.log(`${name}.js - agentic assistant CLI (${backendName})
+  console.log(`${name} v${VERSION} - agentic assistant CLI (${backendName})
+
+Usage: ${name} [OPTIONS] <command|message> [ARGS...]
 
 Commands:
   agents                    List all running agents with state and log paths
+  target                    Show default target session for current tool
   attach [SESSION]          Attach to agent session interactively
   log SESSION               View conversation log (--tail=N, --follow, --reasoning)
-  mailbox                   View daemon observations (--limit=N, --branch=X, --all)
-  daemons start [name]      Start daemon agents (all, or by name)
-  daemons stop [name]       Stop daemon agents (all, or by name)
-  kill                      Kill sessions in current project (--all for all, --session=NAME for one)
+  mailbox                   View archangel observations (--limit=N, --branch=X, --all)
+  summon [name]             Summon archangels (all, or by name)
+  recall [name]             Recall archangels (all, or by name)
+  kill                      Kill sessions (--all, --session=NAME, --orphans [--force])
   status                    Check state (exit: 0=ready, 2=rate_limited, 3=confirming, 4=thinking)
   output [-N]               Show response (0=last, -1=prev, -2=older)
-  debug                     Show raw screen output and detected state${hasReview ? `
-  review [TYPE]             Review code: pr, uncommitted, commit, custom` : ""}
+  debug                     Show raw screen output and detected state${
+    hasReview
+      ? `
+  review [TYPE]             Review code: pr, uncommitted, commit, custom`
+      : ""
+  }
   select N                  Select menu option N
   approve                   Approve pending action (send 'y')
   reject                    Reject pending action (send 'n')
@@ -3471,37 +4227,42 @@ Commands:
 
 Flags:
   --tool=NAME               Use specific agent (codex, claude)
-  --session=NAME            Target session by name, daemon name, or UUID prefix (self = current)
-  --wait                    Wait for response (for review, approve, etc)
-  --no-wait                 Don't wait (for messages, which wait by default)
-  --timeout=N               Set timeout in seconds (default: 120)
+  --session=NAME            Target session by name, archangel name, or UUID prefix (self = current)
+  --wait                    Wait for response (default for messages; required for approve/reject)
+  --no-wait                 Fire-and-forget: send message, print session ID, exit immediately
+  --timeout=N               Set timeout in seconds (default: ${DEFAULT_TIMEOUT_MS / 1000}, reviews: ${REVIEW_TIMEOUT_MS / 1000})
   --yolo                    Skip all confirmations (dangerous)
   --fresh                   Reset conversation before review
+  --orphans                 Kill orphaned claude/codex processes (PPID=1)
+  --force                   Use SIGKILL instead of SIGTERM (with --orphans)
 
 Environment:
-  AX_DEFAULT_TOOL             Default agent when using 'ax' (claude or codex, default: codex)
-  ${agent.envVar}             Override default session name
-  AX_CLAUDE_CONFIG_DIR        Override Claude config directory (default: ~/.claude)
-  AX_CODEX_CONFIG_DIR         Override Codex config directory (default: ~/.codex)
-  AX_REVIEW_MODE=exec         Bypass /review, send instructions directly (codex only)
-  AX_DEBUG=1                  Enable debug logging
+  AX_DEFAULT_TOOL           Default agent when using 'ax' (claude or codex, default: codex)
+  ${agent.envVar}           Override default session name
+  AX_CLAUDE_CONFIG_DIR      Override Claude config directory (default: ~/.claude)
+  AX_CODEX_CONFIG_DIR       Override Codex config directory (default: ~/.codex)
+  AX_REVIEW_MODE=exec       Bypass /review, send instructions directly (codex only)
+  AX_DEBUG=1                Enable debug logging
 
 Examples:
-  ./${name}.js "explain this codebase"
-  ./${name}.js "please review the error handling"   # Auto custom review
-  ./${name}.js review uncommitted --wait
-  ./${name}.js approve --wait
-  ./${name}.js kill                       # Kill agents in current project
-  ./${name}.js kill --all                 # Kill all agents across all projects
-  ./${name}.js kill --session=NAME        # Kill specific session
-  ./${name}.js send "1[Enter]"            # Recovery: select option 1 and press Enter
-  ./${name}.js send "[Escape][Escape]"    # Recovery: escape out of a dialog
-
-Daemon Agents:
-  ./${name}.js daemons start              # Start all daemons from .ai/agents/*.md
-  ./${name}.js daemons stop               # Stop all daemons
-  ./${name}.js daemons init <name>        # Create new daemon config
-  ./${name}.js agents                     # List all agents (shows TYPE=daemon)`);
+  ${name} "explain this codebase"
+  ${name} "review the error handling"           # Auto custom review (${REVIEW_TIMEOUT_MS / 60000}min timeout)
+  ${name} "FYI: auth was refactored" --no-wait  # Send context to a working session (no response needed)
+  ${name} review uncommitted --wait
+  ${name} approve --wait
+  ${name} kill                                 # Kill agents in current project
+  ${name} kill --all                           # Kill all agents across all projects
+  ${name} kill --session=NAME                  # Kill specific session
+  ${name} send "1[Enter]"                      # Recovery: select option 1 and press Enter
+  ${name} send "[Escape][Escape]"              # Recovery: escape out of a dialog
+  ${name} summon                               # Summon all archangels from .ai/agents/*.md
+  ${name} summon reviewer                      # Summon by name (creates config if new)
+  ${name} recall                               # Recall all archangels
+  ${name} recall reviewer                      # Recall one by name
+  ${name} agents                               # List all agents (shows TYPE=archangel)
+
+Note: Reviews and complex tasks may take several minutes.
+      Use Bash run_in_background for long operations (not --no-wait).`);
 }
 
 async function main() {
@@ -3516,33 +4277,21 @@ async function main() {
   const args = process.argv.slice(2);
   const cliName = path.basename(process.argv[1], ".js");
 
-  // Parse flags
-  const wait = args.includes("--wait");
-  const noWait = args.includes("--no-wait");
-  const yolo = args.includes("--yolo");
-  const fresh = args.includes("--fresh");
-  const reasoning = args.includes("--reasoning");
-  const follow = args.includes("--follow") || args.includes("-f");
-
-  // Agent selection
-  let agent = getAgentFromInvocation();
-  const toolArg = args.find((a) => a.startsWith("--tool="));
-  if (toolArg) {
-    const tool = toolArg.split("=")[1];
-    if (tool === "claude") agent = ClaudeAgent;
-    else if (tool === "codex") agent = CodexAgent;
-    else {
-      console.log(`ERROR: unknown tool '${tool}'`);
-      process.exit(1);
-    }
+  // Parse all flags and positionals in one place
+  const { flags, positionals } = parseCliArgs(args);
+
+  if (flags.version) {
+    console.log(VERSION);
+    process.exit(0);
   }
 
-  // Session resolution
-  let session = agent.getDefaultSession();
-  const sessionArg = args.find((a) => a.startsWith("--session="));
-  if (sessionArg) {
-    const val = sessionArg.split("=")[1];
-    if (val === "self") {
+  // Extract flags into local variables for convenience
+  const { wait, noWait, yolo, fresh, reasoning, follow, all, orphans, force } = flags;
+
+  // Session resolution (must happen before agent resolution so we can infer tool from session name)
+  let session = null;
+  if (flags.session) {
+    if (flags.session === "self") {
       const current = tmuxCurrentSession();
       if (!current) {
         console.log("ERROR: --session=self requires running inside tmux");
@@ -3550,99 +4299,106 @@ async function main() {
       }
       session = current;
     } else {
-      // Resolve partial names, daemon names, and UUID prefixes
-      session = resolveSessionName(val);
+      // Resolve partial names, archangel names, and UUID prefixes
+      session = resolveSessionName(flags.session);
     }
   }
 
-  // Timeout
+  // Agent resolution (considers --tool flag, session name, invocation, and env vars)
+  const { agent, error: agentError } = resolveAgent({ toolFlag: flags.tool, sessionName: session });
+  if (agentError) {
+    console.log(`ERROR: ${agentError}`);
+    process.exit(1);
+  }
+
+  // If no explicit session, use agent's default
+  if (!session) {
+    session = agent.getDefaultSession();
+  }
+
+  // Timeout (convert seconds to milliseconds)
   let timeoutMs = DEFAULT_TIMEOUT_MS;
-  const timeoutArg = args.find((a) => a.startsWith("--timeout="));
-  if (timeoutArg) {
-    const val = parseInt(timeoutArg.split("=")[1], 10);
-    if (isNaN(val) || val <= 0) {
+  if (flags.timeout !== undefined) {
+    if (isNaN(flags.timeout) || flags.timeout <= 0) {
       console.log("ERROR: invalid timeout");
       process.exit(1);
     }
-    timeoutMs = val * 1000;
+    timeoutMs = flags.timeout * 1000;
   }
 
   // Tail (for log command)
-  let tail = 50;
-  const tailArg = args.find((a) => a.startsWith("--tail="));
-  if (tailArg) {
-    tail = parseInt(tailArg.split("=")[1], 10) || 50;
-  }
+  const tail = flags.tail ?? 50;
 
   // Limit (for mailbox command)
-  let limit = 20;
-  const limitArg = args.find((a) => a.startsWith("--limit="));
-  if (limitArg) {
-    limit = parseInt(limitArg.split("=")[1], 10) || 20;
-  }
+  const limit = flags.limit ?? 20;
 
   // Branch filter (for mailbox command)
-  let branch = null;
-  const branchArg = args.find((a) => a.startsWith("--branch="));
-  if (branchArg) {
-    branch = branchArg.split("=")[1] || null;
-  }
-
-  // All flag (for mailbox command - show all regardless of age)
-  const all = args.includes("--all");
-
-  // Filter out flags
-  const filteredArgs = args.filter(
-    (a) =>
-      !["--wait", "--no-wait", "--yolo", "--reasoning", "--follow", "-f", "--all"].includes(a) &&
-      !a.startsWith("--timeout") &&
-      !a.startsWith("--session") &&
-      !a.startsWith("--tool") &&
-      !a.startsWith("--tail") &&
-      !a.startsWith("--limit") &&
-      !a.startsWith("--branch")
-  );
-  const cmd = filteredArgs[0];
+  const branch = flags.branch ?? null;
+
+  // Command is first positional
+  const cmd = positionals[0];
 
   // Dispatch commands
   if (cmd === "agents") return cmdAgents();
-  if (cmd === "daemons") return cmdDaemons(filteredArgs[1], filteredArgs[2]);
-  if (cmd === "daemon") return cmdDaemon(filteredArgs[1]);
-  if (cmd === "kill") return cmdKill(session, { all });
-  if (cmd === "attach") return cmdAttach(filteredArgs[1] || session);
-  if (cmd === "log") return cmdLog(filteredArgs[1] || session, { tail, reasoning, follow });
+  if (cmd === "target") {
+    const defaultSession = agent.getDefaultSession();
+    if (defaultSession) {
+      console.log(defaultSession);
+    } else {
+      console.log("NO_TARGET");
+      process.exit(1);
+    }
+    return;
+  }
+  if (cmd === "summon") return cmdSummon(positionals[1]);
+  if (cmd === "recall") return cmdRecall(positionals[1]);
+  if (cmd === "archangel") return cmdArchangel(positionals[1]);
+  if (cmd === "kill") return cmdKill(session, { all, orphans, force });
+  if (cmd === "attach") return cmdAttach(positionals[1] || session);
+  if (cmd === "log") return cmdLog(positionals[1] || session, { tail, reasoning, follow });
   if (cmd === "mailbox") return cmdMailbox({ limit, branch, all });
   if (cmd === "approve") return cmdApprove(agent, session, { wait, timeoutMs });
   if (cmd === "reject") return cmdReject(agent, session, { wait, timeoutMs });
-  if (cmd === "review") return cmdReview(agent, session, filteredArgs[1], filteredArgs[2], { wait, yolo, fresh, timeoutMs });
+  if (cmd === "review")
+    return cmdReview(agent, session, positionals[1], positionals[2], {
+      wait,
+      fresh,
+      timeoutMs,
+    });
   if (cmd === "status") return cmdStatus(agent, session);
   if (cmd === "debug") return cmdDebug(agent, session);
   if (cmd === "output") {
-    const indexArg = filteredArgs[1];
+    const indexArg = positionals[1];
     const index = indexArg?.startsWith("-") ? parseInt(indexArg, 10) : 0;
     return cmdOutput(agent, session, index, { wait, timeoutMs });
   }
-  if (cmd === "send" && filteredArgs.length > 1) return cmdSend(session, filteredArgs.slice(1).join(" "));
+  if (cmd === "send" && positionals.length > 1)
+    return cmdSend(session, positionals.slice(1).join(" "));
   if (cmd === "compact") return cmdAsk(agent, session, "/compact", { noWait: true, timeoutMs });
   if (cmd === "reset") return cmdAsk(agent, session, "/new", { noWait: true, timeoutMs });
-  if (cmd === "select" && filteredArgs[1]) return cmdSelect(agent, session, filteredArgs[1], { wait, timeoutMs });
+  if (cmd === "select" && positionals[1])
+    return cmdSelect(agent, session, positionals[1], { wait, timeoutMs });
 
   // Default: send message
-  let message = filteredArgs.join(" ");
+  let message = positionals.join(" ");
   if (!message && hasStdinData()) {
     message = await readStdin();
   }
 
-  if (!message || cmd === "--help" || cmd === "-h") {
+  if (!message || flags.help) {
     printHelp(agent, cliName);
     process.exit(0);
   }
 
-  // Detect "please review" and route to custom review mode
-  const reviewMatch = message.match(/^please review\s*(.*)/i);
+  // Detect "review ..." or "please review ..." and route to custom review mode
+  const reviewMatch = message.match(/^(?:please )?review\s*(.*)/i);
   if (reviewMatch && agent.reviewOptions) {
     const customInstructions = reviewMatch[1].trim() || null;
-    return cmdReview(agent, session, "custom", customInstructions, { wait: !noWait, yolo, timeoutMs });
+    return cmdReview(agent, session, "custom", customInstructions, {
+      wait: !noWait,
+      yolo,
+      timeoutMs: flags.timeout !== undefined ? timeoutMs : REVIEW_TIMEOUT_MS,
+    });
   }
 
   return cmdAsk(agent, session, message, { noWait, yolo, timeoutMs });
@@ -3650,17 +4406,21 @@ async function main() {
 
 // Run main() only when executed directly (not when imported for testing)
 // Use realpathSync to handle symlinks (e.g., axclaude, axcodex bin entries)
-const __filename = fileURLToPath(import.meta.url);
-const isDirectRun = process.argv[1] && (() => {
-  try {
-    return realpathSync(process.argv[1]) === __filename;
-  } catch {
-    return false;
-  }
-})();
+const isDirectRun =
+  process.argv[1] &&
+  (() => {
+    try {
+      return realpathSync(process.argv[1]) === __filename;
+    } catch {
+      return false;
+    }
+  })();
 if (isDirectRun) {
   main().catch((err) => {
     console.log(`ERROR: ${err.message}`);
+    if (err instanceof TimeoutError && err.session) {
+      console.log(`Hint: Use 'ax debug --session=${err.session}' to see current screen state`);
+    }
     process.exit(1);
   });
 }
@@ -3670,6 +4430,7 @@ export {
   parseSessionName,
   parseAgentConfig,
   parseKeySequence,
+  parseCliArgs,
   getClaudeProjectPath,
   matchesPattern,
   getBaseDir,
@@ -3681,4 +4442,3 @@ export {
   detectState,
   State,
 };
-