@oxgeneral/orch 0.3.2 → 0.3.4

package/dist/agent-KBTLGGCT.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+import { agentToEditorContent, openInEditor, agentFromEditorContent } from './chunk-P6ATSXGL.js';
+import { printSuccess, agentName, printTable, dim, statusIcon, formatTokens, printKeyValue } from './chunk-7X2GI5OV.js';
+
+// src/cli/commands/agent.ts
+function registerAgentCommand(program, container) {
+  const agent = program.command("agent").description("Manage agents");
+  agent.command("add <name>").description("Add a new agent").requiredOption("--adapter <adapter>", "Adapter type: claude, shell, codex, cursor").option("--role <role>", "Agent role description").option("--command <cmd>", "Shell command (for shell adapter)").option("--model <model>", "Model name (for AI adapters)").option("--max-turns <n>", "Max turns per run").option("--timeout <ms>", "Timeout in ms").option("--approval-policy <policy>", "suggest|auto|manual").option("--workspace-mode <mode>", "shared|worktree|isolated").option("--skills <skills>", "Comma-separated list of agent skills").option("-e, --edit", "Open $EDITOR to write the role description").action(async (name, opts) => {
+    await container.paths.requireInit();
+    let role = opts.role;
+    if (opts.edit) {
+      const initial = agentToEditorContent({ name, model: opts.model, role });
+      const edited = await openInEditor(initial);
+      const parsed = agentFromEditorContent(edited);
+      if (parsed.name) name = parsed.name;
+      if (parsed.model) opts.model = parsed.model;
+      if (parsed.role) role = parsed.role;
+    }
+    const a = await container.agentService.create({
+      name,
+      adapter: opts.adapter,
+      role,
+      command: opts.command,
+      model: opts.model,
+      max_turns: opts.maxTurns ? parseInt(opts.maxTurns, 10) : void 0,
+      timeout_ms: opts.timeout ? parseInt(opts.timeout, 10) : void 0,
+      approval_policy: opts.approvalPolicy,
+      workspace_mode: opts.workspaceMode,
+      skills: opts.skills ? opts.skills.split(",").map((s) => s.trim()) : void 0
+    });
+    if (container.context.json) {
+      console.log(JSON.stringify(a, null, 2));
+    } else if (container.context.quiet) {
+      console.log(a.id);
+    } else {
+      printSuccess(`Added agent ${agentName(a.name)} (${a.adapter}) \u2192 ${a.id}`);
+    }
+  });
+  agent.command("shop").description("Browse and install pre-built agent templates").option("--list", "Print all templates (non-interactive)").action(async (opts) => {
+    await container.paths.requireInit();
+    const { AGENT_SHOP_TEMPLATES } = await import('./agent-shop-YN2BSLHM.js');
+    if (opts.list || !process.stdout.isTTY) {
+      printTable(
+        ["Key", "Name", "Adapter", "Model", "Skills"],
+        AGENT_SHOP_TEMPLATES.map((t) => [t.key, t.name, t.adapter, t.model.replace("claude-", ""), t.skills.slice(0, 2).join(", ")])
+      );
+      return;
+    }
+    const { pickFromShop } = await import('./shop-picker-2HY67UWP.js');
+    const template = await pickFromShop(AGENT_SHOP_TEMPLATES);
+    if (!template) {
+      console.log("  Cancelled.");
+      return;
+    }
+    const a = await container.agentService.create({
+      name: template.name,
+      adapter: template.adapter,
+      model: template.model,
+      role: template.role,
+      skills: template.skills,
+      approval_policy: template.approval_policy
+    });
+    printSuccess(`Added agent ${agentName(a.name)} (${a.adapter}) \u2192 ${a.id}`);
+  });
+  agent.command("list").description("List all agents").action(async () => {
+    await container.paths.requireInit();
+    const agents = await container.agentService.list();
+    if (container.context.json) {
+      console.log(JSON.stringify(agents, null, 2));
+      return;
+    }
+    if (container.context.quiet) {
+      agents.forEach((a) => console.log(a.id));
+      return;
+    }
+    if (agents.length === 0) {
+      console.log(`
+  No agents. Add one: ${dim("orch agent add <name> --adapter claude")}
+`);
+      return;
+    }
+    const headers = ["STATUS", "AGENT", "ADAPTER", "TASK", "TIME"];
+    const rows = agents.map((a) => [
+      `${statusIcon(a.status)} ${a.status}`,
+      agentName(a.name),
+      a.adapter,
+      a.current_task ?? dim("\u2014"),
+      dim("\u2014")
+    ]);
+    console.log();
+    printTable(headers, rows);
+    const running = agents.filter((a) => a.status === "running").length;
+    console.log(
+      `
+  ${agents.length} agents \xB7 ${running} running \xB7 ${formatTokens(agents.reduce((sum, a) => sum + (a.stats.tokens_used ?? 0), 0))} tokens total
+`
+    );
+  });
+  agent.command("status <id>").description("Show agent details").action(async (id) => {
+    await container.paths.requireInit();
+    const a = await container.agentService.get(id);
+    if (container.context.json) {
+      console.log(JSON.stringify(a, null, 2));
+      return;
+    }
+    console.log(`
+  ${a.name}`);
+    console.log(`  ${"\u2550".repeat(42)}`);
+    console.log();
+    const pairs = [
+      ["Adapter", `${a.adapter}${a.config.model ? ` (${a.config.model})` : ""}`],
+      ["Status", `${statusIcon(a.status)} ${a.status}`],
+      ["Policy", a.config.approval_policy ?? "auto"]
+    ];
+    if (a.current_task) pairs.push(["Task", a.current_task]);
+    if (a.role) pairs.push(["Role", a.role]);
+    if (a.config.skills?.length) pairs.push(["Skills", a.config.skills.join(", ")]);
+    printKeyValue(pairs);
+    console.log(`
+  Stats
+  ${"\u2500".repeat(42)}`);
+    printKeyValue([
+      ["Tasks completed", String(a.stats.tasks_completed)],
+      ["Tasks failed", String(a.stats.tasks_failed)],
+      ["Total runs", String(a.stats.total_runs)],
+      ["Tokens used", formatTokens(a.stats.tokens_used ?? 0)]
+    ]);
+    console.log();
+  });
+  agent.command("edit <id>").description("Edit an agent in $EDITOR").action(async (id) => {
+    await container.paths.requireInit();
+    const a = await container.agentService.get(id);
+    const initial = agentToEditorContent({
+      name: a.name,
+      model: a.config.model,
+      role: a.role
+    });
+    const edited = await openInEditor(initial);
+    const parsed = agentFromEditorContent(edited);
+    const updated = await container.agentService.update(id, {
+      name: parsed.name,
+      role: parsed.role,
+      model: parsed.model
+    });
+    if (container.context.json) {
+      console.log(JSON.stringify(updated, null, 2));
+    } else if (container.context.quiet) {
+      console.log(updated.id);
+    } else {
+      printSuccess(`Updated agent ${agentName(updated.name)} (${updated.id})`);
+    }
+  });
+  agent.command("remove <id>").description("Remove an agent").action(async (id) => {
+    await container.paths.requireInit();
+    await container.agentService.remove(id);
+    printSuccess(`Removed agent ${id}`);
+  });
+  agent.command("disable <id>").description("Disable an agent").action(async (id) => {
+    await container.paths.requireInit();
+    await container.agentService.disable(id);
+    printSuccess(`Disabled agent ${id}`);
+  });
+  agent.command("enable <id>").description("Enable an agent").action(async (id) => {
+    await container.paths.requireInit();
+    await container.agentService.enable(id);
+    printSuccess(`Enabled agent ${id}`);
+  });
+  agent.command("autonomous <id>").description("Toggle autonomous mode for an agent").option("--on", "Enable autonomous mode").option("--off", "Disable autonomous mode").action(async (id, opts) => {
+    await container.paths.requireInit();
+    const current = await container.agentService.get(id);
+    const enable = opts.on ? true : opts.off ? false : !current.autonomous;
+    const a = await container.agentService.setAutonomous(id, enable);
+    if (container.context.json) {
+      console.log(JSON.stringify(a, null, 2));
+    } else if (container.context.quiet) {
+      console.log(a.id);
+    } else {
+      printSuccess(`Autonomous mode ${enable ? "enabled" : "disabled"} for agent ${agentName(a.name)} (${a.id})`);
+    }
+  });
+}
+
+export { registerAgentCommand };

