@astroanywhere/cli 0.2.0 → 0.2.1

package/dist/{chunk-7H7WD7QX.js → chunk-SYY2HHOY.js}

@@ -168,6 +168,10 @@ var AstroClient = class {
   async listFileChanges(executionId) {
     return this.get("/api/data/file-changes", { executionId });
   }
+  // ── Usage / Cost ────────────────────────────────────────────────────
+  async getUsageHistory(weeks = 1) {
+    return this.get("/api/data/usage/history", { weeks: String(weeks) });
+  }
   // ── Activity ────────────────────────────────────────────────────────
   async listActivities(params) {
     return this.get("/api/data/activities", params);
@@ -286,12 +290,66 @@ var AstroClient = class {
     }
     return res;
   }
+  // ── Chat (SSE streaming) ──────────────────────────────────────────
+  async projectChat(payload) {
+    const url = new URL("/api/agent/project-chat", this.baseUrl);
+    const res = await fetch(url.toString(), {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Project chat failed (${res.status}): ${text}`);
+    }
+    return res;
+  }
+  async taskChat(payload) {
+    const url = new URL("/api/agent/task-chat", this.baseUrl);
+    const res = await fetch(url.toString(), {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Task chat failed (${res.status}): ${text}`);
+    }
+    return res;
+  }
+  // ── Approval ───────────────────────────────────────────────────────
+  async sendApproval(payload) {
+    return this.post("/api/dispatch/approval", payload);
+  }
+  // ── Slurm Dispatch ────────────────────────────────────────────────
+  async dispatchSlurmTask(payload) {
+    const url = new URL("/api/relay/slurm/dispatch", this.baseUrl);
+    const res = await fetch(url.toString(), {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Slurm dispatch failed (${res.status}): ${text}`);
+    }
+    return res;
+  }
 };
-async function streamDispatchToStdout(response) {
-  if (!response.body) {
-    console.log("Task dispatched (no stream)");
-    return;
+function parseSSELines(buffer, lines) {
+  const events = [];
+  for (const line of lines) {
+    if (line.startsWith("data: ")) {
+      try {
+        events.push(JSON.parse(line.slice(6)));
+      } catch {
+      }
+    }
   }
+  return events;
+}
+async function readSSEStream(response, handler) {
+  if (!response.body) return;
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
@@ -301,35 +359,164 @@ async function streamDispatchToStdout(response) {
     buffer += decoder.decode(value, { stream: true });
     const lines = buffer.split("\n");
     buffer = lines.pop() ?? "";
-    for (const line of lines) {
-      if (line.startsWith("data: ")) {
-        try {
-          const event = JSON.parse(line.slice(6));
-          switch (event.type) {
-            case "text":
-              process.stdout.write(event.content ?? "");
-              break;
-            case "tool_use":
-              console.log(`
-[tool] ${event.name}`);
-              break;
-            case "result":
-              console.log(`
+    for (const event of parseSSELines(buffer, lines)) {
+      await handler(event);
+    }
+  }
+}
+async function streamDispatchToStdout(response, opts) {
+  const result = {};
+  if (!response.body) {
+    console.log("Task dispatched (no stream)");
+    return result;
+  }
+  await readSSEStream(response, async (event) => {
+    const type = event.type;
+    if (opts?.json) {
+      console.log(JSON.stringify(event));
+      return;
+    }
+    switch (type) {
+      case "text":
+        process.stdout.write(event.content ?? "");
+        break;
+      case "tool_use":
+        process.stderr.write(`
+[tool] ${event.name}
+`);
+        break;
+      case "tool_result":
+        break;
+      case "session_init":
+        result.sessionId = event.sessionId;
+        break;
+      case "result":
+        console.log(`
 --- Result: ${event.status} ---`);
-              if (event.summary) console.log(event.summary);
-              break;
-            case "error":
-              console.error(`
+        if (event.summary) console.log(event.summary);
+        if (event.durationMs || event.inputTokens || event.outputTokens || event.totalCost) {
+          result.metrics = {
+            durationMs: event.durationMs,
+            inputTokens: event.inputTokens,
+            outputTokens: event.outputTokens,
+            totalCost: event.totalCost,
+            model: event.model
+          };
+        }
+        break;
+      case "plan_result":
+        console.log("\n--- Plan Generated ---");
+        console.log(JSON.stringify(event.plan ?? event, null, 2));
+        break;
+      case "approval_request":
+        if (opts?.onApprovalRequest) {
+          const approval = await opts.onApprovalRequest({
+            requestId: event.requestId,
+            question: event.question,
+            options: event.options,
+            machineId: event.machineId,
+            taskId: event.taskId
+          });
+          void approval;
+        } else {
+          process.stderr.write(`
+[approval] ${event.question}
+`);
+          process.stderr.write(`  Options: ${event.options.join(", ")}
+`);
+        }
+        break;
+      case "error":
+        console.error(`
 Error: ${event.message}`);
-              break;
-            case "done":
-              break;
-          }
-        } catch {
+        break;
+      case "done":
+      case "heartbeat":
+        break;
+    }
+  });
+  return result;
+}
+async function streamChatToStdout(response, opts) {
+  const result = {};
+  let assistantText = "";
+  if (!response.body) {
+    console.log("No stream received");
+    return result;
+  }
+  await readSSEStream(response, async (event) => {
+    const type = event.type;
+    if (opts?.json) {
+      console.log(JSON.stringify(event));
+      return;
+    }
+    switch (type) {
+      case "text":
+        const content = event.content ?? "";
+        process.stdout.write(content);
+        assistantText += content;
+        break;
+      case "tool_use":
+        process.stderr.write(`
+[tool] ${event.name}
+`);
+        break;
+      case "tool_result":
+        break;
+      case "session_init":
+        result.sessionId = event.sessionId;
+        break;
+      case "file_change":
+        process.stderr.write(`[file] ${event.action} ${event.path}
+`);
+        break;
+      case "compaction":
+        process.stderr.write(`[compaction] History compacted: ${event.originalCount} \u2192 ${event.compactedCount} messages
+`);
+        break;
+      case "plan_result":
+        console.log("\n--- Plan Generated ---");
+        console.log(JSON.stringify(event.plan ?? event, null, 2));
+        break;
+      case "approval_request":
+        if (opts?.onApprovalRequest) {
+          const approval = await opts.onApprovalRequest({
+            requestId: event.requestId,
+            question: event.question,
+            options: event.options,
+            machineId: event.machineId,
+            taskId: event.taskId
+          });
+          void approval;
+        } else {
+          process.stderr.write(`
+[approval] ${event.question}
+`);
+          process.stderr.write(`  Options: ${event.options.join(", ")}
+`);
         }
-      }
+        break;
+      case "done":
+        if (event.durationMs || event.inputTokens || event.outputTokens || event.totalCost) {
+          result.metrics = {
+            durationMs: event.durationMs,
+            inputTokens: event.inputTokens,
+            outputTokens: event.outputTokens,
+            totalCost: event.totalCost,
+            model: event.model
+          };
+        }
+        break;
+      case "error":
+        console.error(`
+Error: ${event.message}`);
+        break;
+      case "heartbeat":
+        break;
     }
-  }
+  });
+  result.assistantText = assistantText;
+  return result;
 }
 var _client = null;
 var _clientUrl;
@@ -350,5 +537,6 @@ export {
   getServerUrl,
   AstroClient,
   streamDispatchToStdout,
+  streamChatToStdout,
   getClient
 };

package/dist/client.js

@@ -2,10 +2,12 @@
 import {
   AstroClient,
   getClient,
+  streamChatToStdout,
   streamDispatchToStdout
-} from "./chunk-7H7WD7QX.js";
+} from "./chunk-SYY2HHOY.js";
 export {
   AstroClient,
   getClient,
+  streamChatToStdout,
   streamDispatchToStdout
 };

package/dist/index.js

@@ -6,8 +6,9 @@ import {
   loadConfig,
   resetConfig,
   saveConfig,
+  streamChatToStdout,
   streamDispatchToStdout
-} from "./chunk-7H7WD7QX.js";
+} from "./chunk-SYY2HHOY.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -128,6 +129,74 @@ function formatStatus(status) {
   return colorFn(status);
 }
 
+// src/chat-utils.ts
+import { readFileSync, writeFileSync } from "fs";
+import { createInterface } from "readline";
+var MAX_HISTORY_MESSAGES = 100;
+function loadHistory(path) {
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const messages = JSON.parse(raw);
+    if (!Array.isArray(messages)) return [];
+    return messages.slice(-MAX_HISTORY_MESSAGES);
+  } catch {
+    return [];
+  }
+}
+function saveHistory(path, messages) {
+  writeFileSync(path, JSON.stringify(messages.slice(-MAX_HISTORY_MESSAGES), null, 2));
+}
+async function promptApproval(question, options) {
+  process.stderr.write(`
+${question}
+`);
+  for (let i = 0; i < options.length; i++) {
+    process.stderr.write(`  [${i + 1}] ${options[i]}
+`);
+  }
+  process.stderr.write("Select option (number): ");
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question("", (input) => {
+      rl.close();
+      const idx = parseInt(input.trim(), 10) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve({ answered: true, answer: options[idx] });
+      } else {
+        resolve({ answered: false });
+      }
+    });
+  });
+}
+function createApprovalHandler(client, yolo) {
+  return async (data) => {
+    let result;
+    if (yolo) {
+      result = { answered: true, answer: data.options[0] };
+      process.stderr.write(`
+[yolo] Auto-approved: ${data.question} \u2192 ${data.options[0]}
+`);
+    } else {
+      result = await promptApproval(data.question, data.options);
+    }
+    if (data.taskId && data.machineId && data.requestId) {
+      try {
+        await client.sendApproval({
+          taskId: data.taskId,
+          machineId: data.machineId,
+          requestId: data.requestId,
+          answered: result.answered,
+          answer: result.answer
+        });
+      } catch (err) {
+        process.stderr.write(`[approval] Failed to send: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+    }
+    return result;
+  };
+}
+
 // src/commands/project.ts
 import chalk2 from "chalk";
 var projectColumns = [
@@ -165,7 +234,6 @@ function registerProjectCommands(program2) {
       ["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")],
@@ -311,6 +379,62 @@ function registerProjectCommands(program2) {
       process.exitCode = 1;
     }
   });
+  project.command("chat <id>").description("Chat with AI about a project").requiredOption("--message <msg>", "Message to send").option("--session-id <sid>", "Resume existing session").option("--model <model>", "AI model to use").option("--provider <provider>", "Provider ID").option("--history-file <path>", "Path to conversation history JSON file").option("--yolo", "Auto-approve all approval requests").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;
+    }
+    let planNodes = [];
+    let planEdges = [];
+    try {
+      const plan = await client.getPlan(p.id);
+      planNodes = plan.nodes.filter((n) => !n.deletedAt);
+      planEdges = plan.edges;
+    } catch {
+    }
+    let messages = [];
+    if (cmdOpts.historyFile) {
+      messages = loadHistory(cmdOpts.historyFile);
+    }
+    try {
+      const response = await client.projectChat({
+        message: cmdOpts.message,
+        projectId: p.id,
+        sessionId: cmdOpts.sessionId,
+        model: cmdOpts.model,
+        providerId: cmdOpts.provider,
+        visionDoc: p.visionDoc || void 0,
+        planNodes,
+        planEdges,
+        messages: messages.length > 0 ? messages : void 0
+      });
+      const approvalHandler = createApprovalHandler(client, !!cmdOpts.yolo);
+      const result = await streamChatToStdout(response, {
+        json: opts.json,
+        onApprovalRequest: approvalHandler
+      });
+      if (result.sessionId) {
+        process.stderr.write(`
+${chalk2.dim(`Session: ${result.sessionId}`)}
+`);
+      }
+      if (cmdOpts.historyFile && result.assistantText) {
+        messages.push({ role: "user", content: cmdOpts.message });
+        messages.push({ role: "assistant", content: result.assistantText });
+        saveHistory(cmdOpts.historyFile, messages);
+      }
+      console.log();
+    } catch (err) {
+      console.error(chalk2.red(`Chat failed: ${err instanceof Error ? err.message : String(err)}`));
+      process.exitCode = 1;
+    }
+  });
   project.command("delete <id>").description("Delete a project").action(async (id) => {
     const opts = program2.opts();
     const client = getClient(opts.serverUrl);
@@ -675,6 +799,33 @@ function registerPlanCommands(program2) {
         process.exitCode = 1;
     }
   });
