@actant/cli 0.1.2

package/dist/chunk-2FKBVXMH.js

@@ -0,0 +1,2663 @@
+// src/program.ts
+import { Command as Command72 } from "commander";
+import { getDefaultIpcPath } from "@actant/shared";
+
+// src/client/rpc-client.ts
+import { createConnection } from "net";
+var requestId = 0;
+var RpcClient = class {
+  constructor(socketPath) {
+    this.socketPath = socketPath;
+  }
+  async call(method, params, options) {
+    const id = ++requestId;
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    };
+    const response = await this.send(request, options?.timeoutMs);
+    if (response.error) {
+      const err = new RpcCallError(response.error.message, response.error.code, response.error.data);
+      throw err;
+    }
+    return response.result;
+  }
+  async ping() {
+    try {
+      await this.call("daemon.ping", {});
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  send(request, timeoutMs) {
+    const effectiveTimeout = timeoutMs ?? (process.env["ACTANT_RPC_TIMEOUT_MS"] ? Number(process.env["ACTANT_RPC_TIMEOUT_MS"]) : 1e4);
+    return new Promise((resolve9, reject) => {
+      const socket = createConnection(this.socketPath, () => {
+        socket.write(JSON.stringify(request) + "\n");
+      });
+      let buffer = "";
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const response = JSON.parse(trimmed);
+            socket.end();
+            resolve9(response);
+            return;
+          } catch {
+          }
+        }
+      });
+      socket.on("error", (err) => {
+        reject(new ConnectionError(this.socketPath, err));
+      });
+      socket.setTimeout(effectiveTimeout, () => {
+        socket.destroy();
+        reject(new Error(`RPC call timed out after ${effectiveTimeout}ms`));
+      });
+    });
+  }
+};
+var RpcCallError = class extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "RpcCallError";
+  }
+};
+var ConnectionError = class extends Error {
+  constructor(socketPath, cause) {
+    super(`Cannot connect to daemon at ${socketPath}. Is it running? Start with: actant daemon start`);
+    this.socketPath = socketPath;
+    this.cause = cause;
+    this.name = "ConnectionError";
+  }
+};
+
+// src/commands/template/index.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/template/list.ts
+import { Command } from "commander";
+
+// src/output/formatter.ts
+import Table from "cli-table3";
+import chalk from "chalk";
+function formatTemplateList(templates, format) {
+  if (format === "json") {
+    return JSON.stringify(templates, null, 2);
+  }
+  if (format === "quiet") {
+    return templates.map((t) => t.name).join("\n");
+  }
+  if (templates.length === 0) {
+    return chalk.dim("No templates registered.");
+  }
+  const table = new Table({
+    head: [
+      chalk.cyan("Name"),
+      chalk.cyan("Version"),
+      chalk.cyan("Backend"),
+      chalk.cyan("Provider"),
+      chalk.cyan("Description")
+    ]
+  });
+  for (const t of templates) {
+    table.push([
+      t.name,
+      t.version,
+      t.backend.type,
+      t.provider.type,
+      t.description ?? chalk.dim("\u2014")
+    ]);
+  }
+  return table.toString();
+}
+function formatTemplateDetail(template, format) {
+  if (format === "json") {
+    return JSON.stringify(template, null, 2);
+  }
+  if (format === "quiet") {
+    return template.name;
+  }
+  const ctx = template.domainContext;
+  const lines = [
+    `${chalk.bold("Template:")} ${template.name}`,
+    `${chalk.bold("Version:")}  ${template.version}`,
+    `${chalk.bold("Backend:")}  ${template.backend.type}`,
+    `${chalk.bold("Provider:")} ${template.provider.type}`
+  ];
+  if (template.description) {
+    lines.push(`${chalk.bold("Desc:")}     ${template.description}`);
+  }
+  lines.push("");
+  lines.push(chalk.bold("Domain Context:"));
+  lines.push(`  Skills:      ${ctx.skills?.length ?? 0} ref(s)   ${(ctx.skills ?? []).join(", ") || chalk.dim("none")}`);
+  lines.push(`  Prompts:     ${ctx.prompts?.length ?? 0} ref(s)   ${(ctx.prompts ?? []).join(", ") || chalk.dim("none")}`);
+  lines.push(`  MCP Servers: ${ctx.mcpServers?.length ?? 0} ref(s)   ${(ctx.mcpServers ?? []).map((s) => s.name).join(", ") || chalk.dim("none")}`);
+  lines.push(`  Plugins:     ${ctx.plugins?.length ?? 0} ref(s)   ${(ctx.plugins ?? []).join(", ") || chalk.dim("none")}`);
+  lines.push(`  Workflow:    ${ctx.workflow ?? chalk.dim("none")}`);
+  lines.push(`  SubAgents:   ${(ctx.subAgents ?? []).join(", ") || chalk.dim("none")}`);
+  if (template.metadata && Object.keys(template.metadata).length > 0) {
+    lines.push("");
+    lines.push(chalk.bold("Metadata:"));
+    for (const [k, v] of Object.entries(template.metadata)) {
+      lines.push(`  ${k}: ${v}`);
+    }
+  }
+  return lines.join("\n");
+}
+var STATUS_COLORS = {
+  created: chalk.blue,
+  starting: chalk.yellow,
+  running: chalk.green,
+  stopping: chalk.yellow,
+  stopped: chalk.gray,
+  error: chalk.red
+};
+function colorStatus(status) {
+  const fn = STATUS_COLORS[status] ?? chalk.white;
+  return fn(status);
+}
+function formatAgentList(agents, format) {
+  if (format === "json") {
+    return JSON.stringify(agents, null, 2);
+  }
+  if (format === "quiet") {
+    return agents.map((a) => a.name).join("\n");
+  }
+  if (agents.length === 0) {
+    return chalk.dim("No agents found.");
+  }
+  const table = new Table({
+    head: [
+      chalk.cyan("Name"),
+      chalk.cyan("Template"),
+      chalk.cyan("Status"),
+      chalk.cyan("Launch Mode"),
+      chalk.cyan("PID"),
+      chalk.cyan("Created")
+    ]
+  });
+  for (const a of agents) {
+    table.push([
+      a.name,
+      `${a.templateName}@${a.templateVersion}`,
+      colorStatus(a.status),
+      a.launchMode,
+      a.pid?.toString() ?? chalk.dim("\u2014"),
+      a.createdAt.slice(0, 19).replace("T", " ")
+    ]);
+  }
+  return table.toString();
+}
+function formatAgentDetail(agent, format) {
+  if (format === "json") {
+    return JSON.stringify(agent, null, 2);
+  }
+  if (format === "quiet") {
+    return agent.name;
+  }
+  const lines = [
+    `${chalk.bold("Agent:")}     ${agent.name}`,
+    `${chalk.bold("ID:")}        ${agent.id}`,
+    `${chalk.bold("Template:")}  ${agent.templateName}@${agent.templateVersion}`,
+    `${chalk.bold("Status:")}    ${colorStatus(agent.status)}`,
+    `${chalk.bold("Launch:")}    ${agent.launchMode}`,
+    `${chalk.bold("PID:")}       ${agent.pid ?? chalk.dim("\u2014")}`,
+    `${chalk.bold("Created:")}   ${agent.createdAt}`,
+    `${chalk.bold("Updated:")}   ${agent.updatedAt}`
+  ];
+  if (agent.metadata && Object.keys(agent.metadata).length > 0) {
+    lines.push("");
+    lines.push(chalk.bold("Metadata:"));
+    for (const [k, v] of Object.entries(agent.metadata)) {
+      lines.push(`  ${k}: ${v}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatSkillList(skills, format) {
+  if (format === "json") return JSON.stringify(skills, null, 2);
+  if (format === "quiet") return skills.map((s) => s.name).join("\n");
+  if (skills.length === 0) return chalk.dim("No skills loaded.");
+  const table = new Table({
+    head: [chalk.cyan("Name"), chalk.cyan("Tags"), chalk.cyan("Description")]
+  });
+  for (const s of skills) {
+    table.push([
+      s.name,
+      s.tags?.join(", ") ?? chalk.dim("\u2014"),
+      s.description ?? chalk.dim("\u2014")
+    ]);
+  }
+  return table.toString();
+}
+function formatSkillDetail(skill, format) {
+  if (format === "json") return JSON.stringify(skill, null, 2);
+  if (format === "quiet") return skill.name;
+  const lines = [
+    `${chalk.bold("Skill:")}       ${skill.name}`,
+    ...skill.description ? [`${chalk.bold("Description:")} ${skill.description}`] : [],
+    ...skill.tags?.length ? [`${chalk.bold("Tags:")}        ${skill.tags.join(", ")}`] : [],
+    "",
+    chalk.bold("Content:"),
+    skill.content
+  ];
+  return lines.join("\n");
+}
+function formatPromptList(prompts, format) {
+  if (format === "json") return JSON.stringify(prompts, null, 2);
+  if (format === "quiet") return prompts.map((p) => p.name).join("\n");
+  if (prompts.length === 0) return chalk.dim("No prompts loaded.");
+  const table = new Table({
+    head: [chalk.cyan("Name"), chalk.cyan("Variables"), chalk.cyan("Description")]
+  });
+  for (const p of prompts) {
+    table.push([
+      p.name,
+      p.variables?.join(", ") ?? chalk.dim("\u2014"),
+      p.description ?? chalk.dim("\u2014")
+    ]);
+  }
+  return table.toString();
+}
+function formatPromptDetail(prompt, format) {
+  if (format === "json") return JSON.stringify(prompt, null, 2);
+  if (format === "quiet") return prompt.name;
+  const lines = [
+    `${chalk.bold("Prompt:")}      ${prompt.name}`,
+    ...prompt.description ? [`${chalk.bold("Description:")} ${prompt.description}`] : [],
+    ...prompt.variables?.length ? [`${chalk.bold("Variables:")}   ${prompt.variables.join(", ")}`] : [],
+    "",
+    chalk.bold("Content:"),
+    prompt.content
+  ];
+  return lines.join("\n");
+}
+function formatMcpList(servers, format) {
+  if (format === "json") return JSON.stringify(servers, null, 2);
+  if (format === "quiet") return servers.map((s) => s.name).join("\n");
+  if (servers.length === 0) return chalk.dim("No MCP servers loaded.");
+  const table = new Table({
+    head: [chalk.cyan("Name"), chalk.cyan("Command"), chalk.cyan("Description")]
+  });
+  for (const s of servers) {
+    const cmd = [s.command, ...s.args ?? []].join(" ");
+    table.push([
+      s.name,
+      cmd,
+      s.description ?? chalk.dim("\u2014")
+    ]);
+  }
+  return table.toString();
+}
+function formatMcpDetail(server, format) {
+  if (format === "json") return JSON.stringify(server, null, 2);
+  if (format === "quiet") return server.name;
+  const lines = [
+    `${chalk.bold("MCP Server:")}  ${server.name}`,
+    ...server.description ? [`${chalk.bold("Description:")} ${server.description}`] : [],
+    `${chalk.bold("Command:")}     ${server.command}`,
+    ...server.args?.length ? [`${chalk.bold("Args:")}        ${server.args.join(" ")}`] : []
+  ];
+  if (server.env && Object.keys(server.env).length > 0) {
+    lines.push("");
+    lines.push(chalk.bold("Environment:"));
+    for (const [k, v] of Object.entries(server.env)) {
+      lines.push(`  ${k}=${v}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatWorkflowList(workflows, format) {
+  if (format === "json") return JSON.stringify(workflows, null, 2);
+  if (format === "quiet") return workflows.map((w) => w.name).join("\n");
+  if (workflows.length === 0) return chalk.dim("No workflows loaded.");
+  const table = new Table({
+    head: [chalk.cyan("Name"), chalk.cyan("Description")]
+  });
+  for (const w of workflows) {
+    table.push([w.name, w.description ?? chalk.dim("\u2014")]);
+  }
+  return table.toString();
+}
+function formatWorkflowDetail(workflow, format) {
+  if (format === "json") return JSON.stringify(workflow, null, 2);
+  if (format === "quiet") return workflow.name;
+  const lines = [
+    `${chalk.bold("Workflow:")}    ${workflow.name}`,
+    ...workflow.description ? [`${chalk.bold("Description:")} ${workflow.description}`] : [],
+    "",
+    chalk.bold("Content:"),
+    workflow.content
+  ];
+  return lines.join("\n");
+}
+function formatPluginList(plugins, format) {
+  if (format === "json") return JSON.stringify(plugins, null, 2);
+  if (format === "quiet") return plugins.map((p) => p.name).join("\n");
+  if (plugins.length === 0) return chalk.dim("No plugins loaded.");
+  const table = new Table({
+    head: [chalk.cyan("Name"), chalk.cyan("Type"), chalk.cyan("Source"), chalk.cyan("Enabled"), chalk.cyan("Description")]
+  });
+  for (const p of plugins) {
+    table.push([
+      p.name,
+      p.type,
+      p.source ?? chalk.dim("\u2014"),
+      p.enabled !== false ? chalk.green("yes") : chalk.red("no"),
+      p.description ?? chalk.dim("\u2014")
+    ]);
+  }
+  return table.toString();
+}
+function formatPluginDetail(plugin, format) {
+  if (format === "json") return JSON.stringify(plugin, null, 2);
+  if (format === "quiet") return plugin.name;
+  const lines = [
+    `${chalk.bold("Plugin:")}      ${plugin.name}`,
+    ...plugin.description ? [`${chalk.bold("Description:")} ${plugin.description}`] : [],
+    `${chalk.bold("Type:")}        ${plugin.type}`,
+    ...plugin.source ? [`${chalk.bold("Source:")}      ${plugin.source}`] : [],
+    `${chalk.bold("Enabled:")}     ${plugin.enabled !== false ? chalk.green("yes") : chalk.red("no")}`
+  ];
+  if (plugin.config && Object.keys(plugin.config).length > 0) {
+    lines.push("");
+    lines.push(chalk.bold("Config:"));
+    for (const [k, v] of Object.entries(plugin.config)) {
+      lines.push(`  ${k}: ${JSON.stringify(v)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/output/error-presenter.ts
+import chalk3 from "chalk";
+import { ActantError } from "@actant/shared";
+
+// src/output/printer.ts
+import chalk2 from "chalk";
+var consoleOutput = {
+  log: (msg) => {
+    console.log(msg);
+  },
+  error: (msg) => {
+    console.error(msg);
+  }
+};
+var CliPrinter = class {
+  out;
+  constructor(output) {
+    this.out = output ?? consoleOutput;
+  }
+  log(text) {
+    this.out.log(text);
+  }
+  error(text) {
+    this.out.error(text);
+  }
+  success(text) {
+    this.out.log(chalk2.green(text));
+  }
+  warn(text) {
+    this.out.log(chalk2.yellow(text));
+  }
+  dim(text) {
+    this.out.log(chalk2.dim(text));
+  }
+  errorStyled(text) {
+    this.out.error(chalk2.red(text));
+  }
+  errorDim(text) {
+    this.out.error(chalk2.dim(text));
+  }
+};
+var defaultPrinter = new CliPrinter();
+
+// src/output/error-presenter.ts
+function presentError(err, printer = defaultPrinter) {
+  if (err instanceof ConnectionError) {
+    printer.errorStyled("Cannot connect to daemon.");
+    printer.errorDim("Start with: actant daemon start");
+    return;
+  }
+  if (err instanceof RpcCallError) {
+    printer.error(`${chalk3.red(`[RPC ${err.code}]`)} ${err.message}`);
+    if (err.data && typeof err.data === "object") {
+      const data = err.data;
+      if (data.context) {
+        printer.error(`${chalk3.dim("  Context:")} ${JSON.stringify(data.context)}`);
+      }
+    }
+    return;
+  }
+  if (err instanceof ActantError) {
+    printer.error(`${chalk3.red(`[${err.code}]`)} ${err.message}`);
+    if (err.context && Object.keys(err.context).length > 0) {
+      printer.error(`${chalk3.dim("  Context:")} ${JSON.stringify(err.context)}`);
+    }
+    return;
+  }
+  if (err instanceof Error) {
+    printer.error(`${chalk3.red("Error:")} ${err.message}`);
+  } else {
+    printer.error(`${chalk3.red("Error:")} ${String(err)}`);
+  }
+}
+
+// src/output/stream-renderer.ts
+import chalk4 from "chalk";
+async function renderStream(stream, options) {
+  const output = options?.output ?? process.stdout;
+  const showTools = options?.showTools ?? true;
+  const label = options?.agentLabel ?? "agent";
+  let started = false;
+  let collectedText = "";
+  for await (const chunk of stream) {
+    if (!started) {
+      output.write(chalk4.cyan(`${label}> `));
+      started = true;
+    }
+    switch (chunk.type) {
+      case "text":
+        output.write(chunk.content);
+        collectedText += chunk.content;
+        break;
+      case "tool_use":
+        if (showTools) {
+          output.write(chalk4.dim(`
+  ${chunk.content}
+`));
+        }
+        break;
+      case "result":
+        output.write(chunk.content);
+        collectedText += chunk.content;
+        break;
+      case "error":
+        output.write(chalk4.red(`
+[Error] ${chunk.content}
+`));
+        break;
+    }
+  }
+  if (started) {
+    output.write("\n\n");
+  }
+  return collectedText;
+}
+
+// src/commands/template/list.ts
+function createTemplateListCommand(client, printer = defaultPrinter) {
+  return new Command("list").alias("ls").description("List all registered templates").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (opts) => {
+    try {
+      const templates = await client.call("template.list", {});
+      printer.log(formatTemplateList(templates, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/template/show.ts
+import { Command as Command2 } from "commander";
+function createTemplateShowCommand(client, printer = defaultPrinter) {
+  return new Command2("show").description("Show template details").argument("<name>", "Template name").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (name, opts) => {
+    try {
+      const template = await client.call("template.get", { name });
+      printer.log(formatTemplateDetail(template, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/template/validate.ts
+import { resolve } from "path";
+import { Command as Command3 } from "commander";
+import chalk5 from "chalk";
+function createTemplateValidateCommand(client, printer = defaultPrinter) {
+  return new Command3("validate").description("Validate a template JSON file").argument("<file>", "Path to template JSON file").action(async (file) => {
+    try {
+      const result = await client.call("template.validate", { filePath: resolve(file) });
+      if (result.valid && result.template) {
+        printer.log(`${chalk5.green("Valid")} \u2014 ${result.template.name}@${result.template.version}`);
+        if (result.warnings?.length) {
+          printer.log(chalk5.yellow(`  ${result.warnings.length} warning(s):`));
+          for (const w of result.warnings) {
+            printer.log(chalk5.yellow(`  - ${w.path}: ${w.message}`));
+          }
+        }
+      } else {
+        printer.error(chalk5.red("Invalid template"));
+        if (result.errors) {
+          for (const e of result.errors) {
+            printer.errorDim(`  - ${e.path}: ${e.message}`);
+          }
+        }
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/template/load.ts
+import { resolve as resolve2 } from "path";
+import { Command as Command4 } from "commander";
+import chalk6 from "chalk";
+function createTemplateLoadCommand(client, printer = defaultPrinter) {
+  return new Command4("load").description("Load a template from a JSON file into the registry").argument("<file>", "Path to template JSON file").action(async (file) => {
+    try {
+      const template = await client.call("template.load", { filePath: resolve2(file) });
+      printer.log(`${chalk6.green("Loaded")} ${template.name}@${template.version}`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/template/install.ts
+import { Command as Command5 } from "commander";
+function createTemplateInstallCommand(_client, printer = defaultPrinter) {
+  return new Command5("install").description("Install a template from a source (source@name)").argument("<spec>", "Source and template name, e.g. my-source@my-template").action(async (spec) => {
+    try {
+      const at = spec.indexOf("@");
+      if (at < 0) {
+        printer.error("Expected format: <source>@<name>");
+        process.exitCode = 1;
+        return;
+      }
+      const source = spec.slice(0, at);
+      printer.log(
+        `Template install not yet implemented via RPC - use "actant source sync ${source}" to sync templates from the source.`
+      );
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/template/index.ts
+function createTemplateCommand(client, printer) {
+  const cmd = new Command6("template").alias("tpl").description("Manage agent templates");
+  cmd.addCommand(createTemplateListCommand(client, printer));
+  cmd.addCommand(createTemplateShowCommand(client, printer));
+  cmd.addCommand(createTemplateValidateCommand(client, printer));
+  cmd.addCommand(createTemplateLoadCommand(client, printer));
+  cmd.addCommand(createTemplateInstallCommand(client, printer));
+  return cmd;
+}
+
+// src/commands/agent/index.ts
+import { Command as Command23 } from "commander";
+
+// src/commands/agent/create.ts
+import { existsSync } from "fs";
+import { resolve as resolve3 } from "path";
+import { createInterface } from "readline";
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+var VALID_LAUNCH_MODES = /* @__PURE__ */ new Set(["direct", "acp-background", "acp-service", "one-shot"]);
+function askQuestion(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((res) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      res(answer.trim().toLowerCase());
+    });
+  });
+}
+function createAgentCreateCommand(client, printer = defaultPrinter) {
+  return new Command7("create").description("Create a new agent from a template").argument("<name>", "Agent instance name").requiredOption("-t, --template <template>", "Template name to use").option("--launch-mode <mode>", "Launch mode: direct, acp-background, acp-service, one-shot").option("--work-dir <path>", "Custom workspace directory (absolute or relative path)").option("--workspace <path>", "Same as --work-dir: create instance at external path instead of builtin location").option("--overwrite", "If work-dir exists, remove it and recreate").option("--append", "If work-dir exists, add agent files into it").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (name, opts) => {
+    try {
+      if (opts.launchMode && !VALID_LAUNCH_MODES.has(opts.launchMode)) {
+        printer.error(`${chalk7.red(`Invalid launch mode: ${opts.launchMode}`)}`);
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.overwrite && opts.append) {
+        printer.error(`${chalk7.red("Cannot use both --overwrite and --append")}`);
+        process.exitCode = 1;
+        return;
+      }
+      let workDirConflict;
+      const workDirPath = opts.workspace ?? opts.workDir;
+      const workDir = workDirPath ? resolve3(workDirPath) : void 0;
+      if (workDir && existsSync(workDir)) {
+        if (opts.overwrite) {
+          workDirConflict = "overwrite";
+        } else if (opts.append) {
+          workDirConflict = "append";
+        } else {
+          printer.warn(`Directory already exists: ${workDir}`);
+          const answer = await askQuestion(
+            `  ${chalk7.yellow("(o)")}verwrite / ${chalk7.cyan("(a)")}ppend / ${chalk7.dim("(c)")}ancel? `
+          );
+          if (answer === "o" || answer === "overwrite") {
+            workDirConflict = "overwrite";
+          } else if (answer === "a" || answer === "append") {
+            workDirConflict = "append";
+          } else {
+            printer.log("Cancelled.");
+            return;
+          }
+        }
+      }
+      const overrides = {};
+      if (opts.launchMode) overrides.launchMode = opts.launchMode;
+      if (workDir) overrides.workDir = workDir;
+      if (workDirConflict) overrides.workDirConflict = workDirConflict;
+      const meta = await client.call("agent.create", {
+        name,
+        template: opts.template,
+        overrides: Object.keys(overrides).length > 0 ? overrides : void 0
+      });
+      printer.log(`${chalk7.green("Agent created successfully.")}
+`);
+      printer.log(formatAgentDetail(meta, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/start.ts
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+function createAgentStartCommand(client, printer = defaultPrinter) {
+  return new Command8("start").description("Start an agent").argument("<name>", "Agent name").action(async (name) => {
+    try {
+      await client.call("agent.start", { name });
+      printer.log(`${chalk8.green("Started")} ${name}`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/stop.ts
+import { Command as Command9 } from "commander";
+import chalk9 from "chalk";
+function createAgentStopCommand(client, printer = defaultPrinter) {
+  return new Command9("stop").description("Stop a running agent").argument("<name>", "Agent name").action(async (name) => {
+    try {
+      await client.call("agent.stop", { name });
+      printer.log(`${chalk9.green("Stopped")} ${name}`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/status.ts
+import { Command as Command10 } from "commander";
+function createAgentStatusCommand(client, printer = defaultPrinter) {
+  return new Command10("status").description("Show agent status (all agents if no name given)").argument("[name]", "Agent name (optional)").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (name, opts) => {
+    try {
+      if (name) {
+        const agent = await client.call("agent.status", { name });
+        printer.log(formatAgentDetail(agent, opts.format));
+      } else {
+        const agents = await client.call("agent.list", {});
+        printer.log(formatAgentList(agents, opts.format));
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/list.ts
+import { Command as Command11 } from "commander";
+function createAgentListCommand(client, printer = defaultPrinter) {
+  return new Command11("list").alias("ls").description("List all agents").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (opts) => {
+    try {
+      const agents = await client.call("agent.list", {});
+      printer.log(formatAgentList(agents, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/adopt.ts
+import chalk10 from "chalk";
+import { Command as Command12 } from "commander";
+function formatAdoptResult(result, format) {
+  if (format === "json") {
+    return JSON.stringify(result, null, 2);
+  }
+  if (format === "quiet") {
+    return result.name;
+  }
+  const lines = [
+    chalk10.green("Agent adopted successfully."),
+    "",
+    `${chalk10.bold("Name:")}          ${result.name}`,
+    `${chalk10.bold("Template:")}      ${result.template}`,
+    `${chalk10.bold("Workspace:")}     ${result.workspacePath}`,
+    `${chalk10.bold("Location:")}      ${result.location}`,
+    `${chalk10.bold("Status:")}        ${result.status}`,
+    `${chalk10.bold("Created:")}       ${result.createdAt}`
+  ];
+  return lines.join("\n");
+}
+function createAgentAdoptCommand(client, printer = defaultPrinter) {
+  return new Command12("adopt").description("Adopt an existing agent workspace into the instance registry").argument("<path>", "Path to the agent workspace directory (contains .actant.json)").option("--rename <name>", "Register with a different name than in .actant.json").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (path, opts) => {
+    try {
+      const result = await client.call("agent.adopt", {
+        path,
+        rename: opts.rename
+      });
+      printer.log(formatAdoptResult(result, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/destroy.ts
+import { Command as Command13 } from "commander";
+import chalk11 from "chalk";
+function createAgentDestroyCommand(client, printer = defaultPrinter) {
+  return new Command13("destroy").alias("rm").description("Destroy an agent (removes workspace directory)").argument("<name>", "Agent name").option("--force", "Skip confirmation", false).action(async (name, opts) => {
+    if (!opts.force) {
+      printer.warn(`Destroying agent "${name}" will remove its entire workspace.`);
+      printer.warn("Use --force to skip this warning.");
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      await client.call("agent.destroy", { name });
+      printer.log(`${chalk11.green("Destroyed")} ${name}`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/resolve.ts
+import { Command as Command14 } from "commander";
+import chalk12 from "chalk";
+function createAgentResolveCommand(client, printer = defaultPrinter) {
+  return new Command14("resolve").description("Resolve spawn info for an agent (external spawn support)").argument("<name>", "Agent instance name").option("-t, --template <template>", "Template name (auto-creates instance if not found)").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (name, opts) => {
+    try {
+      const result = await client.call("agent.resolve", {
+        name,
+        template: opts.template
+      });
+      if (opts.format === "json") {
+        printer.log(JSON.stringify(result, null, 2));
+      } else if (opts.format === "quiet") {
+        printer.log([result.command, ...result.args].join(" "));
+      } else {
+        if (result.created) {
+          printer.log(`${chalk12.green("Instance created.")}
+`);
+        }
+        printer.log(`${chalk12.bold("Instance:")}  ${result.instanceName}`);
+        printer.log(`${chalk12.bold("Backend:")}   ${result.backendType}`);
+        printer.log(`${chalk12.bold("Workspace:")} ${result.workspaceDir}`);
+        printer.log(`${chalk12.bold("Command:")}   ${result.command}`);
+        printer.log(`${chalk12.bold("Args:")}      ${result.args.join(" ")}`);
+        if (result.env && Object.keys(result.env).length > 0) {
+          printer.log(chalk12.bold("Env:"));
+          for (const [k, v] of Object.entries(result.env)) {
+            printer.log(`  ${k}=${v}`);
+          }
+        }
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/attach.ts
+import { Command as Command15 } from "commander";
+import chalk13 from "chalk";
+function createAgentAttachCommand(client, printer = defaultPrinter) {
+  return new Command15("attach").description("Attach an externally-spawned process to an agent").argument("<name>", "Agent instance name").requiredOption("--pid <pid>", "Process ID of the externally-spawned agent").option("--metadata <json>", "Additional metadata as JSON object").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (name, opts) => {
+    try {
+      const pid = parseInt(opts.pid, 10);
+      if (isNaN(pid) || pid <= 0) {
+        printer.error(chalk13.red("Invalid PID: must be a positive integer"));
+        process.exitCode = 1;
+        return;
+      }
+      let metadata;
+      if (opts.metadata) {
+        try {
+          metadata = JSON.parse(opts.metadata);
+        } catch {
+          printer.error(chalk13.red("Invalid --metadata: must be valid JSON"));
+          process.exitCode = 1;
+          return;
+        }
+      }
+      const meta = await client.call("agent.attach", { name, pid, metadata });
+      printer.log(`${chalk13.green("Process attached.")}
+`);
+      printer.log(formatAgentDetail(meta, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/detach.ts
+import { Command as Command16 } from "commander";
+function createAgentDetachCommand(client, printer = defaultPrinter) {
+  return new Command16("detach").description("Detach an externally-managed process from an agent").argument("<name>", "Agent instance name").option("--cleanup", "Clean up ephemeral workspace after detach").action(async (name, opts) => {
+    try {
+      const result = await client.call("agent.detach", {
+        name,
+        cleanup: opts.cleanup
+      });
+      printer.success("Process detached.");
+      if (result.workspaceCleaned) {
+        printer.dim("Ephemeral workspace cleaned up.");
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/run.ts
+import { Command as Command17 } from "commander";
+function createAgentRunCommand(client, printer = defaultPrinter) {
+  return new Command17("run").description("Send a prompt to an agent and get the response").argument("<name>", "Agent name").requiredOption("--prompt <prompt>", "The prompt to send").option("--model <model>", "Model to use (e.g. sonnet, opus)").option("--max-turns <turns>", "Maximum agentic turns", parseInt).option("--timeout <ms>", "Timeout in milliseconds", parseInt).option("--session-id <id>", "Resume a specific session").option("-f, --format <format>", "Output format: text, json", "text").action(async (name, opts) => {
+    try {
+      const rpcTimeout = (opts.timeout ?? 3e5) + 5e3;
+      const result = await client.call("agent.run", {
+        name,
+        prompt: opts.prompt,
+        options: {
+          model: opts.model,
+          maxTurns: opts.maxTurns,
+          timeoutMs: opts.timeout,
+          sessionId: opts.sessionId
+        }
+      }, { timeoutMs: rpcTimeout });
+      if (opts.format === "json") {
+        printer.log(JSON.stringify(result, null, 2));
+      } else {
+        printer.log(result.text);
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/prompt.ts
+import { Command as Command18 } from "commander";
+function createAgentPromptCommand(client, printer = defaultPrinter) {
+  return new Command18("prompt").description("Send a message to a running agent's ACP session").argument("<name>", "Agent name (must be started with `agent start`)").requiredOption("-m, --message <message>", "The message to send").option("--session-id <id>", "Specific ACP session ID (uses primary session if omitted)").option("-f, --format <format>", "Output format: text, json", "text").action(async (name, opts) => {
+    try {
+      const result = await client.call("agent.prompt", {
+        name,
+        message: opts.message,
+        sessionId: opts.sessionId
+      });
+      if (opts.format === "json") {
+        printer.log(JSON.stringify(result, null, 2));
+      } else {
+        printer.log(result.response);
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/chat.ts
+import { createInterface as createInterface2 } from "readline";
+import { Command as Command19 } from "commander";
+import chalk14 from "chalk";
+import { AcpConnection } from "@actant/acp";
+function createAgentChatCommand(client, printer = defaultPrinter) {
+  return new Command19("chat").description("Start an interactive chat session with an agent").argument("<name>", "Agent name").option("-t, --template <template>", "Template name (auto-creates instance if not found)").action(async (name, opts) => {
+    try {
+      await runChat(client, name, opts, printer);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+async function runChat(client, name, opts, printer) {
+  const alive = await client.ping();
+  if (!alive) {
+    printer.error("Daemon is not running. Start it with: actant daemon start");
+    process.exitCode = 1;
+    return;
+  }
+  let daemonManaged = false;
+  try {
+    const status = await client.call("agent.status", { name });
+    if (status.status === "running") {
+      daemonManaged = true;
+    }
+  } catch {
+  }
+  if (daemonManaged) {
+    await runDaemonChat(client, name, printer);
+  } else {
+    await runDirectBridgeChat(client, name, opts, printer);
+  }
+}
+async function runDaemonChat(client, name, printer) {
+  const meta = await client.call("agent.status", { name });
+  printer.log(
+    chalk14.bold(`Chat with ${meta.name}`) + chalk14.dim(` (${meta.templateName}@${meta.templateVersion}) [daemon-managed]`)
+  );
+  printer.log(chalk14.dim('Type your message and press Enter. Use "exit" or Ctrl+C to quit.\n'));
+  const rl = createReadline();
+  rl.prompt();
+  let sessionId;
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed === "exit" || trimmed === "quit") {
+      rl.close();
+      return;
+    }
+    try {
+      process.stdout.write(chalk14.cyan("agent> "));
+      const result = await client.call("agent.prompt", {
+        name,
+        message: trimmed,
+        sessionId
+      }, { timeoutMs: 305e3 });
+      process.stdout.write(result.response + "\n\n");
+      sessionId = result.sessionId;
+    } catch (err) {
+      presentError(err, printer);
+    }
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    process.stdout.write(chalk14.dim("\nChat ended.\n"));
+  });
+  return new Promise((resolve9) => {
+    rl.on("close", resolve9);
+  });
+}
+async function runDirectBridgeChat(client, name, opts, printer) {
+  const resolved = await client.call("agent.resolve", {
+    name,
+    template: opts.template
+  });
+  const conn = new AcpConnection({ autoApprove: true });
+  let session = null;
+  let attached = false;
+  const cleanup = async () => {
+    await conn.close();
+    if (attached) {
+      try {
+        await client.call("agent.detach", { name: resolved.instanceName, cleanup: false });
+      } catch {
+      }
+    }
+  };
+  try {
+    await conn.spawn(resolved.command, resolved.args, resolved.workspaceDir);
+    await client.call("agent.attach", {
+      name: resolved.instanceName,
+      pid: process.pid,
+      // register for lifecycle tracking
+      metadata: { proxyMode: "direct-bridge-chat" }
+    });
+    attached = true;
+    const initResult = await conn.initialize();
+    const agentName = initResult.agentInfo?.name ?? name;
+    session = await conn.newSession(resolved.workspaceDir);
+    printer.log(
+      chalk14.bold(`Chat with ${agentName}`) + chalk14.dim(` (direct bridge, session ${session.sessionId.slice(0, 8)}...)`)
+    );
+    printer.log(chalk14.dim('Type your message and press Enter. Use "exit" or Ctrl+C to quit.\n'));
+    const rl = createReadline();
+    process.on("SIGINT", () => {
+      if (session) {
+        conn.cancel(session.sessionId).catch(() => {
+        });
+      }
+      rl.close();
+    });
+    rl.prompt();
+    const activeSession = session;
+    rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        rl.prompt();
+        return;
+      }
+      if (trimmed === "exit" || trimmed === "quit") {
+        rl.close();
+        return;
+      }
+      try {
+        const chunkStream = mapNotificationsToChunks(
+          conn.streamPrompt(activeSession.sessionId, trimmed)
+        );
+        await renderStream(chunkStream, { agentLabel: agentName });
+      } catch (err) {
+        presentError(err, printer);
+      }
+      rl.prompt();
+    });
+    rl.on("close", () => {
+      process.stdout.write(chalk14.dim("\nChat ended.\n"));
+    });
+    await new Promise((resolve9) => {
+      rl.on("close", resolve9);
+    });
+  } finally {
+    await cleanup();
+  }
+}
+function createReadline() {
+  return createInterface2({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk14.green("you> "),
+    terminal: process.stdin.isTTY ?? false
+  });
+}
+async function* mapNotificationsToChunks(notifications) {
+  for await (const notification of notifications) {
+    const chunk = notificationToChunk(notification);
+    if (chunk) yield chunk;
+  }
+}
+function notificationToChunk(notification) {
+  const update = notification.update;
+  switch (update.sessionUpdate) {
+    case "agent_message_chunk":
+      if (update.content.type === "text") {
+        return { type: "text", content: update.content.text };
+      }
+      return null;
+    case "tool_call":
+      return {
+        type: "tool_use",
+        content: `[Tool: ${update.title ?? "unknown"}] ${update.toolCallId}`
+      };
+    case "tool_call_update":
+      if (update.status === "completed" && update.content) {
+        const textParts = [];
+        for (const item of update.content) {
+          if (item.type === "content" && item.content.type === "text") {
+            textParts.push(item.content.text);
+          }
+        }
+        if (textParts.length > 0) {
+          return { type: "text", content: textParts.join("") };
+        }
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+
+// src/commands/agent/dispatch.ts
+import { Command as Command20 } from "commander";
+function createAgentDispatchCommand(client, printer = defaultPrinter) {
+  return new Command20("dispatch").description("Queue a one-off task for an agent's scheduler").argument("<name>", "Agent name").requiredOption("-m, --message <message>", "The prompt/message to dispatch").option("-p, --priority <priority>", "Task priority: low, normal, high, critical", "normal").action(async (name, opts) => {
+    try {
+      const result = await client.call("agent.dispatch", {
+        name,
+        prompt: opts.message,
+        priority: opts.priority
+      });
+      if (result.queued) {
+        printer.log("Task queued.");
+      } else {
+        printer.dim(`No scheduler for agent "${name}". Task not queued.`);
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/tasks.ts
+import { Command as Command21 } from "commander";
+function createAgentTasksCommand(client, printer = defaultPrinter) {
+  return new Command21("tasks").description("List queued tasks for an agent's scheduler").argument("<name>", "Agent name").option("-f, --format <format>", "Output format: table, json", "table").action(async (name, opts) => {
+    try {
+      const result = await client.call("agent.tasks", { name });
+      if (opts.format === "json") {
+        printer.log(JSON.stringify(result, null, 2));
+      } else {
+        printer.log(`Queued: ${result.queued}  Processing: ${result.processing}`);
+        if (result.tasks.length > 0) {
+          for (const t of result.tasks) {
+            const promptPreview = (t.prompt ?? "").length > 40 ? `${(t.prompt ?? "").slice(0, 40)}...` : t.prompt ?? "";
+            printer.log(`  ${t.id?.slice(0, 8) ?? "?"}  ${t.priority}  ${t.source}  ${promptPreview}`);
+          }
+        }
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/logs.ts
+import { Command as Command22 } from "commander";
+function createAgentLogsCommand(client, printer = defaultPrinter) {
+  return new Command22("logs").description("Show execution logs for an agent's scheduler").argument("<name>", "Agent name").option("--limit <n>", "Maximum number of records to show", parseInt, 20).option("-f, --format <format>", "Output format: table, json", "table").action(async (name, opts) => {
+    try {
+      const result = await client.call("agent.logs", { name, limit: opts.limit });
+      if (opts.format === "json") {
+        printer.log(JSON.stringify(result, null, 2));
+      } else {
+        const records = result;
+        if (records.length === 0) {
+          printer.dim("No execution logs.");
+        } else {
+          for (const r of records) {
+            const dur = r.durationMs != null ? ` ${r.durationMs}ms` : "";
+            const err = r.error ? `  error: ${r.error}` : "";
+            printer.log(`  ${r.taskId?.slice(0, 8) ?? "?"}  ${r.status}  ${r.source}  ${r.startedAt}${dur}${err}`);
+          }
+        }
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent/index.ts
+function createAgentCommand(client, printer) {
+  const cmd = new Command23("agent").description("Manage agent instances");
+  cmd.addCommand(createAgentCreateCommand(client, printer));
+  cmd.addCommand(createAgentStartCommand(client, printer));
+  cmd.addCommand(createAgentStopCommand(client, printer));
+  cmd.addCommand(createAgentStatusCommand(client, printer));
+  cmd.addCommand(createAgentListCommand(client, printer));
+  cmd.addCommand(createAgentAdoptCommand(client, printer));
+  cmd.addCommand(createAgentDestroyCommand(client, printer));
+  cmd.addCommand(createAgentResolveCommand(client, printer));
+  cmd.addCommand(createAgentAttachCommand(client, printer));
+  cmd.addCommand(createAgentDetachCommand(client, printer));
+  cmd.addCommand(createAgentRunCommand(client, printer));
+  cmd.addCommand(createAgentPromptCommand(client, printer));
+  cmd.addCommand(createAgentChatCommand(client, printer));
+  cmd.addCommand(createAgentDispatchCommand(client, printer));
+  cmd.addCommand(createAgentTasksCommand(client, printer));
+  cmd.addCommand(createAgentLogsCommand(client, printer));
+  return cmd;
+}
+
+// src/commands/help.ts
+import { Command as Command24 } from "commander";
+import chalk15 from "chalk";
+
+// package.json
+var package_default = {
+  name: "@actant/cli",
+  version: "0.1.2",
+  description: "CLI for the Actant AI agent platform \u2014 build, manage, and compose AI agents",
+  type: "module",
+  license: "MIT",
+  author: "blackplume <blackplume233@gmail.com>",
+  repository: {
+    type: "git",
+    url: "https://github.com/blackplume233/Actant.git",
+    directory: "packages/cli"
+  },
+  homepage: "https://github.com/blackplume233/Actant#readme",
+  bugs: "https://github.com/blackplume233/Actant/issues",
+  keywords: ["actant", "ai-agent", "cli", "agent-platform"],
+  publishConfig: {
+    access: "public"
+  },
+  files: ["dist", "scripts/postinstall.mjs"],
+  bin: {
+    actant: "./dist/bin/actant.js"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsx src/index.ts",
+    "type-check": "tsc --noEmit",
+    test: "vitest run",
+    clean: "rimraf dist",
+    postinstall: "node scripts/postinstall.mjs",
+    prepublishOnly: "tsup"
+  },
+  dependencies: {
+    "@actant/acp": "workspace:*",
+    "@actant/api": "workspace:*",
+    "@actant/core": "workspace:*",
+    "@actant/shared": "workspace:*",
+    chalk: "^5.6.2",
+    "cli-table3": "^0.6.5",
+    commander: "^14.0.3"
+  }
+};
+
+// src/commands/help.ts
+function showOverview() {
+  const version = package_default.version ?? "0.1.0";
+  const lines = [
+    "",
+    chalk15.bold("  Actant \u2014 Build, manage, and compose AI agents"),
+    chalk15.gray(`  v${version}`),
+    "",
+    chalk15.bold("  Quick Start:"),
+    `    ${chalk15.cyan("actant daemon start")}              Start the daemon`,
+    `    ${chalk15.cyan("actant agent create my-agent")}     Create an Agent`,
+    `    ${chalk15.cyan("actant agent start my-agent")}      Start an Agent`,
+    `    ${chalk15.cyan("actant agent chat my-agent")}      Chat with an Agent`,
+    "",
+    chalk15.bold("  Agent Management:"),
+    `    ${chalk15.cyan("agent")} create|start|stop|list|chat|run    Agent lifecycle`,
+    `    ${chalk15.cyan("agent adopt")} <path>                       Adopt existing workspace`,
+    `    ${chalk15.cyan("template")} list|show                       Agent templates`,
+    `    ${chalk15.cyan("proxy")} <name>                             ACP proxy forwarding`,
+    "",
+    chalk15.bold("  Component Management:"),
+    `    ${chalk15.cyan("skill")} list|add|remove|show       Manage skills`,
+    `    ${chalk15.cyan("prompt")} list|add|remove|show      Manage prompts`,
+    `    ${chalk15.cyan("mcp")} list|show                    Manage MCP server configs`,
+    `    ${chalk15.cyan("workflow")} list|show               Manage workflows`,
+    `    ${chalk15.cyan("plugin")} list|add|remove|show     Manage plugins`,
+    "",
+    chalk15.bold("  Ecosystem:"),
+    `    ${chalk15.cyan("source")} list|add|remove|sync      Manage component sources`,
+    `    ${chalk15.cyan("preset")} list|apply                Manage preset packs`,
+    "",
+    chalk15.bold("  Scheduling:"),
+    `    ${chalk15.cyan("schedule")} list                    Manage employee agent scheduling`,
+    "",
+    chalk15.bold("  System:"),
+    `    ${chalk15.cyan("daemon")} start|stop|status         Daemon management`,
+    `    ${chalk15.cyan("help")} [command]                   Show help`,
+    `    ${chalk15.cyan("--version")}                        Show version`,
+    "",
+    chalk15.bold("  Tips:"),
+    chalk15.gray("    Use 'actant help <command>' for detailed help on a command"),
+    ""
+  ];
+  process.stdout.write(lines.join("\n"));
+}
+function showCommandHelp(program, commandName) {
+  const subcmd = program.commands.find((c) => c.name() === commandName);
+  if (subcmd) {
+    subcmd.outputHelp();
+  } else {
+    process.stdout.write(
+      chalk15.red(`Unknown command: ${commandName}
+`) + chalk15.gray("Run 'actant help' to see available commands.\n")
+    );
+  }
+}
+function createHelpCommand() {
+  return new Command24("help").argument("[command]", "Command to get help for").description("Show help information").action(function(command) {
+    const program = this.parent;
+    if (command) {
+      showCommandHelp(program, command);
+    } else {
+      showOverview();
+    }
+  });
+}
+
+// src/commands/skill/index.ts
+import { Command as Command30 } from "commander";
+
+// src/commands/skill/list.ts
+import { Command as Command25 } from "commander";
+function createSkillListCommand(client, printer = defaultPrinter) {
+  return new Command25("list").alias("ls").description("List all loaded skills").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (opts) => {
+    try {
+      const skills = await client.call("skill.list", {});
+      printer.log(formatSkillList(skills, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/skill/show.ts
+import { Command as Command26 } from "commander";
+function createSkillShowCommand(client, printer = defaultPrinter) {
+  return new Command26("show").description("Show skill details").argument("<name>", "Skill name").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (name, opts) => {
+    try {
+      const skill = await client.call("skill.get", { name });
+      printer.log(formatSkillDetail(skill, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/skill/add.ts
+import { readFile } from "fs/promises";
+import { resolve as resolve4 } from "path";
+import { Command as Command27 } from "commander";
+function createSkillAddCommand(client, printer = defaultPrinter) {
+  return new Command27("add").description("Add a skill from a JSON file").argument("<file>", "Path to skill definition JSON file").action(async (file) => {
+    try {
+      const raw = await readFile(resolve4(file), "utf-8");
+      const component = JSON.parse(raw);
+      const result = await client.call("skill.add", { component });
+      printer.success(`Skill "${result.name}" added successfully.`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/skill/remove.ts
+import { Command as Command28 } from "commander";
+function createSkillRemoveCommand(client, printer = defaultPrinter) {
+  return new Command28("remove").alias("rm").description("Remove a loaded skill").argument("<name>", "Skill name").action(async (name) => {
+    try {
+      const result = await client.call("skill.remove", { name });
+      if (result.success) {
+        printer.success(`Skill "${name}" removed.`);
+      } else {
+        printer.warn(`Skill "${name}" not found.`);
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/skill/export.ts
+import { Command as Command29 } from "commander";
+function createSkillExportCommand(client, printer = defaultPrinter) {
+  return new Command29("export").description("Export a skill to a JSON file").argument("<name>", "Skill name").option("-o, --out <file>", "Output file path", "./{name}.json").action(async (name, opts) => {
+    try {
+      const outPath = opts.out.replace("{name}", name);
+      await client.call("skill.export", { name, filePath: outPath });
+      printer.success(`Skill "${name}" exported to ${outPath}`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/skill/index.ts
+function createSkillCommand(client, printer) {
+  const cmd = new Command30("skill").description("Manage loaded skills");
+  cmd.addCommand(createSkillListCommand(client, printer));
+  cmd.addCommand(createSkillShowCommand(client, printer));
+  cmd.addCommand(createSkillAddCommand(client, printer));
+  cmd.addCommand(createSkillRemoveCommand(client, printer));
+  cmd.addCommand(createSkillExportCommand(client, printer));
+  return cmd;
+}
+
+// src/commands/prompt/index.ts
+import { Command as Command36 } from "commander";
+
+// src/commands/prompt/list.ts
+import { Command as Command31 } from "commander";
+function createPromptListCommand(client, printer = defaultPrinter) {
+  return new Command31("list").alias("ls").description("List all loaded prompts").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (opts) => {
+    try {
+      const prompts = await client.call("prompt.list", {});
+      printer.log(formatPromptList(prompts, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/prompt/show.ts
+import { Command as Command32 } from "commander";
+function createPromptShowCommand(client, printer = defaultPrinter) {
+  return new Command32("show").description("Show prompt details").argument("<name>", "Prompt name").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (name, opts) => {
+    try {
+      const prompt = await client.call("prompt.get", { name });
+      printer.log(formatPromptDetail(prompt, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/prompt/add.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+import { Command as Command33 } from "commander";
+function createPromptAddCommand(client, printer = defaultPrinter) {
+  return new Command33("add").description("Add a prompt from a JSON file").argument("<file>", "Path to prompt definition JSON file").action(async (file) => {
+    try {
+      const raw = await readFile2(resolve5(file), "utf-8");
+      const component = JSON.parse(raw);
+      const result = await client.call("prompt.add", { component });
+      printer.success(`Prompt "${result.name}" added successfully.`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/prompt/remove.ts
+import { Command as Command34 } from "commander";
+function createPromptRemoveCommand(client, printer = defaultPrinter) {
+  return new Command34("remove").alias("rm").description("Remove a loaded prompt").argument("<name>", "Prompt name").action(async (name) => {
+    try {
+      const result = await client.call("prompt.remove", { name });
+      if (result.success) {
+        printer.success(`Prompt "${name}" removed.`);
+      } else {
+        printer.warn(`Prompt "${name}" not found.`);
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/prompt/export.ts
+import { Command as Command35 } from "commander";
+function createPromptExportCommand(client, printer = defaultPrinter) {
+  return new Command35("export").description("Export a prompt to a JSON file").argument("<name>", "Prompt name").option("-o, --out <file>", "Output file path", "./{name}.json").action(async (name, opts) => {
+    try {
+      const outPath = opts.out.replace("{name}", name);
+      await client.call("prompt.export", { name, filePath: outPath });
+      printer.success(`Prompt "${name}" exported to ${outPath}`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/prompt/index.ts
+function createPromptCommand(client, printer) {
+  const cmd = new Command36("prompt").description("Manage loaded prompts");
+  cmd.addCommand(createPromptListCommand(client, printer));
+  cmd.addCommand(createPromptShowCommand(client, printer));
+  cmd.addCommand(createPromptAddCommand(client, printer));
+  cmd.addCommand(createPromptRemoveCommand(client, printer));
+  cmd.addCommand(createPromptExportCommand(client, printer));
+  return cmd;
+}
+
+// src/commands/mcp/index.ts
+import { Command as Command42 } from "commander";
+
+// src/commands/mcp/list.ts
+import { Command as Command37 } from "commander";
+function createMcpListCommand(client, printer = defaultPrinter) {
+  return new Command37("list").alias("ls").description("List all loaded MCP server configs").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (opts) => {
+    try {
+      const servers = await client.call("mcp.list", {});
+      printer.log(formatMcpList(servers, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/mcp/show.ts
+import { Command as Command38 } from "commander";
+function createMcpShowCommand(client, printer = defaultPrinter) {
+  return new Command38("show").description("Show MCP server config details").argument("<name>", "MCP server name").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (name, opts) => {
+    try {
+      const server = await client.call("mcp.get", { name });
+      printer.log(formatMcpDetail(server, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/mcp/add.ts
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve6 } from "path";
+import { Command as Command39 } from "commander";
+function createMcpAddCommand(client, printer = defaultPrinter) {
+  return new Command39("add").description("Add an MCP server config from a JSON file").argument("<file>", "Path to MCP server definition JSON file").action(async (file) => {
+    try {
+      const raw = await readFile3(resolve6(file), "utf-8");
+      const component = JSON.parse(raw);
+      const result = await client.call("mcp.add", { component });
+      printer.success(`MCP "${result.name}" added successfully.`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/mcp/remove.ts
+import { Command as Command40 } from "commander";
+function createMcpRemoveCommand(client, printer = defaultPrinter) {
+  return new Command40("remove").alias("rm").description("Remove a loaded MCP server config").argument("<name>", "MCP server name").action(async (name) => {
+    try {
+      const result = await client.call("mcp.remove", { name });
+      if (result.success) {
+        printer.success(`MCP "${name}" removed.`);
+      } else {
+        printer.warn(`MCP "${name}" not found.`);
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/mcp/export.ts
+import { Command as Command41 } from "commander";
+function createMcpExportCommand(client, printer = defaultPrinter) {
+  return new Command41("export").description("Export an MCP server config to a JSON file").argument("<name>", "MCP server name").option("-o, --out <file>", "Output file path", "./{name}.json").action(async (name, opts) => {
+    try {
+      const outPath = opts.out.replace("{name}", name);
+      await client.call("mcp.export", { name, filePath: outPath });
+      printer.success(`MCP "${name}" exported to ${outPath}`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/mcp/index.ts
+function createMcpCommand(client, printer) {
+  const cmd = new Command42("mcp").description("Manage loaded MCP server configs");
+  cmd.addCommand(createMcpListCommand(client, printer));
+  cmd.addCommand(createMcpShowCommand(client, printer));
+  cmd.addCommand(createMcpAddCommand(client, printer));
+  cmd.addCommand(createMcpRemoveCommand(client, printer));
+  cmd.addCommand(createMcpExportCommand(client, printer));
+  return cmd;
+}
+
+// src/commands/workflow/index.ts
+import { Command as Command48 } from "commander";
+
+// src/commands/workflow/list.ts
+import { Command as Command43 } from "commander";
+function createWorkflowListCommand(client, printer = defaultPrinter) {
+  return new Command43("list").alias("ls").description("List all loaded workflows").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (opts) => {
+    try {
+      const workflows = await client.call("workflow.list", {});
+      printer.log(formatWorkflowList(workflows, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/workflow/show.ts
+import { Command as Command44 } from "commander";
+function createWorkflowShowCommand(client, printer = defaultPrinter) {
+  return new Command44("show").description("Show workflow details").argument("<name>", "Workflow name").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (name, opts) => {
+    try {
+      const workflow = await client.call("workflow.get", { name });
+      printer.log(formatWorkflowDetail(workflow, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/workflow/add.ts
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve7 } from "path";
+import { Command as Command45 } from "commander";
+function createWorkflowAddCommand(client, printer = defaultPrinter) {
+  return new Command45("add").description("Add a workflow from a JSON file").argument("<file>", "Path to workflow definition JSON file").action(async (file) => {
+    try {
+      const raw = await readFile4(resolve7(file), "utf-8");
+      const component = JSON.parse(raw);
+      const result = await client.call("workflow.add", { component });
+      printer.success(`Workflow "${result.name}" added successfully.`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/workflow/remove.ts
+import { Command as Command46 } from "commander";
+function createWorkflowRemoveCommand(client, printer = defaultPrinter) {
+  return new Command46("remove").alias("rm").description("Remove a loaded workflow").argument("<name>", "Workflow name").action(async (name) => {
+    try {
+      const result = await client.call("workflow.remove", { name });
+      if (result.success) {
+        printer.success(`Workflow "${name}" removed.`);
+      } else {
+        printer.warn(`Workflow "${name}" not found.`);
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/workflow/export.ts
+import { Command as Command47 } from "commander";
+function createWorkflowExportCommand(client, printer = defaultPrinter) {
+  return new Command47("export").description("Export a workflow to a JSON file").argument("<name>", "Workflow name").option("-o, --out <file>", "Output file path", "./{name}.json").action(async (name, opts) => {
+    try {
+      const outPath = opts.out.replace("{name}", name);
+      await client.call("workflow.export", { name, filePath: outPath });
+      printer.success(`Workflow "${name}" exported to ${outPath}`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/workflow/index.ts
+function createWorkflowCommand(client, printer) {
+  const cmd = new Command48("workflow").description("Manage loaded workflows");
+  cmd.addCommand(createWorkflowListCommand(client, printer));
+  cmd.addCommand(createWorkflowShowCommand(client, printer));
+  cmd.addCommand(createWorkflowAddCommand(client, printer));
+  cmd.addCommand(createWorkflowRemoveCommand(client, printer));
+  cmd.addCommand(createWorkflowExportCommand(client, printer));
+  return cmd;
+}
+
+// src/commands/plugin/index.ts
+import { Command as Command54 } from "commander";
+
+// src/commands/plugin/list.ts
+import { Command as Command49 } from "commander";
+function createPluginListCommand(client, printer = defaultPrinter) {
+  return new Command49("list").alias("ls").description("List all plugins").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (opts) => {
+    try {
+      const plugins = await client.call("plugin.list", {});
+      printer.log(formatPluginList(plugins, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/plugin/show.ts
+import { Command as Command50 } from "commander";
+function createPluginShowCommand(client, printer = defaultPrinter) {
+  return new Command50("show").description("Show plugin details").argument("<name>", "Plugin name").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (name, opts) => {
+    try {
+      const plugin = await client.call("plugin.get", { name });
+      printer.log(formatPluginDetail(plugin, opts.format));
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/plugin/add.ts
+import { readFile as readFile5 } from "fs/promises";
+import { resolve as resolve8 } from "path";
+import { Command as Command51 } from "commander";
+function createPluginAddCommand(client, printer = defaultPrinter) {
+  return new Command51("add").description("Add a plugin from a JSON file").argument("<file>", "Path to plugin definition JSON file").action(async (file) => {
+    try {
+      const raw = await readFile5(resolve8(file), "utf-8");
+      const component = JSON.parse(raw);
+      const result = await client.call("plugin.add", { component });
+      printer.success(`Plugin "${result.name}" added successfully.`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/plugin/remove.ts
+import { Command as Command52 } from "commander";
+function createPluginRemoveCommand(client, printer = defaultPrinter) {
+  return new Command52("remove").alias("rm").description("Remove a loaded plugin").argument("<name>", "Plugin name").action(async (name) => {
+    try {
+      const result = await client.call("plugin.remove", { name });
+      if (result.success) {
+        printer.success(`Plugin "${name}" removed.`);
+      } else {
+        printer.warn(`Plugin "${name}" not found.`);
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/plugin/export.ts
+import { Command as Command53 } from "commander";
+function createPluginExportCommand(client, printer = defaultPrinter) {
+  return new Command53("export").description("Export a plugin to a JSON file").argument("<name>", "Plugin name").option("-o, --out <file>", "Output file path", "./{name}.json").action(async (name, opts) => {
+    try {
+      const outPath = opts.out.replace("{name}", name);
+      await client.call("plugin.export", { name, filePath: outPath });
+      printer.success(`Plugin "${name}" exported to ${outPath}`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/plugin/index.ts
+function createPluginCommand(client, printer) {
+  const cmd = new Command54("plugin").description("Manage loaded plugins");
+  cmd.addCommand(createPluginListCommand(client, printer));
+  cmd.addCommand(createPluginShowCommand(client, printer));
+  cmd.addCommand(createPluginAddCommand(client, printer));
+  cmd.addCommand(createPluginRemoveCommand(client, printer));
+  cmd.addCommand(createPluginExportCommand(client, printer));
+  return cmd;
+}
+
+// src/commands/source/index.ts
+import { Command as Command59 } from "commander";
+
+// src/commands/source/list.ts
+import { Command as Command55 } from "commander";
+function createSourceListCommand(client, printer = defaultPrinter) {
+  return new Command55("list").alias("ls").description("List registered component sources").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (opts) => {
+    try {
+      const sources = await client.call("source.list", {});
+      if (opts.format === "json") {
+        printer.log(JSON.stringify(sources, null, 2));
+      } else if (opts.format === "quiet") {
+        printer.log(sources.map((s) => s.name).join("\n"));
+      } else {
+        if (sources.length === 0) {
+          printer.dim("No sources registered.");
+        } else {
+          for (const s of sources) {
+            const cfg = s.config;
+            const detail = cfg.type === "github" ? cfg.url : cfg.type === "local" ? cfg.path : "unknown";
+            printer.log(`  ${s.name}  (${cfg.type})  ${detail}`);
+          }
+        }
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/source/add.ts
+import { Command as Command56 } from "commander";
+function createSourceAddCommand(client, printer = defaultPrinter) {
+  return new Command56("add").description("Register a component source").argument("<url-or-path>", "GitHub URL or local directory path").requiredOption("--name <name>", "Package name (namespace prefix)").option("--type <type>", "Source type: github, local", "github").option("--branch <branch>", "Git branch (for github type)", "main").action(async (urlOrPath, opts) => {
+    try {
+      const config = opts.type === "local" ? { type: "local", path: urlOrPath } : { type: "github", url: urlOrPath, branch: opts.branch };
+      const result = await client.call("source.add", { name: opts.name, config });
+      const c = result.components;
+      printer.success(
+        `Source "${opts.name}" added. Components: ${c.skills} skills, ${c.prompts} prompts, ${c.mcp} mcp, ${c.workflows} workflows, ${c.presets} presets`
+      );
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/source/remove.ts
+import { Command as Command57 } from "commander";
+function createSourceRemoveCommand(client, printer = defaultPrinter) {
+  return new Command57("remove").alias("rm").description("Remove a registered source").argument("<name>", "Source name").action(async (name) => {
+    try {
+      const result = await client.call("source.remove", { name });
+      if (result.success) {
+        printer.success(`Source "${name}" removed.`);
+      } else {
+        printer.warn(`Source "${name}" not found.`);
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/source/sync.ts
+import chalk16 from "chalk";
+import { Command as Command58 } from "commander";
+function createSourceSyncCommand(client, printer = defaultPrinter) {
+  return new Command58("sync").description("Sync component source(s)").argument("[name]", "Source name (syncs all if omitted)").action(async (name) => {
+    try {
+      const result = await client.call("source.sync", { name });
+      printer.success(`Synced: ${result.synced.join(", ")}`);
+      const report = result.report;
+      if (report) {
+        const parts = [];
+        if (report.addedCount > 0) parts.push(chalk16.green(`+${report.addedCount} added`));
+        if (report.updatedCount > 0) parts.push(chalk16.yellow(`${report.updatedCount} updated`));
+        if (report.removedCount > 0) parts.push(chalk16.red(`-${report.removedCount} removed`));
+        if (parts.length > 0) {
+          printer.log(`  ${parts.join(", ")}`);
+        }
+        if (report.hasBreakingChanges) {
+          printer.warn("  \u26A0 Breaking changes detected (major version bump). Review updated components.");
+        }
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/source/index.ts
+function createSourceCommand(client, printer) {
+  const cmd = new Command59("source").description("Manage component sources (GitHub repos, local dirs)");
+  cmd.addCommand(createSourceListCommand(client, printer));
+  cmd.addCommand(createSourceAddCommand(client, printer));
+  cmd.addCommand(createSourceRemoveCommand(client, printer));
+  cmd.addCommand(createSourceSyncCommand(client, printer));
+  return cmd;
+}
+
+// src/commands/preset/index.ts
+import { Command as Command63 } from "commander";
+
+// src/commands/preset/list.ts
+import { Command as Command60 } from "commander";
+function createPresetListCommand(client, printer = defaultPrinter) {
+  return new Command60("list").alias("ls").description("List available presets from registered sources").argument("[package]", "Filter by source package name").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (packageName, opts) => {
+    try {
+      const presets = await client.call("preset.list", { packageName });
+      if (opts.format === "json") {
+        printer.log(JSON.stringify(presets, null, 2));
+      } else if (opts.format === "quiet") {
+        printer.log(presets.map((p) => p.name).join("\n"));
+      } else {
+        if (presets.length === 0) {
+          printer.dim("No presets available.");
+        } else {
+          for (const p of presets) {
+            const desc = p.description ? ` \u2014 ${p.description}` : "";
+            printer.log(`  ${p.name}${desc}`);
+          }
+        }
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/preset/show.ts
+import { Command as Command61 } from "commander";
+function createPresetShowCommand(client, printer = defaultPrinter) {
+  return new Command61("show").description("Show preset details").argument("<qualified-name>", "Preset qualified name (package@preset)").option("-f, --format <format>", "Output format: table, json", "table").action(async (qualifiedName, opts) => {
+    try {
+      const preset = await client.call("preset.show", { qualifiedName });
+      if (opts.format === "json") {
+        printer.log(JSON.stringify(preset, null, 2));
+      } else {
+        printer.log(`Preset: ${preset.name}`);
+        if (preset.description) printer.log(`Description: ${preset.description}`);
+        if (preset.skills?.length) printer.log(`Skills: ${preset.skills.join(", ")}`);
+        if (preset.prompts?.length) printer.log(`Prompts: ${preset.prompts.join(", ")}`);
+        if (preset.mcpServers?.length) printer.log(`MCP Servers: ${preset.mcpServers.join(", ")}`);
+        if (preset.workflows?.length) printer.log(`Workflows: ${preset.workflows.join(", ")}`);
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/preset/apply.ts
+import { Command as Command62 } from "commander";
+function createPresetApplyCommand(client, printer = defaultPrinter) {
+  return new Command62("apply").description("Apply a preset to a template (adds all preset components)").argument("<qualified-name>", "Preset qualified name (package@preset)").argument("<template>", "Template name to apply to").action(async (qualifiedName, templateName) => {
+    try {
+      const result = await client.call("preset.apply", { qualifiedName, templateName });
+      printer.success(`Preset "${qualifiedName}" applied to template "${result.name}".`);
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/preset/index.ts
+function createPresetCommand(client, printer) {
+  const cmd = new Command63("preset").description("Manage component presets (bundled compositions)");
+  cmd.addCommand(createPresetListCommand(client, printer));
+  cmd.addCommand(createPresetShowCommand(client, printer));
+  cmd.addCommand(createPresetApplyCommand(client, printer));
+  return cmd;
+}
+
+// src/commands/schedule/index.ts
+import { Command as Command65 } from "commander";
+
+// src/commands/schedule/list.ts
+import { Command as Command64 } from "commander";
+function createScheduleListCommand(client, printer = defaultPrinter) {
+  return new Command64("list").alias("ls").description("List schedule sources for an agent").argument("<name>", "Agent name").option("-f, --format <format>", "Output format: table, json", "table").action(async (name, opts) => {
+    try {
+      const result = await client.call("schedule.list", { name });
+      if (opts.format === "json") {
+        printer.log(JSON.stringify(result, null, 2));
+      } else {
+        if (result.sources.length === 0 && !result.running) {
+          printer.dim(`No scheduler for agent "${name}".`);
+        } else {
+          printer.log(`Scheduler: ${result.running ? "running" : "stopped"}`);
+          for (const s of result.sources) {
+            printer.log(`  ${s.id}  (${s.type})  ${s.active ? "active" : "inactive"}`);
+          }
+        }
+      }
+    } catch (err) {
+      presentError(err, printer);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/schedule/index.ts
+function createScheduleCommand(client, printer) {
+  const cmd = new Command65("schedule").description("Manage agent schedules (heartbeat, cron, hooks)");
+  cmd.addCommand(createScheduleListCommand(client, printer));
+  return cmd;
+}
+
+// src/commands/daemon/index.ts
+import { Command as Command69 } from "commander";
+
+// src/commands/daemon/start.ts
+import { Command as Command66 } from "commander";
+import { join } from "path";
+import { fork, spawn } from "child_process";
+import chalk17 from "chalk";
+import { onShutdownSignal, isWindows, isSingleExecutable } from "@actant/shared";
+var SEA_DAEMON_FLAG = "--__actant-daemon";
+function spawnDaemonChild() {
+  if (isSingleExecutable()) {
+    return spawn(process.execPath, [SEA_DAEMON_FLAG], {
+      detached: true,
+      stdio: ["ignore", "ignore", "pipe"],
+      env: process.env
+    });
+  }
+  const daemonScript = join(import.meta.dirname, "daemon-entry.js");
+  return isWindows() ? spawn(process.execPath, [daemonScript], {
+    detached: true,
+    stdio: ["ignore", "ignore", "pipe"],
+    env: process.env
+  }) : fork(daemonScript, [], {
+    detached: true,
+    stdio: ["ignore", "ignore", "pipe", "ipc"],
+    env: process.env
+  });
+}
+function createDaemonStartCommand(printer = defaultPrinter) {
+  return new Command66("start").description("Start the Actant daemon").option("--foreground", "Run in foreground (don't daemonize)", false).action(async (opts) => {
+    const client = new RpcClient(defaultSocketPath());
+    const alive = await client.ping();
+    if (alive) {
+      printer.warn("Daemon is already running.");
+      return;
+    }
+    if (opts.foreground) {
+      try {
+        const { Daemon } = await import("@actant/api");
+        const daemon = new Daemon();
+        onShutdownSignal(async () => {
+          await daemon.stop();
+          process.exit(0);
+        });
+        await daemon.start();
+        printer.log(`${chalk17.green("Daemon started (foreground).")} PID: ${process.pid}`);
+        printer.dim("Press Ctrl+C to stop.");
+        await new Promise(() => {
+        });
+      } catch (err) {
+        presentError(err, printer);
+        process.exitCode = 1;
+      }
+    } else {
+      const child = spawnDaemonChild();
+      const stderrChunks = [];
+      child.stderr?.on("data", (chunk) => {
+        stderrChunks.push(chunk);
+      });
+      let earlyExit = false;
+      let earlyExitCode = null;
+      child.on("exit", (code) => {
+        earlyExit = true;
+        earlyExitCode = code;
+      });
+      await new Promise((resolve9) => setTimeout(resolve9, 2e3));
+      if (earlyExit) {
+        const stderr = Buffer.concat(stderrChunks).toString().trim();
+        printer.error(`Daemon process exited unexpectedly (code: ${earlyExitCode}).`);
+        if (stderr) printer.error(stderr);
+        process.exitCode = 1;
+        return;
+      }
+      let healthy = false;
+      for (let i = 0; i < 3; i++) {
+        healthy = await client.ping();
+        if (healthy) break;
+        await new Promise((resolve9) => setTimeout(resolve9, 500));
+      }
+      child.stderr?.destroy();
+      if ("connected" in child && child.connected) child.disconnect();
+      child.unref();
+      if (healthy) {
+        printer.log(`${chalk17.green("Daemon started.")} PID: ${child.pid}`);
+      } else {
+        const stderr = Buffer.concat(stderrChunks).toString().trim();
+        printer.error("Daemon process started but is not responding.");
+        if (stderr) printer.error(stderr);
+        process.exitCode = 1;
+      }
+    }
+  });
+}
+
+// src/commands/daemon/stop.ts
+import { Command as Command67 } from "commander";
+function createDaemonStopCommand(printer = defaultPrinter, client) {
+  return new Command67("stop").description("Stop the Actant daemon").action(async () => {
+    const rpc = client ?? new RpcClient(defaultSocketPath());
+    try {
+      await rpc.call("daemon.shutdown", {});
+      printer.success("Daemon stopping...");
+    } catch {
+      printer.warn("Daemon is not running.");
+    }
+  });
+}
+
+// src/commands/daemon/status.ts
+import { Command as Command68 } from "commander";
+import chalk18 from "chalk";
+function createDaemonStatusCommand(printer = defaultPrinter) {
+  return new Command68("status").description("Check if the daemon is running").option("-f, --format <format>", "Output format: table, json, quiet", "table").action(async (opts) => {
+    const client = new RpcClient(defaultSocketPath());
+    try {
+      const result = await client.call("daemon.ping", {});
+      if (opts.format === "json") {
+        printer.log(JSON.stringify({ running: true, ...result }, null, 2));
+      } else if (opts.format === "quiet") {
+        printer.log("running");
+      } else {
+        printer.success("Daemon is running.");
+        printer.log(`  Version: ${result.version}`);
+        printer.log(`  Uptime:  ${result.uptime}s`);
+        printer.log(`  Agents:  ${result.agents}`);
+      }
+    } catch {
+      if (opts.format === "json") {
+        printer.log(JSON.stringify({ running: false }, null, 2));
+      } else if (opts.format === "quiet") {
+        printer.log("stopped");
+      } else {
+        printer.log(chalk18.red("Daemon is not running."));
+        printer.dim("Start with: actant daemon start");
+      }
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/daemon/index.ts
+function createDaemonCommand(printer) {
+  const cmd = new Command69("daemon").description("Manage the Actant daemon");
+  cmd.addCommand(createDaemonStartCommand(printer));
+  cmd.addCommand(createDaemonStopCommand(printer));
+  cmd.addCommand(createDaemonStatusCommand(printer));
+  return cmd;
+}
+
+// src/commands/proxy.ts
+import { Command as Command70 } from "commander";
+import { spawn as spawn2 } from "child_process";
+import { createInterface as createInterface3 } from "readline";
+function createProxyCommand(printer = defaultPrinter) {
+  return new Command70("proxy").description("Run an ACP proxy for an agent (stdin/stdout ACP protocol)").argument("<name>", "Agent name to proxy").option("--lease", "Use Session Lease mode (requires running agent)", false).option("-t, --template <template>", "Template name (auto-creates instance if not found)").action(async (name, opts) => {
+    if (opts.lease) {
+      await runSessionLease(name, printer);
+    } else {
+      await runDirectBridge(name, opts, printer);
+    }
+  });
+}
+async function runDirectBridge(name, opts, printer) {
+  const client = new RpcClient(defaultSocketPath());
+  let child = null;
+  let instanceName = name;
+  let attached = false;
+  let cleaning = false;
+  const cleanup = async () => {
+    if (cleaning) return;
+    cleaning = true;
+    if (child && !child.killed) {
+      child.kill("SIGTERM");
+      await new Promise((resolve9) => {
+        const timer = setTimeout(() => {
+          child?.kill("SIGKILL");
+          resolve9();
+        }, 3e3);
+        child?.once("exit", () => {
+          clearTimeout(timer);
+          resolve9();
+        });
+      });
+    }
+    if (attached) {
+      try {
+        await client.call("agent.detach", { name: instanceName, cleanup: true });
+      } catch {
+      }
+      attached = false;
+    }
+  };
+  try {
+    const alive = await client.ping();
+    if (!alive) {
+      printer.error("Daemon is not running. Start it with: actant daemon start");
+      process.exitCode = 1;
+      return;
+    }
+    const resolved = await client.call("agent.resolve", {
+      name,
+      template: opts.template
+    });
+    instanceName = resolved.instanceName;
+    const targetInstance = await resolveAvailableInstance(
+      client,
+      instanceName,
+      resolved,
+      printer
+    );
+    if (!targetInstance) {
+      process.exitCode = 1;
+      return;
+    }
+    instanceName = targetInstance.instanceName;
+    const workspaceDir = targetInstance.workspaceDir;
+    const command = targetInstance.command;
+    const args = targetInstance.args;
+    const env = { ...process.env, ...targetInstance.env };
+    child = spawn2(command, args, {
+      cwd: workspaceDir,
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    if (!child.stdin || !child.stdout || child.pid == null) {
+      throw new Error("Failed to create stdio pipes for agent subprocess");
+    }
+    const childPid = child.pid;
+    const childProc = child;
+    await client.call("agent.attach", {
+      name: instanceName,
+      pid: childPid,
+      metadata: { proxyMode: "direct-bridge" }
+    });
+    attached = true;
+    process.on("SIGINT", () => {
+      void cleanup().then(() => process.exit(0));
+    });
+    process.on("SIGTERM", () => {
+      void cleanup().then(() => process.exit(0));
+    });
+    process.stdin.pipe(child.stdin);
+    child.stdout.pipe(process.stdout);
+    child.stderr?.pipe(process.stderr);
+    const exitCode = await new Promise((resolve9) => {
+      childProc.on("exit", (code) => resolve9(code ?? 1));
+      childProc.on("error", (err) => {
+        printer.error(`Agent process error: ${err.message}`);
+        resolve9(1);
+      });
+    });
+    if (attached) {
+      try {
+        await client.call("agent.detach", { name: instanceName, cleanup: true });
+      } catch {
+      }
+      attached = false;
+    }
+    process.exitCode = exitCode;
+  } catch (err) {
+    await cleanup();
+    presentError(err, printer);
+    process.exitCode = 1;
+  }
+}
+async function resolveAvailableInstance(client, instanceName, resolved, printer) {
+  try {
+    const status = await client.call("agent.status", { name: instanceName });
+    if (status.status === "running" && status.pid != null) {
+      const templateName = status.templateName;
+      if (!templateName) {
+        printer.error(
+          `Agent "${instanceName}" is already running (pid ${status.pid}) and has no template for auto-instantiation.`
+        );
+        return null;
+      }
+      const ephemeralName = `${instanceName}-proxy-${Date.now()}`;
+      const ephemeral = await client.call("agent.resolve", {
+        name: ephemeralName,
+        template: templateName,
+        overrides: { workspacePolicy: "ephemeral" }
+      });
+      printer.dim(
+        `Instance "${instanceName}" occupied \u2192 created ephemeral "${ephemeralName}"`
+      );
+      return {
+        instanceName: ephemeral.instanceName,
+        workspaceDir: ephemeral.workspaceDir,
+        command: ephemeral.command,
+        args: ephemeral.args,
+        env: ephemeral.env
+      };
+    }
+  } catch {
+  }
+  return {
+    instanceName: resolved.instanceName,
+    workspaceDir: resolved.workspaceDir,
+    command: resolved.command,
+    args: resolved.args,
+    env: resolved.env
+  };
+}
+async function runSessionLease(agentName, printer) {
+  const rpcClient = new RpcClient(defaultSocketPath());
+  try {
+    const alive = await rpcClient.ping();
+    if (!alive) {
+      printer.error("Daemon is not running. Start it with: actant daemon start");
+      process.exitCode = 1;
+      return;
+    }
+    const meta = await rpcClient.call("agent.status", { name: agentName });
+    if (meta.status !== "running") {
+      printer.error(
+        `Agent "${agentName}" is not running (status: ${meta.status}). Session Lease requires a running agent. Start with: actant agent start ${agentName}`
+      );
+      process.exitCode = 1;
+      return;
+    }
+  } catch (err) {
+    presentError(err, printer);
+    process.exitCode = 1;
+    return;
+  }
+  let gatewaySocketPath = null;
+  try {
+    const result = await rpcClient.call("gateway.lease", { agentName });
+    gatewaySocketPath = result.socketPath;
+  } catch {
+  }
+  if (gatewaySocketPath) {
+    await runGatewayPipe(gatewaySocketPath, printer);
+  } else {
+    printer.dim("Gateway lease not available, using legacy session lease mode");
+    await runLegacySessionLease(agentName, rpcClient, printer);
+  }
+}
+async function runGatewayPipe(gatewaySocketPath, _printer) {
+  const net = await import("net");
+  const socket = net.createConnection(gatewaySocketPath);
+  let cleaning = false;
+  const cleanup = () => {
+    if (cleaning) return;
+    cleaning = true;
+    socket.destroy();
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  socket.on("connect", () => {
+    process.stdin.pipe(socket);
+    socket.pipe(process.stdout);
+  });
+  socket.on("error", (err) => {
+    _printer.error(`Gateway connection error: ${err.message}`);
+    cleanup();
+    process.exitCode = 1;
+  });
+  socket.on("close", () => {
+    cleanup();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+async function runLegacySessionLease(agentName, client, _printer) {
+  const clientId = `proxy-${Date.now()}`;
+  let sessionId = null;
+  let closed = false;
+  const cleanup = async () => {
+    if (closed) return;
+    closed = true;
+    if (sessionId) {
+      try {
+        await client.call("session.close", { sessionId });
+      } catch {
+      }
+    }
+  };
+  process.on("SIGINT", () => {
+    void cleanup().then(() => process.exit(0));
+  });
+  process.on("SIGTERM", () => {
+    void cleanup().then(() => process.exit(0));
+  });
+  const rl = createInterface3({ input: process.stdin });
+  rl.on("line", (line) => {
+    if (closed) return;
+    void handleLegacyMessage(line, agentName, clientId, client, {
+      getSessionId: () => sessionId,
+      setSessionId: (id) => {
+        sessionId = id;
+      }
+    }).catch((err) => {
+      writeAcpError(null, -32603, err instanceof Error ? err.message : String(err));
+    });
+  });
+  rl.on("close", () => {
+    void cleanup().then(() => process.exit(0));
+  });
+}
+async function handleLegacyMessage(line, agentName, clientId, client, ctx) {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+  if (!msg.method) return;
+  const params = msg.params ?? {};
+  switch (msg.method) {
+    case "initialize":
+      writeAcpResponse(msg.id, {
+        protocolVersion: 1,
+        agentInfo: { name: "actant-proxy", title: `Actant Proxy: ${agentName} (lease)`, version: "0.1.0" },
+        agentCapabilities: {}
+      });
+      break;
+    case "session/new":
+      try {
+        const result = await client.call("session.create", { agentName, clientId });
+        ctx.setSessionId(result.sessionId);
+        writeAcpResponse(msg.id, { sessionId: result.sessionId, modes: {} });
+      } catch (err) {
+        writeAcpError(msg.id, -32603, err instanceof Error ? err.message : String(err));
+      }
+      break;
+    case "session/prompt": {
+      const sid = params["sessionId"] ?? ctx.getSessionId();
+      if (!sid) {
+        writeAcpError(msg.id, -32602, "No session. Call session/new first.");
+        break;
+      }
+      try {
+        const prompt = params["prompt"];
+        const text = prompt?.find((p) => p.type === "text")?.text ?? "";
+        const result = await client.call("session.prompt", { sessionId: sid, text }, { timeoutMs: 305e3 });
+        writeAcpResponse(msg.id, { stopReason: result.stopReason });
+      } catch (err) {
+        writeAcpError(msg.id, -32603, err instanceof Error ? err.message : String(err));
+      }
+      break;
+    }
+    case "session/cancel": {
+      const sid = params["sessionId"] ?? ctx.getSessionId();
+      if (sid) {
+        try {
+          await client.call("session.cancel", { sessionId: sid });
+        } catch {
+        }
+      }
+      if (msg.id != null) writeAcpResponse(msg.id, { ok: true });
+      break;
+    }
+    default:
+      if (msg.id != null) writeAcpError(msg.id, -32601, `Unsupported method: ${msg.method}`);
+  }
+}
+function writeAcpResponse(id, result) {
+  process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: id ?? null, result }) + "\n");
+}
+function writeAcpError(id, code, message) {
+  process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: id ?? null, error: { code, message } }) + "\n");
+}
+
+// src/commands/self-update.ts
+import { Command as Command71 } from "commander";
+import { spawn as spawn3 } from "child_process";
+import { writeFileSync, mkdirSync, readFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+import chalk19 from "chalk";
+function createSelfUpdateCommand() {
+  return new Command71("self-update").description("Update Actant from local source").option("--source <path>", "Source directory path").option("--check", "Only check for updates, don't apply").option("--force", "Skip active session warnings").option("--dry-run", "Show what would be done without doing it").option("--no-agent", "Skip agent supervisor, run script directly").option("--skip-build", "Skip build step (use pre-built dist)").action(async (opts) => {
+    const actantHome = process.env.ACTANT_HOME || join2(homedir(), ".actant");
+    let devSourcePath = opts.source;
+    if (!devSourcePath) {
+      const configPath = join2(actantHome, "config.json");
+      try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        devSourcePath = config.devSourcePath;
+      } catch {
+      }
+    }
+    if (!devSourcePath) {
+      console.error(
+        chalk19.red(
+          "No source path specified. Use --source <path> or set devSourcePath in ~/.actant/config.json"
+        )
+      );
+      process.exit(1);
+    }
+    if (opts.check) {
+      showVersionCheck(devSourcePath, actantHome);
+      return;
+    }
+    let installedVersion = "0.1.0";
+    const cliPkgPath = join2(devSourcePath, "packages", "cli", "package.json");
+    if (existsSync2(cliPkgPath)) {
+      try {
+        const cliPkg = JSON.parse(readFileSync(cliPkgPath, "utf-8"));
+        installedVersion = cliPkg.version ?? installedVersion;
+      } catch {
+      }
+    }
+    const updateId = `upd-${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:T.]/g, "").slice(0, 15)}`;
+    const manifestPath = join2(actantHome, "update-manifest.json");
+    const manifest = {
+      updateId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourcePath: devSourcePath,
+      installedVersion: { version: installedVersion },
+      backupPath: join2(actantHome, "backups", updateId),
+      runningAgents: [],
+      daemonSocketPath: join2(actantHome, "daemon.sock"),
+      rollbackOnFailure: true,
+      phase: "pending",
+      useAgent: !opts.noAgent
+    };
+    mkdirSync(actantHome, { recursive: true });
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    console.log(chalk19.cyan("=== Actant Self-Update ==="));
+    console.log(`Update ID: ${updateId}`);
+    console.log(`Source: ${devSourcePath}`);
+    const scriptPath = join2(devSourcePath, "scripts", "self-update.js");
+    const scriptArgs = ["--manifest", manifestPath];
+    if (opts.dryRun) scriptArgs.push("--dry-run");
+    if (opts.skipBuild) scriptArgs.push("--skip-build");
+    console.log(chalk19.gray(`Spawning: node ${scriptPath} ${scriptArgs.join(" ")}`));
+    const child = spawn3("node", [scriptPath, ...scriptArgs], {
+      detached: !opts.noAgent,
+      stdio: opts.noAgent ? "inherit" : "ignore"
+    });
+    if (!opts.noAgent) {
+      child.unref();
+      console.log(chalk19.green("Update script spawned in background. Check logs at:"));
+      console.log(chalk19.gray(`  ${join2(actantHome, "logs", `update-${updateId}.log`)}`));
+    } else {
+      child.on("exit", (code) => {
+        if (code === 0) {
+          console.log(chalk19.green("\nUpdate completed successfully!"));
+        } else if (code === 1) {
+          console.log(chalk19.yellow("\nUpdate failed, rolled back to previous version."));
+        } else {
+          console.log(chalk19.red("\nSevere failure \u2014 manual intervention may be needed."));
+        }
+      });
+    }
+  });
+}
+function showVersionCheck(sourcePath, actantHome) {
+  console.log(chalk19.cyan("=== Version Check ==="));
+  try {
+    const pkg = JSON.parse(readFileSync(join2(sourcePath, "package.json"), "utf-8"));
+    console.log(`Source version: ${pkg.version || "unknown"}`);
+  } catch {
+    console.log("Source version: unknown");
+  }
+  const manifestPath = join2(actantHome, "update-manifest.json");
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    console.log(`Last update: ${manifest.updateId} (phase: ${manifest.phase})`);
+  } catch {
+    console.log("Last update: none");
+  }
+}
+
+// src/program.ts
+function defaultSocketPath() {
+  return process.env["ACTANT_SOCKET"] ?? getDefaultIpcPath();
+}
+function createProgram(socketPath, printer) {
+  const sock = socketPath ?? defaultSocketPath();
+  const client = new RpcClient(sock);
+  const program = new Command72("actant").version("0.1.0").description("Actant \u2014 Build, manage, and compose AI agents");
+  program.addCommand(createTemplateCommand(client, printer));
+  program.addCommand(createAgentCommand(client, printer));
+  program.addCommand(createSkillCommand(client, printer));
+  program.addCommand(createPromptCommand(client, printer));
+  program.addCommand(createMcpCommand(client, printer));
+  program.addCommand(createWorkflowCommand(client, printer));
+  program.addCommand(createPluginCommand(client, printer));
+  program.addCommand(createSourceCommand(client, printer));
+  program.addCommand(createPresetCommand(client, printer));
+  program.addCommand(createScheduleCommand(client, printer));
+  program.addCommand(createDaemonCommand(printer));
+  program.addCommand(createProxyCommand(printer));
+  program.addCommand(createHelpCommand());
+  program.addCommand(createSelfUpdateCommand());
+  program.exitOverride();
+  return program;
+}
+async function run(argv) {
+  const args = argv ?? process.argv;
+  const hasSubcommand = args.length > 2 && !args[2]?.startsWith("-");
+  if (!hasSubcommand) {
+    const versionRequested = args.includes("-V") || args.includes("--version");
+    const helpRequested = args.includes("-h") || args.includes("--help");
+    if (!versionRequested && !helpRequested) {
+      const sock = defaultSocketPath();
+      const client = new RpcClient(sock);
+      const { startRepl } = await import("./repl-JIMJ2V2Y.js");
+      await startRepl(client, sock);
+      return;
+    }
+  }
+  const program = createProgram();
+  try {
+    await program.parseAsync(args);
+  } catch (err) {
+    if (err instanceof Error && "code" in err) {
+      const code = err.code;
+      if (code === "commander.helpDisplayed" || code === "commander.version") {
+        return;
+      }
+    }
+    presentError(err);
+    process.exitCode = 1;
+  }
+}
+
+export {
+  RpcClient,
+  RpcCallError,
+  ConnectionError,
+  defaultPrinter,
+  defaultSocketPath,
+  createProgram,
+  run
+};
+//# sourceMappingURL=chunk-2FKBVXMH.js.map