package/dist/agent-shop-YN2BSLHM.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export { AGENT_SHOP_TEMPLATES, getShopTemplateByKey } from './chunk-DAVHOWGD.js';

package/dist/chunk-2C2TFQ7K.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+// src/domain/errors.ts
+var OrchestryError = class extends Error {
+  constructor(message, exitCode, hint) {
+    super(message);
+    this.exitCode = exitCode;
+    this.hint = hint;
+    this.name = "OrchestryError";
+  }
+};
+var NotInitializedError = class extends OrchestryError {
+  constructor() {
+    super("Not initialized", 3, "Run: orch init");
+    this.name = "NotInitializedError";
+  }
+};
+var InvalidArgumentsError = class extends OrchestryError {
+  constructor(message) {
+    super(message, 2);
+    this.name = "InvalidArgumentsError";
+  }
+};
+var LockConflictError = class extends OrchestryError {
+  constructor(pid) {
+    super(`Orchestrator already running (PID: ${pid})`, 4, "Use: orch status");
+    this.name = "LockConflictError";
+  }
+};
+var NoAgentsError = class extends OrchestryError {
+  constructor() {
+    super("No agents configured", 1, "Run: orch agent add <name> --adapter claude");
+    this.name = "NoAgentsError";
+  }
+};
+var TaskNotFoundError = class extends OrchestryError {
+  constructor(taskId) {
+    super(`Task not found: ${taskId}`, 1);
+    this.name = "TaskNotFoundError";
+  }
+};
+var AgentNotFoundError = class extends OrchestryError {
+  constructor(agentId) {
+    super(`Agent not found: ${agentId}`, 1);
+    this.name = "AgentNotFoundError";
+  }
+};
+var TaskAlreadyRunningError = class extends OrchestryError {
+  constructor(taskId, runId, agentName) {
+    super(
+      `Task ${taskId} is already running (run: ${runId}, agent: ${agentName})`,
+      1,
+      `Use: orch logs --task ${taskId} --follow`
+    );
+    this.name = "TaskAlreadyRunningError";
+  }
+};
+var InvalidTransitionError = class extends OrchestryError {
+  constructor(taskId, from, to) {
+    super(`Invalid transition for ${taskId}: ${from} \u2192 ${to}`, 1);
+    this.name = "InvalidTransitionError";
+  }
+};
+var GoalNotFoundError = class extends OrchestryError {
+  constructor(goalId) {
+    super(`Goal not found: ${goalId}`, 1);
+    this.name = "GoalNotFoundError";
+  }
+};
+var TeamNotFoundError = class extends OrchestryError {
+  constructor(teamId) {
+    super(`Team not found: ${teamId}`, 1);
+    this.name = "TeamNotFoundError";
+  }
+};
+var WorkspaceError = class extends OrchestryError {
+  constructor(message, hint) {
+    super(message, 6, hint);
+    this.name = "WorkspaceError";
+  }
+};
+var ERROR_HINTS = {
+  ["adapter_not_found" /* ADAPTER_NOT_FOUND */]: {
+    message: "CLI \u043D\u0435 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D.",
+    fix: "\u0423\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u0435: npm i -g @anthropic-ai/claude-code",
+    doctorHint: true
+  },
+  ["auth_failed" /* AUTH_FAILED */]: {
+    message: "API \u043A\u043B\u044E\u0447 \u043D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D.",
+    fix: "\u041F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435: claude auth status"
+  },
+  ["timeout" /* TIMEOUT */]: {
+    message: "\u0410\u0433\u0435\u043D\u0442 \u043F\u0440\u0435\u0432\u044B\u0441\u0438\u043B \u043B\u0438\u043C\u0438\u0442 \u0432\u0440\u0435\u043C\u0435\u043D\u0438.",
+    fix: "\u0423\u0432\u0435\u043B\u0438\u0447\u044C\u0442\u0435 \u0447\u0435\u0440\u0435\u0437: orch config set agent_timeout <ms>"
+  },
+  ["rate_limit" /* RATE_LIMIT */]: {
+    message: "\u0414\u043E\u0441\u0442\u0438\u0433\u043D\u0443\u0442 \u043B\u0438\u043C\u0438\u0442 API.",
+    fix: "\u041F\u043E\u0434\u043E\u0436\u0434\u0438\u0442\u0435 \u0438 \u043F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0435: orch task retry <id>"
+  },
+  ["process_crash" /* PROCESS_CRASH */]: {
+    message: "\u041F\u0440\u043E\u0446\u0435\u0441\u0441 \u0430\u0433\u0435\u043D\u0442\u0430 \u0443\u043F\u0430\u043B.",
+    fix: "\u041F\u043E\u043F\u0440\u043E\u0431\u0443\u0439\u0442\u0435: orch task retry <id>"
+  },
+  ["spawn_failed" /* SPAWN_FAILED */]: {
+    message: "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u044C \u043F\u0440\u043E\u0446\u0435\u0441\u0441.",
+    fix: "\u041F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435 PATH \u0438 \u043F\u0440\u0430\u0432\u0430 \u0434\u043E\u0441\u0442\u0443\u043F\u0430"
+  },
+  ["unknown" /* UNKNOWN */]: {
+    message: "\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430.",
+    fix: "\u0417\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u0435: orch doctor",
+    doctorHint: true
+  }
+};
+function classifyAdapterError(error, exitCode) {
+  const lower = error.toLowerCase();
+  if (lower.includes("enoent") || lower.includes("spawn failed")) {
+    return "spawn_failed" /* SPAWN_FAILED */;
+  }
+  if (lower.includes("not found") || lower.includes("command not found") || lower.includes("no such file")) {
+    return "adapter_not_found" /* ADAPTER_NOT_FOUND */;
+  }
+  if (lower.includes("auth") || lower.includes("unauthorized") || lower.includes("401") || lower.includes("invalid api key") || lower.includes("authentication")) {
+    return "auth_failed" /* AUTH_FAILED */;
+  }
+  if (lower.includes("timeout") || lower.includes("timed out") || lower.includes("etimedout")) {
+    return "timeout" /* TIMEOUT */;
+  }
+  if (lower.includes("rate limit") || lower.includes("429") || lower.includes("too many requests")) {
+    return "rate_limit" /* RATE_LIMIT */;
+  }
+  if (exitCode !== void 0 && exitCode !== 0) {
+    return "process_crash" /* PROCESS_CRASH */;
+  }
+  return "unknown" /* UNKNOWN */;
+}
+
+export { AgentNotFoundError, ERROR_HINTS, GoalNotFoundError, InvalidArgumentsError, InvalidTransitionError, LockConflictError, NoAgentsError, NotInitializedError, OrchestryError, TaskAlreadyRunningError, TaskNotFoundError, TeamNotFoundError, WorkspaceError, classifyAdapterError };

