@asteroidai/cli 1.9.2 → 1.9.11

package/dist/asteroid.js

@@ -3,225 +3,6 @@
 // src/main.ts
 import { spawn } from "node:child_process";
 
-// src/config.ts
-import envPaths from "env-paths";
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync
-} from "node:fs";
-import { dirname, join } from "node:path";
-
-// src/output.ts
-import Table from "cli-table3";
-import { styleText } from "node:util";
-var PREFERRED = [
-  "id",
-  "name",
-  "title",
-  "workflowName",
-  "status",
-  "outcome",
-  "version",
-  "createdAt",
-  "updatedAt"
-];
-var HIDDEN = /^agent[A-Z]|Url$/;
-var MAX_COLUMNS = 6;
-var MAX_CELL = 60;
-var CONTROL = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b[@-_]?|[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
-function clean(text2) {
-  return text2.replace(CONTROL, "");
-}
-function isObject(value2) {
-  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
-}
-function isScalar(value2) {
-  return value2 === null || ["string", "number", "boolean"].includes(typeof value2);
-}
-function indent(text2) {
-  return text2.split("\n").map((line) => `  ${line}`).join("\n");
-}
-function text(value2) {
-  return clean(isScalar(value2) ? String(value2) : JSON.stringify(value2));
-}
-function cell(value2) {
-  if (value2 === null || value2 === void 0) return "";
-  const line = text(value2).replace(/\s+/g, " ");
-  return line.length > MAX_CELL ? `${line.slice(0, MAX_CELL - 1)}\u2026` : line;
-}
-function columns(rows) {
-  const scalarKeys = [];
-  for (const row of rows) {
-    for (const [key, value2] of Object.entries(row)) {
-      if (isScalar(value2) && !HIDDEN.test(key.split(".").at(-1) ?? key) && !scalarKeys.includes(key))
-        scalarKeys.push(key);
-    }
-  }
-  const ordered = [
-    ...PREFERRED.filter((key) => scalarKeys.includes(key)),
-    ...scalarKeys.filter((key) => !PREFERRED.includes(key))
-  ];
-  return ordered.slice(0, MAX_COLUMNS);
-}
-function style(format, value2, options) {
-  return options.styled ? styleText(format, value2, { validateStream: false }) : value2;
-}
-function flatten(row) {
-  const flat = {};
-  for (const [key, value2] of Object.entries(row)) {
-    if (!isObject(value2)) {
-      flat[key] = value2;
-      continue;
-    }
-    for (const [inner, v] of Object.entries(value2))
-      flat[`${key}.${inner}`] = v;
-  }
-  return flat;
-}
-function table(input, options = {}) {
-  if (input.length === 0) return "No results.";
-  const rows = input.map(flatten);
-  const keys = columns(rows);
-  if (keys.length === 0) return rows.map((row) => text(row)).join("\n");
-  const cells = rows.map((row) => keys.map((key) => cell(row[key])));
-  if (options.styled) {
-    const grid = new Table({
-      head: keys.map((key) => style("bold", key, options)),
-      style: { head: [], border: [] }
-    });
-    grid.push(...cells);
-    return grid.toString();
-  }
-  const widths = keys.map(
-    (key, i) => Math.max(key.length, ...cells.map((r) => r[i].length))
-  );
-  const line = (values) => values.map((v, i) => v.padEnd(widths[i])).join("  ").trimEnd();
-  return [line(keys.map((k) => k.toUpperCase())), ...cells.map(line)].join(
-    "\n"
-  );
-}
-function summary(value2) {
-  if (Array.isArray(value2))
-    return `[${value2.length} item${value2.length === 1 ? "" : "s"}]`;
-  if (value2 && typeof value2 === "object") return cell(value2);
-  return text(value2);
-}
-function record(value2, options) {
-  const width = Math.max(...Object.keys(value2).map((key) => key.length));
-  const label = (key) => style("bold", key.padEnd(width), options);
-  return Object.entries(value2).map(([key, v]) => {
-    if (Array.isArray(v) && v.length > 0 && v.every(isObject)) {
-      return `${style("bold", key, options)}:
-${indent(table(v, options))}`;
-    }
-    if (Array.isArray(v) && v.length > 0 && v.every(isScalar)) {
-      return `${label(key)}  ${v.map(text).join(`
-${" ".repeat(width + 2)}`)}`;
-    }
-    if (isObject(v) && Object.keys(v).length > 0) {
-      return `${style("bold", key, options)}:
-${indent(record(v, options))}`;
-    }
-    return `${label(key)}  ${isScalar(v) ? text(v) : summary(v)}`;
-  }).join("\n");
-}
-function render(value2, options = {}) {
-  if (value2 === void 0) return "";
-  if (Array.isArray(value2)) {
-    return value2.every(isObject) ? table(value2, options) : value2.map(text).join("\n");
-  }
-  if (isObject(value2)) {
-    const row = value2;
-    if (Array.isArray(row.items)) {
-      const rest = Object.entries(row).filter(
-        ([k, v]) => k !== "items" && isScalar(v)
-      );
-      const footer = rest.length ? `
-
-${style("dim", rest.map(([k, v]) => `${k}: ${text(v)}`).join("  "), options)}` : "";
-      return `${table(row.items, options)}${footer}`;
-    }
-    return record(row, options);
-  }
-  return text(value2);
-}
-
-// src/config.ts
-var DEFAULT_API_URL = "https://odyssey.asteroid.ai";
-var DEFAULT_WORKOS_CLIENT_ID = "client_01K3NXPE8X6EJZXZSYCNT5M4P0";
-var DEFAULT_WORKOS_API_URL = "https://api.workos.com";
-function readEnv(env = process.env) {
-  return {
-    apiUrl: (env.ASTEROID_API_URL || DEFAULT_API_URL).replace(/\/+$/, ""),
-    apiKey: env.ASTEROID_API_KEY || void 0,
-    org: env.ASTEROID_ORG || void 0,
-    workosClientId: env.ASTEROID_WORKOS_CLIENT_ID || DEFAULT_WORKOS_CLIENT_ID,
-    workosApiUrl: (env.ASTEROID_WORKOS_API_URL || DEFAULT_WORKOS_API_URL).replace(/\/+$/, ""),
-    configDir: env.ASTEROID_CONFIG_DIR || envPaths("asteroid", { suffix: "" }).config
-  };
-}
-function readJson(path, fallback) {
-  if (!existsSync(path)) return fallback;
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return fallback;
-  }
-}
-function writePrivateJson(path, value2) {
-  mkdirSync(dirname(path), { recursive: true, mode: 448 });
-  const temp = `${path}.${process.pid}.tmp`;
-  writeFileSync(temp, `${JSON.stringify(value2, null, 2)}
-`, { mode: 384 });
-  chmodSync(temp, 384);
-  renameSync(temp, path);
-}
-function loadConfig(env) {
-  return readJson(join(env.configDir, "config.json"), {});
-}
-function saveConfig(env, config) {
-  writePrivateJson(join(env.configDir, "config.json"), config);
-}
-function repoOrg(cwd) {
-  let dir = cwd;
-  for (; ; ) {
-    const file = join(dir, ".asteroid", "org");
-    if (existsSync(file)) return readFileSync(file, "utf8").trim() || void 0;
-    const parent = dirname(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-function requestedOrg(flag, env, cwd, config) {
-  return flag ?? env.org ?? repoOrg(cwd) ?? config.org?.workosId;
-}
-function findOrg(ref, orgs2) {
-  const lower = ref.toLowerCase();
-  return orgs2.find(
-    (org) => org.workosId.toLowerCase() === lower || org.id?.toLowerCase() === lower
-  ) ?? orgs2.find((org) => org.name?.toLowerCase() === lower) ?? (/^org_[0-9a-z]+$/i.test(ref) ? { workosId: ref } : void 0);
-}
-function mergeOrgs(known = [], found = []) {
-  const byId = new Map(known.map((org) => [org.workosId, org]));
-  for (const org of found) {
-    const merged = { ...byId.get(org.workosId) };
-    for (const [key, value2] of Object.entries(org))
-      if (value2 !== void 0) Object.assign(merged, { [key]: value2 });
-    byId.set(org.workosId, merged);
-  }
-  return [...byId.values()].sort(
-    (a, b) => (a.name ?? a.workosId).localeCompare(b.name ?? b.workosId)
-  );
-}
-function orgLabel(org) {
-  const id = clean(org.id ?? org.workosId);
-  return org.name ? `${clean(org.name)} (${id})` : id;
-}
-
 // src/generated/commands.ts
 var COMMANDS = [
   {
@@ -4725,50 +4506,378 @@ var COMMANDS = [
   }
 ];
 
-// src/program.ts
-import { Command, CommanderError } from "commander";
-
-// src/args.ts
-var UsageError = class extends Error {
+// src/sync/commands.ts
+function option(name, type, description, extra = {}) {
+  return { name, flag: name, type, required: false, description, ...extra };
+}
+var DIR = option(
+  "dir",
+  "string",
+  "Write here instead of `<workflow-name>/...` under the current directory."
+);
+var local = {
+  method: "GET",
+  path: "",
+  binary: false,
+  destructive: false,
+  local: true
 };
-
-// src/reference.ts
-var BUILTINS = [
-  {
-    command: "login",
-    usage: "asteroid login",
-    description: "Sign in with your browser. Stores a refresh token in the OS keychain, or in a private file in the config directory when no keychain is available.",
-    args: 0
-  },
-  {
-    command: "logout",
-    usage: "asteroid logout",
-    description: "Forget the stored sign-in and cached tokens.",
-    args: 0
-  },
-  {
-    command: "orgs",
-    usage: "asteroid orgs",
-    description: "List the organizations you can act in. The active one is marked.",
-    args: 0
-  },
+var SYNC_COMMANDS = [
   {
-    command: "use",
-    usage: "asteroid use [org]",
-    arg: "org",
-    description: "Make an organization, by id or name, the default for later commands. Without one, pick from a list.",
-    args: 1
+    ...local,
+    command: "workflow pull",
+    tool: "workflow_pull",
+    title: "Pull a workflow to disk",
+    description: "Write a workflow's editable head to `<workflow-name>/head/` as files: settings, per-node instructions and scripts, and the workflow's own files. Pass --version-id for a pinned version, written read-only to `<workflow-name>/.versions/`. Edit the head files, then run `asteroid workflow push` from that folder.",
+    readOnly: true,
+    args: [
+      {
+        name: "workflowId",
+        flag: "workflow-id",
+        type: "string",
+        required: true
+      }
+    ],
+    query: [
+      option(
+        "version-id",
+        "string",
+        "A workflow version ID. Omit for the editable head."
+      ),
+      DIR
+    ]
   },
   {
-    command: "complete",
-    usage: "asteroid complete <zsh|bash|fish|powershell>",
-    arg: "shell",
-    description: "Print a shell completion script. For zsh: `asteroid complete zsh > ~/.zfunc/_asteroid`.",
-    args: 1
+    ...local,
+    command: "workflow push",
+    tool: "workflow_push",
+    title: "Push local edits to a workflow head",
+    description: "Send the edits in a pulled head folder to the workflow's editable head: changed and new files are written, removed files are deleted. Fails if the head changed since the pull; pull again and reapply. Push does not publish.",
+    readOnly: false,
+    args: [],
+    query: [
+      option(
+        "dir",
+        "string",
+        "The pulled head folder. Defaults to the current directory."
+      )
+    ]
   },
   {
-    command: "whoami",
-    usage: "asteroid whoami",
+    ...local,
+    command: "execution pull",
+    tool: "execution_pull",
+    title: "Pull an execution to disk",
+    description: "Write an execution to `<workflow-name>/executions/<id>/`: summary.json, activities.md (the step-by-step log), and the files the run produced.",
+    readOnly: true,
+    args: [
+      {
+        name: "executionId",
+        flag: "execution-id",
+        type: "string",
+        required: true
+      }
+    ],
+    query: [
+      option(
+        "files",
+        "string",
+        "Only download files whose path matches this glob. --no-files skips downloads.",
+        {
+          negatable: true
+        }
+      ),
+      option(
+        "summary-only",
+        "boolean",
+        "Write summary.json only: no activities, no files."
+      ),
+      option(
+        "max-file-size",
+        "integer",
+        "Skip files larger than this many bytes."
+      ),
+      option(
+        "dir",
+        "string",
+        "Write here instead of `<workflow-name>/executions/<id>/` under the current directory."
+      )
+    ]
+  }
+];
+
+// src/commands.ts
+function withSyncCommands(commands) {
+  return [...commands, ...SYNC_COMMANDS].sort(
+    (a, b) => a.command.localeCompare(b.command)
+  );
+}
+var ALL_COMMANDS = withSyncCommands(COMMANDS);
+
+// src/config.ts
+import envPaths from "env-paths";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+
+// src/output.ts
+import Table from "cli-table3";
+import { styleText } from "node:util";
+var PREFERRED = [
+  "id",
+  "name",
+  "title",
+  "workflowName",
+  "status",
+  "outcome",
+  "version",
+  "createdAt",
+  "updatedAt"
+];
+var HIDDEN = /^agent[A-Z]|Url$/;
+var MAX_COLUMNS = 6;
+var MAX_CELL = 60;
+var CONTROL = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b[@-_]?|[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+function clean(text2) {
+  return text2.replace(CONTROL, "");
+}
+function isObject(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+function isScalar(value2) {
+  return value2 === null || ["string", "number", "boolean"].includes(typeof value2);
+}
+function indent(text2) {
+  return text2.split("\n").map((line2) => `  ${line2}`).join("\n");
+}
+function text(value2) {
+  return clean(isScalar(value2) ? String(value2) : JSON.stringify(value2));
+}
+function cell(value2, options = {}) {
+  if (value2 === null || value2 === void 0) return "";
+  const line2 = text(value2).replace(/\s+/g, " ");
+  if (options.full || line2.length <= MAX_CELL) return line2;
+  return `${line2.slice(0, MAX_CELL - 1)}\u2026`;
+}
+function columns(rows, options) {
+  const scalarKeys = [];
+  for (const row of rows) {
+    for (const [key, value2] of Object.entries(row)) {
+      if (isScalar(value2) && !HIDDEN.test(key.split(".").at(-1) ?? key) && !scalarKeys.includes(key))
+        scalarKeys.push(key);
+    }
+  }
+  const ordered = [
+    ...PREFERRED.filter((key) => scalarKeys.includes(key)),
+    ...scalarKeys.filter((key) => !PREFERRED.includes(key))
+  ];
+  return options.full ? ordered : ordered.slice(0, MAX_COLUMNS);
+}
+function style(format, value2, options) {
+  return options.styled ? styleText(format, value2, { validateStream: false }) : value2;
+}
+function flatten(row) {
+  const flat = {};
+  for (const [key, value2] of Object.entries(row)) {
+    if (!isObject(value2)) {
+      flat[key] = value2;
+      continue;
+    }
+    for (const [inner, v] of Object.entries(value2))
+      flat[`${key}.${inner}`] = v;
+  }
+  return flat;
+}
+function table(input, options = {}) {
+  if (input.length === 0) return "No results.";
+  const rows = input.map(flatten);
+  const keys = columns(rows, options);
+  if (keys.length === 0) return rows.map((row) => text(row)).join("\n");
+  const cells = rows.map((row) => keys.map((key) => cell(row[key], options)));
+  if (options.styled) {
+    const grid = new Table({
+      head: keys.map((key) => style("bold", key, options)),
+      style: { head: [], border: [] }
+    });
+    grid.push(...cells);
+    return grid.toString();
+  }
+  const widths = keys.map(
+    (key, i) => Math.max(key.length, ...cells.map((r) => r[i].length))
+  );
+  const line2 = (values) => values.map((v, i) => v.padEnd(widths[i])).join("  ").trimEnd();
+  return [line2(keys.map((k) => k.toUpperCase())), ...cells.map(line2)].join(
+    "\n"
+  );
+}
+function summary(value2, options) {
+  if (Array.isArray(value2))
+    return `[${value2.length} item${value2.length === 1 ? "" : "s"}]`;
+  if (value2 && typeof value2 === "object") return cell(value2, options);
+  return text(value2);
+}
+function record(value2, options) {
+  const width = Math.max(...Object.keys(value2).map((key) => key.length));
+  const label = (key) => style("bold", key.padEnd(width), options);
+  return Object.entries(value2).map(([key, v]) => {
+    if (Array.isArray(v) && v.length > 0 && v.every(isObject)) {
+      return `${style("bold", key, options)}:
+${indent(table(v, options))}`;
+    }
+    if (Array.isArray(v) && v.length > 0 && v.every(isScalar)) {
+      return `${label(key)}  ${v.map(text).join(`
+${" ".repeat(width + 2)}`)}`;
+    }
+    if (isObject(v) && Object.keys(v).length > 0) {
+      return `${style("bold", key, options)}:
+${indent(record(v, options))}`;
+    }
+    return `${label(key)}  ${isScalar(v) ? text(v) : summary(v, options)}`;
+  }).join("\n");
+}
+function render(value2, options = {}) {
+  if (value2 === void 0) return "";
+  if (Array.isArray(value2)) {
+    return value2.every(isObject) ? table(value2, options) : value2.map(text).join("\n");
+  }
+  if (isObject(value2)) {
+    const row = value2;
+    if (Array.isArray(row.items)) {
+      const rest = Object.entries(row).filter(
+        ([k, v]) => k !== "items" && isScalar(v)
+      );
+      const footer = rest.length ? `
+
+${style("dim", rest.map(([k, v]) => `${k}: ${text(v)}`).join("  "), options)}` : "";
+      return `${table(row.items, options)}${footer}`;
+    }
+    return record(row, options);
+  }
+  return text(value2);
+}
+
+// src/config.ts
+var DEFAULT_API_URL = "https://odyssey.asteroid.ai";
+var DEFAULT_WORKOS_CLIENT_ID = "client_01K3NXPE8X6EJZXZSYCNT5M4P0";
+var DEFAULT_WORKOS_API_URL = "https://api.workos.com";
+function readEnv(env = process.env) {
+  return {
+    apiUrl: (env.ASTEROID_API_URL || DEFAULT_API_URL).replace(/\/+$/, ""),
+    apiKey: env.ASTEROID_API_KEY || void 0,
+    org: env.ASTEROID_ORG || void 0,
+    workosClientId: env.ASTEROID_WORKOS_CLIENT_ID || DEFAULT_WORKOS_CLIENT_ID,
+    workosApiUrl: (env.ASTEROID_WORKOS_API_URL || DEFAULT_WORKOS_API_URL).replace(/\/+$/, ""),
+    configDir: env.ASTEROID_CONFIG_DIR || envPaths("asteroid", { suffix: "" }).config
+  };
+}
+function readJson(path, fallback) {
+  if (!existsSync(path)) return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function writePrivateJson(path, value2) {
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(value2, null, 2)}
+`, { mode: 384 });
+  chmodSync(temp, 384);
+  renameSync(temp, path);
+}
+function loadConfig(env) {
+  return readJson(join(env.configDir, "config.json"), {});
+}
+function saveConfig(env, config) {
+  writePrivateJson(join(env.configDir, "config.json"), config);
+}
+function repoOrg(cwd) {
+  let dir = cwd;
+  for (; ; ) {
+    const file = join(dir, ".asteroid", "org");
+    if (existsSync(file)) return readFileSync(file, "utf8").trim() || void 0;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function requestedOrg(flag2, env, cwd, config) {
+  return flag2 ?? env.org ?? repoOrg(cwd) ?? config.org?.workosId;
+}
+function findOrg(ref, orgs2) {
+  const lower = ref.toLowerCase();
+  return orgs2.find(
+    (org) => org.workosId.toLowerCase() === lower || org.id?.toLowerCase() === lower
+  ) ?? orgs2.find((org) => org.name?.toLowerCase() === lower) ?? (/^org_[0-9a-z]+$/i.test(ref) ? { workosId: ref } : void 0);
+}
+function mergeOrgs(known = [], found = []) {
+  const byId = new Map(known.map((org) => [org.workosId, org]));
+  for (const org of found) {
+    const merged = { ...byId.get(org.workosId) };
+    for (const [key, value2] of Object.entries(org))
+      if (value2 !== void 0) Object.assign(merged, { [key]: value2 });
+    byId.set(org.workosId, merged);
+  }
+  return [...byId.values()].sort(
+    (a, b) => (a.name ?? a.workosId).localeCompare(b.name ?? b.workosId)
+  );
+}
+function orgLabel(org) {
+  const id = clean(org.id ?? org.workosId);
+  return org.name ? `${clean(org.name)} (${id})` : id;
+}
+
+// src/program.ts
+import { Command, CommanderError } from "commander";
+
+// src/args.ts
+var UsageError = class extends Error {
+};
+
+// src/reference.ts
+var BUILTINS = [
+  {
+    command: "login",
+    usage: "asteroid login",
+    description: "Sign in with your browser. Stores a refresh token in the OS keychain, or in a private file in the config directory when no keychain is available.",
+    args: 0
+  },
+  {
+    command: "logout",
+    usage: "asteroid logout",
+    description: "Forget the stored sign-in and cached tokens.",
+    args: 0
+  },
+  {
+    command: "orgs",
+    usage: "asteroid orgs",
+    description: "List the organizations you can act in. The active one is marked.",
+    args: 0
+  },
+  {
+    command: "use",
+    usage: "asteroid use [org]",
+    arg: "org",
+    description: "Make an organization, by id or name, the default for later commands. Without one, pick from a list.",
+    args: 1
+  },
+  {
+    command: "complete",
+    usage: "asteroid complete <zsh|bash|fish|powershell>",
+    arg: "shell",
+    description: "Print a shell completion script. For zsh: `asteroid complete zsh > ~/.zfunc/_asteroid`.",
+    args: 1
+  },
+  {
+    command: "whoami",
+    usage: "asteroid whoami",
     description: "Show who you act as, in which organization, and how long the token lasts.",
     args: 0
   }
@@ -4793,12 +4902,12 @@ var DOTTED = /^--([a-z0-9-]+\.[a-z0-9.-]+)(?:=(.*))?$/;
 function collect(value2, previous) {
   return [...previous ?? [], value2];
 }
-function optionText(option) {
-  const text2 = option.description?.replace(/\s+/g, " ").trim() ?? "";
+function optionText(option2) {
+  const text2 = option2.description?.replace(/\s+/g, " ").trim() ?? "";
   const parts = [text2 && !/[.!?]$/.test(text2) ? `${text2}.` : text2];
-  if (option.enum) parts.push(`One of: ${option.enum.join(", ")}.`);
-  if (option.type.endsWith("[]")) parts.push("Repeatable.");
-  if (option.required) parts.push("Required.");
+  if (option2.enum) parts.push(`One of: ${option2.enum.join(", ")}.`);
+  if (option2.type.endsWith("[]")) parts.push("Repeatable.");
+  if (option2.required) parts.push("Required.");
   return parts.filter(Boolean).join(" ");
 }
 function splitDotted(argv2) {
@@ -4825,18 +4934,20 @@ function group(parent, name, groups, path) {
   return created;
 }
 function leafOptions(leaf, command) {
-  for (const option of [...command.query, ...command.body?.fields ?? []]) {
-    if (option.type === "boolean") {
-      leaf.option(`--${option.flag}`, optionText(option));
-      leaf.option(`--no-${option.flag}`, `Set ${option.flag} to false.`);
+  for (const option2 of [...command.query, ...command.body?.fields ?? []]) {
+    if (option2.type === "boolean") {
+      leaf.option(`--${option2.flag}`, optionText(option2));
+      leaf.option(`--no-${option2.flag}`, `Set ${option2.flag} to false.`);
       continue;
     }
-    const placeholder = option.enum ? option.enum.join("|") : option.type.replace("[]", "");
+    const placeholder = option2.enum ? option2.enum.join("|") : option2.type.replace("[]", "");
     leaf.option(
-      `--${option.flag} <${placeholder}>`,
-      optionText(option),
+      `--${option2.flag} <${placeholder}>`,
+      optionText(option2),
       collect
     );
+    if (option2.negatable)
+      leaf.option(`--no-${option2.flag}`, `Skip ${option2.flag}.`);
   }
   for (const file of command.body?.files ?? []) {
     leaf.option(`--${file} <path>`, "File to upload. Repeatable.", collect);
@@ -4846,11 +4957,11 @@ function toParsed(leaf, positionals, dotted) {
   const globals = leaf.optsWithGlobals();
   const own = leaf.opts();
   const flags = new Map(dotted);
-  for (const option of leaf.options) {
-    const flag = option.long?.replace(/^--(no-)?/, "");
-    const value2 = own[option.attributeName()];
-    if (!flag || value2 === void 0 || flags.has(flag)) continue;
-    flags.set(flag, Array.isArray(value2) ? value2.map(String) : [String(value2)]);
+  for (const option2 of leaf.options) {
+    const flag2 = option2.long?.replace(/^--(no-)?/, "");
+    const value2 = own[option2.attributeName()];
+    if (!flag2 || value2 === void 0 || flags.has(flag2)) continue;
+    flags.set(flag2, Array.isArray(value2) ? value2.map(String) : [String(value2)]);
   }
   return {
     positionals,
@@ -4863,7 +4974,11 @@ function toParsed(leaf, positionals, dotted) {
 }
 function defineCommands(root, options, dotted = /* @__PURE__ */ new Map(), onInvocation = () => void 0) {
   if (options.description) root.description(options.description);
-  if (options.version) root.version(options.version, "-v, --version");
+  if (options.version)
+    root.addHelpText(
+      "after",
+      "\nRun `asteroid --version` to print the CLI version."
+    );
   for (const [flags, text2] of GLOBAL_FLAGS) {
     if (!flags.startsWith("-h")) root.option(flags, text2);
   }
@@ -4925,8 +5040,8 @@ ${notes.join("\n")}`);
         );
       }
       const unknownDotted = [...dotted.keys()].filter(
-        (flag) => !(command.body?.fields ?? []).some(
-          (f) => flag.startsWith(`${f.flag}.`)
+        (flag2) => !(command.body?.fields ?? []).some(
+          (f) => flag2.startsWith(`${f.flag}.`)
         )
       );
       if (unknownDotted.length > 0) {
@@ -4947,6 +5062,15 @@ async function parseInvocation(argv2, options) {
   let stdout = "";
   let stderr = "";
   let result;
+  if (options.version && (argv2[0] === "-v" || argv2[0] === "--version")) {
+    return {
+      kind: "exit",
+      code: 0,
+      stdout: `${options.version}
+`,
+      stderr: ""
+    };
+  }
   const { argv: rest, dotted } = splitDotted(argv2);
   const root = new Command("asteroid").exitOverride().helpCommand(false).configureOutput({
     writeOut: (text2) => stdout += text2,
@@ -5329,7 +5453,7 @@ var ApiError = class extends Error {
   status;
   body;
 };
-var VERSION = "1.9.2";
+var VERSION = "1.9.11";
 function problem(status, body, fallback) {
   if (body && typeof body === "object") {
     const record2 = body;
@@ -5602,34 +5726,34 @@ import { basename } from "node:path";
 function camel(segment) {
   return segment.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
 }
-function scalar(option, raw) {
-  const type = option.type.replace("[]", "");
-  if (option.enum && !option.enum.includes(raw)) {
+function scalar(option2, raw) {
+  const type = option2.type.replace("[]", "");
+  if (option2.enum && !option2.enum.includes(raw)) {
     throw new UsageError(
-      `--${option.flag} must be one of ${option.enum.join(", ")}`
+      `--${option2.flag} must be one of ${option2.enum.join(", ")}`
     );
   }
   if (type === "integer" || type === "number") {
     const value2 = Number(raw);
     if (raw.trim() === "" || Number.isNaN(value2) || type === "integer" && !Number.isInteger(value2)) {
       throw new UsageError(
-        `--${option.flag} must be ${type === "integer" ? "an integer" : "a number"}`
+        `--${option2.flag} must be ${type === "integer" ? "an integer" : "a number"}`
       );
     }
     return value2;
   }
   if (type === "boolean") {
     if (raw !== "true" && raw !== "false") {
-      throw new UsageError(`--${option.flag} must be true or false`);
+      throw new UsageError(`--${option2.flag} must be true or false`);
     }
     return raw === "true";
   }
-  if (type === "json") return parseJson(raw, `--${option.flag}`);
+  if (type === "json") return parseJson(raw, `--${option2.flag}`);
   return raw;
 }
-function value(option, raws) {
-  if (option.type.endsWith("[]")) return raws.map((raw) => scalar(option, raw));
-  return scalar(option, raws.at(-1));
+function value(option2, raws) {
+  if (option2.type.endsWith("[]")) return raws.map((raw) => scalar(option2, raw));
+  return scalar(option2, raws.at(-1));
 }
 var nodeReader = {
   text: async (path) => readFileSync2(path, "utf8"),
@@ -5641,12 +5765,12 @@ async function readInput(raw, io) {
   return raw;
 }
 async function resolveInputs(command, parsed, io) {
-  const jsonFlags = [...command.query, ...command.body?.fields ?? []].filter((option) => option.type === "json").map((option) => option.flag);
+  const jsonFlags = [...command.query, ...command.body?.fields ?? []].filter((option2) => option2.type === "json").map((option2) => option2.flag);
   const flags = new Map(parsed.flags);
-  for (const flag of jsonFlags) {
-    const raws = flags.get(flag);
+  for (const flag2 of jsonFlags) {
+    const raws = flags.get(flag2);
     if (raws)
-      flags.set(flag, await Promise.all(raws.map((raw) => readInput(raw, io))));
+      flags.set(flag2, await Promise.all(raws.map((raw) => readInput(raw, io))));
   }
   const body = parsed.body === void 0 ? void 0 : await readInput(parsed.body, io);
   return { ...parsed, flags, body };
@@ -5696,18 +5820,18 @@ async function buildRequest(command, input, context = {}) {
   });
   const flags = new Map(parsed.flags);
   const query = new URLSearchParams();
-  for (const option of command.query) {
-    const raws = flags.get(option.flag);
-    flags.delete(option.flag);
+  for (const option2 of command.query) {
+    const raws = flags.get(option2.flag);
+    flags.delete(option2.flag);
     if (!raws) {
-      if (option.required) throw new UsageError(`--${option.flag} is required`);
+      if (option2.required) throw new UsageError(`--${option2.flag} is required`);
       continue;
     }
-    const parsedValue = value(option, raws);
+    const parsedValue = value(option2, raws);
     const values = Array.isArray(parsedValue) ? parsedValue : [parsedValue];
-    if (option.explode === false)
-      query.append(option.name, values.map(String).join(","));
-    else for (const v of values) query.append(option.name, String(v));
+    if (option2.explode === false)
+      query.append(option2.name, values.map(String).join(","));
+    else for (const v of values) query.append(option2.name, String(v));
   }
   const built = { method: command.method, path, query };
   const body = command.body;
@@ -5757,11 +5881,11 @@ async function buildRequest(command, input, context = {}) {
     flags.delete(field.flag);
     json[field.name] = value(field, raws);
   }
-  for (const [flag, raws] of [...flags]) {
-    const [head, ...rest] = flag.split(".");
+  for (const [flag2, raws] of [...flags]) {
+    const [head, ...rest] = flag2.split(".");
     const field = body.fields.find((f) => f.flag === head);
     if (!field || rest.length === 0) continue;
-    flags.delete(flag);
+    flags.delete(flag2);
     const current = json[field.name];
     json[field.name] = typeof current === "object" && current !== null ? current : {};
     setPath(json, [field.name, ...rest.map(camel)], loose(raws.at(-1)));
@@ -5793,6 +5917,679 @@ function rejectUnknown(flags) {
   }
 }
 
+// src/sync/activities.ts
+function indentJson(data) {
+  return JSON.stringify(data, null, 2).split("\n").map((line2) => `  ${line2}`).join("\n");
+}
+function action(label, payload) {
+  const info = payload.info;
+  const detail = info && Object.keys(info).length > 0 ? `
+info:
+${indentJson(info)}` : "";
+  return `[${label}: ${payload.actionName}]:${detail}
+`;
+}
+function line(payload) {
+  switch (payload.activityType) {
+    case "reasoning":
+      return `[reasoning]:
+${payload.reasoning}
+`;
+    case "generic":
+      return `[message]:
+${payload.message}
+`;
+    case "user_message_received":
+      return `[user_message]:
+${payload.message}
+`;
+    case "action_started":
+      return action("action_started", payload);
+    case "action_completed":
+      return action("action_completed", payload);
+    case "action_failed":
+      return `[action_failed: ${payload.actionName}]:
+failure: ${payload.message}
+`;
+    case "compaction_performed":
+      return `[compaction]: summary_tokens: ${payload.summaryTokens}, duration_ms: ${payload.durationMs}
+`;
+    case "compaction_started":
+      return "[compaction_started]\n";
+    default: {
+      const summary2 = payload.display?.summaryText;
+      return summary2 ? `[${payload.activityType}]: ${summary2}
+` : `[${payload.activityType}]
+`;
+    }
+  }
+}
+function formatActivitiesMarkdown(activities, status, createdAt) {
+  const lines = [
+    "# Execution Activities\n",
+    `Status: ${status}`,
+    `Started: ${createdAt}`
+  ];
+  let currentTurn = "";
+  for (const { payload } of activities) {
+    const turnId = payload.display?.turnId ?? "";
+    if (turnId && turnId !== currentTurn) {
+      currentTurn = turnId;
+      lines.push(`
+---
+
+## ${turnId}
+`);
+    } else if (!currentTurn && !turnId) {
+      currentTurn = "_started";
+      lines.push("\n---\n");
+    }
+    lines.push(line(payload));
+  }
+  return lines.join("\n");
+}
+
+// ../workflow-files/src/representation/name-charset.ts
+var NAME_CHARSET_RE = /^[A-Za-z0-9 !#$%&'()+,.;=@^`{}[\]~-]+$/;
+var WINDOWS_RESERVED = /* @__PURE__ */ new Set([
+  "con",
+  "prn",
+  "aux",
+  "nul",
+  ...Array.from({ length: 9 }, (_, i) => `com${i + 1}`),
+  ...Array.from({ length: 9 }, (_, i) => `lpt${i + 1}`)
+]);
+function isNameCharsetConforming(name) {
+  return NAME_CHARSET_RE.test(name);
+}
+
+// ../workflow-files/src/representation/types.ts
+function normalizeNodeName(name) {
+  let result = name.toLowerCase();
+  result = result.replace(/[^a-z0-9]+/g, "_");
+  result = result.replace(/^_+|_+$/g, "");
+  if (result.length > 80) {
+    result = result.slice(0, 80).replace(/_+$/, "");
+  }
+  if (result === "") {
+    throw new Error(
+      `representation: node name "${name}" produces an empty directory name after normalization`
+    );
+  }
+  return result;
+}
+function nodeDirName(name) {
+  if (isNameCharsetConforming(name)) {
+    return name.replaceAll(" ", "_");
+  }
+  return normalizeNodeName(name);
+}
+function agentDirName(name) {
+  try {
+    return nodeDirName(name);
+  } catch {
+    return "agent";
+  }
+}
+function executionDirName(executionId) {
+  return executionId.slice(0, 8);
+}
+function workflowDirName(workflowId, version, parentId, parentVersion) {
+  const short = workflowId.slice(0, 8);
+  if (version !== void 0 && version !== null) {
+    return `v${version}_${short}`;
+  }
+  if (parentId) {
+    if (parentVersion !== void 0 && parentVersion !== null) {
+      return `draft_${short}_from_v${parentVersion}`;
+    }
+    return `draft_${short}_from_draft_${parentId.slice(0, 8)}`;
+  }
+  return `draft_${short}`;
+}
+
+// src/sync/paths.ts
+import { createHash } from "node:crypto";
+function join3(...parts) {
+  return parts.filter((part) => part !== "").join("/").replace(/\/{2,}/g, "/");
+}
+function workflowRoot(root, workflowName) {
+  return join3(root, agentDirName(workflowName));
+}
+function isContained(path) {
+  if (path === "" || path.startsWith("/") || path.includes("\\")) return false;
+  return path.split("/").every((segment) => segment !== ".." && segment !== "");
+}
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function matchesGlob(path, pattern) {
+  let source = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*" && pattern[i + 1] === "*" && pattern[i + 2] === "/") {
+      source += "(?:.*/)?";
+      i += 2;
+    } else if (ch === "*" && pattern[i + 1] === "*") {
+      source += ".*";
+      i += 1;
+    } else if (ch === "*") source += "[^/]*";
+    else if (ch === "?") source += "[^/]";
+    else source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${source}$`).test(path);
+}
+
+// src/sync/types.ts
+var MANIFEST = ".asteroid.json";
+function get(path, query = {}) {
+  return { method: "GET", path, query: new URLSearchParams(query) };
+}
+function statusOf(error) {
+  const status = error?.status;
+  return typeof status === "number" ? status : void 0;
+}
+
+// src/sync/execution-pull.ts
+var DIRECTORIES = ["workspace", "downloads", "shared"];
+function relativeFilePath(file) {
+  const at = file.filePath.indexOf(`/${file.directory}/`);
+  if (at === -1)
+    return `${file.directory}/${file.filePath.split("/").pop() ?? "unknown"}`;
+  return file.filePath.slice(at + 1).replace(/^workspace\/\.execution-context\//, "");
+}
+function executionDir(options, execution) {
+  const chosen = options.dir?.(execution);
+  if (chosen) return chosen;
+  const root = workflowRoot(
+    options.root,
+    execution.workflowName ?? execution.workflowId
+  );
+  return join3(root, "executions", executionDirName(execution.id));
+}
+async function writeText(sync, path, text2) {
+  await sync.files.write(path, Buffer.from(text2, "utf8"));
+}
+async function writeActivities(sync, dir, execution) {
+  try {
+    const activities = await sync.remote.json(
+      get(`/agents/v2/executions/${execution.id}/activities`, { order: "asc" })
+    );
+    if (activities.length === 0) return false;
+    const markdown = formatActivitiesMarkdown(
+      activities,
+      execution.status,
+      execution.createdAt
+    );
+    await writeText(sync, join3(dir, "activities.md"), markdown);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listFiles(sync, executionId) {
+  const listing = await sync.remote.json(
+    get(`/agents/v2/executions/${executionId}/files`)
+  );
+  return DIRECTORIES.flatMap((name) => listing.directories[name] ?? []);
+}
+async function download(sync, executionId, file) {
+  const path = `/agents/v2/executions/${executionId}/files/${file.id}/signed-url`;
+  const { url } = await sync.remote.json(get(path));
+  return sync.remote.download(url);
+}
+function selectFiles(files, options, skipped) {
+  return files.filter((file) => {
+    const path = relativeFilePath(file);
+    if (!isContained(path)) skipped.push(`${path} (unsafe path)`);
+    else if (options.glob !== void 0 && !matchesGlob(path, options.glob))
+      skipped.push(`${path} (excluded by --files)`);
+    else if (options.maxFileBytes !== void 0 && file.fileSize > options.maxFileBytes)
+      skipped.push(`${path} (${file.fileSize} bytes, over the size limit)`);
+    else return true;
+    return false;
+  });
+}
+async function pullFiles(sync, dir, options) {
+  const skipped = [];
+  const failed = [];
+  let files;
+  try {
+    files = await listFiles(sync, options.executionId);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return {
+      downloaded: 0,
+      candidates: 0,
+      skipped,
+      failed: [`file listing (${reason})`]
+    };
+  }
+  let downloaded = 0;
+  await Promise.all(
+    selectFiles(files, options, skipped).map(async (file) => {
+      try {
+        const bytes = await download(sync, options.executionId, file);
+        await sync.files.write(join3(dir, relativeFilePath(file)), bytes);
+        downloaded++;
+      } catch (error) {
+        failed.push(
+          `${file.fileName} (${error instanceof Error ? error.message : String(error)})`
+        );
+      }
+    })
+  );
+  return { downloaded, candidates: files.length, skipped, failed };
+}
+async function pullExecution(sync, options) {
+  const execution = await sync.remote.json(
+    get(`/agents/v2/executions/${options.executionId}`)
+  );
+  const dir = executionDir(options, execution);
+  await writeText(
+    sync,
+    join3(dir, "summary.json"),
+    JSON.stringify(execution, null, 2)
+  );
+  const result = {
+    execution,
+    dir,
+    written: ["summary.json"],
+    downloaded: 0,
+    candidates: 0,
+    skipped: [],
+    failed: []
+  };
+  if (execution.purgedAt) return result;
+  if (options.activities !== false && await writeActivities(sync, dir, execution))
+    result.written.push("activities.md");
+  if (options.files === false) {
+    return {
+      ...result,
+      skippedBy: options.activities === false ? "--summary-only" : "--no-files"
+    };
+  }
+  return { ...result, ...await pullFiles(sync, dir, options) };
+}
+function filesLine(result) {
+  const parts = [...result.written];
+  if (result.downloaded > 0) parts.push(`${result.downloaded} downloaded`);
+  const counted = `Files: ${result.written.length + result.downloaded} written (${parts.join(", ")})`;
+  if (result.skippedBy)
+    return `${counted}; downloads skipped (${result.skippedBy})`;
+  if (result.candidates === 0) return `${counted}; no execution files matched`;
+  return counted;
+}
+function failures(execution) {
+  const list = execution.scriptFailures ?? [];
+  if (list.length === 0) return null;
+  const lines = list.map(
+    (f) => `  - ${f.nodeName ?? "(unknown node)"}: ${(f.error ?? "").split("\n")[0]}`
+  );
+  return `Script failures: ${list.length}
+${lines.join("\n")}`;
+}
+function purged(result) {
+  const { execution } = result;
+  return [
+    `Execution: ${execution.id}`,
+    `Status: ${execution.status}`,
+    `Purged: ${execution.purgedAt}`,
+    "This run was retention-purged. Activities, files, inputs and result are gone. Do not diagnose it.",
+    `Written to: ${result.dir}/`
+  ].join("\n");
+}
+function formatExecutionPull(result) {
+  const { execution } = result;
+  if (execution.purgedAt) return purged(result);
+  const outcome = execution.executionResult;
+  return [
+    `Execution: ${execution.id}`,
+    `Status: ${execution.status}`,
+    `Workflow: ${execution.workflowName ?? execution.workflowId}`,
+    execution.workflowVersionId ? `Workflow version: ${execution.workflowVersionId}` : null,
+    execution.inputs ? `Inputs: ${JSON.stringify(execution.inputs)}` : null,
+    outcome ? `Result: ${outcome.outcome}: ${outcome.reasoning}` : null,
+    `Created: ${execution.createdAt}`,
+    execution.terminalAt ? `Completed: ${execution.terminalAt}` : null,
+    execution.duration != null ? `Duration: ${execution.duration.toFixed(1)}s` : null,
+    failures(execution),
+    filesLine(result),
+    result.skipped.length > 0 ? `Skipped:
+${result.skipped.map((s) => `  - ${s}`).join("\n")}` : null,
+    result.failed.length > 0 ? `Failed: ${result.failed.join(", ")}` : null,
+    `Written to: ${result.dir}/`
+  ].filter(Boolean).join("\n");
+}
+
+// src/sync/node-files.ts
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname as dirname2, relative, resolve, sep } from "node:path";
+function missing(error) {
+  return error.code === "ENOENT";
+}
+async function walk(root, dir, out) {
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const path = resolve(dir, entry.name);
+    if (entry.isDirectory()) await walk(root, path, out);
+    else if (entry.isFile())
+      out.push(relative(root, path).split(sep).join("/"));
+  }
+}
+function nodeFiles(cwd) {
+  const at = (path) => resolve(cwd, path);
+  return {
+    async read(path) {
+      try {
+        return new Uint8Array(await readFile(at(path)));
+      } catch (error) {
+        if (missing(error)) return void 0;
+        throw error;
+      }
+    },
+    async write(path, bytes) {
+      await mkdir(dirname2(at(path)), { recursive: true });
+      await writeFile(at(path), bytes);
+    },
+    async remove(path) {
+      await rm(at(path), { force: true });
+    },
+    async list(dir) {
+      const out = [];
+      try {
+        await walk(at(dir), at(dir), out);
+      } catch (error) {
+        if (!missing(error)) throw error;
+      }
+      return out.sort();
+    }
+  };
+}
+
+// src/sync/workflow-pull.ts
+var CONCURRENCY = 16;
+function treeRequest(options) {
+  const base = `/agents/v2/workflows/${options.workflowId}`;
+  const path = options.versionId ? `${base}/versions/${options.versionId}/files` : `${base}/head/files`;
+  return get(path, { contents: "all" });
+}
+function pullDir(options, tree) {
+  if (options.dir) return options.dir;
+  const root = workflowRoot(options.root, tree.workflowName);
+  if (!options.versionId) return join3(root, "head");
+  return join3(root, ".versions", workflowDirName(tree.versionId, tree.version));
+}
+async function agentFileBytes(sync, workflowId, tree, entry) {
+  const path = `/agents/v2/workflows/${workflowId}/versions/${tree.versionId}/files/${entry.fileId}/signed-url`;
+  const { url } = await sync.remote.json(get(path));
+  return sync.remote.download(url);
+}
+async function entryBytes(sync, workflowId, tree, entry) {
+  if (entry.contentBase64 !== void 0)
+    return Buffer.from(entry.contentBase64, "base64");
+  if (entry.content !== void 0) return Buffer.from(entry.content, "utf8");
+  if (!entry.fileId) return void 0;
+  return agentFileBytes(sync, workflowId, tree, entry);
+}
+async function writeEntries(sync, options, tree, dir) {
+  const hashes = {};
+  const skipped = [];
+  let shared = 0;
+  const wanted = tree.files.filter((entry) => {
+    if (!isContained(entry.path)) skipped.push(`${entry.path} (unsafe path)`);
+    else if (options.maxFileBytes !== void 0 && entry.size > options.maxFileBytes)
+      skipped.push(`${entry.path} (${entry.size} bytes, over the size limit)`);
+    else return true;
+    return false;
+  });
+  for (let i = 0; i < wanted.length; i += CONCURRENCY) {
+    await Promise.all(
+      wanted.slice(i, i + CONCURRENCY).map(async (entry) => {
+        const bytes = await entryBytes(sync, options.workflowId, tree, entry);
+        if (!bytes) return void skipped.push(`${entry.path} (no content)`);
+        await sync.files.write(join3(dir, entry.path), bytes);
+        hashes[entry.path] = sha256(bytes);
+        if (entry.kind === "agent_file") shared++;
+      })
+    );
+  }
+  return { hashes, skipped, shared };
+}
+async function removeStale(sync, dir, keep) {
+  for (const path of await sync.files.list(dir)) {
+    if (!keep.has(path) && path !== MANIFEST)
+      await sync.files.remove(join3(dir, path));
+  }
+}
+async function writeManifest(sync, dir, manifest) {
+  const text2 = `${JSON.stringify(manifest, null, 2)}
+`;
+  await sync.files.write(join3(dir, MANIFEST), Buffer.from(text2, "utf8"));
+}
+async function pullWorkflow(sync, options) {
+  const tree = await sync.remote.json(treeRequest(options));
+  const dir = pullDir(options, tree);
+  const { hashes, skipped, shared } = await writeEntries(
+    sync,
+    options,
+    tree,
+    dir
+  );
+  await removeStale(sync, dir, new Set(Object.keys(hashes)));
+  if (options.manifest !== false) {
+    await writeManifest(sync, dir, {
+      workflowId: options.workflowId,
+      versionId: tree.versionId,
+      head: !options.versionId,
+      rev: tree.rev,
+      files: hashes
+    });
+  }
+  return {
+    workflowId: options.workflowId,
+    workflowName: tree.workflowName,
+    versionId: tree.versionId,
+    version: tree.version,
+    rev: tree.rev,
+    dir,
+    written: Object.keys(hashes).length,
+    shared,
+    skipped
+  };
+}
+function formatWorkflowPull(result) {
+  const definition = result.written - result.shared;
+  const files = result.written === 0 ? "Files: none written" : result.shared === 0 ? `Files: ${result.written} written` : `Files: ${result.written} written (${definition} workflow definition, ${result.shared} shared)`;
+  return [
+    `Workflow: ${result.workflowName} (${result.workflowId})`,
+    `Workflow version: ${result.versionId}${result.version ? ` (v${result.version})` : " (draft)"}`,
+    `Written to: ${result.dir}/`,
+    files,
+    result.skipped.length > 0 ? `Skipped:
+${result.skipped.map((s) => `  - ${s}`).join("\n")}` : null
+  ].filter(Boolean).join("\n");
+}
+
+// src/sync/workflow-push.ts
+async function readManifest(sync, dir) {
+  const bytes = await sync.files.read(join3(dir, MANIFEST));
+  if (!bytes) {
+    throw new UsageError(
+      `no pulled workflow in ${dir}. Run \`asteroid workflow pull <workflow-id>\`, then push from the head folder it writes.`
+    );
+  }
+  const manifest = JSON.parse(Buffer.from(bytes).toString("utf8"));
+  if (!manifest.head) {
+    throw new UsageError(
+      `${dir} holds a pinned workflow version, which is read-only. Push from a pulled head.`
+    );
+  }
+  return manifest;
+}
+async function localChanges(sync, dir, manifest) {
+  const local2 = (await sync.files.list(dir)).filter(
+    (path) => path !== MANIFEST
+  );
+  const writes = [];
+  for (const path of local2) {
+    const bytes = await sync.files.read(join3(dir, path));
+    if (!bytes) continue;
+    const hash = sha256(bytes);
+    if (manifest.files[path] === hash) continue;
+    writes.push({
+      path,
+      contentBase64: Buffer.from(bytes).toString("base64"),
+      hash
+    });
+  }
+  const present = new Set(local2);
+  const deletes = Object.keys(manifest.files).filter(
+    (path) => !present.has(path)
+  );
+  return { writes, deletes };
+}
+async function patch(sync, manifest, writes, deletes) {
+  try {
+    await sync.remote.json({
+      method: "PATCH",
+      path: `/agents/v2/workflows/${manifest.workflowId}/head/files`,
+      query: new URLSearchParams(),
+      json: { baseRev: manifest.rev, writes, deletes }
+    });
+  } catch (error) {
+    if (statusOf(error) !== 409) throw error;
+    throw new UsageError(
+      `the workflow head changed since your pull (rev ${manifest.rev}). Copy your edits aside, run \`asteroid workflow pull ${manifest.workflowId}\`, reapply them, then push again.`
+    );
+  }
+}
+async function refresh2(sync, dir, manifest, pushed) {
+  const tree = await sync.remote.json(
+    get(`/agents/v2/workflows/${manifest.workflowId}/head/files`)
+  );
+  const files = {};
+  for (const entry of tree.files) {
+    if (entry.content !== void 0) {
+      const bytes = Buffer.from(entry.content, "utf8");
+      files[entry.path] = sha256(bytes);
+      if (pushed.get(entry.path) !== files[entry.path])
+        await sync.files.write(join3(dir, entry.path), bytes);
+    } else {
+      const local2 = await sync.files.read(join3(dir, entry.path));
+      const hash = local2 ? sha256(local2) : pushed.get(entry.path) ?? entry.checksum;
+      if (hash) files[entry.path] = hash;
+    }
+  }
+  for (const path of await sync.files.list(dir)) {
+    if (path !== MANIFEST && !(path in files))
+      await sync.files.remove(join3(dir, path));
+  }
+  const next = { ...manifest, versionId: tree.versionId, rev: tree.rev, files };
+  await writeManifest(sync, dir, next);
+  return next;
+}
+async function pushWorkflow(sync, dir) {
+  const manifest = await readManifest(sync, dir);
+  const { writes, deletes } = await localChanges(sync, dir, manifest);
+  const result = {
+    workflowId: manifest.workflowId,
+    dir,
+    written: writes.map((w) => w.path),
+    deleted: deletes
+  };
+  if (writes.length === 0 && deletes.length === 0) {
+    return { ...result, rev: manifest.rev, versionId: manifest.versionId };
+  }
+  await patch(
+    sync,
+    manifest,
+    writes.map(({ path, contentBase64 }) => ({ path, contentBase64 })),
+    deletes
+  );
+  const next = await refresh2(
+    sync,
+    dir,
+    manifest,
+    new Map(writes.map((w) => [w.path, w.hash]))
+  );
+  return { ...result, rev: next.rev, versionId: next.versionId };
+}
+function formatWorkflowPush(result) {
+  if (result.written.length === 0 && result.deleted.length === 0) {
+    return `Nothing to push: ${result.dir}/ matches the head you pulled (rev ${result.rev}).`;
+  }
+  return [
+    `Pushed to workflow ${result.workflowId}: ${result.written.length} written, ${result.deleted.length} deleted.`,
+    ...result.written.map((path) => `  + ${path}`),
+    ...result.deleted.map((path) => `  - ${path}`),
+    `Head is now rev ${result.rev} (version ${result.versionId}).`
+  ].join("\n");
+}
+
+// src/sync/run.ts
+function flag(parsed, name) {
+  return parsed.flags.get(name)?.at(-1);
+}
+function integer(parsed, name) {
+  const raw = flag(parsed, name);
+  if (raw === void 0) return void 0;
+  if (!/^\d+$/.test(raw))
+    throw new UsageError(`--${name} must be a whole number`);
+  return Number(raw);
+}
+function executionOptions(parsed) {
+  const summaryOnly = flag(parsed, "summary-only") === "true";
+  const glob = flag(parsed, "files");
+  const dir = flag(parsed, "dir");
+  return {
+    executionId: parsed.positionals[0],
+    activities: !summaryOnly,
+    files: !summaryOnly && glob !== "false",
+    glob: glob === "false" ? void 0 : glob,
+    maxFileBytes: integer(parsed, "max-file-size"),
+    dir: dir ? () => dir : void 0
+  };
+}
+async function execute(command, parsed, sync, deps) {
+  const root = deps.root ?? "";
+  switch (command.command) {
+    case "workflow pull": {
+      const result = await pullWorkflow(sync, {
+        workflowId: parsed.positionals[0],
+        versionId: flag(parsed, "version-id"),
+        dir: flag(parsed, "dir"),
+        root,
+        ...deps.workflowPull
+      });
+      return { result, text: formatWorkflowPull(result) };
+    }
+    case "workflow push": {
+      const result = await pushWorkflow(sync, flag(parsed, "dir") ?? ".");
+      return { result, text: formatWorkflowPush(result) };
+    }
+    case "execution pull": {
+      const result = await pullExecution(sync, {
+        ...executionOptions(parsed),
+        root,
+        ...deps.executionPull
+      });
+      return { result, text: formatExecutionPull(result) };
+    }
+    default:
+      throw new UsageError(`unknown command ${command.command}`);
+  }
+}
+async function runSync(command, parsed, deps) {
+  const sync = {
+    remote: deps.remote,
+    files: deps.files ?? nodeFiles(deps.cwd)
+  };
+  const { result, text: text2 } = await execute(command, parsed, sync, deps);
+  deps.stdout(`${parsed.json ? JSON.stringify(result, null, 2) : text2}
+`);
+  return 0;
+}
+
 // src/run.ts
 function rejectOrgWithApiKey(deps, flagOrg) {
   if (deps.env.apiKey && (flagOrg || deps.env.org)) {
@@ -5832,25 +6629,30 @@ async function credentialOrganization(deps, auth) {
   );
   return response.json?.organizationId;
 }
-async function runCommand(command, parsed, deps) {
-  const needsOrganization = command.body?.credentialOrganization === true;
-  let request = needsOrganization ? void 0 : await buildRequest(command, parsed);
+async function authFor(parsed, deps) {
   rejectOrgWithApiKey(deps, parsed.org);
   const config = loadConfig(deps.env);
-  const auth = await resolveAuth(
+  return resolveAuth(
     deps.env,
     config,
     requestedOrg(parsed.org, deps.env, deps.cwd, config),
     deps.fetch
   );
+}
+function announce(command, auth, deps) {
+  if (command.readOnly) return;
+  const org = auth.kind === "api-key" ? "the API key's organization" : auth.org ? orgLabel(auth.org) : "your default organization";
+  deps.stderr(`Acting in ${org}.
+`);
+}
+async function runCommand(command, parsed, deps) {
+  const needsOrganization = command.body?.credentialOrganization === true;
+  let request = needsOrganization ? void 0 : await buildRequest(command, parsed);
+  const auth = await authFor(parsed, deps);
   request ??= await buildRequest(command, parsed, {
     organizationId: await credentialOrganization(deps, auth)
   });
-  if (!command.readOnly) {
-    const org = auth.kind === "api-key" ? "the API key's organization" : auth.org ? orgLabel(auth.org) : "your default organization";
-    deps.stderr(`Acting in ${org}.
-`);
-  }
+  announce(command, auth, deps);
   const response = await send(
     deps.env.apiUrl,
     auth,
@@ -5878,7 +6680,10 @@ async function runCommand(command, parsed, deps) {
   }
   if (response.json !== void 0) {
     deps.stdout(
-      `${parsed.json ? JSON.stringify(response.json, null, 2) : render(response.json, { styled: deps.styled })}
+      `${parsed.json ? JSON.stringify(response.json, null, 2) : render(response.json, {
+        styled: deps.styled,
+        full: !deps.stdoutIsTTY
+      })}
 `
     );
     return 0;
@@ -5887,11 +6692,22 @@ async function runCommand(command, parsed, deps) {
 `);
   return 0;
 }
-var DESCRIPTION = "The Asteroid CLI. Sign in with `asteroid login`, or set ASTEROID_API_KEY.";
+function nodeRemote(apiUrl, auth, fetchImpl) {
+  return {
+    json: async (request) => (await send(apiUrl, auth, request, false, fetchImpl)).json,
+    async download(url) {
+      const response = await fetchImpl(url);
+      if (!response.ok)
+        throw new Error(`download failed: HTTP ${response.status}`);
+      return new Uint8Array(await response.arrayBuffer());
+    }
+  };
+}
+var DESCRIPTION = "The Asteroid CLI. Sign in with `asteroid login`, or set ASTEROID_API_KEY.\nAt a terminal, tables show up to 6 columns and cut long cells to fit; when output is piped, they show every column in full. Use `--json` for every field.";
 async function run(argv2, deps) {
   try {
     const invocation = await parseInvocation(argv2, {
-      commands: COMMANDS,
+      commands: ALL_COMMANDS,
       builtins: BUILTINS,
       version: VERSION,
       description: DESCRIPTION
@@ -5904,6 +6720,14 @@ async function run(argv2, deps) {
     if (invocation.kind === "builtin") {
       return await runBuiltin(invocation.name, invocation.parsed, deps);
     }
+    if (invocation.command.local) {
+      const auth = await authFor(invocation.parsed, deps);
+      announce(invocation.command, auth, deps);
+      return await runSync(invocation.command, invocation.parsed, {
+        ...deps,
+        remote: nodeRemote(deps.env.apiUrl, auth, deps.fetch)
+      });
+    }
     return await runCommand(invocation.command, invocation.parsed, deps);
   } catch (error) {
     if (error instanceof UsageError) {
@@ -5959,7 +6783,7 @@ function openUrl(url) {
 }
 var argv = process.argv.slice(2);
 if (argv[0] === "complete") {
-  await runCompletion(argv, { commands: COMMANDS, builtins: BUILTINS });
+  await runCompletion(argv, { commands: ALL_COMMANDS, builtins: BUILTINS });
   process.exit(0);
 }
 var code = await run(argv, {