@oxgeneral/orch 0.2.0

package/dist/chunk-O5AO5QIR.js

@@ -0,0 +1,76 @@
+#!/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";
+  }
+};
+
+export { AgentNotFoundError, GoalNotFoundError, InvalidArgumentsError, InvalidTransitionError, LockConflictError, NoAgentsError, NotInitializedError, OrchestryError, TaskAlreadyRunningError, TaskNotFoundError, TeamNotFoundError };

package/dist/chunk-P6ATSXGL.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { mkdtemp, writeFile, readFile, unlink, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { spawn } from 'child_process';
+
+async function openInEditor(initialContent, opts = {}) {
+  const { extension = ".yml", prefix = "orch-" } = opts;
+  const editor = process.env["EDITOR"] || process.env["VISUAL"] || "vi";
+  const dir = await mkdtemp(join(tmpdir(), prefix));
+  const filePath = join(dir, `edit${extension}`);
+  await writeFile(filePath, initialContent, "utf8");
+  try {
+    const parts = editor.split(/\s+/);
+    const child = spawn(parts[0], [...parts.slice(1), filePath], { stdio: "inherit" });
+    await new Promise((resolve, reject) => {
+      child.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Editor exited with code ${code}`));
+      });
+      child.on("error", reject);
+    });
+    return await readFile(filePath, "utf8");
+  } finally {
+    await unlink(filePath).catch(() => {
+    });
+    await rm(dir, { recursive: true }).catch(() => {
+    });
+  }
+}
+function toEditorContent(fields) {
+  const lines = [
+    "---",
+    `title: ${fields.title}`,
+    `priority: ${fields.priority}`,
+    "---",
+    "",
+    fields.description ?? ""
+  ];
+  return lines.join("\n");
+}
+function fromEditorContent(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) {
+    return { description: content.trim() || void 0 };
+  }
+  const frontmatter = match[1] ?? "";
+  const body = match[2] ?? "";
+  const result = {};
+  for (const line of frontmatter.split("\n")) {
+    const kv = line.match(/^([\w]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1];
+    const value = kv[2] ?? "";
+    if (key === "title" && value.trim()) {
+      result.title = value.trim();
+    } else if (key === "priority") {
+      const n = parseInt(value.trim(), 10);
+      if (n >= 1 && n <= 4) result.priority = n;
+    }
+  }
+  const desc = body.trim();
+  if (desc) result.description = desc;
+  return result;
+}
+function agentToEditorContent(fields) {
+  const lines = [
+    "# Edit agent configuration.",
+    "# Lines starting with # are ignored.",
+    "# Role description goes below the second --- separator.",
+    "---",
+    `name: ${fields.name}`,
+    `model: ${fields.model ?? ""}`,
+    "---",
+    "",
+    fields.role ?? ""
+  ];
+  return lines.join("\n");
+}
+function agentFromEditorContent(content) {
+  const lines = content.split("\n");
+  const firstFence = lines.findIndex((l) => l.trimEnd() === "---");
+  const stripped = (firstFence >= 0 ? [...lines.slice(0, firstFence).filter((l) => !l.startsWith("#")), ...lines.slice(firstFence)] : lines.filter((l) => !l.startsWith("#"))).join("\n");
+  const match = stripped.trimStart().match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) {
+    const role = stripped.trim();
+    return { role: role || void 0 };
+  }
+  const frontmatter = match[1] ?? "";
+  const body = match[2] ?? "";
+  const result = {};
+  for (const line of frontmatter.split("\n")) {
+    const kv = line.match(/^([\w]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1];
+    const value = kv[2] ?? "";
+    if (key === "name") {
+      result.name = value.trim();
+    } else if (key === "model") {
+      result.model = value.trim();
+    }
+  }
+  result.role = body.trim();
+  return result;
+}
+
+export { agentFromEditorContent, agentToEditorContent, fromEditorContent, openInEditor, toEditorContent };

package/dist/chunk-PBFE5V3G.js

@@ -0,0 +1,2 @@
+function n(e,t){return {input:e,output:t,total:e+t}}export{n as a};//# sourceMappingURL=chunk-PBFE5V3G.js.map
+//# sourceMappingURL=chunk-PBFE5V3G.js.map

package/dist/chunk-PBFE5V3G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/domain/run.ts"],"names":["createTokenUsage","input","output"],"mappings":"AAqCO,SAASA,CAAAA,CAAiBC,CAAAA,CAAeC,CAAAA,CAA4B,CAC1E,OAAO,CAAE,KAAA,CAAAD,CAAAA,CAAO,MAAA,CAAAC,CAAAA,CAAQ,KAAA,CAAOD,CAAAA,CAAQC,CAAO,CAChD","file":"chunk-PBFE5V3G.js","sourcesContent":["/**\n * Run domain model.\n *\n * A Run represents a single execution attempt of a Task by an Agent.\n * Events are stored in separate .jsonl files (append-only), not in memory.\n */\n\nexport type RunStatus =\n  | 'preparing'\n  | 'running'\n  | 'succeeded'\n  | 'failed'\n  | 'timed_out'\n  | 'cancelled';\n\nexport interface Run {\n  id: string;\n  task_id: string;\n  agent_id: string;\n  attempt: number;\n  status: RunStatus;\n  started_at: string;\n  finished_at?: string;\n  workspace_path: string;\n  prompt: string;\n  pid?: number;\n  error?: string;\n  tokens?: TokenUsage;\n}\n\nexport interface TokenUsage {\n  input: number;\n  output: number;\n  total: number;\n}\n\n/** Create TokenUsage with total always computed as input + output. */\nexport function createTokenUsage(input: number, output: number): TokenUsage {\n  return { input, output, total: input + output };\n}\n\nexport interface RunEvent {\n  timestamp: string;\n  type: RunEventType;\n  data: unknown;\n}\n\nexport type RunEventType =\n  | 'agent_output'\n  | 'file_changed'\n  | 'command_run'\n  | 'tool_call'\n  | 'error'\n  | 'done';\n"]}

package/dist/chunk-PNE6LQRF.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// src/domain/task.ts
+var AUTONOMOUS_LABEL = "autonomous";
+
+export { AUTONOMOUS_LABEL };

package/dist/chunk-POUC4CPC.js

@@ -0,0 +1,2 @@
+import {spawn}from'child_process';var c=class{isAlive(e){try{return process.kill(e,0),!0}catch(n){return n.code==="EPERM"}}kill(e,n="SIGTERM"){try{process.kill(-e,n);}catch{try{process.kill(e,n);}catch{}}}async killWithGrace(e,n=1e4){if(!this.isAlive(e))return;this.kill(e,"SIGTERM");let r=Date.now()+n;for(;Date.now()<r;){if(!this.isAlive(e))return;await new Promise(t=>setTimeout(t,200));}this.kill(e,"SIGKILL");}spawn(e,n,r){let t=spawn(e,n,{stdio:["ignore","pipe","pipe"],detached:true,...r});if(!t.pid)throw new Error(`Failed to spawn process: ${e}`);return t.unref(),{process:t,pid:t.pid}}},u=16384;function p(i){return i.length>u?i.slice(0,u):i}async function*h(i){let e=[],n=0;for await(let r of i){let t=Buffer.isBuffer(r)?r:Buffer.from(r,"utf-8");if(t.length===0)continue;e.push(t),n+=t.length;let o=e.length===1?e[0]:Buffer.concat(e,n);e.length=0,n=0;let s=0,l;for(;(l=o.indexOf(10,s))!==-1;)l>s&&(yield p(o.toString("utf-8",s,l))),s=l+1;if(s<o.length){let a=o.subarray(s);e.push(a),n=a.length;}}if(n>0){let r=e.length===1?e[0]:Buffer.concat(e,n);yield p(r.toString("utf-8"));}}export{c as a,h as b};//# sourceMappingURL=chunk-POUC4CPC.js.map
+//# sourceMappingURL=chunk-POUC4CPC.js.map

package/dist/chunk-POUC4CPC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/infrastructure/process/process-manager.ts"],"names":["ProcessManager","pid","err","signal","graceMs","deadline","r","command","args","options","proc","spawn","MAX_LINE_LEN","capLine","s","readLines","stream","chunks","totalLen","chunk","buf","buffer","offset","newlineIdx","remainder","final"],"mappings":"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","file":"chunk-POUC4CPC.js","sourcesContent":["/**\n * Process management utilities.\n *\n * Handles spawning subprocesses, PID checks, graceful kill.\n */\n\nimport { spawn, type ChildProcess, type SpawnOptions } from 'node:child_process';\nimport type { Readable } from 'node:stream';\n\nexport interface SpawnResult {\n  process: ChildProcess;\n  pid: number;\n}\n\nexport interface IProcessManager {\n  isAlive(pid: number): boolean;\n  kill(pid: number, signal?: NodeJS.Signals): void;\n  killWithGrace(pid: number, graceMs?: number): Promise<void>;\n  spawn(command: string, args: string[], options?: SpawnOptions): SpawnResult;\n}\n\nexport class ProcessManager implements IProcessManager {\n  isAlive(pid: number): boolean {\n    try {\n      process.kill(pid, 0);\n      return true;\n    } catch (err) {\n      // EPERM means process exists but we lack permission to signal it\n      if ((err as NodeJS.ErrnoException).code === 'EPERM') return true;\n      return false;\n    }\n  }\n\n  kill(pid: number, signal: NodeJS.Signals = 'SIGTERM'): void {\n    // Kill entire process group (-pid) to clean up child processes (vitest, playwright, etc.)\n    try {\n      process.kill(-pid, signal);\n    } catch {\n      // Group kill failed — fall back to direct PID kill\n      try {\n        process.kill(pid, signal);\n      } catch {\n        // Process already dead\n      }\n    }\n  }\n\n  async killWithGrace(pid: number, graceMs: number = 10_000): Promise<void> {\n    if (!this.isAlive(pid)) return;\n\n    this.kill(pid, 'SIGTERM');\n\n    const deadline = Date.now() + graceMs;\n\n    while (Date.now() < deadline) {\n      if (!this.isAlive(pid)) return;\n      await new Promise((r) => setTimeout(r, 200));\n    }\n\n    // Force kill if still alive\n    this.kill(pid, 'SIGKILL');\n  }\n\n  spawn(command: string, args: string[], options?: SpawnOptions): SpawnResult {\n    const proc = spawn(command, args, {\n      stdio: ['ignore', 'pipe', 'pipe'],\n      detached: true, // Create new process group so killWithGrace(-pid) kills all children\n      ...options,\n    });\n\n    if (!proc.pid) {\n      throw new Error(`Failed to spawn process: ${command}`);\n    }\n\n    // Allow parent to exit without waiting for this child.\n    // Pipes (stdout/stderr) still hold refs while being read — that's intentional.\n    proc.unref();\n\n    return { process: proc, pid: proc.pid };\n  }\n}\n\n/**\n * Max stdout line length before truncation (16 KB).\n * First layer of a three-layer cap: readLines (16 KB) → serializeEventData (8 KB) → bus emit (4 KB).\n * Truncated lines produce invalid JSON → adapters' catch block handles gracefully.\n */\nconst MAX_LINE_LEN = 16384;\n\n/** Cap a string to MAX_LINE_LEN. */\nfunction capLine(s: string): string {\n  return s.length > MAX_LINE_LEN ? s.slice(0, MAX_LINE_LEN) : s;\n}\n\n/**\n * Read lines from a readable stream as an async generator.\n *\n * Uses `for await` on the raw Readable (proper backpressure) instead of\n * readline.createInterface, which buffers all 'line' events in an unbounded\n * queue even when the consumer is paused — causing OOM under high throughput.\n *\n * Uses Buffer.concat + offset tracking to avoid O(n²) string copies.\n */\nexport async function* readLines(stream: Readable): AsyncGenerator<string> {\n  const chunks: Buffer[] = [];\n  let totalLen = 0;\n\n  for await (const chunk of stream) {\n    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as string, 'utf-8');\n    if (buf.length === 0) continue;\n    chunks.push(buf);\n    totalLen += buf.length;\n\n    // Concat once per chunk arrival, then scan for newlines with offset tracking\n    const buffer = chunks.length === 1 ? chunks[0]! : Buffer.concat(chunks, totalLen);\n    chunks.length = 0;\n    totalLen = 0;\n\n    let offset = 0;\n    let newlineIdx: number;\n    while ((newlineIdx = buffer.indexOf(0x0a, offset)) !== -1) {\n      if (newlineIdx > offset) {\n        yield capLine(buffer.toString('utf-8', offset, newlineIdx));\n      }\n      offset = newlineIdx + 1;\n    }\n\n    // Keep unconsumed remainder for next chunk\n    if (offset < buffer.length) {\n      const remainder = buffer.subarray(offset);\n      chunks.push(remainder);\n      totalLen = remainder.length;\n    }\n  }\n\n  // Flush remaining data (last line without trailing newline)\n  if (totalLen > 0) {\n    const final = chunks.length === 1 ? chunks[0]! : Buffer.concat(chunks, totalLen);\n    yield capLine(final.toString('utf-8'));\n  }\n}\n"]}

package/dist/chunk-TX7WOFCW.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { readLines } from './chunk-CHIP7O6V.js';
+
+// src/domain/run.ts
+function createTokenUsage(input, output) {
+  return { input, output, total: input + output };
+}
+
+// src/infrastructure/adapters/utils.ts
+function extractTokens(parsed, opts) {
+  let usage = parsed.usage;
+  if (!usage && opts?.statsFallback) {
+    const stats = parsed.stats;
+    usage = stats?.usage;
+  }
+  if (usage && typeof usage.input_tokens === "number") {
+    const input = usage.input_tokens;
+    const output = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+    return createTokenUsage(input, output);
+  }
+  return void 0;
+}
+function createStreamingEvents(proc, parseEvent, adapterName, signal) {
+  async function* generate() {
+    let gotDoneEvent = false;
+    let exitCode = null;
+    let exitError = null;
+    const exitPromise = new Promise((resolve) => {
+      proc.on("close", (code) => {
+        exitCode = code;
+        resolve();
+      });
+      proc.on("error", (err) => {
+        exitError = err;
+        resolve();
+      });
+    });
+    if (proc.stdout) {
+      for await (const line of readLines(proc.stdout)) {
+        if (signal?.aborted) break;
+        const event = parseEvent(line);
+        if (event) {
+          if (event.type === "done") gotDoneEvent = true;
+          yield event;
+        }
+      }
+    }
+    await exitPromise;
+    if (exitError && !signal?.aborted && !gotDoneEvent) {
+      throw exitError;
+    }
+    if (exitCode !== 0 && exitCode !== null && !signal?.aborted && !gotDoneEvent) {
+      throw new Error(`${adapterName} process exited with code ${exitCode}`);
+    }
+  }
+  return generate();
+}
+
+export { createStreamingEvents, extractTokens };

package/dist/chunk-VTA74YWX.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+import { NotInitializedError } from './chunk-O5AO5QIR.js';
+import { randomBytes } from 'crypto';
+import fs from 'fs/promises';
+import path2 from 'path';
+import yaml from 'js-yaml';
+import { accessSync } from 'fs';
+
+async function atomicWrite(filePath, content) {
+  const dir = path2.dirname(filePath);
+  await ensureDir(dir);
+  const tmpPath = path2.join(dir, `.${path2.basename(filePath)}.${randomBytes(4).toString("hex")}.tmp`);
+  try {
+    await fs.writeFile(tmpPath, content, "utf-8");
+    await fs.rename(tmpPath, filePath);
+  } catch (err) {
+    await fs.unlink(tmpPath).catch(() => {
+    });
+    throw err;
+  }
+}
+async function readYaml(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return yaml.load(content);
+  } catch (err) {
+    if (isENOENT(err)) return null;
+    throw err;
+  }
+}
+async function writeYaml(filePath, data) {
+  const content = yaml.dump(data, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  });
+  await atomicWrite(filePath, content);
+}
+async function readJson(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (isENOENT(err)) return null;
+    throw err;
+  }
+}
+async function writeJson(filePath, data) {
+  const content = JSON.stringify(data, null, 2) + "\n";
+  await atomicWrite(filePath, content);
+}
+var PIPE_BUF = 4096;
+async function appendJsonl(filePath, record) {
+  const dir = path2.dirname(filePath);
+  await ensureDir(dir);
+  let line = JSON.stringify(record) + "\n";
+  const byteLen = Buffer.byteLength(line, "utf-8");
+  if (byteLen > PIPE_BUF && record !== null && typeof record === "object") {
+    const obj = record;
+    if (typeof obj.data === "string" && obj.data.length > 0) {
+      const shell = JSON.stringify({ ...obj, data: "" }) + "\n";
+      const overhead = Buffer.byteLength(shell, "utf-8");
+      const budget = PIPE_BUF - overhead - 3;
+      if (budget > 0) {
+        const truncated = obj.data.slice(0, budget);
+        line = JSON.stringify({ ...obj, data: truncated + "\u2026" }) + "\n";
+      }
+    }
+  }
+  const fd = await fs.open(filePath, "a");
+  try {
+    await fd.write(line, null, "utf-8");
+  } finally {
+    await fd.close();
+  }
+}
+var MAX_JSONL_READ_SIZE = 50 * 1024 * 1024;
+async function readJsonl(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    if (stat.size > MAX_JSONL_READ_SIZE) {
+      process.stderr.write(
+        `[readJsonl] file too large (${(stat.size / 1024 / 1024).toFixed(1)} MB), reading tail only: ${filePath}
+`
+      );
+      return readJsonlTail(filePath, 200);
+    }
+    return readAndParseJsonl(filePath);
+  } catch (err) {
+    if (isENOENT(err)) return [];
+    throw err;
+  }
+}
+async function readJsonlTail(filePath, count) {
+  try {
+    const stat = await fs.stat(filePath);
+    if (stat.size < 32768) {
+      return (await readAndParseJsonl(filePath)).slice(-count);
+    }
+    const fd = await fs.open(filePath, "r");
+    try {
+      const chunkSize = Math.min(stat.size, stat.size > 1048576 ? 131072 : 65536);
+      let position = Math.max(0, stat.size - chunkSize);
+      let earliestReadPosition = position;
+      let tail = "";
+      for (let attempt = 0; attempt < 4 && position >= 0; attempt++) {
+        earliestReadPosition = position;
+        const readSize = Math.min(chunkSize, stat.size - position);
+        const buf = Buffer.alloc(readSize);
+        await fd.read(buf, 0, readSize, position);
+        tail = buf.toString("utf-8") + tail;
+        const lines2 = tail.split("\n").filter((l) => l.trim().length > 0);
+        if (lines2.length >= count + 1) {
+          return parseJsonlLines(lines2.slice(-count));
+        }
+        if (position === 0) break;
+        position = Math.max(0, position - chunkSize);
+      }
+      const lines = tail.split("\n").filter((l) => l.trim().length > 0);
+      const safeLines = earliestReadPosition > 0 ? lines.slice(1) : lines;
+      return parseJsonlLines(safeLines.slice(-count));
+    } finally {
+      await fd.close();
+    }
+  } catch (err) {
+    if (isENOENT(err)) return [];
+    throw err;
+  }
+}
+async function readAndParseJsonl(filePath) {
+  const content = await fs.readFile(filePath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim().length > 0);
+  return parseJsonlLines(lines);
+}
+function parseJsonlLines(lines) {
+  const results = [];
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    try {
+      results.push(JSON.parse(line));
+    } catch {
+      process.stderr.write(`[readJsonl] skipping corrupt line: ${line.slice(0, 200)}
+`);
+    }
+  }
+  return results;
+}
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listFiles(dirPath, ext) {
+  try {
+    const entries = await fs.readdir(dirPath);
+    if (ext) {
+      return entries.filter((e) => e.endsWith(ext));
+    }
+    return entries;
+  } catch (err) {
+    if (isENOENT(err)) return [];
+    throw err;
+  }
+}
+function isENOENT(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+var ORCHESTRY_DIR = ".orchestry";
+var ID_PATTERN = /^[A-Za-z0-9._-]+$/;
+var Paths = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  /** Root .orchestry/ directory */
+  get root() {
+    return path2.join(this.projectRoot, ORCHESTRY_DIR);
+  }
+  get configPath() {
+    return path2.join(this.root, "config.yml");
+  }
+  get statePath() {
+    return path2.join(this.root, "state.json");
+  }
+  get lockPath() {
+    return path2.join(this.root, "orchestry.lock");
+  }
+  get tasksDir() {
+    return path2.join(this.root, "tasks");
+  }
+  get agentsDir() {
+    return path2.join(this.root, "agents");
+  }
+  get runsDir() {
+    return path2.join(this.root, "runs");
+  }
+  get templatesDir() {
+    return path2.join(this.root, "templates");
+  }
+  get logsDir() {
+    return path2.join(this.root, "logs");
+  }
+  get contextDir() {
+    return path2.join(this.root, "context");
+  }
+  contextPath(key) {
+    return path2.join(this.contextDir, `${sanitizeId(key)}.json`);
+  }
+  get messagesDir() {
+    return path2.join(this.root, "messages");
+  }
+  messagePath(id) {
+    return path2.join(this.messagesDir, `${sanitizeId(id)}.json`);
+  }
+  get goalsDir() {
+    return path2.join(this.root, "goals");
+  }
+  goalPath(id) {
+    return path2.join(this.goalsDir, `${sanitizeId(id)}.yml`);
+  }
+  get teamsDir() {
+    return path2.join(this.root, "teams");
+  }
+  teamPath(id) {
+    return path2.join(this.teamsDir, `${sanitizeId(id)}.yml`);
+  }
+  get gitignorePath() {
+    return path2.join(this.root, ".gitignore");
+  }
+  get workspaceExcludePath() {
+    return path2.join(this.root, "workspace-exclude");
+  }
+  taskPath(id) {
+    return path2.join(this.tasksDir, `${sanitizeId(id)}.yml`);
+  }
+  agentPath(id) {
+    return path2.join(this.agentsDir, `${sanitizeId(id)}.yml`);
+  }
+  runPath(id) {
+    return path2.join(this.runsDir, `${sanitizeId(id)}.json`);
+  }
+  runEventsPath(id) {
+    return path2.join(this.runsDir, `${sanitizeId(id)}.jsonl`);
+  }
+  defaultTemplatePath() {
+    return path2.join(this.templatesDir, "default.md");
+  }
+  async isInitialized() {
+    return pathExists(this.root);
+  }
+  async requireInit() {
+    if (!await this.isInitialized()) {
+      throw new NotInitializedError();
+    }
+  }
+};
+function sanitizeId(id) {
+  if (!ID_PATTERN.test(id)) {
+    throw new Error(`Invalid identifier: "${id}"`);
+  }
+  return id;
+}
+function validateWorkspacePath(workspacePath, projectRoot) {
+  const resolved = path2.resolve(workspacePath);
+  const root = path2.resolve(projectRoot);
+  if (!resolved.startsWith(root + path2.sep) && resolved !== root) {
+    throw new Error(`Workspace path "${workspacePath}" is outside project root`);
+  }
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = path2.resolve(startDir);
+  const root = path2.parse(dir).root;
+  while (dir !== root) {
+    try {
+      accessSync(path2.join(dir, ".orchestry"));
+      return dir;
+    } catch {
+    }
+    dir = path2.dirname(dir);
+  }
+  return startDir;
+}
+
+export { Paths, appendJsonl, atomicWrite, ensureDir, findProjectRoot, listFiles, pathExists, readJson, readJsonl, readJsonlTail, readYaml, sanitizeId, validateWorkspacePath, writeJson, writeYaml };

package/dist/chunk-XI4TU6VU.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+var execFileAsync = promisify(execFile);
+var DoctorService = class {
+  constructor(adapterRegistry, processManager) {
+    this.adapterRegistry = adapterRegistry;
+    this.processManager = processManager;
+  }
+  async runAll() {
+    const checks = [];
+    const adapters = this.adapterRegistry.list();
+    let adaptersReady = 0;
+    for (const adapter of adapters) {
+      const result = await adapter.test();
+      if (result.ok) {
+        adaptersReady++;
+        checks.push({
+          name: adapter.kind,
+          status: "ok",
+          detail: result.version
+        });
+      } else {
+        checks.push({
+          name: adapter.kind,
+          status: "fail",
+          detail: result.error
+        });
+      }
+    }
+    checks.push(await this.checkCommand("git", ["--version"], "git"));
+    checks.push(await this.checkCommand("node", ["--version"], "node"));
+    return {
+      checks,
+      adaptersReady,
+      adaptersTotal: adapters.length
+    };
+  }
+  async checkCommand(command, args, name) {
+    try {
+      const { stdout } = await execFileAsync(command, args);
+      return { name, status: "ok", detail: stdout.trim() };
+    } catch {
+      return { name, status: "fail", detail: `${command}: command not found` };
+    }
+  }
+};
+
+export { DoctorService };

package/dist/chunk-ZU6AY2VU.js

@@ -0,0 +1,2 @@
+var t=class extends Error{constructor(r,e,h){super(r);this.exitCode=e;this.hint=h;this.name="OrchestryError";}},o=class extends t{constructor(){super("Not initialized",3,"Run: orch init"),this.name="NotInitializedError";}},a=class extends t{constructor(s){super(s,2),this.name="InvalidArgumentsError";}},c=class extends t{constructor(s){super(`Orchestrator already running (PID: ${s})`,4,"Use: orch status"),this.name="LockConflictError";}};var i=class extends t{constructor(){super("No agents configured",1,"Run: orch agent add <name> --adapter claude"),this.name="NoAgentsError";}},u=class extends t{constructor(s){super(`Task not found: ${s}`,1),this.name="TaskNotFoundError";}},d=class extends t{constructor(s){super(`Agent not found: ${s}`,1),this.name="AgentNotFoundError";}},p=class extends t{constructor(s,r,e){super(`Task ${s} is already running (run: ${r}, agent: ${e})`,1,`Use: orch logs --task ${s} --follow`),this.name="TaskAlreadyRunningError";}},l=class extends t{constructor(s,r,e){super(`Invalid transition for ${s}: ${r} \u2192 ${e}`,1),this.name="InvalidTransitionError";}},x=class extends t{constructor(s){super(`Goal not found: ${s}`,1),this.name="GoalNotFoundError";}},g=class extends t{constructor(s){super(`Team not found: ${s}`,1),this.name="TeamNotFoundError";}};export{t as a,o as b,a as c,c as d,i as e,u as f,d as g,p as h,l as i,x as j,g as k};//# sourceMappingURL=chunk-ZU6AY2VU.js.map
+//# sourceMappingURL=chunk-ZU6AY2VU.js.map

package/dist/chunk-ZU6AY2VU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/domain/errors.ts"],"names":["OrchestryError","message","exitCode","hint","NotInitializedError","InvalidArgumentsError","LockConflictError","pid","NoAgentsError","TaskNotFoundError","taskId","AgentNotFoundError","agentId","TaskAlreadyRunningError","runId","agentName","InvalidTransitionError","from","to","GoalNotFoundError","goalId","TeamNotFoundError","teamId"],"mappings":"AAeO,IAAMA,CAAAA,CAAN,cAA6B,KAAM,CACxC,YACEC,CAAAA,CACgBC,CAAAA,CACAC,CAAAA,CAChB,CACA,KAAA,CAAMF,CAAO,EAHG,IAAA,CAAA,QAAA,CAAAC,CAAAA,CACA,UAAAC,CAAAA,CAGhB,IAAA,CAAK,KAAO,iBACd,CACF,CAAA,CAEaC,CAAAA,CAAN,cAAkCJ,CAAe,CACtD,WAAA,EAAc,CACZ,MAAM,iBAAA,CAAmB,CAAA,CAAG,gBAAgB,CAAA,CAC5C,IAAA,CAAK,IAAA,CAAO,sBACd,CACF,CAAA,CAEaK,EAAN,cAAoCL,CAAe,CACxD,WAAA,CAAYC,CAAAA,CAAiB,CAC3B,MAAMA,CAAAA,CAAS,CAAC,CAAA,CAChB,IAAA,CAAK,IAAA,CAAO,wBACd,CACF,CAAA,CAEaK,CAAAA,CAAN,cAAgCN,CAAe,CACpD,YAAYO,CAAAA,CAAa,CACvB,KAAA,CAAM,CAAA,mCAAA,EAAsCA,CAAG,CAAA,CAAA,CAAA,CAAK,EAAG,kBAAkB,CAAA,CACzE,IAAA,CAAK,IAAA,CAAO,oBACd,CACF,EASO,IAAMC,CAAAA,CAAN,cAA4BR,CAAe,CAChD,WAAA,EAAc,CACZ,KAAA,CAAM,sBAAA,CAAwB,EAAG,6CAA6C,CAAA,CAC9E,KAAK,IAAA,CAAO,gBACd,CACF,CAAA,CAEaS,CAAAA,CAAN,cAAgCT,CAAe,CACpD,WAAA,CAAYU,CAAAA,CAAgB,CAC1B,KAAA,CAAM,CAAA,gBAAA,EAAmBA,CAAM,CAAA,CAAA,CAAI,CAAC,CAAA,CACpC,IAAA,CAAK,IAAA,CAAO,oBACd,CACF,CAAA,CAEaC,CAAAA,CAAN,cAAiCX,CAAe,CACrD,YAAYY,CAAAA,CAAiB,CAC3B,KAAA,CAAM,CAAA,iBAAA,EAAoBA,CAAO,CAAA,CAAA,CAAI,CAAC,CAAA,CACtC,IAAA,CAAK,KAAO,qBACd,CACF,EAEaC,CAAAA,CAAN,cAAsCb,CAAe,CAC1D,WAAA,CAAYU,CAAAA,CAAgBI,EAAeC,CAAAA,CAAmB,CAC5D,MACE,CAAA,KAAA,EAAQL,CAAM,6BAA6BI,CAAK,CAAA,SAAA,EAAYC,CAAS,CAAA,CAAA,CAAA,CACrE,CAAA,CACA,CAAA,sBAAA,EAAyBL,CAAM,CAAA,SAAA,CACjC,CAAA,CACA,IAAA,CAAK,IAAA,CAAO,0BACd,CACF,EAEaM,CAAAA,CAAN,cAAqChB,CAAe,CACzD,WAAA,CAAYU,CAAAA,CAAgBO,EAAcC,CAAAA,CAAY,CACpD,MAAM,CAAA,uBAAA,EAA0BR,CAAM,KAAKO,CAAI,CAAA,QAAA,EAAMC,CAAE,CAAA,CAAA,CAAI,CAAC,CAAA,CAC5D,KAAK,IAAA,CAAO,yBACd,CACF,CAAA,CAEaC,CAAAA,CAAN,cAAgCnB,CAAe,CACpD,WAAA,CAAYoB,CAAAA,CAAgB,CAC1B,KAAA,CAAM,CAAA,gBAAA,EAAmBA,CAAM,CAAA,CAAA,CAAI,CAAC,EACpC,IAAA,CAAK,IAAA,CAAO,oBACd,CACF,CAAA,CAEaC,CAAAA,CAAN,cAAgCrB,CAAe,CACpD,YAAYsB,CAAAA,CAAgB,CAC1B,KAAA,CAAM,CAAA,gBAAA,EAAmBA,CAAM,CAAA,CAAA,CAAI,CAAC,CAAA,CACpC,IAAA,CAAK,IAAA,CAAO,oBACd,CACF","file":"chunk-ZU6AY2VU.js","sourcesContent":["/**\n * Typed error hierarchy for the orchestrator.\n *\n * Every error carries an exit code (matching CLI_UI_DESIGN.md §11)\n * and an optional hint for the user.\n *\n * Exit codes:\n *   0 - Success\n *   1 - General error\n *   2 - Invalid arguments\n *   3 - Not initialized (.orchestry/ not found)\n *   4 - Lock conflict (orchestrator already running)\n *   5 - Agent error (adapter test failed)\n */\n\nexport class OrchestryError extends Error {\n  constructor(\n    message: string,\n    public readonly exitCode: number,\n    public readonly hint?: string,\n  ) {\n    super(message);\n    this.name = 'OrchestryError';\n  }\n}\n\nexport class NotInitializedError extends OrchestryError {\n  constructor() {\n    super('Not initialized', 3, 'Run: orch init');\n    this.name = 'NotInitializedError';\n  }\n}\n\nexport class InvalidArgumentsError extends OrchestryError {\n  constructor(message: string) {\n    super(message, 2);\n    this.name = 'InvalidArgumentsError';\n  }\n}\n\nexport class LockConflictError extends OrchestryError {\n  constructor(pid: number) {\n    super(`Orchestrator already running (PID: ${pid})`, 4, 'Use: orch status');\n    this.name = 'LockConflictError';\n  }\n}\n\nexport class AgentAdapterError extends OrchestryError {\n  constructor(adapter: string, detail: string) {\n    super(`Agent adapter \"${adapter}\" not available`, 5, detail);\n    this.name = 'AgentAdapterError';\n  }\n}\n\nexport class NoAgentsError extends OrchestryError {\n  constructor() {\n    super('No agents configured', 1, 'Run: orch agent add <name> --adapter claude');\n    this.name = 'NoAgentsError';\n  }\n}\n\nexport class TaskNotFoundError extends OrchestryError {\n  constructor(taskId: string) {\n    super(`Task not found: ${taskId}`, 1);\n    this.name = 'TaskNotFoundError';\n  }\n}\n\nexport class AgentNotFoundError extends OrchestryError {\n  constructor(agentId: string) {\n    super(`Agent not found: ${agentId}`, 1);\n    this.name = 'AgentNotFoundError';\n  }\n}\n\nexport class TaskAlreadyRunningError extends OrchestryError {\n  constructor(taskId: string, runId: string, agentName: string) {\n    super(\n      `Task ${taskId} is already running (run: ${runId}, agent: ${agentName})`,\n      1,\n      `Use: orch logs --task ${taskId} --follow`,\n    );\n    this.name = 'TaskAlreadyRunningError';\n  }\n}\n\nexport class InvalidTransitionError extends OrchestryError {\n  constructor(taskId: string, from: string, to: string) {\n    super(`Invalid transition for ${taskId}: ${from} → ${to}`, 1);\n    this.name = 'InvalidTransitionError';\n  }\n}\n\nexport class GoalNotFoundError extends OrchestryError {\n  constructor(goalId: string) {\n    super(`Goal not found: ${goalId}`, 1);\n    this.name = 'GoalNotFoundError';\n  }\n}\n\nexport class TeamNotFoundError extends OrchestryError {\n  constructor(teamId: string) {\n    super(`Team not found: ${teamId}`, 1);\n    this.name = 'TeamNotFoundError';\n  }\n}\n\nexport class MessageNotFoundError extends OrchestryError {\n  constructor(messageId: string) {\n    super(`Message not found: ${messageId}`, 1);\n    this.name = 'MessageNotFoundError';\n  }\n}\n"]}

package/dist/claude-GH6P2DC5.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export { ClaudeAdapter } from './chunk-IRN2U2NE.js';
+import './chunk-TX7WOFCW.js';
+import './chunk-CHIP7O6V.js';

package/dist/claude-S47YTIHU.js

@@ -0,0 +1,2 @@
+import {b,a as a$1}from'./chunk-IZYSGYXG.js';import'./chunk-PBFE5V3G.js';import'./chunk-POUC4CPC.js';import {execFile}from'child_process';import {promisify}from'util';var l=promisify(execFile),a=class{constructor(e){this.processManager=e;}kind="claude";async test(){try{let{stdout:e}=await l("claude",["--version"]);return {ok:!0,version:e.trim()}}catch{return {ok:false,error:"Claude Code CLI not found. Install: npm i -g @anthropic-ai/claude-code"}}}execute(e){let t=["--print","--output-format","stream-json","--max-turns",String(e.config.max_turns??50),"--verbose","--dangerously-skip-permissions"];e.config.model&&t.push("--model",e.config.model),e.config.system_prompt&&t.push("--system-prompt",e.config.system_prompt),t.push(e.prompt);let{process:s,pid:c}=this.processManager.spawn("claude",t,{cwd:e.workspace,env:{...process.env,...e.env},signal:e.signal}),u=b(s,d,"Claude",e.signal);return {pid:c,events:u}}async stop(e){await this.processManager.killWithGrace(e);}};function d(r){if(!r.trim())return null;try{let e=JSON.parse(r),t=new Date().toISOString();switch(e.type){case "assistant":return {type:"output",timestamp:t,data:e.message??e};case "tool_use":return {type:"tool_call",timestamp:t,data:e};case "tool_result":return {type:"output",timestamp:t,data:e};case "error":return {type:"error",timestamp:t,data:e.error??e};case "result":{let s=a$1(e,{statsFallback:!0});return {type:"done",timestamp:t,data:e,tokens:s}}default:return {type:"output",timestamp:t,data:e}}}catch{return {type:"output",timestamp:new Date().toISOString(),data:r}}}export{a as ClaudeAdapter};//# sourceMappingURL=claude-S47YTIHU.js.map
+//# sourceMappingURL=claude-S47YTIHU.js.map

package/dist/claude-S47YTIHU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/infrastructure/adapters/claude.ts"],"names":["execFileAsync","promisify","execFile","ClaudeAdapter","processManager","stdout","params","args","proc","pid","events","createStreamingEvents","parseClaudeEvent","line","parsed","timestamp","tokens","extractTokens"],"mappings":"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","file":"claude-S47YTIHU.js","sourcesContent":["/**\n * Claude Code adapter.\n *\n * Spawns `claude --print --output-format stream-json` in headless mode.\n * Parses JSON-lines from stdout into AgentEvent stream.\n */\n\nimport type { IAgentAdapter, AdapterTestResult, ExecuteParams, AgentEvent, ExecuteHandle } from './interface.js';\nimport type { IProcessManager } from '../process/process-manager.js';\nimport { extractTokens, createStreamingEvents } from './utils.js';\nimport { execFile } from 'node:child_process';\nimport { promisify } from 'node:util';\n\nconst execFileAsync = promisify(execFile);\n\nexport class ClaudeAdapter implements IAgentAdapter {\n  readonly kind = 'claude';\n\n  constructor(private readonly processManager: IProcessManager) {}\n\n  async test(): Promise<AdapterTestResult> {\n    try {\n      const { stdout } = await execFileAsync('claude', ['--version']);\n      return { ok: true, version: stdout.trim() };\n    } catch {\n      return {\n        ok: false,\n        error: 'Claude Code CLI not found. Install: npm i -g @anthropic-ai/claude-code',\n      };\n    }\n  }\n\n  execute(params: ExecuteParams): ExecuteHandle {\n    const args = [\n      '--print',\n      '--output-format', 'stream-json',\n      '--max-turns', String(params.config.max_turns ?? 50),\n      '--verbose',\n      '--dangerously-skip-permissions', // Agents run autonomously; stdin is 'ignore' so prompts would hang\n    ];\n\n    if (params.config.model) {\n      args.push('--model', params.config.model);\n    }\n\n    if (params.config.system_prompt) {\n      args.push('--system-prompt', params.config.system_prompt);\n    }\n\n    args.push(params.prompt);\n\n    const { process: proc, pid } = this.processManager.spawn('claude', args, {\n      cwd: params.workspace,\n      env: { ...process.env, ...params.env },\n      signal: params.signal,\n    });\n\n    const events = createStreamingEvents(proc, parseClaudeEvent, 'Claude', params.signal);\n\n    return { pid, events };\n  }\n\n  async stop(pid: number): Promise<void> {\n    await this.processManager.killWithGrace(pid);\n  }\n}\n\nfunction parseClaudeEvent(line: string): AgentEvent | null {\n  if (!line.trim()) return null;\n\n  try {\n    const parsed: Record<string, unknown> = JSON.parse(line);\n    const timestamp = new Date().toISOString();\n\n    switch (parsed.type) {\n      case 'assistant':\n        return { type: 'output', timestamp, data: (parsed.message as unknown) ?? parsed };\n      case 'tool_use':\n        return { type: 'tool_call', timestamp, data: parsed };\n      case 'tool_result':\n        return { type: 'output', timestamp, data: parsed };\n      case 'error':\n        return { type: 'error', timestamp, data: (parsed.error as unknown) ?? parsed };\n      case 'result': {\n        const tokens = extractTokens(parsed, { statsFallback: true });\n        return { type: 'done', timestamp, data: parsed, tokens };\n      }\n      default:\n        return { type: 'output', timestamp, data: parsed };\n    }\n  } catch {\n    return { type: 'output', timestamp: new Date().toISOString(), data: line };\n  }\n}\n"]}