omp-fabric 0.85.0

package/dist/worker.js

@@ -0,0 +1,1061 @@
+#!/usr/bin/env node
+
+// src/worker.ts
+import fs from "node:fs";
+import path from "node:path";
+import crossSpawn from "cross-spawn";
+import { StringDecoder } from "node:string_decoder";
+import { validateJsonSchemaValue } from "@oh-my-pi/pi-ai/utils/schema";
+var NODE_SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".cjs", ".mjs", ".ts", ".cts", ".mts"]);
+var spawnCli = (command, args, options) => NODE_SCRIPT_EXTENSIONS.has(path.extname(command).toLowerCase()) ? crossSpawn(process.execPath, [command, ...args], options) : crossSpawn(command, [...args], options);
+var loadWorkerOptions = async () => {
+  if (!import.meta.url.endsWith(".ts")) return import("./worker/options.js");
+  const sourceModulePath = "./worker/options.ts";
+  return import(sourceModulePath);
+};
+var loadWorkerRunRecord = async () => {
+  if (!import.meta.url.endsWith(".ts")) return import("./worker/run-record.js");
+  const sourceModulePath = "./worker/run-record.ts";
+  return import(sourceModulePath);
+};
+var loadWorkerSessionExport = async () => {
+  if (!import.meta.url.endsWith(".ts")) return import("./worker/session-export.js");
+  const sourceModulePath = "./worker/session-export.ts";
+  return import(sourceModulePath);
+};
+var loadCompactControl = async () => {
+  if (!import.meta.url.endsWith(".ts")) return import("./agents/compact-control.js");
+  const sourceModulePath = "./agents/compact-control.ts";
+  return import(sourceModulePath);
+};
+var loadClaudeCli = async () => {
+  if (!import.meta.url.endsWith(".ts")) return import("./agents/claude-cli.js");
+  const sourceModulePath = "./agents/claude-cli.ts";
+  return import(sourceModulePath);
+};
+var loadVedaCli = async () => {
+  if (!import.meta.url.endsWith(".ts")) return import("./agents/veda-cli.js");
+  const sourceModulePath = "./agents/veda-cli.ts";
+  return import(sourceModulePath);
+};
+var MAX_STDERR_CHARS = 2e4;
+var MAX_EVENT_LINE_CHARS = 4 * 1024 * 1024;
+var STEER_READ_CHUNK_BYTES = 256 * 1024;
+var MAX_STEER_LINE_BYTES = 64 * 1024;
+var MAX_STEER_COMMANDS_PER_POLL = 256;
+var MAX_CLAUDE_PENDING_INPUTS = 256;
+var MAX_CLAUDE_PENDING_TOOLS = 1e3;
+var KILL_GRACE_MS = 5e3;
+var extractText = (message) => {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter(
+    (part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string"
+  ).map((part) => part.text).join("");
+};
+var readImages = (filePath) => {
+  if (!filePath) return [];
+  const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  if (!Array.isArray(parsed)) throw new Error("Agent images file must contain an array");
+  const images = [];
+  for (const value of parsed) {
+    if (typeof value !== "object" || value === null || Array.isArray(value) || value.type !== "image" || typeof value.data !== "string" || typeof value.mimeType !== "string") {
+      throw new Error("Agent images file contains an invalid image block");
+    }
+    images.push({
+      type: "image",
+      data: value.data,
+      mimeType: value.mimeType
+    });
+  }
+  return images;
+};
+var numberField = (value) => typeof value === "number" ? value : 0;
+var stringField = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+var assistantError = (message) => {
+  const details = [];
+  const direct = stringField(message.errorMessage) ?? stringField(message.error);
+  if (direct) details.push(direct);
+  if (Array.isArray(message.diagnostics)) {
+    for (const diagnostic of message.diagnostics) {
+      if (typeof diagnostic !== "object" || diagnostic === null || Array.isArray(diagnostic)) continue;
+      const record = diagnostic;
+      const nested = typeof record.error === "object" && record.error !== null && !Array.isArray(record.error) ? record.error : void 0;
+      const detail = stringField(nested?.message) ?? stringField(record.message);
+      if (detail) details.push(detail);
+    }
+  }
+  const unique = [...new Set(details)];
+  const provider = stringField(message.provider);
+  const model = stringField(message.model);
+  const source = [provider, model].filter((value) => Boolean(value)).join("/");
+  const summary = unique.join(" \xB7 ") || "OMP agent reported an error";
+  return `${source ? `${source}: ` : ""}${summary}`.slice(0, MAX_STDERR_CHARS);
+};
+var runnerLabel = (runner) => runner === "claude" ? "Claude" : runner === "veda" ? "Veda" : "OMP";
+var terminateChild = (child, signal) => {
+  if (!child.pid) return;
+  try {
+    process.kill(process.platform === "win32" ? child.pid : -child.pid, signal);
+  } catch {
+  }
+};
+var extractBalancedJson = (text, start) => {
+  const open = text[start];
+  if (open !== "{" && open !== "[") return null;
+  const close = open === "{" ? "}" : "]";
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === open) depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return null;
+};
+var parseStructuredValue = (text) => {
+  const trimmed = text.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+  }
+  const fenced = trimmed.match(/```(?:json)?\s*\n([\s\S]*?)\n```/i);
+  if (fenced?.[1]) {
+    try {
+      return JSON.parse(fenced[1].trim());
+    } catch {
+    }
+  }
+  const start = trimmed.search(/[{\[]/);
+  if (start >= 0) {
+    const balanced = extractBalancedJson(trimmed, start);
+    if (balanced) return JSON.parse(balanced);
+  }
+  return JSON.parse(trimmed);
+};
+var crashContext;
+var runRecordHelpers;
+var terminalWritten = false;
+var writeCrashStatus = (error) => {
+  if (!crashContext || !runRecordHelpers || terminalWritten) return;
+  try {
+    runRecordHelpers.writeCrashRunRecord(crashContext.statusFile, crashContext.record, error);
+  } catch {
+  }
+};
+process.on("uncaughtException", (error) => {
+  writeCrashStatus(error);
+  process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : error}
+`);
+  process.exit(1);
+});
+process.on("unhandledRejection", (error) => {
+  writeCrashStatus(error);
+  process.stderr.write(`Unhandled rejection: ${error instanceof Error ? error.stack ?? error.message : error}
+`);
+  process.exit(1);
+});
+var main = async () => {
+  const [optionHelpers, loadedRunRecordHelpers, sessionExportHelpers] = await Promise.all([
+    loadWorkerOptions(),
+    loadWorkerRunRecord(),
+    loadWorkerSessionExport()
+  ]);
+  runRecordHelpers = loadedRunRecordHelpers;
+  const {
+    applyUsage,
+    createRunningRecord,
+    emptyUsage,
+    extractUsageDelta,
+    latestRunText,
+    updateRunRecord,
+    writeRunRecord
+  } = loadedRunRecordHelpers;
+  const options = optionHelpers.parseWorkerOptions();
+  const sessionExporter = options.sessionExportFile ? new sessionExportHelpers.SessionExporter({
+    file: options.sessionExportFile,
+    sessionId: options.id,
+    cwd: options.cwd,
+    agentName: options.name
+  }) : void 0;
+  const thinking = options.thinking === "off" || options.thinking === "minimal" || options.thinking === "low" || options.thinking === "medium" || options.thinking === "high" || options.thinking === "xhigh" || options.thinking === "max" ? options.thinking : void 0;
+  const task = fs.readFileSync(options.taskFile, "utf8");
+  const images = readImages(options.imagesFile);
+  const record = createRunningRecord(options, task, thinking, Date.now());
+  writeRunRecord(options.statusFile, record);
+  const emitLifecycle = (event, data) => {
+    try {
+      fs.mkdirSync(path.dirname(options.lifecycleFile), { recursive: true });
+      fs.appendFileSync(
+        options.lifecycleFile,
+        JSON.stringify({ version: 1, event, occurredAt: Date.now(), ...data ? { data } : {} }) + "\n",
+        { encoding: "utf8", mode: 384 }
+      );
+    } catch {
+    }
+  };
+  crashContext = { statusFile: options.statusFile, record };
+  process.stdout.write(`[omp-fabric] ${options.name}
+${task}
+
+`);
+  fs.mkdirSync(path.dirname(options.logFile), { recursive: true });
+  const appendLog = (text) => {
+    try {
+      fs.appendFileSync(options.logFile, text, { encoding: "utf8", mode: 384 });
+    } catch {
+    }
+  };
+  const sessionStream = options.runner === "claude" && options.sessionFile ? fs.createWriteStream(options.sessionFile, { flags: "a", mode: 384 }) : void 0;
+  sessionStream?.on("error", () => {
+  });
+  const schema = options.schemaFile ? fs.readFileSync(options.schemaFile, "utf8") : void 0;
+  const ompArguments = ["--mode", "rpc"];
+  if (options.sessionFile) ompArguments.push("--session", options.sessionFile);
+  else ompArguments.push("--no-session");
+  if (!options.extensions) ompArguments.push("--no-extensions");
+  if (options.fabricExtensionPath) ompArguments.push("-e", options.fabricExtensionPath);
+  if (options.tools.length > 0) ompArguments.push("--tools", options.tools.join(","));
+  else ompArguments.push("--no-tools");
+  if (options.model) ompArguments.push("--model", options.model);
+  if (thinking) ompArguments.push("--thinking", thinking);
+  if (options.systemPrompt) ompArguments.push("--append-system-prompt", options.systemPrompt);
+  if (schema) {
+    ompArguments.push(
+      "--append-system-prompt",
+      `Your final response must contain only JSON matching this schema, without Markdown fences:
+${schema}`
+    );
+  }
+  const claudeCli = options.runner === "claude" ? await loadClaudeCli() : void 0;
+  const vedaCli = options.runner === "veda" ? await loadVedaCli() : void 0;
+  const childArguments = options.runner === "claude" ? claudeCli.buildClaudeArguments({
+    tools: options.tools,
+    extensions: options.extensions,
+    persistentSession: Boolean(options.sessionFile),
+    ...options.model ? { model: options.model } : {},
+    ...thinking ? { thinking } : {},
+    ...options.systemPrompt ? { systemPrompt: options.systemPrompt } : {},
+    ...schema ? { schema } : {},
+    ...options.runnerSessionId ? { runnerSessionId: options.runnerSessionId } : {},
+    name: options.name
+  }) : options.runner === "veda" ? vedaCli.buildVedaArguments({
+    backend: options.vedaBackend,
+    persona: options.vedaPersona,
+    ...options.model ? { model: options.model } : {},
+    ...thinking ? { thinking } : {},
+    tools: options.tools,
+    // Isolate selection and conversation state per child run so
+    // parallel Fabric agents never share Veda session state.
+    session: `fabric-${options.id}`
+  }) : ompArguments;
+  const childBinary = options.runner === "claude" ? options.claudeBinary : options.runner === "veda" ? options.vedaBinary : options.ompBinary;
+  const child = spawnCli(childBinary, childArguments, {
+    cwd: options.cwd,
+    detached: process.platform !== "win32",
+    env: {
+      ...process.env,
+      OMP_FABRIC_DEPTH: String(options.depth),
+      OMP_FABRIC_PARENT_RUN: options.id,
+      OMP_FABRIC_AGENT_NAME: options.name,
+      ...options.mainAgentId ? { OMP_FABRIC_MAIN_AGENT_ID: options.mainAgentId } : {},
+      ...options.fabricSessionId ? { OMP_FABRIC_SESSION_ID: options.fabricSessionId } : {},
+      OMP_FABRIC_GRANTED_RISKS: options.grantedRisks.join(","),
+      OMP_FABRIC_FULL_CODE_MODE: String(options.fullCodeMode),
+      // Native tool allowlist for nested-call enforcement: full-code children
+      // reach omp.* through fabric_exec, which is not gated by the --tools
+      // allowlist, so both OMP and captured-tool providers enforce this
+      // child-side allowlist before preparation, discovery, and invocation.
+      OMP_FABRIC_TOOL_ALLOWLIST: JSON.stringify(options.tools),
+      ...options.actorId ? { OMP_FABRIC_ACTOR_ID: options.actorId } : {},
+      ...options.actorName ? { OMP_FABRIC_ACTOR_NAME: options.actorName } : {},
+      OMP_FABRIC_CAPABILITY_REQUIREMENTS: JSON.stringify(
+        options.capabilityRequirements ?? []
+      ),
+      OMP_FABRIC_CAPABILITY_DIGEST: options.capabilityDigest ?? "",
+      ...options.meshRoot ? { OMP_FABRIC_MESH_ROOT: options.meshRoot } : {},
+      ...options.projectRoot ? { OMP_FABRIC_PROJECT_ROOT: options.projectRoot } : {},
+      ...options.ownerHostId ? { OMP_FABRIC_OWNER_HOST_ID: options.ownerHostId } : {},
+      ...options.ownerIdentityId ? { OMP_FABRIC_OWNER_IDENTITY_ID: options.ownerIdentityId } : {},
+      ...options.runRoot ? { OMP_FABRIC_RUN_ROOT: options.runRoot } : {}
+    },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let stderr = "";
+  let outputBuffer = "";
+  let vedaOutput = "";
+  let vedaParsed;
+  const outputDecoder = new StringDecoder("utf8");
+  const stderrDecoder = new StringDecoder("utf8");
+  let terminalStatus;
+  let terminalError;
+  let sawAgentError = false;
+  let retryPending = false;
+  let lastCompactionReason;
+  const update = () => updateRunRecord(options.statusFile, record);
+  const lastEmittedUsage = emptyUsage();
+  const emitTokenUsage = (delta, attribution) => {
+    const snapshot = record.usage;
+    if (snapshot.input === lastEmittedUsage.input && snapshot.output === lastEmittedUsage.output && snapshot.cacheRead === lastEmittedUsage.cacheRead && snapshot.cacheWrite === lastEmittedUsage.cacheWrite && snapshot.cost === lastEmittedUsage.cost) {
+      return;
+    }
+    emitLifecycle("tokens.usage", {
+      runId: options.id,
+      name: options.name,
+      runner: options.runner,
+      depth: options.depth,
+      ...options.actorId ? { actorId: options.actorId } : {},
+      ...options.actorName ? { actorName: options.actorName } : {},
+      cumulativeTokens: snapshot.input + snapshot.output + snapshot.cacheRead + snapshot.cacheWrite,
+      input: delta?.input ?? 0,
+      output: delta?.output ?? 0,
+      cacheRead: delta?.cacheRead ?? 0,
+      cacheWrite: delta?.cacheWrite ?? 0,
+      cost: delta?.cost ?? snapshot.cost
+    });
+    sessionExporter?.push(
+      {
+        input: delta?.input ?? 0,
+        output: delta?.output ?? 0,
+        cacheRead: delta?.cacheRead ?? 0,
+        cacheWrite: delta?.cacheWrite ?? 0,
+        cost: delta?.cost ?? snapshot.cost
+      },
+      attribution?.model ?? record.model ?? options.model,
+      attribution?.provider
+    );
+    lastEmittedUsage.input = snapshot.input;
+    lastEmittedUsage.output = snapshot.output;
+    lastEmittedUsage.cacheRead = snapshot.cacheRead;
+    lastEmittedUsage.cacheWrite = snapshot.cacheWrite;
+    lastEmittedUsage.cost = snapshot.cost;
+  };
+  const { ChildCompactControl } = await loadCompactControl();
+  const compactControl = new ChildCompactControl(options.id, {
+    send(frame) {
+      if (!child.stdin || child.stdin.writableEnded || child.stdin.destroyed) {
+        throw new Error("Child OMP stdin closed before compaction could start");
+      }
+      child.stdin.write(`${JSON.stringify(frame)}
+`);
+    },
+    close() {
+      child.stdin?.end();
+    },
+    update(status) {
+      record.compaction = status;
+      update();
+    }
+  });
+  const enforceTokenLimit = () => {
+    if (terminalStatus || !options.maxTokens || options.maxTokens <= 0) return;
+    const total = record.usage.input + record.usage.output + record.usage.cacheRead + record.usage.cacheWrite;
+    if (total <= options.maxTokens) return;
+    terminalStatus = "timed_out";
+    terminalError = `Fabric token limit reached: ${total} tokens (limit ${options.maxTokens} set by agents.maxTokensPerChild); terminating child. The count is cumulative across the run and includes cache reads/writes, so it grows every turn; raise or disable agents.maxTokensPerChild in /fabric settings (0 disables), or split the task into smaller agent runs.`;
+    terminateChild(child, "SIGTERM");
+    setTimeout(() => terminateChild(child, "SIGKILL"), KILL_GRACE_MS).unref();
+    child.stdin?.end();
+  };
+  const claudeTools = /* @__PURE__ */ new Map();
+  const claudeCompletedUsage = emptyUsage();
+  const claudeCurrentUsage = emptyUsage();
+  const syncClaudeUsage = () => {
+    record.usage = {
+      input: claudeCompletedUsage.input + claudeCurrentUsage.input,
+      output: claudeCompletedUsage.output + claudeCurrentUsage.output,
+      cacheRead: claudeCompletedUsage.cacheRead + claudeCurrentUsage.cacheRead,
+      cacheWrite: claudeCompletedUsage.cacheWrite + claudeCurrentUsage.cacheWrite,
+      cost: claudeCompletedUsage.cost
+    };
+  };
+  const claudeSentInputs = [];
+  const claudeSteering = [];
+  const claudeFollowUps = [];
+  let claudeSteeringMode = "one-at-a-time";
+  let claudeFollowUpMode = "one-at-a-time";
+  let claudeCanFollowUp = false;
+  let claudeResultSeen = false;
+  const enqueueClaudeControl = (queue, message) => {
+    const pendingInputs = claudeSentInputs.length + claudeSteering.length + claudeFollowUps.length;
+    if (pendingInputs >= MAX_CLAUDE_PENDING_INPUTS) return;
+    queue.push(message);
+  };
+  let claudeCloseTimer;
+  const updateClaudeQueue = () => {
+    const sentSteering = claudeSentInputs.filter((entry) => entry.kind === "steer").map((entry) => entry.message);
+    const sentFollowUps = claudeSentInputs.filter((entry) => entry.kind === "follow_up").map((entry) => entry.message);
+    record.pendingMessages = {
+      steering: [...sentSteering, ...claudeSteering],
+      followUp: [...sentFollowUps, ...claudeFollowUps]
+    };
+    update();
+  };
+  const writeClaudeInput = (kind, message, inputImages = []) => {
+    if (claudeCloseTimer) clearTimeout(claudeCloseTimer);
+    claudeCloseTimer = void 0;
+    if (!child.stdin || child.stdin.writableEnded || child.stdin.destroyed) return;
+    claudeSentInputs.push({ kind, message });
+    if (kind === "follow_up") claudeCanFollowUp = false;
+    child.stdin.write(
+      `${JSON.stringify(claudeCli.claudeUserMessage(message, inputImages))}
+`
+    );
+    updateClaudeQueue();
+  };
+  const flushClaudeSteering = () => {
+    if (claudeSteering.length === 0) return;
+    const alreadySent = claudeSentInputs.some((entry) => entry.kind === "steer");
+    if (claudeSteeringMode === "one-at-a-time" && alreadySent) return;
+    const count = claudeSteeringMode === "all" ? claudeSteering.length : 1;
+    for (const message of claudeSteering.splice(0, count)) {
+      writeClaudeInput("steer", message);
+    }
+  };
+  const flushClaudeFollowUps = () => {
+    if (claudeFollowUps.length === 0 || claudeSteering.length > 0) return;
+    if (claudeSentInputs.some((entry) => entry.kind === "steer")) return;
+    const alreadySent = claudeSentInputs.some((entry) => entry.kind === "follow_up");
+    if (claudeFollowUpMode === "one-at-a-time" && alreadySent) return;
+    const count = claudeFollowUpMode === "all" ? claudeFollowUps.length : 1;
+    for (const message of claudeFollowUps.splice(0, count)) {
+      writeClaudeInput("follow_up", message);
+    }
+  };
+  const scheduleClaudeClose = () => {
+    if (claudeCloseTimer || terminalStatus) return;
+    claudeCloseTimer = setTimeout(() => {
+      claudeCloseTimer = void 0;
+      if (claudeSentInputs.length === 0 && claudeSteering.length === 0 && claudeFollowUps.length === 0) {
+        child.stdin?.end();
+      }
+    }, 300);
+    claudeCloseTimer.unref();
+  };
+  const processClaudeEvent = (event) => {
+    if (event.type === "system" && event.subtype === "init") {
+      const sessionId2 = stringField(event.session_id);
+      if (sessionId2) record.runnerSessionId = sessionId2;
+      const model = stringField(event.model);
+      if (model && !record.model) record.model = model;
+      update();
+      return;
+    }
+    if (event.type === "assistant") {
+      const message = event.message;
+      if (typeof message !== "object" || message === null || Array.isArray(message)) return;
+      const assistant = message;
+      const text = extractText(assistant);
+      if (text) {
+        record.text = latestRunText(text);
+        process.stdout.write(`
+${text}
+`);
+      }
+      const content = assistant.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (typeof block !== "object" || block === null || Array.isArray(block)) continue;
+          const part = block;
+          if (part.type !== "tool_use") continue;
+          const id = stringField(part.id);
+          const name = stringField(part.name);
+          if (!id || !name || claudeTools.has(id)) continue;
+          claudeTools.set(id, name);
+          while (claudeTools.size > MAX_CLAUDE_PENDING_TOOLS) {
+            const oldestToolId = claudeTools.keys().next().value;
+            if (oldestToolId === void 0) break;
+            claudeTools.delete(oldestToolId);
+          }
+          record.toolCalls++;
+          record.currentTool = name;
+          process.stdout.write(`\u2192 ${name}
+`);
+        }
+      }
+      const usage = assistant.usage;
+      if (typeof usage === "object" && usage !== null && !Array.isArray(usage)) {
+        const values = usage;
+        const delta = {
+          input: numberField(values.input_tokens),
+          output: numberField(values.output_tokens),
+          cacheRead: numberField(values.cache_read_input_tokens),
+          cacheWrite: numberField(values.cache_creation_input_tokens),
+          cost: 0
+        };
+        claudeCurrentUsage.input += delta.input;
+        claudeCurrentUsage.output += delta.output;
+        claudeCurrentUsage.cacheRead += delta.cacheRead;
+        claudeCurrentUsage.cacheWrite += delta.cacheWrite;
+        syncClaudeUsage();
+        emitTokenUsage(delta, { model: record.model ?? stringField(event.model) });
+      }
+      if (typeof event.error === "string") {
+        sawAgentError = true;
+        terminalError = event.error;
+      }
+      enforceTokenLimit();
+      update();
+      return;
+    }
+    if (event.type === "user") {
+      const message = event.message;
+      if (typeof message !== "object" || message === null || Array.isArray(message)) return;
+      const content = message.content;
+      if (!Array.isArray(content)) return;
+      for (const block of content) {
+        if (typeof block !== "object" || block === null || Array.isArray(block)) continue;
+        const part = block;
+        if (part.type !== "tool_result") continue;
+        const id = stringField(part.tool_use_id);
+        if (id) claudeTools.delete(id);
+      }
+      const current = [...claudeTools.values()].at(-1);
+      if (current) record.currentTool = current;
+      else delete record.currentTool;
+      update();
+      return;
+    }
+    if (event.type === "stream_event") {
+      const streamEvent = event.event;
+      if (typeof streamEvent !== "object" || streamEvent === null || Array.isArray(streamEvent)) return;
+      const stream = streamEvent;
+      if (stream.type !== "content_block_start") return;
+      const contentBlock = stream.content_block;
+      if (typeof contentBlock !== "object" || contentBlock === null || Array.isArray(contentBlock)) return;
+      const block = contentBlock;
+      const name = stringField(block.name);
+      if (block.type === "tool_use" && name) {
+        record.currentTool = name;
+        update();
+      }
+      return;
+    }
+    if (event.type !== "result") return;
+    claudeResultSeen = true;
+    const sessionId = stringField(event.session_id);
+    if (sessionId) record.runnerSessionId = sessionId;
+    const resultText = typeof event.result === "string" ? event.result : "";
+    if (resultText) record.text = latestRunText(resultText);
+    if (event.structured_output !== void 0) record.value = event.structured_output;
+    record.turns += Math.max(0, Math.floor(numberField(event.num_turns)));
+    const resultUsage = typeof event.usage === "object" && event.usage !== null && !Array.isArray(event.usage) ? event.usage : void 0;
+    const resultDelta = resultUsage ? {
+      input: numberField(resultUsage.input_tokens) - claudeCurrentUsage.input,
+      output: numberField(resultUsage.output_tokens) - claudeCurrentUsage.output,
+      cacheRead: numberField(resultUsage.cache_read_input_tokens) - claudeCurrentUsage.cacheRead,
+      cacheWrite: numberField(resultUsage.cache_creation_input_tokens) - claudeCurrentUsage.cacheWrite,
+      cost: Math.max(0, numberField(event.total_cost_usd))
+    } : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: Math.max(0, numberField(event.total_cost_usd)) };
+    claudeCompletedUsage.input += resultUsage ? numberField(resultUsage.input_tokens) : claudeCurrentUsage.input;
+    claudeCompletedUsage.output += resultUsage ? numberField(resultUsage.output_tokens) : claudeCurrentUsage.output;
+    claudeCompletedUsage.cacheRead += resultUsage ? numberField(resultUsage.cache_read_input_tokens) : claudeCurrentUsage.cacheRead;
+    claudeCompletedUsage.cacheWrite += resultUsage ? numberField(resultUsage.cache_creation_input_tokens) : claudeCurrentUsage.cacheWrite;
+    claudeCompletedUsage.cost += Math.max(0, numberField(event.total_cost_usd));
+    claudeCurrentUsage.input = 0;
+    claudeCurrentUsage.output = 0;
+    claudeCurrentUsage.cacheRead = 0;
+    claudeCurrentUsage.cacheWrite = 0;
+    syncClaudeUsage();
+    emitTokenUsage(resultDelta, { model: record.model ?? stringField(event.model) });
+    enforceTokenLimit();
+    const failed = event.is_error === true || event.subtype !== "success";
+    if (failed) {
+      sawAgentError = true;
+      const errors = Array.isArray(event.errors) ? event.errors.filter((value) => typeof value === "string").join(" \xB7 ") : "";
+      terminalError = errors || resultText || `Claude returned ${String(event.subtype ?? "an error")}`;
+      claudeSteering.splice(0);
+      claudeFollowUps.splice(0);
+    } else {
+      sawAgentError = false;
+      if (!terminalStatus) terminalError = void 0;
+    }
+    if (failed || terminalStatus) claudeSentInputs.splice(0);
+    else claudeSentInputs.shift();
+    claudeCanFollowUp = !failed && !terminalStatus;
+    delete record.currentTool;
+    updateClaudeQueue();
+    if (failed || terminalStatus) {
+      child.stdin?.end();
+      return;
+    }
+    flushClaudeSteering();
+    if (claudeSentInputs.length === 0 && claudeSteering.length === 0) {
+      flushClaudeFollowUps();
+    }
+    if (claudeSentInputs.length === 0 && claudeSteering.length === 0 && claudeFollowUps.length === 0) {
+      scheduleClaudeClose();
+    }
+  };
+  const processEvent = (line) => {
+    if (process.env.OMP_FABRIC_INJECT_CRASH === "stream") throw new Error("simulated stream crash");
+    if (!line.trim()) return;
+    appendLog(`${line}
+`);
+    sessionStream?.write(`${line}
+`);
+    let event;
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
+      event = parsed;
+    } catch {
+      return;
+    }
+    if (options.runner === "claude") {
+      processClaudeEvent(event);
+      return;
+    }
+    compactControl.observe(event);
+    if (event.type === "agent_start") {
+      emitLifecycle("omp.agent_start");
+      retryPending = false;
+      sawAgentError = false;
+      terminalError = void 0;
+      return;
+    }
+    if (event.type === "response" && event.command === "prompt" && event.success === false) {
+      sawAgentError = true;
+      terminalError = typeof event.error === "string" ? event.error : "OMP rejected the prompt";
+      child.stdin?.end();
+      return;
+    }
+    if (event.type === "extension_ui_request") {
+      const method = event.method;
+      if (typeof event.id === "string" && (method === "select" || method === "confirm" || method === "input" || method === "editor")) {
+        child.stdin?.write(
+          `${JSON.stringify({ type: "extension_ui_response", id: event.id, cancelled: true })}
+`
+        );
+      }
+      return;
+    }
+    if (event.type === "tool_execution_start") {
+      record.toolCalls++;
+      if (typeof event.toolName === "string") {
+        record.currentTool = event.toolName;
+        process.stdout.write(`\u2192 ${event.toolName}
+`);
+      }
+      update();
+      return;
+    }
+    if (event.type === "tool_execution_end") {
+      if (event.isError === true) {
+        emitLifecycle("omp.tool_error", {
+          ...typeof event.toolCallId === "string" ? { toolCallId: event.toolCallId } : {},
+          ...typeof event.toolName === "string" ? { toolName: event.toolName } : {}
+        });
+      }
+      delete record.currentTool;
+      update();
+      return;
+    }
+    if (event.type === "turn_end") {
+      emitLifecycle("omp.turn_end", {
+        ...typeof event.turnIndex === "number" ? { turnIndex: event.turnIndex } : {}
+      });
+      record.turns++;
+      update();
+      return;
+    }
+    if (event.type === "queue_update") {
+      const steering = Array.isArray(event.steering) ? event.steering.filter((value) => typeof value === "string") : [];
+      const followUp = Array.isArray(event.followUp) ? event.followUp.filter((value) => typeof value === "string") : [];
+      record.pendingMessages = { steering, followUp };
+      update();
+      return;
+    }
+    if (event.type === "message_end") {
+      const message = event.message;
+      if (typeof message !== "object" || message === null || Array.isArray(message)) return;
+      const messageRecord = message;
+      if (messageRecord.role !== "assistant") return;
+      const text = extractText(messageRecord);
+      if (text) {
+        record.text = latestRunText(text);
+        process.stdout.write(`
+${text}
+`);
+      }
+      const usageDelta = extractUsageDelta(messageRecord);
+      applyUsage(record, messageRecord);
+      emitTokenUsage(usageDelta, {
+        model: stringField(messageRecord.model),
+        provider: stringField(messageRecord.provider)
+      });
+      enforceTokenLimit();
+      if (messageRecord.stopReason === "error") {
+        sawAgentError = true;
+        terminalError = assistantError(messageRecord);
+      } else {
+        sawAgentError = false;
+        if (!terminalStatus) terminalError = void 0;
+      }
+      update();
+      return;
+    }
+    if (event.type === "agent_end") {
+      retryPending = event.isTerminal === false;
+      emitLifecycle("omp.agent_end", { isTerminal: !retryPending });
+      if (!retryPending) {
+        pollSteer();
+        compactControl.childSettled();
+      }
+      return;
+    }
+    if (event.type === "auto_compaction_start") {
+      lastCompactionReason = typeof event.reason === "string" ? event.reason : void 0;
+      return;
+    }
+    if (event.type === "auto_compaction_end") {
+      emitLifecycle("omp.session_compact", {
+        ...lastCompactionReason !== void 0 ? { reason: lastCompactionReason } : {},
+        ...typeof event.willRetry === "boolean" ? { willRetry: event.willRetry } : {},
+        ...typeof event.aborted === "boolean" ? { aborted: event.aborted } : {}
+      });
+      lastCompactionReason = void 0;
+      return;
+    }
+    if (event.type === "extension_error") {
+      const error = typeof event.error === "string" ? event.error : "Extension error";
+      stderr = `${stderr}
+${error}`.trim().slice(-MAX_STDERR_CHARS);
+      update();
+    }
+  };
+  child.stdin?.on("error", () => {
+  });
+  if (options.runner === "claude") {
+    writeClaudeInput("initial", task, images);
+  } else if (options.runner === "veda") {
+    const sections = [];
+    if (options.systemPrompt) {
+      sections.push(`<system_instructions>
+${options.systemPrompt}
+</system_instructions>`);
+    }
+    if (schema) {
+      sections.push(
+        `Your final response must contain only JSON matching this schema, without Markdown fences:
+${schema}`
+      );
+    }
+    sections.push(task);
+    child.stdin?.write(sections.join("\n\n"));
+    child.stdin?.end();
+  } else {
+    child.stdin?.write(
+      `${JSON.stringify({
+        type: "prompt",
+        message: task,
+        ...images.length > 0 ? { images } : {}
+      })}
+`
+    );
+  }
+  let steerOffset = 0;
+  let steerRemainder = Buffer.alloc(0);
+  let skippingOversizedSteerLine = false;
+  const pollSteer = () => {
+    if (!options.steerFile || terminalStatus) return;
+    let descriptor;
+    try {
+      descriptor = fs.openSync(options.steerFile, "r");
+    } catch {
+      return;
+    }
+    try {
+      const size = fs.fstatSync(descriptor).size;
+      if (size < steerOffset) {
+        steerOffset = 0;
+        steerRemainder = Buffer.alloc(0);
+        skippingOversizedSteerLine = false;
+      }
+      if (size <= steerOffset) return;
+      const length = Math.min(size - steerOffset, STEER_READ_CHUNK_BYTES);
+      const buffer = Buffer.allocUnsafe(length);
+      const bytesRead = fs.readSync(descriptor, buffer, 0, length, steerOffset);
+      steerOffset += bytesRead;
+      let combined = Buffer.concat([steerRemainder, buffer.subarray(0, bytesRead)]);
+      if (skippingOversizedSteerLine) {
+        const skippedLineEnd = combined.indexOf(10);
+        if (skippedLineEnd < 0) return;
+        combined = combined.subarray(skippedLineEnd + 1);
+        skippingOversizedSteerLine = false;
+      }
+      const newline = combined.lastIndexOf(10);
+      if (newline < 0) {
+        if (combined.length > MAX_STEER_LINE_BYTES) {
+          steerRemainder = Buffer.alloc(0);
+          skippingOversizedSteerLine = true;
+        } else {
+          steerRemainder = Buffer.from(combined);
+        }
+        return;
+      }
+      const remainder = combined.subarray(newline + 1);
+      if (remainder.length > MAX_STEER_LINE_BYTES) {
+        steerRemainder = Buffer.alloc(0);
+        skippingOversizedSteerLine = true;
+      } else {
+        steerRemainder = Buffer.from(remainder);
+      }
+      let processedCommands = 0;
+      for (const raw of combined.subarray(0, newline + 1).toString("utf8").split("\n")) {
+        if (processedCommands >= MAX_STEER_COMMANDS_PER_POLL) break;
+        if (Buffer.byteLength(raw, "utf8") > MAX_STEER_LINE_BYTES) continue;
+        const line = raw.trim();
+        if (!line) continue;
+        processedCommands += 1;
+        let command;
+        try {
+          command = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        try {
+          if (options.runner === "claude") {
+            if (claudeCloseTimer) clearTimeout(claudeCloseTimer);
+            claudeCloseTimer = void 0;
+            if (command.type === "steer" && typeof command.message === "string") {
+              enqueueClaudeControl(claudeSteering, command.message);
+              flushClaudeSteering();
+            } else if (command.type === "follow_up" && typeof command.message === "string") {
+              enqueueClaudeControl(claudeFollowUps, command.message);
+              if (claudeCanFollowUp && claudeSentInputs.length === 0) flushClaudeFollowUps();
+            } else if (command.type === "set_steering_mode" && (command.mode === "all" || command.mode === "one-at-a-time")) {
+              claudeSteeringMode = command.mode;
+              flushClaudeSteering();
+            } else if (command.type === "set_follow_up_mode" && (command.mode === "all" || command.mode === "one-at-a-time")) {
+              claudeFollowUpMode = command.mode;
+              if (claudeCanFollowUp && claudeSentInputs.length === 0) flushClaudeFollowUps();
+            }
+            updateClaudeQueue();
+          } else if (options.runner === "veda") {
+          } else if (command.type === "steer" && typeof command.message === "string") {
+            child.stdin?.write(JSON.stringify({ type: "steer", message: command.message }) + "\n");
+          } else if (command.type === "follow_up" && typeof command.message === "string") {
+            child.stdin?.write(JSON.stringify({ type: "follow_up", message: command.message }) + "\n");
+          } else if (command.type === "set_steering_mode" && typeof command.mode === "string") {
+            child.stdin?.write(JSON.stringify({ type: "set_steering_mode", mode: command.mode }) + "\n");
+          } else if (command.type === "set_follow_up_mode" && typeof command.mode === "string") {
+            child.stdin?.write(JSON.stringify({ type: "set_follow_up_mode", mode: command.mode }) + "\n");
+          } else if (command.type === "compact") {
+            compactControl.queue(command.instructions);
+          }
+        } catch {
+        }
+      }
+    } finally {
+      fs.closeSync(descriptor);
+    }
+  };
+  const steerTimer = options.steerFile ? setInterval(pollSteer, 200) : void 0;
+  steerTimer?.unref?.();
+  const failOversizedEvent = (line) => {
+    const prefix = line.slice(0, MAX_EVENT_LINE_CHARS);
+    let artifactPath;
+    try {
+      artifactPath = path.join(path.dirname(options.logFile), "oversized-event-prefix.txt");
+      fs.writeFileSync(artifactPath, prefix, { encoding: "utf8", mode: 384 });
+    } catch {
+      artifactPath = void 0;
+    }
+    terminalStatus = "failed";
+    terminalError = artifactPath ? `Agent emitted an oversized event line; first ${prefix.length} characters saved to: ${artifactPath}` : "Agent emitted an oversized event line";
+    outputBuffer = "";
+    terminateChild(child, "SIGTERM");
+  };
+  child.stdout?.on("data", (chunk) => {
+    const decoded = outputDecoder.write(chunk);
+    if (options.runner === "veda") {
+      vedaOutput += decoded;
+      return;
+    }
+    outputBuffer += decoded;
+    while (true) {
+      const newline = outputBuffer.indexOf("\n");
+      if (newline < 0) {
+        if (outputBuffer.length > MAX_EVENT_LINE_CHARS) {
+          failOversizedEvent(outputBuffer);
+        }
+        break;
+      }
+      if (newline > MAX_EVENT_LINE_CHARS) {
+        failOversizedEvent(outputBuffer.slice(0, newline));
+        return;
+      }
+      const line = outputBuffer.slice(0, newline).replace(/\r$/, "");
+      outputBuffer = outputBuffer.slice(newline + 1);
+      processEvent(line);
+    }
+  });
+  const recordStderr = (text) => {
+    if (!text) return;
+    appendLog(`${JSON.stringify({ type: "worker_stderr", text })}
+`);
+    process.stderr.write(text);
+    stderr = `${stderr}${text}`.slice(-MAX_STDERR_CHARS);
+  };
+  child.stderr?.on("data", (chunk) => {
+    recordStderr(stderrDecoder.write(chunk));
+  });
+  child.stderr?.on("error", () => {
+  });
+  const timeout = setTimeout(() => {
+    terminalStatus = "timed_out";
+    terminalError = `Agent timed out after ${options.timeoutMs}ms`;
+    terminateChild(child, "SIGTERM");
+    setTimeout(() => terminateChild(child, "SIGKILL"), KILL_GRACE_MS).unref();
+  }, options.timeoutMs);
+  timeout.unref();
+  const stop = () => {
+    if (terminalStatus) return;
+    terminalStatus = "stopped";
+    terminalError = "Agent stopped";
+    terminateChild(child, "SIGTERM");
+    setTimeout(() => terminateChild(child, "SIGKILL"), KILL_GRACE_MS).unref();
+  };
+  process.once("SIGTERM", stop);
+  process.once("SIGINT", stop);
+  process.once("SIGHUP", stop);
+  const exitCode = await new Promise((resolve) => {
+    child.once("error", (error) => {
+      terminalStatus = "failed";
+      terminalError = error.message;
+      resolve(null);
+    });
+    child.once("close", (code) => resolve(code));
+  });
+  if (steerTimer) clearInterval(steerTimer);
+  if (claudeCloseTimer) clearTimeout(claudeCloseTimer);
+  clearTimeout(timeout);
+  if (process.env.OMP_FABRIC_INJECT_CRASH === "close") throw new Error("simulated close crash");
+  if (options.runner === "veda") {
+    vedaOutput += outputDecoder.end();
+  } else {
+    outputBuffer += outputDecoder.end();
+  }
+  recordStderr(stderrDecoder.end());
+  if (options.runner === "veda") {
+    const trimmed = vedaOutput.trim();
+    if (trimmed) {
+      try {
+        const parsed = parseStructuredValue(trimmed);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          vedaParsed = parsed;
+          const text = stringField(vedaParsed.text) ?? "";
+          if (text) {
+            record.text = latestRunText(text);
+            process.stdout.write(`
+${text}
+`);
+          }
+          const sessionId = stringField(vedaParsed.sessionId);
+          if (sessionId) record.runnerSessionId = sessionId;
+          const usage = vedaParsed.usage;
+          if (typeof usage === "object" && usage !== null && !Array.isArray(usage)) {
+            const values = usage;
+            const input = numberField(values.inputTokens);
+            const output = numberField(values.outputTokens);
+            const cacheRead = numberField(values.cachedTokens);
+            const cost = typeof values.costUsd === "number" ? values.costUsd : 0;
+            record.usage = { input, output, cacheRead, cacheWrite: 0, cost };
+            emitTokenUsage({ input, output, cacheRead, cacheWrite: 0, cost }, { model: stringField(vedaParsed.model) });
+          }
+          const envelopeErrors = [];
+          const error = stringField(vedaParsed.error);
+          if (error) envelopeErrors.push(error);
+          for (const key of ["design", "worker"]) {
+            const gate = vedaParsed[key];
+            if (typeof gate !== "object" || gate === null || Array.isArray(gate)) continue;
+            const status = gate;
+            if (status.ok !== false) continue;
+            const details = Array.isArray(status.errors) ? status.errors.filter((entry) => typeof entry === "string").join("; ") : [stringField(status.reason), stringField(status.detail)].filter((entry) => entry !== void 0).join(": ");
+            envelopeErrors.push(`Veda ${key} failed${details ? `: ${details}` : ""}`);
+          }
+          if (envelopeErrors.length > 0) {
+            sawAgentError = true;
+            terminalError = envelopeErrors.join("\n");
+          }
+          record.turns += 1;
+          update();
+        }
+      } catch {
+      }
+    }
+  } else if (outputBuffer.trim()) {
+    processEvent(outputBuffer);
+  }
+  record.exitCode = exitCode;
+  record.stderr = stderr.slice(-MAX_STDERR_CHARS);
+  if (record.compaction?.status === "queued" || record.compaction?.status === "in_flight") {
+    const error = terminalError ?? "Child OMP exited before the queued compaction completed";
+    record.compaction = {
+      ...record.compaction,
+      status: "failed",
+      updatedAt: Date.now(),
+      finishedAt: Date.now(),
+      error
+    };
+    if (!terminalStatus) {
+      terminalStatus = "failed";
+      terminalError = error;
+    }
+  }
+  record.finishedAt = Date.now();
+  record.updatedAt = record.finishedAt;
+  const childCompleted = exitCode === 0 && !sawAgentError && (options.runner === "omp" || options.runner === "claude" && claudeResultSeen && claudeSentInputs.length === 0 && claudeSteering.length === 0 && claudeFollowUps.length === 0 || options.runner === "veda" && vedaParsed !== void 0);
+  record.status = terminalStatus ?? (childCompleted ? "completed" : "failed");
+  if (terminalError) record.error = terminalError;
+  if (record.status === "failed" && !record.error) {
+    record.error = stderr.trim() || (exitCode === 0 ? `${runnerLabel(options.runner)} agent reported an error before exiting` : `${runnerLabel(options.runner)} exited with code ${exitCode ?? "unknown"}`);
+  }
+  if (record.status === "completed" && options.schemaFile) {
+    try {
+      const schema2 = JSON.parse(fs.readFileSync(options.schemaFile, "utf8"));
+      const value = record.value ?? parseStructuredValue(record.text);
+      const validation = validateJsonSchemaValue(schema2, value);
+      if (!validation.success) {
+        const errors = validation.issues.slice(0, 5).map((error) => error.message).join("; ");
+        throw new Error(errors || "value does not match schema");
+      }
+      record.value = value;
+    } catch (error) {
+      record.status = "failed";
+      const reason = error instanceof Error ? error.message : String(error);
+      const output = record.text.trim();
+      const snippet = output.slice(0, 200);
+      record.error = `Structured agent output was invalid: ${reason}${snippet ? ` (output: ${snippet}${output.length > 200 ? "\u2026" : ""})` : ""}`;
+    }
+  }
+  delete record.currentTool;
+  writeRunRecord(options.statusFile, record);
+  terminalWritten = true;
+  process.stdout.write(`
+[omp-fabric] ${record.status}
+`);
+  await new Promise(
+    (resolve) => sessionStream ? sessionStream.end(resolve) : resolve()
+  );
+  process.exitCode = record.status === "completed" ? 0 : 1;
+};
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+  writeCrashStatus(error);
+  process.exit(1);
+});
+//# sourceMappingURL=worker.js.map