@syntropic137/cli 0.19.0

package/dist/syn.mjs

@@ -0,0 +1,4823 @@
+#!/usr/bin/env node
+
+// src/config.ts
+var CLI_NAME = "syn";
+var CLI_VERSION = "0.18.0";
+var CLI_DESCRIPTION = "Syntropic137 - Event-sourced workflow engine for AI agents";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var SSE_CONNECT_TIMEOUT_MS = 5e3;
+function getApiUrl() {
+  return process.env["SYN_API_URL"] ?? "http://localhost:8137";
+}
+function getAuthHeaders() {
+  const token = process.env["SYN_API_TOKEN"];
+  if (token) return { Authorization: `Bearer ${token}` };
+  const user = process.env["SYN_API_USER"];
+  const password = process.env["SYN_API_PASSWORD"];
+  if (user && password) {
+    const encoded = Buffer.from(`${user}:${password}`).toString("base64");
+    return { Authorization: `Basic ${encoded}` };
+  }
+  return {};
+}
+
+// src/framework/errors.ts
+var CLIError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CLIError";
+    this.exitCode = exitCode;
+  }
+};
+
+// src/output/ansi.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var CYAN = "\x1B[36m";
+var ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+function isColorEnabled() {
+  if (process.env["NO_COLOR"] !== void 0) return false;
+  return process.stdout.isTTY === true;
+}
+function style(text, ...codes) {
+  if (!isColorEnabled()) return text;
+  return codes.join("") + text + RESET;
+}
+function stripAnsi(text) {
+  return text.replace(ANSI_REGEX, "");
+}
+
+// src/output/console.ts
+function printError(message) {
+  process.stderr.write(style("Error:", BOLD, RED) + " " + message + "\n");
+}
+function printSuccess(message) {
+  process.stdout.write(style(message, GREEN) + "\n");
+}
+function printDim(message) {
+  process.stdout.write(style(message, DIM) + "\n");
+}
+function print(message) {
+  process.stdout.write(message + "\n");
+}
+
+// src/client/http.ts
+var SynClient = class {
+  baseUrl;
+  timeoutMs;
+  authHeaders;
+  constructor(options) {
+    this.baseUrl = options?.baseUrl ?? getApiUrl();
+    this.timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.authHeaders = getAuthHeaders();
+  }
+  async get(path8, params) {
+    const url = this.buildUrl(path8, params);
+    return this.request(url, { method: "GET" });
+  }
+  async post(path8, body, params) {
+    const url = this.buildUrl(path8, params);
+    return this.request(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+  }
+  async put(path8, body) {
+    const url = this.buildUrl(path8);
+    return this.request(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+  }
+  async patch(path8, body) {
+    const url = this.buildUrl(path8);
+    return this.request(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+  }
+  async delete(path8) {
+    const url = this.buildUrl(path8);
+    return this.request(url, { method: "DELETE" });
+  }
+  async stream(path8) {
+    const url = this.buildUrl(path8);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), SSE_CONNECT_TIMEOUT_MS);
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: { ...this.authHeaders },
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body;
+  }
+  buildUrl(path8, params) {
+    const base = new URL(this.baseUrl);
+    const basePath = base.pathname.replace(/\/+$/, "");
+    const reqPath = path8.startsWith("/") ? path8 : `/${path8}`;
+    const url = new URL(`${basePath}${reqPath}`, base);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url;
+  }
+  async request(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const existingHeaders = init.headers;
+      const response = await fetch(url.toString(), {
+        ...init,
+        headers: { ...this.authHeaders, ...existingHeaders },
+        signal: controller.signal
+      });
+      const data = response.status === 204 || response.status === 205 ? void 0 : await response.json();
+      return { status: response.status, data };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/client/api.ts
+function handleConnectError() {
+  printError(`Could not connect to API at ${getApiUrl()}`);
+  printDim("Make sure the API server is running.");
+  throw new CLIError("Connection failed", 1);
+}
+function checkResponse(status, data, expected) {
+  if (expected.includes(status)) return;
+  let detail = `HTTP ${status}`;
+  if (typeof data === "object" && data !== null && "detail" in data && typeof data.detail === "string") {
+    detail = data.detail;
+  }
+  throw new CLIError(detail);
+}
+async function safeRequest(fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    if (err instanceof CLIError) throw err;
+    handleConnectError();
+  }
+}
+async function apiGet(path8, options) {
+  const client = new SynClient();
+  const { status, data } = await safeRequest(
+    () => client.get(path8, options?.params)
+  );
+  checkResponse(status, data, options?.expected ?? [200]);
+  return data;
+}
+async function apiGetList(path8, options) {
+  const client = new SynClient();
+  const { status, data } = await safeRequest(
+    () => client.get(path8, options?.params)
+  );
+  checkResponse(status, data, options?.expected ?? [200]);
+  return data;
+}
+async function apiPost(path8, options) {
+  const client = new SynClient(
+    options?.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : void 0
+  );
+  const { status, data } = await safeRequest(
+    () => client.post(path8, options?.body, options?.params)
+  );
+  checkResponse(status, data, options?.expected ?? [200]);
+  return data;
+}
+async function apiPut(path8, options) {
+  const client = new SynClient();
+  const { status, data } = await safeRequest(
+    () => client.put(path8, options?.body)
+  );
+  checkResponse(status, data, options?.expected ?? [200]);
+  return data;
+}
+async function apiDelete(path8, options) {
+  const client = new SynClient();
+  const { status, data } = await safeRequest(() => client.delete(path8));
+  checkResponse(status, data, options?.expected ?? [200]);
+  return data;
+}
+function buildParams(params) {
+  const result = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== null && value !== void 0) {
+      result[key] = String(value);
+    }
+  }
+  return result;
+}
+
+// src/commands/health.ts
+var healthCommand = {
+  name: "health",
+  description: "Check API server health status",
+  handler: async () => {
+    const data = await apiGet("/health");
+    const { status, mode } = data;
+    if (status === "healthy" && mode === "full") {
+      print(style("Healthy", BOLD, GREEN) + " \u2014 all systems operational");
+    } else if (status === "healthy") {
+      print(style("Degraded", BOLD, YELLOW) + ` \u2014 mode: ${mode}`);
+      if (data.degraded_reasons) {
+        for (const reason of data.degraded_reasons) {
+          print(style(`  \u2022 ${reason}`, YELLOW));
+        }
+      }
+    } else {
+      print(style("Unhealthy", BOLD, RED) + ` \u2014 status: ${status}`);
+      throw new CLIError("API is unhealthy");
+    }
+    if (data.subscription) {
+      print(style("  Event store: connected", DIM));
+      print(style(`  Subscription: ${data.subscription.status}`, DIM));
+    }
+  }
+};
+
+// src/commands/version.ts
+var versionCommand = {
+  name: "version",
+  description: "Show version information",
+  handler: () => {
+    print(`${style("Syntropic137", BOLD)} v${CLI_VERSION}`);
+  }
+};
+
+// src/framework/command.ts
+var CommandGroup = class {
+  name;
+  description;
+  _commands = /* @__PURE__ */ new Map();
+  constructor(name, description) {
+    this.name = name;
+    this.description = description;
+  }
+  get commands() {
+    return this._commands;
+  }
+  command(def) {
+    this._commands.set(def.name, def);
+    return this;
+  }
+  getCommand(name) {
+    return this._commands.get(name);
+  }
+};
+
+// src/output/table.ts
+var Table = class {
+  columns = [];
+  rows = [];
+  title;
+  constructor(options) {
+    this.title = options?.title;
+  }
+  addColumn(name, options) {
+    this.columns.push({ name, ...options });
+    return this;
+  }
+  addRow(...values) {
+    this.rows.push(values);
+    return this;
+  }
+  render() {
+    const widths = this.columns.map((col, i) => {
+      const headerLen = stripAnsi(col.name).length;
+      const cellLens = this.rows.map(
+        (row) => stripAnsi(row[i] ?? "").length
+      );
+      const maxCell = cellLens.length > 0 ? Math.max(...cellLens) : 0;
+      const natural = Math.max(headerLen, maxCell);
+      return col.maxWidth !== void 0 ? Math.min(natural, col.maxWidth) : natural;
+    });
+    const lines = [];
+    if (this.title) {
+      lines.push(style(this.title, BOLD));
+    }
+    const header = this.columns.map((col, i) => pad(style(col.name, BOLD), widths[i], col.align)).join("  ");
+    lines.push(header);
+    const sep = widths.map((w) => "\u2500".repeat(w)).join("  ");
+    lines.push(style(sep, DIM));
+    for (const row of this.rows) {
+      const cells = this.columns.map((col, i) => {
+        const raw = row[i] ?? "";
+        const truncated = truncate(raw, widths[i]);
+        const styled = col.style ? style(truncated, col.style) : truncated;
+        return pad(styled, widths[i], col.align);
+      });
+      lines.push(cells.join("  "));
+    }
+    return lines.join("\n");
+  }
+  print() {
+    process.stdout.write(this.render() + "\n");
+  }
+};
+function truncate(text, maxWidth) {
+  const visible = stripAnsi(text);
+  if (visible.length <= maxWidth) return text;
+  return visible.slice(0, maxWidth - 1) + "\u2026";
+}
+function pad(text, width, align) {
+  const visible = stripAnsi(text).length;
+  const diff = width - visible;
+  if (diff <= 0) return text;
+  const spaces = " ".repeat(diff);
+  return align === "right" ? spaces + text : text + spaces;
+}
+
+// src/commands/workflow/resolver.ts
+async function resolveWorkflow(partialId, opts) {
+  const params = {};
+  if (opts?.includeArchived) {
+    params["include_archived"] = "true";
+  }
+  const data = await apiGet("/workflows", { params });
+  const workflows = data.workflows ?? [];
+  const matching = workflows.filter((w) => w.id.startsWith(partialId));
+  if (matching.length === 0) {
+    printError(`No workflow found matching: ${partialId}`);
+    throw new CLIError("Workflow not found", 1);
+  }
+  if (matching.length > 1) {
+    print(style(`Multiple workflows match '${partialId}':`, YELLOW));
+    for (const w of matching.slice(0, 5)) {
+      print(`  ${style(w.id.slice(0, 12) + "...", DIM)} - ${w.name}`);
+    }
+    printDim("Please provide a more specific ID");
+    throw new CLIError("Ambiguous workflow ID", 1);
+  }
+  const m = matching[0];
+  return {
+    id: m.id,
+    name: m.name,
+    workflow_type: m.workflow_type,
+    phase_count: m.phase_count ?? 0
+  };
+}
+
+// src/packages/resolver.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/persistence/store.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var SYN_DIR = path.join(os.homedir(), ".syntropic137");
+function synPath(...segments) {
+  return path.join(SYN_DIR, ...segments);
+}
+function readJsonFile(filePath, schema, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return schema.parse(JSON.parse(content));
+  } catch {
+    return fallback;
+  }
+}
+function writeJsonFile(filePath, data) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+// src/packages/models.ts
+import { z } from "zod";
+var PluginManifestSchema = z.object({
+  manifest_version: z.number().default(1),
+  name: z.string().min(1),
+  version: z.string().default("0.1.0"),
+  description: z.string().nullish(),
+  author: z.string().nullish(),
+  license: z.string().nullish(),
+  repository: z.string().nullish()
+}).passthrough();
+var InstalledWorkflowRefSchema = z.object({
+  id: z.string(),
+  name: z.string()
+}).strict();
+var InstallationRecordSchema = z.object({
+  package_name: z.string(),
+  package_version: z.string(),
+  source: z.string(),
+  source_ref: z.string(),
+  installed_at: z.string(),
+  format: z.string(),
+  workflows: z.array(InstalledWorkflowRefSchema).default([]),
+  marketplace_source: z.string().nullish(),
+  git_sha: z.string().nullish()
+}).strict();
+var InstalledRegistrySchema = z.object({
+  version: z.number().default(1),
+  installations: z.array(InstallationRecordSchema).default([])
+}).strict();
+
+// src/packages/git.ts
+import { execFile } from "child_process";
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+function gitClone(url, ref, destDir) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(
+      "git",
+      ["clone", "--depth=1", "--branch", ref, url, destDir],
+      { timeout: 12e4 },
+      (error, _stdout, stderr) => {
+        if (error) {
+          reject(new Error(`git clone failed: ${stderr.trim()}`));
+        } else {
+          resolve();
+        }
+      }
+    );
+    child.unref?.();
+  });
+}
+function gitLsRemote(repo, ref) {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      ["ls-remote", `https://github.com/${repo}.git`, ref],
+      { timeout: 3e4 },
+      (error, stdout) => {
+        if (error) {
+          resolve(null);
+          return;
+        }
+        const line = stdout.trim().split("\n")[0] ?? "";
+        if (line.includes("	")) {
+          resolve(line.split("	")[0]);
+        } else {
+          resolve(null);
+        }
+      }
+    );
+  });
+}
+function makeTempDir(prefix) {
+  return fs2.mkdtempSync(path2.join(os2.tmpdir(), prefix));
+}
+function removeTempDir(dir) {
+  try {
+    fs2.rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/packages/yaml.ts
+function parseYaml(input) {
+  const lines = input.split("\n");
+  const { value } = parseNode(lines, 0, -1);
+  return value;
+}
+function skipBlanksAndComments(lines, start) {
+  let i = start;
+  while (i < lines.length) {
+    const trimmed = lines[i].trim();
+    if (trimmed !== "" && !trimmed.startsWith("#")) break;
+    i++;
+  }
+  return i;
+}
+function parseNode(lines, startLine, _parentIndent) {
+  const i = skipBlanksAndComments(lines, startLine);
+  if (i >= lines.length) {
+    return { value: null, nextLine: i };
+  }
+  const line = lines[i];
+  const indent = getIndent(line);
+  const trimmed = line.trim();
+  if (trimmed.startsWith("- ") || trimmed === "-") {
+    return parseList(lines, i, indent);
+  }
+  if (trimmed.includes(":")) {
+    return parseMap(lines, i, indent);
+  }
+  return { value: parseScalar(trimmed), nextLine: i + 1 };
+}
+function parseMapEntry(lines, i, afterColon, mapIndent) {
+  if (afterColon === "" || afterColon.startsWith("#")) {
+    return parseNode(lines, i + 1, mapIndent);
+  }
+  if (afterColon === "|" || afterColon === ">") {
+    return parseMultilineString(lines, i + 1, afterColon);
+  }
+  return { value: parseInlineValue(afterColon), nextLine: i + 1 };
+}
+function parseMap(lines, startLine, mapIndent) {
+  const result = {};
+  let i = startLine;
+  while (i < lines.length) {
+    const trimmed = lines[i].trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      i++;
+      continue;
+    }
+    const indent = getIndent(lines[i]);
+    if (indent !== mapIndent) break;
+    const colonIdx = findUnquotedColon(trimmed);
+    if (colonIdx === -1) break;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const afterColon = trimmed.slice(colonIdx + 1).trim();
+    const { value, nextLine } = parseMapEntry(lines, i, afterColon, mapIndent);
+    result[key] = value;
+    i = nextLine;
+  }
+  return { value: result, nextLine: i };
+}
+function parseListItem(lines, i, trimmed, indent) {
+  const afterDash = trimmed.slice(2).trim();
+  if (afterDash === "" || trimmed === "-") {
+    const { value, nextLine } = parseNode(lines, i + 1, indent);
+    return { value, nextLine };
+  }
+  if (afterDash.includes(":") && !isQuoted(afterDash)) {
+    return parseInlineMapItem(lines, i, afterDash, indent);
+  }
+  return { value: parseInlineValue(afterDash), nextLine: i + 1 };
+}
+function parseInlineMapItem(lines, i, afterDash, indent) {
+  const itemIndent = indent + 2;
+  const originalLine = lines[i];
+  lines[i] = " ".repeat(itemIndent) + afterDash;
+  const { value, nextLine } = parseMap(lines, i, itemIndent);
+  lines[i] = originalLine;
+  return { value, nextLine };
+}
+function parseList(lines, startLine, listIndent) {
+  const result = [];
+  let i = startLine;
+  while (i < lines.length) {
+    const trimmed = lines[i].trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      i++;
+      continue;
+    }
+    const indent = getIndent(lines[i]);
+    if (indent !== listIndent) break;
+    if (!trimmed.startsWith("- ") && trimmed !== "-") break;
+    const { value, nextLine } = parseListItem(lines, i, trimmed, indent);
+    result.push(value);
+    i = nextLine;
+  }
+  return { value: result, nextLine: i };
+}
+function collectMultilineContent(lines, startLine) {
+  const contentLines = [];
+  let i = startLine;
+  let blockIndent = -1;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      contentLines.push("");
+      i++;
+      continue;
+    }
+    const indent = getIndent(line);
+    if (blockIndent === -1) blockIndent = indent;
+    if (indent < blockIndent) break;
+    contentLines.push(line.slice(blockIndent));
+    i++;
+  }
+  while (contentLines.length > 0 && contentLines[contentLines.length - 1] === "") {
+    contentLines.pop();
+  }
+  return { contentLines, nextLine: i };
+}
+function parseMultilineString(lines, startLine, blockStyle) {
+  const { contentLines, nextLine } = collectMultilineContent(lines, startLine);
+  const value = blockStyle === "|" ? contentLines.join("\n") : contentLines.join(" ").replace(/\s+/g, " ").trim();
+  return { value, nextLine };
+}
+function parseInlineValue(raw) {
+  const value = stripInlineComment(raw);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (inner === "") return [];
+    return splitFlow(inner).map((item) => parseScalar(item.trim()));
+  }
+  return parseScalar(value);
+}
+var TRUE_VALUES = /* @__PURE__ */ new Set(["true", "True", "TRUE"]);
+var FALSE_VALUES = /* @__PURE__ */ new Set(["false", "False", "FALSE"]);
+var NULL_VALUES = /* @__PURE__ */ new Set(["null", "~", ""]);
+function parseQuoted(raw) {
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  return null;
+}
+function parseNumber(raw) {
+  if (/^-?\d+$/.test(raw)) return parseInt(raw, 10);
+  if (/^-?\d+\.\d+$/.test(raw)) return parseFloat(raw);
+  return null;
+}
+function parseScalar(raw) {
+  if (NULL_VALUES.has(raw)) return null;
+  if (TRUE_VALUES.has(raw)) return true;
+  if (FALSE_VALUES.has(raw)) return false;
+  const quoted = parseQuoted(raw);
+  if (quoted !== null) return quoted;
+  const num = parseNumber(raw);
+  if (num !== null) return num;
+  return raw;
+}
+function getIndent(line) {
+  let count = 0;
+  for (const ch of line) {
+    if (ch === " ") count++;
+    else break;
+  }
+  return count;
+}
+var QUOTE_CHARS = /* @__PURE__ */ new Set(["'", '"']);
+function toggleQuote(current, ch) {
+  if (current === "") return QUOTE_CHARS.has(ch) ? ch : "";
+  return ch === current ? "" : current;
+}
+function buildQuoteMask(text) {
+  const mask = new Array(text.length);
+  let quote = "";
+  for (let i = 0; i < text.length; i++) {
+    quote = toggleQuote(quote, text[i]);
+    mask[i] = quote !== "";
+  }
+  return mask;
+}
+function findUnquotedColon(text) {
+  const mask = buildQuoteMask(text);
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== ":" || mask[i]) continue;
+    if (i + 1 >= text.length || text[i + 1] === " ") return i;
+  }
+  return -1;
+}
+function isQuoted(text) {
+  return text.startsWith('"') && text.endsWith('"') || text.startsWith("'") && text.endsWith("'");
+}
+function stripInlineComment(text) {
+  const mask = buildQuoteMask(text);
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== " " || mask[i]) continue;
+    if (text[i + 1] === "#") return text.slice(0, i).trim();
+  }
+  return text;
+}
+var DEPTH_CHANGE = { "[": 1, "]": -1 };
+function buildDepthMap(text, mask) {
+  const depths = new Int8Array(text.length);
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (!mask[i]) depth += DEPTH_CHANGE[text[i]] ?? 0;
+    depths[i] = depth;
+  }
+  return depths;
+}
+function splitFlow(text) {
+  const mask = buildQuoteMask(text);
+  const depths = buildDepthMap(text, mask);
+  const items = [];
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === "," && !mask[i] && depths[i] === 0) {
+      items.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  const last = text.slice(start);
+  if (last.trim()) items.push(last);
+  return items;
+}
+
+// src/packages/resolver.ts
+var INSTALLED_PATH = synPath("workflows", "installed.json");
+function loadInstalled() {
+  const fallback = { version: 1, installations: [] };
+  return readJsonFile(INSTALLED_PATH, InstalledRegistrySchema, fallback);
+}
+function saveInstalled(registry) {
+  writeJsonFile(INSTALLED_PATH, registry);
+}
+function recordInstallation(opts) {
+  const registry = loadInstalled();
+  const record = {
+    package_name: opts.packageName,
+    package_version: opts.packageVersion,
+    source: opts.source,
+    source_ref: opts.sourceRef,
+    installed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    format: opts.format,
+    workflows: opts.workflows,
+    marketplace_source: opts.marketplaceSource ?? null,
+    git_sha: opts.gitSha ?? null
+  };
+  saveInstalled({
+    version: registry.version,
+    installations: [...registry.installations, record]
+  });
+}
+var REMOTE_PREFIXES = ["https://", "http://", "git@", "ssh://"];
+function isRemoteUrl(source) {
+  return REMOTE_PREFIXES.some((prefix) => source.startsWith(prefix));
+}
+function isLocalPath(source) {
+  return fs3.existsSync(source) || source.startsWith(".") || source.startsWith("/");
+}
+function isGitHubShorthand(source) {
+  return source.includes("/") && !source.includes("@") && !source.startsWith(".");
+}
+function parseSource(source) {
+  if (isRemoteUrl(source)) {
+    return { resolved: source, isRemote: true };
+  }
+  if (isLocalPath(source)) {
+    return { resolved: source, isRemote: false };
+  }
+  if (isGitHubShorthand(source)) {
+    return { resolved: `https://github.com/${source}.git`, isRemote: true };
+  }
+  return { resolved: source, isRemote: false };
+}
+function detectFormat(pkgPath) {
+  if (!fs3.existsSync(pkgPath)) {
+    throw new Error(`Package path does not exist: ${pkgPath}`);
+  }
+  if (!fs3.statSync(pkgPath).isDirectory()) {
+    throw new Error(`Package path is not a directory: ${pkgPath}`);
+  }
+  if (hasMultiWorkflowLayout(pkgPath)) return "multi";
+  if (fs3.existsSync(path3.join(pkgPath, "workflow.yaml"))) return "single";
+  if (hasYamlFiles(pkgPath)) return "standalone";
+  throw new Error(
+    `No workflow files found in ${pkgPath}
+Expected: workflow.yaml, workflows/*/workflow.yaml, or *.yaml files`
+  );
+}
+function hasMultiWorkflowLayout(pkgPath) {
+  const workflowsDir = path3.join(pkgPath, "workflows");
+  if (!fs3.existsSync(workflowsDir) || !fs3.statSync(workflowsDir).isDirectory()) {
+    return false;
+  }
+  return fs3.readdirSync(workflowsDir).some((d) => {
+    const subPath = path3.join(workflowsDir, d);
+    return fs3.statSync(subPath).isDirectory() && fs3.existsSync(path3.join(subPath, "workflow.yaml"));
+  });
+}
+function hasYamlFiles(pkgPath) {
+  return fs3.readdirSync(pkgPath).some(
+    (f) => f.endsWith(".yaml") || f.endsWith(".yml")
+  );
+}
+function loadManifest(pkgPath) {
+  const jsonPath = path3.join(pkgPath, "syntropic137-plugin.json");
+  if (fs3.existsSync(jsonPath)) {
+    return parseManifestFile(jsonPath, "json");
+  }
+  const yamlPath = path3.join(pkgPath, "syntropic137.yaml");
+  if (fs3.existsSync(yamlPath)) {
+    return parseManifestFile(yamlPath, "yaml");
+  }
+  return null;
+}
+function parseManifestFile(filePath, format) {
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const data = format === "json" ? JSON.parse(content) : parseYaml(content);
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new Error(`${path3.basename(filePath)} must be a ${format === "json" ? "JSON object" : "YAML mapping"}`);
+  }
+  return PluginManifestSchema.parse(data);
+}
+function loadWorkflowYaml(workflowDir, sourcePath) {
+  const yamlPath = path3.join(workflowDir, "workflow.yaml");
+  if (!fs3.existsSync(yamlPath)) {
+    throw new Error(`workflow.yaml not found in ${workflowDir}`);
+  }
+  const content = fs3.readFileSync(yamlPath, "utf-8");
+  const data = parseYaml(content);
+  const phases = Array.isArray(data["phases"]) ? data["phases"] : [];
+  const resolvedPhases = phases.map(
+    (phase) => resolvePhase(phase, workflowDir)
+  );
+  const repository = data["repository"];
+  return {
+    id: String(data["id"] ?? ""),
+    name: String(data["name"] ?? ""),
+    workflow_type: String(data["type"] ?? data["workflow_type"] ?? "custom"),
+    classification: String(data["classification"] ?? "standard"),
+    repository_url: repository ? String(repository["url"] ?? "https://github.com/placeholder/not-configured") : "https://github.com/placeholder/not-configured",
+    repository_ref: repository ? String(repository["ref"] ?? "main") : "main",
+    description: data["description"] ? String(data["description"]) : null,
+    project_name: data["project_name"] ? String(data["project_name"]) : null,
+    phases: resolvedPhases,
+    input_declarations: parseInputDeclarations(data),
+    source_path: sourcePath
+  };
+}
+function resolvePhase(phase, workflowDir) {
+  if (typeof phase["prompt_file"] !== "string" || phase["prompt_template"]) {
+    return phase;
+  }
+  const promptPath = path3.join(workflowDir, phase["prompt_file"]);
+  if (!fs3.existsSync(promptPath)) return phase;
+  const promptContent = fs3.readFileSync(promptPath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(promptContent);
+  const resolved = { ...phase, prompt_template: body };
+  delete resolved["prompt_file"];
+  if (frontmatter) {
+    mergeFrontmatter(resolved, frontmatter);
+  }
+  return resolved;
+}
+function mergeFrontmatter(phase, fm) {
+  const mappings = [
+    ["argument-hint", "argument_hint"],
+    ["allowed-tools", "allowed_tools", (v) => String(v).split(",").map((t) => t.trim())],
+    ["max-tokens", "max_tokens", Number],
+    ["timeout-seconds", "timeout_seconds", Number],
+    ["model", "model"]
+  ];
+  for (const [fmKey, phaseKey, transform] of mappings) {
+    if (fm[fmKey] && !phase[phaseKey]) {
+      phase[phaseKey] = transform ? transform(fm[fmKey]) : fm[fmKey];
+    }
+  }
+}
+function parseInputDeclarations(data) {
+  const inputs = Array.isArray(data["inputs"]) ? data["inputs"] : [];
+  return inputs.map((i) => {
+    const inp = i;
+    return {
+      name: inp["name"] ?? "",
+      description: inp["description"] ?? "",
+      required: inp["required"] ?? true,
+      default: inp["default"] ?? null
+    };
+  });
+}
+function parseFrontmatter(content) {
+  if (!content.startsWith("---")) {
+    return { frontmatter: null, body: content };
+  }
+  const endIdx = content.indexOf("---", 3);
+  if (endIdx === -1) {
+    return { frontmatter: null, body: content };
+  }
+  const fmContent = content.slice(3, endIdx).trim();
+  const body = content.slice(endIdx + 3).trim();
+  const fm = parseYaml(fmContent);
+  return {
+    frontmatter: typeof fm === "object" && fm !== null && !Array.isArray(fm) ? fm : null,
+    body
+  };
+}
+function resolveMultiWorkflow(pkgPath, source) {
+  const workflowsDir = path3.join(pkgPath, "workflows");
+  const subdirs = fs3.readdirSync(workflowsDir).sort().filter((d) => {
+    const subPath = path3.join(workflowsDir, d);
+    return fs3.statSync(subPath).isDirectory() && fs3.existsSync(path3.join(subPath, "workflow.yaml"));
+  });
+  return subdirs.map(
+    (d) => loadWorkflowYaml(path3.join(workflowsDir, d), source)
+  );
+}
+function resolveStandaloneYaml(pkgPath, source) {
+  const files = fs3.readdirSync(pkgPath).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).sort();
+  return files.map((f) => {
+    const filePath = path3.join(pkgPath, f);
+    const content = fs3.readFileSync(filePath, "utf-8");
+    const data = parseYaml(content);
+    const baseName = path3.basename(f, path3.extname(f));
+    return {
+      id: String(data["id"] ?? baseName),
+      name: String(data["name"] ?? baseName),
+      workflow_type: String(data["type"] ?? data["workflow_type"] ?? "custom"),
+      classification: String(data["classification"] ?? "standard"),
+      repository_url: "https://github.com/placeholder/not-configured",
+      repository_ref: "main",
+      description: data["description"] ? String(data["description"]) : null,
+      project_name: data["project_name"] ? String(data["project_name"]) : null,
+      phases: Array.isArray(data["phases"]) ? data["phases"] : [],
+      input_declarations: [],
+      source_path: source
+    };
+  });
+}
+function resolvePackage(pkgPath) {
+  const format = detectFormat(pkgPath);
+  const manifest = loadManifest(pkgPath);
+  const source = pkgPath;
+  if (format === "single") {
+    const workflow = loadWorkflowYaml(pkgPath, source);
+    return { manifest, workflows: [workflow] };
+  }
+  if (format === "multi") {
+    return { manifest, workflows: resolveMultiWorkflow(pkgPath, source) };
+  }
+  return { manifest, workflows: resolveStandaloneYaml(pkgPath, source) };
+}
+async function resolveFromGit(url, ref) {
+  const tmpdir = makeTempDir("syn-pkg-");
+  try {
+    await gitClone(url, ref, tmpdir);
+  } catch (err) {
+    removeTempDir(tmpdir);
+    throw err;
+  }
+  const { manifest, workflows } = resolvePackage(tmpdir);
+  return { tmpdir, manifest, workflows };
+}
+var PHASE_MD_TEMPLATE = (phaseNum, phaseName) => `---
+model: sonnet
+argument-hint: "[topic]"
+allowed-tools: Read,Glob,Grep,Bash
+max-tokens: 4096
+timeout-seconds: 300
+---
+
+You are an AI assistant working on phase ${phaseNum}: ${phaseName}.
+
+Your task: $ARGUMENTS
+
+Work thoroughly and report your findings.
+`;
+function generatePhaseNames(workflowType, count) {
+  const presets = {
+    research: ["Discovery", "Deep Dive", "Synthesis"],
+    implementation: ["Research", "Plan", "Execute", "Review", "Ship"],
+    review: ["Analyze", "Evaluate", "Report"],
+    planning: ["Gather Context", "Design", "Validate"],
+    deployment: ["Prepare", "Deploy", "Verify"]
+  };
+  const names = [...presets[workflowType] ?? []];
+  while (names.length < count) {
+    names.push(`Phase ${names.length + 1}`);
+  }
+  return names.slice(0, count);
+}
+function scaffoldSinglePackage(directory, opts) {
+  const workflowType = opts.workflowType ?? "research";
+  const numPhases = opts.numPhases ?? 3;
+  const phasesDir = path3.join(directory, "phases");
+  fs3.mkdirSync(phasesDir, { recursive: true });
+  const workflowId = opts.name.toLowerCase().replace(/ /g, "-") + "-v1";
+  const phaseNames = generatePhaseNames(workflowType, numPhases);
+  const phasesYamlLines = [];
+  for (let i = 0; i < phaseNames.length; i++) {
+    const phaseName = phaseNames[i];
+    const phaseId = phaseName.toLowerCase().replace(/ /g, "-");
+    fs3.writeFileSync(
+      path3.join(phasesDir, `${phaseId}.md`),
+      PHASE_MD_TEMPLATE(i + 1, phaseName),
+      "utf-8"
+    );
+    phasesYamlLines.push(
+      `  - id: ${phaseId}
+    name: ${phaseName}
+    order: ${i + 1}
+    execution_type: sequential
+    prompt_file: phases/${phaseId}.md
+    output_artifacts: [${phaseId}_output]`
+    );
+  }
+  const workflowYaml = `id: ${workflowId}
+name: ${opts.name}
+description: "${opts.name} workflow"
+type: ${workflowType}
+classification: standard
+
+inputs:
+  - name: task
+    description: "The primary task to accomplish"
+    required: true
+
+phases:
+` + phasesYamlLines.join("\n");
+  fs3.writeFileSync(path3.join(directory, "workflow.yaml"), workflowYaml, "utf-8");
+  const phaseList = phaseNames.map((pn, i) => `- **Phase ${i + 1}:** ${pn}`).join("\n");
+  const readme = `# ${opts.name}
+
+${opts.name} workflow
+
+## Usage
+
+\`\`\`bash
+syn workflow install ./${path3.basename(directory)}/
+syn workflow run ${workflowId} --task "Your task here"
+\`\`\`
+
+## Phases
+
+${phaseList}
+`;
+  fs3.writeFileSync(path3.join(directory, "README.md"), readme, "utf-8");
+}
+function scaffoldMultiPackage(directory, opts) {
+  fs3.mkdirSync(directory, { recursive: true });
+  const manifest = {
+    manifest_version: 1,
+    name: opts.name.toLowerCase().replace(/ /g, "-"),
+    version: "0.1.0",
+    description: `${opts.name} plugin`
+  };
+  fs3.writeFileSync(
+    path3.join(directory, "syntropic137-plugin.json"),
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf-8"
+  );
+  const libDir = path3.join(directory, "phase-library");
+  fs3.mkdirSync(libDir, { recursive: true });
+  fs3.writeFileSync(
+    path3.join(libDir, "summarize.md"),
+    PHASE_MD_TEMPLATE("N", "Summarize"),
+    "utf-8"
+  );
+  const wfName = opts.name.toLowerCase().replace(/ /g, "-");
+  const wfDir = path3.join(directory, "workflows", wfName);
+  scaffoldSinglePackage(wfDir, opts);
+  const readme = `# ${opts.name} Plugin
+
+Plugin containing ${opts.name} workflows and shared phases
+
+## Usage
+
+\`\`\`bash
+syn workflow install ./${path3.basename(directory)}/
+syn workflow run ${wfName}-v1 --task "Your task here"
+\`\`\`
+
+## Phases
+
+- **${opts.name}** \u2014 ${opts.numPhases ?? 3} phases
+`;
+  fs3.writeFileSync(path3.join(directory, "README.md"), readme, "utf-8");
+}
+
+// src/commands/workflow/crud.ts
+var createCommand = {
+  name: "create",
+  description: "Create a new workflow",
+  args: [{ name: "name", description: "Name of the workflow", required: true }],
+  options: {
+    type: { type: "string", short: "t", description: "Workflow type (research, planning, implementation, review, deployment, custom)", default: "custom" },
+    repo: { type: "string", short: "r", description: "Repository URL", default: "https://github.com/example/repo" },
+    ref: { type: "string", description: "Repository ref/branch", default: "main" },
+    description: { type: "string", short: "d", description: "Workflow description" }
+  },
+  handler: async (parsed) => {
+    const name = parsed.positionals[0];
+    if (!name) {
+      printError("Missing required argument: name");
+      throw new CLIError("Missing argument", 1);
+    }
+    const workflowType = parsed.values["type"] ?? "custom";
+    const repoUrl = parsed.values["repo"] ?? "https://github.com/example/repo";
+    const repoRef = parsed.values["ref"] ?? "main";
+    const description = parsed.values["description"];
+    const data = await apiPost("/workflows", {
+      body: {
+        name,
+        workflow_type: workflowType,
+        repository_url: repoUrl,
+        repository_ref: repoRef,
+        description: description ?? null
+      }
+    });
+    const workflowId = String(data["id"] ?? data["workflow_id"] ?? "unknown");
+    printSuccess(`Created workflow: ${style(name, CYAN)}`);
+    print(`  ID: ${style(workflowId, DIM)}`);
+    print(`  Type: ${style(workflowType, DIM)}`);
+  }
+};
+var listCommand = {
+  name: "list",
+  description: "List all workflows",
+  options: {
+    "include-archived": { type: "boolean", description: "Include archived workflows", default: false }
+  },
+  handler: async (parsed) => {
+    const includeArchived = parsed.values["include-archived"] === true;
+    const params = {};
+    if (includeArchived) params["include_archived"] = "true";
+    const data = await apiGet("/workflows", { params });
+    const workflows = data.workflows ?? [];
+    if (workflows.length === 0) {
+      printDim("No workflows found. Create one with:");
+      print(`  ${style('syn workflow create "My Workflow"', CYAN)}`);
+      return;
+    }
+    const table = new Table({ title: "Workflows" });
+    table.addColumn("ID", { style: DIM });
+    table.addColumn("Name", { style: CYAN });
+    table.addColumn("Type", { style: GREEN });
+    table.addColumn("Phases", { align: "right" });
+    for (const w of workflows) {
+      table.addRow(
+        String(w["id"] ?? "").slice(0, 12) + "...",
+        String(w["name"] ?? ""),
+        String(w["workflow_type"] ?? ""),
+        String(w["phase_count"] ?? 0)
+      );
+    }
+    table.print();
+  }
+};
+function renderWorkflowDetail(detail) {
+  print("");
+  print(style("Workflow Details", BOLD));
+  print(`  ${style("ID:", DIM)} ${detail.id}`);
+  print(`  ${style("Name:", DIM)} ${style(detail.name, CYAN)}`);
+  print(`  ${style("Type:", DIM)} ${detail.workflow_type}`);
+  print(`  ${style("Classification:", DIM)} ${detail.classification}`);
+  if (detail.phases.length > 0) {
+    print(`
+  ${style(`Phases (${detail.phases.length}):`, BOLD)}`);
+    for (const phase of detail.phases) {
+      print(`    - ${String(phase["name"] ?? "unnamed")}`);
+    }
+  } else {
+    printDim("  No phases defined");
+  }
+}
+var showCommand = {
+  name: "show",
+  description: "Show details of a workflow",
+  args: [{ name: "workflow-id", description: "Workflow ID (partial match supported)", required: true }],
+  handler: async (parsed) => {
+    const partialId = parsed.positionals[0];
+    if (!partialId) {
+      printError("Missing required argument: workflow-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const wf = await resolveWorkflow(partialId);
+    const data = await apiGet(`/workflows/${wf.id}`);
+    renderWorkflowDetail(data);
+  }
+};
+var validateCommand = {
+  name: "validate",
+  description: "Validate a workflow YAML file or package directory",
+  args: [{ name: "file", description: "YAML file or package directory", required: true }],
+  handler: async (parsed) => {
+    const file = parsed.positionals[0];
+    if (!file) {
+      printError("Missing required argument: file");
+      throw new CLIError("Missing argument", 1);
+    }
+    const fs8 = await import("fs");
+    const stat = fs8.statSync(file);
+    if (stat.isDirectory()) {
+      validatePackageDir(file);
+      return;
+    }
+    const data = await apiPost("/workflows/validate", {
+      body: { file }
+    });
+    if (data["valid"]) {
+      printSuccess("Valid workflow definition\n");
+      print(`  ${style("Name:", DIM)} ${String(data["name"] ?? "")}`);
+      print(`  ${style("Type:", DIM)} ${String(data["workflow_type"] ?? "")}`);
+      print(`  ${style("Phases:", DIM)} ${String(data["phase_count"] ?? 0)}`);
+    } else {
+      printError("Invalid workflow definition");
+      const errors = data["errors"];
+      if (errors) {
+        for (const error of errors) {
+          print(`  ${error}`);
+        }
+      }
+      throw new CLIError("Validation failed", 1);
+    }
+  }
+};
+function validatePackageDir(pkgPath) {
+  try {
+    const fmt = detectFormat(pkgPath);
+    const { workflows } = resolvePackage(pkgPath);
+    printSuccess(`Valid ${fmt} package
+`);
+    print(`  ${style("Directory:", DIM)} ${pkgPath}`);
+    print(`  ${style("Workflows:", DIM)} ${workflows.length}`);
+    const totalPhases = workflows.reduce((sum, wf) => sum + wf.phases.length, 0);
+    print(`  ${style("Total phases:", DIM)} ${totalPhases}`);
+    for (const wf of workflows) {
+      printDim(`    \u2022 ${wf.name} (${wf.phases.length} phases)`);
+    }
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    throw new CLIError("Validation failed", 1);
+  }
+}
+var deleteCommand = {
+  name: "delete",
+  description: "Archive (soft-delete) a workflow",
+  args: [{ name: "workflow-id", description: "Workflow ID (partial match supported)", required: true }],
+  options: {
+    force: { type: "boolean", short: "f", description: "Skip confirmation prompt", default: false }
+  },
+  handler: async (parsed) => {
+    const partialId = parsed.positionals[0];
+    if (!partialId) {
+      printError("Missing required argument: workflow-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const force = parsed.values["force"] === true;
+    const wf = await resolveWorkflow(partialId, { includeArchived: true });
+    if (!force) {
+      printError(`Use --force to confirm archiving '${wf.name}' (${wf.id})`);
+      throw new CLIError("Confirmation required", 1);
+    }
+    await apiDelete(`/workflows/${wf.id}`);
+    printSuccess(`Archived workflow: ${style(wf.name, CYAN)}`);
+    print(`  ID: ${style(wf.id, DIM)}`);
+  }
+};
+
+// src/output/format.ts
+function formatCost(cost) {
+  const n = typeof cost === "string" ? Number(cost) : cost;
+  if (n < 0.01) return `$${n.toFixed(4)}`;
+  return `$${n.toFixed(2)}`;
+}
+function formatTokens(tokens) {
+  if (tokens >= 1e6) return `${(tokens / 1e6).toFixed(1)}M`;
+  if (tokens >= 1e3) return `${(tokens / 1e3).toFixed(1)}K`;
+  return String(tokens);
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const secs = Math.floor(seconds % 60);
+  if (minutes < 60) return secs ? `${minutes}m ${secs}s` : `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  return mins ? `${hours}h ${mins}m` : `${hours}h`;
+}
+function formatTimestamp(iso) {
+  if (!iso) return "-";
+  try {
+    const date = new Date(iso);
+    if (isNaN(date.getTime())) return iso;
+    return date.toLocaleDateString("en-US", {
+      month: "short",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false
+    });
+  } catch {
+    return iso;
+  }
+}
+var STATUS_COLORS = {
+  active: GREEN,
+  completed: GREEN,
+  paused: YELLOW,
+  deleted: RED,
+  failed: RED,
+  running: BLUE,
+  pending: DIM
+};
+function statusStyle(status) {
+  return STATUS_COLORS[status] ?? "";
+}
+function formatStatus(status) {
+  const color = statusStyle(status);
+  return color ? style(status, color) : status;
+}
+function formatBreakdown(breakdown, title, valueFn) {
+  const lines = [style(title, BOLD)];
+  for (const [key, value] of Object.entries(breakdown)) {
+    const formatted = valueFn ? valueFn(value) : value;
+    lines.push(`  ${key}: ${formatted}`);
+  }
+  return lines.join("\n");
+}
+
+// src/commands/workflow/models.ts
+function isQuoted2(value) {
+  return value.length >= 2 && value[0] === value[value.length - 1] && (value[0] === '"' || value[0] === "'");
+}
+function coerceValue(value) {
+  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+  return value;
+}
+function parseSingleValue(value) {
+  if (isQuoted2(value)) return value.slice(1, -1);
+  const lower = value.toLowerCase();
+  if (lower === "true") return true;
+  if (lower === "false") return false;
+  return coerceValue(value);
+}
+function parseInputs(inputs) {
+  if (!inputs || inputs.length === 0) return {};
+  const result = {};
+  for (const item of inputs) {
+    const eqIdx = item.indexOf("=");
+    if (eqIdx === -1) {
+      process.stderr.write(`Warning: Ignoring invalid input '${item}' (expected key=value)
+`);
+      continue;
+    }
+    const key = item.slice(0, eqIdx).trim();
+    const value = item.slice(eqIdx + 1);
+    result[key] = parseSingleValue(value);
+  }
+  return result;
+}
+
+// src/commands/workflow/run.ts
+function displayRunPreview(workflowName, fullId, phaseCount, task, parsedInputs) {
+  print("");
+  print(style("Workflow Execution", CYAN));
+  print(`  ${style(workflowName, BOLD)}`);
+  print(`  ${style(`ID: ${fullId}`, DIM)}`);
+  print(`  ${style(`Phases: ${phaseCount}`, DIM)}`);
+  if (task) {
+    print(`
+${style("Task:", BOLD)} ${style(task, GREEN)}`);
+  }
+  const inputEntries = Object.entries(parsedInputs);
+  if (inputEntries.length > 0) {
+    print(`
+${style("Inputs:", BOLD)}`);
+    for (const [key, value] of inputEntries) {
+      print(`  ${key}: ${style(String(value), GREEN)}`);
+    }
+  }
+}
+var runCommand = {
+  name: "run",
+  description: "Execute a workflow",
+  args: [{ name: "workflow-id", description: "Workflow ID (partial match supported)", required: true }],
+  options: {
+    input: { type: "string", short: "i", description: "Input variables as key=value", multiple: true },
+    task: { type: "string", short: "t", description: "Primary task description ($ARGUMENTS)" },
+    "dry-run": { type: "boolean", short: "n", description: "Validate without executing", default: false },
+    quiet: { type: "boolean", short: "q", description: "Minimal output", default: false }
+  },
+  handler: async (parsed) => {
+    const partialId = parsed.positionals[0];
+    if (!partialId) {
+      printError("Missing required argument: workflow-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const inputValues = parsed.values["input"];
+    const inputs = Array.isArray(inputValues) ? inputValues : void 0;
+    const parsedInputs = parseInputs(inputs);
+    const task = parsed.values["task"];
+    const dryRun = parsed.values["dry-run"] === true;
+    const quiet = parsed.values["quiet"] === true;
+    const wf = await resolveWorkflow(partialId);
+    if (!quiet) {
+      displayRunPreview(wf.name, wf.id, wf.phase_count, task, parsedInputs);
+    }
+    if (dryRun) {
+      print(`
+${style("DRY RUN", YELLOW)} - Workflow is valid and ready to execute`);
+      printDim("Remove --dry-run to execute");
+      return;
+    }
+    const body = {
+      inputs: Object.fromEntries(
+        Object.entries(parsedInputs).map(([k, v]) => [k, String(v)])
+      )
+    };
+    if (task) body["task"] = task;
+    const result = await apiPost(
+      `/workflows/${wf.id}/execute`,
+      { body, timeoutMs: 3e5 }
+    );
+    if (result.status === "started") {
+      printSuccess("\nWorkflow execution started");
+      print(`  Execution ID: ${result.execution_id}`);
+    } else {
+      print(`
+${style(`Status: ${result.status}`, YELLOW)}`);
+    }
+  }
+};
+var statusCommand = {
+  name: "status",
+  description: "Show execution history for a workflow",
+  args: [{ name: "workflow-id", description: "Workflow ID (partial match supported)", required: true }],
+  handler: async (parsed) => {
+    const partialId = parsed.positionals[0];
+    if (!partialId) {
+      printError("Missing required argument: workflow-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const wf = await resolveWorkflow(partialId);
+    print("");
+    print(style("Workflow Status", CYAN));
+    print(`  ${style(wf.name, BOLD)}`);
+    print(`  ${style(`ID: ${wf.id}`, DIM)}`);
+    const data = await apiGet(`/workflows/${wf.id}/runs`);
+    const runs = data.runs ?? [];
+    if (runs.length === 0) {
+      printDim("\nNo executions found.");
+      printDim(`Run with: syn workflow run ${partialId}`);
+      return;
+    }
+    const table = new Table({ title: "Executions" });
+    table.addColumn("ID", { style: DIM });
+    table.addColumn("Status");
+    table.addColumn("Phases", { align: "right" });
+    table.addColumn("Tokens", { align: "right" });
+    table.addColumn("Cost", { align: "right" });
+    for (const run of runs) {
+      table.addRow(
+        String(run.workflow_execution_id ?? "").slice(0, 12) + "...",
+        String(run.status ?? ""),
+        `${run.completed_phases ?? 0}/${run.total_phases ?? 0}`,
+        formatTokens(Number(run.total_tokens ?? 0)),
+        formatCost(String(run.total_cost_usd ?? "0"))
+      );
+    }
+    table.print();
+  }
+};
+
+// src/commands/workflow/install.ts
+import fs5 from "fs";
+import path5 from "path";
+
+// src/marketplace/client.ts
+import fs4 from "fs";
+import path4 from "path";
+
+// src/marketplace/models.ts
+import { z as z2 } from "zod";
+var SyntropicMarkerSchema = z2.object({
+  type: z2.string(),
+  min_platform_version: z2.string().default("0.0.0")
+}).passthrough();
+var MarketplacePluginEntrySchema = z2.object({
+  name: z2.string().min(1),
+  source: z2.string(),
+  version: z2.string().default("0.1.0"),
+  description: z2.string().default(""),
+  category: z2.string().default(""),
+  tags: z2.array(z2.string()).default([])
+}).passthrough();
+var MarketplaceIndexSchema = z2.object({
+  name: z2.string().min(1),
+  syntropic137: SyntropicMarkerSchema,
+  plugins: z2.array(MarketplacePluginEntrySchema).default([])
+}).passthrough();
+var RegistryEntrySchema = z2.object({
+  repo: z2.string(),
+  ref: z2.string().default("main"),
+  added_at: z2.string()
+}).strict();
+var RegistryConfigSchema = z2.object({
+  version: z2.number().default(1),
+  registries: z2.record(z2.string(), RegistryEntrySchema).default({})
+}).strict();
+var CachedMarketplaceSchema = z2.object({
+  fetched_at: z2.string(),
+  index: MarketplaceIndexSchema
+}).strict();
+
+// src/marketplace/client.ts
+var REGISTRIES_PATH = synPath("registries.json");
+var CACHE_DIR = synPath("marketplace", "cache");
+var CACHE_TTL_MS = 4 * 60 * 60 * 1e3;
+var SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+function validateRegistryName(name) {
+  if (!SAFE_NAME_RE.test(name) || name.includes("..")) {
+    throw new Error(
+      `Invalid registry name '${name}': must start with alphanumeric character and contain only letters, digits, hyphens, underscores, and dots`
+    );
+  }
+  return name;
+}
+function loadRegistries() {
+  const fallback = { version: 1, registries: {} };
+  return readJsonFile(REGISTRIES_PATH, RegistryConfigSchema, fallback);
+}
+function saveRegistries(config) {
+  writeJsonFile(REGISTRIES_PATH, config);
+}
+function loadCachedIndex(registryName) {
+  validateRegistryName(registryName);
+  const cachePath = path4.join(CACHE_DIR, `${registryName}.json`);
+  if (!fs4.existsSync(cachePath)) return null;
+  try {
+    const content = fs4.readFileSync(cachePath, "utf-8");
+    return CachedMarketplaceSchema.parse(JSON.parse(content));
+  } catch {
+    return null;
+  }
+}
+function saveCachedIndex(registryName, cached) {
+  validateRegistryName(registryName);
+  fs4.mkdirSync(CACHE_DIR, { recursive: true });
+  const cachePath = path4.join(CACHE_DIR, `${registryName}.json`);
+  writeJsonFile(cachePath, cached);
+}
+function isCacheStale(cached) {
+  try {
+    const fetched = new Date(cached.fetched_at).getTime();
+    if (isNaN(fetched)) return true;
+    return Date.now() - fetched > CACHE_TTL_MS;
+  } catch {
+    return true;
+  }
+}
+async function fetchMarketplaceJson(repo, ref = "main") {
+  const url = `https://github.com/${repo}.git`;
+  const tmpdir = makeTempDir("syn-mkt-");
+  try {
+    await gitClone(url, ref, tmpdir);
+    const marketplacePath = path4.join(tmpdir, "marketplace.json");
+    if (!fs4.existsSync(marketplacePath)) {
+      throw new Error(`No marketplace.json found in ${repo}`);
+    }
+    const content = fs4.readFileSync(marketplacePath, "utf-8");
+    const data = JSON.parse(content);
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+      throw new Error("marketplace.json must be a JSON object");
+    }
+    const index = MarketplaceIndexSchema.parse(data);
+    if (index.syntropic137.type !== "workflow-marketplace") {
+      throw new Error(
+        `Expected syntropic137.type='workflow-marketplace', got '${index.syntropic137.type}'`
+      );
+    }
+    return index;
+  } finally {
+    removeTempDir(tmpdir);
+  }
+}
+async function refreshIndex(registryName, entry, force = false) {
+  if (!force) {
+    const cached = loadCachedIndex(registryName);
+    if (cached !== null && !isCacheStale(cached)) {
+      return cached.index;
+    }
+  }
+  const index = await fetchMarketplaceJson(entry.repo, entry.ref);
+  saveCachedIndex(registryName, {
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+    index
+  });
+  return index;
+}
+function matchesQuery(plugin, query) {
+  if (!query) return true;
+  const q = query.toLowerCase();
+  return plugin.name.toLowerCase().includes(q) || plugin.description.toLowerCase().includes(q) || plugin.category.toLowerCase().includes(q) || plugin.tags.some((t) => t.toLowerCase().includes(q));
+}
+function matchesFilters(plugin, query, category, tag) {
+  if (!matchesQuery(plugin, query)) return false;
+  if (category && plugin.category.toLowerCase() !== category.toLowerCase())
+    return false;
+  if (tag && !plugin.tags.some((t) => t.toLowerCase() === tag.toLowerCase()))
+    return false;
+  return true;
+}
+async function getRegistryIndex(name, entry) {
+  try {
+    return await refreshIndex(name, entry);
+  } catch {
+    return null;
+  }
+}
+async function searchAllRegistries(query = "", opts) {
+  const config = loadRegistries();
+  const results = [];
+  const category = opts?.category ?? null;
+  const tag = opts?.tag ?? null;
+  for (const [name, entry] of Object.entries(config.registries)) {
+    const index = await getRegistryIndex(name, entry);
+    if (index === null) continue;
+    for (const plugin of index.plugins) {
+      if (matchesFilters(plugin, query, category, tag)) {
+        results.push([name, plugin]);
+      }
+    }
+  }
+  return results;
+}
+function getSearchTargets(config, registry) {
+  if (!registry) return Object.entries(config.registries);
+  const entry = config.registries[registry];
+  return entry ? [[registry, entry]] : [];
+}
+async function findPluginInRegistry(regName, entry, pluginName) {
+  const index = await getRegistryIndex(regName, entry);
+  if (index === null) return null;
+  const plugin = index.plugins.find((p) => p.name === pluginName);
+  return plugin ? [regName, entry, plugin] : null;
+}
+async function resolvePluginByName(name, registry) {
+  const targets = getSearchTargets(loadRegistries(), registry);
+  for (const [regName, entry] of targets) {
+    const result = await findPluginInRegistry(regName, entry, name);
+    if (result) return result;
+  }
+  return null;
+}
+
+// src/commands/workflow/install.ts
+function isBarePluginName(source) {
+  return !source.includes("/") && !source.startsWith(".") && !source.startsWith("http") && !source.startsWith("git@") && !source.startsWith("ssh://") && !fs5.existsSync(source);
+}
+async function tryMarketplaceResolution(source, ref) {
+  const result = await resolvePluginByName(source);
+  if (result === null) return null;
+  const [regName, entry, plugin] = result;
+  const effectiveRef = ref !== "main" ? ref : entry.ref;
+  const url = `https://github.com/${entry.repo}.git`;
+  if (plugin.source.startsWith("/") || plugin.source.includes("..")) {
+    throw new Error(`Unsafe plugin source path in marketplace: ${plugin.source}`);
+  }
+  print(`Found ${style(plugin.name, BOLD)} in marketplace ${style(regName, CYAN)}`);
+  print(`Cloning ${style(entry.repo, CYAN)}@${effectiveRef}...`);
+  const tmpdir = makeTempDir("syn-pkg-");
+  try {
+    await gitClone(url, effectiveRef, tmpdir);
+  } catch (err) {
+    removeTempDir(tmpdir);
+    throw err;
+  }
+  const subdir = path5.resolve(tmpdir, plugin.source.replace(/^\.\//, ""));
+  if (!subdir.startsWith(tmpdir)) {
+    removeTempDir(tmpdir);
+    throw new Error(`Plugin source path escapes repository: ${plugin.source}`);
+  }
+  const { manifest, workflows } = resolvePackage(subdir);
+  const gitSha = await gitLsRemote(entry.repo, effectiveRef);
+  return { packagePath: subdir, manifest, workflows, tmpdir, marketplaceSource: regName, gitSha, effectiveRef };
+}
+async function resolveSource(source, ref) {
+  const { resolved, isRemote } = parseSource(source);
+  if (isRemote) {
+    print(`Cloning ${style(resolved, CYAN)}@${ref}...`);
+    const { tmpdir, manifest: manifest2, workflows: workflows2 } = await resolveFromGit(resolved, ref);
+    return { packagePath: tmpdir, manifest: manifest2, workflows: workflows2, tmpdir };
+  }
+  const packagePath = path5.resolve(resolved);
+  const { manifest, workflows } = resolvePackage(packagePath);
+  return { packagePath, manifest, workflows, tmpdir: null };
+}
+async function installWorkflowsViaApi(workflows) {
+  const installed = [];
+  for (let i = 0; i < workflows.length; i++) {
+    const wf = workflows[i];
+    process.stdout.write(`  [${i + 1}/${workflows.length}] Creating ${style(wf.name, BOLD)}... `);
+    try {
+      const data = await apiPost("/workflows", {
+        body: {
+          name: wf.name,
+          workflow_type: wf.workflow_type,
+          classification: wf.classification,
+          repository_url: wf.repository_url,
+          repository_ref: wf.repository_ref,
+          description: wf.description,
+          project_name: wf.project_name,
+          phases: wf.phases,
+          input_declarations: wf.input_declarations
+        },
+        expected: [201]
+      });
+      const wfId = String(data["id"] ?? "unknown");
+      print(`${style("done", GREEN)} (id: ${wfId})`);
+      installed.push({ id: wfId, name: wf.name });
+    } catch (err) {
+      print(style("failed", "\x1B[31m"));
+      if (err instanceof Error) printError(err.message);
+    }
+  }
+  return installed;
+}
+var installCommand = {
+  name: "install",
+  description: "Install workflow(s) from a package, git repository, or marketplace",
+  args: [{ name: "source", description: "Plugin name, local path, GitHub URL, or org/repo shorthand", required: true }],
+  options: {
+    ref: { type: "string", description: "Git branch/tag to clone", default: "main" },
+    "dry-run": { type: "boolean", short: "n", description: "Validate without installing", default: false }
+  },
+  handler: async (parsed) => {
+    const source = parsed.positionals[0];
+    if (!source) {
+      printError("Missing required argument: source");
+      throw new CLIError("Missing argument", 1);
+    }
+    const ref = parsed.values["ref"] ?? "main";
+    const dryRun = parsed.values["dry-run"] === true;
+    let packagePath;
+    let manifest;
+    let workflows;
+    let tmpdir = null;
+    let marketplaceSource = null;
+    let gitSha = null;
+    let effectiveRef = ref;
+    try {
+      if (isBarePluginName(source)) {
+        const mktResult = await tryMarketplaceResolution(source, ref);
+        if (mktResult !== null) {
+          ({ packagePath, manifest, workflows, tmpdir, marketplaceSource, gitSha, effectiveRef } = mktResult);
+        } else {
+          ({ packagePath, manifest, workflows, tmpdir } = await resolveSource(source, ref));
+        }
+      } else {
+        ({ packagePath, manifest, workflows, tmpdir } = await resolveSource(source, ref));
+      }
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      throw new CLIError("Resolution failed", 1);
+    }
+    try {
+      if (workflows.length === 0) {
+        printError("No workflows found in package");
+        throw new CLIError("No workflows", 1);
+      }
+      const fmt = detectFormat(packagePath);
+      const pkgName = manifest?.name ?? path5.basename(packagePath);
+      const pkgVersion = manifest?.version ?? "0.0.0";
+      printPackagePreview(pkgName, pkgVersion, source, fmt, workflows);
+      if (dryRun) {
+        printSuccess("Dry run \u2014 package is valid, no workflows installed");
+        printWorkflowSummary(workflows);
+        return;
+      }
+      const installedRefs = await installWorkflowsViaApi(workflows);
+      if (installedRefs.length === 0) {
+        printError("No workflows were installed");
+        throw new CLIError("Install failed", 1);
+      }
+      recordInstallation({
+        packageName: pkgName,
+        packageVersion: pkgVersion,
+        source,
+        sourceRef: effectiveRef,
+        format: fmt,
+        workflows: installedRefs,
+        marketplaceSource,
+        gitSha
+      });
+      printSuccess(`
+Installed ${installedRefs.length} workflow(s) from ${source}`);
+    } finally {
+      if (tmpdir !== null) {
+        removeTempDir(tmpdir);
+      }
+    }
+  }
+};
+function printPackagePreview(name, version, source, fmt, workflows) {
+  const totalPhases = workflows.reduce((sum, wf) => sum + wf.phases.length, 0);
+  print("");
+  print(style("Package Preview", CYAN));
+  print(`  ${style(`${name} v${version}`, BOLD)}`);
+  print(`  Source: ${source}`);
+  print(`  Format: ${fmt}`);
+  print(`  Workflows: ${workflows.length}`);
+  print(`  Total phases: ${totalPhases}`);
+}
+function printWorkflowSummary(workflows) {
+  const table = new Table({ title: "Resolved Workflows" });
+  table.addColumn("Name", { style: CYAN });
+  table.addColumn("ID", { style: DIM });
+  table.addColumn("Type");
+  table.addColumn("Phases", { align: "right" });
+  for (const wf of workflows) {
+    table.addRow(wf.name, wf.id, wf.workflow_type, String(wf.phases.length));
+  }
+  table.print();
+}
+var installedCommand = {
+  name: "installed",
+  description: "List installed workflow packages",
+  handler: async () => {
+    const registry = loadInstalled();
+    if (registry.installations.length === 0) {
+      printDim("No packages installed yet.");
+      print(`Install one with: ${style("syn workflow install <source>", CYAN)}`);
+      return;
+    }
+    const table = new Table({ title: "Installed Packages" });
+    table.addColumn("Package", { style: CYAN });
+    table.addColumn("Version");
+    table.addColumn("Source", { style: DIM });
+    table.addColumn("Workflows", { align: "right" });
+    table.addColumn("Installed", { style: DIM });
+    for (const record of registry.installations) {
+      table.addRow(
+        record.package_name,
+        record.package_version,
+        record.source,
+        String(record.workflows.length),
+        formatTimestamp(record.installed_at)
+      );
+    }
+    table.print();
+  }
+};
+var initCommand = {
+  name: "init",
+  description: "Scaffold a new workflow package from a template",
+  args: [{ name: "directory", description: "Directory to scaffold (defaults to current dir)" }],
+  options: {
+    name: { type: "string", short: "n", description: "Workflow name" },
+    type: { type: "string", short: "t", description: "Workflow type", default: "research" },
+    phases: { type: "string", description: "Number of phases", default: "3" },
+    multi: { type: "boolean", description: "Scaffold multi-workflow plugin", default: false }
+  },
+  handler: async (parsed) => {
+    const directory = parsed.positionals[0] ?? ".";
+    const resolvedDir = path5.resolve(directory);
+    const workflowType = parsed.values["type"] ?? "research";
+    const numPhases = parseInt(parsed.values["phases"] ?? "3", 10);
+    const multi = parsed.values["multi"] === true;
+    const wfName = parsed.values["name"] ?? path5.basename(resolvedDir).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    if (fs5.existsSync(resolvedDir)) {
+      const entries = fs5.readdirSync(resolvedDir);
+      if (entries.length > 0) {
+        printError(`Directory is not empty: ${resolvedDir}`);
+        throw new CLIError("Directory not empty", 1);
+      }
+    }
+    if (multi) {
+      scaffoldMultiPackage(resolvedDir, { name: wfName, workflowType, numPhases });
+    } else {
+      scaffoldSinglePackage(resolvedDir, { name: wfName, workflowType, numPhases });
+    }
+    const fmtLabel = multi ? "multi-workflow plugin" : "single workflow package";
+    printSuccess(`Scaffolded ${fmtLabel} at ${resolvedDir}`);
+    print("\nNext steps:");
+    print(`  1. Edit the prompts in ${style(`${resolvedDir}/phases/`, CYAN)}`);
+    print(`  2. Validate: ${style(`syn workflow validate ${resolvedDir}`, CYAN)}`);
+    print(`  3. Install: ${style(`syn workflow install ${resolvedDir}`, CYAN)}`);
+  }
+};
+
+// src/commands/workflow/export.ts
+import fs6 from "fs";
+import path6 from "path";
+var exportCommand = {
+  name: "export",
+  description: "Export a workflow as a distributable package or Claude Code plugin",
+  args: [{ name: "workflow-id", description: "Workflow ID to export", required: true }],
+  options: {
+    format: { type: "string", short: "f", description: "Export format: 'package' (default) or 'plugin'", default: "package" },
+    output: { type: "string", short: "o", description: "Output directory (created if absent)", default: "." }
+  },
+  handler: async (parsed) => {
+    const workflowId = parsed.positionals[0];
+    if (!workflowId) {
+      printError("Missing required argument: workflow-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const fmt = parsed.values["format"] ?? "package";
+    if (fmt !== "package" && fmt !== "plugin") {
+      printError(`Invalid format '${fmt}'. Must be 'package' or 'plugin'.`);
+      throw new CLIError("Invalid format", 1);
+    }
+    const outputDir = parsed.values["output"] ?? ".";
+    const data = await apiGet(
+      `/workflows/${workflowId}/export`,
+      { params: { format: fmt } }
+    );
+    const files = data.files ?? {};
+    if (Object.keys(files).length === 0) {
+      printError("Export returned no files");
+      throw new CLIError("Export empty", 1);
+    }
+    const outDir = path6.resolve(outputDir);
+    if (fs6.existsSync(outDir)) {
+      const entries = fs6.readdirSync(outDir);
+      if (entries.length > 0) {
+        printError(`Output directory is not empty: ${outDir}`);
+        throw new CLIError("Directory not empty", 1);
+      }
+    }
+    for (const [relPath, content] of Object.entries(files).sort(([a], [b]) => a.localeCompare(b))) {
+      if (relPath.startsWith("/") || relPath.includes("..")) {
+        printError(`Unsafe file path in export manifest: ${relPath}`);
+        throw new CLIError("Path traversal", 1);
+      }
+      const filePath = path6.resolve(outDir, relPath);
+      if (!filePath.startsWith(outDir)) {
+        printError(`Path escapes output directory: ${relPath}`);
+        throw new CLIError("Path traversal", 1);
+      }
+      fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
+      fs6.writeFileSync(filePath, content, "utf-8");
+    }
+    const workflowName = data.workflow_name ?? workflowId;
+    print("");
+    print(style("Export Complete", GREEN));
+    print(`  ${style(workflowName, BOLD)}`);
+    print(`  Format: ${fmt}`);
+    print(`  Output: ${outDir}`);
+    print(`  Files: ${Object.keys(files).length}`);
+    print("");
+    print(style(`${path6.basename(outDir)}/`, CYAN));
+    const sortedPaths = Object.keys(files).sort();
+    for (const relPath of sortedPaths) {
+      const parts = relPath.split("/");
+      const indent = "  ".repeat(parts.length);
+      print(`${indent}${style(parts[parts.length - 1], DIM)}`);
+    }
+    printSuccess(`
+Exported to ${outDir}`);
+    print(`
+To install: ${style(`syn workflow install ${outDir}`, CYAN)}`);
+    if (fmt === "plugin") {
+      print(`Plugin command: ${style(`/syn-${workflowName.toLowerCase().replace(/ /g, "-")}`, CYAN)}`);
+    }
+  }
+};
+
+// src/commands/workflow/search.ts
+function truncate2(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 3) + "...";
+}
+var searchCommand = {
+  name: "search",
+  description: "Search for workflows across registered marketplaces",
+  args: [{ name: "query", description: "Search term (matches name, description, tags)" }],
+  options: {
+    category: { type: "string", short: "c", description: "Filter by category" },
+    tag: { type: "string", short: "t", description: "Filter by tag" },
+    registry: { type: "string", short: "r", description: "Search specific marketplace only" }
+  },
+  handler: async (parsed) => {
+    const query = parsed.positionals[0] ?? "";
+    const category = parsed.values["category"] ?? null;
+    const tag = parsed.values["tag"] ?? null;
+    const registryFilter = parsed.values["registry"];
+    let results = await searchAllRegistries(query, { category, tag });
+    if (registryFilter) {
+      results = results.filter(([rn]) => rn === registryFilter);
+    }
+    if (results.length === 0) {
+      printDim("No workflows found.");
+      if (!query && !category && !tag) {
+        printDim("Add a marketplace first: syn marketplace add syntropic137/workflow-library");
+      }
+      return;
+    }
+    const table = new Table({ title: "Available Workflows" });
+    table.addColumn("Name", { style: BOLD });
+    table.addColumn("Version");
+    table.addColumn("Category");
+    table.addColumn("Description");
+    table.addColumn("Registry", { style: DIM });
+    for (const [regName, plugin] of results) {
+      table.addRow(
+        plugin.name,
+        plugin.version,
+        plugin.category || "-",
+        truncate2(plugin.description, 50),
+        regName
+      );
+    }
+    table.print();
+    const count = results.length;
+    printDim(`
+${count} result${count !== 1 ? "s" : ""}. Install with: syn workflow install <name>`);
+  }
+};
+var infoCommand = {
+  name: "info",
+  description: "Show details of a marketplace workflow plugin",
+  args: [{ name: "name", description: "Plugin name from marketplace", required: true }],
+  handler: async (parsed) => {
+    const name = parsed.positionals[0];
+    if (!name) {
+      printError("Missing required argument: name");
+      throw new CLIError("Missing argument", 1);
+    }
+    const result = await resolvePluginByName(name);
+    if (result === null) {
+      printError(`Plugin '${name}' not found in any registered marketplace`);
+      printDim("Try: syn workflow search");
+      throw new CLIError("Not found", 1);
+    }
+    const [regName, entry, plugin] = result;
+    const tagsStr = plugin.tags.length > 0 ? plugin.tags.join(", ") : "-";
+    print("");
+    print(style(plugin.name, BOLD));
+    print(`  ${style("Version:", BOLD)}     ${plugin.version}`);
+    print(`  ${style("Description:", BOLD)} ${plugin.description || "-"}`);
+    print(`  ${style("Category:", BOLD)}    ${plugin.category || "-"}`);
+    print(`  ${style("Tags:", BOLD)}        ${tagsStr}`);
+    print(`  ${style("Source:", BOLD)}      ${entry.repo} (${plugin.source})`);
+    print(`  ${style("Registry:", BOLD)}    ${regName}`);
+    print("");
+    printDim(`Install: syn workflow install ${plugin.name}`);
+  }
+};
+
+// src/commands/workflow/update.ts
+function findInstallation(name) {
+  const registry = loadInstalled();
+  for (const record of registry.installations) {
+    if (record.package_name === name) return record;
+  }
+  return null;
+}
+function removeInstallation(name) {
+  const registry = loadInstalled();
+  const remaining = registry.installations.filter((r) => r.package_name !== name);
+  saveInstalled({ version: registry.version, installations: remaining });
+}
+async function deleteWorkflowsViaApi(record) {
+  let deleted = 0;
+  for (const wfRef of record.workflows) {
+    process.stdout.write(`  Removing ${style(wfRef.name, BOLD)}... `);
+    try {
+      await apiDelete(`/workflows/${wfRef.id}`, { expected: [200, 204, 404] });
+      print(style("done", GREEN));
+      deleted++;
+    } catch {
+      print(style("failed", RED));
+    }
+  }
+  return deleted;
+}
+async function isAlreadyUpToDate(record, effectiveRef) {
+  if (!record.marketplace_source || !record.git_sha) return false;
+  const result = await resolvePluginByName(record.package_name, record.marketplace_source);
+  if (result === null) return false;
+  const [_regName, entry, _plugin] = result;
+  const currentSha = await gitLsRemote(entry.repo, effectiveRef);
+  return currentSha !== null && currentSha === record.git_sha;
+}
+var updateCommand = {
+  name: "update",
+  description: "Update an installed workflow package to the latest version",
+  args: [{ name: "name", description: "Package name to update", required: true }],
+  options: {
+    ref: { type: "string", description: "Override git ref" },
+    "dry-run": { type: "boolean", short: "n", description: "Check for updates without applying", default: false }
+  },
+  handler: async (parsed) => {
+    const name = parsed.positionals[0];
+    if (!name) {
+      printError("Missing required argument: name");
+      throw new CLIError("Missing argument", 1);
+    }
+    const record = findInstallation(name);
+    if (record === null) {
+      printError(`Package '${name}' is not installed`);
+      printDim("See installed packages: syn workflow installed");
+      throw new CLIError("Not installed", 1);
+    }
+    const source = record.source;
+    const effectiveRef = parsed.values["ref"] ?? record.source_ref;
+    const dryRun = parsed.values["dry-run"] === true;
+    if (await isAlreadyUpToDate(record, effectiveRef)) {
+      printDim(`Package '${name}' is already up to date`);
+      return;
+    }
+    if (dryRun) {
+      print(`${style("Update available", CYAN)} for ${style(name, BOLD)}`);
+      print(`  Source: ${source}`);
+      print(`  Ref: ${effectiveRef}`);
+      printDim("Run without --dry-run to apply");
+      return;
+    }
+    let packagePath;
+    let manifest;
+    let workflows;
+    let tmpdir = null;
+    let marketplaceSource = null;
+    let gitSha = null;
+    let resolvedRef = effectiveRef;
+    try {
+      if (isBarePluginName(source) && record.marketplace_source) {
+        const mktResult = await tryMarketplaceResolution(source, effectiveRef);
+        if (mktResult !== null) {
+          ({ packagePath, manifest, workflows, tmpdir, marketplaceSource, gitSha, effectiveRef: resolvedRef } = mktResult);
+        } else {
+          printError(`Plugin '${name}' no longer found in marketplace`);
+          throw new CLIError("Not found", 1);
+        }
+      } else {
+        ({ packagePath, manifest, workflows, tmpdir } = await resolveSource(source, effectiveRef));
+      }
+    } catch (err) {
+      if (err instanceof CLIError) throw err;
+      printError(err instanceof Error ? err.message : String(err));
+      throw new CLIError("Resolution failed", 1);
+    }
+    try {
+      if (workflows.length === 0) {
+        printError("No workflows found in updated package");
+        throw new CLIError("No workflows", 1);
+      }
+      const fmt = detectFormat(packagePath);
+      const pkgName = manifest?.name ?? name;
+      const pkgVersion = manifest?.version ?? "0.0.0";
+      print("");
+      print(style("Package Preview", CYAN));
+      print(`  ${style(`${pkgName} v${pkgVersion}`, BOLD)}`);
+      print(`  Source: ${source}`);
+      print(`  Format: ${fmt}`);
+      print(`  Workflows: ${workflows.length}`);
+      print(`
+${style("Removing old workflows...", BOLD)}`);
+      await deleteWorkflowsViaApi(record);
+      removeInstallation(name);
+      print(`
+${style("Installing updated workflows...", BOLD)}`);
+      const installedRefs = await installWorkflowsViaApi(workflows);
+      if (installedRefs.length === 0) {
+        printError("No workflows were installed during update");
+        throw new CLIError("Update failed", 1);
+      }
+      recordInstallation({
+        packageName: pkgName,
+        packageVersion: pkgVersion,
+        source,
+        sourceRef: resolvedRef,
+        format: fmt,
+        workflows: installedRefs,
+        marketplaceSource: marketplaceSource ?? record.marketplace_source ?? null,
+        gitSha: gitSha ?? record.git_sha ?? null
+      });
+      printSuccess(`
+Updated ${pkgName} (${installedRefs.length} workflow(s))`);
+    } finally {
+      if (tmpdir !== null) {
+        removeTempDir(tmpdir);
+      }
+    }
+  }
+};
+var uninstallCommand = {
+  name: "uninstall",
+  description: "Uninstall a workflow package",
+  args: [{ name: "name", description: "Package name to uninstall", required: true }],
+  options: {
+    "keep-workflows": { type: "boolean", description: "Remove from registry but keep workflows in the platform", default: false }
+  },
+  handler: async (parsed) => {
+    const name = parsed.positionals[0];
+    if (!name) {
+      printError("Missing required argument: name");
+      throw new CLIError("Missing argument", 1);
+    }
+    const record = findInstallation(name);
+    if (record === null) {
+      printError(`Package '${name}' is not installed`);
+      printDim("See installed packages: syn workflow installed");
+      throw new CLIError("Not installed", 1);
+    }
+    if (parsed.values["keep-workflows"] !== true) {
+      print(`Removing workflows from ${style(name, BOLD)}...`);
+      const deleted = await deleteWorkflowsViaApi(record);
+      print(`  Removed ${deleted} workflow(s)`);
+    }
+    removeInstallation(name);
+    printSuccess(`Uninstalled ${style(name, BOLD)}`);
+  }
+};
+
+// src/commands/workflow/index.ts
+var workflowGroup = new CommandGroup(
+  "workflow",
+  "Manage workflows - create, list, run, and inspect"
+);
+workflowGroup.command(createCommand).command(listCommand).command(showCommand).command(validateCommand).command(deleteCommand).command(runCommand).command(statusCommand).command(installCommand).command(installedCommand).command(initCommand).command(exportCommand).command(searchCommand).command(infoCommand).command(updateCommand).command(uninstallCommand);
+
+// src/commands/marketplace/registry.ts
+import fs7 from "fs";
+import path7 from "path";
+var addCommand = {
+  name: "add",
+  description: "Register a GitHub repo as a workflow marketplace",
+  args: [{ name: "repo", description: "GitHub repo (org/repo shorthand)", required: true }],
+  options: {
+    ref: { type: "string", short: "r", description: "Git branch or tag", default: "main" },
+    name: { type: "string", short: "n", description: "Override registry name" }
+  },
+  handler: async (parsed) => {
+    const repo = parsed.positionals[0];
+    if (!repo) {
+      printError("Missing required argument: repo");
+      throw new CLIError("Missing argument", 1);
+    }
+    const ref = parsed.values["ref"] ?? "main";
+    const nameOverride = parsed.values["name"];
+    print(`Fetching marketplace.json from ${style(repo, CYAN)}@${ref}...`);
+    let index;
+    try {
+      index = await fetchMarketplaceJson(repo, ref);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      throw new CLIError("Fetch failed", 1);
+    }
+    const registryName = nameOverride ?? index.name;
+    try {
+      validateRegistryName(registryName);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      throw new CLIError("Invalid name", 1);
+    }
+    const config = loadRegistries();
+    if (config.registries[registryName]) {
+      printError(`Marketplace '${registryName}' is already registered`);
+      printDim("Use 'syn marketplace remove' first to re-register.");
+      throw new CLIError("Already registered", 1);
+    }
+    const entry = {
+      repo,
+      ref,
+      added_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    saveRegistries({
+      version: config.version,
+      registries: { ...config.registries, [registryName]: entry }
+    });
+    saveCachedIndex(registryName, {
+      fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+      index
+    });
+    const pluginCount = index.plugins.length;
+    printSuccess(
+      `Added marketplace ${style(registryName, BOLD)} (${pluginCount} plugin${pluginCount !== 1 ? "s" : ""})`
+    );
+  }
+};
+var listMarketplaceCommand = {
+  name: "list",
+  description: "List registered marketplace registries",
+  handler: async () => {
+    const config = loadRegistries();
+    if (Object.keys(config.registries).length === 0) {
+      printDim("No marketplaces registered.");
+      printDim("Add one with: syn marketplace add syntropic137/workflow-library");
+      return;
+    }
+    const table = new Table({ title: "Registered Marketplaces" });
+    table.addColumn("Name", { style: BOLD });
+    table.addColumn("Repo");
+    table.addColumn("Ref");
+    table.addColumn("Added");
+    for (const [name, entry] of Object.entries(config.registries)) {
+      table.addRow(
+        name,
+        entry.repo,
+        entry.ref,
+        formatTimestamp(entry.added_at)
+      );
+    }
+    table.print();
+  }
+};
+var removeCommand = {
+  name: "remove",
+  description: "Remove a registered marketplace",
+  args: [{ name: "name", description: "Registry name to remove", required: true }],
+  handler: async (parsed) => {
+    const name = parsed.positionals[0];
+    if (!name) {
+      printError("Missing required argument: name");
+      throw new CLIError("Missing argument", 1);
+    }
+    const config = loadRegistries();
+    if (!config.registries[name]) {
+      printError(`Marketplace '${name}' is not registered`);
+      throw new CLIError("Not found", 1);
+    }
+    const remaining = {};
+    for (const [k, v] of Object.entries(config.registries)) {
+      if (k !== name) remaining[k] = v;
+    }
+    saveRegistries({ version: config.version, registries: remaining });
+    try {
+      validateRegistryName(name);
+      const cachePath = path7.join(synPath("marketplace", "cache"), `${name}.json`);
+      if (fs7.existsSync(cachePath)) fs7.unlinkSync(cachePath);
+    } catch {
+    }
+    printSuccess(`Removed marketplace ${style(name, BOLD)}`);
+  }
+};
+var refreshCommand = {
+  name: "refresh",
+  description: "Force-refresh cached marketplace indexes",
+  args: [{ name: "name", description: "Registry name (refreshes all if omitted)" }],
+  handler: async (parsed) => {
+    const nameFilter = parsed.positionals[0];
+    const config = loadRegistries();
+    if (Object.keys(config.registries).length === 0) {
+      printDim("No marketplaces registered.");
+      return;
+    }
+    let targets;
+    if (nameFilter) {
+      const entry = config.registries[nameFilter];
+      if (!entry) {
+        printError(`Marketplace '${nameFilter}' is not registered`);
+        throw new CLIError("Not found", 1);
+      }
+      targets = [[nameFilter, entry]];
+    } else {
+      targets = Object.entries(config.registries);
+    }
+    for (const [regName, entry] of targets) {
+      process.stdout.write(`Refreshing ${style(regName, CYAN)}... `);
+      try {
+        const index = await refreshIndex(regName, entry, true);
+        const pluginCount = index.plugins.length;
+        print(`${style("done", GREEN)} (${pluginCount} plugin${pluginCount !== 1 ? "s" : ""})`);
+      } catch (err) {
+        print(`${style("failed", RED)} (${err instanceof Error ? err.message : String(err)})`);
+      }
+    }
+  }
+};
+
+// src/commands/marketplace/index.ts
+var marketplaceGroup = new CommandGroup(
+  "marketplace",
+  "Manage workflow marketplace registries"
+);
+marketplaceGroup.command(addCommand).command(listMarketplaceCommand).command(removeCommand).command(refreshCommand);
+
+// src/commands/agent.ts
+var listCommand2 = {
+  name: "list",
+  description: "List available agent providers",
+  handler: async () => {
+    const providers = await apiGetList("/agents/providers");
+    const table = new Table({ title: "Agent Providers" });
+    table.addColumn("Provider", { style: CYAN });
+    table.addColumn("Display Name");
+    table.addColumn("Available");
+    table.addColumn("Default Model");
+    for (const p of providers) {
+      const available = p["available"] ? style("Yes", GREEN) : style("No", "\x1B[31m");
+      table.addRow(
+        String(p["provider"] ?? ""),
+        String(p["display_name"] ?? ""),
+        available,
+        String(p["default_model"] ?? "")
+      );
+    }
+    table.print();
+  }
+};
+var testCommand = {
+  name: "test",
+  description: "Test an agent provider with a simple prompt",
+  options: {
+    provider: { type: "string", short: "p", description: "Agent provider (claude, mock)", default: "claude" },
+    prompt: { type: "string", description: "Test prompt", default: "Say hello in one sentence." },
+    model: { type: "string", short: "m", description: "Model override" }
+  },
+  handler: async (parsed) => {
+    const provider = parsed.values["provider"] ?? "claude";
+    const prompt = parsed.values["prompt"] ?? "Say hello in one sentence.";
+    const model = parsed.values["model"] ?? null;
+    const result = await apiPost("/agents/test", {
+      body: { provider, prompt, model },
+      timeoutMs: 6e4
+    });
+    print(`${style(`Response from ${String(result["provider"] ?? provider)}:`, GREEN)}`);
+    print(`  Model: ${String(result["model"] ?? "unknown")}`);
+    print(`  Response: ${String(result["response_text"] ?? "")}`);
+    print(`  Tokens: ${String(result["input_tokens"] ?? 0)} in / ${String(result["output_tokens"] ?? 0)} out`);
+  }
+};
+var agentGroup = new CommandGroup("agent", "AI agent management and testing");
+agentGroup.command(listCommand2).command(testCommand);
+
+// src/commands/artifacts.ts
+var listCommand3 = {
+  name: "list",
+  description: "List artifacts",
+  options: {
+    workflow: { type: "string", short: "w", description: "Filter by workflow ID" },
+    phase: { type: "string", short: "p", description: "Filter by phase ID" },
+    type: { type: "string", short: "t", description: "Filter by artifact type" },
+    limit: { type: "string", description: "Max results (max 200)", default: "50" }
+  },
+  handler: async (parsed) => {
+    const params = buildParams({
+      workflow_id: parsed.values["workflow"] ?? null,
+      phase_id: parsed.values["phase"] ?? null,
+      artifact_type: parsed.values["type"] ?? null,
+      limit: parsed.values["limit"] ?? "50"
+    });
+    const items = await apiGetList("/artifacts", { params });
+    if (items.length === 0) {
+      printDim("No artifacts found.");
+      return;
+    }
+    const table = new Table({ title: "Artifacts" });
+    table.addColumn("ID", { style: CYAN });
+    table.addColumn("Type");
+    table.addColumn("Title");
+    table.addColumn("Size", { align: "right" });
+    table.addColumn("Created");
+    for (const a of items) {
+      const size = a.size_bytes;
+      const sizeStr = size < 1024 ? `${size}B` : `${Math.floor(size / 1024)}KB`;
+      table.addRow(
+        a.id.slice(0, 12),
+        a.artifact_type,
+        a.title ?? "\u2014",
+        sizeStr,
+        formatTimestamp(a.created_at)
+      );
+    }
+    table.print();
+  }
+};
+var showCommand2 = {
+  name: "show",
+  description: "Show artifact metadata and content",
+  args: [{ name: "artifact-id", description: "Artifact ID", required: true }],
+  options: {
+    "no-content": { type: "boolean", description: "Skip content; show metadata only", default: false }
+  },
+  handler: async (parsed) => {
+    const id = parsed.positionals[0];
+    if (!id) {
+      printError("Missing artifact-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const noContent = parsed.values["no-content"] === true;
+    const a = await apiGet(`/artifacts/${id}`, {
+      params: { include_content: String(!noContent) }
+    });
+    print(`${style("Artifact:", BOLD)} ${a.id}`);
+    print(`  Type:    ${a.artifact_type}`);
+    if (a.title) print(`  Title:   ${a.title}`);
+    if (a.workflow_id) print(`  Workflow: ${a.workflow_id}`);
+    if (a.phase_id) print(`  Phase:   ${a.phase_id}`);
+    print(`  Created: ${formatTimestamp(a.created_at)}`);
+    if (a.size_bytes) print(`  Size:    ${a.size_bytes.toLocaleString()} bytes`);
+    if (!noContent && a.content) {
+      print("");
+      print(a.content);
+    }
+  }
+};
+var contentCommand = {
+  name: "content",
+  description: "Print the raw content of an artifact",
+  args: [{ name: "artifact-id", description: "Artifact ID", required: true }],
+  handler: async (parsed) => {
+    const id = parsed.positionals[0];
+    if (!id) {
+      printError("Missing artifact-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const data = await apiGet(`/artifacts/${id}/content`);
+    if (!data.content) {
+      printDim("(no content)");
+      return;
+    }
+    print(data.content);
+  }
+};
+var createCommand2 = {
+  name: "create",
+  description: "Create a new artifact",
+  options: {
+    workflow: { type: "string", short: "w", description: "Workflow ID" },
+    type: { type: "string", short: "t", description: "Artifact type (code, document, research_summary)" },
+    title: { type: "string", description: "Artifact title" },
+    content: { type: "string", short: "c", description: "Artifact content" },
+    phase: { type: "string", short: "p", description: "Phase ID" }
+  },
+  handler: async (parsed) => {
+    const data = await apiPost("/artifacts", {
+      body: {
+        workflow_id: parsed.values["workflow"] ?? null,
+        artifact_type: parsed.values["type"] ?? null,
+        title: parsed.values["title"] ?? null,
+        content: parsed.values["content"] ?? null,
+        phase_id: parsed.values["phase"] ?? null
+      }
+    });
+    print(`${style("Created artifact:", GREEN)} ${style(data.title, CYAN)}`);
+    print(`  ID: ${style(data.id, DIM)}`);
+    print(`  Type: ${style(data.artifact_type, DIM)}`);
+  }
+};
+var artifactsGroup = new CommandGroup("artifacts", "Browse and retrieve workflow artifacts");
+artifactsGroup.command(listCommand3).command(showCommand2).command(contentCommand).command(createCommand2);
+
+// src/commands/config.ts
+var showCommand3 = {
+  name: "show",
+  description: "Display current configuration",
+  options: {
+    "show-secrets": { type: "boolean", description: "Show secret values", default: false }
+  },
+  handler: async (parsed) => {
+    const showSecrets = parsed.values["show-secrets"] === true;
+    const snapshot = await apiGet("/config", {
+      params: { show_secrets: String(showSecrets) }
+    });
+    for (const section of ["app", "database", "agents", "storage"]) {
+      const data = snapshot[section];
+      if (!data) continue;
+      print(`
+${style(section.charAt(0).toUpperCase() + section.slice(1), BOLD)}`);
+      for (const [k, v] of Object.entries(data)) {
+        print(`  ${k}: ${String(v)}`);
+      }
+    }
+  }
+};
+var validateCommand2 = {
+  name: "validate",
+  description: "Validate configuration and show issues",
+  handler: async () => {
+    print("Validating configuration...\n");
+    const data = await apiGet("/config/validate");
+    const issues = data["issues"] ?? [];
+    if (issues.length === 0) {
+      print(style("No issues found.", GREEN));
+      return;
+    }
+    const table = new Table({ title: "Configuration Issues" });
+    table.addColumn("Level");
+    table.addColumn("Category");
+    table.addColumn("Message");
+    const levelStyles = { error: RED, warning: YELLOW, info: BLUE };
+    let hasErrors = false;
+    for (const issue of issues) {
+      const level = issue["level"] ?? "info";
+      const levelColor = levelStyles[level];
+      table.addRow(
+        levelColor ? style(level, levelColor) : level,
+        issue["category"] ?? "",
+        issue["message"] ?? ""
+      );
+      if (level === "error") hasErrors = true;
+    }
+    table.print();
+    if (hasErrors) {
+      print(`
+${style("Configuration has errors.", RED)}`);
+      throw new CLIError("Config errors", 1);
+    }
+  }
+};
+var envCommand = {
+  name: "env",
+  description: "Show environment variable template",
+  handler: async () => {
+    const data = await apiGet("/config/env");
+    const template = typeof data === "string" ? data : String(data["template"] ?? JSON.stringify(data));
+    print(template);
+  }
+};
+var configGroup = new CommandGroup("config", "Configuration management");
+configGroup.command(showCommand3).command(validateCommand2).command(envCommand);
+
+// src/commands/control.ts
+function reqId(parsed) {
+  const id = parsed.positionals[0];
+  if (!id) {
+    printError("Missing execution-id");
+    throw new CLIError("Missing argument", 1);
+  }
+  return id;
+}
+var pauseCommand = {
+  name: "pause",
+  description: "Pause a running execution at the next yield point",
+  args: [{ name: "execution-id", description: "Execution ID to pause", required: true }],
+  options: { reason: { type: "string", short: "r", description: "Reason for pausing" } },
+  handler: async (parsed) => {
+    const id = reqId(parsed);
+    const reason = parsed.values["reason"];
+    const data = await apiPost(`/executions/${id}/pause`, {
+      ...reason ? { body: { reason } } : {}
+    });
+    print(style(`Pause signal sent for execution ${id}`, GREEN));
+    print(`  State: ${data.state}`);
+    if (data.message) print(`  Message: ${data.message}`);
+  }
+};
+var resumeCommand = {
+  name: "resume",
+  description: "Resume a paused execution",
+  args: [{ name: "execution-id", description: "Execution ID to resume", required: true }],
+  handler: async (parsed) => {
+    const id = reqId(parsed);
+    const data = await apiPost(`/executions/${id}/resume`);
+    print(style(`Resume signal sent for execution ${id}`, GREEN));
+    print(`  State: ${data.state}`);
+  }
+};
+var cancelCommand = {
+  name: "cancel",
+  description: "Cancel a running or paused execution",
+  args: [{ name: "execution-id", description: "Execution ID to cancel", required: true }],
+  options: {
+    reason: { type: "string", short: "r", description: "Reason for cancelling" },
+    force: { type: "boolean", short: "f", description: "Skip confirmation prompt", default: false }
+  },
+  handler: async (parsed) => {
+    const id = reqId(parsed);
+    if (parsed.values["force"] !== true) {
+      printError(`Use --force to confirm cancelling execution ${id}`);
+      throw new CLIError("Confirmation required", 1);
+    }
+    const reason = parsed.values["reason"];
+    const data = await apiPost(`/executions/${id}/cancel`, {
+      ...reason ? { body: { reason } } : {}
+    });
+    print(style(`Cancel signal sent for execution ${id}`, GREEN));
+    print(`  State: ${data.state}`);
+  }
+};
+var statusCommand2 = {
+  name: "status",
+  description: "Get current execution control state",
+  args: [{ name: "execution-id", description: "Execution ID to check", required: true }],
+  handler: async (parsed) => {
+    const id = reqId(parsed);
+    const data = await apiGet(`/executions/${id}/state`);
+    print(`Execution: ${id}`);
+    print(`State: ${formatStatus(data.state)}`);
+  }
+};
+var injectCommand = {
+  name: "inject",
+  description: "Inject a message into a running execution",
+  args: [{ name: "execution-id", description: "Execution ID", required: true }],
+  options: {
+    message: { type: "string", short: "m", description: "Message to inject" }
+  },
+  handler: async (parsed) => {
+    const id = reqId(parsed);
+    const message = parsed.values["message"];
+    if (!message) {
+      printError("Missing --message");
+      throw new CLIError("Missing option", 1);
+    }
+    await apiPost(`/executions/${id}/inject`, { body: { message } });
+    print(style(`Message injected into execution ${id}`, GREEN));
+  }
+};
+var stopCommand = {
+  name: "stop",
+  description: "Forcefully stop a running execution via SIGINT",
+  args: [{ name: "execution-id", description: "Execution ID to stop", required: true }],
+  options: {
+    reason: { type: "string", short: "r", description: "Reason for stopping" },
+    force: { type: "boolean", short: "f", description: "Skip confirmation prompt", default: false }
+  },
+  handler: async (parsed) => {
+    const id = reqId(parsed);
+    if (parsed.values["force"] !== true) {
+      printError(`Use --force to confirm stopping execution ${id}`);
+      throw new CLIError("Confirmation required", 1);
+    }
+    const reason = parsed.values["reason"] ?? "Stopped by user via syn stop";
+    const data = await apiPost(`/executions/${id}/cancel`, {
+      body: { reason }
+    });
+    print(style(`Stop signal sent for execution ${id}`, YELLOW));
+    print(`  State: ${data.state}`);
+    if (data.message) print(`  Message: ${data.message}`);
+  }
+};
+var controlGroup = new CommandGroup("control", "Control running executions");
+controlGroup.command(pauseCommand).command(resumeCommand).command(cancelCommand).command(statusCommand2).command(injectCommand).command(stopCommand);
+
+// src/commands/conversations.ts
+var showCommand4 = {
+  name: "show",
+  description: "Show parsed conversation log lines for a session",
+  args: [{ name: "session-id", description: "Session ID", required: true }],
+  options: {
+    offset: { type: "string", description: "Line offset for pagination", default: "0" },
+    limit: { type: "string", description: "Max lines to show (max 500)", default: "100" }
+  },
+  handler: async (parsed) => {
+    const sessionId = parsed.positionals[0];
+    if (!sessionId) {
+      printError("Missing session-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const offset = parseInt(parsed.values["offset"] ?? "0", 10);
+    const limit = parseInt(parsed.values["limit"] ?? "100", 10);
+    const data = await apiGet(`/conversations/${sessionId}`, {
+      params: { offset, limit }
+    });
+    if (data.lines.length === 0) {
+      printDim("No conversation lines found.");
+      return;
+    }
+    print(`${style("Conversation:", BOLD)} ${sessionId.slice(0, 16)}  ${style(`(lines ${offset + 1}-${offset + data.lines.length} of ${data.total_lines})`, DIM)}`);
+    print("");
+    const table = new Table();
+    table.addColumn("#", { align: "right", style: DIM });
+    table.addColumn("Type", { style: CYAN });
+    table.addColumn("Tool", { style: DIM });
+    table.addColumn("Preview");
+    for (const line of data.lines) {
+      table.addRow(
+        String(line.line_number),
+        line.event_type ?? "\u2014",
+        line.tool_name ?? "\u2014",
+        line.content_preview ?? "\u2014"
+      );
+    }
+    table.print();
+    if (data.total_lines > offset + data.lines.length) {
+      printDim(`More lines available. Use --offset ${offset + limit}.`);
+    }
+  }
+};
+var metadataCommand = {
+  name: "metadata",
+  description: "Show metadata summary for a session's conversation",
+  args: [{ name: "session-id", description: "Session ID", required: true }],
+  handler: async (parsed) => {
+    const sessionId = parsed.positionals[0];
+    if (!sessionId) {
+      printError("Missing session-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const m = await apiGet(`/conversations/${sessionId}/metadata`);
+    print(`${style("Metadata:", BOLD)} ${m.session_id}`);
+    if (m.model != null) print(`  Model:            ${m.model}`);
+    if (m.event_count != null) print(`  Events:           ${m.event_count.toLocaleString()}`);
+    if (m.total_input_tokens != null) print(`  Input tokens:     ${m.total_input_tokens.toLocaleString()}`);
+    if (m.total_output_tokens != null) print(`  Output tokens:    ${m.total_output_tokens.toLocaleString()}`);
+    if (m.started_at != null) print(`  Started:          ${formatTimestamp(m.started_at)}`);
+    if (m.completed_at != null) print(`  Completed:        ${formatTimestamp(m.completed_at)}`);
+    if (m.size_bytes != null) print(`  Log size:         ${m.size_bytes.toLocaleString()} bytes`);
+    if (m.tool_counts) {
+      print("  Tool counts:");
+      const sorted = Object.entries(m.tool_counts).sort(([, a], [, b]) => b - a);
+      for (const [tool, count] of sorted) {
+        print(`    ${tool}: ${count}`);
+      }
+    }
+  }
+};
+var conversationsGroup = new CommandGroup("conversations", "Inspect agent conversation logs");
+conversationsGroup.command(showCommand4).command(metadataCommand);
+
+// src/commands/costs.ts
+function safeCost(v) {
+  if (v.startsWith("$")) return v;
+  try {
+    return formatCost(v);
+  } catch {
+    return v;
+  }
+}
+var summaryCommand = {
+  name: "summary",
+  description: "Show aggregated cost summary",
+  handler: async () => {
+    const d = await apiGet("/costs/summary");
+    print(style("Cost Summary", CYAN));
+    print(`  ${style("Total Cost:", BOLD)} ${formatCost(d.total_cost_usd)}`);
+    print(`  ${style("Sessions:", BOLD)} ${d.total_sessions}`);
+    print(`  ${style("Executions:", BOLD)} ${d.total_executions}`);
+    print(`  ${style("Tokens:", BOLD)} ${formatTokens(d.total_tokens)}`);
+    print(`  ${style("Tool Calls:", BOLD)} ${d.total_tool_calls}`);
+    const topModels = d.top_models ?? [];
+    if (topModels.length > 0) {
+      const table = new Table({ title: "Top Models" });
+      table.addColumn("Model", { style: CYAN });
+      table.addColumn("Cost", { align: "right" });
+      for (const e of topModels) table.addRow(e["model"] ?? "unknown", e["cost"] ?? "$0");
+      table.print();
+    }
+    const topSessions = d.top_sessions ?? [];
+    if (topSessions.length > 0) {
+      const table = new Table({ title: "Top Sessions" });
+      table.addColumn("Session", { style: DIM });
+      table.addColumn("Cost", { align: "right" });
+      for (const e of topSessions) {
+        const sid = e["session_id"] ?? "unknown";
+        table.addRow(sid.length > 12 ? sid.slice(0, 12) + "..." : sid, e["cost"] ?? "$0");
+      }
+      table.print();
+    }
+  }
+};
+var sessionsCommand = {
+  name: "sessions",
+  description: "List cost data for sessions",
+  options: {
+    execution: { type: "string", short: "e", description: "Filter by execution ID" },
+    limit: { type: "string", short: "n", description: "Max results", default: "50" }
+  },
+  handler: async (parsed) => {
+    const params = buildParams({
+      execution_id: parsed.values["execution"] ?? null,
+      limit: parsed.values["limit"] ?? "50"
+    });
+    const items = await apiGetList("/costs/sessions", { params });
+    if (items.length === 0) {
+      printDim("No session cost data found.");
+      return;
+    }
+    const table = new Table({ title: "Session Costs" });
+    table.addColumn("Session ID", { style: DIM });
+    table.addColumn("Cost", { align: "right" });
+    table.addColumn("Tokens", { align: "right" });
+    table.addColumn("Duration", { align: "right" });
+    table.addColumn("Tools", { align: "right" });
+    for (const s of items) {
+      const sid = s.session_id;
+      table.addRow(
+        sid.length > 12 ? sid.slice(0, 12) + "..." : sid,
+        formatCost(s.total_cost_usd),
+        formatTokens(s.total_tokens),
+        formatDuration(s.duration_ms),
+        String(s.tool_calls)
+      );
+    }
+    table.print();
+  }
+};
+var sessionDetailCommand = {
+  name: "session",
+  description: "Show detailed cost breakdown for a session",
+  args: [{ name: "session-id", description: "Session ID", required: true }],
+  handler: async (parsed) => {
+    const id = parsed.positionals[0];
+    if (!id) {
+      printError("Missing session-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const s = await apiGet(`/costs/sessions/${id}`);
+    print(style("Session Cost Detail", CYAN));
+    print(`  ${style("Session:", BOLD)} ${s.session_id}`);
+    print(`  ${style("Cost:", BOLD)} ${formatCost(s.total_cost_usd)}`);
+    print(`  ${style("Tokens:", BOLD)} ${formatTokens(s.total_tokens)} (in: ${formatTokens(s.input_tokens)}, out: ${formatTokens(s.output_tokens)})`);
+    print(`  ${style("Tool Calls:", BOLD)} ${s.tool_calls}  ${style("Turns:", BOLD)} ${s.turns}`);
+    print(`  ${style("Duration:", BOLD)} ${formatDuration(s.duration_ms)}`);
+    print(`  ${style("Started:", BOLD)} ${formatTimestamp(s.started_at)}`);
+    if (s.cost_by_model && Object.keys(s.cost_by_model).length > 0) print(formatBreakdown(s.cost_by_model, "Cost by Model", safeCost));
+    if (s.cost_by_tool && Object.keys(s.cost_by_tool).length > 0) print(formatBreakdown(s.cost_by_tool, "Cost by Tool", safeCost));
+  }
+};
+var executionsCommand = {
+  name: "executions",
+  description: "List cost data for workflow executions",
+  options: { limit: { type: "string", short: "n", description: "Max results", default: "50" } },
+  handler: async (parsed) => {
+    const limit = parsed.values["limit"] ?? "50";
+    const items = await apiGetList("/costs/executions", { params: { limit } });
+    if (items.length === 0) {
+      printDim("No execution cost data found.");
+      return;
+    }
+    const table = new Table({ title: "Execution Costs" });
+    table.addColumn("Execution ID", { style: DIM });
+    table.addColumn("Cost", { align: "right" });
+    table.addColumn("Sessions", { align: "right" });
+    table.addColumn("Tokens", { align: "right" });
+    for (const e of items) {
+      const eid = e.execution_id;
+      table.addRow(
+        eid.length > 12 ? eid.slice(0, 12) + "..." : eid,
+        formatCost(e.total_cost_usd),
+        String(e.session_count),
+        formatTokens(e.total_tokens)
+      );
+    }
+    table.print();
+  }
+};
+var executionDetailCommand = {
+  name: "execution",
+  description: "Show detailed cost breakdown for an execution",
+  args: [{ name: "execution-id", description: "Execution ID", required: true }],
+  handler: async (parsed) => {
+    const id = parsed.positionals[0];
+    if (!id) {
+      printError("Missing execution-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const e = await apiGet(`/costs/executions/${id}`);
+    print(style("Execution Cost Detail", CYAN));
+    print(`  ${style("Execution:", BOLD)} ${e.execution_id}`);
+    print(`  ${style("Cost:", BOLD)} ${formatCost(e.total_cost_usd)}`);
+    print(`  ${style("Sessions:", BOLD)} ${e.session_count}`);
+    print(`  ${style("Tokens:", BOLD)} ${formatTokens(e.total_tokens)} (in: ${formatTokens(e.input_tokens)}, out: ${formatTokens(e.output_tokens)})`);
+    print(`  ${style("Duration:", BOLD)} ${formatDuration(e.duration_ms)}`);
+    print(`  ${style("Started:", BOLD)} ${formatTimestamp(e.started_at)}`);
+    if (e.cost_by_phase && Object.keys(e.cost_by_phase).length > 0) print(formatBreakdown(e.cost_by_phase, "Cost by Phase", safeCost));
+    if (e.cost_by_model && Object.keys(e.cost_by_model).length > 0) print(formatBreakdown(e.cost_by_model, "Cost by Model", safeCost));
+    if (e.cost_by_tool && Object.keys(e.cost_by_tool).length > 0) print(formatBreakdown(e.cost_by_tool, "Cost by Tool", safeCost));
+  }
+};
+var costsGroup = new CommandGroup("costs", "View cost tracking data for sessions and executions");
+costsGroup.command(summaryCommand).command(sessionsCommand).command(sessionDetailCommand).command(executionsCommand).command(executionDetailCommand);
+
+// src/commands/events.ts
+function reqSessionId(parsed) {
+  const id = parsed.positionals[0];
+  if (!id) {
+    printError("Missing session-id");
+    throw new CLIError("Missing argument", 1);
+  }
+  return id;
+}
+var recentCommand = {
+  name: "recent",
+  description: "Show recent domain events across all sessions",
+  options: { limit: { type: "string", description: "Max events (max 200)", default: "50" } },
+  handler: async (parsed) => {
+    const limit = parsed.values["limit"] ?? "50";
+    const data = await apiGet("/events/recent", { params: { limit } });
+    if (data.events.length === 0) {
+      printDim("No recent events.");
+      return;
+    }
+    const table = new Table({ title: "Recent Events" });
+    table.addColumn("Time");
+    table.addColumn("Type", { style: CYAN });
+    table.addColumn("Session", { style: DIM });
+    table.addColumn("Execution", { style: DIM });
+    for (const ev of data.events) {
+      table.addRow(
+        formatTimestamp(String(ev.time ?? "")),
+        ev.event_type,
+        (ev.session_id ?? "").slice(0, 12),
+        (ev.execution_id ?? "").slice(0, 12)
+      );
+    }
+    table.print();
+    if (data.has_more) printDim("More events available. Use --limit to fetch more.");
+  }
+};
+var sessionEventsCommand = {
+  name: "session",
+  description: "List events for a specific session",
+  args: [{ name: "session-id", description: "Session ID", required: true }],
+  options: {
+    type: { type: "string", short: "t", description: "Filter by event type" },
+    limit: { type: "string", description: "Max events (max 1000)", default: "100" },
+    offset: { type: "string", description: "Pagination offset", default: "0" }
+  },
+  handler: async (parsed) => {
+    const sid = reqSessionId(parsed);
+    const params = buildParams({
+      limit: parsed.values["limit"] ?? "100",
+      offset: parsed.values["offset"] ?? "0",
+      event_type: parsed.values["type"] ?? null
+    });
+    const data = await apiGet(`/events/sessions/${sid}`, { params });
+    if (data.events.length === 0) {
+      printDim(`No events for session ${sid}.`);
+      return;
+    }
+    const table = new Table({ title: `Events: ${sid.slice(0, 12)}` });
+    table.addColumn("Time");
+    table.addColumn("Type", { style: CYAN });
+    table.addColumn("Phase", { style: DIM });
+    for (const ev of data.events) {
+      table.addRow(
+        formatTimestamp(String(ev.time ?? "")),
+        ev.event_type,
+        (ev.phase_id ?? "").slice(0, 12)
+      );
+    }
+    table.print();
+    const offset = parseInt(parsed.values["offset"] ?? "0", 10);
+    const limit = parseInt(parsed.values["limit"] ?? "100", 10);
+    if (data.has_more) printDim(`More events available. Use --offset ${offset + limit}.`);
+  }
+};
+var timelineCommand = {
+  name: "timeline",
+  description: "Show a chronological tool-call timeline for a session",
+  args: [{ name: "session-id", description: "Session ID", required: true }],
+  options: { limit: { type: "string", description: "Max entries (max 500)", default: "100" } },
+  handler: async (parsed) => {
+    const sid = reqSessionId(parsed);
+    const limit = parsed.values["limit"] ?? "100";
+    const entries = await apiGetList(`/events/sessions/${sid}/timeline`, { params: { limit } });
+    if (entries.length === 0) {
+      printDim("No timeline entries.");
+      return;
+    }
+    const table = new Table({ title: `Timeline: ${sid.slice(0, 12)}` });
+    table.addColumn("Time");
+    table.addColumn("Event", { style: CYAN });
+    table.addColumn("Tool");
+    table.addColumn("Duration", { align: "right" });
+    table.addColumn("\u2713");
+    for (const e of entries) {
+      table.addRow(
+        formatTimestamp(String(e.time ?? "")),
+        e.event_type,
+        e.tool_name ?? "\u2014",
+        e.duration_ms != null ? formatDuration(e.duration_ms) : "\u2014",
+        e.success === true ? style("\u2713", GREEN) : e.success === false ? style("\u2717", RED) : "\u2014"
+      );
+    }
+    table.print();
+  }
+};
+var costsCommand = {
+  name: "costs",
+  description: "Show token usage and cost breakdown for a session",
+  args: [{ name: "session-id", description: "Session ID", required: true }],
+  handler: async (parsed) => {
+    const sid = reqSessionId(parsed);
+    const d = await apiGet(`/events/sessions/${sid}/costs`);
+    print(`${style("Session costs:", BOLD)} ${d.session_id}`);
+    print(`  Input tokens:       ${d.input_tokens.toLocaleString()}`);
+    print(`  Output tokens:      ${d.output_tokens.toLocaleString()}`);
+    print(`  Total tokens:       ${d.total_tokens.toLocaleString()}`);
+    if (d.cache_creation_tokens) print(`  Cache creation:     ${d.cache_creation_tokens.toLocaleString()}`);
+    if (d.cache_read_tokens) print(`  Cache read:         ${d.cache_read_tokens.toLocaleString()}`);
+    if (d.estimated_cost_usd != null)
+      print(`  Estimated cost:     ${formatCost(String(d.estimated_cost_usd))}`);
+  }
+};
+var toolsCommand = {
+  name: "tools",
+  description: "Show tool usage summary for a session",
+  args: [{ name: "session-id", description: "Session ID", required: true }],
+  handler: async (parsed) => {
+    const sid = reqSessionId(parsed);
+    const tools = await apiGetList(`/events/sessions/${sid}/tools`);
+    if (tools.length === 0) {
+      printDim("No tool usage recorded.");
+      return;
+    }
+    const table = new Table({ title: `Tool Usage: ${sid.slice(0, 12)}` });
+    table.addColumn("Tool", { style: CYAN });
+    table.addColumn("Calls", { align: "right" });
+    table.addColumn("Success", { align: "right" });
+    table.addColumn("Errors", { align: "right" });
+    table.addColumn("Avg Duration", { align: "right" });
+    const sorted = [...tools].sort((a, b) => b.call_count - a.call_count);
+    for (const t of sorted) {
+      table.addRow(
+        t.tool_name,
+        String(t.call_count),
+        String(t.success_count),
+        String(t.error_count),
+        t.avg_duration_ms ? formatDuration(t.avg_duration_ms) : "\u2014"
+      );
+    }
+    table.print();
+  }
+};
+var eventsGroup = new CommandGroup("events", "Query domain events and session observability");
+eventsGroup.command(recentCommand).command(sessionEventsCommand).command(timelineCommand).command(costsCommand).command(toolsCommand);
+
+// src/commands/execution.ts
+var listCommand4 = {
+  name: "list",
+  description: "List all workflow executions",
+  options: {
+    status: { type: "string", short: "s", description: "Filter by status" },
+    page: { type: "string", description: "Page number", default: "1" },
+    "page-size": { type: "string", description: "Items per page (max 100)", default: "50" }
+  },
+  handler: async (parsed) => {
+    const params = buildParams({
+      status: parsed.values["status"] ?? null,
+      page: parsed.values["page"] ?? "1",
+      page_size: parsed.values["page-size"] ?? "50"
+    });
+    const data = await apiGet("/executions", { params });
+    const { executions, total } = data;
+    const page = parseInt(parsed.values["page"] ?? "1", 10);
+    const pageSize = parseInt(parsed.values["page-size"] ?? "50", 10);
+    if (executions.length === 0) {
+      printDim("No executions found.");
+      return;
+    }
+    const table = new Table({ title: `Executions (page ${page}, ${total} total)` });
+    table.addColumn("ID", { style: CYAN });
+    table.addColumn("Workflow");
+    table.addColumn("Status");
+    table.addColumn("Started");
+    table.addColumn("Phases", { align: "right" });
+    table.addColumn("Tokens", { align: "right" });
+    table.addColumn("Cost", { align: "right" });
+    for (const ex of executions) {
+      table.addRow(
+        ex.workflow_execution_id,
+        ex.workflow_name,
+        formatStatus(ex.status),
+        formatTimestamp(ex.started_at),
+        `${ex.completed_phases}/${ex.total_phases}`,
+        formatTokens(ex.total_tokens),
+        formatCost(ex.total_cost_usd)
+      );
+    }
+    table.print();
+    if (total > page * pageSize) printDim(`Showing page ${page}. Use --page ${page + 1} for more.`);
+  }
+};
+var showCommand5 = {
+  name: "show",
+  description: "Show detailed information about a single execution",
+  args: [{ name: "execution-id", description: "Execution ID", required: true }],
+  handler: async (parsed) => {
+    const id = parsed.positionals[0];
+    if (!id) {
+      printError("Missing execution-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const ex = await apiGet(`/executions/${id}`);
+    print(`${style("Execution:", BOLD)} ${ex.workflow_execution_id}`);
+    print(`  Workflow:   ${ex.workflow_name}`);
+    print(`  Status:     ${formatStatus(ex.status)}`);
+    print(`  Started:    ${formatTimestamp(ex.started_at)}`);
+    if (ex.completed_at) print(`  Completed:  ${formatTimestamp(ex.completed_at)}`);
+    print(`  Tokens:     ${formatTokens(ex.total_tokens)}`);
+    print(`  Cost:       ${formatCost(ex.total_cost_usd)}`);
+    if (ex.error_message) print(`  ${style("Error:", RED)}     ${ex.error_message}`);
+    const phases = ex.phases ?? [];
+    if (phases.length > 0) {
+      print("");
+      const table = new Table({ title: "Phases" });
+      table.addColumn("#", { align: "right", style: DIM });
+      table.addColumn("Name");
+      table.addColumn("Status");
+      table.addColumn("Started");
+      table.addColumn("Tokens", { align: "right" });
+      table.addColumn("Cost", { align: "right" });
+      for (let i = 0; i < phases.length; i++) {
+        const ph = phases[i];
+        table.addRow(
+          String(i + 1),
+          ph.name,
+          formatStatus(ph.status),
+          formatTimestamp(ph.started_at),
+          formatTokens(ph.total_tokens),
+          formatCost(ph.cost_usd)
+        );
+      }
+      table.print();
+    }
+  }
+};
+var executionGroup = new CommandGroup("execution", "List and inspect workflow executions");
+executionGroup.command(listCommand4).command(showCommand5);
+
+// src/commands/insights.ts
+var SPARKLINE_CHARS = " \u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+function renderSparkline(values) {
+  if (values.length === 0) return "";
+  const max = Math.max(...values);
+  if (max === 0) return SPARKLINE_CHARS[0].repeat(values.length);
+  return values.map((v) => {
+    const idx = Math.min(Math.round(v / max * 8), 8);
+    return SPARKLINE_CHARS[idx] ?? " ";
+  }).join("");
+}
+var overviewCommand = {
+  name: "overview",
+  description: "Show global overview of systems and health",
+  handler: async () => {
+    const d = await apiGet("/insights/overview");
+    print(style("System Overview", CYAN));
+    print(`  ${style("Total systems:", BOLD)}     ${d["total_systems"] ?? 0}`);
+    print(`  ${style("Total repos:", BOLD)}       ${d["total_repos"] ?? 0}`);
+    print(`  ${style("Active sessions:", BOLD)}   ${d["active_sessions"] ?? 0}`);
+    print(`  ${style("Total executions:", BOLD)}  ${d["total_executions"] ?? 0}`);
+    const health = d["health"];
+    if (health) {
+      const h = String(health["status"] ?? "unknown");
+      const color = h === "healthy" ? GREEN : h === "degraded" ? YELLOW : RED;
+      print(`  ${style("Health:", BOLD)}           ${style(h, color)}`);
+    }
+    const systems = d["systems"] ?? [];
+    if (systems.length > 0) {
+      const table = new Table({ title: "Systems" });
+      table.addColumn("Name", { style: CYAN });
+      table.addColumn("Repos", { align: "right" });
+      table.addColumn("Health");
+      table.addColumn("Executions", { align: "right" });
+      for (const sys of systems) {
+        const sh = String(sys["health"] ?? "unknown");
+        const sc = sh === "healthy" ? GREEN : sh === "degraded" ? YELLOW : RED;
+        table.addRow(
+          String(sys["name"] ?? ""),
+          String(sys["repo_count"] ?? 0),
+          style(sh, sc),
+          String(sys["execution_count"] ?? 0)
+        );
+      }
+      table.print();
+    }
+  }
+};
+var costCommand = {
+  name: "cost",
+  description: "Show global cost breakdown",
+  options: {
+    days: { type: "string", short: "d", description: "Number of days to look back", default: "30" }
+  },
+  handler: async (parsed) => {
+    const days = parsed.values["days"] ?? "30";
+    const d = await apiGet("/insights/costs", { params: { days } });
+    print(style(`Cost Overview (last ${days} days)`, CYAN));
+    print(`  ${style("Total cost:", BOLD)}   ${formatCost(String(d["total_cost_usd"] ?? "0"))}`);
+    print(`  ${style("Total tokens:", BOLD)} ${formatTokens(Number(d["total_tokens"] ?? 0))}`);
+    const byRepo = d["by_repo"] ?? [];
+    if (byRepo.length > 0) {
+      const table = new Table({ title: "Cost by Repository" });
+      table.addColumn("Repository", { style: CYAN });
+      table.addColumn("Cost", { align: "right" });
+      table.addColumn("Tokens", { align: "right" });
+      for (const r of byRepo) {
+        table.addRow(
+          String(r["repo_name"] ?? r["repo_id"] ?? ""),
+          formatCost(String(r["cost_usd"] ?? "0")),
+          formatTokens(Number(r["tokens"] ?? 0))
+        );
+      }
+      table.print();
+    }
+    const byModel = d["by_model"] ?? [];
+    if (byModel.length > 0) {
+      const table = new Table({ title: "Cost by Model" });
+      table.addColumn("Model", { style: CYAN });
+      table.addColumn("Cost", { align: "right" });
+      for (const m of byModel) {
+        table.addRow(
+          String(m["model"] ?? ""),
+          formatCost(String(m["cost_usd"] ?? "0"))
+        );
+      }
+      table.print();
+    }
+  }
+};
+var heatmapCommand = {
+  name: "heatmap",
+  description: "Show activity heatmap over time",
+  options: {
+    days: { type: "string", short: "d", description: "Number of days to show", default: "14" }
+  },
+  handler: async (parsed) => {
+    const days = parsed.values["days"] ?? "14";
+    const d = await apiGet("/insights/heatmap", { params: { days } });
+    const buckets = d["buckets"] ?? [];
+    if (buckets.length === 0) {
+      printDim("No activity data.");
+      return;
+    }
+    const values = buckets.map((b) => Number(b["count"] ?? 0));
+    print(style(`Activity Heatmap (last ${days} days)`, CYAN));
+    print(`  ${renderSparkline(values)}`);
+    print(style(`  ${values.reduce((a, b) => a + b, 0)} total events`, DIM));
+    const topRepos = d["top_repos"] ?? [];
+    if (topRepos.length > 0) {
+      const table = new Table({ title: "Top Repositories" });
+      table.addColumn("Repository", { style: CYAN });
+      table.addColumn("Events", { align: "right" });
+      for (const r of topRepos.slice(0, 5)) {
+        table.addRow(
+          String(r["repo_name"] ?? r["repo_id"] ?? ""),
+          String(r["count"] ?? 0)
+        );
+      }
+      table.print();
+    }
+  }
+};
+var insightsGroup = new CommandGroup("insights", "Global system insights and cost analysis");
+insightsGroup.command(overviewCommand).command(costCommand).command(heatmapCommand);
+
+// src/commands/metrics.ts
+var showCommand6 = {
+  name: "show",
+  description: "Show aggregated workflow and session metrics",
+  options: {
+    workflow: { type: "string", short: "w", description: "Filter by workflow ID" }
+  },
+  handler: async (parsed) => {
+    const workflow = parsed.values["workflow"] ?? null;
+    const params = {};
+    if (workflow) params["workflow_id"] = workflow;
+    const d = await apiGet("/metrics", { params });
+    print(style("Aggregated Metrics", CYAN));
+    print(`  ${style("Workflows:", BOLD)}     ${d.total_workflows}`);
+    print(`  ${style("Sessions:", BOLD)}      ${d.total_sessions}`);
+    print(`  ${style("Input tokens:", BOLD)}  ${formatTokens(d.total_input_tokens)}`);
+    print(`  ${style("Output tokens:", BOLD)} ${formatTokens(d.total_output_tokens)}`);
+    print(`  ${style("Total cost:", BOLD)}    ${formatCost(d.total_cost_usd)}`);
+    print(`  ${style("Artifacts:", BOLD)}     ${d.total_artifacts}`);
+    const phases = d.phases ?? [];
+    if (phases.length > 0) {
+      const table = new Table({ title: "Phase Metrics" });
+      table.addColumn("Phase");
+      table.addColumn("Status");
+      table.addColumn("Tokens", { align: "right" });
+      table.addColumn("Cost", { align: "right" });
+      table.addColumn("Duration", { align: "right" });
+      table.addColumn("Artifacts", { align: "right" });
+      for (const ph of phases) {
+        table.addRow(
+          ph.phase_name,
+          formatStatus(ph.status),
+          formatTokens(ph.total_tokens),
+          formatCost(ph.cost_usd),
+          formatDuration(ph.duration_seconds * 1e3),
+          String(ph.artifact_count)
+        );
+      }
+      table.print();
+    }
+    if (phases.length === 0 && !d.total_workflows) {
+      printDim("No metrics data available.");
+    }
+  }
+};
+var metricsGroup = new CommandGroup("metrics", "View aggregated workflow and session metrics");
+metricsGroup.command(showCommand6);
+
+// src/commands/observe.ts
+function reqSessionId2(parsed) {
+  const id = parsed.positionals[0];
+  if (!id) {
+    printError("Missing session-id");
+    throw new CLIError("Missing argument", 1);
+  }
+  return id;
+}
+var toolTimelineCommand = {
+  name: "tools",
+  description: "Show tool execution timeline for a session",
+  args: [{ name: "session-id", description: "Session ID", required: true }],
+  options: {
+    limit: { type: "string", description: "Max entries", default: "100" }
+  },
+  handler: async (parsed) => {
+    const sid = reqSessionId2(parsed);
+    const limit = parsed.values["limit"] ?? "100";
+    const entries = await apiGetList(`/observe/sessions/${sid}/tools`, { params: { limit } });
+    if (entries.length === 0) {
+      printDim("No tool timeline entries.");
+      return;
+    }
+    const table = new Table({ title: `Tool Timeline: ${sid.slice(0, 12)}` });
+    table.addColumn("Time");
+    table.addColumn("Tool", { style: CYAN });
+    table.addColumn("Duration", { align: "right" });
+    table.addColumn("Status");
+    for (const e of entries) {
+      const dur = e["duration_ms"];
+      const success = e["success"];
+      table.addRow(
+        formatTimestamp(String(e["time"] ?? "")),
+        String(e["tool_name"] ?? ""),
+        dur !== null && dur !== void 0 ? formatDuration(Number(dur)) : "\u2014",
+        success === true ? style("ok", GREEN) : success === false ? style("error", RED) : style("\u2014", DIM)
+      );
+    }
+    table.print();
+  }
+};
+var tokenMetricsCommand = {
+  name: "tokens",
+  description: "Show token breakdown for a session",
+  args: [{ name: "session-id", description: "Session ID", required: true }],
+  handler: async (parsed) => {
+    const sid = reqSessionId2(parsed);
+    const d = await apiGet(`/observe/sessions/${sid}/tokens`);
+    print(`${style("Token Metrics:", BOLD)} ${d["session_id"] ?? sid}`);
+    print(`  Input tokens:       ${Number(d["input_tokens"] ?? 0).toLocaleString()}`);
+    print(`  Output tokens:      ${Number(d["output_tokens"] ?? 0).toLocaleString()}`);
+    print(`  Total tokens:       ${Number(d["total_tokens"] ?? 0).toLocaleString()}`);
+    if (d["cache_creation_tokens"]) print(`  Cache creation:     ${Number(d["cache_creation_tokens"]).toLocaleString()}`);
+    if (d["cache_read_tokens"]) print(`  Cache read:         ${Number(d["cache_read_tokens"]).toLocaleString()}`);
+    if (d["estimated_cost_usd"] !== null && d["estimated_cost_usd"] !== void 0)
+      print(`  Estimated cost:     ${formatCost(String(d["estimated_cost_usd"]))}`);
+  }
+};
+var observeGroup = new CommandGroup("observe", "Session observability \u2014 tool timelines and token metrics");
+observeGroup.command(toolTimelineCommand).command(tokenMetricsCommand);
+
+// src/commands/org.ts
+function reqId2(parsed) {
+  const id = parsed.positionals[0];
+  if (!id) {
+    printError("Missing org-id");
+    throw new CLIError("Missing argument", 1);
+  }
+  return id;
+}
+var createCommand3 = {
+  name: "create",
+  description: "Create a new organization",
+  options: {
+    name: { type: "string", short: "n", description: "Organization name" },
+    slug: { type: "string", short: "s", description: "URL-safe slug" }
+  },
+  handler: async (parsed) => {
+    const name = parsed.values["name"];
+    const slug = parsed.values["slug"];
+    if (!name) {
+      printError("Missing --name");
+      throw new CLIError("Missing option", 1);
+    }
+    const body = { name };
+    if (slug) body["slug"] = slug;
+    const d = await apiPost("/organizations", { body, expected: [200, 201] });
+    printSuccess(`Organization created: ${d["organization_id"] ?? ""}`);
+    print(`  Name: ${d["name"] ?? name}`);
+    if (d["slug"]) print(`  Slug: ${String(d["slug"])}`);
+  }
+};
+var listCommand5 = {
+  name: "list",
+  description: "List all organizations",
+  handler: async () => {
+    const items = await apiGetList("/organizations");
+    if (items.length === 0) {
+      printDim("No organizations found.");
+      return;
+    }
+    const table = new Table({ title: "Organizations" });
+    table.addColumn("ID", { style: CYAN });
+    table.addColumn("Name");
+    table.addColumn("Slug", { style: DIM });
+    table.addColumn("Systems", { align: "right" });
+    table.addColumn("Repos", { align: "right" });
+    for (const o of items) {
+      table.addRow(
+        String(o["organization_id"] ?? ""),
+        String(o["name"] ?? ""),
+        String(o["slug"] ?? ""),
+        String(o["system_count"] ?? 0),
+        String(o["repo_count"] ?? 0)
+      );
+    }
+    table.print();
+  }
+};
+var showCommand7 = {
+  name: "show",
+  description: "Show organization details",
+  args: [{ name: "org-id", description: "Organization ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqId2(parsed);
+    const d = await apiGet(`/organizations/${id}`);
+    print(`${style("Organization:", BOLD)} ${d["name"] ?? id}`);
+    print(`  ID:      ${d["organization_id"] ?? id}`);
+    if (d["slug"]) print(`  Slug:    ${String(d["slug"])}`);
+    print(`  Systems: ${d["system_count"] ?? 0}`);
+    print(`  Repos:   ${d["repo_count"] ?? 0}`);
+  }
+};
+var updateCommand2 = {
+  name: "update",
+  description: "Update an organization",
+  args: [{ name: "org-id", description: "Organization ID", required: true }],
+  options: {
+    name: { type: "string", short: "n", description: "New name" },
+    slug: { type: "string", short: "s", description: "New slug" }
+  },
+  handler: async (parsed) => {
+    const id = reqId2(parsed);
+    const body = {};
+    const name = parsed.values["name"];
+    const slug = parsed.values["slug"];
+    if (name) body["name"] = name;
+    if (slug) body["slug"] = slug;
+    if (Object.keys(body).length === 0) {
+      printError("Nothing to update. Use --name or --slug.");
+      throw new CLIError("No updates", 1);
+    }
+    await apiPut(`/organizations/${id}`, { body });
+    printSuccess(`Organization ${id} updated.`);
+  }
+};
+var deleteCommand2 = {
+  name: "delete",
+  description: "Delete an organization",
+  args: [{ name: "org-id", description: "Organization ID", required: true }],
+  options: {
+    force: { type: "boolean", short: "f", description: "Skip confirmation", default: false }
+  },
+  handler: async (parsed) => {
+    const id = reqId2(parsed);
+    if (parsed.values["force"] !== true) {
+      printError(`Use --force to confirm deleting organization ${id}`);
+      throw new CLIError("Confirmation required", 1);
+    }
+    await apiDelete(`/organizations/${id}`);
+    printSuccess(`Organization ${id} deleted.`);
+  }
+};
+var orgGroup = new CommandGroup("org", "Manage organizations");
+orgGroup.command(createCommand3).command(listCommand5).command(showCommand7).command(updateCommand2).command(deleteCommand2);
+
+// src/commands/repo.ts
+function reqRepoId(parsed) {
+  const id = parsed.positionals[0];
+  if (!id) {
+    printError("Missing repo-id");
+    throw new CLIError("Missing argument", 1);
+  }
+  return id;
+}
+var registerCommand = {
+  name: "register",
+  description: "Register a repository",
+  options: {
+    url: { type: "string", short: "u", description: "Repository URL (owner/repo or full URL)" },
+    system: { type: "string", short: "s", description: "Assign to system ID" },
+    org: { type: "string", short: "o", description: "Organization ID" }
+  },
+  handler: async (parsed) => {
+    const url = parsed.values["url"];
+    if (!url) {
+      printError("Missing --url");
+      throw new CLIError("Missing option", 1);
+    }
+    const body = { repo_url: url };
+    const system = parsed.values["system"];
+    const org = parsed.values["org"];
+    if (system) body["system_id"] = system;
+    if (org) body["organization_id"] = org;
+    const d = await apiPost("/repos", { body, expected: [200, 201] });
+    printSuccess(`Repository registered: ${d["repo_id"] ?? ""}`);
+    print(`  URL: ${d["repo_url"] ?? url}`);
+    if (d["system_id"]) print(`  System: ${String(d["system_id"])}`);
+  }
+};
+var listCommand6 = {
+  name: "list",
+  description: "List repositories",
+  options: {
+    org: { type: "string", short: "o", description: "Filter by organization" },
+    system: { type: "string", short: "s", description: "Filter by system" }
+  },
+  handler: async (parsed) => {
+    const params = buildParams({
+      organization_id: parsed.values["org"] ?? null,
+      system_id: parsed.values["system"] ?? null
+    });
+    const items = await apiGetList("/repos", { params });
+    if (items.length === 0) {
+      printDim("No repositories found.");
+      return;
+    }
+    const table = new Table({ title: "Repositories" });
+    table.addColumn("ID", { style: CYAN });
+    table.addColumn("URL");
+    table.addColumn("System", { style: DIM });
+    table.addColumn("Status");
+    for (const r of items) {
+      table.addRow(
+        String(r["repo_id"] ?? ""),
+        String(r["repo_url"] ?? ""),
+        String(r["system_id"] ?? "\u2014"),
+        formatStatus(String(r["status"] ?? ""))
+      );
+    }
+    table.print();
+  }
+};
+var showCommand8 = {
+  name: "show",
+  description: "Show repository details",
+  args: [{ name: "repo-id", description: "Repository ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqRepoId(parsed);
+    const d = await apiGet(`/repos/${id}`);
+    print(`${style("Repository:", BOLD)} ${d["repo_url"] ?? id}`);
+    print(`  ID:     ${d["repo_id"] ?? id}`);
+    if (d["system_id"]) print(`  System: ${String(d["system_id"])}`);
+    if (d["organization_id"]) print(`  Org:    ${String(d["organization_id"])}`);
+    print(`  Status: ${formatStatus(String(d["status"] ?? ""))}`);
+  }
+};
+var assignCommand = {
+  name: "assign",
+  description: "Assign a repository to a system",
+  args: [{ name: "repo-id", description: "Repository ID", required: true }],
+  options: {
+    system: { type: "string", short: "s", description: "System ID to assign to" }
+  },
+  handler: async (parsed) => {
+    const id = reqRepoId(parsed);
+    const system = parsed.values["system"];
+    if (!system) {
+      printError("Missing --system");
+      throw new CLIError("Missing option", 1);
+    }
+    await apiPut(`/repos/${id}/assign`, { body: { system_id: system } });
+    printSuccess(`Repository ${id} assigned to system ${system}.`);
+  }
+};
+var unassignCommand = {
+  name: "unassign",
+  description: "Remove repository from its system",
+  args: [{ name: "repo-id", description: "Repository ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqRepoId(parsed);
+    await apiPost(`/repos/${id}/unassign`);
+    printSuccess(`Repository ${id} unassigned from system.`);
+  }
+};
+var healthCommand2 = {
+  name: "health",
+  description: "Show health metrics for a repository",
+  args: [{ name: "repo-id", description: "Repository ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqRepoId(parsed);
+    const d = await apiGet(`/repos/${id}/health`);
+    const h = String(d["health_status"] ?? "unknown");
+    const color = h === "healthy" ? GREEN : h === "degraded" ? YELLOW : RED;
+    print(`${style("Repository Health:", BOLD)} ${id}`);
+    print(`  Status:          ${style(h, color)}`);
+    print(`  Success rate:    ${d["success_rate"] != null ? `${(Number(d["success_rate"]) * 100).toFixed(1)}%` : "\u2014"}`);
+    print(`  Avg duration:    ${d["avg_duration_ms"] != null ? formatDuration(Number(d["avg_duration_ms"])) : "\u2014"}`);
+    print(`  Total runs:      ${d["total_executions"] ?? 0}`);
+    const trends = d["trends"] ?? [];
+    if (trends.length > 0) {
+      const table = new Table({ title: "Trends" });
+      table.addColumn("Period");
+      table.addColumn("Runs", { align: "right" });
+      table.addColumn("Success", { align: "right" });
+      table.addColumn("Cost", { align: "right" });
+      for (const t of trends) {
+        table.addRow(
+          String(t["period"] ?? ""),
+          String(t["count"] ?? 0),
+          String(t["success_count"] ?? 0),
+          formatCost(String(t["cost_usd"] ?? "0"))
+        );
+      }
+      table.print();
+    }
+  }
+};
+var costCommand2 = {
+  name: "cost",
+  description: "Show cost breakdown for a repository",
+  args: [{ name: "repo-id", description: "Repository ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqRepoId(parsed);
+    const d = await apiGet(`/repos/${id}/costs`);
+    print(`${style("Repository Costs:", BOLD)} ${id}`);
+    print(`  Total cost:  ${formatCost(String(d["total_cost_usd"] ?? "0"))}`);
+    print(`  Tokens:      ${formatTokens(Number(d["total_tokens"] ?? 0))}`);
+    const byModel = d["by_model"] ?? [];
+    if (byModel.length > 0) {
+      const table = new Table({ title: "Cost by Model" });
+      table.addColumn("Model", { style: CYAN });
+      table.addColumn("Cost", { align: "right" });
+      table.addColumn("Tokens", { align: "right" });
+      for (const m of byModel) {
+        table.addRow(
+          String(m["model"] ?? ""),
+          formatCost(String(m["cost_usd"] ?? "0")),
+          formatTokens(Number(m["tokens"] ?? 0))
+        );
+      }
+      table.print();
+    }
+  }
+};
+var activityCommand = {
+  name: "activity",
+  description: "Show recent execution activity for a repository",
+  args: [{ name: "repo-id", description: "Repository ID", required: true }],
+  options: {
+    limit: { type: "string", short: "n", description: "Max results", default: "20" }
+  },
+  handler: async (parsed) => {
+    const id = reqRepoId(parsed);
+    const limit = parsed.values["limit"] ?? "20";
+    const items = await apiGetList(`/repos/${id}/activity`, { params: { limit } });
+    if (items.length === 0) {
+      printDim("No recent activity.");
+      return;
+    }
+    const table = new Table({ title: `Activity: ${id}` });
+    table.addColumn("Execution", { style: DIM });
+    table.addColumn("Workflow");
+    table.addColumn("Status");
+    table.addColumn("Started");
+    table.addColumn("Duration", { align: "right" });
+    table.addColumn("Cost", { align: "right" });
+    for (const e of items) {
+      table.addRow(
+        String(e["execution_id"] ?? "").slice(0, 12),
+        String(e["workflow_name"] ?? ""),
+        formatStatus(String(e["status"] ?? "")),
+        formatTimestamp(e["started_at"]),
+        e["duration_ms"] != null ? formatDuration(Number(e["duration_ms"])) : "\u2014",
+        formatCost(String(e["cost_usd"] ?? "0"))
+      );
+    }
+    table.print();
+  }
+};
+var failuresCommand = {
+  name: "failures",
+  description: "Show recent execution failures for a repository",
+  args: [{ name: "repo-id", description: "Repository ID", required: true }],
+  options: {
+    limit: { type: "string", short: "n", description: "Max results", default: "10" }
+  },
+  handler: async (parsed) => {
+    const id = reqRepoId(parsed);
+    const limit = parsed.values["limit"] ?? "10";
+    const items = await apiGetList(`/repos/${id}/failures`, { params: { limit } });
+    if (items.length === 0) {
+      printDim("No recent failures.");
+      return;
+    }
+    const table = new Table({ title: `Failures: ${id}` });
+    table.addColumn("Execution", { style: DIM });
+    table.addColumn("Workflow");
+    table.addColumn("Error");
+    table.addColumn("Time");
+    for (const e of items) {
+      table.addRow(
+        String(e["execution_id"] ?? "").slice(0, 12),
+        String(e["workflow_name"] ?? ""),
+        String(e["error_message"] ?? "\u2014").slice(0, 60),
+        formatTimestamp(e["failed_at"])
+      );
+    }
+    table.print();
+  }
+};
+var sessionsCommand2 = {
+  name: "sessions",
+  description: "Show agent sessions for a repository",
+  args: [{ name: "repo-id", description: "Repository ID", required: true }],
+  options: {
+    limit: { type: "string", short: "n", description: "Max results", default: "20" }
+  },
+  handler: async (parsed) => {
+    const id = reqRepoId(parsed);
+    const limit = parsed.values["limit"] ?? "20";
+    const items = await apiGetList(`/repos/${id}/sessions`, { params: { limit } });
+    if (items.length === 0) {
+      printDim("No sessions found.");
+      return;
+    }
+    const table = new Table({ title: `Sessions: ${id}` });
+    table.addColumn("Session", { style: DIM });
+    table.addColumn("Status");
+    table.addColumn("Started");
+    table.addColumn("Tokens", { align: "right" });
+    table.addColumn("Cost", { align: "right" });
+    for (const s of items) {
+      table.addRow(
+        String(s["session_id"] ?? "").slice(0, 12),
+        formatStatus(String(s["status"] ?? "")),
+        formatTimestamp(s["started_at"]),
+        formatTokens(Number(s["total_tokens"] ?? 0)),
+        formatCost(String(s["cost_usd"] ?? "0"))
+      );
+    }
+    table.print();
+  }
+};
+var repoGroup = new CommandGroup("repo", "Manage repositories and view observability data");
+repoGroup.command(registerCommand).command(listCommand6).command(showCommand8).command(assignCommand).command(unassignCommand).command(healthCommand2).command(costCommand2).command(activityCommand).command(failuresCommand).command(sessionsCommand2);
+
+// src/commands/sessions.ts
+var listCommand7 = {
+  name: "list",
+  description: "List agent sessions",
+  options: {
+    workflow: { type: "string", short: "w", description: "Filter by workflow ID" },
+    status: { type: "string", short: "s", description: "Filter by status" },
+    limit: { type: "string", short: "n", description: "Max results", default: "50" }
+  },
+  handler: async (parsed) => {
+    const params = buildParams({
+      workflow_id: parsed.values["workflow"] ?? null,
+      status: parsed.values["status"] ?? null,
+      limit: parsed.values["limit"] ?? "50"
+    });
+    const items = await apiGetList("/sessions", { params });
+    if (items.length === 0) {
+      printDim("No sessions found.");
+      return;
+    }
+    const table = new Table({ title: "Sessions" });
+    table.addColumn("Session ID", { style: CYAN });
+    table.addColumn("Status");
+    table.addColumn("Provider");
+    table.addColumn("Started");
+    table.addColumn("Tokens", { align: "right" });
+    table.addColumn("Cost", { align: "right" });
+    for (const s of items) {
+      table.addRow(
+        s.id.slice(0, 16),
+        formatStatus(s.status),
+        s.agent_provider ?? "\u2014",
+        formatTimestamp(s.started_at),
+        formatTokens(s.total_tokens),
+        formatCost(s.total_cost_usd)
+      );
+    }
+    table.print();
+  }
+};
+var showCommand9 = {
+  name: "show",
+  description: "Show detailed session information",
+  args: [{ name: "session-id", description: "Session ID", required: true }],
+  handler: async (parsed) => {
+    const id = parsed.positionals[0];
+    if (!id) {
+      printError("Missing session-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    const d = await apiGet(`/sessions/${id}`);
+    print(`${style("Session:", BOLD)} ${d.id}`);
+    print(`  Workflow:    ${d.workflow_name ?? d.workflow_id ?? "\u2014"}`);
+    print(`  Status:      ${formatStatus(d.status)}`);
+    print(`  Provider:    ${d.agent_provider ?? "\u2014"}`);
+    print(`  Model:       ${d.agent_model ?? "\u2014"}`);
+    print(`  Started:     ${formatTimestamp(d.started_at)}`);
+    if (d.completed_at) print(`  Completed:   ${formatTimestamp(d.completed_at)}`);
+    if (d.duration_seconds != null) print(`  Duration:    ${formatDuration(d.duration_seconds * 1e3)}`);
+    print(`  Tokens:      ${formatTokens(d.total_tokens)} (in: ${formatTokens(d.input_tokens)}, out: ${formatTokens(d.output_tokens)})`);
+    print(`  Cost:        ${formatCost(d.total_cost_usd)}`);
+    if (d.error_message) print(`  Error:       ${d.error_message}`);
+    const operations = d.operations ?? [];
+    if (operations.length > 0) {
+      print("");
+      const table = new Table({ title: "Operations" });
+      table.addColumn("#", { align: "right", style: DIM });
+      table.addColumn("Type", { style: CYAN });
+      table.addColumn("Tool");
+      table.addColumn("Success");
+      for (let i = 0; i < operations.length; i++) {
+        const op = operations[i];
+        table.addRow(
+          String(i + 1),
+          op.operation_type,
+          op.tool_name ?? "\u2014",
+          op.success ? "yes" : "no"
+        );
+      }
+      table.print();
+    }
+  }
+};
+var sessionsGroup = new CommandGroup("sessions", "List and inspect agent sessions");
+sessionsGroup.command(listCommand7).command(showCommand9);
+
+// src/commands/system.ts
+function reqId3(parsed) {
+  const id = parsed.positionals[0];
+  if (!id) {
+    printError("Missing system-id");
+    throw new CLIError("Missing argument", 1);
+  }
+  return id;
+}
+var createCommand4 = {
+  name: "create",
+  description: "Create a new system",
+  options: {
+    name: { type: "string", short: "n", description: "System name" },
+    description: { type: "string", short: "d", description: "System description" },
+    org: { type: "string", short: "o", description: "Organization ID" }
+  },
+  handler: async (parsed) => {
+    const name = parsed.values["name"];
+    if (!name) {
+      printError("Missing --name");
+      throw new CLIError("Missing option", 1);
+    }
+    const body = { name };
+    const desc = parsed.values["description"];
+    const org = parsed.values["org"];
+    if (desc) body["description"] = desc;
+    if (org) body["organization_id"] = org;
+    const d = await apiPost("/systems", { body, expected: [200, 201] });
+    printSuccess(`System created: ${d["system_id"] ?? ""}`);
+    print(`  Name: ${d["name"] ?? name}`);
+  }
+};
+var listCommand8 = {
+  name: "list",
+  description: "List all systems",
+  options: {
+    org: { type: "string", short: "o", description: "Filter by organization" }
+  },
+  handler: async (parsed) => {
+    const params = buildParams({
+      organization_id: parsed.values["org"] ?? null
+    });
+    const items = await apiGetList("/systems", { params });
+    if (items.length === 0) {
+      printDim("No systems found.");
+      return;
+    }
+    const table = new Table({ title: "Systems" });
+    table.addColumn("ID", { style: CYAN });
+    table.addColumn("Name");
+    table.addColumn("Org", { style: DIM });
+    table.addColumn("Repos", { align: "right" });
+    table.addColumn("Status");
+    for (const s of items) {
+      table.addRow(
+        String(s["system_id"] ?? ""),
+        String(s["name"] ?? ""),
+        String(s["organization_id"] ?? "\u2014"),
+        String(s["repo_count"] ?? 0),
+        formatStatus(String(s["status"] ?? ""))
+      );
+    }
+    table.print();
+  }
+};
+var showCommand10 = {
+  name: "show",
+  description: "Show system details",
+  args: [{ name: "system-id", description: "System ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqId3(parsed);
+    const d = await apiGet(`/systems/${id}`);
+    print(`${style("System:", BOLD)} ${d["name"] ?? id}`);
+    print(`  ID:          ${d["system_id"] ?? id}`);
+    if (d["description"]) print(`  Description: ${String(d["description"])}`);
+    if (d["organization_id"]) print(`  Org:         ${String(d["organization_id"])}`);
+    print(`  Repos:       ${d["repo_count"] ?? 0}`);
+    print(`  Status:      ${formatStatus(String(d["status"] ?? ""))}`);
+  }
+};
+var updateCommand3 = {
+  name: "update",
+  description: "Update a system",
+  args: [{ name: "system-id", description: "System ID", required: true }],
+  options: {
+    name: { type: "string", short: "n", description: "New name" },
+    description: { type: "string", short: "d", description: "New description" }
+  },
+  handler: async (parsed) => {
+    const id = reqId3(parsed);
+    const body = {};
+    const name = parsed.values["name"];
+    const desc = parsed.values["description"];
+    if (name) body["name"] = name;
+    if (desc) body["description"] = desc;
+    if (Object.keys(body).length === 0) {
+      printError("Nothing to update. Use --name or --description.");
+      throw new CLIError("No updates", 1);
+    }
+    await apiPut(`/systems/${id}`, { body });
+    printSuccess(`System ${id} updated.`);
+  }
+};
+var deleteCommand3 = {
+  name: "delete",
+  description: "Delete a system",
+  args: [{ name: "system-id", description: "System ID", required: true }],
+  options: {
+    force: { type: "boolean", short: "f", description: "Skip confirmation", default: false }
+  },
+  handler: async (parsed) => {
+    const id = reqId3(parsed);
+    if (parsed.values["force"] !== true) {
+      printError(`Use --force to confirm deleting system ${id}`);
+      throw new CLIError("Confirmation required", 1);
+    }
+    await apiDelete(`/systems/${id}`);
+    printSuccess(`System ${id} deleted.`);
+  }
+};
+var statusCommand3 = {
+  name: "status",
+  description: "Show system health status",
+  args: [{ name: "system-id", description: "System ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqId3(parsed);
+    const d = await apiGet(`/systems/${id}/status`);
+    const h = String(d["health_status"] ?? "unknown");
+    const color = h === "healthy" ? GREEN : h === "degraded" ? YELLOW : RED;
+    print(`${style("System Status:", BOLD)} ${d["name"] ?? id}`);
+    print(`  Health:    ${style(h, color)}`);
+    print(`  Repos:     ${d["repo_count"] ?? 0}`);
+    print(`  Active:    ${d["active_executions"] ?? 0}`);
+    const repos = d["repos"] ?? [];
+    if (repos.length > 0) {
+      const table = new Table({ title: "Repository Health" });
+      table.addColumn("Repo", { style: CYAN });
+      table.addColumn("Health");
+      table.addColumn("Last Run");
+      table.addColumn("Success Rate", { align: "right" });
+      for (const r of repos) {
+        const rh = String(r["health"] ?? "unknown");
+        const rc = rh === "healthy" ? GREEN : rh === "degraded" ? YELLOW : RED;
+        table.addRow(
+          String(r["repo_url"] ?? r["repo_id"] ?? ""),
+          style(rh, rc),
+          formatTimestamp(r["last_run_at"]),
+          r["success_rate"] != null ? `${(Number(r["success_rate"]) * 100).toFixed(0)}%` : "\u2014"
+        );
+      }
+      table.print();
+    }
+  }
+};
+var costCommand3 = {
+  name: "cost",
+  description: "Show cost breakdown for a system",
+  args: [{ name: "system-id", description: "System ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqId3(parsed);
+    const d = await apiGet(`/systems/${id}/costs`);
+    print(`${style("System Costs:", BOLD)} ${id}`);
+    print(`  Total cost:  ${formatCost(String(d["total_cost_usd"] ?? "0"))}`);
+    print(`  Tokens:      ${formatTokens(Number(d["total_tokens"] ?? 0))}`);
+    const byRepo = d["by_repo"] ?? [];
+    if (byRepo.length > 0) {
+      const table = new Table({ title: "Cost by Repository" });
+      table.addColumn("Repo", { style: CYAN });
+      table.addColumn("Cost", { align: "right" });
+      table.addColumn("Tokens", { align: "right" });
+      for (const r of byRepo) {
+        table.addRow(
+          String(r["repo_url"] ?? r["repo_id"] ?? ""),
+          formatCost(String(r["cost_usd"] ?? "0")),
+          formatTokens(Number(r["tokens"] ?? 0))
+        );
+      }
+      table.print();
+    }
+  }
+};
+var activityCommand2 = {
+  name: "activity",
+  description: "Show recent execution activity for a system",
+  args: [{ name: "system-id", description: "System ID", required: true }],
+  options: {
+    limit: { type: "string", short: "n", description: "Max results", default: "20" }
+  },
+  handler: async (parsed) => {
+    const id = reqId3(parsed);
+    const limit = parsed.values["limit"] ?? "20";
+    const items = await apiGetList(`/systems/${id}/activity`, { params: { limit } });
+    if (items.length === 0) {
+      printDim("No recent activity.");
+      return;
+    }
+    const table = new Table({ title: `Activity: ${id}` });
+    table.addColumn("Execution", { style: DIM });
+    table.addColumn("Repo");
+    table.addColumn("Workflow");
+    table.addColumn("Status");
+    table.addColumn("Started");
+    table.addColumn("Cost", { align: "right" });
+    for (const e of items) {
+      table.addRow(
+        String(e["execution_id"] ?? "").slice(0, 12),
+        String(e["repo_url"] ?? ""),
+        String(e["workflow_name"] ?? ""),
+        formatStatus(String(e["status"] ?? "")),
+        formatTimestamp(e["started_at"]),
+        formatCost(String(e["cost_usd"] ?? "0"))
+      );
+    }
+    table.print();
+  }
+};
+var patternsCommand = {
+  name: "patterns",
+  description: "Show failure patterns and cost outliers for a system",
+  args: [{ name: "system-id", description: "System ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqId3(parsed);
+    const d = await apiGet(`/systems/${id}/patterns`);
+    const failures = d["failure_patterns"] ?? [];
+    if (failures.length > 0) {
+      const table = new Table({ title: "Failure Patterns" });
+      table.addColumn("Pattern");
+      table.addColumn("Count", { align: "right" });
+      table.addColumn("Last Seen");
+      for (const f of failures) {
+        table.addRow(
+          String(f["pattern"] ?? "").slice(0, 60),
+          String(f["count"] ?? 0),
+          formatTimestamp(f["last_seen"])
+        );
+      }
+      table.print();
+    } else {
+      printDim("No failure patterns detected.");
+    }
+    const outliers = d["cost_outliers"] ?? [];
+    if (outliers.length > 0) {
+      const table = new Table({ title: "Cost Outliers" });
+      table.addColumn("Execution", { style: DIM });
+      table.addColumn("Cost", { align: "right" });
+      table.addColumn("Avg Cost", { align: "right" });
+      table.addColumn("Ratio", { align: "right" });
+      for (const o of outliers) {
+        table.addRow(
+          String(o["execution_id"] ?? "").slice(0, 12),
+          formatCost(String(o["cost_usd"] ?? "0")),
+          formatCost(String(o["avg_cost_usd"] ?? "0")),
+          `${Number(o["ratio"] ?? 0).toFixed(1)}x`
+        );
+      }
+      table.print();
+    }
+  }
+};
+var historyCommand = {
+  name: "history",
+  description: "Show full execution history for a system",
+  args: [{ name: "system-id", description: "System ID", required: true }],
+  options: {
+    limit: { type: "string", short: "n", description: "Max results", default: "50" },
+    status: { type: "string", short: "s", description: "Filter by status" }
+  },
+  handler: async (parsed) => {
+    const id = reqId3(parsed);
+    const params = buildParams({
+      limit: parsed.values["limit"] ?? "50",
+      status: parsed.values["status"] ?? null
+    });
+    const items = await apiGetList(`/systems/${id}/history`, { params });
+    if (items.length === 0) {
+      printDim("No execution history.");
+      return;
+    }
+    const table = new Table({ title: `History: ${id}` });
+    table.addColumn("Execution", { style: DIM });
+    table.addColumn("Workflow");
+    table.addColumn("Status");
+    table.addColumn("Started");
+    table.addColumn("Duration", { align: "right" });
+    table.addColumn("Cost", { align: "right" });
+    for (const e of items) {
+      table.addRow(
+        String(e["execution_id"] ?? "").slice(0, 12),
+        String(e["workflow_name"] ?? ""),
+        formatStatus(String(e["status"] ?? "")),
+        formatTimestamp(e["started_at"]),
+        e["duration_ms"] != null ? formatDuration(Number(e["duration_ms"])) : "\u2014",
+        formatCost(String(e["cost_usd"] ?? "0"))
+      );
+    }
+    table.print();
+  }
+};
+var systemGroup = new CommandGroup("system", "Manage systems and view system observability");
+systemGroup.command(createCommand4).command(listCommand8).command(showCommand10).command(updateCommand3).command(deleteCommand3).command(statusCommand3).command(costCommand3).command(activityCommand2).command(patternsCommand).command(historyCommand);
+
+// src/commands/triggers.ts
+function reqId4(parsed) {
+  const id = parsed.positionals[0];
+  if (!id) {
+    printError("Missing trigger-id");
+    throw new CLIError("Missing argument", 1);
+  }
+  return id;
+}
+function parseConditions(condStrs) {
+  return condStrs.map((c) => {
+    const eqIdx = c.indexOf("=");
+    if (eqIdx < 1) throw new CLIError(`Invalid condition format: ${c} (expected key=value)`, 1);
+    return { key: c.slice(0, eqIdx), value: c.slice(eqIdx + 1) };
+  });
+}
+var registerCommand2 = {
+  name: "register",
+  description: "Register a new trigger rule",
+  options: {
+    repo: { type: "string", short: "r", description: "Repository ID" },
+    workflow: { type: "string", short: "w", description: "Workflow ID to execute" },
+    event: { type: "string", short: "e", description: "GitHub event type (e.g. check_run.completed)" },
+    condition: { type: "string", short: "c", multiple: true, description: "Condition as key=value (repeatable)" },
+    "max-fires": { type: "string", description: "Maximum fires per period", default: "5" },
+    cooldown: { type: "string", description: "Cooldown in seconds", default: "300" },
+    budget: { type: "string", description: "Budget limit in USD" }
+  },
+  handler: async (parsed) => {
+    const repo = parsed.values["repo"];
+    const workflow = parsed.values["workflow"];
+    const event = parsed.values["event"];
+    if (!repo) {
+      printError("Missing --repo");
+      throw new CLIError("Missing option", 1);
+    }
+    if (!workflow) {
+      printError("Missing --workflow");
+      throw new CLIError("Missing option", 1);
+    }
+    if (!event) {
+      printError("Missing --event");
+      throw new CLIError("Missing option", 1);
+    }
+    const conditionStrs = parsed.values["condition"] ?? [];
+    const conditions = conditionStrs.length > 0 ? parseConditions(conditionStrs) : [];
+    const body = {
+      repo_id: repo,
+      workflow_id: workflow,
+      event_type: event,
+      conditions,
+      max_fires_per_period: parseInt(parsed.values["max-fires"] ?? "5", 10),
+      cooldown_seconds: parseInt(parsed.values["cooldown"] ?? "300", 10)
+    };
+    const budget = parsed.values["budget"];
+    if (budget) body["budget_usd"] = parseFloat(budget);
+    const d = await apiPost("/triggers", { body, expected: [200, 201] });
+    printSuccess(`Trigger registered: ${d["trigger_id"] ?? ""}`);
+  }
+};
+var enablePresetCommand = {
+  name: "enable",
+  description: "Enable a built-in trigger preset",
+  args: [{ name: "preset", description: "Preset name (self-healing, review-fix)", required: true }],
+  options: {
+    repo: { type: "string", short: "r", description: "Repository ID" },
+    workflow: { type: "string", short: "w", description: "Workflow ID" }
+  },
+  handler: async (parsed) => {
+    const preset = parsed.positionals[0];
+    if (!preset) {
+      printError("Missing preset name");
+      throw new CLIError("Missing argument", 1);
+    }
+    const repo = parsed.values["repo"];
+    if (!repo) {
+      printError("Missing --repo");
+      throw new CLIError("Missing option", 1);
+    }
+    const body = { preset, repo_id: repo };
+    const workflow = parsed.values["workflow"];
+    if (workflow) body["workflow_id"] = workflow;
+    const d = await apiPost("/triggers/presets", { body, expected: [200, 201] });
+    printSuccess(`Preset "${preset}" enabled: ${d["trigger_id"] ?? ""}`);
+  }
+};
+var listCommand9 = {
+  name: "list",
+  description: "List trigger rules",
+  options: {
+    repo: { type: "string", short: "r", description: "Filter by repository" },
+    status: { type: "string", short: "s", description: "Filter by status" }
+  },
+  handler: async (parsed) => {
+    const params = buildParams({
+      repo_id: parsed.values["repo"] ?? null,
+      status: parsed.values["status"] ?? null
+    });
+    const items = await apiGetList("/triggers", { params });
+    if (items.length === 0) {
+      printDim("No triggers found.");
+      return;
+    }
+    const table = new Table({ title: "Triggers" });
+    table.addColumn("ID", { style: CYAN });
+    table.addColumn("Event");
+    table.addColumn("Repo", { style: DIM });
+    table.addColumn("Workflow", { style: DIM });
+    table.addColumn("Status");
+    table.addColumn("Fires", { align: "right" });
+    for (const t of items) {
+      table.addRow(
+        String(t["trigger_id"] ?? "").slice(0, 12),
+        String(t["event_type"] ?? ""),
+        String(t["repo_id"] ?? "").slice(0, 12),
+        String(t["workflow_id"] ?? "").slice(0, 12),
+        formatStatus(String(t["status"] ?? "")),
+        String(t["fire_count"] ?? 0)
+      );
+    }
+    table.print();
+  }
+};
+var showCommand11 = {
+  name: "show",
+  description: "Show trigger details",
+  args: [{ name: "trigger-id", description: "Trigger ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqId4(parsed);
+    const d = await apiGet(`/triggers/${id}`);
+    print(`${style("Trigger:", BOLD)} ${d["trigger_id"] ?? id}`);
+    print(`  Event:      ${d["event_type"] ?? ""}`);
+    print(`  Repo:       ${d["repo_id"] ?? ""}`);
+    print(`  Workflow:   ${d["workflow_id"] ?? ""}`);
+    print(`  Status:     ${formatStatus(String(d["status"] ?? ""))}`);
+    print(`  Fires:      ${d["fire_count"] ?? 0} / max ${d["max_fires_per_period"] ?? "\u2014"}`);
+    print(`  Cooldown:   ${d["cooldown_seconds"] ?? 0}s`);
+    if (d["budget_usd"] != null) print(`  Budget:     ${formatCost(String(d["budget_usd"]))}`);
+    if (d["last_fired_at"]) print(`  Last fired: ${formatTimestamp(d["last_fired_at"])}`);
+    const conditions = d["conditions"] ?? [];
+    if (conditions.length > 0) {
+      print(style("  Conditions:", BOLD));
+      for (const c of conditions) {
+        print(`    ${c["key"] ?? ""} = ${c["value"] ?? ""}`);
+      }
+    }
+  }
+};
+var historyCommand2 = {
+  name: "history",
+  description: "Show trigger execution history",
+  args: [{ name: "trigger-id", description: "Trigger ID", required: true }],
+  options: {
+    limit: { type: "string", short: "n", description: "Max results", default: "20" }
+  },
+  handler: async (parsed) => {
+    const id = reqId4(parsed);
+    const limit = parsed.values["limit"] ?? "20";
+    const items = await apiGetList(`/triggers/${id}/history`, { params: { limit } });
+    if (items.length === 0) {
+      printDim("No trigger history.");
+      return;
+    }
+    const table = new Table({ title: `Trigger History: ${id.slice(0, 12)}` });
+    table.addColumn("Time");
+    table.addColumn("Execution", { style: DIM });
+    table.addColumn("Status");
+    table.addColumn("Cost", { align: "right" });
+    for (const h of items) {
+      table.addRow(
+        formatTimestamp(h["fired_at"]),
+        String(h["execution_id"] ?? "").slice(0, 12),
+        formatStatus(String(h["status"] ?? "")),
+        formatCost(String(h["cost_usd"] ?? "0"))
+      );
+    }
+    table.print();
+  }
+};
+var pauseCommand2 = {
+  name: "pause",
+  description: "Pause a trigger rule",
+  args: [{ name: "trigger-id", description: "Trigger ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqId4(parsed);
+    await apiPost(`/triggers/${id}/pause`);
+    printSuccess(`Trigger ${id} paused.`);
+  }
+};
+var resumeCommand2 = {
+  name: "resume",
+  description: "Resume a paused trigger rule",
+  args: [{ name: "trigger-id", description: "Trigger ID", required: true }],
+  handler: async (parsed) => {
+    const id = reqId4(parsed);
+    await apiPost(`/triggers/${id}/resume`);
+    printSuccess(`Trigger ${id} resumed.`);
+  }
+};
+var deleteCommand4 = {
+  name: "delete",
+  description: "Delete a trigger rule",
+  args: [{ name: "trigger-id", description: "Trigger ID", required: true }],
+  options: {
+    force: { type: "boolean", short: "f", description: "Skip confirmation", default: false }
+  },
+  handler: async (parsed) => {
+    const id = reqId4(parsed);
+    if (parsed.values["force"] !== true) {
+      printError(`Use --force to confirm deleting trigger ${id}`);
+      throw new CLIError("Confirmation required", 1);
+    }
+    await apiDelete(`/triggers/${id}`);
+    printSuccess(`Trigger ${id} deleted.`);
+  }
+};
+var disableAllCommand = {
+  name: "disable-all",
+  description: "Disable all triggers for a repository",
+  options: {
+    repo: { type: "string", short: "r", description: "Repository ID" },
+    force: { type: "boolean", short: "f", description: "Skip confirmation", default: false }
+  },
+  handler: async (parsed) => {
+    const repo = parsed.values["repo"];
+    if (!repo) {
+      printError("Missing --repo");
+      throw new CLIError("Missing option", 1);
+    }
+    if (parsed.values["force"] !== true) {
+      printError(`Use --force to confirm disabling all triggers for repo ${repo}`);
+      throw new CLIError("Confirmation required", 1);
+    }
+    await apiPost(`/triggers/disable-all`, { body: { repo_id: repo } });
+    printSuccess(`All triggers disabled for repository ${repo}.`);
+  }
+};
+var triggersGroup = new CommandGroup("triggers", "Manage self-healing trigger rules");
+triggersGroup.command(registerCommand2).command(enablePresetCommand).command(listCommand9).command(showCommand11).command(historyCommand2).command(pauseCommand2).command(resumeCommand2).command(deleteCommand4).command(disableAllCommand);
+
+// src/client/sse.ts
+function parseSseLine(line) {
+  if (!line.startsWith("data: ")) return null;
+  const raw = line.slice(6).trim();
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function* streamSSE(path8) {
+  const client = new SynClient();
+  const body = await client.stream(path8);
+  const reader = body.pipeThrough(new TextDecoderStream()).getReader();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += value;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        const event = parseSseLine(trimmed);
+        if (event) yield event;
+      }
+    }
+    if (buffer.trim()) {
+      const event = parseSseLine(buffer.trim());
+      if (event) yield event;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/commands/watch.ts
+var EVENT_STYLES = {
+  WorkflowExecutionStarted: GREEN,
+  WorkflowCompleted: GREEN,
+  WorkflowFailed: RED,
+  PhaseStarted: CYAN,
+  PhaseCompleted: GREEN,
+  PhaseFailed: RED,
+  SessionTokensRecorded: DIM,
+  ExecutionPaused: YELLOW,
+  ExecutionResumed: GREEN,
+  ExecutionCancelled: RED
+};
+function extractEventId(data) {
+  return data["workflow_execution_id"] ?? data["execution_id"] ?? data["session_id"] ?? "";
+}
+function renderEventData(parts, data) {
+  const id = extractEventId(data);
+  if (id) parts.push(` ${style(id.slice(0, 12), DIM)}`);
+  if (data["workflow_name"]) parts.push(` ${String(data["workflow_name"])}`);
+  if (data["phase_name"]) parts.push(` phase:${String(data["phase_name"])}`);
+  if (data["total_tokens"]) parts.push(` tokens:${formatTokens(Number(data["total_tokens"]))}`);
+  if (data["cost_usd"]) parts.push(` cost:${formatCost(String(data["cost_usd"]))}`);
+  if (data["error_message"]) parts.push(` ${style(String(data["error_message"]).slice(0, 80), RED)}`);
+}
+function renderEvent(event) {
+  const ts = event.timestamp ? formatTimestamp(event.timestamp) : style("now", DIM);
+  const eventType = event.event_type ?? event.type ?? "unknown";
+  const eventStyle = EVENT_STYLES[eventType] ?? "";
+  const parts = [style(ts, DIM), " ", eventStyle ? style(eventType, eventStyle) : eventType];
+  if (event.data) {
+    renderEventData(parts, event.data);
+  }
+  print(parts.join(""));
+}
+var executionCommand = {
+  name: "execution",
+  description: "Stream live events for a specific execution",
+  args: [{ name: "execution-id", description: "Execution ID to watch", required: true }],
+  handler: async (parsed) => {
+    const id = parsed.positionals[0];
+    if (!id) {
+      printError("Missing execution-id");
+      throw new CLIError("Missing argument", 1);
+    }
+    print(style(`Watching execution ${id}...`, BOLD));
+    printDim("Press Ctrl+C to stop.\n");
+    try {
+      for await (const event of streamSSE(`/watch/executions/${id}`)) {
+        renderEvent(event);
+      }
+      print(style("\nStream ended.", DIM));
+    } catch (err) {
+      if (err instanceof CLIError) throw err;
+      if (err instanceof Error && err.name === "AbortError") return;
+      printError(`Stream error: ${err instanceof Error ? err.message : String(err)}`);
+      throw new CLIError("Stream failed", 1);
+    }
+  }
+};
+var activityCommand3 = {
+  name: "activity",
+  description: "Stream live global activity across all executions",
+  handler: async () => {
+    print(style("Watching global activity...", BOLD));
+    printDim("Press Ctrl+C to stop.\n");
+    try {
+      for await (const event of streamSSE("/watch/activity")) {
+        renderEvent(event);
+      }
+      print(style("\nStream ended.", DIM));
+    } catch (err) {
+      if (err instanceof CLIError) throw err;
+      if (err instanceof Error && err.name === "AbortError") return;
+      printError(`Stream error: ${err instanceof Error ? err.message : String(err)}`);
+      throw new CLIError("Stream failed", 1);
+    }
+  }
+};
+var watchGroup = new CommandGroup("watch", "Stream live execution events via SSE");
+watchGroup.command(executionCommand).command(activityCommand3);
+
+// src/framework/cli.ts
+import { parseArgs } from "util";
+
+// src/framework/help.ts
+function renderTopLevelHelp(name, description, groups, rootCommands) {
+  const lines = [];
+  lines.push(`${style(name, BOLD)} \u2014 ${description}`);
+  lines.push("");
+  lines.push(style("Usage:", BOLD) + `  ${name} <command> [options]`);
+  if (rootCommands.size > 0) {
+    lines.push("");
+    lines.push(style("Commands:", BOLD));
+    const maxLen = maxNameLength(rootCommands);
+    for (const [cmdName, cmd] of rootCommands) {
+      lines.push(
+        `  ${style(cmdName.padEnd(maxLen), CYAN)}  ${style(cmd.description, DIM)}`
+      );
+    }
+  }
+  if (groups.size > 0) {
+    lines.push("");
+    lines.push(style("Command Groups:", BOLD));
+    const maxLen = Math.max(...[...groups.values()].map((g) => g.name.length));
+    for (const group of groups.values()) {
+      lines.push(
+        `  ${style(group.name.padEnd(maxLen), CYAN)}  ${style(group.description, DIM)}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(
+    style(`Run '${name} <command> --help' for more information on a command.`, DIM)
+  );
+  return lines.join("\n");
+}
+function renderGroupHelp(name, group) {
+  const lines = [];
+  lines.push(`${style(name + " " + group.name, BOLD)} \u2014 ${group.description}`);
+  lines.push("");
+  lines.push(
+    style("Usage:", BOLD) + `  ${name} ${group.name} <command> [options]`
+  );
+  lines.push("");
+  lines.push(style("Commands:", BOLD));
+  const maxLen = maxNameLength(group.commands);
+  for (const [cmdName, cmd] of group.commands) {
+    lines.push(
+      `  ${style(cmdName.padEnd(maxLen), CYAN)}  ${style(cmd.description, DIM)}`
+    );
+  }
+  return lines.join("\n");
+}
+function renderCommandHelp(command, cliName, groupName) {
+  const lines = [];
+  const prefix = groupName ? `${cliName} ${groupName} ${command.name}` : `${cliName} ${command.name}`;
+  lines.push(`${style(prefix, BOLD)} \u2014 ${command.description}`);
+  lines.push("");
+  lines.push(style("Usage:", BOLD) + renderUsageLine(prefix, command));
+  if (command.args && command.args.length > 0) {
+    renderArguments(lines, command.args);
+  }
+  if (command.options) {
+    renderOptions(lines, command.options);
+  }
+  return lines.join("\n");
+}
+function renderUsageLine(prefix, command) {
+  let usage = `  ${prefix}`;
+  if (command.args) {
+    for (const arg of command.args) {
+      usage += arg.required !== false ? ` <${arg.name}>` : ` [${arg.name}]`;
+    }
+  }
+  if (command.options && Object.keys(command.options).length > 0) {
+    usage += " [options]";
+  }
+  return usage;
+}
+function renderArguments(lines, args) {
+  lines.push("");
+  lines.push(style("Arguments:", BOLD));
+  const maxLen = Math.max(...args.map((a) => a.name.length));
+  for (const arg of args) {
+    const req = arg.required !== false ? " (required)" : "";
+    lines.push(
+      `  ${style(arg.name.padEnd(maxLen), CYAN)}  ${arg.description}${style(req, DIM)}`
+    );
+  }
+}
+function renderOptions(lines, options) {
+  const entries = Object.entries(options);
+  if (entries.length === 0) return;
+  lines.push("");
+  lines.push(style("Options:", BOLD));
+  const formatted = entries.map(([name, opt]) => {
+    const flag = opt.short ? `-${opt.short}, --${name}` : `    --${name}`;
+    return { flag, opt };
+  });
+  const maxLen = Math.max(...formatted.map((f) => f.flag.length));
+  for (const { flag, opt } of formatted) {
+    const def = opt.default !== void 0 ? ` ${style(`(default: ${String(opt.default)})`, DIM)}` : "";
+    lines.push(`  ${style(flag.padEnd(maxLen), CYAN)}  ${opt.description}${def}`);
+  }
+}
+function maxNameLength(map) {
+  return Math.max(...[...map.values()].map((v) => v.name.length));
+}
+
+// src/framework/cli.ts
+var CLI = class {
+  name;
+  description;
+  version;
+  groups = /* @__PURE__ */ new Map();
+  rootCommands = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.name = options.name;
+    this.description = options.description;
+    this.version = options.version;
+  }
+  addGroup(group) {
+    this.groups.set(group.name, group);
+    return this;
+  }
+  addCommand(def) {
+    this.rootCommands.set(def.name, def);
+    return this;
+  }
+  async run(argv) {
+    const args = argv ?? process.argv.slice(2);
+    try {
+      await this.dispatch(args);
+    } catch (err) {
+      if (err instanceof CLIError) {
+        printError(err.message);
+        process.exit(err.exitCode);
+      }
+      printError(`Unexpected error: ${String(err)}`);
+      process.exit(2);
+    }
+  }
+  async dispatch(args) {
+    const first = args[0];
+    if (!first || first === "--help" || first === "-h") {
+      print(renderTopLevelHelp(this.name, this.description, this.groups, this.rootCommands));
+      process.exit(0);
+    }
+    if (first === "--version") {
+      print(`${this.name} v${this.version}`);
+      process.exit(0);
+    }
+    const rootCmd = this.rootCommands.get(first);
+    if (rootCmd) {
+      await this.executeCommand(rootCmd, args.slice(1));
+      return;
+    }
+    const group = this.groups.get(first);
+    if (group) {
+      await this.dispatchGroup(first, group, args.slice(1));
+      return;
+    }
+    throw new CLIError(`Unknown command: ${first}. Run '${this.name} --help' for usage.`);
+  }
+  async dispatchGroup(groupName, group, args) {
+    const second = args[0];
+    if (!second || second === "--help" || second === "-h") {
+      print(renderGroupHelp(this.name, group));
+      process.exit(0);
+    }
+    const cmd = group.getCommand(second);
+    if (!cmd) {
+      throw new CLIError(
+        `Unknown command: ${groupName} ${second}. Run '${this.name} ${groupName} --help' for usage.`
+      );
+    }
+    await this.executeCommand(cmd, args.slice(1), group.name);
+  }
+  async executeCommand(cmd, argv, groupName) {
+    const parsed = this.parseCommandArgs(cmd, argv);
+    if (parsed.values["help"]) {
+      print(renderCommandHelp(cmd, this.name, groupName));
+      process.exit(0);
+    }
+    await cmd.handler(parsed);
+  }
+  parseCommandArgs(cmd, argv) {
+    const optionsConfig = buildOptionsConfig(cmd);
+    try {
+      const { values, positionals } = parseArgs({
+        args: argv,
+        options: optionsConfig,
+        allowPositionals: true,
+        strict: true
+      });
+      return {
+        positionals,
+        values
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new CLIError(msg);
+    }
+  }
+};
+function buildOptionsConfig(cmd) {
+  const config = {
+    help: { type: "boolean", short: "h", default: false }
+  };
+  if (!cmd.options) return config;
+  for (const [name, def] of Object.entries(cmd.options)) {
+    const entry = {
+      type: def.type
+    };
+    if (def.short) entry.short = def.short;
+    if (def.multiple) entry.multiple = def.multiple;
+    if (def.default !== void 0) entry.default = def.default;
+    config[name] = entry;
+  }
+  return config;
+}
+
+// src/index.ts
+var cli = new CLI({
+  name: CLI_NAME,
+  description: CLI_DESCRIPTION,
+  version: CLI_VERSION
+});
+cli.addCommand(healthCommand);
+cli.addCommand(versionCommand);
+cli.addCommand({
+  ...runCommand,
+  description: "Execute a workflow (shortcut for 'syn workflow run')"
+});
+cli.addGroup(workflowGroup);
+cli.addGroup(marketplaceGroup);
+cli.addGroup(agentGroup);
+cli.addGroup(artifactsGroup);
+cli.addGroup(configGroup);
+cli.addGroup(controlGroup);
+cli.addGroup(conversationsGroup);
+cli.addGroup(costsGroup);
+cli.addGroup(eventsGroup);
+cli.addGroup(executionGroup);
+cli.addGroup(insightsGroup);
+cli.addGroup(metricsGroup);
+cli.addGroup(observeGroup);
+cli.addGroup(orgGroup);
+cli.addGroup(repoGroup);
+cli.addGroup(sessionsGroup);
+cli.addGroup(systemGroup);
+cli.addGroup(triggersGroup);
+cli.addGroup(watchGroup);
+cli.run();