@iowarp/clio-coder 0.3.0

package/dist/worker/entry.js

@@ -0,0 +1,1739 @@
+#!/usr/bin/env node
+import {
+  createEngineAgent,
+  createLoopGuardRegistration,
+  createProtectedArtifactsRegistration,
+  describeCallTarget,
+  isLoopGuardSynthesisBackstopReason,
+  isReserveAdmittedTool,
+  patchWorkerRequestPayload,
+  resolveDeliveryTools,
+  sanitizeLockedSynthesisMessage,
+  workerLoopBlockBudget
+} from "../chunk-BYEU76JP.js";
+import {
+  DEFAULT_ESCALATION_FALLBACK,
+  DEFAULT_ESCALATION_TIMEOUT_MS,
+  WORKER_EXIT_PERMISSION_REQUIRED,
+  agentSkillToolPolicy,
+  attestedToolSignature,
+  claudeToolsOutsideProfile,
+  coerceToolInput,
+  createMiddlewareToolChoiceControl,
+  createRunEffectsRecorder,
+  createWorkerSafety,
+  createWorkerToolRegistry,
+  emitClaudeToolPermissionDecision,
+  isClaudeCodeSessionId,
+  parseWorkerSpec,
+  resolveAgentTools,
+  runtimeSpeaksResponseSchemaDialect,
+  shouldRequestStalledTurnContinuation,
+  startAntigravityWorkerRun,
+  startClaudeCodeWorkerRun,
+  validateRehydratedWorkerRuntime
+} from "../chunk-GNGDQYDU.js";
+import "../chunk-2J63S4SF.js";
+import "../chunk-RQDWMVRB.js";
+import "../chunk-7BHLZB3A.js";
+import "../chunk-TPOCL34A.js";
+import "../chunk-E3NYWENM.js";
+import {
+  RESULT_CONTRACT_REPAIR_LIMIT,
+  parseResultContract,
+  resultContractRepairMessage,
+  validateResultContract
+} from "../chunk-XV4ZJ6ZM.js";
+import "../chunk-26BZQOAD.js";
+import "../chunk-WD6AJM35.js";
+import {
+  ToolNames
+} from "../chunk-QV47YRF4.js";
+import "../chunk-CLJ5HLUD.js";
+import {
+  UNKNOWN_RESOURCE,
+  WORKER_PROTOCOL_VERSION,
+  WORKER_RESOURCE_LABEL_MAX,
+  WORKER_STDIN_FRAME_MAX_BYTES,
+  encodeControlFrame,
+  endpointIdentityHash,
+  knownResource,
+  parseAgentLedgerBody,
+  parseAgentLedgerEntry,
+  withinFrameBudget,
+  workerSpecDigest
+} from "../chunk-BBUH4VAA.js";
+import "../chunk-GOTUR54M.js";
+import {
+  FileKnowledgeBase,
+  applyModelCapabilityPatch,
+  disposeLmStudioClients,
+  getRuntimeRegistry,
+  loadPluginRuntimes,
+  registerBuiltinRuntimes,
+  registerClioApiProviders,
+  registerFauxFromEnv,
+  resolveModelRuntimeCapabilitiesForModel,
+  resolveProviderKnowledgeBaseRoots,
+  setGlobalDefaultMaxOutputTokens,
+  setProtectedModelsProvider,
+  setResidencyNoticeSink
+} from "../chunk-TKHQ4DGZ.js";
+import "../chunk-D5YD55AR.js";
+import {
+  readSettings,
+  validateSettingsFile
+} from "../chunk-JWHCJDCI.js";
+import {
+  configureGuardrails,
+  isWorkerToolCallCapExceededReason,
+  isWorkerToolCallCapSynthesisReason
+} from "../chunk-UHTSULZS.js";
+import "../chunk-5LDRNKX2.js";
+import "../chunk-UGYAX5YI.js";
+import "../chunk-5N2FG33Q.js";
+import "../chunk-VPAWTYLY.js";
+import "../chunk-X3NE4WVW.js";
+import {
+  readClioVersion
+} from "../chunk-DXQNI4PC.js";
+
+// src/engine/worker-runtime.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+// src/engine/claude/sdk-runtime.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+var DEFAULT_CLAUDE_TOOLS = { type: "preset", preset: "claude_code" };
+function sdkUserTextMessage(text, shouldQuery) {
+  return {
+    type: "user",
+    message: { role: "user", content: [{ type: "text", text }] },
+    parent_tool_use_id: null,
+    shouldQuery,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildClaudeSdkPrompt(input) {
+  const parts = (input.dynamicPromptMessages ?? []).map((message) => message.body.trim()).filter(Boolean);
+  parts.push(input.task);
+  return parts.join("\n\n");
+}
+async function* oneSdkUserMessage(message) {
+  yield message;
+}
+function claudeSdkPermissionModeForAutonomy(_level) {
+  return "default";
+}
+function claudeSdkToolsForAutonomy(_level) {
+  return DEFAULT_CLAUDE_TOOLS;
+}
+function effortForThinking(level) {
+  switch (level) {
+    case "minimal":
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+    case "xhigh":
+      return "xhigh";
+    default:
+      return void 0;
+  }
+}
+function thinkingForInput(input) {
+  const level = input.runtimeResolution?.effectiveThinkingLevel ?? input.thinkingLevel ?? "off";
+  if (level === "off") return { type: "disabled" };
+  const budgetTokens = input.runtimeResolution?.request.budgetTokens;
+  if (typeof budgetTokens === "number" && Number.isFinite(budgetTokens) && budgetTokens > 0) {
+    return { type: "enabled", budgetTokens, display: "summarized" };
+  }
+  return { type: "adaptive", display: "summarized" };
+}
+function systemPromptForInput(input) {
+  const append = input.systemPrompt.trim();
+  if (append.length === 0) return { type: "preset", preset: "claude_code" };
+  return { type: "preset", preset: "claude_code", append };
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function nestedRecord(record, key) {
+  const value = record[key];
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function normalizeUsage(raw, totalCostUsd = 0) {
+  const record = typeof raw === "object" && raw !== null ? raw : {};
+  const cacheCreation = finite(record.cache_creation_input_tokens) + finite(record.cacheCreationInputTokens) + finite(record.cacheWrite) + finite(record.cacheWriteTokens);
+  const cacheRead = finite(record.cache_read_input_tokens) + finite(record.cacheReadInputTokens) + finite(record.cacheRead) + finite(record.cacheReadTokens);
+  const input = finite(record.input_tokens) + finite(record.inputTokens) + finite(record.input) + finite(record.prompt_tokens) + finite(record.promptTokens);
+  const output = finite(record.output_tokens) + finite(record.outputTokens) + finite(record.output) + finite(record.completion_tokens) + finite(record.completionTokens);
+  const totalTokens = input + output + cacheRead + cacheCreation;
+  const cost = finite(totalCostUsd) + finite(record.costUSD) + finite(record.cost_usd);
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite: cacheCreation,
+    totalTokens,
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      total: cost
+    }
+  };
+}
+function textFromUnknownBlock(block) {
+  if (typeof block !== "object" || block === null) return "";
+  const record = block;
+  if (record.type === "text" && typeof record.text === "string") return record.text;
+  if (record.type === "thinking" && typeof record.thinking === "string") return "";
+  return "";
+}
+function thinkingFromUnknownBlock(block) {
+  if (typeof block !== "object" || block === null) return "";
+  const record = block;
+  if (record.type === "thinking" && typeof record.thinking === "string") return record.thinking;
+  return "";
+}
+function contentFromSdkMessage(message) {
+  const content = [];
+  const record = typeof message === "object" && message !== null ? message : {};
+  const blocks = Array.isArray(record.content) ? record.content : [];
+  for (const block of blocks) {
+    const text = textFromUnknownBlock(block);
+    if (text.length > 0) {
+      content.push({ type: "text", text });
+      continue;
+    }
+    const thinking = thinkingFromUnknownBlock(block);
+    if (thinking.length > 0) {
+      content.push({ type: "thinking", thinking });
+      continue;
+    }
+    if (typeof block === "object" && block !== null) {
+      const tool = block;
+      if (tool.type === "tool_use" && typeof tool.name === "string" && typeof tool.id === "string") {
+        content.push({
+          type: "toolCall",
+          id: tool.id,
+          name: tool.name,
+          arguments: nestedRecord(tool, "input") ?? {}
+        });
+      }
+    }
+  }
+  if (content.length === 0) content.push({ type: "text", text: "" });
+  return {
+    role: "assistant",
+    content,
+    api: "claude-agent-sdk",
+    provider: "anthropic",
+    model: "",
+    usage: normalizeUsage(null),
+    stopReason: "stop",
+    timestamp: Date.now()
+  };
+}
+function extractAssistantText(message) {
+  if (message.type !== "assistant") return "";
+  const record = message;
+  const assistant = contentFromSdkMessage(record.message);
+  return assistant.content.map((block) => block.type === "text" ? block.text : "").filter(Boolean).join("");
+}
+function extractStreamDelta(message) {
+  if (message.type !== "stream_event") return "";
+  const event = message.event;
+  if (typeof event !== "object" || event === null) return "";
+  const record = event;
+  const delta = nestedRecord(record, "delta");
+  if (delta && typeof delta.text === "string") return delta.text;
+  if (delta && typeof delta.thinking === "string") return "";
+  const contentBlock = nestedRecord(record, "content_block");
+  if (contentBlock && contentBlock.type === "text" && typeof contentBlock.text === "string") return contentBlock.text;
+  return "";
+}
+function resultText(message) {
+  if (message?.subtype !== "success") return "";
+  return typeof message.result === "string" ? message.result : "";
+}
+function resultError(message) {
+  if (!message || message.subtype === "success") return "";
+  return Array.isArray(message.errors) ? message.errors.join("; ") : "Claude Agent SDK run failed";
+}
+function stopReasonFor(result, aborted) {
+  if (aborted) return "aborted";
+  if (!result) return "stop";
+  if (result.subtype !== "success") return "error";
+  if (result.stop_reason === "max_tokens") return "length";
+  return "stop";
+}
+function buildAssistantMessage(input) {
+  const usage = normalizeUsage(input.result?.usage, input.result?.total_cost_usd ?? 0);
+  const message = {
+    role: "assistant",
+    content: [{ type: "text", text: input.text }],
+    api: "claude-agent-sdk",
+    provider: "anthropic",
+    model: input.model,
+    usage,
+    stopReason: stopReasonFor(input.result, input.aborted),
+    timestamp: Date.now()
+  };
+  if (input.responseModel !== void 0) message.responseModel = input.responseModel;
+  if (input.responseId !== void 0) message.responseId = input.responseId;
+  if (input.errorMessage !== void 0 && input.errorMessage.length > 0) message.errorMessage = input.errorMessage;
+  return message;
+}
+function emitTextDelta(emit, state, delta) {
+  if (delta.length === 0) return;
+  state.text += delta;
+  const message = buildAssistantMessage({ model: state.model, text: state.text, result: null, aborted: false });
+  if (!state.started) {
+    state.started = true;
+    emit({ type: "message_start", message });
+  }
+  emit({
+    type: "message_update",
+    message,
+    assistantMessageEvent: {
+      type: "text_delta",
+      contentIndex: 0,
+      delta,
+      partial: message
+    }
+  });
+}
+function createClaudeWorkerBudgetGate(budget, onBoundary, onHardCap, deliveryTools = []) {
+  let attempts = 0;
+  let admitted = 0;
+  let locked = false;
+  const phaseDecision = (canonicalToolName) => {
+    const reserveAdmits = isReserveAdmittedTool(canonicalToolName, deliveryTools);
+    if (locked || admitted >= budget.toolCalls) {
+      if (deliveryTools.length > 0 && !locked) {
+        if (reserveAdmits) return { kind: "allow" };
+        return {
+          kind: "deny",
+          reason: `worker discovery budget reached (${budget.toolCalls}); only read and ${deliveryTools.join("/")} are admitted for the rest of this run`
+        };
+      }
+      return {
+        kind: "deny",
+        reason: budget.synthesis ? `worker agent budget reached (${budget.toolCalls}); tool calls are disabled for final synthesis` : `worker agent budget reached (${budget.toolCalls}); synthesis is disabled`
+      };
+    }
+    const reserveStart = budget.toolCalls - budget.readReserve;
+    if (budget.readReserve > 0 && admitted >= reserveStart && !reserveAdmits) {
+      const admittedNames = deliveryTools.length > 0 ? `read and ${deliveryTools.join("/")} are` : "only read is";
+      return {
+        kind: "deny",
+        reason: `worker read reserve: ${budget.toolCalls - admitted} admitted calls remain and ${admittedNames} allowed`
+      };
+    }
+    return { kind: "allow" };
+  };
+  return {
+    attempt(canonicalToolName) {
+      attempts += 1;
+      if (attempts > budget.hardCap) {
+        onHardCap();
+        return { kind: "deny", reason: `workerToolCallCap reached (${budget.hardCap}); abort run` };
+      }
+      return phaseDecision(canonicalToolName);
+    },
+    admit(canonicalToolName) {
+      const phase = phaseDecision(canonicalToolName);
+      if (phase.kind === "deny") return phase;
+      admitted += 1;
+      if (admitted >= budget.toolCalls && deliveryTools.length === 0) {
+        locked = true;
+        onBoundary();
+      }
+      return { kind: "allow" };
+    },
+    phaseReached: () => locked
+  };
+}
+function permissionResultForDecision(decision, toolUseID, input) {
+  if (decision.kind === "allow") {
+    const result2 = {
+      behavior: "allow",
+      decisionClassification: "user_temporary"
+    };
+    if (toolUseID !== void 0) result2.toolUseID = toolUseID;
+    return result2;
+  }
+  if (decision.permissionRequired && input.onPermission === "fail") {
+    input.onPermissionFailure();
+  }
+  const result = {
+    behavior: "deny",
+    message: decision.reason,
+    interrupt: decision.permissionRequired && input.onPermission === "fail",
+    decisionClassification: "user_reject"
+  };
+  if (toolUseID !== void 0) result.toolUseID = toolUseID;
+  return result;
+}
+function decideToolUse(input, toolName, toolInput) {
+  return emitClaudeToolPermissionDecision({
+    toolName,
+    input: coerceToolInput(toolInput),
+    safety: input.safety,
+    cwd: input.cwd,
+    ...input.autonomy !== void 0 ? { autonomy: input.autonomy } : {},
+    onPermission: input.onPermission,
+    emit: input.emit,
+    allowedTools: input.allowedTools,
+    ...input.budgetGate ? { budgetGate: input.budgetGate } : {}
+  });
+}
+function decideClaudeSdkToolUseOnce(handled, toolUseID, decide) {
+  const cached = toolUseID ? handled.get(toolUseID) : void 0;
+  if (cached) return cached;
+  const decision = decide();
+  if (toolUseID) handled.set(toolUseID, decision);
+  return decision;
+}
+function decideToolUseOnce(input, toolUseID, toolName, toolInput) {
+  return decideClaudeSdkToolUseOnce(
+    input.handledToolDecisions,
+    toolUseID,
+    () => decideToolUse(input, toolName, toolInput)
+  );
+}
+function buildCanUseTool(input) {
+  return async (toolName, toolInput, options) => {
+    const decision = decideToolUseOnce(input, options.toolUseID, toolName, toolInput);
+    return permissionResultForDecision(decision, options.toolUseID, input);
+  };
+}
+function buildPreToolUseHook(input) {
+  return async (hookInput, toolUseID) => {
+    if (hookInput.hook_event_name !== "PreToolUse") return { continue: true };
+    const id = hookInput.tool_use_id || toolUseID;
+    const decision = decideToolUseOnce(input, id, hookInput.tool_name, hookInput.tool_input);
+    if (decision.kind === "allow") {
+      return {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow",
+          permissionDecisionReason: decision.reason
+        }
+      };
+    }
+    if (decision.permissionRequired && input.onPermission === "fail") input.onPermissionFailure();
+    return {
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: decision.reason
+      }
+    };
+  };
+}
+function startClaudeSdkWorkerRun(input, emit) {
+  const abortController = new AbortController();
+  let queryHandle = null;
+  let aborted = false;
+  let permissionFailure = false;
+  let budgetFailure = false;
+  const abort = () => {
+    aborted = true;
+    abortController.abort();
+    void queryHandle?.interrupt().catch(() => {
+    });
+    queryHandle?.close();
+  };
+  if (input.signal) {
+    if (input.signal.aborted) abort();
+    else input.signal.addEventListener("abort", abort, { once: true });
+  }
+  const safety = createWorkerSafety({
+    cwd: process.cwd(),
+    ...input.writeRoots !== void 0 ? { writeRoots: input.writeRoots } : {},
+    ...input.protectedArtifactState !== void 0 ? { protectedArtifactState: { artifacts: [...input.protectedArtifactState.artifacts] } } : {}
+  });
+  const onPermission = input.onPermission === "fail" ? "fail" : "deny";
+  const allowedToolSet = new Set(input.allowedTools);
+  const budgetGate = input.budget ? createClaudeWorkerBudgetGate(
+    input.budget,
+    () => {
+    },
+    () => {
+      budgetFailure = true;
+      emit({ type: "clio_run_outcome", payload: { outcomeCode: "worker_tool_call_cap_exhausted" } });
+      abort();
+    },
+    resolveDeliveryTools(allowedToolSet, input.product)
+  ) : void 0;
+  const permissionGate = {
+    safety,
+    cwd: process.cwd(),
+    ...input.autonomy !== void 0 ? { autonomy: input.autonomy } : {},
+    onPermission,
+    emit,
+    handledToolDecisions: /* @__PURE__ */ new Map(),
+    onPermissionFailure() {
+      permissionFailure = true;
+      abort();
+    },
+    allowedTools: allowedToolSet,
+    ...budgetGate ? { budgetGate } : {}
+  };
+  const canUseTool = buildCanUseTool(permissionGate);
+  const preToolUseHook = buildPreToolUseHook(permissionGate);
+  const postToolBatchHook = async (hookInput) => {
+    if (hookInput.hook_event_name !== "PostToolBatch" || !budgetGate?.phaseReached()) return { continue: true };
+    if (input.budget?.synthesis === false) {
+      budgetFailure = true;
+      emit({ type: "clio_run_outcome", payload: { outcomeCode: "worker_tool_call_cap_exhausted" } });
+      return { continue: false, stopReason: `worker agent budget reached (${input.budget.toolCalls})` };
+    }
+    return {
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "PostToolBatch",
+        additionalContext: "The admitted tool-call phase is complete. Tools are now disabled. Return the final answer in plain text from evidence already gathered."
+      }
+    };
+  };
+  const options = {
+    abortController,
+    cwd: process.cwd(),
+    model: input.wireModelId,
+    systemPrompt: systemPromptForInput(input),
+    tools: claudeSdkToolsForAutonomy(input.autonomy),
+    permissionMode: claudeSdkPermissionModeForAutonomy(input.autonomy),
+    canUseTool,
+    hooks: {
+      PreToolUse: [{ hooks: [preToolUseHook] }],
+      ...budgetGate ? { PostToolBatch: [{ hooks: [postToolBatchHook] }] } : {}
+    },
+    includePartialMessages: true,
+    persistSession: false,
+    settingSources: [],
+    env: { ...process.env, CLAUDE_AGENT_SDK_CLIENT_APP: `@iowarp/clio-coder/${readClioVersion()}` }
+  };
+  const disallowedTools = claudeToolsOutsideProfile(allowedToolSet);
+  if (disallowedTools.length > 0) options.disallowedTools = disallowedTools;
+  const thinking = thinkingForInput(input);
+  if (thinking !== void 0) options.thinking = thinking;
+  const effort = input.runtimeResolution?.request.reasoningEffort ?? effortForThinking(input.runtimeResolution?.effectiveThinkingLevel ?? input.thinkingLevel);
+  if (effort !== void 0) options.effort = effort;
+  if (isClaudeCodeSessionId(input.sessionId)) options.sessionId = input.sessionId.trim();
+  const promise = (async () => {
+    const messages = [];
+    const streamState = { started: false, text: "", model: input.wireModelId };
+    let result = null;
+    let responseModel;
+    let responseId;
+    emit({ type: "agent_start" });
+    try {
+      queryHandle = query({ prompt: buildClaudeSdkPrompt(input), options });
+      for await (const sdkMessage of queryHandle) {
+        if (sdkMessage.type === "system" && sdkMessage.subtype === "init") {
+          const init = sdkMessage;
+          if (typeof init.model === "string" && init.model.length > 0) streamState.model = init.model;
+          if (typeof init.uuid === "string") responseId = init.uuid;
+          continue;
+        }
+        if (sdkMessage.type === "stream_event") {
+          emitTextDelta(emit, streamState, extractStreamDelta(sdkMessage));
+          continue;
+        }
+        if (sdkMessage.type === "assistant") {
+          const text = extractAssistantText(sdkMessage);
+          if (text.length > 0 && text.length >= streamState.text.length) {
+            streamState.text = text;
+          }
+          const assistant = sdkMessage;
+          if (typeof assistant.message?.model === "string") responseModel = assistant.message.model;
+          if (typeof assistant.request_id === "string") responseId = assistant.request_id;
+          else if (typeof assistant.uuid === "string") responseId = assistant.uuid;
+          continue;
+        }
+        if (sdkMessage.type === "result") {
+          result = sdkMessage;
+        }
+      }
+      const error = resultError(result);
+      const finalText = streamState.text || resultText(result) || error;
+      const finalMessage = buildAssistantMessage({
+        model: streamState.model,
+        responseModel,
+        responseId,
+        text: finalText,
+        result,
+        aborted,
+        errorMessage: error
+      });
+      if (!streamState.started) emit({ type: "message_start", message: finalMessage });
+      emit({ type: "message_end", message: finalMessage });
+      messages.push(finalMessage);
+      emit({ type: "agent_end", messages });
+      if (permissionFailure) return { messages, exitCode: WORKER_EXIT_PERMISSION_REQUIRED };
+      if (budgetFailure) return { messages, exitCode: 1 };
+      return { messages, exitCode: finalMessage.stopReason === "error" ? 1 : 0 };
+    } catch (error) {
+      const messageText = error instanceof Error ? error.message : String(error);
+      const finalMessage = buildAssistantMessage({
+        model: streamState.model,
+        text: messageText,
+        result,
+        aborted,
+        errorMessage: messageText
+      });
+      emit({ type: "message_end", message: finalMessage });
+      messages.push(finalMessage);
+      emit({ type: "agent_end", messages });
+      if (permissionFailure) return { messages, exitCode: WORKER_EXIT_PERMISSION_REQUIRED };
+      if (budgetFailure) return { messages, exitCode: 1 };
+      if (!aborted) process.stderr.write(`[worker:claude-sdk] ${messageText}
+`);
+      return { messages, exitCode: 1 };
+    } finally {
+      queryHandle?.close();
+    }
+  })();
+  return {
+    promise,
+    abort,
+    async steer(text) {
+      const trimmed = text.trim();
+      const activeQuery = queryHandle;
+      if (trimmed.length === 0 || activeQuery === null) return false;
+      try {
+        await activeQuery.streamInput(oneSdkUserMessage(sdkUserTextMessage(trimmed, true)));
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
+// src/engine/worker-runtime.ts
+function isAssistantMessage(message) {
+  if (typeof message !== "object" || message === null) return false;
+  return "role" in message && message.role === "assistant";
+}
+function getTerminalAgentError(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!isAssistantMessage(message)) continue;
+    if (message.stopReason !== "error") return null;
+    return typeof message.errorMessage === "string" ? message.errorMessage : "";
+  }
+  return null;
+}
+function assistantMessageText(message) {
+  if (!isAssistantMessage(message) || !Array.isArray(message.content)) return null;
+  return message.content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("").trim();
+}
+function isTerminalAssistantMessage(message) {
+  if (!isAssistantMessage(message)) return false;
+  return message.stopReason !== "toolUse" && message.stopReason !== "error";
+}
+function terminalContractViolation(contract, message, cwd, observedReadRanges, observedRunEffects) {
+  if (!isAssistantMessage(message)) return null;
+  const text = assistantMessageText(message);
+  if (text === null || text.length === 0) return "missing final result";
+  const stopReason = message.stopReason;
+  if (shouldRequestStalledTurnContinuation({
+    hook: "turn_end",
+    text,
+    metadata: { turnToolCalls: 0, ...typeof stopReason === "string" ? { stopReason } : {} }
+  })) {
+    return "the response announced further work instead of stating the final result";
+  }
+  const validation = validateResultContract({
+    contract,
+    output: text,
+    cwd,
+    observedReadRanges,
+    observedRunEffects,
+    // Repair rounds judge shape and grounding only. Network posture belongs to
+    // the orchestrator's sealed validation, which runs again on the receipt.
+    networkAllowed: true,
+    filesystem: {
+      readFile(filePath) {
+        try {
+          return readFileSync(filePath, "utf8");
+        } catch {
+          return null;
+        }
+      },
+      pathExists(filePath) {
+        return existsSync(filePath);
+      }
+    }
+  });
+  return validation.conformance === "pass" ? null : validation.reason ?? "invalid result";
+}
+var NullKnowledgeBase = class {
+  lookup(_modelId) {
+    return null;
+  }
+  entries() {
+    return [];
+  }
+};
+var kbSingleton = null;
+function getKnowledgeBase() {
+  if (kbSingleton) return kbSingleton;
+  try {
+    const roots = resolveProviderKnowledgeBaseRoots(import.meta.url);
+    kbSingleton = roots.length > 0 ? new FileKnowledgeBase(roots) : new NullKnowledgeBase();
+  } catch {
+    kbSingleton = new NullKnowledgeBase();
+  }
+  return kbSingleton;
+}
+function clampThinkingLevelForModel(model, requested) {
+  const level = requested ?? "off";
+  return resolveModelRuntimeCapabilitiesForModel(model, level).thinking.effectiveLevel;
+}
+function promptMessage(fragment) {
+  return {
+    role: "user",
+    content: [{ type: "text", text: fragment.body }],
+    timestamp: Date.now()
+  };
+}
+function taskMessage(task) {
+  return {
+    role: "user",
+    content: [{ type: "text", text: task }],
+    timestamp: Date.now()
+  };
+}
+function promptMessagesForWorker(input) {
+  const messages = (input.dynamicPromptMessages ?? []).map(promptMessage);
+  messages.push(taskMessage(input.task));
+  return messages;
+}
+function workerProviderSupportsTools(input) {
+  const runtimeDecision = input.runtimeResolution?.capabilities.tools;
+  if (runtimeDecision !== void 0) return runtimeDecision === true;
+  if (typeof input.modelCapabilities?.tools === "boolean") return input.modelCapabilities.tools;
+  return input.runtime.defaultCapabilities.tools === true;
+}
+function assertResponseSchemaRuntime(input) {
+  if (input.responseSchema === void 0) return;
+  if (runtimeSpeaksResponseSchemaDialect(input.runtime) && input.modelCapabilities?.structuredOutputs === "json-schema") {
+    return;
+  }
+  throw new Error(
+    `responseSchema requires a native llamacpp runtime with resolved JSON-schema support; received '${input.runtime.id}'`
+  );
+}
+function resolveWorkerRuntimeBudget(input) {
+  return input.budget;
+}
+function startWorkerRun(input, emit) {
+  assertResponseSchemaRuntime(input);
+  if (input.resultContract !== void 0) parseResultContract(input.resultContract, "WorkerSpec.resultContract");
+  if (input.runtime.id === "claude-sdk") {
+    return startClaudeSdkWorkerRun(input, emit);
+  }
+  if (input.runtime.id === "claude-code") {
+    return startClaudeCodeWorkerRun(input, emit);
+  }
+  if (input.runtime.id === "antigravity-code") {
+    return startAntigravityWorkerRun(input, emit);
+  }
+  registerClioApiProviders();
+  const workerSettings = validateSettingsFile().settings;
+  setGlobalDefaultMaxOutputTokens(workerSettings.defaults.maxTokens);
+  configureGuardrails(workerSettings.guardrails);
+  const fauxModel = registerFauxFromEnv();
+  const agentSkillPolicy = input.allowedTools.includes(ToolNames.Context) && input.noSkills !== true ? agentSkillToolPolicy(input.agentSkills ?? []) : void 0;
+  const activeWorkerTools = workerProviderSupportsTools(input) ? input.allowedTools : [];
+  const kb = getKnowledgeBase();
+  const kbHit = kb.lookup(input.wireModelId);
+  const synthesized = input.runtime.synthesizeModel(input.target, input.wireModelId, kbHit);
+  const model = applyModelCapabilityPatch(
+    input.target.runtime === "faux" && fauxModel ? fauxModel : synthesized,
+    input.modelCapabilities
+  );
+  const safety = createWorkerSafety({
+    cwd: process.cwd(),
+    ...input.writeRoots !== void 0 ? { writeRoots: input.writeRoots } : {},
+    ...input.protectedArtifactState !== void 0 ? { protectedArtifactState: { artifacts: [...input.protectedArtifactState.artifacts] } } : {}
+  });
+  let synthesisToolLock = false;
+  let workerBoundFailure = null;
+  let workerBoundAborted = false;
+  let abortWorkerForBound = null;
+  let stopAfterToolResultCallId = null;
+  const workerBudget = resolveWorkerRuntimeBudget(input);
+  const readReserve = input.allowedTools.includes(ToolNames.Read) ? workerBudget.readReserve : 0;
+  const deliveryTools = resolveDeliveryTools(input.allowedTools, input.product);
+  const middlewareToolChoice = createMiddlewareToolChoiceControl();
+  let workerModelRound = 0;
+  const registry = createWorkerToolRegistry(
+    input.middlewareSnapshot,
+    safety,
+    {
+      ...input.noSkills !== void 0 ? { noSkills: input.noSkills } : {},
+      ...input.skillPaths !== void 0 ? { skillPaths: [...input.skillPaths] } : {},
+      ...input.trustProjectCompatRoots !== void 0 ? { trustProjectCompatRoots: input.trustProjectCompatRoots } : {}
+    },
+    // Workers run unattended, so the loop guard carries the hard tool-call
+    // cap in addition to repetition blocking, plus the synthesis lockout:
+    // after the loop-block budget the worker is told to report from what it
+    // gathered instead of burning the lifetime cap on a retry spiral, and
+    // the bounded backstop reason is watched in telemetry.onFinish below to
+    // abort a worker that keeps calling tools anyway.
+    // The protected-artifacts guard starts from the parent-session snapshot
+    // and has no persistence sink. It can still absorb worker-local
+    // protect_path effects from snapshot rules for the rest of this run.
+    [
+      createLoopGuardRegistration({
+        safety,
+        toolCallCap: workerBudget.hardCap,
+        toolCallSoftLimit: workerBudget.toolCalls,
+        // A worker's blocks all land in one run-long bucket, so the bound on
+        // them is a statement about this run's length, not about a turn.
+        turnBlockBudget: workerLoopBlockBudget(workerBudget.toolCalls),
+        toolCallSoftReadReserve: readReserve,
+        ...deliveryTools.length > 0 ? { deliveryTools } : {},
+        turnSynthesisLockout: workerBudget.synthesis,
+        // Once locked, the next model round is forced text-only at the
+        // request level (tool_choice none in onPayload below): the lockout
+        // directive alone relies on model compliance, and measured local
+        // models kept calling tools until the backstop aborted the run.
+        onSynthesisLockout: () => {
+          if (workerBudget.synthesis) {
+            synthesisToolLock = true;
+          }
+        },
+        ...!workerBudget.synthesis ? {
+          onSoftLimitFinalCallAdmitted: (toolCallId) => {
+            if (workerBoundFailure === null) {
+              workerBoundFailure = `worker agent budget reached (${workerBudget.toolCalls}); synthesis is disabled`;
+            }
+            stopAfterToolResultCallId = toolCallId ?? "";
+          }
+        } : {},
+        // Forcing the next round to `read` is only correct when reading is
+        // the whole reserve. An agent with delivery tools must be able to
+        // write in its own reserve window, so it gets the steering directive
+        // without the request-level lock.
+        ...readReserve > 0 && deliveryTools.length === 0 ? {
+          onSoftReadReserve: () => {
+            middlewareToolChoice.apply([{ kind: "require_tool", toolName: ToolNames.Read }]);
+          }
+        } : {}
+      }),
+      createProtectedArtifactsRegistration({
+        ...input.protectedArtifactState !== void 0 ? { initialState: { artifacts: [...input.protectedArtifactState.artifacts] } } : {}
+      })
+    ],
+    input.autonomy,
+    (effects) => middlewareToolChoice.apply(effects),
+    input.agentLedger
+  );
+  const contractCwd = input.cwd ?? process.cwd();
+  let resultContractRepairsQueued = 0;
+  const pendingReadCitations = /* @__PURE__ */ new Map();
+  const observedReadRanges = /* @__PURE__ */ new Map();
+  const runEffects = createRunEffectsRecorder(contractCwd);
+  const recordObservedRead = (request, result) => {
+    const observation = result?.details?.observation;
+    if (!observation) return;
+    const shown = observation.shownCount;
+    const total = observation.totalCount;
+    if (typeof shown !== "number" || !Number.isFinite(shown) || shown <= 0) return;
+    let start;
+    if (request.tail) {
+      if (typeof total !== "number" || !Number.isFinite(total)) return;
+      start = Math.max(1, Math.floor(total) - shown + 1);
+    } else {
+      start = request.offset ?? 1;
+    }
+    const key = path.resolve(contractCwd, request.path);
+    const spans = observedReadRanges.get(key) ?? [];
+    spans.push([start, start + shown - 1]);
+    observedReadRanges.set(key, spans);
+  };
+  const observedReadAnchors = () => [...observedReadRanges.entries()].flatMap(
+    ([key, spans]) => spans.map(([start, end]) => `${path.relative(contractCwd, key) || key}:${start}-${end}`)
+  );
+  const telemetry = {
+    onStart(event) {
+      emit({ type: "clio_tool_start", payload: event });
+    },
+    onFinish(event) {
+      emit({ type: "clio_tool_finish", payload: event });
+      if (event.outcome !== "blocked" || typeof event.reason !== "string") return;
+      if (isWorkerToolCallCapSynthesisReason(event.reason)) {
+        emit({ type: "clio_run_outcome", payload: { outcomeCode: "worker_tool_call_cap_exhausted" } });
+        if (workerBoundFailure === null) {
+          workerBoundFailure = event.reason;
+          process.stderr.write(`[worker] ${event.reason}
+`);
+        }
+        return;
+      }
+      if (isWorkerToolCallCapExceededReason(event.reason) || isLoopGuardSynthesisBackstopReason(event.reason)) {
+        emit({
+          type: "clio_run_outcome",
+          payload: {
+            outcomeCode: isLoopGuardSynthesisBackstopReason(event.reason) ? "loop_guard_tools_disabled_exhausted" : "worker_tool_call_cap_exhausted"
+          }
+        });
+        if (workerBoundAborted) return;
+        workerBoundAborted = true;
+        if (workerBoundFailure === null) workerBoundFailure = event.reason;
+        process.stderr.write(`[worker] ${event.reason}
+`);
+        abortWorkerForBound?.();
+      }
+    }
+  };
+  const tools = resolveAgentTools({
+    registry,
+    telemetry,
+    allowedTools: activeWorkerTools,
+    agentId: input.agentId,
+    task: input.task,
+    includeInteractiveTools: false,
+    invokeOptions: () => ({
+      correlationId: `worker-model-round-${workerModelRound}`,
+      ...agentSkillPolicy ? { pendingSkillPolicy: agentSkillPolicy } : {}
+    })
+  });
+  if (tools.length === 0 && activeWorkerTools.length > 0) {
+    process.stderr.write(`[worker] warning: no tools resolved for allowed=[${activeWorkerTools.join(",")}]
+`);
+  }
+  const effectiveThinkingLevel = clampThinkingLevelForModel(
+    model,
+    input.runtimeResolution?.effectiveThinkingLevel ?? input.thinkingLevel
+  );
+  const options = {
+    initialState: {
+      systemPrompt: input.systemPrompt,
+      model,
+      thinkingLevel: effectiveThinkingLevel,
+      tools,
+      messages: []
+    },
+    onPayload: async (payload, currentModel) => {
+      const middlewareChoice = middlewareToolChoice.current();
+      return patchWorkerRequestPayload(payload, currentModel, {
+        runtimeId: input.runtime.id,
+        thinkingLevel: effectiveThinkingLevel,
+        ...input.responseSchema !== void 0 ? { responseSchema: input.responseSchema } : {},
+        toolChoiceNone: synthesisToolLock || middlewareChoice.kind === "none",
+        ...middlewareChoice.kind === "required" ? { toolChoiceName: middlewareChoice.toolName } : {}
+      });
+    },
+    getApiKey: async () => input.apiKey
+  };
+  if (input.sessionId) options.sessionId = input.sessionId;
+  const { agent } = createEngineAgent(options);
+  abortWorkerForBound = () => agent.abort();
+  const unsubscribe = agent.subscribe(async (event) => {
+    if (event.type === "turn_start") workerModelRound += 1;
+    if (event.type === "tool_execution_start") middlewareToolChoice.toolStarted(event.toolName);
+    if (event.type === "tool_execution_start") {
+      runEffects.start(event.toolCallId, event.toolName, event.args);
+    }
+    if (event.type === "tool_execution_end") {
+      runEffects.finish(event.toolCallId, event.isError === true);
+    }
+    if (event.type === "tool_execution_start" && event.toolName === ToolNames.Read) {
+      const args = event.args;
+      const readPath = typeof args.path === "string" ? args.path.trim() : "";
+      const offset = typeof args.offset === "number" && Number.isFinite(args.offset) && args.offset > 0 ? Math.floor(args.offset) : null;
+      if (readPath.length > 0) {
+        pendingReadCitations.set(event.toolCallId, { path: readPath, offset, tail: args.tail !== void 0 });
+      }
+    }
+    if (event.type === "tool_execution_end" && event.toolName === ToolNames.Read) {
+      const request = pendingReadCitations.get(event.toolCallId);
+      pendingReadCitations.delete(event.toolCallId);
+      if (request !== void 0 && event.isError !== true) recordObservedRead(request, event.result);
+    }
+    if (synthesisToolLock && event.type === "message_end") {
+      sanitizeLockedSynthesisMessage(event.message);
+    }
+    const contract = input.resultContract;
+    if (contract && event.type === "message_end" && isTerminalAssistantMessage(event.message)) {
+      const violation = terminalContractViolation(
+        contract,
+        event.message,
+        contractCwd,
+        observedReadRanges,
+        runEffects.snapshot()
+      );
+      if (violation !== null) {
+        if (resultContractRepairsQueued < RESULT_CONTRACT_REPAIR_LIMIT) {
+          resultContractRepairsQueued += 1;
+          synthesisToolLock = true;
+          agent.followUp(
+            taskMessage(
+              resultContractRepairMessage({
+                contract,
+                reason: violation,
+                attempt: resultContractRepairsQueued,
+                anchors: observedReadAnchors()
+              })
+            )
+          );
+        } else if (workerBoundFailure === null) {
+          workerBoundFailure = `result contract failed after ${RESULT_CONTRACT_REPAIR_LIMIT} bounded repair rounds: ${violation}`;
+          emit({ type: "clio_run_outcome", payload: { outcomeCode: "result_contract_exhausted" } });
+          process.stderr.write(`[worker] ${workerBoundFailure}
+`);
+        }
+      }
+    }
+    emit(event);
+    if (stopAfterToolResultCallId !== null && event.type === "message_end" && event.message.role === "toolResult" && (stopAfterToolResultCallId.length === 0 || event.message.toolCallId === stopAfterToolResultCallId)) {
+      stopAfterToolResultCallId = null;
+      workerBoundAborted = true;
+      abortWorkerForBound?.();
+    }
+  });
+  const onPermission = input.onPermission ?? "deny";
+  const escalationConfig = onPermission === "escalate" ? {
+    timeoutMs: input.escalation?.timeoutMs ?? DEFAULT_ESCALATION_TIMEOUT_MS,
+    fallback: input.escalation?.fallback ?? DEFAULT_ESCALATION_FALLBACK
+  } : null;
+  let permissionFailure = false;
+  const denyReason = (tool, actionClass) => `permission denied by policy: dispatched workers run non-interactively (workers.onPermission=deny); ${tool} requires ${actionClass} confirmation`;
+  const failReason = (tool, actionClass) => `permission required for ${tool} (${actionClass}); workers.onPermission=fail ends this run`;
+  let activeEscalation = null;
+  const clearActiveEscalation = () => {
+    if (activeEscalation) {
+      clearTimeout(activeEscalation.timer);
+      activeEscalation = null;
+    }
+  };
+  const resolveEscalation = (requestId, decision, source) => {
+    const active = activeEscalation;
+    if (!active || active.requestId !== requestId) return false;
+    clearActiveEscalation();
+    if (decision === "approve") {
+      emit({
+        type: "clio_permission_resolved",
+        payload: {
+          tool: active.tool,
+          actionClass: active.actionClass,
+          mode: "escalate",
+          source,
+          requestId,
+          decision: "approved",
+          reason: `operator approved permission escalation for ${active.tool} (${active.actionClass})`
+        }
+      });
+      void registry.resumeParkedCalls({
+        actionClass: active.actionClass,
+        requestId,
+        requestedBy: `escalation:${source}`
+      });
+      return true;
+    }
+    const effectiveFail = source === "timeout" && escalationConfig?.fallback === "fail";
+    const mode = effectiveFail ? "fail" : "deny";
+    const denialContext = source === "timeout" ? "escalation timed out with no operator decision" : "operator denied";
+    const reason = effectiveFail ? `permission required for ${active.tool} (${active.actionClass}); ${denialContext} and workers fallback=fail ends this run` : `permission denied by ${source === "timeout" ? "escalation timeout fallback" : "operator"}: ${active.tool} requires ${active.actionClass} confirmation`;
+    emit({
+      type: "clio_permission_resolved",
+      payload: {
+        tool: active.tool,
+        actionClass: active.actionClass,
+        mode,
+        source,
+        requestId,
+        decision: "denied",
+        reason
+      }
+    });
+    if (effectiveFail) {
+      permissionFailure = true;
+      registry.cancelParkedCalls(reason);
+      agent.abort();
+      return true;
+    }
+    if (source === "operator") registry.cancelParkedCall(requestId, reason);
+    else registry.cancelParkedCalls(reason);
+    return true;
+  };
+  const denyActiveEscalationOnAbort = (reason) => {
+    const active = activeEscalation;
+    if (!active) return;
+    emit({
+      type: "clio_permission_resolved",
+      payload: {
+        tool: active.tool,
+        actionClass: active.actionClass,
+        mode: "escalate",
+        source: "operator",
+        requestId: active.requestId,
+        decision: "denied",
+        reason
+      }
+    });
+    clearActiveEscalation();
+  };
+  const unsubscribePermission = registry.onPermissionRequired((call, decision, meta) => {
+    const actionClass = decision.classification.actionClass;
+    if (escalationConfig) {
+      if (activeEscalation !== null) return;
+      const requestId = meta.requestId;
+      const timer = setTimeout(() => resolveEscalation(requestId, "deny", "timeout"), escalationConfig.timeoutMs);
+      activeEscalation = { requestId, tool: call.tool, actionClass, timer };
+      const target = describeCallTarget(call.args).slice(0, 200);
+      emit({
+        type: "clio_permission_escalated",
+        payload: {
+          requestId,
+          tool: call.tool,
+          summary: `${call.tool} requires ${actionClass} confirmation`,
+          ...target.length > 0 ? { target } : {},
+          axis: meta.axis,
+          decision: {
+            actionClass,
+            reasons: decision.classification.reasons,
+            ...decision.policy?.reasonCode ? { reasonCode: decision.policy.reasonCode } : {},
+            ...decision.policy?.ruleId ? { ruleId: decision.policy.ruleId } : {},
+            ...decision.policy?.policySource ? { policySource: decision.policy.policySource } : {}
+          },
+          timeoutMs: escalationConfig.timeoutMs
+        }
+      });
+      return;
+    }
+    const reason = onPermission === "fail" ? failReason(call.tool, actionClass) : denyReason(call.tool, actionClass);
+    emit({
+      type: "clio_permission_resolved",
+      payload: {
+        tool: call.tool,
+        actionClass,
+        mode: onPermission,
+        source: "policy",
+        requestId: meta.requestId,
+        reason
+      }
+    });
+    if (onPermission === "fail") {
+      permissionFailure = true;
+      registry.cancelParkedCalls(reason);
+      agent.abort();
+      return;
+    }
+    registry.cancelParkedCalls(reason);
+  });
+  const promise = (async () => {
+    try {
+      await agent.prompt(promptMessagesForWorker(input));
+      await agent.waitForIdle();
+      unsubscribe();
+      if (workerBoundFailure !== null) {
+        return { messages: agent.state.messages, exitCode: 1 };
+      }
+      if (permissionFailure) {
+        return { messages: agent.state.messages, exitCode: WORKER_EXIT_PERMISSION_REQUIRED };
+      }
+      const messages = agent.state.messages;
+      const errorMessage = getTerminalAgentError(messages);
+      if (errorMessage !== null) {
+        if (errorMessage.length > 0) {
+          process.stderr.write(`[worker] agent ended with stopReason=error: ${errorMessage}
+`);
+        }
+        return { messages, exitCode: 1 };
+      }
+      return { messages, exitCode: 0 };
+    } catch (err) {
+      unsubscribe();
+      if (workerBoundFailure !== null) {
+        return { messages: agent.state.messages, exitCode: 1 };
+      }
+      if (permissionFailure) {
+        return { messages: agent.state.messages, exitCode: WORKER_EXIT_PERMISSION_REQUIRED };
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      emit({ type: "agent_end", messages: agent.state.messages });
+      process.stderr.write(`[worker] agent error: ${msg}
+`);
+      return { messages: agent.state.messages, exitCode: 1 };
+    } finally {
+      clearActiveEscalation();
+      unsubscribePermission();
+    }
+  })();
+  return {
+    promise,
+    abort: () => {
+      if (escalationConfig) {
+        const reason = "run aborted while a permission escalation was pending";
+        denyActiveEscalationOnAbort(reason);
+        registry.cancelParkedCalls(reason);
+      }
+      agent.abort();
+    },
+    steer: (text) => {
+      const trimmed = text.trim();
+      if (trimmed.length === 0) return false;
+      agent.steer(taskMessage(trimmed));
+      return true;
+    },
+    resolvePermission: (requestId, decision) => resolveEscalation(requestId, decision, "operator")
+  };
+}
+
+// src/worker/control-lane.ts
+function emitControlFrame(frame) {
+  try {
+    process.stderr.write(encodeControlFrame(frame));
+  } catch {
+  }
+}
+
+// src/worker/event-projection.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function projectWorkerEventForStdout(event) {
+  if (!isRecord(event) || event.type !== "message_update") return event;
+  const { message: _message, assistantMessageEvent, ...rest } = event;
+  if (!isRecord(assistantMessageEvent)) return rest;
+  const { partial: _partial, ...slimAssistantMessageEvent } = assistantMessageEvent;
+  return { ...rest, assistantMessageEvent: slimAssistantMessageEvent };
+}
+
+// src/worker/heartbeat.ts
+function startWorkerHeartbeat(intervalMs = 1e3) {
+  emitControlFrame({ kind: "heartbeat", at: Date.now() });
+  const id = setInterval(() => emitControlFrame({ kind: "heartbeat", at: Date.now() }), intervalMs);
+  id.unref?.();
+  return () => clearInterval(id);
+}
+
+// src/worker/ledger-mirror.ts
+var WORKER_AGENT_LEDGER_POST_CAP = 20;
+function createWorkerAgentLedgerMirror() {
+  const bySequence = /* @__PURE__ */ new Map();
+  let watermark = 0;
+  return {
+    apply(entries) {
+      for (const entry of entries) {
+        bySequence.set(entry.sequence, entry);
+        if (entry.sequence > watermark) watermark = entry.sequence;
+      }
+    },
+    entries() {
+      return [...bySequence.values()].sort((left, right) => left.sequence - right.sequence);
+    },
+    watermark() {
+      return watermark;
+    }
+  };
+}
+function createWorkerAgentLedgerPort(deps) {
+  const mirror = deps.mirror ?? createWorkerAgentLedgerMirror();
+  const { ledger, emitControlFrame: emitControlFrame2 } = deps;
+  let posted = 0;
+  return {
+    post(body) {
+      if (ledger === void 0) return { ok: false, reason: "no-ledger" };
+      const parsed = parseAgentLedgerBody(body);
+      if (!parsed.ok) return { ok: false, reason: "invalid-body" };
+      if (posted >= WORKER_AGENT_LEDGER_POST_CAP) return { ok: false, reason: "per-run-cap" };
+      posted += 1;
+      emitControlFrame2({ kind: "ledger_post", body: parsed.body });
+      return { ok: true };
+    },
+    read() {
+      if (ledger === void 0) return null;
+      return { open: true, watermark: mirror.watermark(), entries: mirror.entries() };
+    },
+    acceptDelta(entries) {
+      mirror.apply(entries);
+    }
+  };
+}
+
+// src/worker/ndjson.ts
+function emitEvent(event) {
+  try {
+    process.stdout.write(`${JSON.stringify(event)}
+`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[worker] failed to emit event: ${msg}
+`);
+  }
+}
+function drainStdout(timeoutMs = 2e3) {
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    try {
+      process.stdout.write("", finish);
+    } catch {
+      finish();
+    }
+  });
+}
+
+// src/worker/resource-facts.ts
+import { execFileSync } from "node:child_process";
+import { cpus, freemem, hostname, totalmem } from "node:os";
+var GPU_PROBE_TIMEOUT_MS = 1e3;
+function probeNvidiaGpus() {
+  try {
+    const stdout = execFileSync("nvidia-smi", ["--query-gpu=memory.total", "--format=csv,noheader,nounits"], {
+      timeout: GPU_PROBE_TIMEOUT_MS,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const megabytes = stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => Number.parseInt(line, 10)).filter((value) => Number.isFinite(value) && value > 0);
+    if (megabytes.length === 0) return { gpuCount: UNKNOWN_RESOURCE, vramBytes: UNKNOWN_RESOURCE };
+    const totalBytes = megabytes.reduce((sum, value) => sum + value, 0) * 1024 * 1024;
+    return { gpuCount: knownResource(megabytes.length), vramBytes: knownResource(totalBytes) };
+  } catch {
+    return { gpuCount: UNKNOWN_RESOURCE, vramBytes: UNKNOWN_RESOURCE };
+  }
+}
+function observeCpuCount() {
+  const count = cpus().length;
+  return count > 0 ? knownResource(count) : UNKNOWN_RESOURCE;
+}
+function observeMemory(read) {
+  const bytes = read();
+  return Number.isFinite(bytes) && bytes > 0 ? knownResource(bytes) : UNKNOWN_RESOURCE;
+}
+function observeWorkerResourceFacts(labels = []) {
+  const gpu = probeNvidiaGpus();
+  return {
+    labels: [...labels].slice(0, WORKER_RESOURCE_LABEL_MAX),
+    cpuCount: observeCpuCount(),
+    totalMemoryBytes: observeMemory(totalmem),
+    freeMemoryBytes: observeMemory(freemem),
+    gpuCount: gpu.gpuCount,
+    vramBytes: gpu.vramBytes,
+    residentModels: UNKNOWN_RESOURCE
+  };
+}
+function observeHostIdentity() {
+  const name = hostname();
+  return name.length > 0 ? name : "unknown-host";
+}
+
+// src/worker/runtime-registry.ts
+async function resolveWorkerRuntime(runtimeId) {
+  const registry = getRuntimeRegistry();
+  registerBuiltinRuntimes(registry);
+  await loadPluginRuntimes(registry, readSettings());
+  return registry.get(runtimeId);
+}
+
+// src/worker/stdin-demux.ts
+function createOrderedSteerHandler(deliver, onAccepted, onRejected) {
+  let tail = Promise.resolve();
+  return (steer) => {
+    tail = tail.then(async () => {
+      let rejection = null;
+      try {
+        if (await deliver(steer.text)) onAccepted(steer);
+        else rejection = "runtime does not accept live guidance";
+      } catch (error) {
+        rejection = error instanceof Error ? error.message : String(error);
+      }
+      if (rejection !== null) {
+        try {
+          onRejected(rejection);
+        } catch {
+        }
+      }
+    });
+    return tail;
+  };
+}
+function createWorkerStdinDemux() {
+  let buffer = "";
+  let specResolve = null;
+  let specReject = null;
+  let specValue = null;
+  let specError = null;
+  let specReceived = false;
+  let closed = false;
+  let steerHandler = null;
+  const pendingSteers = [];
+  let permissionHandler = null;
+  const pendingPermissionDecisions = [];
+  let ledgerDeltaHandler = null;
+  const pendingLedgerDeltas = [];
+  let droppedLines = 0;
+  let channelCloseHandler = null;
+  let channelCloseDelivered = false;
+  let channelClosedAfterSpec = false;
+  function deliverChannelClose() {
+    if (channelCloseDelivered || channelCloseHandler === null) return;
+    channelCloseDelivered = true;
+    channelCloseHandler();
+  }
+  function resolveSpec(spec) {
+    specValue = spec;
+    specResolve?.(spec);
+  }
+  function rejectSpec(err) {
+    specError = err;
+    specReject?.(err);
+  }
+  function deliverSteer(steer) {
+    if (steerHandler) {
+      steerHandler(steer);
+      return;
+    }
+    pendingSteers.push(steer);
+  }
+  function deliverPermissionDecision(requestId, decision) {
+    if (permissionHandler) {
+      permissionHandler({ requestId, decision });
+      return;
+    }
+    pendingPermissionDecisions.push({ requestId, decision });
+  }
+  function deliverLedgerDelta(entries) {
+    if (ledgerDeltaHandler) {
+      ledgerDeltaHandler(entries);
+      return;
+    }
+    pendingLedgerDeltas.push(entries);
+  }
+  function processPostSpecLine(line) {
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      droppedLines += 1;
+      return;
+    }
+    if (typeof value === "object" && value !== null && value.type === "steer" && typeof value.text === "string" && value.text.trim().length > 0 && Number.isSafeInteger(value.sequence) && Number(value.sequence) > 0) {
+      deliverSteer({
+        text: value.text,
+        sequence: value.sequence
+      });
+      return;
+    }
+    if (typeof value === "object" && value !== null && value.type === "permission_decision" && typeof value.requestId === "string" && value.requestId.length > 0 && (value.decision === "approve" || value.decision === "deny")) {
+      deliverPermissionDecision(
+        value.requestId,
+        value.decision
+      );
+      return;
+    }
+    if (typeof value === "object" && value !== null && value.type === "ledger_delta") {
+      const raw = value.entries;
+      if (!Array.isArray(raw)) {
+        droppedLines += 1;
+        return;
+      }
+      const entries = [];
+      for (const candidate of raw) {
+        const entry = parseAgentLedgerEntry(candidate);
+        if (entry !== null) entries.push(entry);
+      }
+      if (entries.length === 0) {
+        droppedLines += 1;
+        return;
+      }
+      deliverLedgerDelta(entries);
+      return;
+    }
+    droppedLines += 1;
+  }
+  function processLine(line) {
+    if (line.length === 0) return;
+    if (!withinFrameBudget(line, WORKER_STDIN_FRAME_MAX_BYTES)) {
+      if (!specReceived) {
+        specReceived = true;
+        rejectSpec(new Error(`WorkerSpec line exceeds the ${WORKER_STDIN_FRAME_MAX_BYTES} byte stdin frame limit`));
+        return;
+      }
+      droppedLines += 1;
+      return;
+    }
+    if (!specReceived) {
+      specReceived = true;
+      try {
+        resolveSpec(parseWorkerSpec(JSON.parse(line)));
+      } catch (err) {
+        rejectSpec(err instanceof Error ? err : new Error(String(err)));
+      }
+      return;
+    }
+    processPostSpecLine(line);
+  }
+  let discardingOversizedLine = false;
+  return {
+    feed(chunk) {
+      if (closed) return;
+      buffer += chunk;
+      let idx = buffer.indexOf("\n");
+      while (idx >= 0) {
+        const line = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 1);
+        if (discardingOversizedLine) {
+          discardingOversizedLine = false;
+          droppedLines += 1;
+        } else {
+          processLine(line);
+        }
+        idx = buffer.indexOf("\n");
+      }
+      if (!withinFrameBudget(buffer, WORKER_STDIN_FRAME_MAX_BYTES)) {
+        if (!specReceived) {
+          specReceived = true;
+          rejectSpec(new Error(`WorkerSpec line exceeds the ${WORKER_STDIN_FRAME_MAX_BYTES} byte stdin frame limit`));
+        }
+        buffer = "";
+        discardingOversizedLine = true;
+      }
+    },
+    eof() {
+      if (closed) return;
+      closed = true;
+      if (buffer.length > 0) {
+        processLine(buffer);
+        buffer = "";
+      }
+      if (!specReceived) {
+        rejectSpec(new Error("worker stdin closed before spec received"));
+        return;
+      }
+      channelClosedAfterSpec = true;
+      deliverChannelClose();
+    },
+    readSpec() {
+      if (specValue) return Promise.resolve(specValue);
+      if (specError) return Promise.reject(specError);
+      if (closed && !specReceived) return Promise.reject(new Error("worker stdin closed before spec received"));
+      return new Promise((resolve, reject) => {
+        specResolve = resolve;
+        specReject = reject;
+      });
+    },
+    onSteer(handler) {
+      steerHandler = handler;
+      while (pendingSteers.length > 0) {
+        const steer = pendingSteers.shift();
+        if (steer !== void 0) handler(steer);
+      }
+    },
+    onPermissionDecision(handler) {
+      permissionHandler = handler;
+      while (pendingPermissionDecisions.length > 0) {
+        const entry = pendingPermissionDecisions.shift();
+        if (entry !== void 0) handler(entry);
+      }
+    },
+    onLedgerDelta(handler) {
+      ledgerDeltaHandler = handler;
+      while (pendingLedgerDeltas.length > 0) {
+        const batch = pendingLedgerDeltas.shift();
+        if (batch !== void 0) handler(batch);
+      }
+    },
+    droppedLineCount() {
+      return droppedLines;
+    },
+    onChannelClose(handler) {
+      channelCloseHandler = handler;
+      if (channelClosedAfterSpec) deliverChannelClose();
+    }
+  };
+}
+
+// src/worker/entry.ts
+var CHANNEL_CLOSE_EXIT_GRACE_MS = 5e3;
+function configuredNodeLabels() {
+  return (process.env.CLIO_CODER_WORKER_LABELS ?? "").split(",").map((label) => label.trim()).filter((label) => label.length > 0);
+}
+function announcedProcessGroupId() {
+  const declared = Number.parseInt(process.env.CLIO_CODER_WORKER_PGID ?? "", 10);
+  if (Number.isSafeInteger(declared) && declared > 0) return declared;
+  return process.platform === "win32" ? null : process.pid;
+}
+function announceWorker(spec, input) {
+  emitControlFrame({
+    kind: "announce",
+    attestation: {
+      protocolVersion: WORKER_PROTOCOL_VERSION,
+      specVersion: spec.specVersion,
+      pid: process.pid,
+      processGroupId: announcedProcessGroupId(),
+      host: observeHostIdentity(),
+      settingsFingerprint: spec.settingsFingerprint,
+      specDigest: workerSpecDigest(spec),
+      runtimeId: spec.runtimeId,
+      targetId: spec.target.id,
+      endpointIdentityHash: endpointIdentityHash(spec.target.url),
+      wireModelId: spec.wireModelId,
+      toolSignature: attestedToolSignature({
+        allowedTools: spec.allowedTools,
+        toolsSupported: workerProviderSupportsTools(input),
+        ...spec.toolProfile !== void 0 ? { toolProfile: spec.toolProfile } : {},
+        agentId: spec.agentId,
+        task: spec.task
+      }),
+      resources: observeWorkerResourceFacts(configuredNodeLabels())
+    }
+  });
+}
+async function main() {
+  setResidencyNoticeSink((notice) => {
+    process.stderr.write(`[worker] residency ${notice.kind}: ${notice.message}
+`);
+    if (notice.kind === "will-not-fit") {
+      emitEvent({ type: "clio_run_outcome", payload: { outcomeCode: "vram_capacity_fit_failure" } });
+    }
+  });
+  const demux = createWorkerStdinDemux();
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => demux.feed(chunk));
+  process.stdin.on("end", () => demux.eof());
+  process.stdin.on("error", () => demux.eof());
+  process.stdin.resume();
+  const spec = await demux.readSpec();
+  setProtectedModelsProvider(() => spec.protectedModels ?? []);
+  const stopHeartbeat = startWorkerHeartbeat();
+  const runtime = await resolveWorkerRuntime(spec.runtimeId);
+  if (!runtime) {
+    process.stderr.write(`[worker] runtime '${spec.runtimeId}' not registered
+`);
+    stopHeartbeat();
+    return 2;
+  }
+  try {
+    validateRehydratedWorkerRuntime(spec, runtime);
+  } catch (err) {
+    process.stderr.write(`[worker] ${err instanceof Error ? err.message : String(err)}
+`);
+    stopHeartbeat();
+    return 2;
+  }
+  const ledgerPort = createWorkerAgentLedgerPort({
+    ...spec.ledger !== void 0 ? { ledger: spec.ledger } : {},
+    emitControlFrame
+  });
+  demux.onLedgerDelta((entries) => ledgerPort.acceptDelta(entries));
+  const input = {
+    systemPrompt: spec.systemPrompt,
+    dynamicPromptMessages: spec.dynamicPromptMessages ?? [],
+    agentId: spec.agentId,
+    task: spec.task,
+    target: spec.target,
+    runtime,
+    wireModelId: spec.wireModelId,
+    allowedTools: spec.allowedTools,
+    budget: spec.budget,
+    ...spec.noSkills !== void 0 ? { noSkills: spec.noSkills } : {},
+    ...spec.skillPaths !== void 0 ? { skillPaths: [...spec.skillPaths] } : {},
+    ...spec.agentSkills !== void 0 ? { agentSkills: [...spec.agentSkills] } : {},
+    ...spec.trustProjectCompatRoots !== void 0 ? { trustProjectCompatRoots: spec.trustProjectCompatRoots } : {},
+    ...spec.onPermission !== void 0 ? { onPermission: spec.onPermission } : {},
+    ...spec.escalation !== void 0 ? { escalation: spec.escalation } : {},
+    ...spec.toolProfile !== void 0 ? { toolProfile: spec.toolProfile } : {},
+    ...spec.autonomy !== void 0 ? { autonomy: spec.autonomy } : {},
+    ...spec.writeRoots !== void 0 ? { writeRoots: [...spec.writeRoots] } : {},
+    ...spec.protectedArtifactState !== void 0 ? {
+      protectedArtifactState: {
+        version: spec.protectedArtifactState.version,
+        artifacts: structuredClone(spec.protectedArtifactState.artifacts)
+      }
+    } : {},
+    ...spec.responseSchema !== void 0 ? { responseSchema: spec.responseSchema } : {},
+    ...spec.resultContract !== void 0 ? { resultContract: spec.resultContract } : {},
+    ...spec.product !== void 0 ? { product: spec.product } : {},
+    agentLedger: ledgerPort,
+    cwd: process.cwd()
+  };
+  if (spec.modelCapabilities) input.modelCapabilities = spec.modelCapabilities;
+  if (spec.sessionId) input.sessionId = spec.sessionId;
+  if (spec.apiKey) input.apiKey = spec.apiKey;
+  if (spec.thinkingLevel) input.thinkingLevel = spec.thinkingLevel;
+  if (spec.runtimeResolution) input.runtimeResolution = spec.runtimeResolution;
+  if (spec.middlewareSnapshot) input.middlewareSnapshot = spec.middlewareSnapshot;
+  announceWorker(spec, input);
+  const handle = startWorkerRun(input, (event) => emitEvent(projectWorkerEventForStdout(event)));
+  demux.onSteer(
+    createOrderedSteerHandler(
+      (text) => handle.steer?.(text) ?? false,
+      ({ text, sequence }) => emitEvent({ type: "clio_steer_received", payload: { chars: text.trim().length, sequence } }),
+      (reason) => process.stderr.write(`[worker] dropped steer: ${reason}
+`)
+    )
+  );
+  demux.onPermissionDecision(({ requestId, decision }) => {
+    const resolved = handle.resolvePermission?.(requestId, decision) ?? false;
+    if (!resolved) {
+      process.stderr.write(`[worker] dropped permission_decision for unknown request '${requestId}'
+`);
+    }
+  });
+  demux.onChannelClose(() => {
+    process.stderr.write("[worker] control channel closed; aborting run\n");
+    emitControlFrame({ kind: "cancel_ack", at: Date.now() });
+    handle.abort();
+    const forceExit = setTimeout(() => process.exit(1), CHANNEL_CLOSE_EXIT_GRACE_MS);
+    forceExit.unref?.();
+  });
+  const onSignal = () => {
+    emitControlFrame({ kind: "cancel_ack", at: Date.now() });
+    handle.abort();
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  try {
+    const result = await handle.promise;
+    return result.exitCode;
+  } finally {
+    stopHeartbeat();
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    const dropped = demux.droppedLineCount();
+    if (dropped > 0) {
+      process.stderr.write(`[worker] dropped ${dropped} unrecognized stdin line(s) after the spec
+`);
+    }
+    await disposeLmStudioClients();
+  }
+}
+main().then(
+  async (code) => {
+    await drainStdout();
+    process.exit(code);
+  },
+  async (err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[worker] fatal: ${msg}
+`);
+    await drainStdout();
+    process.exit(2);
+  }
+);
+//# sourceMappingURL=entry.js.map