rex-claude 4.0.0 → 6.0.0

package/dist/agents-JIZXXASP.js

@@ -0,0 +1,853 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/agents.ts
+import { homedir } from "os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "fs";
+import { join } from "path";
+import { spawn, execSync } from "child_process";
+var HOME = homedir();
+var ROOT_DIR = join(HOME, ".claude", "rex", "agents");
+var STORE_FILE = join(ROOT_DIR, "agents.json");
+var LOGS_DIR = join(ROOT_DIR, "logs");
+var RUNTIME_DIR = join(ROOT_DIR, "runtime");
+var OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m"
+};
+var PROFILE_TEMPLATES = {
+  scout: {
+    prompt: "You are a codebase scout. Read files, analyze structure, identify issues, and report findings. Do NOT modify any files.",
+    allowedTools: ["Read", "Glob", "Grep", "Bash(ls *)", "Bash(git *)"],
+    maxTurns: 10,
+    model: "claude",
+    intervalSec: 0
+    // one-shot by default
+  },
+  reviewer: {
+    prompt: "You are a strict code reviewer. Analyze recent changes, find bugs, security issues, missing tests. Report with file:line references and severity. Do NOT modify files.",
+    allowedTools: ["Read", "Glob", "Grep", "Bash(git *)", "Bash(npm test *)", "Bash(pnpm test *)"],
+    maxTurns: 20,
+    model: "claude",
+    intervalSec: 0
+  },
+  fixer: {
+    prompt: "You are an autonomous bug fixer. Identify the bug, understand root cause, implement the fix, verify it compiles/passes tests. Create a git commit when done.",
+    allowedTools: ["Read", "Edit", "Write", "Glob", "Grep", "Bash"],
+    maxTurns: 30,
+    model: "claude",
+    intervalSec: 0
+  },
+  architect: {
+    prompt: "You are a senior architect. Analyze the full codebase, identify tech debt, propose refactoring plans, check for scalability issues. Write a report to docs/audit.md.",
+    allowedTools: ["Read", "Write", "Glob", "Grep", "Bash(git *)", "Bash(wc *)", "Bash(cloc *)"],
+    maxTurns: 40,
+    model: "claude",
+    intervalSec: 0
+  },
+  worker: {
+    prompt: "You are an autonomous worker. Execute the assigned task end-to-end: plan, implement, test, verify. If something fails, debug and retry. Do not stop until the task is complete or you have exhausted all approaches.",
+    allowedTools: ["Read", "Edit", "Write", "Glob", "Grep", "Bash"],
+    maxTurns: 50,
+    model: "claude",
+    intervalSec: 0
+  },
+  monitor: {
+    prompt: "You are a system monitor. Check health of services, verify builds pass, check for stale branches, report anomalies. Run periodically.",
+    allowedTools: ["Read", "Glob", "Grep", "Bash(git *)", "Bash(curl *)", "Bash(rex *)"],
+    maxTurns: 15,
+    model: "claude",
+    intervalSec: 3600
+    // hourly
+  },
+  watchdog: {
+    prompt: `You are the REX Watchdog. Monitor system health and fix issues automatically.
+Check: 1) rex ingest runs and captures new sessions (delta ingest for growing files)
+2) Ollama is running for embeddings 3) LaunchAgents are loaded 4) Memory DB is not corrupted.
+If ingest is behind, run "rex ingest" to catch up. If Ollama is down, try "ollama serve".
+Report what you checked and any actions taken.`,
+    allowedTools: ["Read", "Bash(rex *)", "Bash(ollama *)", "Bash(launchctl *)", "Bash(ps *)", "Bash(curl *)"],
+    maxTurns: 15,
+    model: "claude",
+    intervalSec: 1800
+    // every 30 min
+  },
+  "local-analyst": {
+    prompt: "Analyze the project and provide insights on architecture, patterns, and potential improvements.",
+    allowedTools: [],
+    maxTurns: 1,
+    model: "local",
+    intervalSec: 0
+  },
+  orchestrator: {
+    prompt: `You are the REX Orchestrator (Opus). You supervise all agents, detect loops/crashes, and coordinate work.
+You know all agent profiles and can create, start, stop, and monitor agents.
+Use local LLM (Ollama) for simple tasks and Claude for complex ones.
+If an agent fails 3 times consecutively, stop it and alert.
+Always explain what you are doing and why.`,
+    allowedTools: ["Read", "Edit", "Write", "Glob", "Grep", "Bash"],
+    maxTurns: 100,
+    model: "claude",
+    intervalSec: 0
+  }
+};
+function ensureDirs() {
+  for (const d of [ROOT_DIR, LOGS_DIR, RUNTIME_DIR]) {
+    if (!existsSync(d)) mkdirSync(d, { recursive: true });
+  }
+}
+function readStore() {
+  ensureDirs();
+  try {
+    if (existsSync(STORE_FILE)) {
+      const parsed = JSON.parse(readFileSync(STORE_FILE, "utf-8"));
+      if (Array.isArray(parsed.agents)) return parsed;
+    }
+  } catch {
+  }
+  return { agents: [] };
+}
+function writeStore(store) {
+  ensureDirs();
+  writeFileSync(STORE_FILE, JSON.stringify(store, null, 2));
+}
+function runtimePath(id) {
+  return join(RUNTIME_DIR, `${id}.json`);
+}
+function readRuntime(id) {
+  try {
+    const p = runtimePath(id);
+    if (existsSync(p)) return JSON.parse(readFileSync(p, "utf-8"));
+  } catch {
+  }
+  return { id, pid: null, running: false, consecutiveErrors: 0, currentRetry: 0 };
+}
+function writeRuntime(id, data) {
+  ensureDirs();
+  writeFileSync(runtimePath(id), JSON.stringify(data, null, 2));
+}
+function isPidRunning(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function logPath(id) {
+  return join(LOGS_DIR, `${id}.log`);
+}
+function appendLog(id, text) {
+  ensureDirs();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  appendFileSync(logPath(id), `[${now}] ${text}
+`);
+}
+function slug(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "agent";
+}
+function parseFlag(args, name) {
+  const eqIdx = args.findIndex((a) => a.startsWith(`${name}=`));
+  if (eqIdx >= 0) return args[eqIdx].split("=").slice(1).join("=");
+  const idx = args.findIndex((a) => a === name);
+  if (idx < 0) return null;
+  return args[idx + 1] || null;
+}
+function findAgent(store, idOrName) {
+  return store.agents.find((a) => a.id === idOrName || a.name === idOrName) || null;
+}
+function buildAgentContext(agent) {
+  const parts = [];
+  parts.push("# Agent Context (auto-injected by REX)");
+  parts.push(`Agent: ${agent.name} (${agent.profile})`);
+  parts.push(`Time: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  parts.push(`Run #${agent.totalRuns + 1}`);
+  if (agent.cwd) {
+    const claudeMd = join(agent.cwd, "CLAUDE.md");
+    if (existsSync(claudeMd)) {
+      try {
+        const content = readFileSync(claudeMd, "utf-8").slice(0, 2e3);
+        parts.push(`
+# Project Context (from CLAUDE.md)
+${content}`);
+      } catch {
+      }
+    }
+  }
+  const rt = readRuntime(agent.id);
+  if (rt.lastError) {
+    parts.push(`
+# Previous Run Error (self-correct this)
+${rt.lastError.slice(0, 500)}`);
+  }
+  parts.push("\n# Instructions");
+  parts.push(agent.prompt);
+  parts.push("\n# Rules");
+  parts.push("- Be autonomous: plan, execute, verify, retry if needed.");
+  parts.push("- If a tool call fails, analyze the error and try a different approach.");
+  parts.push("- If stuck after 3 attempts at the same approach, stop and report what you tried.");
+  parts.push("- Always verify your work before declaring done (build, test, or read back).");
+  parts.push("- Be concise in your output. Focus on actions taken and results.");
+  return parts.join("\n");
+}
+function findClaudeCli() {
+  try {
+    const path = execSync("which claude", { encoding: "utf-8", timeout: 5e3 }).trim();
+    return path || null;
+  } catch {
+    return null;
+  }
+}
+async function runWithClaude(agent, task) {
+  const claudePath = findClaudeCli();
+  if (!claudePath) {
+    return { ok: false, output: "", exitCode: 1, duration: 0, toolsUsed: [], turns: 0, error: "Claude CLI not found. Install: npm i -g @anthropic-ai/claude-code" };
+  }
+  const systemPrompt = buildAgentContext(agent);
+  const prompt = task || agent.prompt;
+  const start = Date.now();
+  const args = [
+    "-p",
+    prompt,
+    "--append-system-prompt",
+    systemPrompt,
+    "--output-format",
+    "json",
+    "--max-turns",
+    String(agent.maxTurns)
+  ];
+  if (agent.allowedTools.length > 0) {
+    for (const tool of agent.allowedTools) {
+      args.push("--allowedTools", tool);
+    }
+    args.push("--permission-mode", "acceptEdits");
+  }
+  if (agent.mcpServers && agent.mcpServers.length > 0) {
+    for (const mcp of agent.mcpServers) {
+      args.push("--mcp-server", mcp);
+    }
+  }
+  return new Promise((resolve) => {
+    const cwd = agent.cwd || process.cwd();
+    const env = { ...process.env, CLAUDE_CODE_ENTRYPOINT: "rex-agent" };
+    delete env.CLAUDECODE;
+    delete env.CLAUDE_CODE_SESSION;
+    const agentConfigDir = join(HOME, `.claude-agent-${agent.id}`);
+    if (!existsSync(agentConfigDir)) mkdirSync(agentConfigDir, { recursive: true });
+    env.CLAUDE_CONFIG_DIR = agentConfigDir;
+    const child = spawn(claudePath, args, {
+      cwd,
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 6e5
+      // 10 min max
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      const duration = Date.now() - start;
+      let output = "";
+      let toolsUsed = [];
+      let turns = 0;
+      try {
+        const parsed = JSON.parse(stdout);
+        output = parsed.result || parsed.output || "";
+        turns = parsed.num_turns || 0;
+        if (parsed.tools_used) toolsUsed = parsed.tools_used;
+      } catch {
+        const lines = stdout.trim().split("\n");
+        for (const line of lines.reverse()) {
+          try {
+            const obj = JSON.parse(line);
+            if (obj.result) {
+              output = obj.result;
+              break;
+            }
+            if (obj.type === "result" && obj.result) {
+              output = obj.result;
+              break;
+            }
+          } catch {
+          }
+        }
+        if (!output) output = stdout || stderr;
+      }
+      resolve({
+        ok: code === 0,
+        output: output.slice(0, 1e4),
+        // cap log size
+        exitCode: code,
+        duration,
+        toolsUsed,
+        turns,
+        error: code !== 0 ? (stderr || `Exit code ${code}`).slice(0, 2e3) : void 0
+      });
+    });
+    child.on("error", (err) => {
+      resolve({
+        ok: false,
+        output: "",
+        exitCode: 1,
+        duration: Date.now() - start,
+        toolsUsed: [],
+        turns: 0,
+        error: err.message
+      });
+    });
+  });
+}
+async function runWithOllama(agent, task) {
+  const start = Date.now();
+  const prompt = buildAgentContext(agent) + "\n\nTask: " + (task || agent.prompt);
+  let model = agent.localModel || "qwen3.5:4b";
+  try {
+    const tagsRes = await fetch(`${OLLAMA_URL}/api/tags`, { signal: AbortSignal.timeout(3e3) });
+    if (tagsRes.ok) {
+      const tags = await tagsRes.json();
+      const names = (tags.models || []).map((m) => m.name || "").filter(Boolean);
+      if (!names.includes(model)) {
+        const base = model.split(":")[0];
+        model = names.find((n) => n.includes(base)) || names.find((n) => !n.includes("embed")) || model;
+      }
+    }
+  } catch {
+  }
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model, prompt, stream: false, keep_alive: "30s" }),
+      signal: AbortSignal.timeout(3e5)
+    });
+    if (!res.ok) throw new Error(`Ollama ${res.status}`);
+    const data = await res.json();
+    const output = (data.response || "").trim();
+    return {
+      ok: true,
+      output: output.slice(0, 1e4),
+      exitCode: 0,
+      duration: Date.now() - start,
+      toolsUsed: [],
+      turns: 1
+    };
+  } catch (e) {
+    return {
+      ok: false,
+      output: "",
+      exitCode: 1,
+      duration: Date.now() - start,
+      toolsUsed: [],
+      turns: 0,
+      error: e.message
+    };
+  }
+}
+async function executeAgent(agent, task) {
+  const runner = agent.model === "claude" ? runWithClaude : runWithOllama;
+  let lastResult = { ok: false, output: "", exitCode: 1, duration: 0, toolsUsed: [], turns: 0 };
+  for (let attempt = 0; attempt <= agent.maxRetries; attempt++) {
+    if (attempt > 0) {
+      appendLog(agent.id, `RETRY ${attempt}/${agent.maxRetries} \u2014 self-correcting from: ${lastResult.error?.slice(0, 200)}`);
+      const rt = readRuntime(agent.id);
+      writeRuntime(agent.id, { ...rt, currentRetry: attempt, lastError: lastResult.error || lastResult.output.slice(0, 500) });
+      await new Promise((r) => setTimeout(r, 5e3 * Math.pow(3, attempt - 1)));
+    }
+    lastResult = await runner(agent, task);
+    if (lastResult.ok) {
+      return lastResult;
+    }
+    appendLog(agent.id, `ATTEMPT ${attempt + 1} FAILED (${lastResult.duration}ms): ${lastResult.error?.slice(0, 300)}`);
+  }
+  return lastResult;
+}
+function listAgents(jsonMode) {
+  const store = readStore();
+  const rows = store.agents.map((a) => {
+    const rt = readRuntime(a.id);
+    const running = rt.running && isPidRunning(rt.pid);
+    return { id: a.id, name: a.name, profile: a.profile, model: a.model, enabled: a.enabled, running, lastRunAt: a.lastRunAt || null, totalRuns: a.totalRuns, totalErrors: a.totalErrors, intervalSec: a.intervalSec };
+  });
+  if (jsonMode) {
+    console.log(JSON.stringify({ agents: rows }, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(`No agents. Create one:
+  rex agents create <${Object.keys(PROFILE_TEMPLATES).join("|")}> [name] [--cwd path] [--task "..."]`);
+    return;
+  }
+  const line = "\u2500".repeat(60);
+  console.log(`
+${COLORS.bold}  REX Agents${COLORS.reset}
+${line}`);
+  for (const r of rows) {
+    const status = r.running ? `${COLORS.green}RUNNING${COLORS.reset}` : r.enabled ? `${COLORS.yellow}IDLE${COLORS.reset}` : `${COLORS.dim}DISABLED${COLORS.reset}`;
+    const model = r.model === "claude" ? `${COLORS.magenta}claude${COLORS.reset}` : `${COLORS.cyan}local${COLORS.reset}`;
+    const schedule = r.intervalSec > 0 ? `every ${r.intervalSec}s` : "one-shot";
+    console.log(`  ${status}  ${COLORS.bold}${r.name}${COLORS.reset} (${r.profile}) ${model} \u2014 ${schedule}`);
+    console.log(`  ${COLORS.dim}  id=${r.id} runs=${r.totalRuns} errors=${r.totalErrors} last=${r.lastRunAt || "never"}${COLORS.reset}`);
+  }
+  console.log(line);
+}
+function createAgent(args) {
+  const profile = args[0];
+  if (!profile || !PROFILE_TEMPLATES[profile]) {
+    console.log(`Usage: rex agents create <${Object.keys(PROFILE_TEMPLATES).join("|")}> [name] [--cwd path] [--task "..."] [--model claude|local] [--interval sec] [--team name]`);
+    return;
+  }
+  const template = PROFILE_TEMPLATES[profile];
+  const store = readStore();
+  const nameArg = args[1] && !args[1].startsWith("--") ? args[1] : `${profile}-agent`;
+  const taskOverride = parseFlag(args, "--task");
+  const cwdOverride = parseFlag(args, "--cwd");
+  const modelOverride = parseFlag(args, "--model");
+  const intervalOverride = parseFlag(args, "--interval");
+  const maxTurnsOverride = parseFlag(args, "--max-turns");
+  const maxRetriesOverride = parseFlag(args, "--max-retries");
+  const teamFlag = parseFlag(args, "--team");
+  const mcpFlag = parseFlag(args, "--mcp");
+  const id = `${slug(nameArg)}-${Date.now().toString().slice(-6)}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const cwd = cwdOverride || process.cwd();
+  const agent = {
+    id,
+    name: nameArg,
+    profile,
+    prompt: taskOverride || template.prompt,
+    model: modelOverride || template.model,
+    localModel: modelOverride === "local" ? "qwen3.5:4b" : void 0,
+    cwd,
+    allowedTools: template.allowedTools,
+    maxTurns: parseInt(maxTurnsOverride || String(template.maxTurns), 10),
+    maxRetries: parseInt(maxRetriesOverride || "2", 10),
+    intervalSec: parseInt(intervalOverride || String(template.intervalSec), 10),
+    enabled: true,
+    createdAt: now,
+    updatedAt: now,
+    totalRuns: 0,
+    totalErrors: 0,
+    team: teamFlag || void 0,
+    mcpServers: mcpFlag ? mcpFlag.split(",").map((s) => s.trim()).filter(Boolean) : void 0
+  };
+  store.agents.push(agent);
+  writeStore(store);
+  writeRuntime(agent.id, { id: agent.id, pid: null, running: false, consecutiveErrors: 0, currentRetry: 0 });
+  console.log(`
+${COLORS.green}Agent created:${COLORS.reset} ${agent.name} (${agent.profile})`);
+  console.log(`  ${COLORS.dim}id:${COLORS.reset}    ${agent.id}`);
+  console.log(`  ${COLORS.dim}model:${COLORS.reset} ${agent.model}`);
+  console.log(`  ${COLORS.dim}cwd:${COLORS.reset}   ${agent.cwd}`);
+  console.log(`  ${COLORS.dim}tools:${COLORS.reset} ${agent.allowedTools.join(", ") || "none (local mode)"}`);
+  console.log(`  ${COLORS.dim}turns:${COLORS.reset} ${agent.maxTurns} max, ${agent.maxRetries} retries`);
+  console.log(`
+Run it: ${COLORS.cyan}rex agents run ${agent.name}${COLORS.reset}`);
+}
+async function runAgent(args) {
+  const idOrName = args[0];
+  const once = args.includes("--once") || !args.includes("--daemon");
+  const taskOverride = parseFlag(args, "--task");
+  if (!idOrName) {
+    console.log('Usage: rex agents run <id|name> [--task "..."] [--daemon]');
+    return;
+  }
+  const store = readStore();
+  const agent = findAgent(store, idOrName);
+  if (!agent) {
+    console.log(`Agent not found: ${idOrName}`);
+    return;
+  }
+  const rt = readRuntime(agent.id);
+  if (rt.pid && isPidRunning(rt.pid)) {
+    console.log(`${COLORS.yellow}Already running${COLORS.reset} (pid ${rt.pid}). Use: rex agents stop ${agent.name}`);
+    return;
+  }
+  if (once || agent.intervalSec === 0) {
+    console.log(`
+${COLORS.bold}Running ${agent.name}${COLORS.reset} (${agent.profile}, ${agent.model})...`);
+    console.log(`${COLORS.dim}cwd: ${agent.cwd || process.cwd()}${COLORS.reset}`);
+    console.log(`${COLORS.dim}tools: ${agent.allowedTools.join(", ") || "local LLM"}${COLORS.reset}`);
+    console.log(`${COLORS.dim}max turns: ${agent.maxTurns}, retries: ${agent.maxRetries}${COLORS.reset}
+`);
+    writeRuntime(agent.id, { ...rt, pid: process.pid, running: true, startedAt: (/* @__PURE__ */ new Date()).toISOString(), lastHeartbeat: (/* @__PURE__ */ new Date()).toISOString(), consecutiveErrors: 0, currentRetry: 0 });
+    const result = await executeAgent(agent, taskOverride || void 0);
+    agent.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
+    agent.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    agent.totalRuns++;
+    if (!result.ok) agent.totalErrors++;
+    writeStore(store);
+    writeRuntime(agent.id, { ...readRuntime(agent.id), pid: null, running: false, lastRunAt: agent.lastRunAt, lastError: result.error, consecutiveErrors: result.ok ? 0 : readRuntime(agent.id).consecutiveErrors + 1, currentRetry: 0 });
+    const status = result.ok ? "OK" : "FAIL";
+    appendLog(agent.id, `RUN ${status} (${result.duration}ms, ${result.turns} turns, tools: ${result.toolsUsed.join(",") || "none"})`);
+    if (result.output && !result.output.startsWith('[{"type":"system"')) appendLog(agent.id, result.output.slice(0, 5e3));
+    if (result.error) appendLog(agent.id, `ERROR: ${result.error}`);
+    if (result.ok) {
+      console.log(`${COLORS.green}Done${COLORS.reset} (${Math.round(result.duration / 1e3)}s, ${result.turns} turns)
+`);
+      console.log(result.output);
+    } else {
+      console.log(`${COLORS.red}Failed${COLORS.reset} (${Math.round(result.duration / 1e3)}s)
+`);
+      console.log(result.error || result.output);
+    }
+    return;
+  }
+  const script = process.argv[1];
+  const child = spawn(process.execPath, [script, "agents", "_daemon-loop", agent.id], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  const pid = child.pid || null;
+  writeRuntime(agent.id, { id: agent.id, pid, running: pid !== null, startedAt: (/* @__PURE__ */ new Date()).toISOString(), lastHeartbeat: (/* @__PURE__ */ new Date()).toISOString(), consecutiveErrors: 0, currentRetry: 0 });
+  console.log(`${COLORS.green}Agent started in background${COLORS.reset} (pid ${pid})`);
+  console.log(`  Logs: rex agents logs ${agent.name}`);
+  console.log(`  Stop: rex agents stop ${agent.name}`);
+}
+async function daemonLoop(agentId) {
+  let alive = true;
+  process.on("SIGTERM", () => {
+    alive = false;
+  });
+  process.on("SIGINT", () => {
+    alive = false;
+  });
+  const MAX_CONSECUTIVE_ERRORS = 5;
+  while (alive) {
+    const store = readStore();
+    const agent = store.agents.find((a) => a.id === agentId);
+    if (!agent || !agent.enabled) break;
+    const runtime = readRuntime(agent.id);
+    if (runtime.consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+      appendLog(agent.id, `CIRCUIT BREAKER: ${runtime.consecutiveErrors} consecutive errors \u2014 stopping agent`);
+      break;
+    }
+    writeRuntime(agent.id, { ...runtime, id: agent.id, pid: process.pid, running: true, lastHeartbeat: (/* @__PURE__ */ new Date()).toISOString() });
+    const result = await executeAgent(agent);
+    agent.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
+    agent.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    agent.totalRuns++;
+    if (!result.ok) agent.totalErrors++;
+    writeStore(store);
+    const newConsecutive = result.ok ? 0 : runtime.consecutiveErrors + 1;
+    writeRuntime(agent.id, { ...readRuntime(agent.id), id: agent.id, pid: process.pid, running: true, lastRunAt: agent.lastRunAt, lastError: result.error, consecutiveErrors: newConsecutive, currentRetry: 0, lastHeartbeat: (/* @__PURE__ */ new Date()).toISOString() });
+    const status = result.ok ? "OK" : "FAIL";
+    appendLog(agent.id, `SCHEDULED RUN ${status} (${result.duration}ms, ${result.turns} turns)`);
+    if (result.output && !result.output.startsWith('[{"type":"system"')) appendLog(agent.id, result.output.slice(0, 3e3));
+    if (result.error) appendLog(agent.id, `ERROR: ${result.error}`);
+    const interval = Math.max(30, agent.intervalSec);
+    await new Promise((r) => setTimeout(r, interval * 1e3));
+  }
+  const finalState = readRuntime(agentId);
+  writeRuntime(agentId, { ...finalState, id: agentId, pid: null, running: false, lastHeartbeat: (/* @__PURE__ */ new Date()).toISOString() });
+  appendLog(agentId, "DAEMON STOPPED");
+}
+function stopAgent(args) {
+  const idOrName = args[0];
+  if (!idOrName) {
+    console.log("Usage: rex agents stop <id|name>");
+    return;
+  }
+  const store = readStore();
+  const agent = findAgent(store, idOrName);
+  if (!agent) {
+    console.log(`Agent not found: ${idOrName}`);
+    return;
+  }
+  const rt = readRuntime(agent.id);
+  if (rt.pid && isPidRunning(rt.pid)) {
+    try {
+      process.kill(rt.pid, "SIGTERM");
+    } catch {
+    }
+    console.log(`${COLORS.green}Stopped${COLORS.reset} ${agent.name} (pid ${rt.pid})`);
+  } else {
+    console.log(`${COLORS.dim}${agent.name} was not running${COLORS.reset}`);
+  }
+  writeRuntime(agent.id, { ...rt, running: false, pid: null, lastHeartbeat: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function statusAgent(args, jsonMode) {
+  const idOrName = args[0];
+  if (!idOrName) {
+    listAgents(jsonMode);
+    return;
+  }
+  const store = readStore();
+  const agent = findAgent(store, idOrName);
+  if (!agent) {
+    console.log(`Agent not found: ${idOrName}`);
+    return;
+  }
+  const rt = readRuntime(agent.id);
+  const running = rt.running && isPidRunning(rt.pid);
+  if (jsonMode) {
+    console.log(JSON.stringify({ ...agent, runtime: { ...rt, running } }, null, 2));
+    return;
+  }
+  const status = running ? `${COLORS.green}RUNNING${COLORS.reset}` : agent.enabled ? `${COLORS.yellow}IDLE${COLORS.reset}` : `${COLORS.dim}DISABLED${COLORS.reset}`;
+  console.log(`
+  ${COLORS.bold}${agent.name}${COLORS.reset} ${status}`);
+  console.log(`  Profile:   ${agent.profile}`);
+  console.log(`  Model:     ${agent.model}${agent.localModel ? ` (${agent.localModel})` : ""}`);
+  console.log(`  CWD:       ${agent.cwd || "current dir"}`);
+  console.log(`  Tools:     ${agent.allowedTools.join(", ") || "none"}`);
+  console.log(`  Turns:     ${agent.maxTurns} max, ${agent.maxRetries} retries`);
+  console.log(`  Schedule:  ${agent.intervalSec > 0 ? `every ${agent.intervalSec}s` : "one-shot"}`);
+  console.log(`  Runs:      ${agent.totalRuns} total, ${agent.totalErrors} errors`);
+  console.log(`  Last run:  ${agent.lastRunAt || "never"}`);
+  if (rt.lastError) console.log(`  Last err:  ${COLORS.red}${rt.lastError.slice(0, 100)}${COLORS.reset}`);
+  if (rt.consecutiveErrors > 0) console.log(`  Consec errors: ${COLORS.red}${rt.consecutiveErrors}${COLORS.reset}`);
+  console.log();
+}
+function showLogs(args) {
+  const idOrName = args[0];
+  const tailArg = parseFlag(args, "--tail");
+  const tail = Math.max(1, parseInt(tailArg || "50", 10));
+  if (!idOrName) {
+    console.log("Usage: rex agents logs <id|name> [--tail N]");
+    return;
+  }
+  const store = readStore();
+  const agent = findAgent(store, idOrName);
+  if (!agent) {
+    console.log(`Agent not found: ${idOrName}`);
+    return;
+  }
+  const p = logPath(agent.id);
+  if (!existsSync(p)) {
+    console.log("No logs yet.");
+    return;
+  }
+  const lines = readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  console.log(lines.slice(-tail).join("\n"));
+}
+function setEnabled(args, enabled) {
+  const idOrName = args[0];
+  if (!idOrName) {
+    console.log(`Usage: rex agents ${enabled ? "enable" : "disable"} <id|name>`);
+    return;
+  }
+  const store = readStore();
+  const agent = findAgent(store, idOrName);
+  if (!agent) {
+    console.log(`Agent not found: ${idOrName}`);
+    return;
+  }
+  agent.enabled = enabled;
+  agent.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeStore(store);
+  console.log(`${enabled ? COLORS.green : COLORS.yellow}${agent.name} ${enabled ? "enabled" : "disabled"}${COLORS.reset}`);
+}
+function deleteAgent(args) {
+  const idOrName = args[0];
+  if (!idOrName) {
+    console.log("Usage: rex agents delete <id|name>");
+    return;
+  }
+  const store = readStore();
+  const idx = store.agents.findIndex((a) => a.id === idOrName || a.name === idOrName);
+  if (idx < 0) {
+    console.log(`Agent not found: ${idOrName}`);
+    return;
+  }
+  const agent = store.agents[idx];
+  const rt = readRuntime(agent.id);
+  if (rt.pid && isPidRunning(rt.pid)) {
+    try {
+      process.kill(rt.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  store.agents.splice(idx, 1);
+  writeStore(store);
+  console.log(`${COLORS.green}Deleted${COLORS.reset} ${agent.name}`);
+}
+function profiles(jsonMode) {
+  const rows = Object.entries(PROFILE_TEMPLATES).map(([name, t]) => ({
+    name,
+    model: t.model,
+    allowedTools: t.allowedTools,
+    maxTurns: t.maxTurns,
+    intervalSec: t.intervalSec,
+    prompt: t.prompt.slice(0, 80) + "..."
+  }));
+  if (jsonMode) {
+    console.log(JSON.stringify({ profiles: rows }, null, 2));
+    return;
+  }
+  const line = "\u2500".repeat(60);
+  console.log(`
+${COLORS.bold}  Agent Profiles${COLORS.reset}
+${line}`);
+  for (const r of rows) {
+    const model = r.model === "claude" ? `${COLORS.magenta}claude${COLORS.reset}` : `${COLORS.cyan}local${COLORS.reset}`;
+    const schedule = r.intervalSec > 0 ? `every ${r.intervalSec}s` : "one-shot";
+    console.log(`  ${COLORS.bold}${r.name}${COLORS.reset} ${model} \u2014 ${r.maxTurns} turns \u2014 ${schedule}`);
+    console.log(`  ${COLORS.dim}${r.prompt}${COLORS.reset}`);
+    if (r.allowedTools.length) console.log(`  ${COLORS.dim}tools: ${r.allowedTools.join(", ")}${COLORS.reset}`);
+    console.log();
+  }
+}
+function teamCommand(args) {
+  const teamName = args[0];
+  if (!teamName) {
+    const store2 = readStore();
+    const teams = [...new Set(store2.agents.filter((a) => a.team).map((a) => a.team))];
+    if (teams.length === 0) {
+      console.log("No teams defined. Create agents with --team <name>");
+      return;
+    }
+    for (const t of teams) {
+      const members2 = store2.agents.filter((a) => a.team === t);
+      console.log(`
+${COLORS.bold}${t}${COLORS.reset} (${members2.length} agents)`);
+      for (const m of members2) {
+        const rt = readRuntime(m.id);
+        const running = rt.running && isPidRunning(rt.pid);
+        const status = running ? `${COLORS.green}RUN${COLORS.reset}` : `${COLORS.dim}IDLE${COLORS.reset}`;
+        console.log(`  ${status} ${m.name} (${m.profile})`);
+      }
+    }
+    return;
+  }
+  const store = readStore();
+  const members = store.agents.filter((a) => a.team === teamName);
+  if (members.length === 0) {
+    console.log(`No agents in team "${teamName}"`);
+    return;
+  }
+  console.log(`
+${COLORS.bold}Team: ${teamName}${COLORS.reset}`);
+  for (const m of members) {
+    const rt = readRuntime(m.id);
+    const running = rt.running && isPidRunning(rt.pid);
+    const status = running ? `${COLORS.green}RUNNING${COLORS.reset}` : `${COLORS.dim}IDLE${COLORS.reset}`;
+    console.log(`  ${status} ${m.name} (${m.profile})`);
+  }
+}
+async function chatWithOrchestrator(args) {
+  const message = args.join(" ");
+  if (!message) {
+    console.log("Usage: rex agents chat <message>");
+    console.log("Sends a message to the orchestrator agent.");
+    return;
+  }
+  const store = readStore();
+  let orch = store.agents.find((a) => a.profile === "orchestrator");
+  if (!orch) {
+    console.log(`${COLORS.cyan}Creating orchestrator agent...${COLORS.reset}`);
+    const template = PROFILE_TEMPLATES.orchestrator;
+    const id = `orchestrator-${Date.now().toString().slice(-6)}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    orch = {
+      id,
+      name: "orchestrator",
+      profile: "orchestrator",
+      prompt: template.prompt,
+      model: template.model,
+      allowedTools: template.allowedTools,
+      maxTurns: template.maxTurns,
+      maxRetries: 2,
+      intervalSec: 0,
+      enabled: true,
+      createdAt: now,
+      updatedAt: now,
+      totalRuns: 0,
+      totalErrors: 0
+    };
+    store.agents.push(orch);
+    writeStore(store);
+    writeRuntime(orch.id, { id: orch.id, pid: null, running: false, consecutiveErrors: 0, currentRetry: 0 });
+  }
+  const agentList = store.agents.map((a) => {
+    const rt = readRuntime(a.id);
+    const running = rt.running && isPidRunning(rt.pid);
+    return `- ${a.name} (${a.profile}, ${a.model}) ${running ? "RUNNING" : a.enabled ? "IDLE" : "DISABLED"} runs=${a.totalRuns} errors=${a.totalErrors}`;
+  }).join("\n");
+  const enrichedTask = `Current agents:
+${agentList}
+
+User request: ${message}`;
+  console.log(`
+${COLORS.bold}Orchestrator${COLORS.reset} thinking...
+`);
+  const result = await executeAgent(orch, enrichedTask);
+  if (result.ok) {
+    console.log(result.output);
+  } else {
+    console.log(`${COLORS.red}Error:${COLORS.reset} ${result.error || result.output}`);
+  }
+}
+async function agents(args) {
+  ensureDirs();
+  const sub = args[0] || "list";
+  const rest = args.slice(1);
+  const jsonMode = args.includes("--json");
+  switch (sub) {
+    case "list":
+      listAgents(jsonMode);
+      return;
+    case "profiles":
+      profiles(jsonMode);
+      return;
+    case "create":
+      createAgent(rest);
+      return;
+    case "run":
+      await runAgent(rest);
+      return;
+    case "_daemon-loop":
+      await daemonLoop(rest[0]);
+      return;
+    case "stop":
+      stopAgent(rest);
+      return;
+    case "status":
+      statusAgent(rest, jsonMode);
+      return;
+    case "logs":
+      showLogs(rest);
+      return;
+    case "enable":
+      setEnabled(rest, true);
+      return;
+    case "disable":
+      setEnabled(rest, false);
+      return;
+    case "delete":
+      deleteAgent(rest);
+      return;
+    case "team":
+      teamCommand(rest);
+      return;
+    case "chat":
+      await chatWithOrchestrator(rest);
+      return;
+    default:
+      console.log(`Usage: rex agents <profiles|list|create|run|stop|status|logs|enable|disable|delete|team|chat>`);
+      console.log(`
+Quick start:`);
+      console.log(`  rex agents profiles                    # See available profiles`);
+      console.log(`  rex agents create worker my-worker     # Create an agent`);
+      console.log(`  rex agents run my-worker --task "..."  # Run with a task`);
+      console.log(`  rex agents run my-worker --daemon      # Run in background (scheduled)`);
+      console.log(`  rex agents team [name]                 # List teams or team members`);
+      console.log(`  rex agents chat <message>              # Chat with the orchestrator`);
+  }
+}
+export {
+  agents
+};