package/dist/chunk-45K2XID7.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// src/infrastructure/adapters/registry.ts
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  register(adapter) {
+    this.adapters.set(adapter.kind, adapter);
+  }
+  get(kind) {
+    return this.adapters.get(kind);
+  }
+  require(kind) {
+    const adapter = this.adapters.get(kind);
+    if (!adapter) {
+      throw new Error(`Unknown adapter: "${kind}". Available: ${this.listKinds().join(", ")}`);
+    }
+    return adapter;
+  }
+  list() {
+    return Array.from(this.adapters.values());
+  }
+  listKinds() {
+    return Array.from(this.adapters.keys());
+  }
+  has(kind) {
+    return this.adapters.has(kind);
+  }
+};
+
+export { AdapterRegistry };

package/dist/{shell-IH2MMTVP.js → chunk-52BFUGDD.js}

@@ -1,4 +1,6 @@
-import { readLines } from './chunk-O2MSGW3V.js';
+#!/usr/bin/env node
+import { readLines } from './chunk-CHIP7O6V.js';
+import { classifyAdapterError } from './chunk-2C2TFQ7K.js';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 
@@ -122,7 +124,7 @@ var ShellAdapter = class {
       const version = stdout.split("\n")[0]?.trim() ?? "unknown";
       return { ok: true, version };
     } catch {
-      return { ok: false, error: "bash not found" };
+      return { ok: false, error: "bash not found", errorKind: classifyAdapterError("bash not found") };
     }
   }
   execute(params) {
@@ -132,7 +134,8 @@ var ShellAdapter = class {
         yield {
           type: "error",
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          data: "Shell adapter requires a command in agent config"
+          data: "Shell adapter requires a command in agent config",
+          errorKind: "spawn_failed" /* SPAWN_FAILED */
         };
       }
       return { pid: 0, events: errorGen() };
@@ -179,7 +182,8 @@ var ShellAdapter = class {
           await buffer.push({
             type: "error",
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            data: line
+            data: line,
+            errorKind: classifyAdapterError(line)
           });
         }
       })();
