godmode 0.0.2 → 0.0.3

package/dist/dist-I5CEQ4AC.js

@@ -0,0 +1,779 @@
+#!/usr/bin/env node
+import {
+  HelpPage
+} from "./chunk-YDXTIN53.js";
+
+// ../../commands/agent/dist/index.js
+import { spawnSync } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+import { closeSync, existsSync as existsSync2, openSync, readFileSync as readFileSync2, readSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { randomUUID } from "crypto";
+import { mkdirSync, readFileSync, writeFileSync, existsSync, readdirSync } from "fs";
+import { homedir } from "os";
+import { resolve } from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var DEFAULT_HARNESS_ORDER = ["claude", "codex", "gemini", "pi"];
+var HARNESSES = {
+  claude: {
+    id: "claude",
+    displayName: "Claude Code",
+    command: "claude",
+    modelFlags: ["--model"],
+    effortFlags: ["--effort"],
+    helpArgs: ["--help"],
+    promptHints: ["[prompt]", "your prompt"],
+    buildTurnArgs: ({ prompt, model, effort, passthroughArgs, resumeToken }) => [
+      "-p",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+      ...resumeToken ? ["--resume", resumeToken] : [],
+      ...model ? ["--model", model] : [],
+      ...effort ? ["--effort", effort] : [],
+      prompt,
+      ...passthroughArgs
+    ]
+  },
+  codex: {
+    id: "codex",
+    displayName: "Codex CLI",
+    command: "codex",
+    modelFlags: ["-m", "--model"],
+    effortFlags: [],
+    helpArgs: ["--help"],
+    promptHints: ["[prompt]", "optional user prompt"],
+    buildTurnArgs: ({ prompt, model, passthroughArgs }) => [
+      "exec",
+      "--json",
+      ...model ? ["-m", model] : [],
+      prompt,
+      ...passthroughArgs
+    ]
+  },
+  gemini: {
+    id: "gemini",
+    displayName: "Gemini CLI",
+    command: "gemini",
+    modelFlags: ["-m", "--model"],
+    effortFlags: [],
+    helpArgs: ["--help"],
+    promptHints: ["query", "initial prompt"],
+    buildTurnArgs: ({ prompt, model, passthroughArgs, resumeToken }) => [
+      ...resumeToken ? ["--resume", resumeToken] : [],
+      ...model ? ["-m", model] : [],
+      "-p",
+      prompt,
+      "-o",
+      "stream-json",
+      ...passthroughArgs
+    ]
+  },
+  pi: {
+    id: "pi",
+    displayName: "Pi",
+    command: "pi",
+    modelFlags: ["--model"],
+    effortFlags: ["--thinking"],
+    helpArgs: ["--help"],
+    promptHints: ["[messages...]", "initial prompt"],
+    buildTurnArgs: ({ prompt, model, effort, passthroughArgs, resumeToken, sessionDir }) => [
+      "--print",
+      "--mode",
+      "json",
+      ...sessionDir ? ["--session-dir", sessionDir] : [],
+      ...resumeToken ? ["--continue"] : [],
+      ...model ? ["--model", model] : [],
+      ...effort ? ["--thinking", effort] : [],
+      prompt,
+      ...passthroughArgs
+    ]
+  }
+};
+function detectHarness(executor, requested) {
+  const ids = requested ? [requested] : DEFAULT_HARNESS_ORDER;
+  for (const id of ids) {
+    const harness = HARNESSES[id];
+    const result = executor(harness.command, harness.helpArgs);
+    if (!result.error && result.status === 0) return harness;
+  }
+  throw new Error(requested ? `Harness "${requested}" not found.` : "No supported coding harness found.");
+}
+function event(ts, id, turn, partial) {
+  return { ts, id, turn, ...partial };
+}
+function normalizeTurn(harness, id, turn, stdout, stderr, ts) {
+  const lines = stdout.split(/\r?\n/);
+  if (harness === "claude") return parseClaude(lines, id, turn, stderr, ts);
+  if (harness === "gemini") return parseGemini(lines, id, turn, stderr, ts);
+  if (harness === "pi") return parsePi(lines, id, turn, stderr, ts);
+  return {
+    sessionId: null,
+    assistantText: stdout.trim(),
+    events: [
+      event(ts, id, turn, { type: "turn.started" }),
+      event(ts, id, turn, { type: "assistant.completed", text: stdout.trim() }),
+      event(ts, id, turn, { type: "turn.completed", status: "completed" })
+    ]
+  };
+}
+function parseClaude(lines, id, turn, stderr, ts) {
+  const events = [];
+  let sessionId = null;
+  let assistantText = "";
+  let usage;
+  let timing;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (parsed.type === "system" && parsed.subtype === "init") {
+      sessionId = parsed.session_id ?? sessionId;
+      events.push(event(ts, id, turn, { type: "turn.started" }));
+      events.push(event(ts, id, turn, { type: "state.changed", state: "starting" }));
+    }
+    if (parsed.type === "assistant") {
+      const text = (parsed.message?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("");
+      if (text) assistantText = text;
+      if (text) events.push(event(ts, id, turn, { type: "assistant.completed", text }));
+    }
+    if (parsed.type === "result") {
+      sessionId = parsed.session_id ?? sessionId;
+      usage = {
+        inputTokens: parsed.usage?.input_tokens,
+        outputTokens: parsed.usage?.output_tokens,
+        cachedTokens: parsed.usage?.cache_read_input_tokens
+      };
+      timing = { durationMs: parsed.duration_ms };
+      events.push(event(ts, id, turn, { type: "turn.completed", status: parsed.is_error ? "failed" : "completed" }));
+    }
+  }
+  for (const line of stderr.split(/\r?\n/).filter(Boolean)) events.push(event(ts, id, turn, { type: "warning", message: line }));
+  return { sessionId, assistantText, events, usage, timing };
+}
+function parseGemini(lines, id, turn, stderr, ts) {
+  const events = [];
+  let sessionId = null;
+  let assistantText = "";
+  let usage;
+  let timing;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (parsed.type === "init") {
+      sessionId = parsed.session_id ?? sessionId;
+      events.push(event(ts, id, turn, { type: "turn.started" }));
+      events.push(event(ts, id, turn, { type: "state.changed", state: "starting" }));
+    }
+    if (parsed.type === "message" && parsed.role === "assistant" && parsed.delta === true && typeof parsed.content === "string") {
+      assistantText += parsed.content;
+      events.push(event(ts, id, turn, { type: "assistant.delta", text: parsed.content }));
+    }
+    if (parsed.type === "result") {
+      usage = {
+        inputTokens: parsed.stats?.input_tokens,
+        outputTokens: parsed.stats?.output_tokens,
+        cachedTokens: parsed.stats?.cached,
+        totalTokens: parsed.stats?.total_tokens
+      };
+      timing = { durationMs: parsed.stats?.duration_ms };
+      events.push(event(ts, id, turn, { type: "assistant.completed", text: assistantText }));
+      events.push(event(ts, id, turn, { type: "turn.completed", status: parsed.status === "success" ? "completed" : "failed" }));
+    }
+  }
+  for (const line of stderr.split(/\r?\n/).filter(Boolean)) events.push(event(ts, id, turn, { type: "warning", message: line }));
+  return { sessionId, assistantText, events, usage, timing };
+}
+function parsePi(lines, id, turn, stderr, ts) {
+  const events = [];
+  let sessionId = null;
+  let assistantText = "";
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (parsed.type === "session") {
+      sessionId = parsed.id ?? sessionId;
+      events.push(event(ts, id, turn, { type: "turn.started" }));
+      events.push(event(ts, id, turn, { type: "state.changed", state: "starting" }));
+    }
+    if (parsed.type === "turn_start") events.push(event(ts, id, turn, { type: "state.changed", state: "running" }));
+    if (parsed.type === "message_update" && parsed.assistantMessageEvent?.type === "thinking_start") {
+      events.push(event(ts, id, turn, { type: "state.changed", state: "thinking" }));
+    }
+    if (parsed.type === "message_update" && parsed.assistantMessageEvent?.type === "text_delta") {
+      const delta = parsed.assistantMessageEvent.delta ?? "";
+      assistantText += delta;
+      if (delta) events.push(event(ts, id, turn, { type: "assistant.delta", text: delta }));
+    }
+    if (parsed.type === "turn_end") {
+      const text = (parsed.message?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("");
+      if (text) assistantText = text;
+      events.push(event(ts, id, turn, { type: "assistant.completed", text: assistantText }));
+      events.push(event(ts, id, turn, { type: "turn.completed", status: "completed" }));
+    }
+  }
+  for (const line of stderr.split(/\r?\n/).filter(Boolean)) events.push(event(ts, id, turn, { type: "warning", message: line }));
+  return { sessionId, assistantText, events };
+}
+var GODMODE_HOME = process.platform === "linux" && process.env.XDG_CONFIG_HOME ? resolve(process.env.XDG_CONFIG_HOME, "godmode") : resolve(homedir(), ".godmode");
+var CODING_AGENTS_HOME = resolve(GODMODE_HOME, "coding-agents");
+var RUNS_DIR = resolve(CODING_AGENTS_HOME, "runs");
+var ACTIVE_RUNS_PATH = resolve(CODING_AGENTS_HOME, "active-runs.json");
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function ensureDirs() {
+  mkdirSync(RUNS_DIR, { recursive: true });
+}
+function shellEscape(value) {
+  return `'${value.replace(/'/g, `"'"'`)}'`;
+}
+function writeJson(path, value) {
+  mkdirSync(resolve(path, ".."), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readJsonSettingsFile(path) {
+  return readJson(path) ?? {};
+}
+function readYamlSettingsFile(path) {
+  try {
+    return parseYaml(readFileSync(path, "utf-8")) ?? {};
+  } catch {
+    return {};
+  }
+}
+function migrateSettingsJson(dir) {
+  const yamlPath = resolve(dir, "settings.yaml");
+  if (existsSync(yamlPath)) return readYamlSettingsFile(yamlPath);
+  const jsonPath = resolve(dir, "settings.json");
+  if (!existsSync(jsonPath)) return {};
+  const settings = readJsonSettingsFile(jsonPath);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(yamlPath, stringifyYaml(settings));
+  process.stderr.write(`Migrated ${jsonPath} -> ${yamlPath}. Future agent settings are read from settings.yaml.
+`);
+  return settings;
+}
+function loadSettings(cwd = process.cwd()) {
+  const globalSettings = migrateSettingsJson(GODMODE_HOME);
+  const projectSettings = migrateSettingsJson(resolve(cwd, ".godmode"));
+  return {
+    ...globalSettings,
+    ...projectSettings,
+    plugins: {
+      ...globalSettings.plugins ?? {},
+      ...projectSettings.plugins ?? {},
+      "coding-agents": {
+        ...globalSettings.plugins?.["coding-agents"] ?? {},
+        ...projectSettings.plugins?.["coding-agents"] ?? {}
+      }
+    }
+  };
+}
+function loadActiveRuns() {
+  return readJson(ACTIVE_RUNS_PATH) ?? {};
+}
+function saveActiveRun(cwd, id) {
+  const current = loadActiveRuns();
+  current[cwd] = id;
+  writeJson(ACTIVE_RUNS_PATH, current);
+}
+function activeRunIdForCwd(cwd) {
+  return loadActiveRuns()[cwd] ?? null;
+}
+function runDir(id) {
+  return resolve(RUNS_DIR, id);
+}
+function runPath(id) {
+  return resolve(runDir(id), "run.json");
+}
+function turnDir(id, turn) {
+  return resolve(runDir(id), "turns", String(turn).padStart(4, "0"));
+}
+function loadRun(id) {
+  const run = readJson(runPath(id));
+  if (!run) throw new Error(`Run not found: ${id}`);
+  return run;
+}
+function saveRun(run) {
+  run.updatedAt = timestamp();
+  writeJson(runPath(run.id), run);
+}
+function listRuns() {
+  ensureDirs();
+  return readdirSync(RUNS_DIR, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => readJson(runPath(entry.name))).filter((value) => !!value).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+function createRun(cwd, harness, model, effort) {
+  ensureDirs();
+  const id = `run-${Date.now()}-${randomUUID().slice(0, 8)}`;
+  const run = {
+    id,
+    cwd,
+    harness: harness.id,
+    harnessName: harness.displayName,
+    sessions: {
+      zmx: `godmode-agent-${harness.id}-${id.replace(/^run-/, "")}`
+    },
+    model: model ?? null,
+    effort: effort ?? null,
+    status: "idle",
+    createdAt: timestamp(),
+    updatedAt: timestamp(),
+    lastTurn: 0
+  };
+  mkdirSync(runDir(id), { recursive: true });
+  mkdirSync(resolve(runDir(id), "turns"), { recursive: true });
+  saveRun(run);
+  saveActiveRun(cwd, id);
+  return run;
+}
+function buildShellCommand(harness, run, turn, prompt, passthroughArgs) {
+  const dir = turnDir(run.id, turn);
+  mkdirSync(dir, { recursive: true });
+  const stdoutPath = resolve(dir, "stdout.log");
+  const stderrPath = resolve(dir, "stderr.log");
+  const exitCodePath = resolve(dir, "exit-code.txt");
+  const sessionDir = resolve(runDir(run.id), "pi-session");
+  mkdirSync(sessionDir, { recursive: true });
+  const args = harness.buildTurnArgs({
+    prompt,
+    model: run.model ?? void 0,
+    effort: run.effort ?? void 0,
+    passthroughArgs,
+    resumeToken: run.sessions[run.harness] ?? void 0,
+    sessionDir
+  });
+  const command = `${[harness.command, ...args].map(shellEscape).join(" ")} > ${shellEscape(stdoutPath)} 2> ${shellEscape(stderrPath)}`;
+  const shell = `${command}; code=$?; printf '%s' "$code" > ${shellEscape(exitCodePath)}; exit "$code"`;
+  return { shell, stdoutPath, stderrPath, exitCodePath };
+}
+function waitForFile(path, timeoutMs = 3e5) {
+  const started = Date.now();
+  while (!existsSync(path)) {
+    if (Date.now() - started > timeoutMs) throw new Error(`Timed out waiting for ${path}`);
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+  }
+}
+function latestTurn(run) {
+  if (run.lastTurn < 1) throw new Error(`Run ${run.id} has no turns yet.`);
+  const turn = readJson(resolve(turnDir(run.id, run.lastTurn), "normalized.json"));
+  if (!turn) throw new Error(`Turn ${run.lastTurn} not found for ${run.id}`);
+  return turn;
+}
+function resolveRunId(cwd, explicit) {
+  if (explicit) return explicit;
+  const active = activeRunIdForCwd(cwd);
+  if (!active) throw new Error(`No active coding-agent run for ${cwd}`);
+  return active;
+}
+function renderTurn(turn, outputMode) {
+  if (outputMode === "assistant-text") return turn.assistant.text;
+  if (outputMode === "raw") {
+    const stdout = existsSync2(turn.paths.stdout) ? readFileSync2(turn.paths.stdout, "utf-8") : "";
+    const stderr = existsSync2(turn.paths.stderr) ? readFileSync2(turn.paths.stderr, "utf-8") : "";
+    return JSON.stringify({ stdout, stderr }, null, 2);
+  }
+  if (outputMode === "events") {
+    return existsSync2(turn.paths.events) ? readFileSync2(turn.paths.events, "utf-8").trimEnd() : "";
+  }
+  return JSON.stringify(turn, null, 2);
+}
+function renderStatus(run) {
+  return JSON.stringify(run, null, 2);
+}
+function writeEvents(path, events) {
+  writeFileSyncSafe(path, `${events.map((event2) => JSON.stringify(event2)).join("\n")}
+`);
+}
+function writeFileSyncSafe(path, content) {
+  writeFileSync2(path, content);
+}
+function attachHelp() {
+  return [
+    "Usage: godmode agent attach run <id>",
+    "   or: godmode agent attach session <zmx-session-id>"
+  ].join("\n");
+}
+var AgentHelp = class extends HelpPage {
+  usage() {
+    return [
+      "godmode agent start [--harness <name>] [--model <id>] <prompt>",
+      "godmode agent send  [--harness <name>] [--model <id>] <prompt>",
+      "godmode agent attach run <id>",
+      "godmode agent attach session <session-id>",
+      "godmode agent output [id] [--json|--assistant-text|--events|--raw]",
+      "godmode agent status [id]",
+      "godmode agent list"
+    ];
+  }
+  sections() {
+    return [
+      { title: "Options:", rows: [
+        ["    --harness <name>", "coding agent harness (claude, codex, gemini, etc.)"],
+        ["    --model <id>", "model identifier passed to the harness"],
+        ["    --effort <level>", "effort level passed to the harness"],
+        ["    --json", "output machine-readable events"],
+        ["    --follow", "stream output until the run completes"]
+      ] },
+      { title: "Shortcuts:", rows: [
+        ["godmode agent <prompt>", "send prompt to active run, or start a new run"]
+      ] }
+    ];
+  }
+};
+function agentHelp() {
+  const lines = [];
+  const origLog = console.log;
+  console.log = (...args) => {
+    lines.push(args.join(" "));
+  };
+  try {
+    new AgentHelp().render();
+  } finally {
+    console.log = origLog;
+  }
+  return lines.join("\n");
+}
+function followOutput(run, turn, outputMode, writer) {
+  const dir = turnDir(run.id, turn);
+  const stdoutPath = resolve2(dir, "stdout.log");
+  const stderrPath = resolve2(dir, "stderr.log");
+  const statePath = runPath(run.id);
+  let assistant = "";
+  const emit = (event2) => {
+    if (outputMode === "events") writer.write(`${JSON.stringify(event2)}
+`);
+    if (outputMode === "assistant-text") {
+      if (event2.type === "assistant.delta" && event2.text) writer.write(event2.text);
+      if (event2.type === "assistant.completed" && !assistant && event2.text) writer.write(event2.text);
+    }
+  };
+  streamFile(stdoutPath, (line) => {
+    const normalized = normalizeTurn(run.harness, run.id, turn, `${line}
+`, "", timestamp());
+    for (const event2 of normalized.events) {
+      if (event2.type === "assistant.delta" && event2.text) assistant += event2.text;
+      emit(event2);
+    }
+  }, () => (readJson2(statePath)?.status ?? "completed") === "running");
+  if (outputMode === "assistant-text") writer.write("\n");
+  if (outputMode === "events" && existsSync2(stderrPath)) {
+    for (const line of readFileSync2(stderrPath, "utf-8").split(/\r?\n/).filter(Boolean)) {
+      writer.write(`${JSON.stringify({ ts: timestamp(), id: run.id, turn, type: "warning", message: line })}
+`);
+    }
+  }
+}
+function streamFile(path, onLine, until) {
+  let offset = 0;
+  let pending = "";
+  while (true) {
+    if (existsSync2(path)) {
+      const size = statSync(path).size;
+      if (size > offset) {
+        const fd = openSync(path, "r");
+        const buffer = Buffer.alloc(size - offset);
+        try {
+          const bytes = buffer.length ? readSync(fd, buffer, 0, buffer.length, offset) : 0;
+          offset += bytes;
+          pending += buffer.toString("utf-8", 0, bytes);
+          const lines = pending.split(/\r?\n/);
+          pending = lines.pop() ?? "";
+          for (const line of lines) if (line) onLine(line);
+        } finally {
+          closeSync(fd);
+        }
+      }
+    }
+    if (!until()) {
+      if (pending) onLine(pending);
+      return;
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+  }
+}
+function readJson2(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function defaultExecutor(command, args, stdio = "pipe") {
+  const spawnStdio = stdio === "inherit" ? "inherit" : "pipe";
+  const result = spawnSync(command, args, { encoding: "utf-8", stdio: spawnStdio });
+  return {
+    status: result.status,
+    stdout: stdio === "pipe" && typeof result.stdout === "string" ? result.stdout : "",
+    stderr: stdio === "pipe" && typeof result.stderr === "string" ? result.stderr : "",
+    error: result.error ?? void 0
+  };
+}
+function parseOutputMode(args) {
+  let outputMode = "json";
+  let follow = false;
+  const remaining = [];
+  for (const arg of args) {
+    if (arg === "--json") outputMode = "json";
+    else if (arg === "--assistant-text") outputMode = "assistant-text";
+    else if (arg === "--events") outputMode = "events";
+    else if (arg === "--raw") outputMode = "raw";
+    else if (arg === "--follow") follow = true;
+    else remaining.push(arg);
+  }
+  return { outputMode, follow, remaining };
+}
+function parseStartSendArgs(action, argv) {
+  const { outputMode, remaining } = parseOutputMode(argv);
+  let harness;
+  let model;
+  let effort;
+  let passthroughArgs = [];
+  const promptParts = [];
+  for (let i = 0; i < remaining.length; i++) {
+    const arg = remaining[i];
+    if (arg === "--") {
+      passthroughArgs = remaining.slice(i + 1);
+      break;
+    }
+    if (arg === "--harness") {
+      const value = remaining[++i];
+      if (!value || !(value in HARNESSES)) throw new Error("Missing or invalid value for --harness");
+      harness = value;
+      continue;
+    }
+    if (arg.startsWith("--harness=")) {
+      const value = arg.slice("--harness=".length);
+      if (!value || !(value in HARNESSES)) throw new Error("Missing or invalid value for --harness");
+      harness = value;
+      continue;
+    }
+    if (arg === "--model") {
+      model = remaining[++i];
+      if (!model) throw new Error("Missing value for --model");
+      continue;
+    }
+    if (arg.startsWith("--model=")) {
+      model = arg.slice("--model=".length);
+      if (!model) throw new Error("Missing value for --model");
+      continue;
+    }
+    if (arg === "--effort") {
+      effort = remaining[++i];
+      if (!effort) throw new Error("Missing value for --effort");
+      continue;
+    }
+    if (arg.startsWith("--effort=")) {
+      effort = arg.slice("--effort=".length);
+      if (!effort) throw new Error("Missing value for --effort");
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") throw new Error(agentHelp());
+    if (arg.startsWith("-")) throw new Error(`Unknown flag: ${arg}. Use -- to pass flags through to the native harness.`);
+    promptParts.push(arg);
+  }
+  return { action, prompt: promptParts.join(" ").trim(), harness, model, effort, passthroughArgs, outputMode };
+}
+function parseOutputArgs(argv) {
+  const { outputMode, follow, remaining } = parseOutputMode(argv);
+  return { outputMode, follow, id: remaining.find((arg) => !arg.startsWith("-")) };
+}
+function classifyStatus(exitCode, stdout, stderr) {
+  const text = `${stdout}
+${stderr}`.toLowerCase();
+  if (exitCode === 0) return "completed";
+  if (text.includes("auth") || text.includes("api key") || text.includes("permission") || text.includes("may not exist")) return "blocked";
+  return "failed";
+}
+function resolveRunAndHarness(parsed, executor, cwd, options) {
+  const settings = options.settings ?? loadSettings(cwd);
+  const plugin = settings.plugins?.["coding-agents"];
+  const requestedHarnessId = parsed.harness ?? plugin?.harness;
+  let model = parsed.model ?? plugin?.model;
+  let effort = parsed.effort ?? plugin?.effort;
+  let run;
+  let harness;
+  if (parsed.action === "start") {
+    harness = detectHarness(executor, requestedHarnessId);
+    if (effort && harness.effortFlags.length === 0) throw new Error(`Harness "${harness.id}" does not support --effort.`);
+    run = createRun(cwd, harness, model, effort);
+  } else {
+    const active = activeRunIdForCwd(cwd);
+    if (active) {
+      run = loadRun(active);
+      if (parsed.harness && parsed.harness !== run.harness) throw new Error(`Active run uses harness ${run.harness}; start a new run for ${parsed.harness}.`);
+      harness = detectHarness(executor, run.harness);
+      model = parsed.model ?? run.model ?? plugin?.model ?? void 0;
+      effort = parsed.effort ?? run.effort ?? plugin?.effort ?? void 0;
+      if (effort && harness.effortFlags.length === 0) throw new Error(`Harness "${harness.id}" does not support --effort.`);
+      run.model = model ?? run.model;
+      run.effort = effort ?? run.effort;
+    } else {
+      harness = detectHarness(executor, requestedHarnessId);
+      if (effort && harness.effortFlags.length === 0) throw new Error(`Harness "${harness.id}" does not support --effort.`);
+      run = createRun(cwd, harness, model, effort);
+    }
+  }
+  run.status = "running";
+  run.model = model ?? run.model;
+  run.effort = effort ?? run.effort;
+  run.lastTurn += 1;
+  saveRun(run);
+  saveActiveRun(cwd, run.id);
+  return { run, harness };
+}
+function executeTurn(parsed, options) {
+  const executor = options.executor ?? defaultExecutor;
+  const writer = options.writer ?? process.stdout;
+  const errorWriter = options.errorWriter ?? process.stderr;
+  const cwd = options.cwd ?? process.cwd();
+  const zmxCheck = executor("zmx", ["--help"]);
+  if (zmxCheck.error || zmxCheck.status !== 0) {
+    errorWriter.write("zmx not found. Install zmx to use coding agents.\n");
+    return 2;
+  }
+  const { run, harness } = resolveRunAndHarness(parsed, executor, cwd, options);
+  const { shell, stdoutPath, stderrPath, exitCodePath } = buildShellCommand(harness, run, run.lastTurn, parsed.prompt, parsed.passthroughArgs);
+  const launch = executor("zmx", ["run", run.sessions.zmx, "sh", "-lc", shell], "ignore");
+  if (launch.error || launch.status !== 0) {
+    run.status = "failed";
+    saveRun(run);
+    errorWriter.write(`Failed to queue turn in zmx session ${run.sessions.zmx}.
+`);
+    return 3;
+  }
+  waitForFile(exitCodePath);
+  const exitCode = Number(readFileSync3(exitCodePath, "utf-8").trim() || "1");
+  const stdout = existsSync3(stdoutPath) ? readFileSync3(stdoutPath, "utf-8") : "";
+  const stderr = existsSync3(stderrPath) ? readFileSync3(stderrPath, "utf-8") : "";
+  const normalized = normalizeTurn(run.harness, run.id, run.lastTurn, stdout, stderr, (/* @__PURE__ */ new Date()).toISOString());
+  const turnStatus = classifyStatus(exitCode, stdout, stderr);
+  const turn = {
+    id: run.id,
+    turn: run.lastTurn,
+    status: turnStatus,
+    prompt: parsed.prompt,
+    harness: run.harness,
+    sessions: {
+      zmx: run.sessions.zmx,
+      ...normalized.sessionId || run.sessions[run.harness] ? { [run.harness]: normalized.sessionId ?? run.sessions[run.harness] } : {}
+    },
+    assistant: { text: normalized.assistantText },
+    usage: normalized.usage,
+    timing: normalized.timing,
+    paths: {
+      stdout: stdoutPath,
+      stderr: stderrPath,
+      events: resolve3(turnDir(run.id, run.lastTurn), "events.jsonl")
+    },
+    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeEvents(turn.paths.events, normalized.events);
+  writeJson(resolve3(turnDir(run.id, run.lastTurn), "normalized.json"), turn);
+  if (turn.sessions[run.harness]) run.sessions[run.harness] = turn.sessions[run.harness];
+  run.status = turnStatus;
+  saveRun(run);
+  writer.write(`${renderTurn(turn, parsed.outputMode)}
+`);
+  return turnStatus === "completed" ? 0 : 1;
+}
+function attachToTarget(argv, options) {
+  const executor = options.executor ?? defaultExecutor;
+  const errorWriter = options.errorWriter ?? process.stderr;
+  if (argv.length < 2) {
+    errorWriter.write(`${attachHelp()}
+`);
+    return 1;
+  }
+  const session = argv[0] === "run" ? loadRun(argv[1]).sessions.zmx : argv[0] === "session" ? argv[1] : null;
+  if (!session) {
+    errorWriter.write(`${attachHelp()}
+`);
+    return 1;
+  }
+  return executor("zmx", ["attach", session], "inherit").status ?? 1;
+}
+function outputCommand(argv, options) {
+  const writer = options.writer ?? process.stdout;
+  const cwd = options.cwd ?? process.cwd();
+  const parsed = parseOutputArgs(argv);
+  const run = loadRun(resolveRunId(cwd, parsed.id));
+  if (parsed.follow && run.status === "running") {
+    followOutput(run, run.lastTurn, parsed.outputMode, writer);
+    return 0;
+  }
+  writer.write(`${renderTurn(latestTurn(run), parsed.outputMode)}
+`);
+  return 0;
+}
+function statusCommand(argv, options) {
+  const writer = options.writer ?? process.stdout;
+  const cwd = options.cwd ?? process.cwd();
+  writer.write(`${renderStatus(loadRun(resolveRunId(cwd, argv.find((arg) => !arg.startsWith("-")))))}
+`);
+  return 0;
+}
+function listCommand(options) {
+  const writer = options.writer ?? process.stdout;
+  writer.write(`${JSON.stringify(listRuns(), null, 2)}
+`);
+  return 0;
+}
+async function runAgentCommand(argv, options = {}) {
+  ensureDirs();
+  const writer = options.writer ?? process.stdout;
+  const errorWriter = options.errorWriter ?? process.stderr;
+  if (!argv.length) {
+    writer.write(`${agentHelp()}
+`);
+    return 0;
+  }
+  try {
+    const [cmd, ...rest] = argv;
+    if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+      writer.write(`${agentHelp()}
+`);
+      return 0;
+    }
+    if (cmd === "start") return executeTurn(parseStartSendArgs("start", rest), options);
+    if (cmd === "send") return executeTurn(parseStartSendArgs("send", rest), options);
+    if (cmd === "attach") return attachToTarget(rest, options);
+    if (cmd === "output") return outputCommand(rest, options);
+    if (cmd === "status") return statusCommand(rest, options);
+    if (cmd === "list") return listCommand(options);
+    return executeTurn(parseStartSendArgs("send", argv), options);
+  } catch (error) {
+    errorWriter.write(`${error.message || error}
+`);
+    return 1;
+  }
+}
+export {
+  HARNESSES,
+  agentHelp,
+  defaultExecutor,
+  runAgentCommand
+};