+  plan.command("generate").description("Generate a plan using AI").requiredOption("--project-id <id>", "Project ID").requiredOption("--description <desc>", "Description of what to plan").option("--model <model>", "AI model to use").option("--provider <provider>", "Preferred provider ID").option("--machine <id>", "Target machine ID").option("--yolo", "Auto-approve all approval requests").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    console.log(chalk3.dim("Generating plan..."));
+    console.log();
+    try {
+      const response = await client.dispatchTask({
+        nodeId: `plan-${cmdOpts.projectId}`,
+        projectId: cmdOpts.projectId,
+        isInteractivePlan: true,
+        description: cmdOpts.description,
+        model: cmdOpts.model,
+        preferredProvider: cmdOpts.provider,
+        targetMachineId: cmdOpts.machine
+      });
+      const approvalHandler = createApprovalHandler(client, !!cmdOpts.yolo);
+      await streamDispatchToStdout(response, {
+        json: opts.json,
+        onApprovalRequest: approvalHandler
+      });
+      console.log();
+      console.log(chalk3.green("Plan generation complete."));
+    } catch (err) {
+      console.error(chalk3.red(`Plan generation failed: ${err instanceof Error ? err.message : String(err)}`));
+      process.exitCode = 1;
+    }
+  });
 }
 
 // src/commands/task.ts