@@ -214,5 +218,3 @@ var ShellAdapter = class {
 };
 
 export { ShellAdapter };
-//# sourceMappingURL=shell-IH2MMTVP.js.map
-//# sourceMappingURL=shell-IH2MMTVP.js.map

package/dist/chunk-7X2GI5OV.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+
+var icons = {
+  running: "\u25CF",
+  todo: "\u25CB",
+  review: "\u25C8",
+  done: "\u2713",
+  failed: "\u2715",
+  retrying: "\u21BB",
+  cancelled: "\u25CB",
+  idle: "\u25CB",
+  error: "\u2715",
+  disabled: "\u2500",
+  agentAction: "\u25B8",
+  orchestratorEvent: "\u2192",
+  warning: "\u26A0"
+};
+var asciiIcons = {
+  running: "*",
+  todo: "o",
+  review: "#",
+  done: "+",
+  failed: "x",
+  retrying: "~",
+  cancelled: "o",
+  idle: "o",
+  error: "x",
+  disabled: "-",
+  agentAction: ">",
+  orchestratorEvent: "->",
+  warning: "!!"
+};
+var COLOR_CODES = {
+  amber: 214,
+  green: 72,
+  red: 167,
+  blue: 74,
+  yellow: 178,
+  dim: 240,
+  ghost: 236,
+  white: 255,
+  purple: 141
+};
+var _colors;
+function getColors() {
+  if (!_colors) {
+    _colors = {};
+    for (const [name, code] of Object.entries(COLOR_CODES)) {
+      _colors[name] = chalk.ansi256(code);
+    }
+  }
+  return _colors;
+}
+var colors = new Proxy({}, {
+  get(_target, prop) {
+    return getColors()[prop];
+  }
+});
+var useAscii = false;
+function setAsciiMode(ascii) {
+  useAscii = ascii;
+}
+function setNoColor(noColor) {
+  if (noColor) {
+    chalk.level = 0;
+  }
+}
+function getIcon(name) {
+  return useAscii ? asciiIcons[name] : icons[name];
+}
+function statusIcon(status) {
+  const icon = getIcon(status);
+  switch (status) {
+    case "running":
+    case "in_progress":
+      return colors.green(getIcon("running"));
+    case "todo":
+      return colors.dim(getIcon("todo"));
+    case "review":
+      return colors.blue(getIcon("review"));
+    case "done":
+      return colors.green(getIcon("done"));
+    case "failed":
+      return colors.red(getIcon("failed"));
+    case "retrying":
+      return colors.yellow(getIcon("retrying"));
+    case "cancelled":
+      return colors.dim(getIcon("cancelled"));
+    case "idle":
+      return colors.dim(getIcon("idle"));
+    case "error":
+      return colors.red(getIcon("error"));
+    case "disabled":
+      return colors.ghost(getIcon("disabled"));
+    default:
+      return icon;
+  }
+}
+function priorityLabel(priority) {
+  switch (priority) {
+    case 1:
+      return colors.red("P1");
+    case 2:
+      return colors.yellow("P2");
+    case 3:
+      return "P3";
+    case 4:
+      return colors.dim("P4");
+    default:
+      return `P${priority}`;
+  }
+}
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  if (minutes < 60) return `${minutes}:${String(secs).padStart(2, "0")}`;
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  return `${hours}h${String(mins).padStart(2, "0")}m`;
+}
+function formatDurationSince(isoDate) {
+  const ms = Date.now() - new Date(isoDate).getTime();
+  return formatDuration(ms);
+}
+function formatTokens(n) {
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+function printError(message, hint) {
+  console.error(`  ${colors.red(getIcon("failed"))} ${message}`);
+  if (hint) {
+    console.error(`    ${hint}`);
+  }
+}
+function printSuccess(message) {
+  console.log(`  ${colors.green(getIcon("done"))} ${message}`);
+}
+function printWarning(message) {
+  console.log(`  ${colors.yellow(getIcon("warning"))} ${message}`);
+}
+function printTable(headers, rows, padding = 2) {
+  const colWidths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => stripAnsi(r[i] ?? "").length))
+  );
+  const headerLine = headers.map((h, i) => h.padEnd(colWidths[i] + padding)).join("");
+  console.log(`  ${colors.dim(headerLine)}`);
+  for (const row of rows) {
+    const line = row.map((cell, i) => {
+      const stripped = stripAnsi(cell);
+      const pad = (colWidths[i] ?? 0) + padding - stripped.length;
+      return cell + " ".repeat(Math.max(0, pad));
+    }).join("");
+    console.log(`  ${line}`);
+  }
+}
+function printKeyValue(pairs) {
+  const maxKey = Math.max(...pairs.map(([k]) => k.length));
+  for (const [key, value] of pairs) {
+    console.log(`  ${colors.dim(key.padEnd(maxKey + 2))}${value}`);
+  }
+}
+function filePath(p) {
+  return colors.purple(p);
+}
+function agentName(name) {
+  return colors.green(name);
+}
+function amber(text) {
+  return colors.amber(text);
+}
+function dim(text) {
+  return colors.dim(text);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+export { agentName, amber, dim, filePath, formatDuration, formatDurationSince, formatTokens, getIcon, printError, printKeyValue, printSuccess, printTable, printWarning, priorityLabel, setAsciiMode, setNoColor, statusIcon };

package/dist/{chunk-HSBYJ5C5.js → chunk-A36WAF2S.js}

@@ -1,5 +1,90 @@
 #!/usr/bin/env node
-import {a}from'./chunk-CHRW4CLD.js';var p=class{engine;renderTimeoutMs;constructor(s){this.renderTimeoutMs=s?.renderTimeoutMs??5e3;}async getEngine(){if(!this.engine){let{Liquid:s}=await import('liquidjs');this.engine=new s({strictFilters:false,strictVariables:false});}return this.engine}async render(s,o){let r=(await this.getEngine()).parseAndRender(s,o);if(this.renderTimeoutMs<=0)return r;let i,n=new Promise((g,a)=>{i=setTimeout(()=>a(new Error(`Template render timed out after ${this.renderTimeoutMs}ms`)),this.renderTimeoutMs);});try{return await Promise.race([r,n])}finally{clearTimeout(i);}}};function y(t,s,o,d,r,i){let{allAgents:n,retryContext:g,sharedContext:a$1,feedback:m,messages:l,goal:u}=i??{},f=new Map((n??[]).map(e=>[e.id,e])),h=l?.length?l.map(e=>({id:e.id,from:f.get(e.from_agent_id)?.name??e.from_agent_id,subject:e.subject,body:e.body,sent_at:e.created_at,reply_to:e.reply_to})):void 0;return {project:{name:r.project.name,description:r.project.description},task:{id:t.id,title:t.title,description:t.description,priority:t.priority,labels:t.labels,scope:t.scope,is_autonomous:t.labels?.includes(a)??false,goal_id:t.goalId},agent:{id:s.id,name:s.name,role:s.role},agents:(n??[]).map(e=>({id:e.id,name:e.name,role:e.role,adapter:e.adapter})),attempt:o>1?o:null,workspace_path:d,retry:o>1?g:void 0,feedback:m,shared_context:a$1&&Object.keys(a$1).length>0?a$1:void 0,messages:h,goal:u}}var b=`You are {{ agent.name }}{% if agent.role %} ({{ agent.role }}){% endif %}.
+import { AUTONOMOUS_LABEL } from './chunk-PNE6LQRF.js';
+
+// src/infrastructure/template/template-engine.ts
+var LiquidTemplateEngine = class {
+  engine;
+  renderTimeoutMs;
+  constructor(options) {
+    this.renderTimeoutMs = options?.renderTimeoutMs ?? 5e3;
+  }
+  async getEngine() {
+    if (!this.engine) {
+      const { Liquid } = await import('liquidjs');
+      this.engine = new Liquid({
+        strictFilters: false,
+        strictVariables: false
+      });
+    }
+    return this.engine;
+  }
+  async render(template, context) {
+    const engine = await this.getEngine();
+    const renderPromise = engine.parseAndRender(template, context);
+    if (this.renderTimeoutMs <= 0) {
+      return renderPromise;
+    }
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`Template render timed out after ${this.renderTimeoutMs}ms`)),
+        this.renderTimeoutMs
+      );
+    });
+    try {
+      return await Promise.race([renderPromise, timeoutPromise]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function buildPromptContext(task, agent, attempt, workspacePath, config, options) {
+  const { allAgents, retryContext, sharedContext, feedback, messages: rawMessages, goal } = options ?? {};
+  const agentById = new Map((allAgents ?? []).map((a) => [a.id, a]));
+  const messages = rawMessages?.length ? rawMessages.map((m) => ({
+    id: m.id,
+    from: agentById.get(m.from_agent_id)?.name ?? m.from_agent_id,
+    subject: m.subject,
+    body: m.body,
+    sent_at: m.created_at,
+    reply_to: m.reply_to
+  })) : void 0;
+  return {
+    project: {
+      name: config.project.name,
+      description: config.project.description
+    },
+    task: {
+      id: task.id,
+      title: task.title,
+      description: task.description,
+      priority: task.priority,
+      labels: task.labels,
+      scope: task.scope,
+      is_autonomous: task.labels?.includes(AUTONOMOUS_LABEL) ?? false,
+      goal_id: task.goalId
+    },
+    agent: {
+      id: agent.id,
+      name: agent.name,
+      role: agent.role
+    },
+    agents: (allAgents ?? []).map((a) => ({
+      id: a.id,
+      name: a.name,
+      role: a.role,
+      adapter: a.adapter
+    })),
+    attempt: attempt > 1 ? attempt : null,
+    workspace_path: workspacePath,
+    retry: attempt > 1 ? retryContext : void 0,
+    feedback,
+    shared_context: sharedContext && Object.keys(sharedContext).length > 0 ? sharedContext : void 0,
+    messages,
+    goal
+  };
+}
+var DEFAULT_PROMPT_TEMPLATE = `You are {{ agent.name }}{% if agent.role %} ({{ agent.role }}){% endif %}.
 
 ## Task: {{ task.title }}
 {{ task.description }}
@@ -109,4 +194,6 @@ This is an autonomous task driven by a goal. Work in a continuous loop until the
 - If critical information is missing, document your assumptions and continue.
 - When a task is too large or spans multiple domains, break it into subtasks using \`orch task add\`.
 - When creating subtasks, use \`--scope\` to declare which files each task will touch, and \`--depends-on\` to order dependent work.
-`;export{p as a,y as b,b as c};
+`;
+
+export { DEFAULT_PROMPT_TEMPLATE, LiquidTemplateEngine, buildPromptContext };