@goah/cli 0.13.0 → 0.13.2

package/dist/chunk-KJ4HJCTK.js

@@ -0,0 +1,1178 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  runnerPlugin
+} from "./chunk-D2DVAH37.js";
+import {
+  SQLITE_SCHEMA_VERSION,
+  SqliteLedger
+} from "./chunk-YH6YJ2IB.js";
+import {
+  RunnerRouter,
+  Supervisor,
+  deriveRecoveryViews
+} from "./chunk-QBD6EJ2Z.js";
+import {
+  ProcessRunner,
+  piWorkerPath,
+  resolveEnvSpec
+} from "./chunk-7E7V6OIU.js";
+import {
+  createPiModel
+} from "./chunk-6M3OOCKO.js";
+import {
+  replayTranscript
+} from "./chunk-R6I3VKME.js";
+import {
+  normalizeAssistantText
+} from "./chunk-TJON22J4.js";
+
+// node_modules/.dist-original/index.js
+import { accessSync, chmodSync as chmodSync3, constants, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync, closeSync, readFileSync as readFileSync3, renameSync, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, isAbsolute, join as join4, resolve as resolve2 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+// node_modules/.dist-original/thread-inspect.js
+import { homedir } from "node:os";
+function listThreads(ledger) {
+  return ledger.threads().map((thread) => summarizeThread(ledger, thread.id)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+function showThread(ledger, threadId) {
+  if (!ledger.thread(threadId))
+    throw new Error(`thread not found: ${threadId}`);
+  return { thread: summarizeThread(ledger, threadId), turns: ledger.turns(threadId).map((turn) => {
+    const events = ledger.readStream(`turn:${turn.id}`);
+    return { ...turn, leaseToken: null, items: ledger.turnItems(turn.id), transcript: events.some((event) => event.type === "transcript.started") ? replayTranscript(events) : null };
+  }) };
+}
+function replayThread(ledger, threadId) {
+  return showThread(ledger, threadId);
+}
+function showTurnContext(ledger, turnId) {
+  if (!ledger.turn(turnId))
+    throw new Error(`turn not found: ${turnId}`);
+  return contextSnapshot(ledger.readStream(`turn:${turnId}`));
+}
+function streamEvents(ledger, streamId, fromStreamSeq = 1) {
+  if (!streamId.trim())
+    throw new Error("--stream is required");
+  if (!Number.isInteger(fromStreamSeq) || fromStreamSeq < 1)
+    throw new Error("--from must be a positive integer");
+  return ledger.readStream(streamId, fromStreamSeq);
+}
+function exportThread(ledger, threadId, options = {}) {
+  const detail = showThread(ledger, threadId);
+  const value = {
+    format: "goah.thread-export.v1",
+    exportedAt: options.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+    redacted: !options.raw,
+    thread: detail.thread,
+    events: ledger.turns(threadId).flatMap((turn) => ledger.readStream(`turn:${turn.id}`)).sort((a, b) => a.seq - b.seq)
+  };
+  return options.raw ? value : redactValue(value);
+}
+function redactValue(value, key = "") {
+  if (SENSITIVE_KEY.test(key))
+    return "[REDACTED]";
+  if (Array.isArray(value))
+    return value.map((item) => redactValue(item));
+  if (value && typeof value === "object")
+    return Object.fromEntries(Object.entries(value).map(([childKey, child]) => [childKey, redactValue(child, childKey)]));
+  if (typeof value !== "string")
+    return value;
+  return value.replaceAll(homedir(), "<HOME>").replace(/\bBearer\s+[^\s"']+/gi, "Bearer [REDACTED]").replace(/\b(?:sk|ak|key)[-_][A-Za-z0-9_-]{12,}\b/gi, "[REDACTED]").replace(/((?:api[_-]?key|token|secret|password|authorization)\s*[=:]\s*)[^\s,;"']+/gi, "$1[REDACTED]");
+}
+function summarizeThread(ledger, threadId) {
+  const thread = ledger.thread(threadId);
+  if (!thread)
+    throw new Error(`thread not found: ${threadId}`);
+  const turns = ledger.turns(threadId);
+  const items = turns.flatMap((turn) => ledger.turnItems(turn.id));
+  return { threadId, agent: thread.agent, status: turns.some((turn) => turn.status === "in_progress") ? "in_progress" : "idle", turnCount: turns.length, itemCount: items.length, toolCalls: items.filter((item) => item.type === "tool_call").length, updatedAt: thread.updatedAt };
+}
+function contextSnapshot(events) {
+  const event = events.findLast((candidate) => candidate.type === "request.prepared");
+  if (!event)
+    return null;
+  const request = event.data;
+  return {
+    eventSeq: event.seq,
+    provider: request.provider,
+    model: request.model,
+    systemPrompt: request.systemPrompt,
+    text: request.activeContext,
+    sourceSeqs: request.sourceSeqs,
+    toolCount: request.tools.length,
+    messageCount: request.messages.length,
+    modelConfig: request.modelConfig
+  };
+}
+var SENSITIVE_KEY = /^(?:api[_-]?key|token|(?:lease|fencing|access|refresh|auth)[_-]?token|secret|password|authorization|cookie|set-cookie)$/i;
+
+// node_modules/.dist-original/control.js
+import { createHash } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import { createConnection, createServer } from "node:net";
+import { join as join2 } from "node:path";
+
+// node_modules/.dist-original/update.js
+import { spawn } from "node:child_process";
+import { readFileSync, realpathSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+function packageRoot() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "..");
+}
+function installedVersion(root = packageRoot()) {
+  return JSON.parse(readFileSync(join(root, "package.json"), "utf8")).version;
+}
+function planNpmUpdate(root, globalPrefix, target, npm = process.platform === "win32" ? "npm.cmd" : "npm") {
+  const installed = realpathSync(root);
+  const globalRoots = process.platform === "win32" ? [join(globalPrefix, "node_modules")] : [join(globalPrefix, "lib", "node_modules"), join(globalPrefix, "node_modules")];
+  if (globalRoots.some((directory) => isInside(installed, directory)))
+    return { command: npm, args: ["install", "--global", `@goah/cli@${target}`], mode: "global", prefix: globalPrefix };
+  const marker = `${sep}node_modules${sep}@goah${sep}cli`;
+  const index = installed.lastIndexOf(marker);
+  if (index < 0)
+    throw new Error("This Goah is running from a source checkout. Build or install @goah/cli instead of self-updating the checkout.");
+  const prefix = installed.slice(0, index);
+  return { command: npm, args: ["install", "--prefix", prefix, `@goah/cli@${target}`], mode: "prefix", prefix };
+}
+async function runUpdate(options = {}) {
+  const current = installedVersion();
+  const target = options.target !== void 0 ? options.target : await capture("npm", ["view", "@goah/cli", "version", "--json"]).then((text) => String(JSON.parse(text)));
+  if (current === target) {
+    console.log(`Goah ${current} is already up to date.`);
+    return;
+  }
+  const globalPrefix = (await capture("npm", ["prefix", "--global"])).trim();
+  const plan = planNpmUpdate(packageRoot(), globalPrefix, target);
+  if (options.check) {
+    console.log(`Goah ${current} \u2192 ${target} is available.`);
+    return;
+  }
+  if (!options.dryRun)
+    console.log(`Updating Goah ${current} \u2192 ${target}\u2026`);
+  else
+    console.log(`Would run: ${plan.command} ${plan.args.join(" ")}`);
+  if (options.dryRun)
+    return;
+  await runQuiet(plan.command, [...plan.args, "--no-fund", "--no-audit", "--loglevel=error"]);
+  const updated = installedVersion();
+  if (updated !== target)
+    throw new Error(`npm completed but the active installation reports ${updated}, expected ${target}`);
+  console.log(`Updated Goah to ${updated}. The next goah launch will restart the resident daemon automatically.`);
+}
+function isInside(path, directory) {
+  const prefix = resolve(directory);
+  return path === prefix || path.startsWith(`${prefix}${sep}`);
+}
+function capture(command, args) {
+  return new Promise((resolveOutput, reject) => {
+    const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.once("error", reject);
+    child.once("close", (code) => code === 0 ? resolveOutput(stdout) : reject(new Error(stderr.trim() || `${command} exited ${code}`)));
+  });
+}
+function runQuiet(command, args) {
+  return new Promise((resolveRun, reject) => {
+    const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.once("error", reject);
+    child.once("close", (code) => code === 0 ? resolveRun() : reject(new Error(stderr.trim() || stdout.trim() || `${command} exited ${code}`)));
+  });
+}
+
+// node_modules/.dist-original/control.js
+var CONTROL_LINE_LIMIT = 1e6;
+function controlEndpoint(stateDir) {
+  if (process.platform !== "win32")
+    return join2(stateDir, "control.sock");
+  return `\\\\.\\pipe\\goah-${createHash("sha256").update(stateDir).digest("hex").slice(0, 16)}`;
+}
+async function runControlServer(supervisor, ledger, stateDir, signal, options = {}) {
+  mkdirSync(stateDir, { recursive: true });
+  const endpoint = controlEndpoint(stateDir);
+  if (process.platform !== "win32" && existsSync(endpoint))
+    rmSync(endpoint);
+  const sockets = /* @__PURE__ */ new Set();
+  const server = createServer((socket) => {
+    sockets.add(socket);
+    socket.on("error", () => void 0);
+    socket.once("close", () => sockets.delete(socket));
+    void serve(socket, supervisor, ledger, options.reloadRuntime, options.stop);
+  });
+  await new Promise((resolve3, reject) => {
+    server.once("error", reject);
+    server.listen(endpoint, resolve3);
+  });
+  if (process.platform !== "win32")
+    chmodSync(endpoint, 384);
+  await new Promise((resolve3) => {
+    const stop = () => {
+      for (const socket of sockets)
+        socket.destroy();
+      server.close(() => resolve3());
+    };
+    if (signal.aborted)
+      stop();
+    else
+      signal.addEventListener("abort", stop, { once: true });
+  });
+  if (process.platform !== "win32" && existsSync(endpoint))
+    rmSync(endpoint);
+}
+async function requestControl(stateDir, request) {
+  let result;
+  await streamControl(stateDir, request, (frame) => {
+    if (frame.type === "error")
+      throw new Error(frame.error);
+    if (frame.type === "result")
+      result = frame.value;
+  });
+  if (result === void 0)
+    throw new Error("control request ended without a result");
+  return result;
+}
+async function streamControl(stateDir, request, onFrame, signal) {
+  if (signal?.aborted)
+    return;
+  const socket = createConnection(controlEndpoint(stateDir));
+  const abort = () => socket.destroy();
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    await new Promise((resolve3, reject) => {
+      socket.once("connect", resolve3);
+      socket.once("error", reject);
+      socket.once("close", () => signal?.aborted ? resolve3() : reject(new Error("control connection closed before connecting")));
+    });
+    if (signal?.aborted)
+      return;
+    socket.write(`${JSON.stringify(request)}
+`);
+    let buffer = "";
+    await new Promise((resolve3, reject) => {
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString();
+        while (buffer.includes("\n")) {
+          const index = buffer.indexOf("\n");
+          const line = buffer.slice(0, index);
+          buffer = buffer.slice(index + 1);
+          if (!line)
+            continue;
+          try {
+            onFrame(JSON.parse(line));
+          } catch (error) {
+            reject(error);
+            socket.destroy();
+          }
+        }
+      });
+      socket.once("end", resolve3);
+      socket.once("close", resolve3);
+      socket.once("error", reject);
+    });
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    socket.destroy();
+  }
+}
+async function controlAvailable(stateDir) {
+  try {
+    return await requestControl(stateDir, { op: "ping" }) === "pong";
+  } catch {
+    return false;
+  }
+}
+async function serve(socket, supervisor, ledger, reloadRuntime, stop) {
+  let buffer = "";
+  let bufferedBytes = 0;
+  socket.on("data", (chunk) => {
+    bufferedBytes += chunk.length;
+    if (bufferedBytes > CONTROL_LINE_LIMIT) {
+      socket.removeAllListeners("data");
+      write(socket, { type: "error", error: "control request exceeded 1 MB" });
+      socket.end();
+      return;
+    }
+    buffer += chunk.toString();
+    const index = buffer.indexOf("\n");
+    if (index < 0)
+      return;
+    socket.removeAllListeners("data");
+    const line = buffer.slice(0, index);
+    let request;
+    try {
+      request = JSON.parse(line);
+    } catch (error) {
+      write(socket, { type: "error", error: error instanceof Error ? error.message : String(error) });
+      socket.end();
+      return;
+    }
+    void dispatch(request, socket, supervisor, ledger, reloadRuntime, stop).catch((error) => {
+      write(socket, { type: "error", error: error instanceof Error ? error.message : String(error) });
+      socket.end();
+    });
+  });
+}
+async function dispatch(request, socket, supervisor, ledger, reloadRuntime, stop) {
+  if (request.op === "interact") {
+    await interact(request.message, socket, supervisor, ledger);
+    return;
+  }
+  if (request.op === "goal.interact") {
+    const accepted = await supervisor.startHumanGoalTurn(request.objective, request.id);
+    write(socket, { type: "accepted", turnId: accepted.turnId, value: accepted });
+    for await (const frame of turnFrames(accepted.turnId, ledger, () => !socket.destroyed))
+      write(socket, frame);
+    socket.end();
+    return;
+  }
+  if (request.op === "turn.attach") {
+    for await (const frame of turnFrames(request.turnId, ledger, () => !socket.destroyed))
+      write(socket, frame);
+    socket.end();
+    return;
+  }
+  let value;
+  if (request.op === "daemon.stop") {
+    value = { stopping: true };
+    setTimeout(() => stop?.(), 10);
+  } else if (request.op === "daemon.version")
+    value = installedVersion();
+  else if (request.op === "config.reload") {
+    const swap = reloadRuntime ? await reloadRuntime(request.configPath) : void 0;
+    if (swap) {
+      supervisor.swapRunner(swap.runner, swap.profiles);
+      if (swap.ledger) {
+        ledger.close();
+        ledger = swap.ledger;
+      }
+    }
+    value = { reloaded: Boolean(swap) };
+  } else if (request.op === "ping")
+    value = "pong";
+  else if (request.op === "status")
+    value = snapshot(ledger, supervisor);
+  else if (request.op === "goal.start")
+    value = supervisor.startGoal(request.objective, request.id);
+  else if (request.op === "goal.update")
+    value = supervisor.updateGoal(request.id, { ...request.objective !== void 0 ? { objective: request.objective } : {}, ...request.observationMethod !== void 0 ? { observationMethod: request.observationMethod } : {}, ...request.verificationMethod !== void 0 ? { verificationMethod: request.verificationMethod } : {} }, "human");
+  else if (request.op === "goal.observe")
+    value = supervisor.confirmObservationMethod(request.id, request.observationMethod);
+  else if (request.op === "goal.transition")
+    value = supervisor.transitionGoal(request.id, request.phase, "human");
+  else if (request.op === "goal.complete")
+    value = supervisor.completeGoal({ goalId: request.id, revision: requiredGoal(ledger, request.id).revision, reason: request.reason, evidence: request.evidence }, "human");
+  else if (request.op === "ceo.send")
+    value = await supervisor.sendToCeo({ message: request.message });
+  else if (request.op === "ceo.status")
+    value = ceoStatus(ledger, supervisor);
+  else if (request.op === "ceo.inbox")
+    value = ledger.unreadMail("human");
+  else if (request.op === "work.records")
+    value = ledger.workRecords();
+  else if (request.op === "work.record")
+    value = ledger.workRecord(request.goalId);
+  else if (request.op === "work.history")
+    value = ledger.workRecordHistory(request.goalId);
+  else if (request.op === "work.diff")
+    value = ledger.workRecordDiff(request.goalId, request.fromRevision, request.toRevision);
+  else if (request.op === "wake.stop")
+    value = await supervisor.stopAgentWake(request.agent, request.goalId);
+  else if (request.op === "turn.interrupt")
+    value = await supervisor.interruptTurn(request.turnId);
+  else if (request.op === "turn.steer")
+    value = await supervisor.startHumanTurn(request.message);
+  else
+    value = { unknown: String(request) };
+  write(socket, { type: "result", value });
+  socket.end();
+}
+async function interact(message, socket, supervisor, ledger) {
+  for await (const frame of interactFrames(message, supervisor, ledger, () => !socket.destroyed))
+    write(socket, frame);
+  socket.end();
+}
+async function* interactFrames(message, supervisor, ledger, isActive = () => true) {
+  if (!message.trim())
+    throw new Error("message is required");
+  const accepted = await supervisor.startHumanTurn(message);
+  yield { type: "accepted", turnId: accepted.turnId, value: accepted };
+  yield* turnFrames(accepted.turnId, ledger, isActive);
+}
+async function* turnFrames(turnId, ledger, isActive) {
+  let nextStreamSeq = 1;
+  const turn = ledger.turn(turnId);
+  if (!turn)
+    throw new Error("Turn not found");
+  const drain = async function* () {
+    const events = ledger.readStream(`turn:${turnId}`, nextStreamSeq);
+    for (const event of events) {
+      nextStreamSeq = event.streamSeq + 1;
+      if (isTurnPresentationEvent(event.type))
+        yield { type: "event", event };
+    }
+  };
+  while (true) {
+    if (!isActive())
+      return;
+    yield* drain();
+    const current = ledger.turn(turnId);
+    if (!current)
+      throw new Error("Turn disappeared");
+    if (current.status !== "in_progress") {
+      yield* drain();
+      const answer = ledger.turnItems(turnId).filter((item) => item.type === "assistant_message").at(-1);
+      const answerText = String(answer?.data?.text ?? "");
+      const streamed = answerText !== "" && ledger.readStream(`turn:${turnId}`).some((event) => event.type === "response.committed" ? event.data.text === answerText : event.type === "message.assistant.completed" && assistantEventText(event.data) === answerText);
+      yield { type: "result", value: { turn: { ...current, leaseToken: null }, ...answer && !streamed ? { response: { content: answerText } } : {} } };
+      return;
+    }
+    await new Promise((resolve3) => setTimeout(resolve3, 50));
+  }
+}
+function snapshot(ledger, supervisor) {
+  return { seq: ledger.events().at(-1)?.seq ?? 0, threads: ledger.threads(), turns: ledger.turns().map((turn) => ({ ...turn, leaseToken: null })), goals: ledger.goals(), team: supervisor.teamList(), wakes: ledger.wakes(), wakeTriggers: ledger.wakes().flatMap((wake) => ledger.wakeTriggers(wake.id)), schedules: ledger.schedules() };
+}
+function ceoStatus(ledger, supervisor) {
+  return { root: supervisor.currentRoot(), roots: ledger.goals().filter((goal) => goal.parentId === null && goal.owner === "ceo"), team: supervisor.teamList(), pendingHuman: ledger.unreadMail("human"), recentCeoHandoffs: ledger.eventsSince(0, ["handoff.recorded"]).filter((event) => event.actor === "ceo").slice(-10) };
+}
+function requiredGoal(ledger, id) {
+  const goal = ledger.goal(id);
+  if (!goal)
+    throw new Error("goal not found");
+  return goal;
+}
+function assistantEventText(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || !value.message || typeof value.message !== "object" || Array.isArray(value.message))
+    return "";
+  const content = value.message.content;
+  if (typeof content === "string")
+    return normalizeAssistantText(content);
+  if (!Array.isArray(content))
+    return "";
+  return content.map((item) => item && typeof item === "object" && !Array.isArray(item) && item.type === "text" && typeof item.text === "string" ? normalizeAssistantText(item.text) : "").filter(Boolean).join("\n");
+}
+function isTurnPresentationEvent(type) {
+  return type.startsWith("message.") || type.startsWith("tool.") || type.startsWith("item.") || type.startsWith("turn.") || type === "response.committed" || type === "handoff.recorded" || type === "transcript.interrupted" || type === "transcript.completed";
+}
+function write(socket, frame) {
+  socket.write(`${JSON.stringify(frame)}
+`);
+}
+
+// node_modules/.dist-original/web-console.js
+import { randomUUID } from "node:crypto";
+import { chmodSync as chmodSync2, existsSync as existsSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync, writeFileSync } from "node:fs";
+import { createServer as createServer2 } from "node:http";
+import { extname, join as join3, normalize } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var assetsDirectory = fileURLToPath2(new URL("./console/", import.meta.url));
+function consoleMetadataPath(stateDir) {
+  return join3(stateDir, "console.json");
+}
+function readConsoleMetadata(stateDir) {
+  const path = consoleMetadataPath(stateDir);
+  if (!existsSync2(path))
+    return null;
+  try {
+    const value = JSON.parse(readFileSync2(path, "utf8"));
+    if (!value.url || !Number.isInteger(value.port) || !value.token)
+      return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function consoleSnapshot(ledger, supervisor, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const events = ledger.events().slice(-300).map((event) => redactValue(event));
+  return redactValue({
+    seq: ledger.events().at(-1)?.seq ?? 0,
+    now,
+    currentRoot: supervisor.currentRoot(),
+    goals: ledger.goals(),
+    team: supervisor.teamList(now),
+    threads: ledger.threads(),
+    turns: ledger.turns().map((turn) => ({ ...turn, leaseToken: null })),
+    wakes: ledger.wakes(),
+    wakeTriggers: ledger.wakes().flatMap((wake) => ledger.wakeTriggers(wake.id)),
+    schedules: ledger.schedules(),
+    recoveries: deriveRecoveryViews(ledger),
+    mailbox: ledger.mailbox(),
+    events
+  });
+}
+function organizationTrajectory(ledger, options = {}) {
+  const limit = Math.min(Math.max(options.limit ?? 100, 1), 200);
+  const beforeSeq = options.beforeSeq ?? Number.MAX_SAFE_INTEGER;
+  const wakeAgents = new Map(ledger.wakes().map((wake) => [wake.id, wake.agent]));
+  const candidates = ledger.events().filter((event) => {
+    if (event.seq >= beforeSeq || !isTrajectoryEvent(event.type))
+      return false;
+    const wakeId = event.streamId.startsWith("wake:") ? event.streamId.slice("wake:".length) : null;
+    const agent = wakeId ? wakeAgents.get(wakeId) ?? event.actor : event.actor;
+    if (options.agent && agent !== options.agent)
+      return false;
+    if (options.type && !event.type.startsWith(`${options.type}.`))
+      return false;
+    return true;
+  }).reverse();
+  const page = candidates.slice(0, limit);
+  return {
+    items: page.map((event) => {
+      const wakeId = event.streamId.startsWith("wake:") ? event.streamId.slice("wake:".length) : null;
+      return { event: redactValue(event), agent: wakeId ? wakeAgents.get(wakeId) ?? event.actor : event.actor, wakeId };
+    }),
+    nextBeforeSeq: candidates.length > limit ? page.at(-1)?.seq ?? null : null
+  };
+}
+async function runWebConsole(supervisor, ledger, stateDir, signal, options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  if (!["127.0.0.1", "localhost", "::1"].includes(host))
+    throw new Error("Goah Console only binds to loopback hosts");
+  const token = randomUUID();
+  let allowedHost = "";
+  const server = createServer2((request, response) => {
+    route(request, response, supervisor, ledger, token, allowedHost).catch((error) => {
+      const message = { error: error instanceof Error ? error.message : String(error) };
+      if (response.headersSent)
+        response.end(`data: ${JSON.stringify({ ...message, type: "error" })}
+
+`);
+      else
+        sendJson(response, 500, message);
+    });
+  });
+  await new Promise((resolve3, reject) => {
+    server.once("error", reject);
+    server.listen(options.port ?? 0, host, resolve3);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string")
+    throw new Error("console server did not bind a TCP port");
+  const metadata = { url: `http://${host.includes(":") ? `[${host}]` : host}:${address.port}/`, host, port: address.port, pid: process.pid, token };
+  allowedHost = new URL(metadata.url).host;
+  const metadataPath = consoleMetadataPath(stateDir);
+  writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}
+`, { mode: 384 });
+  if (process.platform !== "win32")
+    chmodSync2(metadataPath, 384);
+  options.onListening?.(metadata);
+  await new Promise((resolve3) => {
+    const stop = () => server.close(() => resolve3());
+    if (signal.aborted)
+      stop();
+    else
+      signal.addEventListener("abort", stop, { once: true });
+  });
+  rmSync2(metadataPath, { force: true });
+}
+async function route(request, response, supervisor, ledger, token, allowedHost) {
+  setHeaders(response);
+  if (request.headers.host !== allowedHost) {
+    sendJson(response, 403, { error: "console host is not allowed" });
+    return;
+  }
+  const url = new URL(request.url ?? "/", "http://127.0.0.1");
+  if (url.pathname.startsWith("/api/")) {
+    if (!authorized(request, url, token)) {
+      sendJson(response, 403, { error: "console authorization failed" });
+      return;
+    }
+    if (request.method === "GET" && url.pathname === "/api/snapshot") {
+      sendJson(response, 200, consoleSnapshot(ledger, supervisor));
+      return;
+    }
+    if (request.method === "GET" && url.pathname === "/api/trajectory") {
+      const options = {};
+      const beforeSeq = positiveInteger(url.searchParams.get("beforeSeq"));
+      if (beforeSeq)
+        options.beforeSeq = beforeSeq;
+      const limit = positiveInteger(url.searchParams.get("limit"));
+      if (limit)
+        options.limit = limit;
+      const agent = nonEmpty(url.searchParams.get("agent"));
+      if (agent)
+        options.agent = agent;
+      const type = nonEmpty(url.searchParams.get("type"));
+      if (type)
+        options.type = type;
+      sendJson(response, 200, organizationTrajectory(ledger, options));
+      return;
+    }
+    if (request.method === "GET" && url.pathname.startsWith("/api/threads/")) {
+      const threadId = decodeURIComponent(url.pathname.slice("/api/threads/".length));
+      const thread = ledger.thread(threadId);
+      if (!thread) {
+        sendJson(response, 404, { error: "thread not found" });
+        return;
+      }
+      const turns = ledger.turns(threadId);
+      sendJson(response, 200, redactValue({ thread, turns: turns.map((turn) => ({ ...turn, leaseToken: null, items: ledger.turnItems(turn.id) })) }));
+      return;
+    }
+    if (request.method === "POST" && url.pathname === "/api/ceo") {
+      const body = await readBody(request);
+      const message = typeof body.message === "string" ? body.message.trim() : "";
+      if (!message) {
+        sendJson(response, 400, { error: "message is required" });
+        return;
+      }
+      sendJson(response, 202, await supervisor.startHumanTurn(message));
+      return;
+    }
+    if (request.method === "POST" && url.pathname === "/api/chat") {
+      const body = await readBody(request);
+      const message = typeof body.message === "string" ? body.message.trim() : "";
+      if (!message) {
+        sendJson(response, 400, { error: "message is required" });
+        return;
+      }
+      response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+      let active = true;
+      request.on("close", () => {
+        active = false;
+      });
+      try {
+        for await (const frame of interactFrames(message, supervisor, ledger, () => active)) {
+          if (!active)
+            break;
+          response.write(`data: ${JSON.stringify(frame)}
+
+`);
+        }
+      } catch (error) {
+        if (active)
+          response.write(`data: ${JSON.stringify({ type: "error", error: error instanceof Error ? error.message : String(error) })}
+
+`);
+      }
+      response.end();
+      return;
+    }
+    sendJson(response, 404, { error: "not found" });
+    return;
+  }
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    response.writeHead(405);
+    response.end();
+    return;
+  }
+  const relative = url.pathname === "/" ? "index.html" : normalize(url.pathname).replace(/^\/+/, "");
+  if (relative === "index.html")
+    response.setHeader("set-cookie", `goah_console=${token}; Path=/; HttpOnly; SameSite=Strict`);
+  const path = join3(assetsDirectory, relative);
+  if (!path.startsWith(assetsDirectory) || !existsSync2(path) || !statSync(path).isFile()) {
+    const fallback = join3(assetsDirectory, "index.html");
+    if (!existsSync2(fallback)) {
+      response.writeHead(503);
+      response.end("Console assets are not built. Run npm run build.");
+      return;
+    }
+    serveFile(response, fallback, request.method === "HEAD");
+    return;
+  }
+  serveFile(response, path, request.method === "HEAD");
+}
+function isTrajectoryEvent(type) {
+  return ["goal.", "delegation.", "handoff.", "wake.", "mail.", "schedule.", "observation.", "ceo.", "human."].some((prefix) => type.startsWith(prefix));
+}
+function positiveInteger(value) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+function nonEmpty(value) {
+  const result = value?.trim();
+  return result ? result : void 0;
+}
+function authorized(request, url, token) {
+  const supplied = request.headers.authorization?.replace(/^Bearer\s+/i, "") ?? url.searchParams.get("token");
+  if (supplied === token)
+    return true;
+  const cookieToken = request.headers.cookie?.split(";").map((value) => value.trim()).find((value) => value.startsWith("goah_console="))?.slice("goah_console=".length);
+  if (cookieToken === token)
+    return true;
+  return false;
+}
+function serveFile(response, path, head) {
+  const types = { ".html": "text/html; charset=utf-8", ".js": "text/javascript; charset=utf-8", ".css": "text/css; charset=utf-8", ".png": "image/png", ".svg": "image/svg+xml", ".map": "application/json" };
+  response.writeHead(200, { "content-type": types[extname(path)] ?? "application/octet-stream", "cache-control": extname(path) === ".html" ? "no-store" : "public, max-age=31536000, immutable" });
+  response.end(head ? void 0 : readFileSync2(path));
+}
+function setHeaders(response) {
+  response.setHeader("content-security-policy", "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; connect-src 'self'; object-src 'none'; frame-ancestors 'none'; base-uri 'none'");
+  response.setHeader("referrer-policy", "no-referrer");
+  response.setHeader("x-content-type-options", "nosniff");
+  response.setHeader("x-frame-options", "DENY");
+}
+function sendJson(response, status, value) {
+  response.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+  response.end(`${JSON.stringify(value)}
+`);
+}
+async function readBody(request) {
+  let body = "";
+  for await (const chunk of request) {
+    body += chunk.toString();
+    if (body.length > 65536)
+      throw new Error("request body is too large");
+  }
+  const parsed = JSON.parse(body || "{}");
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+
+// node_modules/.dist-original/index.js
+var configRoots = /* @__PURE__ */ new WeakMap();
+function loadConfig(path = "goah.config.json") {
+  recoverProfileTransaction();
+  const absolute = resolve2(path);
+  const config = JSON.parse(readFileSync3(absolute, "utf8"));
+  if (config.version !== 1 && config.version !== 2)
+    throw new Error(`unsupported goah config version: ${String(config.version)}`);
+  const base = dirname2(absolute);
+  const root = config.workspace ? absolutePath(base, config.workspace) : base;
+  delete config.workspace;
+  delete config.limits;
+  delete config.heartbeatPolicies;
+  delete config.progressPolicies;
+  configRoots.set(config, root);
+  config.stateDir = absolutePath(base, config.stateDir);
+  if (config.runner) {
+    config.runner.command = resolveCommand(config.runner.command);
+    config.runner.args = config.runner.args.map((arg) => arg === "$GOAH_PI_WORKER" ? piWorkerPath() : arg);
+  }
+  if (!config.runnerProfiles?.length && config.runner?.env?.GOAH_PI_PROVIDER && config.runner.env.GOAH_PI_MODEL) {
+    const env = config.runner.env;
+    const provider = env.GOAH_PI_PROVIDER;
+    const model = env.GOAH_PI_MODEL;
+    const keyRef = Object.entries(env).find(([key, value]) => key.endsWith("API_KEY") && value.startsWith("env:"));
+    config.runnerProfiles = [{ id: "default", runner: "pi", config: { provider, model, ...keyRef ? { apiKeyEnv: keyRef[1].slice(4) } : {}, ...env.GOAH_PI_BASE_URL ? { baseUrl: env.GOAH_PI_BASE_URL } : {} } }];
+    if (config.profiles)
+      config.profiles = config.profiles.map((profile) => ({ ...profile, runnerProfile: profile.runnerProfile ?? "default" }));
+  }
+  return config;
+}
+function createRuntime(config) {
+  mkdirSync2(config.stateDir, { recursive: true });
+  const ledger = new SqliteLedger(join4(config.stateDir, "ledger.sqlite"));
+  const runner = config.runnerProfiles?.length ? new RunnerRouter(new Map(config.runnerProfiles.map((profile) => [profile.id, runnerPlugin(profile.runner).create(profile.config, configRoot(config))]))) : legacyRunner(config);
+  const supervisor = new Supervisor(ledger, runner, new class {
+    now() {
+      return /* @__PURE__ */ new Date();
+    }
+  }(), {
+    ...config.profiles ? { profiles: config.profiles } : {},
+    ...config.runnerProfiles ? { runnerProfiles: config.runnerProfiles } : {},
+    ...config.retryPolicy ? { retryPolicy: config.retryPolicy } : {}
+  });
+  return { ledger, supervisor };
+}
+function defaultConfig(directory, options = {}) {
+  const provider = options.provider ?? "faux";
+  const model = options.model ?? defaultModel(provider);
+  const runnerProfile = { id: "default", runner: "pi", config: { provider, model, thinking: "medium", ...options.apiKeyEnv ? { apiKeyEnv: options.apiKeyEnv } : {}, ...options.baseUrl ? { baseUrl: options.baseUrl } : {}, ...options.contextWindowTokens ? { contextWindowTokens: options.contextWindowTokens } : {}, ...options.maxOutputTokensPerTurn ? { maxOutputTokens: options.maxOutputTokensPerTurn } : {} } };
+  return {
+    version: 2,
+    stateDir: defaultStateDir(directory),
+    runnerProfiles: [runnerProfile],
+    profiles: [{ agent: "ceo", role: "ceo", runnerProfile: "default" }, { agent: options.agent ?? "worker", role: "child", runnerProfile: "default" }]
+  };
+}
+var SupervisorLock = class {
+  path;
+  #owned = false;
+  constructor(stateDir) {
+    this.path = join4(stateDir, "supervisor.lock");
+  }
+  acquire() {
+    mkdirSync2(dirname2(this.path), { recursive: true });
+    if (existsSync3(this.path)) {
+      const pid = Number(readFileSync3(this.path, "utf8"));
+      if (Number.isInteger(pid) && alive(pid))
+        throw new Error(`supervisor already running with pid ${pid}`);
+      rmSync3(this.path);
+    }
+    const fd = openSync(this.path, "wx");
+    writeFileSync2(fd, String(process.pid));
+    closeSync(fd);
+    this.#owned = true;
+  }
+  release() {
+    if (this.#owned) {
+      rmSync3(this.path, { force: true });
+      this.#owned = false;
+    }
+  }
+};
+function writeDefaultConfig(path = "goah.config.json", options = {}, overwrite = false) {
+  const absolute = resolve2(path);
+  if (existsSync3(absolute) && !overwrite)
+    throw new Error(`${absolute} already exists`);
+  writeFileSync2(absolute, `${JSON.stringify(defaultConfig(dirname2(absolute), options), null, 2)}
+`);
+}
+function profilePath() {
+  return join4(process.env.GOAH_STATE_HOME ?? join4(homedir2(), ".goah"), "profile.json");
+}
+function readDefaultRunnerProfile() {
+  recoverProfileTransaction();
+  try {
+    const raw = JSON.parse(readFileSync3(profilePath(), "utf8"));
+    if (typeof raw.id === "string" && typeof raw.runner === "string" && raw.config && typeof raw.config === "object")
+      return raw;
+    if (typeof raw.provider === "string" && typeof raw.model === "string") {
+      const { provider, model, apiKeyEnv, baseUrl, contextWindowTokens, maxOutputTokensPerTurn } = raw;
+      return { id: "default", runner: "pi", config: { provider, model, ...typeof apiKeyEnv === "string" ? { apiKeyEnv } : {}, ...typeof baseUrl === "string" ? { baseUrl } : {}, ...typeof contextWindowTokens === "number" ? { contextWindowTokens } : {}, ...typeof maxOutputTokensPerTurn === "number" ? { maxOutputTokens: maxOutputTokensPerTurn } : {} } };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeDefaultRunnerProfile(profile) {
+  withProfileLock(() => {
+    recoverProfileTransactionUnlocked();
+    writeDefaultRunnerProfileUnlocked(profile);
+  });
+}
+function writeDefaultRunnerProfileUnlocked(profile) {
+  mkdirSync2(dirname2(profilePath()), { recursive: true });
+  const temporary = `${profilePath()}.${process.pid}.tmp`;
+  writeFileSync2(temporary, `${JSON.stringify(profile, null, 2)}
+`, { mode: 384 });
+  renameSync(temporary, profilePath());
+  chmodSync3(profilePath(), 384);
+}
+function updateWorkspaceRunnerProfile(path, profile) {
+  withProfileLock(() => {
+    recoverProfileTransactionUnlocked();
+    updateWorkspaceRunnerProfileUnlocked(path, profile);
+  });
+}
+function updateWorkspaceRunnerProfileUnlocked(path, profile) {
+  const absolute = resolve2(path);
+  const current = existsSync3(absolute) ? JSON.parse(readFileSync3(absolute, "utf8")) : defaultConfig(dirname2(absolute));
+  current.runnerProfiles = [...(current.runnerProfiles ?? []).filter((item) => item.id !== profile.id), profile];
+  current.profiles = (current.profiles ?? [{ agent: "ceo", role: "ceo" }, { agent: "worker", role: "child" }]).map((agent) => ({ ...agent, runnerProfile: agent.runnerProfile ?? profile.id }));
+  const temporary = `${absolute}.${process.pid}.tmp`;
+  writeFileSync2(temporary, `${JSON.stringify(current, null, 2)}
+`);
+  renameSync(temporary, absolute);
+}
+function persistRunnerProfile(profile, workspacePath) {
+  withProfileLock(() => {
+    recoverProfileTransactionUnlocked();
+    const targets = [profilePath(), ...workspacePath ? [resolve2(workspacePath)] : []];
+    const before = targets.map((path) => ({ path, content: existsSync3(path) ? readFileSync3(path) : null }));
+    writeProfileTransaction(before);
+    try {
+      writeDefaultRunnerProfileUnlocked(profile);
+      if (workspacePath)
+        updateWorkspaceRunnerProfileUnlocked(workspacePath, profile);
+      rmSync3(profileTransactionPath(), { force: true });
+    } catch (error) {
+      restoreProfileSnapshots(before);
+      rmSync3(profileTransactionPath(), { force: true });
+      throw error;
+    }
+  });
+}
+function withProfileLock(operation) {
+  const lock = `${profilePath()}.lock`;
+  const ownerPath = join4(lock, "owner.json");
+  const token = randomUUID2();
+  mkdirSync2(dirname2(lock), { recursive: true });
+  acquireProfileLock(lock, ownerPath, token);
+  try {
+    return operation();
+  } finally {
+    if (readProfileLockOwner(ownerPath)?.token === token)
+      rmSync3(lock, { recursive: true, force: true });
+  }
+}
+function acquireProfileLock(lock, ownerPath, token) {
+  while (true) {
+    try {
+      mkdirSync2(lock);
+      try {
+        writeFileSync2(ownerPath, JSON.stringify({ pid: process.pid, token }), { mode: 384 });
+      } catch (error) {
+        rmSync3(lock, { recursive: true, force: true });
+        throw error;
+      }
+      return;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+    const owner = readProfileLockOwner(ownerPath);
+    let oldUnownedLock = false;
+    try {
+      oldUnownedLock = !owner && Date.now() - statSync2(lock).mtimeMs > 5e3;
+    } catch (error) {
+      if (error.code === "ENOENT")
+        continue;
+      throw error;
+    }
+    if (owner && processIsAlive(owner.pid) || !owner && !oldUnownedLock)
+      throw new Error("Another Goah process is updating Runner Profiles; try again.");
+    const stale = `${lock}.stale.${token}`;
+    try {
+      renameSync(lock, stale);
+      rmSync3(stale, { recursive: true, force: true });
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+}
+function profileTransactionPath() {
+  return join4(dirname2(profilePath()), "profile-transaction.json");
+}
+function writeProfileTransaction(snapshots) {
+  const path = profileTransactionPath();
+  const temporary = `${path}.${process.pid}.tmp`;
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(temporary, `${JSON.stringify({ version: 1, snapshots: snapshots.map((snapshot2) => ({ path: snapshot2.path, content: snapshot2.content?.toString("base64") ?? null })) })}
+`, { mode: 384 });
+  renameSync(temporary, path);
+  chmodSync3(path, 384);
+}
+function restoreProfileSnapshots(snapshots) {
+  for (const snapshot2 of snapshots) {
+    if (snapshot2.content === null)
+      rmSync3(snapshot2.path, { force: true });
+    else {
+      mkdirSync2(dirname2(snapshot2.path), { recursive: true });
+      const temporary = `${snapshot2.path}.${process.pid}.rollback.tmp`;
+      writeFileSync2(temporary, snapshot2.content, snapshot2.path === profilePath() ? { mode: 384 } : void 0);
+      renameSync(temporary, snapshot2.path);
+      if (snapshot2.path === profilePath())
+        chmodSync3(snapshot2.path, 384);
+    }
+  }
+}
+function recoverProfileTransaction() {
+  if (existsSync3(profileTransactionPath()))
+    withProfileLock(recoverProfileTransactionUnlocked);
+}
+function recoverProfileTransactionUnlocked() {
+  const path = profileTransactionPath();
+  if (!existsSync3(path))
+    return;
+  const value = JSON.parse(readFileSync3(path, "utf8"));
+  if (value.version !== 1 || !Array.isArray(value.snapshots))
+    throw new Error("Goah Runner Profile transaction journal is invalid");
+  const snapshots = value.snapshots.map((snapshot2) => {
+    if (typeof snapshot2.path !== "string" || snapshot2.content !== null && typeof snapshot2.content !== "string")
+      throw new Error("Goah Runner Profile transaction journal is invalid");
+    return { path: snapshot2.path, content: snapshot2.content === null ? null : Buffer.from(snapshot2.content, "base64") };
+  });
+  restoreProfileSnapshots(snapshots);
+  rmSync3(path, { force: true });
+}
+function readProfileLockOwner(path) {
+  try {
+    const value = JSON.parse(readFileSync3(path, "utf8"));
+    return Number.isInteger(value.pid) && Number(value.pid) > 0 && typeof value.token === "string" ? value : null;
+  } catch (error) {
+    if (error.code === "ENOENT" || error instanceof SyntaxError)
+      return null;
+    throw error;
+  }
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function diagnoseConfig(config) {
+  const checks = [];
+  const check = (name, fn) => {
+    try {
+      checks.push({ name, ok: true, detail: fn() });
+    } catch (error) {
+      checks.push({ name, ok: false, detail: error instanceof Error ? error.message : String(error) });
+    }
+  };
+  check("node", () => {
+    if (Number(process.versions.node.split(".")[0]) < 24)
+      throw new Error(`Node ${process.versions.node} is unsupported; require >=24`);
+    return process.versions.node;
+  });
+  check("root", () => {
+    const root = configRoot(config);
+    accessSync(root, constants.R_OK | constants.W_OK);
+    return `${root} (runner-owned local execution)`;
+  });
+  check("state", () => {
+    const existing = nearestExisting(config.stateDir);
+    accessSync(existing, constants.W_OK);
+    const database = join4(config.stateDir, "ledger.sqlite");
+    if (!existsSync3(database))
+      return `${config.stateDir} (will create)`;
+    const db = new DatabaseSync(database, { readOnly: true });
+    try {
+      const version = db.prepare("PRAGMA user_version").get().user_version;
+      if (version > SQLITE_SCHEMA_VERSION)
+        throw new Error(`ledger schema ${version} is newer than supported schema ${SQLITE_SCHEMA_VERSION}`);
+      if (version > 0 && version < SQLITE_SCHEMA_VERSION)
+        throw new Error(`ledger schema ${version} predates runtime schema ${SQLITE_SCHEMA_VERSION}; recreate this development workspace`);
+      return `${database} (schema ${version})`;
+    } finally {
+      db.close();
+    }
+  });
+  check("runner", () => {
+    if (config.runnerProfiles?.length) {
+      for (const profile of config.runnerProfiles)
+        runnerPlugin(profile.runner);
+      return config.runnerProfiles.map((profile) => `${profile.id}:${profile.runner}`).join(", ");
+    }
+    if (!config.runner)
+      throw new Error("no runner is configured");
+    accessSync(config.runner.command, constants.X_OK);
+    const workerArg = config.runner.args[0];
+    if (workerArg && isAbsolute(workerArg))
+      accessSync(workerArg, constants.R_OK);
+    const env = resolveEnvSpec(config.runner.env, { root: configRoot(config) });
+    const provider = requiredEnv(env, "GOAH_PI_PROVIDER");
+    const modelId = requiredEnv(env, "GOAH_PI_MODEL");
+    const model = createPiModel(provider, modelId, env).model;
+    return `${provider}/${modelId} context=${model.contextWindow} output=${model.maxTokens}; auth is checked when the wake starts`;
+  });
+  return { ok: checks.every((item) => item.ok || item.severity === "warning"), checks };
+}
+function statusSnapshot(ledger) {
+  const events = ledger.events();
+  const wakes = ledger.wakes().map((wake) => {
+    const turn = wake.turnId ? ledger.turn(wake.turnId) : null;
+    const turnEvents = turn ? ledger.readStream(`turn:${turn.id}`) : [];
+    const tokensUsed = turnEvents.reduce((total, event) => total + assistantTokens(event.data), 0);
+    return { ...wake, tokensUsed, abnormalReason: turn?.status === "failed" ? field(turn.error, "message") : null };
+  });
+  const goals = ledger.goals();
+  const handoffs = events.filter((event) => event.type === "handoff.recorded").slice(-20).map((event) => ({ seq: event.seq, ts: event.ts, agent: event.actor, streamId: event.streamId, handoff: event.data }));
+  const modelCapabilitiesByAgent = Object.fromEntries(ledger.threads().flatMap((thread) => {
+    const turnIds = new Set(ledger.turns(thread.id).map((turn) => turn.id));
+    const capability = [...events].reverse().find((event) => event.type === "transcript.started" && event.streamId.startsWith("turn:") && turnIds.has(event.streamId.slice("turn:".length)))?.data;
+    return capability ? [[thread.agent, capability]] : [];
+  }));
+  const modelCapabilities = modelCapabilitiesByAgent.ceo ?? [...events].reverse().find((event) => event.type === "transcript.started")?.data ?? null;
+  return { seq: events.at(-1)?.seq ?? 0, threads: ledger.threads(), turns: ledger.turns().map((turn) => ({ ...turn, leaseToken: null })), goals, wakes, wakeTriggers: wakes.flatMap((wake) => ledger.wakeTriggers(wake.id)), schedules: ledger.schedules(), modelCapabilities, modelCapabilitiesByAgent, recentHandoffs: handoffs };
+}
+function defaultModel(provider) {
+  if (provider === "faux")
+    return "faux-goah";
+  throw new Error(`--model is required for ${provider}; interactive setup discovers models through the selected Runner.`);
+}
+function legacyRunner(config) {
+  if (!config.runner)
+    throw new Error("no runner profiles are configured");
+  const { env, ...spec } = config.runner;
+  return new ProcessRunner({ ...spec, envSpec: env, cwd: configRoot(config) });
+}
+function requiredEnv(env, name) {
+  const value = env[name];
+  if (!value)
+    throw new Error(`${name} is missing`);
+  return value;
+}
+function nearestExisting(path) {
+  let current = resolve2(path);
+  while (!existsSync3(current)) {
+    const parent = dirname2(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return current;
+}
+function defaultStateDir(directory) {
+  const id = createHash2("sha256").update(resolve2(directory)).digest("hex").slice(0, 16);
+  return join4(process.env.GOAH_STATE_HOME ?? join4(homedir2(), ".goah", "state"), id);
+}
+function field(value, key) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value[key] : void 0;
+}
+function assistantTokens(value) {
+  const message = field(value, "message");
+  if (field(message, "role") !== "assistant")
+    return 0;
+  const usage = field(message, "usage");
+  const total = field(usage, "totalTokens");
+  return typeof total === "number" ? total : 0;
+}
+function resolveCommand(command) {
+  return command === "$NODE" ? process.execPath : command;
+}
+function absolutePath(base, value) {
+  return isAbsolute(value) ? value : resolve2(base, value);
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function configRoot(config) {
+  return configRoots.get(config) ?? process.cwd();
+}
+
+export {
+  listThreads,
+  showThread,
+  replayThread,
+  showTurnContext,
+  streamEvents,
+  exportThread,
+  redactValue,
+  installedVersion,
+  runUpdate,
+  controlEndpoint,
+  runControlServer,
+  requestControl,
+  streamControl,
+  controlAvailable,
+  consoleMetadataPath,
+  readConsoleMetadata,
+  consoleSnapshot,
+  organizationTrajectory,
+  runWebConsole,
+  loadConfig,
+  createRuntime,
+  defaultConfig,
+  SupervisorLock,
+  writeDefaultConfig,
+  profilePath,
+  readDefaultRunnerProfile,
+  writeDefaultRunnerProfile,
+  updateWorkspaceRunnerProfile,
+  persistRunnerProfile,
+  diagnoseConfig,
+  statusSnapshot,
+  configRoot
+};