@agenti-os/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,1018 @@
+#!/usr/bin/env node
+import {
+  display
+} from "./chunk-4J3VBGVR.js";
+import {
+  GatewayNotRunningError,
+  gateway
+} from "./chunk-I442WICJ.js";
+import {
+  GATEWAY_BASE_URL
+} from "./chunk-CPCT2FTQ.js";
+
+// src/index.ts
+import { Command } from "commander";
+import chalk5 from "chalk";
+
+// src/commands/init.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+var AGENTOS_DIR = ".agentos";
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize Agent OS in the current repository").option("--force", "Overwrite existing configuration files").action((opts) => {
+    runInit(opts.force);
+  });
+}
+function runInit(force = false) {
+  const cwd = process.cwd();
+  if (!existsSync(join(cwd, ".git"))) {
+    display.warning("No .git directory found. Agent OS works best inside a Git repository.");
+    console.log(chalk.grey("  Continuing anyway...\n"));
+  }
+  console.log(chalk.bold("\n  Initializing Agent OS\n"));
+  const dirs = [
+    AGENTOS_DIR,
+    join(AGENTOS_DIR, "context"),
+    join(AGENTOS_DIR, "context", "api-contracts"),
+    join(AGENTOS_DIR, "context", "decisions"),
+    join(AGENTOS_DIR, "missions"),
+    join(AGENTOS_DIR, "runs"),
+    join(AGENTOS_DIR, "artifacts"),
+    join(AGENTOS_DIR, "approvals"),
+    join(AGENTOS_DIR, "workspaces"),
+    join(AGENTOS_DIR, ".secrets")
+  ];
+  for (const dir of dirs) {
+    mkdirSync(join(cwd, dir), { recursive: true });
+    console.log(chalk.grey(`  created  `) + dir + "/");
+  }
+  const files = [
+    {
+      path: join(AGENTOS_DIR, "config.yml"),
+      content: CONFIG_YML
+    },
+    {
+      path: join(AGENTOS_DIR, "agents.yml"),
+      content: AGENTS_YML
+    },
+    {
+      path: join(AGENTOS_DIR, "policies.yml"),
+      content: POLICIES_YML
+    },
+    {
+      path: join(AGENTOS_DIR, "context", "product.md"),
+      content: PRODUCT_MD
+    },
+    {
+      path: join(AGENTOS_DIR, "context", "architecture.md"),
+      content: ARCHITECTURE_MD
+    },
+    {
+      path: join(AGENTOS_DIR, "context", "constraints.md"),
+      content: CONSTRAINTS_MD
+    },
+    {
+      path: join(AGENTOS_DIR, "context", "glossary.md"),
+      content: GLOSSARY_MD
+    },
+    {
+      path: join(AGENTOS_DIR, ".gitignore"),
+      content: GITIGNORE
+    }
+  ];
+  for (const file of files) {
+    const fullPath = join(cwd, file.path);
+    if (existsSync(fullPath) && !force) {
+      console.log(chalk.grey(`  exists   `) + file.path);
+    } else {
+      writeFileSync(fullPath, file.content, "utf-8");
+      console.log(chalk.green(`  created  `) + file.path);
+    }
+  }
+  console.log("\n" + chalk.bold.green("  \u2713 Agent OS initialized\n"));
+  console.log(chalk.grey("  Next steps:"));
+  console.log(chalk.grey("    1. Edit .agentos/context/product.md with your project description"));
+  console.log(chalk.grey("    2. Run: ") + chalk.white("agentos daemon start"));
+  console.log(chalk.grey("    3. Run: ") + chalk.white("agentos agent add claude --role frontend"));
+  console.log();
+}
+var CONFIG_YML = `# Agent OS configuration
+# This file is committed to your repository.
+version: "1"
+
+gateway:
+  port: 47821
+  log_level: info
+
+dashboard:
+  port: 47822
+
+context:
+  token_budget_default: 8000
+  token_budget_max: 16000
+
+workspace:
+  base_path: .agentos/workspaces
+  strategy: git_worktree
+`;
+var AGENTS_YML = `# Registered agents
+# This file is committed to your repository.
+# Credentials are stored in the OS keychain \u2014 never here.
+version: "1"
+agents: []
+`;
+var POLICIES_YML = `# Risk policies for Agent OS
+# This file is committed to your repository.
+version: "1"
+
+risk_thresholds:
+  auto_approve: 30
+  ask_user: 70
+  block: 100
+
+sensitive_paths:
+  - ".env*"
+  - "**/secrets/**"
+  - "infra/**"
+  - "db/migrations/**"
+  - "auth/**"
+  - "payments/**"
+
+dangerous_commands:
+  - "rm -rf"
+  - "drop database"
+  - "git push --force"
+  - "curl * | sh"
+  - "chmod -R 777"
+  - "npm publish"
+  - "vercel --prod"
+  - "supabase db push --linked"
+
+auto_approve_patterns:
+  - "npm test"
+  - "pytest"
+  - "git status"
+  - "git diff"
+`;
+var PRODUCT_MD = `# Product Context
+
+<!-- 
+  Fill this in with your project's product context.
+  This document is injected into every agent's context pack.
+-->
+
+## What this product is
+[Describe what the app does and who it serves]
+
+## Target users
+[Who uses this app and what are their main goals]
+
+## Key features
+[List the main features]
+
+## Current status
+[What phase of development are you in]
+`;
+var ARCHITECTURE_MD = `# Architecture Context
+
+<!--
+  Fill this in with your project's technical architecture.
+  Agents use this to understand the codebase structure and conventions.
+-->
+
+## Stack
+[List your tech stack]
+
+## Folder structure
+[Describe your key directories]
+
+## Conventions
+[List coding conventions, naming patterns, etc.]
+
+## Key dependencies
+[List important libraries and why they're used]
+`;
+var CONSTRAINTS_MD = `# Agent Constraints
+
+<!--
+  Hard rules that ALL agents must follow, regardless of task.
+  These are injected into every context pack.
+-->
+
+## Always
+- Follow existing code style and conventions
+- Write tests for new functionality
+- Keep changes within your assigned scope
+- Commit working code only \u2014 no broken states
+
+## Never
+- Modify files outside your assigned scope
+- Remove existing tests
+- Change configuration that affects other agents' work
+- Deploy to production without explicit approval
+`;
+var GLOSSARY_MD = `# Project Glossary
+
+<!--
+  Define project-specific terms agents need to understand.
+  Add entries as your project develops domain-specific vocabulary.
+-->
+
+| Term | Definition |
+|------|-----------|
+| [term] | [definition] |
+`;
+var GITIGNORE = `# Agent OS \u2014 never commit these
+.secrets/
+runs/
+workspaces/
+approvals/
+*.db
+*.db-wal
+*.db-shm
+`;
+
+// src/commands/daemon.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2, unlinkSync } from "fs";
+import { join as join2 } from "path";
+import { spawn } from "child_process";
+import ora from "ora";
+var PID_FILE = ".agentos/gateway.pid";
+var LOG_FILE = ".agentos/gateway.log";
+function registerDaemonCommand(program2) {
+  const daemon = program2.command("daemon").description("Manage the Agent OS gateway daemon");
+  daemon.command("start").description("Start the gateway daemon in the background").option("--port <port>", "Port to run on (default: 47821)").action(async (opts) => {
+    await startDaemon(opts.port ? parseInt(opts.port) : void 0);
+  });
+  daemon.command("stop").description("Stop the running gateway daemon").action(stopDaemon);
+  daemon.command("status").description("Check if the gateway daemon is running").action(daemonStatus);
+}
+async function startDaemon(port) {
+  const spinner = ora("Starting Agent OS gateway...").start();
+  try {
+    const health = await gateway.health();
+    spinner.succeed(
+      `Gateway already running (v${health.version}, uptime: ${String(Math.floor(health.uptime_seconds))}s)`
+    );
+    return;
+  } catch (err) {
+    if (!(err instanceof GatewayNotRunningError)) {
+      spinner.fail("Unexpected error checking gateway status");
+      display.error(String(err));
+      process.exit(1);
+    }
+  }
+  const userProjectDir = process.cwd();
+  const env = {
+    ...process.env,
+    AGENTOS_PORT: String(port ?? 47821),
+    AGENTOS_LOG_LEVEL: "info"
+  };
+  const logPath = join2(userProjectDir, LOG_FILE);
+  const pidPath = join2(userProjectDir, PID_FILE);
+  const proc = spawn(
+    "python",
+    ["-m", "agentos_gateway"],
+    {
+      cwd: userProjectDir,
+      env,
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    }
+  );
+  mkdirSync2(join2(userProjectDir, ".agentos"), { recursive: true });
+  writeFileSync2(pidPath, String(proc.pid), "utf-8");
+  const logStream = (await import("fs")).createWriteStream(logPath, { flags: "a" });
+  proc.stdout.pipe(logStream);
+  proc.stderr.pipe(logStream);
+  proc.unref();
+  const maxWait = 1e4;
+  const interval = 200;
+  let elapsed = 0;
+  while (elapsed < maxWait) {
+    await new Promise((r) => setTimeout(r, interval));
+    elapsed += interval;
+    try {
+      const health = await gateway.health();
+      spinner.succeed(`Gateway started (v${health.version}, port: ${String(port ?? 47821)})`);
+      display.info(`Logs: ${logPath}`);
+      display.info(`PID: ${String(proc.pid)}`);
+      return;
+    } catch {
+    }
+  }
+  spinner.fail("Gateway did not start within 10 seconds");
+  display.info(`Check logs: ${logPath}`);
+  process.exit(1);
+}
+function stopDaemon() {
+  const pidPath = join2(process.cwd(), PID_FILE);
+  if (!existsSync2(pidPath)) {
+    display.warning("No gateway PID file found. Is the daemon running?");
+    process.exit(1);
+  }
+  const pid = parseInt(readFileSync(pidPath, "utf-8").trim());
+  try {
+    process.kill(pid, "SIGTERM");
+    unlinkSync(pidPath);
+    display.success(`Gateway stopped (PID: ${String(pid)})`);
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ESRCH") {
+      display.warning(`Process ${String(pid)} not found \u2014 removing stale PID file`);
+      unlinkSync(pidPath);
+    } else {
+      display.error(`Failed to stop gateway: ${String(err)}`);
+      process.exit(1);
+    }
+  }
+}
+async function daemonStatus() {
+  const pidPath = join2(process.cwd(), PID_FILE);
+  const pidExists = existsSync2(pidPath);
+  try {
+    const health = await gateway.health();
+    display.success("Gateway is running");
+    display.info(`Version: ${health.version}`);
+    display.info(`Uptime: ${String(Math.floor(health.uptime_seconds))}s`);
+    display.info(`Active missions: ${String(health.active_missions)}`);
+    display.info(`Active agents: ${String(health.active_agents)}`);
+    if (pidExists) {
+      const pid = readFileSync(pidPath, "utf-8").trim();
+      display.info(`PID: ${pid}`);
+    }
+  } catch (err) {
+    if (err instanceof GatewayNotRunningError) {
+      display.error("Gateway is not running");
+      if (pidExists) {
+        display.warning("Stale PID file found. Run: agentos daemon start");
+      }
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+
+// src/commands/agent.ts
+function collect(value, previous) {
+  return [...previous, value];
+}
+function registerAgentCommand(program2) {
+  const agent = program2.command("agent").description("Manage registered agents");
+  agent.command("add <name>").description("Register a new agent").option("--role <role>", "Role this agent plays (e.g. frontend, backend)", "general").option("--cmd <command>", "CLI command to invoke the agent (e.g. claude, codex)").option("--fallback <agent_id>", "Agent to route to on credential failure").option("--adapter <adapter>", "Adapter type: claude-code | codex | mock", "claude-code").option("--capability <cap>", "A capability this agent has (repeatable)", collect, []).action(async (name, opts) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    if (!opts.cmd) {
+      display.error("--cmd is required (the CLI command to invoke the agent)");
+      process.exit(1);
+    }
+    try {
+      const created = await gateway2.registerAgent({
+        display_name: name,
+        adapter: opts.adapter,
+        command: opts.cmd,
+        role: opts.role ?? "general",
+        capabilities: opts.capability,
+        ...opts.fallback ? { fallback_agent_id: opts.fallback } : {}
+      });
+      display.success(`Registered agent "${created.display_name}" (id: ${created.id})`);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  agent.command("remove <id>").description("Remove a registered agent").action(async (id) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      await gateway2.removeAgent(id);
+      display.success(`Removed agent ${id}`);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  const agents = program2.command("agents").description("List all agents").action(async () => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const list = await gateway2.listAgents();
+      if (list.length === 0) {
+        display.info("No agents registered. Run: agentos agent add");
+        return;
+      }
+      display.agentTable(list);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  agents.command("health").description("Show credential health for every registered agent").action(async () => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const list = await gateway2.listAgents();
+      if (list.length === 0) {
+        display.info("No agents registered. Run: agentos agent add");
+        return;
+      }
+      const rows = await Promise.all(
+        list.map(async (a) => {
+          let health = null;
+          try {
+            health = await gateway2.getAgentHealth(a.id);
+          } catch {
+            health = null;
+          }
+          return { agent: a, health };
+        })
+      );
+      display.agentHealthTable(rows);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+}
+
+// src/commands/mission.ts
+function deriveTitle(objective) {
+  return objective.length > 60 ? `${objective.slice(0, 57)}...` : objective;
+}
+function registerMissionCommand(program2) {
+  const mission = program2.command("mission").description("Manage missions");
+  mission.command("create <objective>").description("Create a new mission from a natural-language objective").option("--title <title>", "Short title for the mission (derived from objective if omitted)").action(async (objective, opts) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const created = await gateway2.createMission(opts.title ?? deriveTitle(objective), objective);
+      display.success(`Created mission "${created.title}" (id: ${created.id})`);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  mission.command("plan <mission_id>").description("Generate the task breakdown for a mission").action(async (missionId) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const [plan, agents] = await Promise.all([
+        gateway2.planMission(missionId),
+        gateway2.listAgents()
+      ]);
+      const nameById = new Map(agents.map((a) => [a.id, a.display_name]));
+      display.success(`Planned ${String(plan.tasks.length)} tasks`);
+      for (const task of plan.tasks) {
+        const agentName = task.assigned_agent_id ? nameById.get(task.assigned_agent_id) ?? task.assigned_agent_id : "unassigned";
+        console.log(
+          `  ${display.riskBadge(task.risk_level)} ${task.title} \u2014 ${agentName}` + (task.depends_on.length > 0 ? ` (depends on: ${task.depends_on.join(", ")})` : "")
+        );
+      }
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  mission.command("run <mission_id>").description("Start mission execution and stream live events until it stops running").option("--parallel", "Run ready tasks in parallel", true).action(async (missionId, opts) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const result = await gateway2.runMission(missionId, opts.parallel);
+      display.success(`Started ${String(result.started_tasks.length)} task(s)`);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+    const { GATEWAY_BASE_URL: GATEWAY_BASE_URL2 } = await import("./dist-SD33RKHO.js");
+    const { EventSource } = await import("eventsource");
+    display.info("Streaming live events \u2014 press Ctrl+C to stop watching");
+    const es = new EventSource(`${GATEWAY_BASE_URL2}/events/stream?mission_id=${missionId}`);
+    let stopped = false;
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      es.close();
+      clearInterval(poll);
+    };
+    es.onmessage = (msg) => {
+      try {
+        const event = JSON.parse(String(msg.data));
+        console.log(`  ${chalkTime(event.timestamp)} ${event.source}: ${event.type}`);
+      } catch {
+      }
+    };
+    es.onerror = () => {
+    };
+    const poll = setInterval(() => {
+      void gateway2.getMissionStatus(missionId).then((status) => {
+        if (status.status !== "running") {
+          display.success(`Mission ${status.status}`);
+          stop();
+        }
+      }).catch(() => {
+        stop();
+      });
+    }, 2e3);
+    await new Promise((resolve) => {
+      const check = setInterval(() => {
+        if (stopped) {
+          clearInterval(check);
+          resolve();
+        }
+      }, 250);
+    });
+  });
+  mission.command("pause <mission_id>").description("Pause a running mission \u2014 stops live agent runs and freezes their workspaces").action(async (missionId) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const result = await gateway2.pauseMission(missionId);
+      display.success(
+        `Paused mission ${missionId} \u2014 stopped ${String(result.paused_tasks.length)} task(s)`
+      );
+      for (const skipped of result.skipped_tasks) {
+        display.warning(`Task ${skipped.task_id} could not be stopped: ${skipped.reason}`);
+      }
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  mission.command("resume <mission_id>").description("Resume a paused mission \u2014 relaunches paused tasks with their preserved work").action(async (missionId) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const result = await gateway2.resumeMission(missionId);
+      const started = result.started_tasks.length > 0 ? `, started ${String(result.started_tasks.length)} newly-ready task(s)` : "";
+      display.success(
+        `Resumed mission ${missionId} \u2014 relaunched ${String(result.resumed_tasks.length)} task(s)${started}`
+      );
+      for (const skipped of result.skipped_tasks) {
+        display.warning(`Task ${skipped.task_id} not resumed: ${skipped.reason}`);
+      }
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+}
+function chalkTime(iso) {
+  return new Date(iso).toLocaleTimeString();
+}
+
+// src/commands/inbox.ts
+function scopeFromOptions(opts) {
+  if (opts.always) return "always";
+  if (opts.mission) return "mission";
+  return "once";
+}
+function registerInboxCommand(program2) {
+  program2.command("inbox").description("Show pending approvals, credential failures, and conflicts").action(async () => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const inbox = await gateway2.getInbox();
+      if (inbox.action_requests.length === 0 && inbox.credential_events.length === 0 && inbox.conflicts.length === 0) {
+        display.success("Inbox is empty \u2014 no pending items");
+        return;
+      }
+      display.inboxActionRequests(inbox.action_requests);
+      display.inboxCredentialEvents(inbox.credential_events);
+      display.inboxConflicts(inbox.conflicts);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  program2.command("approve <id>").description("Approve a pending action request").option("--once", "Approve this single occurrence only (default)").option("--mission", "Approve for the rest of the current mission").option("--always", "Always auto-approve this pattern going forward").action(async (id, opts) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    const scope = scopeFromOptions(opts);
+    try {
+      await gateway2.approve(id, { scope });
+      display.success(`Approved ${id} (scope: ${scope})`);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  program2.command("deny <id>").description("Deny a pending action request").action(async (id) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      await gateway2.deny(id);
+      display.success(`Denied ${id}`);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+}
+
+// src/commands/workspace.ts
+import chalk2 from "chalk";
+function printDiff(diffText) {
+  for (const line of diffText.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      console.log(chalk2.green(line));
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      console.log(chalk2.red(line));
+    } else {
+      console.log(chalk2.grey(line));
+    }
+  }
+}
+function registerWorkspaceCommands(program2) {
+  program2.command("diff <task_id>").description("View agent changes for a task").action(async (taskId) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const diff = await gateway2.getDiff(taskId);
+      if (!diff.diff_text) {
+        display.info("No changes yet for this task");
+        return;
+      }
+      printDiff(diff.diff_text);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  program2.command("merge <task_id>").description("Merge approved task work into the base branch").action(async (taskId) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const result = await gateway2.mergeTask(taskId);
+      display.success(`Merged task ${taskId} (sha: ${result.merged_sha.slice(0, 8)})`);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  program2.command("rollback <task_id>").description("Discard a task's latest run and restore the last clean state").action(async (taskId) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const result = await gateway2.rollbackTask(taskId);
+      display.success(`Rolled back task ${taskId} to ${result.rolled_back_to_sha.slice(0, 8)}`);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+  program2.command("route <task_id>").description("Reroute a task to a different agent").requiredOption("--to <agent_id>", "Target agent ID").action(async (taskId, opts) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const result = await gateway2.routeTask(taskId, opts.to);
+      display.success(`Routed task ${taskId} to ${opts.to} (new run: ${result.new_run_id})`);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+}
+
+// src/commands/context.ts
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { basename, extname, join as join3 } from "path";
+var CONTEXT_DIR = ".agentos/context";
+function registerContextCommand(program2) {
+  const context = program2.command("context").description("Manage the context vault");
+  context.command("add <file>").description("Copy a document into the local context vault (.agentos/context/)").action((file) => {
+    const cwd = process.cwd();
+    if (!existsSync3(file)) {
+      display.error(`File not found: ${file}`);
+      process.exit(1);
+    }
+    if (extname(file).toLowerCase() !== ".md") {
+      display.error(`Not a Markdown file: ${file}`);
+      process.exit(1);
+    }
+    const destDir = join3(cwd, CONTEXT_DIR);
+    mkdirSync3(destDir, { recursive: true });
+    const dest = join3(destDir, basename(file));
+    copyFileSync(file, dest);
+    display.success(`Added ${basename(file)} to context vault`);
+  });
+  context.command("show <task_id>").description("Show the most recent context pack built for a task (documents, token usage, preview)").action(async (taskId) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const pack = await gateway2.getLatestContextPackForTask(taskId);
+      display.info(`Context pack ${pack.id} for task ${pack.task_id}`);
+      console.log(`  documents: ${pack.documents.length > 0 ? pack.documents.join(", ") : "(none)"}`);
+      console.log(`  tokens used: ${String(pack.tokens_used)} / ${String(pack.token_budget)}`);
+      if (pack.content) {
+        const preview = pack.content.length > 500 ? `${pack.content.slice(0, 500)}...` : pack.content;
+        console.log("  preview:");
+        console.log(preview);
+      }
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+}
+
+// src/commands/credentials.ts
+function registerCredentialsCommand(program2) {
+  const creds = program2.command("credentials").description("Manage agent credentials");
+  creds.command("rotate <agent_id>").description("Rotate the stored credential for an agent (prompts for the new value)").action(async (agentId) => {
+    const { default: inquirer } = await import("inquirer");
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    const { credentialValue } = await inquirer.prompt([
+      {
+        type: "password",
+        name: "credentialValue",
+        message: `New credential value for agent ${agentId}:`,
+        mask: "*"
+      }
+    ]);
+    try {
+      const result = await gateway2.rotateCredential(agentId, credentialValue);
+      display.success(
+        `Rotated credential for ${agentId} \u2014 validated: ${result.validated ? "yes" : "no"}`
+      );
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+}
+
+// src/commands/conflicts.ts
+function registerConflictsCommand(program2) {
+  program2.command("conflicts").description("List all active conflicts in the current mission").action(async () => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    try {
+      const inbox = await gateway2.getInbox();
+      display.inboxConflicts(inbox.conflicts);
+    } catch (err) {
+      display.gatewayError(err);
+    }
+  });
+}
+
+// src/commands/logs.ts
+import chalk3 from "chalk";
+function severityColor(severity) {
+  switch (severity) {
+    case "warning":
+      return chalk3.yellow;
+    case "error":
+      return chalk3.red;
+    case "critical":
+      return chalk3.red.bold;
+    default:
+      return chalk3.grey;
+  }
+}
+function sourceLabel(source) {
+  if (source === "gateway") return chalk3.grey.italic(source);
+  if (source === "user") return chalk3.white(source);
+  return chalk3.cyan(source);
+}
+function formatEvent(event) {
+  const time = new Date(event.timestamp).toLocaleTimeString();
+  const severity = severityColor(event.severity)(`[${event.severity}]`);
+  const source = sourceLabel(event.source);
+  const prefix = `[${time}] ${severity} ${source}: ${chalk3.bold(event.type)}`;
+  if (event.type === "agent.output") {
+    const preview = event.payload.content_preview.slice(0, 80);
+    return `${prefix} \u2014 "${preview}"`;
+  }
+  const payload = JSON.stringify(event.payload);
+  const truncated = payload.length > 120 ? `${payload.slice(0, 117)}...` : payload;
+  return `${prefix} \u2014 ${chalk3.grey(truncated)}`;
+}
+function registerLogsCommand(program2) {
+  program2.command("logs").description("Stream or view recent event logs").option("--follow", "Keep streaming live events instead of exiting after the last 50").option("--run <id>", "Filter by run ID").option("--mission <id>", "Filter by mission ID").action(async (opts) => {
+    const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+    if (!opts.follow) {
+      try {
+        const result = await gateway2.listEvents({
+          ...opts.run ? { run_id: opts.run } : {},
+          ...opts.mission ? { mission_id: opts.mission } : {},
+          limit: 50
+        });
+        if (result.events.length === 0) {
+          display.info("No events recorded yet");
+          return;
+        }
+        for (const event of result.events) {
+          console.log(formatEvent(event));
+        }
+      } catch (err) {
+        display.gatewayError(err);
+      }
+      return;
+    }
+    const { GATEWAY_BASE_URL: GATEWAY_BASE_URL2 } = await import("./dist-SD33RKHO.js");
+    const { EventSource } = await import("eventsource");
+    const params = new URLSearchParams();
+    if (opts.run) params.set("run_id", opts.run);
+    if (opts.mission) params.set("mission_id", opts.mission);
+    const query = params.toString();
+    display.info("Following live events \u2014 press Ctrl+C to stop");
+    const es = new EventSource(`${GATEWAY_BASE_URL2}/events/stream${query ? `?${query}` : ""}`);
+    es.onmessage = (msg) => {
+      try {
+        const event = JSON.parse(String(msg.data));
+        console.log(formatEvent(event));
+      } catch {
+      }
+    };
+    await new Promise(() => {
+    });
+  });
+}
+
+// src/commands/start.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join4 } from "path";
+import { exec } from "child_process";
+import { fileURLToPath } from "url";
+import chalk4 from "chalk";
+var DASHBOARD_URL = `${GATEWAY_BASE_URL}/ui`;
+function registerStartCommand(program2) {
+  program2.command("start").description("Start the gateway, open the dashboard, and stream live events").action(runStart);
+}
+async function runStart() {
+  const cwd = process.cwd();
+  const bundledDashboardPath = join4(dirname(fileURLToPath(import.meta.url)), "../dashboard");
+  if (existsSync4(bundledDashboardPath)) {
+    process.env.AGENTOS_DASHBOARD_PATH = bundledDashboardPath;
+  }
+  let gatewayRunning = true;
+  try {
+    await gateway.health();
+  } catch (err) {
+    if (!(err instanceof GatewayNotRunningError)) {
+      display.gatewayError(err);
+    }
+    gatewayRunning = false;
+  }
+  if (!gatewayRunning) {
+    await startDaemon();
+  }
+  const repoRoot = findRepoRoot(cwd);
+  const dashboardBuiltInRepo = repoRoot !== null && existsSync4(join4(repoRoot, "apps", "dashboard", "out"));
+  const dashboardAvailable = dashboardBuiltInRepo || existsSync4(bundledDashboardPath);
+  if (dashboardAvailable) {
+    display.success(`Dashboard at ${DASHBOARD_URL}`);
+  } else {
+    display.warning(
+      "Dashboard not available. To enable it:\n  pnpm build:dashboard && pnpm build"
+    );
+    display.info(`Gateway API available at ${GATEWAY_BASE_URL}`);
+    display.info("Use the CLI for all operations.");
+  }
+  console.log(`
+  Agent OS v0.2.0
+  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  Gateway    ${GATEWAY_BASE_URL}   \u2713
+  Dashboard  ${DASHBOARD_URL} ${dashboardAvailable ? "\u2713" : "\u2717"}
+  Project    ${cwd}
+  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  Streaming live events  (Ctrl+C to stop, gateway keeps running)
+`);
+  if (dashboardAvailable) {
+    openBrowser(DASHBOARD_URL);
+  }
+  await streamEvents();
+}
+function findRepoRoot(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    const pkgPath = join4(dir, "package.json");
+    if (existsSync4(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+        if (pkg.name === "agent-os") return dir;
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function openBrowser(url) {
+  try {
+    const command = process.platform === "win32" ? `start ${url}` : process.platform === "darwin" ? `open ${url}` : `xdg-open ${url}`;
+    exec(command, () => {
+    });
+  } catch {
+  }
+}
+function severityColor2(severity) {
+  switch (severity) {
+    case "warning":
+      return chalk4.yellow;
+    case "error":
+      return chalk4.red;
+    case "critical":
+      return chalk4.red.bold;
+    default:
+      return (text) => text;
+  }
+}
+function formatEvent2(event) {
+  const time = new Date(event.timestamp).toLocaleTimeString("en-GB", { hour12: false });
+  const color = severityColor2(event.severity);
+  const base = `[${time}] [${color(event.severity)}]  ${event.source}: ${event.type}`;
+  if (event.type === "agent.output") {
+    return `${base} \u2014 ${event.payload.content_preview}`;
+  }
+  if (event.type === "tool.requested") {
+    const line = `\u26A0  ${base} \u2014 risk: ${event.payload.risk_level}
+   \u2192 agentos approve ${event.payload.action_request_id} --once`;
+    return line;
+  }
+  const preview = JSON.stringify(event.payload);
+  const truncated = preview.length > 120 ? `${preview.slice(0, 117)}...` : preview;
+  return `${base} \u2014 ${truncated}`;
+}
+async function streamEvents() {
+  const { EventSource } = await import("eventsource");
+  const es = new EventSource(`${GATEWAY_BASE_URL}/events/stream`);
+  es.onmessage = (msg) => {
+    try {
+      const event = JSON.parse(String(msg.data));
+      console.log(formatEvent2(event));
+    } catch {
+    }
+  };
+  process.on("SIGINT", () => {
+    console.log("\n  Gateway is still running. Use: agentos daemon stop");
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+
+// src/commands/stop.ts
+import { createInterface } from "readline";
+function registerStopCommand(program2) {
+  program2.command("stop").description("Stop the Agent OS gateway").action(runStop);
+}
+async function runStop() {
+  try {
+    await gateway.health();
+  } catch (err) {
+    if (err instanceof GatewayNotRunningError) {
+      display.info("Gateway is not running");
+      process.exit(0);
+    }
+    display.gatewayError(err);
+  }
+  const runningMissions = await gateway.listMissions("running");
+  if (runningMissions.length > 0) {
+    const proceed = await confirm("Active mission running. Stop anyway? (y/N) ");
+    if (!proceed) {
+      process.exit(0);
+    }
+  }
+  stopDaemon();
+  display.success("Agent OS stopped");
+}
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+
+// src/commands/stop-task.ts
+function registerStopTaskCommand(program2) {
+  program2.command("stop-task <task_id>").description("Stop the live agent run on a task \u2014 preserves partial work via a workspace freeze").action(stopTask);
+}
+async function stopTask(taskId) {
+  const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+  try {
+    const result = await gateway2.stopTask(taskId);
+    display.success(`Stopped run ${result.run_id} \u2014 task ${result.task_id} is paused`);
+    if (result.workspace_state) {
+      display.info(`Workspace frozen (${result.workspace_state}) \u2014 partial work preserved`);
+    }
+    display.info(`Resume by routing to another agent: agentos route ${taskId} --to <agent_id>`);
+  } catch (err) {
+    display.gatewayError(err);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("agentos").description(
+  chalk5.bold("Agent OS") + " \u2014 Personal control plane for AI coding agents"
+).version("0.2.0", "-v, --version", "Print version").helpOption("-h, --help", "Show help");
+registerInitCommand(program);
+registerDaemonCommand(program);
+registerAgentCommand(program);
+registerMissionCommand(program);
+registerInboxCommand(program);
+registerWorkspaceCommands(program);
+registerContextCommand(program);
+registerCredentialsCommand(program);
+registerConflictsCommand(program);
+registerLogsCommand(program);
+registerStartCommand(program);
+registerStopCommand(program);
+registerStopTaskCommand(program);
+program.command("status").description("Show current mission and agent status").action(async () => {
+  const { gateway: gateway2 } = await import("./gateway-client-RSQFHBFE.js");
+  const { display: display2 } = await import("./display-ZLPTSJQM.js");
+  try {
+    const health = await gateway2.health();
+    display2.success(
+      `Gateway v${health.version} \u2014 ${String(health.active_missions)} active missions, ${String(health.active_agents)} active agents`
+    );
+    const agents = await gateway2.listAgents();
+    if (agents.length === 0) {
+      display2.info("No agents registered. Run: agentos agent add");
+      return;
+    }
+    display2.agentTable(agents);
+  } catch (err) {
+    display2.gatewayError(err);
+  }
+});
+program.exitOverride();
+try {
+  await program.parseAsync(process.argv);
+} catch (err) {
+  if (err instanceof Error && err.name === "CommanderError") {
+    process.exit(err.exitCode ?? 1);
+  }
+  console.error(chalk5.red("Unexpected error:"), err);
+  process.exit(1);
+}