@@ -860,17 +1011,54 @@ function registerTaskCommands(program2) {
     }
     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) => {
+  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").option("--machine <id>", "Target machine ID").option("--model <model>", "AI model to use").option("--provider <provider>", "Preferred provider ID").option("--yolo", "Auto-approve all approval requests").option("--slurm", "Dispatch to Slurm cluster").option("--slurm-partition <p>", "Slurm partition").option("--slurm-gpus <n>", "Number of GPUs", parseInt).option("--slurm-gpu-type <t>", "GPU type (e.g. a100, v100)").option("--slurm-mem <m>", "Memory (e.g. 16G, 64G)").option("--slurm-time <t>", "Time limit (e.g. 1:00:00)").option("--slurm-nodes <n>", "Number of nodes", parseInt).option("--slurm-cpus <n>", "CPUs per task", parseInt).option("--slurm-qos <q>", "Quality of service").option("--slurm-account <a>", "Slurm account").option("--slurm-modules <m>", "Comma-separated modules to load").option("--cluster <id>", "Target Slurm cluster ID").action(async (nodeId, opts) => {
     const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
     console.log(chalk4.dim(`Dispatching task ${chalk4.bold(nodeId)} to server...`));
     console.log();
     try {
+      if (opts.slurm) {
+        const slurmConfig = {};
+        if (opts.slurmPartition) slurmConfig.partition = opts.slurmPartition;
+        if (opts.slurmNodes) slurmConfig.nodes = opts.slurmNodes;
+        if (opts.slurmCpus) slurmConfig.cpusPerTask = opts.slurmCpus;
+        if (opts.slurmMem) slurmConfig.mem = opts.slurmMem;
+        if (opts.slurmTime) slurmConfig.time = opts.slurmTime;
+        if (opts.slurmQos) slurmConfig.qos = opts.slurmQos;
+        if (opts.slurmAccount) slurmConfig.account = opts.slurmAccount;
+        if (opts.slurmModules) slurmConfig.modules = opts.slurmModules.split(",").map((s) => s.trim());
+        if (opts.slurmGpus || opts.slurmGpuType) {
+          slurmConfig.gpu = { count: opts.slurmGpus ?? 1, type: opts.slurmGpuType };
+        }
+        const response2 = await client.dispatchSlurmTask({
+          task: {
+            taskId: `exec-${nodeId}-${Date.now()}`,
+            projectId: opts.projectId,
+            nodeId,
+            title: nodeId,
+            preferredProvider: opts.provider
+          },
+          targetClusterId: opts.cluster,
+          slurmConfig: Object.keys(slurmConfig).length > 0 ? slurmConfig : void 0
+        });
+        await streamDispatchToStdout(response2, { json: isJson });
+        console.log();
+        console.log(chalk4.green("Slurm dispatch complete."));
+        return;
+      }
+      const approvalHandler = createApprovalHandler(client, !!opts.yolo);
       const response = await client.dispatchTask({
         nodeId,
         projectId: opts.projectId,
-        force: opts.force
+        force: opts.force,
+        targetMachineId: opts.machine,
+        model: opts.model,
+        preferredProvider: opts.provider
+      });
+      await streamDispatchToStdout(response, {
+        json: isJson,
+        onApprovalRequest: approvalHandler
       });
-      await streamDispatchToStdout(response);
       console.log();
       console.log(chalk4.green("Task dispatch complete."));
     } catch (err) {
@@ -878,6 +1066,70 @@ function registerTaskCommands(program2) {
       process.exitCode = 1;
     }
   });
