@astroanywhere/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2076 @@
+import {
+  clearAuth,
+  getClient,
+  getServerUrl,
+  loadConfig,
+  resetConfig,
+  saveConfig,
+  streamDispatchToStdout
+} from "./chunk-PYFBZGQG.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/output.ts
+import chalk from "chalk";
+function formatTable(rows, columns) {
+  if (rows.length === 0) return chalk.dim("  No results.");
+  const widths = columns.map((col) => {
+    const headerLen = col.label.length;
+    const maxDataLen = rows.reduce((max, row) => {
+      const val = col.format ? col.format(row[col.key]) : String(row[col.key] ?? "");
+      return Math.max(max, val.length);
+    }, 0);
+    return col.width ?? Math.max(headerLen, Math.min(maxDataLen, 50));
+  });
+  const header = columns.map((col, i) => col.label.padEnd(widths[i])).join("  ");
+  const separator = columns.map((_, i) => "\u2500".repeat(widths[i])).join("\u2500\u2500");
+  const dataRows = rows.map(
+    (row) => columns.map((col, i) => {
+      const val = col.format ? col.format(row[col.key]) : String(row[col.key] ?? "");
+      return val.slice(0, widths[i]).padEnd(widths[i]);
+    }).join("  ")
+  );
+  return [chalk.bold(header), chalk.dim(separator), ...dataRows].join("\n");
+}
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function print(data, opts) {
+  if (opts.json) {
+    console.log(formatJson(data));
+  } else if (opts.columns && Array.isArray(data)) {
+    console.log(formatTable(data, opts.columns));
+  } else {
+    console.log(formatJson(data));
+  }
+}
+function formatRelativeTime(date) {
+  if (!date) return chalk.dim("\u2014");
+  const d = typeof date === "string" ? new Date(date) : date;
+  const now = Date.now();
+  const diff = now - d.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (seconds < 60) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  if (hours < 24) return `${hours}h ago`;
+  if (days < 30) return `${days}d ago`;
+  return d.toLocaleDateString();
+}
+function parseDateFilter(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === "today") {
+    const d2 = /* @__PURE__ */ new Date();
+    d2.setHours(0, 0, 0, 0);
+    return d2;
+  }
+  if (trimmed === "yesterday") {
+    const d2 = /* @__PURE__ */ new Date();
+    d2.setDate(d2.getDate() - 1);
+    d2.setHours(0, 0, 0, 0);
+    return d2;
+  }
+  const relMatch = trimmed.match(/^(\d+)\s*(m|h|d|w)$/);
+  if (relMatch) {
+    const amount = parseInt(relMatch[1], 10);
+    const unit = relMatch[2];
+    const now = Date.now();
+    const ms = {
+      m: 60 * 1e3,
+      h: 60 * 60 * 1e3,
+      d: 24 * 60 * 60 * 1e3,
+      w: 7 * 24 * 60 * 60 * 1e3
+    };
+    return new Date(now - amount * ms[unit]);
+  }
+  const d = new Date(value);
+  if (isNaN(d.getTime())) {
+    throw new Error(`Invalid date filter: "${value}". Use relative (2d, 1h, 30m, 1w), named (today, yesterday), or ISO format.`);
+  }
+  return d;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const totalSeconds = ms / 1e3;
+  if (totalSeconds < 60) return `${totalSeconds.toFixed(1)}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = Math.round(totalSeconds % 60);
+  if (minutes < 60) {
+    return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+}
+function formatStatus(status) {
+  const colors = {
+    active: chalk.green,
+    completed: chalk.blue,
+    planned: chalk.yellow,
+    in_progress: chalk.cyan,
+    dispatched: chalk.cyan,
+    auto_verified: chalk.green,
+    awaiting_approval: chalk.magenta,
+    awaiting_judgment: chalk.magenta,
+    pruned: chalk.dim,
+    archived: chalk.dim,
+    running: chalk.cyan,
+    success: chalk.green,
+    failure: chalk.red,
+    cancelled: chalk.dim,
+    pending: chalk.yellow
+  };
+  const colorFn = colors[status] ?? chalk.white;
+  return colorFn(status);
+}
+
+// src/commands/project.ts
+import chalk2 from "chalk";
+var projectColumns = [
+  { key: "id", label: "ID", width: 8, format: (v) => String(v ?? "").slice(0, 8) },
+  { key: "name", label: "NAME", width: 30 },
+  { key: "status", label: "STATUS", width: 12, format: (v) => formatStatus(String(v ?? "")) },
+  { key: "workingDirectory", label: "WORK DIR", width: 30, format: (v) => v ? String(v) : chalk2.dim("\u2014") },
+  { key: "updatedAt", label: "UPDATED", width: 12, format: (v) => formatRelativeTime(v) }
+];
+function registerProjectCommands(program2) {
+  const project = program2.command("project").description("Manage projects");
+  project.command("list").description("List all projects").action(async () => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    const rows = await client.listProjects();
+    print(rows, { json: opts.json, columns: projectColumns });
+  });
+  project.command("show <id>").description("Show project details").action(async (id) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    let p;
+    try {
+      p = await client.resolveProject(id);
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+      process.exit(1);
+    }
+    if (opts.json) {
+      print(p, { json: true });
+      return;
+    }
+    const fields = [
+      ["ID", p.id],
+      ["Name", p.name],
+      ["Status", formatStatus(p.status)],
+      ["Description", p.description || chalk2.dim("\u2014")],
+      ["Working Directory", p.workingDirectory || chalk2.dim("\u2014")],
+      ["Source Directory", p.sourceDirectory || chalk2.dim("\u2014")],
+      ["Repository", p.repository || chalk2.dim("\u2014")],
+      ["Delivery Mode", p.deliveryMode || chalk2.dim("\u2014")],
+      ["Health", p.health || chalk2.dim("\u2014")],
+      ["Progress", `${p.progress ?? 0}%`],
+      ["Start Date", p.startDate || chalk2.dim("\u2014")],
+      ["Target Date", p.targetDate || chalk2.dim("\u2014")],
+      ["Lead", p.lead || chalk2.dim("\u2014")],
+      ["Default Environment", p.defaultEnvironment || chalk2.dim("\u2014")],
+      ["Default Machine ID", p.defaultMachineId || chalk2.dim("\u2014")],
+      ["Created", formatRelativeTime(p.createdAt)],
+      ["Updated", formatRelativeTime(p.updatedAt)]
+    ];
+    const maxKeyLen = Math.max(...fields.map(([k]) => k.length));
+    for (const [key, value] of fields) {
+      console.log(`  ${chalk2.bold(key.padEnd(maxKeyLen))}  ${value}`);
+    }
+    if (p.visionDoc) {
+      console.log();
+      console.log(chalk2.bold("  Vision Document:"));
+      console.log(`  ${p.visionDoc.slice(0, 500)}${p.visionDoc.length > 500 ? "..." : ""}`);
+    }
+  });
+  project.command("create").description("Create a new project").requiredOption("--name <name>", "Project name").option("--description <desc>", "Project description", "").option("--dir <path>", "Working directory").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    const created = await client.createProject({
+      name: cmdOpts.name,
+      description: cmdOpts.description,
+      workingDirectory: cmdOpts.dir
+    });
+    if (opts.json) {
+      print(created, { json: true });
+    } else {
+      console.log(chalk2.green("Project created:"));
+      console.log(`  ${chalk2.bold("ID")}    ${created.id}`);
+      console.log(`  ${chalk2.bold("Name")}  ${created.name}`);
+      if (created.workingDirectory) {
+        console.log(`  ${chalk2.bold("Dir")}   ${created.workingDirectory}`);
+      }
+    }
+  });
+  project.command("update <id>").description("Update a project").option("--name <name>", "New project name").option("--description <desc>", "New description").option("--status <status>", "New status").option("--dir <path>", "New working directory").option("--vision-doc <text>", "Update vision document").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    let p;
+    try {
+      p = await client.resolveProject(id);
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    const patch = {};
+    if (cmdOpts.name !== void 0) patch.name = cmdOpts.name;
+    if (cmdOpts.description !== void 0) patch.description = cmdOpts.description;
+    if (cmdOpts.status !== void 0) patch.status = cmdOpts.status;
+    if (cmdOpts.dir !== void 0) patch.workingDirectory = cmdOpts.dir;
+    if (cmdOpts.visionDoc !== void 0) patch.visionDoc = cmdOpts.visionDoc;
+    if (Object.keys(patch).length === 0) {
+      console.error(chalk2.red("No update fields provided. Use --name, --description, --status, --dir, or --vision-doc."));
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const updated = await client.updateProject(p.id, patch);
+      if (opts.json) {
+        print(updated, { json: true });
+      } else {
+        console.log(chalk2.green(`Project "${updated.name}" updated: ${Object.keys(patch).join(", ")}`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk2.red(`Update failed: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  project.command("stats <id>").description("Show project statistics").action(async (id) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    let p;
+    try {
+      p = await client.resolveProject(id);
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const { nodes, edges } = await client.getPlan(p.id);
+      const active = nodes.filter((n) => !n.deletedAt);
+      const executions = await client.getExecutions();
+      const statusCounts = {};
+      for (const n of active) {
+        statusCounts[n.status] = (statusCounts[n.status] || 0) + 1;
+      }
+      const projectExecs = Object.values(executions).filter((e) => e.projectId === p.id);
+      const successCount = projectExecs.filter((e) => e.status === "success").length;
+      const totalTokens = projectExecs.reduce((sum, e) => sum + (e.tokensUsed ?? 0), 0);
+      const totalCost = projectExecs.reduce((sum, e) => sum + (e.estimatedCostUsd ?? 0), 0);
+      const stats = {
+        project: { id: p.id, name: p.name, status: p.status },
+        plan: {
+          totalNodes: active.length,
+          totalEdges: edges.length,
+          statusCounts
+        },
+        executions: {
+          total: projectExecs.length,
+          successRate: projectExecs.length > 0 ? `${Math.round(successCount / projectExecs.length * 100)}%` : "\u2014",
+          totalTokens,
+          totalCost: `$${totalCost.toFixed(4)}`
+        }
+      };
+      if (opts.json) {
+        print(stats, { json: true });
+        return;
+      }
+      console.log();
+      console.log(chalk2.bold(`  Project: ${p.name}`));
+      console.log(chalk2.dim("  " + "\u2500".repeat(50)));
+      console.log(`  ${chalk2.dim("Status:")}          ${formatStatus(p.status)}`);
+      console.log(`  ${chalk2.dim("Progress:")}        ${p.progress ?? 0}%`);
+      console.log();
+      console.log(chalk2.bold("  Plan"));
+      console.log(`    ${chalk2.dim("Nodes:")}  ${active.length}`);
+      console.log(`    ${chalk2.dim("Edges:")}  ${edges.length}`);
+      for (const [status, count] of Object.entries(statusCounts).sort((a, b) => b[1] - a[1])) {
+        console.log(`    ${formatStatus(status).padEnd(25)} ${count}`);
+      }
+      console.log();
+      console.log(chalk2.bold("  Executions"));
+      console.log(`    ${chalk2.dim("Total:")}        ${projectExecs.length}`);
+      console.log(`    ${chalk2.dim("Success Rate:")} ${stats.executions.successRate}`);
+      console.log(`    ${chalk2.dim("Tokens:")}       ${totalTokens.toLocaleString()}`);
+      console.log(`    ${chalk2.dim("Cost:")}         ${stats.executions.totalCost}`);
+      console.log();
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+      process.exitCode = 1;
+    }
+  });
+  project.command("delete <id>").description("Delete a project").action(async (id) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    let p;
+    try {
+      p = await client.resolveProject(id);
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+      process.exit(1);
+    }
+    console.log(chalk2.yellow(`Deleting project: ${p.name} (${p.id})`));
+    await client.deleteProject(p.id);
+    if (opts.json) {
+      print({ deleted: true, id: p.id, name: p.name }, { json: true });
+    } else {
+      console.log(chalk2.green("Project deleted."));
+    }
+  });
+}
+
+// src/commands/plan.ts
+import chalk3 from "chalk";
+var nodeColumns = [
+  { key: "id", label: "ID", width: 20 },
+  { key: "title", label: "TITLE", width: 40 },
+  { key: "type", label: "TYPE", width: 10 },
+  { key: "status", label: "STATUS", width: 18, format: (v) => formatStatus(String(v ?? "")) },
+  { key: "startDate", label: "START", width: 12, format: (v) => v ? String(v) : chalk3.dim("\u2014") },
+  { key: "endDate", label: "END", width: 12, format: (v) => v ? String(v) : chalk3.dim("\u2014") }
+];
+function buildTree(nodes, edges) {
+  const adj = /* @__PURE__ */ new Map();
+  const hasParent = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    const children = adj.get(edge.source) ?? [];
+    children.push(edge.target);
+    adj.set(edge.source, children);
+    hasParent.add(edge.target);
+  }
+  const lookup = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    lookup.set(node.id, node);
+  }
+  function buildSubtree(nodeId) {
+    const node = lookup.get(nodeId);
+    if (!node) return null;
+    const childIds = adj.get(nodeId) ?? [];
+    const children = [];
+    for (const childId of childIds) {
+      const child = buildSubtree(childId);
+      if (child) children.push(child);
+    }
+    return { ...node, children };
+  }
+  const roots = [];
+  for (const node of nodes) {
+    if (!hasParent.has(node.id)) {
+      const tree = buildSubtree(node.id);
+      if (tree) roots.push(tree);
+    }
+  }
+  return roots;
+}
+function renderTreeLines(roots) {
+  const lines = [];
+  function walk(node, prefix, isLast) {
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const statusStr = formatStatus(node.status);
+    const typeTag = chalk3.dim(`[${node.type}]`);
+    lines.push(`${prefix}${connector}${chalk3.bold(node.id)}: ${node.title} ${typeTag} ${statusStr}`);
+    const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+    for (let i = 0; i < node.children.length; i++) {
+      walk(node.children[i], childPrefix, i === node.children.length - 1);
+    }
+  }
+  for (let i = 0; i < roots.length; i++) {
+    walk(roots[i], "", i === roots.length - 1);
+  }
+  return lines;
+}
+function registerPlanCommands(program2) {
+  const plan = program2.command("plan").description("Manage plans");
+  plan.command("list").description("List plan nodes for a project").requiredOption("--project-id <id>", "Project ID").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    try {
+      const { nodes } = await client.getPlan(cmdOpts.projectId);
+      print(nodes, { json: opts.json, columns: nodeColumns });
+    } catch (err) {
+      console.error(chalk3.red(err.message));
+      process.exitCode = 1;
+    }
+  });
+  plan.command("show <nodeId>").description("Show plan node details").option("--project-id <id>", "Project ID (narrows search)").action(async (nodeId, cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    let nodes;
+    try {
+      const result = cmdOpts.projectId ? await client.getPlan(cmdOpts.projectId) : await client.getFullPlan();
+      nodes = result.nodes;
+    } catch (err) {
+      console.error(chalk3.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    const node = nodes.find((n) => n.id === nodeId);
+    if (!node) {
+      console.error(chalk3.red(`No plan node found with ID "${nodeId}"`));
+      process.exitCode = 1;
+      return;
+    }
+    if (opts.json) {
+      print(node, { json: true });
+      return;
+    }
+    const fields = [
+      ["ID", node.id],
+      ["Title", node.title],
+      ["Type", node.type],
+      ["Status", formatStatus(node.status)],
+      ["Description", node.description || chalk3.dim("\u2014")],
+      ["Project ID", node.projectId],
+      ["Parent ID", node.parentId || chalk3.dim("\u2014")],
+      ["Priority", node.priority || chalk3.dim("\u2014")],
+      ["Estimate", node.estimate || chalk3.dim("\u2014")],
+      ["Start Date", node.startDate || chalk3.dim("\u2014")],
+      ["End Date", node.endDate || chalk3.dim("\u2014")],
+      ["Due Date", node.dueDate || chalk3.dim("\u2014")],
+      ["Milestone ID", node.milestoneId || chalk3.dim("\u2014")],
+      ["Verification", node.verification ?? chalk3.dim("\u2014")],
+      ["Branch Name", node.branchName || chalk3.dim("\u2014")],
+      ["PR URL", node.prUrl || chalk3.dim("\u2014")],
+      ["Execution ID", node.executionId || chalk3.dim("\u2014")],
+      ["Execution Started", node.executionStartedAt ? formatRelativeTime(node.executionStartedAt) : chalk3.dim("\u2014")],
+      ["Execution Completed", node.executionCompletedAt ? formatRelativeTime(node.executionCompletedAt) : chalk3.dim("\u2014")],
+      ["Created", formatRelativeTime(node.createdAt)],
+      ["Updated", formatRelativeTime(node.updatedAt)]
+    ];
+    const maxKeyLen = Math.max(...fields.map(([k]) => k.length));
+    for (const [key, value] of fields) {
+      console.log(`  ${chalk3.bold(key.padEnd(maxKeyLen))}  ${value}`);
+    }
+    if (node.executionOutput) {
+      console.log();
+      console.log(chalk3.bold("  Execution Output:"));
+      const output = node.executionOutput.slice(0, 500);
+      console.log(`  ${output}${node.executionOutput.length > 500 ? "..." : ""}`);
+    }
+    if (node.executionError) {
+      console.log();
+      console.log(chalk3.bold.red("  Execution Error:"));
+      console.log(`  ${node.executionError}`);
+    }
+  });
+  plan.command("tree").description("Show ASCII dependency tree for a project").requiredOption("--project-id <id>", "Project ID").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    let nodes, edges;
+    try {
+      const result = await client.getPlan(cmdOpts.projectId);
+      nodes = result.nodes;
+      edges = result.edges;
+    } catch (err) {
+      console.error(chalk3.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    if (nodes.length === 0) {
+      console.log(chalk3.dim("  No plan nodes found."));
+      return;
+    }
+    if (opts.json) {
+      const tree2 = buildTree(nodes, edges);
+      print(tree2, { json: true });
+      return;
+    }
+    const tree = buildTree(nodes, edges);
+    const lines = renderTreeLines(tree);
+    if (lines.length === 0) {
+      console.log(chalk3.dim("  No plan nodes found."));
+      return;
+    }
+    console.log();
+    console.log(chalk3.bold(`  Plan tree (${nodes.length} nodes, ${edges.length} edges):`));
+    console.log();
+    for (const line of lines) {
+      console.log(`  ${line}`);
+    }
+    console.log();
+  });
+  plan.command("create-node").description("Create a new plan node").requiredOption("--project-id <id>", "Project ID").requiredOption("--title <title>", "Node title").option("--type <type>", "Node type: task, milestone, decision", "task").option("--description <desc>", "Node description").option("--status <status>", "Initial status", "planned").option("--parent-id <id>", "Parent node ID").option("--priority <priority>", "Priority: critical, high, normal, low").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    const id = `node-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+      await client.createPlanNode({
+        id,
+        projectId: cmdOpts.projectId,
+        title: cmdOpts.title,
+        type: cmdOpts.type,
+        description: cmdOpts.description,
+        status: cmdOpts.status,
+        parentId: cmdOpts.parentId ?? null,
+        priority: cmdOpts.priority ?? null
+      });
+      if (opts.json) {
+        print({ ok: true, id, projectId: cmdOpts.projectId, title: cmdOpts.title }, { json: true });
+      } else {
+        console.log(chalk3.green("Node created:"));
+        console.log(`  ${chalk3.bold("ID")}     ${id}`);
+        console.log(`  ${chalk3.bold("Title")}  ${cmdOpts.title}`);
+        console.log(`  ${chalk3.bold("Type")}   ${cmdOpts.type}`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk3.red(`Create failed: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  plan.command("update-node <nodeId>").description("Update a plan node").option("--title <title>", "New title").option("--status <status>", "New status").option("--description <desc>", "New description").option("--priority <priority>", "New priority: critical, high, normal, low").option("--type <type>", "New type: task, milestone, decision").action(async (nodeId, cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    const patch = {};
+    if (cmdOpts.title !== void 0) patch.title = cmdOpts.title;
+    if (cmdOpts.status !== void 0) patch.status = cmdOpts.status;
+    if (cmdOpts.description !== void 0) patch.description = cmdOpts.description;
+    if (cmdOpts.priority !== void 0) patch.priority = cmdOpts.priority;
+    if (cmdOpts.type !== void 0) patch.type = cmdOpts.type;
+    if (Object.keys(patch).length === 0) {
+      console.error(chalk3.red("No update fields provided. Use --title, --status, --description, --priority, or --type."));
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const result = await client.updatePlanNode(nodeId, patch);
+      if (opts.json) {
+        print({ ...result, nodeId, updated: Object.keys(patch) }, { json: true });
+      } else {
+        console.log(chalk3.green(`Node ${nodeId} updated: ${Object.keys(patch).join(", ")}`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk3.red(`Update failed: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  plan.command("delete-node <nodeId>").description("Delete a plan node").action(async (nodeId) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    try {
+      const result = await client.deletePlanNode(nodeId);
+      if (opts.json) {
+        print({ ...result, nodeId }, { json: true });
+      } else {
+        console.log(chalk3.green(`Node ${nodeId} deleted.`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk3.red(`Delete failed: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  plan.command("stats").description("Show plan statistics for a project").requiredOption("--project-id <id>", "Project ID").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    try {
+      const { nodes, edges } = await client.getPlan(cmdOpts.projectId);
+      const active = nodes.filter((n) => !n.deletedAt);
+      const statusCounts = {};
+      for (const n of active) {
+        statusCounts[n.status] = (statusCounts[n.status] || 0) + 1;
+      }
+      const withExecution = active.filter((n) => n.executionId).length;
+      const dates = active.flatMap((n) => [n.startDate, n.endDate].filter(Boolean)).map((d) => new Date(d).getTime()).filter((d) => !isNaN(d));
+      const minDate = dates.length > 0 ? new Date(Math.min(...dates)).toISOString().split("T")[0] : null;
+      const maxDate = dates.length > 0 ? new Date(Math.max(...dates)).toISOString().split("T")[0] : null;
+      const stats = {
+        totalNodes: active.length,
+        totalEdges: edges.length,
+        statusCounts,
+        executionCoverage: active.length > 0 ? `${withExecution}/${active.length} (${Math.round(withExecution / active.length * 100)}%)` : "0/0",
+        dateRange: minDate && maxDate ? `${minDate} \u2192 ${maxDate}` : "\u2014"
+      };
+      if (opts.json) {
+        print(stats, { json: true });
+        return;
+      }
+      console.log();
+      console.log(chalk3.bold("  Plan Statistics"));
+      console.log(chalk3.dim("  " + "\u2500".repeat(40)));
+      console.log(`  ${chalk3.dim("Total Nodes:")}       ${stats.totalNodes}`);
+      console.log(`  ${chalk3.dim("Total Edges:")}       ${stats.totalEdges}`);
+      console.log(`  ${chalk3.dim("Execution Coverage:")} ${stats.executionCoverage}`);
+      console.log(`  ${chalk3.dim("Date Range:")}        ${stats.dateRange}`);
+      console.log();
+      console.log(chalk3.bold("  Status Breakdown"));
+      for (const [status, count] of Object.entries(statusCounts).sort((a, b) => b[1] - a[1])) {
+        console.log(`    ${formatStatus(status).padEnd(25)} ${count}`);
+      }
+      console.log();
+    } catch (err) {
+      console.error(chalk3.red(err.message));
+      process.exitCode = 1;
+    }
+  });
+  plan.command("export").description("Export plan in various formats").requiredOption("--project-id <id>", "Project ID").option("--format <fmt>", "Output format: json, dot, mermaid", "json").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    let nodes, edges;
+    try {
+      const result = await client.getPlan(cmdOpts.projectId);
+      nodes = result.nodes.filter((n) => !n.deletedAt);
+      edges = result.edges;
+    } catch (err) {
+      console.error(chalk3.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    switch (cmdOpts.format) {
+      case "json":
+        console.log(JSON.stringify({ nodes, edges }, null, 2));
+        break;
+      case "dot": {
+        const lines = ["digraph plan {", "  rankdir=LR;", "  node [shape=box];"];
+        for (const n of nodes) {
+          const label = n.title.replace(/"/g, '\\"');
+          lines.push(`  "${n.id}" [label="${label}\\n[${n.status}]"];`);
+        }
+        for (const e of edges) {
+          lines.push(`  "${e.source}" -> "${e.target}";`);
+        }
+        lines.push("}");
+        console.log(lines.join("\n"));
+        break;
+      }
+      case "mermaid": {
+        const lines = ["graph LR"];
+        for (const n of nodes) {
+          const label = n.title.replace(/"/g, "'");
+          lines.push(`  ${n.id}["${label}<br/>${n.status}"]`);
+        }
+        for (const e of edges) {
+          lines.push(`  ${e.source} --> ${e.target}`);
+        }
+        console.log(lines.join("\n"));
+        break;
+      }
+      default:
+        console.error(chalk3.red(`Unknown format "${cmdOpts.format}". Use json, dot, or mermaid.`));
+        process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/task.ts
+import chalk4 from "chalk";
+function registerTaskCommands(program2) {
+  const cmd = program2.command("task").description("Manage tasks");
+  cmd.command("list").description("List tasks across projects").option("--project <id>", "Filter by project ID").option("--status <status>", "Filter by status (planned, in_progress, completed, etc.)").option("--since <date>", "Show tasks updated after date (e.g. 2d, 1h, today, ISO)").option("--until <date>", "Show tasks updated before date (e.g. 2d, 1h, yesterday, ISO)").action(async (opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
+    let nodes;
+    try {
+      const result = opts.project ? await client.getPlan(opts.project) : await client.getFullPlan();
+      nodes = result.nodes;
+    } catch (err) {
+      console.error(chalk4.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    let filtered = nodes.filter((n) => !n.deletedAt);
+    if (opts.status) {
+      filtered = filtered.filter((n) => n.status === opts.status);
+    }
+    if (opts.since) {
+      const since = parseDateFilter(opts.since);
+      filtered = filtered.filter((n) => n.updatedAt && new Date(n.updatedAt) >= since);
+    }
+    if (opts.until) {
+      const until = parseDateFilter(opts.until);
+      filtered = filtered.filter((n) => n.updatedAt && new Date(n.updatedAt) <= until);
+    }
+    filtered.sort((a, b) => {
+      const da = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+      const db = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+      return db - da;
+    });
+    const projects = await client.listProjects();
+    const projectMap = new Map(projects.map((p) => [p.id, p.name]));
+    const rows = filtered.map((n) => ({
+      id: n.id,
+      title: n.title,
+      status: n.status,
+      projectName: projectMap.get(n.projectId) ?? n.projectId,
+      updatedAt: n.updatedAt
+    }));
+    if (isJson) {
+      print(rows, { json: true });
+      return;
+    }
+    const columns = [
+      { key: "id", label: "ID", width: 12 },
+      { key: "title", label: "TITLE", width: 40 },
+      { key: "status", label: "STATUS", width: 18, format: (v) => formatStatus(String(v ?? "")) },
+      { key: "projectName", label: "PROJECT", width: 20 },
+      { key: "updatedAt", label: "UPDATED", width: 12, format: (v) => formatRelativeTime(v) }
+    ];
+    print(rows, { columns });
+  });
+  cmd.command("show <id>").description("Show task details").action(async (clientId) => {
+    const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
+    let nodes;
+    try {
+      const result = await client.getFullPlan();
+      nodes = result.nodes;
+    } catch (err) {
+      console.error(chalk4.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    const node = nodes.find((n) => n.id === clientId && !n.deletedAt);
+    if (!node) {
+      console.error(chalk4.red(`Task not found: ${clientId}`));
+      process.exitCode = 1;
+      return;
+    }
+    let projectName;
+    let latestExecution;
+    let changes = [];
+    try {
+      const projects = await client.listProjects();
+      const project = projects.find((p) => p.id === node.projectId);
+      projectName = project?.name ?? node.projectId;
+      const executionMap = await client.getExecutions();
+      latestExecution = executionMap[node.id] ?? null;
+      if (latestExecution?.executionId) {
+        changes = await client.listFileChanges(latestExecution.executionId);
+      }
+    } catch (err) {
+      console.error(chalk4.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    if (isJson) {
+      print({ ...node, projectName, execution: latestExecution, fileChanges: changes }, { json: true });
+      return;
+    }
+    console.log();
+    console.log(chalk4.bold(node.title));
+    console.log(chalk4.dim("\u2500".repeat(60)));
+    console.log(`  ${chalk4.dim("ID:")}           ${node.id}`);
+    console.log(`  ${chalk4.dim("Type:")}         ${node.type}`);
+    console.log(`  ${chalk4.dim("Status:")}       ${formatStatus(node.status)}`);
+    console.log(`  ${chalk4.dim("Project:")}      ${projectName}`);
+    if (node.priority) {
+      console.log(`  ${chalk4.dim("Priority:")}     ${node.priority}`);
+    }
+    if (node.estimate) {
+      console.log(`  ${chalk4.dim("Estimate:")}     ${node.estimate}`);
+    }
+    if (node.startDate) {
+      console.log(`  ${chalk4.dim("Start Date:")}   ${node.startDate}`);
+    }
+    if (node.endDate) {
+      console.log(`  ${chalk4.dim("End Date:")}     ${node.endDate}`);
+    }
+    if (node.dueDate) {
+      console.log(`  ${chalk4.dim("Due Date:")}     ${node.dueDate}`);
+    }
+    if (node.branchName) {
+      console.log(`  ${chalk4.dim("Branch:")}       ${node.branchName}`);
+    }
+    if (node.prUrl) {
+      console.log(`  ${chalk4.dim("PR:")}           ${node.prUrl}`);
+    }
+    if (node.description) {
+      console.log();
+      console.log(chalk4.dim("  Description:"));
+      console.log(`  ${node.description}`);
+    }
+    console.log();
+    console.log(`  ${chalk4.dim("Created:")}      ${formatRelativeTime(node.createdAt)}`);
+    console.log(`  ${chalk4.dim("Updated:")}      ${formatRelativeTime(node.updatedAt)}`);
+    if (latestExecution) {
+      console.log();
+      console.log(chalk4.bold("  Latest Execution"));
+      console.log(chalk4.dim("  " + "\u2500".repeat(56)));
+      console.log(`    ${chalk4.dim("Execution ID:")}  ${latestExecution.executionId}`);
+      console.log(`    ${chalk4.dim("Status:")}        ${formatStatus(latestExecution.status)}`);
+      if (latestExecution.providerName) {
+        console.log(`    ${chalk4.dim("Provider:")}      ${latestExecution.providerName}`);
+      }
+      if (latestExecution.model) {
+        console.log(`    ${chalk4.dim("Model:")}         ${latestExecution.model}`);
+      }
+      if (latestExecution.machineId) {
+        console.log(`    ${chalk4.dim("Machine:")}       ${latestExecution.machineId}`);
+      }
+      console.log(`    ${chalk4.dim("Started:")}       ${formatRelativeTime(latestExecution.startedAt)}`);
+      if (latestExecution.completedAt) {
+        console.log(`    ${chalk4.dim("Completed:")}     ${formatRelativeTime(latestExecution.completedAt)}`);
+      }
+      if (latestExecution.durationMs != null) {
+        const secs = (latestExecution.durationMs / 1e3).toFixed(1);
+        console.log(`    ${chalk4.dim("Duration:")}      ${secs}s`);
+      }
+      if (latestExecution.tokensUsed != null) {
+        console.log(`    ${chalk4.dim("Tokens:")}        ${latestExecution.tokensUsed.toLocaleString()}`);
+      }
+      if (latestExecution.estimatedCostUsd != null) {
+        console.log(`    ${chalk4.dim("Cost:")}          $${latestExecution.estimatedCostUsd.toFixed(4)}`);
+      }
+      if (latestExecution.error) {
+        console.log(`    ${chalk4.red("Error:")}         ${latestExecution.error}`);
+      }
+      if (latestExecution.markdownSummary) {
+        console.log();
+        console.log(chalk4.dim("    Summary:"));
+        console.log(`    ${latestExecution.markdownSummary}`);
+      }
+    }
+    if (changes.length > 0) {
+      console.log();
+      console.log(chalk4.bold("  File Changes"));
+      console.log(chalk4.dim("  " + "\u2500".repeat(56)));
+      for (const fc of changes) {
+        const actionColor = fc.action === "create" ? chalk4.green : fc.action === "delete" ? chalk4.red : chalk4.yellow;
+        const stats = [];
+        if (fc.linesAdded != null && fc.linesAdded > 0) stats.push(chalk4.green(`+${fc.linesAdded}`));
+        if (fc.linesRemoved != null && fc.linesRemoved > 0) stats.push(chalk4.red(`-${fc.linesRemoved}`));
+        const statsStr = stats.length > 0 ? ` (${stats.join(", ")})` : "";
+        console.log(`    ${actionColor(fc.action.padEnd(8))} ${fc.path}${statsStr}`);
+      }
+    }
+    console.log();
+  });
+  cmd.command("dispatch <id>").description("Dispatch a task for execution").requiredOption("--project-id <id>", "Project ID").option("--force", "Force re-dispatch even if already running").action(async (nodeId, opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    console.log(chalk4.dim(`Dispatching task ${chalk4.bold(nodeId)} to server...`));
+    console.log();
+    try {
+      const response = await client.dispatchTask({
+        nodeId,
+        projectId: opts.projectId,
+        force: opts.force
+      });
+      await streamDispatchToStdout(response);
+      console.log();
+      console.log(chalk4.green("Task dispatch complete."));
+    } catch (err) {
+      console.error(chalk4.red(`Dispatch failed: ${err instanceof Error ? err.message : String(err)}`));
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("cancel <executionId>").description("Cancel a running task execution").option("--machine <id>", "Target machine ID").option("--node-id <id>", "Node ID").action(async (executionId, opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
+    try {
+      const result = await client.cancelTask({
+        executionId,
+        machineId: opts.machine,
+        nodeId: opts.nodeId
+      });
+      if (isJson) {
+        print(result, { json: true });
+      } else {
+        console.log(chalk4.green(`Task ${executionId} cancelled.`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (isJson) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk4.red(`Cancel failed: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("steer <executionId>").description("Send steering guidance to a running task").requiredOption("--machine <id>", "Target machine ID").requiredOption("--message <msg>", "Steering message").option("--action <action>", "Action type: guidance, redirect, pause, resume").action(async (executionId, opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
+    try {
+      const result = await client.steerTask({
+        taskId: executionId,
+        machineId: opts.machine,
+        message: opts.message,
+        action: opts.action
+      });
+      if (isJson) {
+        print(result, { json: true });
+      } else {
+        console.log(chalk4.green(`Steering message sent to ${executionId}.`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (isJson) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk4.red(`Steer failed: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("update-status <nodeId>").description("Update a task node status").requiredOption("--status <status>", "New status (planned, in_progress, completed, etc.)").action(async (nodeId, opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
+    try {
+      const result = await client.updatePlanNode(nodeId, { status: opts.status });
+      if (isJson) {
+        print(result, { json: true });
+      } else {
+        console.log(chalk4.green(`Task ${nodeId} status updated to ${formatStatus(opts.status)}.`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (isJson) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk4.red(`Update failed: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("watch <executionId>").description("Watch real-time output from a running task via SSE").action(async (executionId) => {
+    const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
+    try {
+      const response = await client.streamEvents();
+      if (!response.body) {
+        console.error(chalk4.red("No stream body received"));
+        process.exitCode = 1;
+        return;
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          try {
+            const event = JSON.parse(line.slice(6));
+            if (event.taskId && event.taskId !== executionId) continue;
+            if (isJson) {
+              console.log(JSON.stringify(event));
+              continue;
+            }
+            switch (event.type) {
+              case "task:text":
+                process.stdout.write(event.content ?? event.data ?? "");
+                break;
+              case "task:tool_trace":
+                console.log(chalk4.dim(`[tool] ${event.name ?? "unknown"}`));
+                break;
+              case "task:result":
+                console.log(`
+${chalk4.bold("--- Result:")} ${formatStatus(event.status ?? "unknown")} ${event.duration != null ? chalk4.dim(`(${formatDuration(event.duration)})`) : ""}`);
+                if (event.summary) console.log(event.summary);
+                reader.cancel();
+                return;
+              case "task:progress":
+                if (event.message) console.log(chalk4.dim(`[progress] ${event.message}`));
+                break;
+              case "task:stdout":
+                process.stdout.write(event.data ?? "");
+                break;
+            }
+          } catch {
+          }
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (isJson) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk4.red(`Watch failed: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/search.ts
+import chalk5 from "chalk";
+function registerSearchCommands(program2) {
+  program2.command("search <query>").description("Search across projects, tasks, and executions").option("--type <type>", "Filter by type: projects, tasks, executions").option("--since <date>", "Show results updated after date (e.g. 2d, 1h, today, ISO)").option("--until <date>", "Show results updated before date (e.g. 2d, 1h, yesterday, ISO)").action(async (query, cmdOpts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
+    let projectResults, taskResults, executionResults;
+    try {
+      const results = await client.search(query);
+      projectResults = results.projects;
+      taskResults = results.tasks;
+      executionResults = results.executions;
+    } catch (err) {
+      console.error(chalk5.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    if (cmdOpts.since) {
+      const since = parseDateFilter(cmdOpts.since);
+      projectResults = projectResults.filter((p) => p.updatedAt && new Date(p.updatedAt) >= since);
+      taskResults = taskResults.filter((t) => t.updatedAt && new Date(t.updatedAt) >= since);
+      executionResults = executionResults.filter((e) => e.startedAt && new Date(e.startedAt) >= since);
+    }
+    if (cmdOpts.until) {
+      const until = parseDateFilter(cmdOpts.until);
+      projectResults = projectResults.filter((p) => p.updatedAt && new Date(p.updatedAt) <= until);
+      taskResults = taskResults.filter((t) => t.updatedAt && new Date(t.updatedAt) <= until);
+      executionResults = executionResults.filter((e) => e.startedAt && new Date(e.startedAt) <= until);
+    }
+    if (cmdOpts.type) {
+      if (cmdOpts.type !== "projects") projectResults = [];
+      if (cmdOpts.type !== "tasks") taskResults = [];
+      if (cmdOpts.type !== "executions") executionResults = [];
+    }
+    if (isJson) {
+      print(
+        {
+          projects: projectResults,
+          tasks: taskResults,
+          executions: executionResults
+        },
+        { json: true }
+      );
+      return;
+    }
+    const totalMatches = projectResults.length + taskResults.length + executionResults.length;
+    if (totalMatches === 0) {
+      console.log(chalk5.dim(`No results for "${query}"`));
+      return;
+    }
+    if (projectResults.length > 0) {
+      console.log();
+      console.log(chalk5.bold(`Projects (${projectResults.length} match${projectResults.length === 1 ? "" : "es"}):`));
+      const projectCols = [
+        { key: "id", label: "ID", width: 8, format: (v) => String(v ?? "").slice(0, 8) },
+        { key: "name", label: "NAME", width: 30 },
+        { key: "status", label: "STATUS", width: 12, format: (v) => formatStatus(String(v ?? "")) },
+        { key: "workingDirectory", label: "DIRECTORY", width: 40, format: (v) => String(v ?? "") }
+      ];
+      print(projectResults, { columns: projectCols });
+    }
+    if (taskResults.length > 0) {
+      console.log();
+      console.log(chalk5.bold(`Tasks (${taskResults.length} match${taskResults.length === 1 ? "" : "es"}):`));
+      const taskCols = [
+        { key: "clientId", label: "CLIENT_ID", width: 12 },
+        { key: "title", label: "TITLE", width: 35 },
+        { key: "status", label: "STATUS", width: 18, format: (v) => formatStatus(String(v ?? "")) },
+        { key: "projectName", label: "PROJECT", width: 20, format: (v) => String(v ?? "") }
+      ];
+      print(taskResults, { columns: taskCols });
+    }
+    if (executionResults.length > 0) {
+      console.log();
+      console.log(chalk5.bold(`Executions (${executionResults.length} match${executionResults.length === 1 ? "" : "es"}):`));
+      const execCols = [
+        { key: "executionId", label: "EXECUTION_ID", width: 20 },
+        { key: "nodeClientId", label: "NODE_ID", width: 12 },
+        { key: "status", label: "STATUS", width: 12, format: (v) => formatStatus(String(v ?? "")) },
+        {
+          key: "startedAt",
+          label: "STARTED",
+          width: 20,
+          format: (v) => {
+            if (!v) return "";
+            const d = v instanceof Date ? v : new Date(String(v));
+            return d.toLocaleString();
+          }
+        }
+      ];
+      print(executionResults, { columns: execCols });
+    }
+    console.log();
+  });
+}
+
+// src/commands/activity.ts
+import chalk6 from "chalk";
+var activityColumns = [
+  { key: "time", label: "TIME", width: 12, format: (v) => formatRelativeTime(v) },
+  { key: "type", label: "TYPE", width: 20 },
+  { key: "title", label: "TITLE", width: 40 },
+  { key: "projectId", label: "PROJECT_ID", width: 12, format: (v) => v ? String(v).slice(0, 8) : "\u2014" },
+  { key: "nodeId", label: "NODE_ID", width: 12, format: (v) => v ? String(v).slice(0, 8) : "\u2014" }
+];
+function registerActivityCommands(program2) {
+  const cmd = program2.command("activity").description("View activity feed");
+  cmd.command("list").description("List recent activity").option("--project <id>", "Filter by project").option("--limit <n>", "Number of entries", "20").option("--type <type>", "Filter by event type").option("--since <date>", "Show events after date (e.g. 2d, 1h, today, ISO)").option("--until <date>", "Show events before date (e.g. 2d, 1h, yesterday, ISO)").action(async (opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    let rows;
+    try {
+      rows = await client.listActivities({
+        projectId: opts.project,
+        limit: opts.limit
+      });
+    } catch (err) {
+      console.error(err.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (opts.type) {
+      rows = rows.filter((r) => r.type === opts.type);
+    }
+    if (opts.since) {
+      const since = parseDateFilter(opts.since);
+      rows = rows.filter((r) => r.createdAt && new Date(r.createdAt) >= since);
+    }
+    if (opts.until) {
+      const until = parseDateFilter(opts.until);
+      rows = rows.filter((r) => r.createdAt && new Date(r.createdAt) <= until);
+    }
+    const formatted = rows.map((r) => ({
+      time: r.createdAt,
+      type: r.type,
+      title: r.title,
+      projectId: r.projectId,
+      nodeId: r.nodeId,
+      description: r.description,
+      metadata: r.metadata,
+      id: r.id
+    }));
+    print(formatted, { json, columns: activityColumns });
+  });
+  cmd.command("watch").description("Watch real-time activity events via SSE").option("--project <id>", "Filter by project").option("--type <type>", "Filter by event type").action(async (opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
+    try {
+      const response = await client.streamEvents({ projectId: opts.project });
+      if (!response.body) {
+        console.error(chalk6.red("No stream body received"));
+        process.exitCode = 1;
+        return;
+      }
+      if (!isJson) {
+        console.log(chalk6.dim("Watching activity events... (Ctrl+C to stop)"));
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          try {
+            const event = JSON.parse(line.slice(6));
+            if (event.type === "heartbeat") continue;
+            if (opts.type && event.type !== opts.type) continue;
+            if (isJson) {
+              console.log(JSON.stringify(event));
+              continue;
+            }
+            const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+            const taskStr = event.taskId ? chalk6.dim(` ${event.taskId.slice(0, 12)}`) : "";
+            const statusStr = event.status ? ` ${event.status}` : "";
+            const durationStr = event.duration != null ? chalk6.dim(` (${formatDuration(event.duration)})`) : "";
+            const msgStr = event.message ? ` ${event.message}` : "";
+            console.log(`[${chalk6.dim(time)}] ${chalk6.bold(event.type)}${taskStr}${statusStr}${durationStr}${msgStr}`);
+          } catch {
+          }
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (isJson) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk6.red(`Watch failed: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/trace.ts
+import chalk7 from "chalk";
+function formatTime(date) {
+  if (!date) return "\u2014";
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+function formatTraceDuration(ms) {
+  if (ms == null) return "\u2014";
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function formatTokens(n) {
+  if (n == null) return "\u2014";
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+var traceColumns = [
+  { key: "time", label: "TIME", width: 12, format: (v) => formatTime(v) },
+  { key: "tool", label: "TOOL", width: 24 },
+  { key: "duration", label: "DURATION", width: 12, format: (v) => formatTraceDuration(v) },
+  { key: "status", label: "STATUS", width: 8, format: (v) => v ? chalk7.green("\u2713") : chalk7.red("\u2717") }
+];
+function registerTraceCommands(program2) {
+  const cmd = program2.command("trace").description("View execution traces");
+  cmd.command("list").description("List tool traces for an execution").requiredOption("--execution-id <id>", "Execution ID").option("--since <date>", "Show traces after date (e.g. 2d, 1h, today, ISO)").option("--until <date>", "Show traces before date (e.g. 2d, 1h, yesterday, ISO)").action(async (opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    const executionId = opts.executionId;
+    let traces;
+    let changes;
+    let execution;
+    try {
+      if (opts.since || opts.until) {
+        const params = { executionId };
+        if (opts.since) params.startAfter = parseDateFilter(opts.since).toISOString();
+        if (opts.until) params.startBefore = parseDateFilter(opts.until).toISOString();
+      }
+      traces = await client.listToolTraces(executionId);
+      if (opts.since) {
+        const since = parseDateFilter(opts.since);
+        traces = traces.filter((t) => t.timestamp && new Date(t.timestamp) >= since);
+      }
+      if (opts.until) {
+        const until = parseDateFilter(opts.until);
+        traces = traces.filter((t) => t.timestamp && new Date(t.timestamp) <= until);
+      }
+      changes = await client.listFileChanges(executionId);
+      const executionsMap = await client.getExecutions();
+      execution = Object.values(executionsMap).find(
+        (e) => e.executionId === executionId
+      ) ?? null;
+    } catch (err) {
+      console.error(chalk7.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    const formatted = traces.map((t) => ({
+      time: t.timestamp,
+      tool: t.toolName,
+      duration: t.duration,
+      status: t.success
+    }));
+    if (json) {
+      print({
+        traces,
+        fileChanges: changes,
+        execution,
+        summary: {
+          totalToolCalls: traces.length,
+          totalDurationMs: traces.reduce((sum, t) => sum + (t.duration ?? 0), 0),
+          filesChanged: changes.length,
+          totalTokens: execution ? (execution.inputTokens ?? 0) + (execution.outputTokens ?? 0) : 0
+        }
+      }, { json: true });
+      return;
+    }
+    print(formatted, { columns: traceColumns });
+    if (changes.length > 0) {
+      const actionCounts = {};
+      for (const c of changes) {
+        actionCounts[c.action] = (actionCounts[c.action] || 0) + 1;
+      }
+      const parts = Object.entries(actionCounts).map(([action, count]) => `${count} ${action}d`);
+      console.log(`
+${chalk7.bold("Files changed:")} ${changes.length} (${parts.join(", ")})`);
+    } else {
+      console.log(`
+${chalk7.bold("Files changed:")} 0`);
+    }
+    const totalCalls = traces.length;
+    const totalDurationMs = traces.reduce((sum, t) => sum + (t.duration ?? 0), 0);
+    const totalTokens = execution ? (execution.inputTokens ?? 0) + (execution.outputTokens ?? 0) : 0;
+    console.log(
+      `${chalk7.bold("Total:")} ${totalCalls} tool calls, ${formatTraceDuration(totalDurationMs)}, ${formatTokens(totalTokens)} tokens`
+    );
+  });
+  cmd.command("show").description("Show full trace details for an execution").requiredOption("--execution-id <id>", "Execution ID").action(async (opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    const executionId = opts.executionId;
+    let observations;
+    try {
+      const result = await client.listObservations(executionId);
+      observations = result.data;
+    } catch (err) {
+      console.error(chalk7.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    if (json) {
+      print(observations, { json: true });
+      return;
+    }
+    if (observations.length === 0) {
+      console.log(chalk7.dim("  No observation events found for this execution."));
+      return;
+    }
+    console.log(chalk7.bold(`Trace: ${executionId}
+`));
+    console.log(chalk7.bold("NAME".padEnd(30) + "  TYPE".padEnd(14) + "  MODEL".padEnd(22) + "  TOKENS".padEnd(12) + "  COST"));
+    console.log(chalk7.dim("\u2500".repeat(90)));
+    for (const obs of observations) {
+      const name = (obs.name ?? "\u2014").slice(0, 28).padEnd(30);
+      const type = (obs.type ?? "\u2014").padEnd(12);
+      const model = (obs.model ?? "\u2014").slice(0, 20).padEnd(22);
+      const tokens = obs.inputTokens != null || obs.outputTokens != null ? formatTokens((obs.inputTokens ?? 0) + (obs.outputTokens ?? 0)).padEnd(12) : "\u2014".padEnd(12);
+      const cost = obs.estimatedCostUsd != null ? `$${obs.estimatedCostUsd.toFixed(4)}` : "\u2014";
+      console.log(`${name}${type}${model}${tokens}${cost}`);
+    }
+    const totalTokens = observations.reduce(
+      (sum, o) => sum + (o.inputTokens ?? 0) + (o.outputTokens ?? 0),
+      0
+    );
+    const totalCost = observations.reduce(
+      (sum, o) => sum + (o.estimatedCostUsd ?? 0),
+      0
+    );
+    console.log(chalk7.dim("\u2500".repeat(90)));
+    console.log(
+      chalk7.bold(`Total: ${observations.length} events, ${formatTokens(totalTokens)} tokens, $${totalCost.toFixed(4)}`)
+    );
+  });
+  cmd.command("summary").description("Show markdown summary for an execution").requiredOption("--execution-id <id>", "Execution ID").action(async (opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    const executionId = opts.executionId;
+    try {
+      const summary = await client.getTraceSummary(executionId);
+      if (json) {
+        print({ executionId, summary }, { json: true });
+      } else {
+        console.log(summary);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk7.red(`Failed to get summary: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("stats").description("Show observation statistics for an execution").requiredOption("--execution-id <id>", "Execution ID").action(async (opts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    const executionId = opts.executionId;
+    try {
+      const stats = await client.getObservationStats(executionId);
+      if (json) {
+        print(stats, { json: true });
+        return;
+      }
+      console.log();
+      console.log(chalk7.bold("  Observation Statistics"));
+      console.log(chalk7.dim("  " + "\u2500".repeat(40)));
+      console.log(`  ${chalk7.dim("Total Events:")}       ${stats.totalEvents}`);
+      console.log(`  ${chalk7.dim("Total Spans:")}        ${stats.totalSpans}`);
+      console.log(`  ${chalk7.dim("Total Generations:")}  ${stats.totalGenerations}`);
+      console.log(`  ${chalk7.dim("Total Tools:")}        ${stats.totalTools}`);
+      console.log(`  ${chalk7.dim("Errors:")}             ${stats.errorCount > 0 ? chalk7.red(String(stats.errorCount)) : "0"}`);
+      console.log(`  ${chalk7.dim("Warnings:")}           ${stats.warningCount > 0 ? chalk7.yellow(String(stats.warningCount)) : "0"}`);
+      console.log(`  ${chalk7.dim("Input Tokens:")}       ${formatTokens(stats.totalInputTokens)}`);
+      console.log(`  ${chalk7.dim("Output Tokens:")}      ${formatTokens(stats.totalOutputTokens)}`);
+      console.log(`  ${chalk7.dim("Total Cost:")}         $${stats.totalCostUsd.toFixed(4)}`);
+      console.log();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk7.red(`Failed to get stats: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/env.ts
+import chalk8 from "chalk";
+var envColumns = [
+  { key: "id", label: "ID", width: 10, format: (v) => String(v ?? "").slice(0, 8) },
+  { key: "name", label: "NAME", width: 20 },
+  { key: "hostname", label: "HOSTNAME", width: 24 },
+  { key: "platform", label: "PLATFORM", width: 10 },
+  { key: "providers", label: "PROVIDERS", width: 24, format: (v) => Array.isArray(v) ? v.join(", ") : "\u2014" },
+  { key: "connected", label: "CONNECTED", width: 10, format: (v) => v ? chalk8.green("\u2713") : chalk8.dim("\u2717") },
+  { key: "lastSeen", label: "LAST_SEEN", width: 14, format: (v) => formatRelativeTime(v) }
+];
+function registerEnvCommands(program2) {
+  const cmd = program2.command("env").description("Manage environments and machines");
+  cmd.command("list").description("List registered machines").action(async () => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    const machines = await client.listMachines();
+    const active = machines.filter((m) => !m.isRevoked);
+    const formatted = active.map((m) => ({
+      id: m.id,
+      name: m.name,
+      hostname: m.hostname,
+      platform: m.platform,
+      providers: m.providers,
+      connected: m.isConnected,
+      lastSeen: m.lastSeenAt,
+      environmentType: m.environmentType
+    }));
+    print(formatted, { json, columns: envColumns });
+  });
+  cmd.command("show <id>").description("Show machine details").action(async (id) => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    let machine;
+    try {
+      machine = await client.resolveMachine(id);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk8.red(msg));
+      }
+      process.exitCode = 1;
+      return;
+    }
+    if (json) {
+      print(machine, { json: true });
+      return;
+    }
+    console.log(chalk8.bold(`Machine: ${machine.name}
+`));
+    const fields = [
+      ["ID", machine.id],
+      ["Name", machine.name],
+      ["Hostname", machine.hostname],
+      ["Platform", machine.platform],
+      ["Environment", machine.environmentType],
+      ["Providers", (machine.providers ?? []).join(", ") || "\u2014"],
+      ["Connected", machine.isConnected ? chalk8.green("Yes") : chalk8.dim("No")],
+      ["Revoked", machine.isRevoked ? chalk8.red("Yes") : "No"],
+      ["Workspace ID", machine.workspaceId ?? "\u2014"],
+      ["Registered", machine.registeredAt ?? "\u2014"],
+      ["Last Seen", formatRelativeTime(machine.lastSeenAt)]
+    ];
+    for (const [label, value] of fields) {
+      console.log(`  ${chalk8.dim(label.padEnd(14))} ${value}`);
+    }
+    if (machine.metadata && Object.keys(machine.metadata).length > 0) {
+      console.log(`
+  ${chalk8.dim("Metadata:")}`);
+      for (const [k, v] of Object.entries(machine.metadata)) {
+        console.log(`    ${chalk8.dim(k)}: ${v}`);
+      }
+    }
+    if (machine.providerConfigs && Array.isArray(machine.providerConfigs) && machine.providerConfigs.length > 0) {
+      console.log(`
+  ${chalk8.dim("Provider Configs:")}`);
+      for (const cfg of machine.providerConfigs) {
+        const enabled = cfg.enabled ? chalk8.green("enabled") : chalk8.dim("disabled");
+        console.log(`    ${cfg.provider}: ${enabled}${cfg.defaultModel ? ` (model: ${cfg.defaultModel})` : ""}`);
+      }
+    }
+  });
+  cmd.command("remove <id>").description("Remove/revoke a registered machine").action(async (id) => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    let machine;
+    try {
+      machine = await client.resolveMachine(id);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk8.red(msg));
+      }
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      await client.revokeMachine(machine.id);
+      if (json) {
+        print({ ok: true, machineId: machine.id, name: machine.name }, { json: true });
+      } else {
+        console.log(chalk8.green(`Revoked machine "${machine.name}" (${machine.id.slice(0, 8)})`));
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (json) {
+        print({ error: errMsg }, { json: true });
+      } else {
+        console.error(chalk8.red(`Failed to revoke machine: ${errMsg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("set-default <id>").description("Set default machine for task dispatch").action(async (id) => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    let machine;
+    try {
+      machine = await client.resolveMachine(id);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk8.red(msg));
+      }
+      process.exitCode = 1;
+      return;
+    }
+    saveConfig({ defaultMachineId: machine.id });
+    if (json) {
+      print({ ok: true, defaultMachineId: machine.id, name: machine.name }, { json: true });
+    } else {
+      console.log(chalk8.green(`Default machine set to "${machine.name}" (${machine.id.slice(0, 8)})`));
+    }
+  });
+  cmd.command("status").description("Show relay server status and summary").action(async () => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    try {
+      const status = await client.getRelayStatus();
+      if (json) {
+        print(status, { json: true });
+        return;
+      }
+      console.log();
+      console.log(chalk8.bold("  Relay Server Status"));
+      console.log(chalk8.dim("  " + "\u2500".repeat(40)));
+      const server = status.server;
+      if (server) {
+        console.log(`  ${chalk8.dim("Running:")}    ${server.running ? chalk8.green("Yes") : chalk8.red("No")}`);
+        if (server.port) console.log(`  ${chalk8.dim("Port:")}       ${server.port}`);
+      }
+      const machines = status.machines;
+      if (machines) {
+        console.log();
+        console.log(chalk8.bold("  Machines"));
+        console.log(`    ${chalk8.dim("Total:")}       ${machines.total ?? 0}`);
+        console.log(`    ${chalk8.dim("Connected:")}   ${machines.connected ?? 0}`);
+        console.log(`    ${chalk8.dim("Available:")}   ${machines.available ?? 0}`);
+      }
+      const redis = status.redis;
+      if (redis) {
+        console.log();
+        console.log(`  ${chalk8.dim("Redis:")}      ${redis.connected ? chalk8.green("Connected") : chalk8.dim("Not connected")}`);
+      }
+      if (status.timestamp) {
+        console.log(`  ${chalk8.dim("Timestamp:")}  ${status.timestamp}`);
+      }
+      console.log();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk8.red(`Failed to get relay status: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("providers").description("List all providers across machines").action(async () => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    try {
+      const machines = await client.listMachines();
+      const active = machines.filter((m) => !m.isRevoked);
+      const providers = [];
+      for (const m of active) {
+        if (m.providerConfigs && Array.isArray(m.providerConfigs)) {
+          for (const cfg of m.providerConfigs) {
+            providers.push({
+              machine: m.name,
+              machineId: m.id.slice(0, 8),
+              provider: cfg.provider,
+              enabled: cfg.enabled,
+              model: cfg.defaultModel ?? "\u2014",
+              connected: m.isConnected
+            });
+          }
+        } else if (m.providers && Array.isArray(m.providers)) {
+          for (const p of m.providers) {
+            providers.push({
+              machine: m.name,
+              machineId: m.id.slice(0, 8),
+              provider: p,
+              enabled: true,
+              model: "\u2014",
+              connected: m.isConnected
+            });
+          }
+        }
+      }
+      if (json) {
+        print(providers, { json: true });
+        return;
+      }
+      const columns = [
+        { key: "machine", label: "MACHINE", width: 16 },
+        { key: "provider", label: "PROVIDER", width: 16 },
+        { key: "enabled", label: "ENABLED", width: 8, format: (v) => v ? chalk8.green("\u2713") : chalk8.dim("\u2717") },
+        { key: "model", label: "MODEL", width: 24 },
+        { key: "connected", label: "CONNECTED", width: 10, format: (v) => v ? chalk8.green("\u2713") : chalk8.dim("\u2717") }
+      ];
+      print(providers, { columns });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk8.red(`Failed to list providers: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("clusters").description("List HPC/SLURM clusters").action(async () => {
+    const client = getClient(program2.opts().serverUrl);
+    const json = program2.opts().json;
+    try {
+      const clusters = await client.getSlurmClusters();
+      if (json) {
+        print(clusters, { json: true });
+        return;
+      }
+      if (!Array.isArray(clusters) || clusters.length === 0) {
+        console.log(chalk8.dim("  No SLURM clusters registered."));
+        return;
+      }
+      const columns = [
+        { key: "name", label: "NAME", width: 20 },
+        { key: "hostname", label: "HOSTNAME", width: 24 },
+        { key: "gpus", label: "GPUS", width: 8 },
+        { key: "activeJobs", label: "ACTIVE JOBS", width: 12 },
+        { key: "status", label: "STATUS", width: 12 }
+      ];
+      print(clusters, { columns });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (json) {
+        print({ error: msg }, { json: true });
+      } else {
+        console.error(chalk8.red(`Failed to list clusters: ${msg}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/config.ts
+import chalk9 from "chalk";
+var KEY_MAP = {
+  "server-url": "serverUrl",
+  "default-machine": "defaultMachineId",
+  "auth-token": "authToken",
+  "refresh-token": "refreshToken"
+};
+var SUPPORTED_KEYS = Object.keys(KEY_MAP);
+function resolveKey(key) {
+  if (KEY_MAP[key]) return KEY_MAP[key];
+  if (Object.values(KEY_MAP).includes(key)) return key;
+  return null;
+}
+function registerConfigCommands(program2) {
+  const cmd = program2.command("config").description("Manage CLI configuration");
+  cmd.command("show").description("Show current configuration").action(() => {
+    const json = program2.opts().json;
+    const config = loadConfig();
+    if (json) {
+      print(config, { json: true });
+      return;
+    }
+    const entries = Object.entries(config);
+    if (entries.length === 0) {
+      console.log(chalk9.dim("  No configuration set."));
+      return;
+    }
+    console.log(chalk9.bold("Configuration:\n"));
+    for (const [key, value] of entries) {
+      const displayValue = (key === "authToken" || key === "refreshToken") && typeof value === "string" && value.length > 8 ? value.slice(0, 4) + "..." + value.slice(-4) : String(value ?? "\u2014");
+      console.log(`  ${chalk9.dim(key.padEnd(20))} ${displayValue}`);
+    }
+  });
+  cmd.command("set <key> <value>").description(`Set a configuration value. Keys: ${SUPPORTED_KEYS.join(", ")}
+
+  Example: astro config set server-url http://localhost:3001`).action((key, value) => {
+    const json = program2.opts().json;
+    const resolved = resolveKey(key);
+    if (!resolved) {
+      if (json) {
+        print({ error: `Unknown config key "${key}". Supported: ${SUPPORTED_KEYS.join(", ")}` }, { json: true });
+      } else {
+        console.error(chalk9.red(`Unknown config key "${key}"`));
+        console.error(`Supported keys: ${SUPPORTED_KEYS.join(", ")}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    saveConfig({ [resolved]: value });
+    if (json) {
+      print({ ok: true, key: resolved, value }, { json: true });
+    } else {
+      console.log(chalk9.green(`Set ${key} = ${value}`));
+    }
+  });
+  cmd.command("get <key>").description(`Get a configuration value. Keys: ${SUPPORTED_KEYS.join(", ")}`).action((key) => {
+    const json = program2.opts().json;
+    const resolved = resolveKey(key);
+    if (!resolved) {
+      if (json) {
+        print({ error: `Unknown config key "${key}". Supported: ${SUPPORTED_KEYS.join(", ")}` }, { json: true });
+      } else {
+        console.error(chalk9.red(`Unknown config key "${key}"`));
+        console.error(`Supported keys: ${SUPPORTED_KEYS.join(", ")}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const config = loadConfig();
+    const value = config[resolved];
+    if (json) {
+      print({ key: resolved, value: value ?? null }, { json: true });
+    } else {
+      if (value != null) {
+        const displayValue = (resolved === "authToken" || resolved === "refreshToken") && typeof value === "string" && value.length > 8 ? value.slice(0, 4) + "..." + value.slice(-4) : String(value);
+        console.log(displayValue);
+      } else {
+        console.log(chalk9.dim("(not set)"));
+      }
+    }
+  });
+}
+
+// src/commands/auth.ts
+import chalk10 from "chalk";
+import { exec } from "child_process";
+import { hostname, platform } from "os";
+function openUrl(url) {
+  const cmd = platform() === "darwin" ? "open" : "xdg-open";
+  exec(`${cmd} ${JSON.stringify(url)}`, () => {
+  });
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function registerAuthCommands(program2) {
+  program2.command("login").description("Authenticate with the Astro server via device code flow").action(async () => {
+    const json = program2.opts().json;
+    resetConfig();
+    const serverUrl = program2.opts().serverUrl || getServerUrl();
+    try {
+      const authRes = await fetch(new URL("/api/device/authorize", serverUrl).toString(), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          scopes: ["machine:connect", "machine:execute", "machine:read"],
+          machineInfo: {
+            hostname: hostname(),
+            platform: platform()
+          }
+        })
+      });
+      if (!authRes.ok) {
+        const text = await authRes.text();
+        throw new Error(`Failed to request device code: ${text}`);
+      }
+      const authData = await authRes.json();
+      if (!json) {
+        console.log();
+        console.log(chalk10.bold("Device Authorization"));
+        console.log();
+        console.log(`  Code:  ${chalk10.bold.cyan(authData.deviceCode)}`);
+        console.log(`  URL:   ${chalk10.underline(authData.verificationUri)}`);
+        console.log();
+        console.log(chalk10.dim("Opening browser..."));
+      }
+      openUrl(authData.verificationUriComplete);
+      let interval = authData.interval * 1e3;
+      const deadline = Date.now() + authData.expiresIn * 1e3;
+      while (Date.now() < deadline) {
+        await sleep(interval);
+        const tokenRes = await fetch(new URL("/api/device/token", serverUrl).toString(), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            userCode: authData.userCode,
+            grantType: "urn:ietf:params:oauth:grant-type:device_code"
+          })
+        });
+        if (tokenRes.ok) {
+          const tokenData = await tokenRes.json();
+          saveConfig({
+            serverUrl,
+            authToken: tokenData.accessToken,
+            refreshToken: tokenData.refreshToken
+          });
+          if (json) {
+            print({ ok: true, expiresIn: tokenData.expiresIn }, { json: true });
+          } else {
+            console.log(chalk10.green("\nAuthenticated successfully!"));
+          }
+          return;
+        }
+        const errData = await tokenRes.json();
+        switch (errData.error) {
+          case "authorization_pending":
+            if (!json) {
+              process.stdout.write(chalk10.dim("."));
+            }
+            break;
+          case "slow_down":
+            interval += 5e3;
+            break;
+          case "access_denied":
+            throw new Error("Authorization denied by user");
+          case "expired_token":
+            throw new Error("Device code expired. Please try again.");
+          default:
+            throw new Error(errData.errorDescription || errData.error);
+        }
+      }
+      throw new Error("Device code expired. Please try again.");
+    } catch (err) {
+      if (json) {
+        print({ error: err instanceof Error ? err.message : String(err) }, { json: true });
+      } else {
+        console.error(chalk10.red(`
+Login failed: ${err instanceof Error ? err.message : err}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  program2.command("logout").description("Clear stored authentication tokens").action(async () => {
+    const json = program2.opts().json;
+    const config = loadConfig();
+    const serverUrl = getServerUrl(program2.opts().serverUrl);
+    if (config.refreshToken) {
+      try {
+        await fetch(new URL("/api/device/revoke", serverUrl).toString(), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ token: config.refreshToken })
+        });
+      } catch {
+      }
+    }
+    clearAuth();
+    if (json) {
+      print({ ok: true }, { json: true });
+    } else {
+      console.log(chalk10.green("Logged out."));
+    }
+  });
+  program2.command("whoami").description("Show current authentication status").action(async () => {
+    const json = program2.opts().json;
+    const config = loadConfig();
+    if (!config.authToken) {
+      if (json) {
+        print({ authenticated: false }, { json: true });
+      } else {
+        console.log(chalk10.yellow("Not logged in. Run `astro login` to authenticate."));
+      }
+      return;
+    }
+    const serverUrl = getServerUrl(program2.opts().serverUrl);
+    try {
+      const res = await fetch(new URL("/api/health", serverUrl).toString(), {
+        headers: { Authorization: `Bearer ${config.authToken}` }
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (json) {
+          print({ authenticated: true, server: serverUrl, ...data }, { json: true });
+        } else {
+          console.log(chalk10.green("Authenticated"));
+          console.log(`  Server:  ${serverUrl}`);
+          if (data.mode) console.log(`  Mode:    ${data.mode}`);
+        }
+      } else if (res.status === 401) {
+        if (json) {
+          print({ authenticated: false, expired: true }, { json: true });
+        } else {
+          console.log(chalk10.yellow("Token expired. Run `astro login` to re-authenticate."));
+        }
+      } else {
+        throw new Error(`Server returned ${res.status}`);
+      }
+    } catch (err) {
+      if (json) {
+        print({ authenticated: false, error: err instanceof Error ? err.message : String(err) }, { json: true });
+      } else {
+        console.error(chalk10.red(`Failed to reach server: ${err instanceof Error ? err.message : err}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/completion.ts
+function generateBashCompletion(program2) {
+  const topLevel = program2.commands.map((c) => c.name()).join(" ");
+  return `# bash completion for astro-cli
+_astro_cli_completions() {
+  local cur prev commands
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  # Top-level commands
+  commands="${topLevel}"
+
+  case "\${prev}" in
+${program2.commands.map((cmd) => {
+    const subs = cmd.commands.map((c) => c.name()).join(" ");
+    return `    ${cmd.name()})
+      COMPREPLY=( $(compgen -W "${subs}" -- "\${cur}") )
+      return 0
+      ;;`;
+  }).join("\n")}
+  esac
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+    return 0
+  fi
+
+  # Options
+  if [[ "\${cur}" == -* ]]; then
+    COMPREPLY=( $(compgen -W "--json --quiet --server-url --help --version" -- "\${cur}") )
+    return 0
+  fi
+}
+
+complete -F _astro_cli_completions astro-cli
+`;
+}
+function generateZshCompletion(program2) {
+  const groups = program2.commands.map((cmd) => {
+    const desc = cmd.description() ?? cmd.name();
+    return `    '${cmd.name()}:${desc.replace(/'/g, "")}'`;
+  }).join("\n");
+  const subcommandCases = program2.commands.map((cmd) => {
+    const subs = cmd.commands.map((sub) => {
+      const desc = sub.description() ?? sub.name();
+      return `        '${sub.name()}:${desc.replace(/'/g, "")}'`;
+    }).join("\n");
+    if (!subs) return "";
+    return `  ${cmd.name()})
+    local -a subcmds
+    subcmds=(
+${subs}
+    )
+    _describe 'subcommand' subcmds
+    ;;`;
+  }).filter(Boolean).join("\n");
+  return `#compdef astro-cli
+
+_astro-cli() {
+  local -a commands
+  commands=(
+${groups}
+  )
+
+  _arguments -C \\
+    '--json[Machine-readable JSON output]' \\
+    '--quiet[Suppress spinners and decorative output]' \\
+    '--server-url[Override server URL]:url:_urls' \\
+    '--help[Show help]' \\
+    '--version[Show version]' \\
+    '1:command:->command' \\
+    '*::arg:->args'
+
+  case ${"$"}state in
+  command)
+    _describe 'command' commands
+    ;;
+  args)
+    case ${"$"}words[1] in
+${subcommandCases}
+    esac
+    ;;
+  esac
+}
+
+_astro-cli "$@"
+`;
+}
+function generateFishCompletion(program2) {
+  const lines = [
+    "# Fish completions for astro-cli",
+    "",
+    "# Disable file completions by default",
+    "complete -c astro-cli -f",
+    "",
+    "# Global options",
+    'complete -c astro-cli -l json -d "Machine-readable JSON output"',
+    'complete -c astro-cli -l quiet -d "Suppress spinners and decorative output"',
+    'complete -c astro-cli -l server-url -x -d "Override server URL"',
+    ""
+  ];
+  for (const cmd of program2.commands) {
+    const desc = cmd.description() ?? cmd.name();
+    lines.push(`# ${cmd.name()} commands`);
+    lines.push(`complete -c astro-cli -n "__fish_use_subcommand" -a "${cmd.name()}" -d "${desc.replace(/"/g, '\\"')}"`);
+    for (const sub of cmd.commands) {
+      const subDesc = sub.description() ?? sub.name();
+      lines.push(`complete -c astro-cli -n "__fish_seen_subcommand_from ${cmd.name()}" -a "${sub.name()}" -d "${subDesc.replace(/"/g, '\\"')}"`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function registerCompletionCommands(program2) {
+  program2.command("completion").description("Generate shell completion script").option("--shell <shell>", "Shell type: bash, zsh, fish", "bash").action((opts) => {
+    switch (opts.shell) {
+      case "bash":
+        console.log(generateBashCompletion(program2));
+        break;
+      case "zsh":
+        console.log(generateZshCompletion(program2));
+        break;
+      case "fish":
+        console.log(generateFishCompletion(program2));
+        break;
+      default:
+        console.error(`Unknown shell "${opts.shell}". Use bash, zsh, or fish.`);
+        process.exitCode = 1;
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("astro-cli").description("CLI for managing Astro projects, plans, tasks, and environments").version("0.1.0").option("--json", "Machine-readable JSON output").option("--quiet", "Suppress spinners and decorative output").option("--server-url <url>", "Override server URL");
+registerProjectCommands(program);
+registerPlanCommands(program);
+registerTaskCommands(program);
+registerSearchCommands(program);
+registerActivityCommands(program);
+registerTraceCommands(program);
+registerEnvCommands(program);
+registerConfigCommands(program);
+registerAuthCommands(program);
+registerCompletionCommands(program);
+program.parse();