+  cmd.command("chat <nodeId>").description("Chat with AI about a specific task").requiredOption("--project-id <id>", "Project ID").requiredOption("--message <msg>", "Message to send").option("--session-id <sid>", "Resume existing session").option("--model <model>", "AI model to use").option("--provider <provider>", "Provider ID").option("--history-file <path>", "Path to conversation history JSON file").option("--yolo", "Auto-approve all approval requests").action(async (nodeId, cmdOpts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
+    let node;
+    try {
+      const { nodes } = await client.getPlan(cmdOpts.projectId);
+      node = nodes.find((n) => n.id === nodeId && !n.deletedAt);
+    } catch (err) {
+      console.error(chalk4.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    if (!node) {
+      console.error(chalk4.red(`Task not found: ${nodeId}`));
+      process.exitCode = 1;
+      return;
+    }
+    let visionDoc;
+    try {
+      const project = await client.getProject(cmdOpts.projectId);
+      visionDoc = project.visionDoc || void 0;
+    } catch {
+    }
+    let messages = [];
+    if (cmdOpts.historyFile) {
+      messages = loadHistory(cmdOpts.historyFile);
+    }
+    try {
+      const response = await client.taskChat({
+        message: cmdOpts.message,
+        nodeId,
+        projectId: cmdOpts.projectId,
+        taskTitle: node.title,
+        taskDescription: node.description || void 0,
+        taskOutput: node.executionOutput || void 0,
+        visionDoc,
+        sessionId: cmdOpts.sessionId,
+        model: cmdOpts.model,
+        providerId: cmdOpts.provider,
+        branchName: node.branchName || void 0,
+        prUrl: node.prUrl || void 0,
+        messages: messages.length > 0 ? messages : void 0
+      });
+      const approvalHandler = createApprovalHandler(client, !!cmdOpts.yolo);
+      const result = await streamChatToStdout(response, {
+        json: isJson,
+        onApprovalRequest: approvalHandler
+      });
+      if (result.sessionId) {
+        process.stderr.write(`
+${chalk4.dim(`Session: ${result.sessionId}`)}
+`);
+      }
+      if (cmdOpts.historyFile && result.assistantText) {
+        messages.push({ role: "user", content: cmdOpts.message });
+        messages.push({ role: "assistant", content: result.assistantText });
+        saveHistory(cmdOpts.historyFile, messages);
+      }
+      console.log();
+    } catch (err) {
+      console.error(chalk4.red(`Chat 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;
@@ -947,9 +1199,10 @@ function registerTaskCommands(program2) {
       process.exitCode = 1;
     }
   });
-  cmd.command("watch <executionId>").description("Watch real-time output from a running task via SSE").action(async (executionId) => {
+  cmd.command("watch <executionId>").description("Watch real-time output from a running task via SSE").option("--yolo", "Auto-approve all approval requests").action(async (executionId, cmdOpts) => {
     const client = getClient(program2.opts().serverUrl);
     const isJson = program2.opts().json;
+    const approvalHandler = createApprovalHandler(client, !!cmdOpts.yolo);
     try {
       const response = await client.streamEvents();
       if (!response.body) {
@@ -994,6 +1247,17 @@ ${chalk4.bold("--- Result:")} ${formatStatus(event.status ?? "unknown")} ${event
               case "task:stdout":
                 process.stdout.write(event.data ?? "");
                 break;
+              case "task:approval_request": {
+                const result = await approvalHandler({
+                  requestId: event.requestId,
+                  question: event.question,
+                  options: event.options,
+                  machineId: event.machineId,
+                  taskId: event.taskId
+                });
+                void result;
+                break;
+              }
             }
           } catch {
           }
@@ -2074,6 +2338,43 @@ function registerCompletionCommands(program2) {
   });
 }
 
+// src/commands/playground.ts
+import chalk11 from "chalk";
+function registerPlaygroundCommands(program2) {
+  const playground = program2.command("playground").description("Run ephemeral AI executions");
+  playground.command("start").description("Start a playground execution").requiredOption("--project-id <id>", "Project ID").requiredOption("--description <desc>", "What to execute").option("--dir <path>", "Working directory override").option("--model <model>", "AI model to use").option("--provider <provider>", "Preferred provider ID").option("--machine <id>", "Target machine ID").option("--yolo", "Auto-approve all approval requests").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    const nodeId = `playground-${cmdOpts.projectId}-${Date.now()}`;
+    console.log(chalk11.dim(`Starting playground execution ${chalk11.bold(nodeId)}...`));
+    console.log();
+    try {
+      const response = await client.dispatchTask({
+        nodeId,
+        projectId: cmdOpts.projectId,
+        skipSafetyCheck: true,
+        description: cmdOpts.description,
+        title: "Playground execution",
+        model: cmdOpts.model,
+        preferredProvider: cmdOpts.provider,
+        targetMachineId: cmdOpts.machine,
+        ...cmdOpts.dir ? { workingDirectory: cmdOpts.dir } : {}
+      });
+      const approvalHandler = createApprovalHandler(client, !!cmdOpts.yolo);
+      await streamDispatchToStdout(response, {
+        json: opts.json,
+        onApprovalRequest: approvalHandler
+      });
+      console.log();
+      console.log(chalk11.green("Playground execution complete."));
+      console.log(chalk11.dim(`For follow-up: astro-cli task chat ${nodeId} --project-id ${cmdOpts.projectId} --message "..."`));
+    } catch (err) {
+      console.error(chalk11.red(`Playground failed: ${err instanceof Error ? err.message : String(err)}`));
+      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.2.0").option("--json", "Machine-readable JSON output").option("--quiet", "Suppress spinners and decorative output").option("--server-url <url>", "Override server URL");
@@ -2087,6 +2388,7 @@ registerEnvCommands(program);
 registerConfigCommands(program);
 registerAuthCommands(program);
 registerCompletionCommands(program);
+registerPlaygroundCommands(program);
 program.command("tui").description("Launch interactive terminal UI").action(async () => {
   const { launchTui } = await import("./tui.js");
   await launchTui(program.opts().serverUrl);