@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-R7FGRZNF.js

@@ -0,0 +1,1794 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  typedValidationSummary
+} from "./chunk-DOUISWEE.js";
+import {
+  assertValidResponseSchema,
+  runtimeSpeaksResponseSchemaDialect,
+  snapshotTurnConstraints
+} from "./chunk-OQ2EOAHA.js";
+import {
+  completeHistoryLength,
+  contextHash,
+  messageToolCalls,
+  parseWorkerContextSeed
+} from "./chunk-T33IYTZM.js";
+import {
+  describeCallAction
+} from "./chunk-XNIZBOFV.js";
+import {
+  assertToolProfileEnforceable
+} from "./chunk-XZWSP67B.js";
+import {
+  boundedExternalDiagnostic
+} from "./chunk-77DCC6JZ.js";
+import {
+  DEFAULT_AUTONOMY_LEVEL,
+  autonomyAskRejection,
+  autonomyDenyRejection,
+  mapAutonomy
+} from "./chunk-UZVYEF57.js";
+import {
+  INTERNAL_HELPER_RESULT_KINDS
+} from "./chunk-LNOXCGN2.js";
+import {
+  classify
+} from "./chunk-VYRQHORQ.js";
+import {
+  commandArgumentSegments,
+  detectValidationCommand,
+  extractCommandDeleteTargets,
+  extractCommandWriteTargets,
+  toolMutationPaths
+} from "./chunk-P4GNZPXO.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import {
+  THINKING_LEVELS
+} from "./chunk-QZTTRSJE.js";
+import {
+  buildSafeToolEnv,
+  resolveSafeCwd
+} from "./chunk-M2IPMWCN.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/worker/spec-contract.ts
+init_esm_shims();
+var WORKER_SPEC_VERSION = 4;
+var WORKER_RUNTIME_DESCRIPTOR_VERSION = 2;
+var WORKER_PROTECTED_ARTIFACT_STATE_VERSION = 1;
+var WORKER_EXIT_PERMISSION_REQUIRED = 3;
+var DEFAULT_ESCALATION_TIMEOUT_MS = 12e4;
+var DEFAULT_ESCALATION_FALLBACK = "deny";
+var RUNTIME_KINDS = ["http", "sdk", "subprocess"];
+var RUNTIME_API_FAMILIES = [
+  "openai-completions",
+  "openai-responses",
+  "openai-codex-responses",
+  "azure-openai-responses",
+  "anthropic-messages",
+  "bedrock-converse-stream",
+  "google-generative-ai",
+  "google-vertex",
+  "mistral-conversations",
+  "ollama-native",
+  "rerank-http",
+  "embeddings-http",
+  "claude-agent-sdk",
+  "claude-code-subprocess",
+  "external-agent-subprocess"
+];
+var RUNTIME_AUTHS = [
+  "api-key",
+  "oauth",
+  "aws-sdk",
+  "vertex-adc",
+  "claude-cli",
+  "none"
+];
+var TOOL_PROFILE_NAMES = [
+  "minimal-local",
+  "science-local",
+  "full-agent",
+  "council-read-only"
+];
+var WORKER_PRODUCTS = ["orientation"];
+var TARGET_LIFECYCLES = ["user-managed", "clio-coder-managed"];
+var RESIDENCY_ROLES = ["chat", "memory", "worker", "target-default"];
+var MIDDLEWARE_HOOKS = ["before_tool", "after_tool", "turn_start", "turn_end", "on_compaction"];
+var MIDDLEWARE_EFFECT_KINDS = [
+  "inject_reminder",
+  "annotate_tool_result",
+  "block_tool",
+  "protect_path",
+  "request_continuation",
+  "require_tool",
+  "lock_tools"
+];
+var RUNTIME_RESOLUTION_SEVERITIES = ["info", "warning", "error"];
+var SPEC_AUTONOMY_LEVELS = [
+  "read-only",
+  "suggest",
+  "auto-edit",
+  "full-auto"
+];
+var THINKING_MECHANISMS = ["effort-levels", "budget-tokens", "on-off", "always-on", "none"];
+var THINKING_BUDGET_ENFORCEMENTS = ["enforced", "informational", "none"];
+var THINKING_NOTICE_KINDS = ["applied", "ignored-on-off", "always-on", "unsupported"];
+function serializeWorkerRuntimeDescriptor(runtime) {
+  return {
+    version: WORKER_RUNTIME_DESCRIPTOR_VERSION,
+    id: runtime.id,
+    kind: runtime.kind,
+    apiFamily: runtime.apiFamily,
+    auth: runtime.auth,
+    // Carried so the target check can recognize a configured runtime id that
+    // resolves to this runtime through an alias. Without them the contract has
+    // no way to tell a legacy spelling from a genuinely wrong runtime.
+    ...runtime.aliases !== void 0 && runtime.aliases.length > 0 ? { aliases: [...runtime.aliases] } : {}
+  };
+}
+function readRecord(value, source) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${source} must be an object`);
+  }
+  return value;
+}
+function readWorkerPromptMessages(value, source) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) throw new Error(`${source} must be an array`);
+  for (let index = 0; index < value.length; index++) {
+    const entry = readRecord(value[index], `${source}[${index}]`);
+    readString(entry.id, `${source}[${index}].id`);
+    readString(entry.body, `${source}[${index}].body`);
+    readString(entry.contentHash, `${source}[${index}].contentHash`);
+  }
+}
+function readString(value, source, options) {
+  if (typeof value !== "string") throw new Error(`${source} must be a string`);
+  if (!options?.allowEmpty && value.length === 0) throw new Error(`${source} must be a non-empty string`);
+  return value;
+}
+function readOptionalString(record2, key, source) {
+  if (record2[key] !== void 0) readString(record2[key], `${source}.${key}`);
+}
+function readOptionalBoolean(record2, key, source) {
+  const value = record2[key];
+  if (value !== void 0 && typeof value !== "boolean") throw new Error(`${source}.${key} must be a boolean`);
+}
+function readOptionalNumber(record2, key, source) {
+  const value = record2[key];
+  if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value))) {
+    throw new Error(`${source}.${key} must be a finite number`);
+  }
+}
+function readEnum(value, source, allowed) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new Error(`${source} must be one of: ${allowed.join(", ")}`);
+  }
+  return value;
+}
+function readOptionalEnum(record2, key, source, allowed) {
+  if (record2[key] !== void 0) readEnum(record2[key], `${source}.${key}`, allowed);
+}
+function readStringArray(value, source) {
+  if (!Array.isArray(value)) throw new Error(`${source} must be an array`);
+  return value.map((item, index) => readString(item, `${source}[${index}]`));
+}
+function readOptionalStringArray(record2, key, source) {
+  if (record2[key] !== void 0) readStringArray(record2[key], `${source}.${key}`);
+}
+function validateProtectedModels(value) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) throw new Error("WorkerSpec.protectedModels must be an array");
+  value.forEach((item, index) => {
+    const source = `WorkerSpec.protectedModels[${index}]`;
+    if (typeof item === "string") {
+      readString(item, source);
+      return;
+    }
+    const ref = readRecord(item, source);
+    readString(ref.modelId, `${source}.modelId`);
+    readEnum(ref.role, `${source}.role`, RESIDENCY_ROLES);
+  });
+}
+function validateTarget(value, runtimeId, runtimeAliases) {
+  const target = readRecord(value, "WorkerSpec.target");
+  const targetId = readString(target.id, "WorkerSpec.target.id");
+  const targetRuntime = readString(target.runtime, "WorkerSpec.target.runtime");
+  if (targetRuntime !== runtimeId && !runtimeAliases.includes(targetRuntime)) {
+    throw new Error(
+      `WorkerSpec target runtime mismatch: target.runtime=${targetRuntime} runtimeId=${runtimeId}. Set the target's runtime to '${runtimeId}' in settings.yaml, or run 'clio-coder upgrade' to migrate a legacy runtime id.`
+    );
+  }
+  if (targetId.length === 0) throw new Error("WorkerSpec.target.id must be a non-empty string");
+  readOptionalString(target, "url", "WorkerSpec.target");
+  readOptionalString(target, "defaultModel", "WorkerSpec.target");
+  readOptionalStringArray(target, "wireModels", "WorkerSpec.target");
+  readOptionalBoolean(target, "gateway", "WorkerSpec.target");
+  readOptionalEnum(target, "lifecycle", "WorkerSpec.target", TARGET_LIFECYCLES);
+  if (target.auth !== void 0) validateTargetAuth(target.auth);
+  if (target.pricing !== void 0) validateTargetPricing(target.pricing);
+  if (target.cache !== void 0) {
+    const cache = readRecord(target.cache, "WorkerSpec.target.cache");
+    readOptionalEnum(cache, "retention", "WorkerSpec.target.cache", ["none", "short", "long"]);
+    if (cache.deployment !== void 0) {
+      const binding = readRecord(cache.deployment, "WorkerSpec.target.cache.deployment");
+      readString(binding.backend, "WorkerSpec.target.cache.deployment.backend");
+      readOptionalEnum(binding, "backend", "WorkerSpec.target.cache.deployment", [
+        "llamacpp",
+        "vllm",
+        "lmstudio"
+      ]);
+      for (const key of ["controlUrl", "model", "build"]) {
+        if (key === "build" && binding.backend === "lmstudio" && binding[key] === void 0) continue;
+        readString(binding[key], `WorkerSpec.target.cache.deployment.${key}`);
+      }
+      readOptionalString(binding, "gatewayDeploymentId", "WorkerSpec.target.cache.deployment");
+      const url = new URL(readString(binding.controlUrl, "WorkerSpec.target.cache.deployment.controlUrl"));
+      if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+        throw new Error(
+          "WorkerSpec.target.cache.deployment.controlUrl must be HTTP(S) without credentials, query, or fragment"
+        );
+    }
+    if (cache.warm !== void 0) {
+      const warm = readRecord(cache.warm, "WorkerSpec.target.cache.warm");
+      readOptionalBoolean(warm, "startup", "WorkerSpec.target.cache.warm");
+      for (const key of ["maxInputTokens", "maxDurationMs", "cooldownMs"]) {
+        if (warm[key] !== void 0 && (typeof warm[key] !== "number" || !Number.isSafeInteger(warm[key]) || warm[key] < 1))
+          throw new Error(`WorkerSpec.target.cache.warm.${key} must be a positive safe integer`);
+      }
+    }
+  }
+  if (target.capabilities !== void 0) validateCapabilityPatch(target.capabilities, "WorkerSpec.target.capabilities");
+}
+function validateTargetAuth(value) {
+  const auth = readRecord(value, "WorkerSpec.target.auth");
+  readOptionalString(auth, "apiKeyEnvVar", "WorkerSpec.target.auth");
+  readOptionalString(auth, "apiKeyRef", "WorkerSpec.target.auth");
+  readOptionalString(auth, "oauthProfile", "WorkerSpec.target.auth");
+  if (auth.headers === void 0) return;
+  const headers = readRecord(auth.headers, "WorkerSpec.target.auth.headers");
+  for (const [key, value2] of Object.entries(headers)) {
+    readString(value2, `WorkerSpec.target.auth.headers.${key}`);
+  }
+}
+function validateTargetPricing(value) {
+  const pricing = readRecord(value, "WorkerSpec.target.pricing");
+  const input = pricing.input;
+  const output = pricing.output;
+  if (typeof input !== "number" || !Number.isFinite(input) || input < 0) {
+    throw new Error("WorkerSpec.target.pricing.input must be a non-negative finite number");
+  }
+  if (typeof output !== "number" || !Number.isFinite(output) || output < 0) {
+    throw new Error("WorkerSpec.target.pricing.output must be a non-negative finite number");
+  }
+  readOptionalNumber(pricing, "cacheRead", "WorkerSpec.target.pricing");
+  readOptionalNumber(pricing, "cacheWrite", "WorkerSpec.target.pricing");
+}
+function validateCapabilityPatch(value, source) {
+  const caps = readRecord(value, source);
+  for (const key of ["chat", "tools", "reasoning", "vision", "audio", "embeddings", "rerank", "fim"]) {
+    readOptionalBoolean(caps, key, source);
+  }
+  for (const key of ["contextWindow", "maxTokens"]) {
+    readOptionalNumber(caps, key, source);
+  }
+  if (caps.thinkingControlRuntime !== void 0) {
+    readEnum(caps.thinkingControlRuntime, `${source}.thinkingControlRuntime`, ["lmstudio", "llamacpp"]);
+  }
+  for (const key of ["toolCallFormat", "thinkingFormat", "structuredOutputs"]) {
+    readOptionalString(caps, key, source);
+  }
+}
+function validateAllowedTools(value) {
+  for (const name of readStringArray(value, "WorkerSpec.allowedTools")) {
+    if (name.trim().length === 0) throw new Error("WorkerSpec.allowedTools entries must be non-empty strings");
+  }
+}
+function validateWorkerBudget(value) {
+  const budget = readRecord(value, "WorkerSpec.budget");
+  const expected = ["mode", "hardCap", "readReserve", "revision", "synthesis", "toolCalls"];
+  const actual = Object.keys(budget).sort();
+  if (actual.some((key) => !expected.includes(key)) || actual.some((key) => key === "revision" && budget.revision === void 0)) {
+    throw new Error(`WorkerSpec.budget may contain only: ${expected.join(", ")}`);
+  }
+  if (budget.mode !== void 0 && budget.mode !== "advisory" && budget.mode !== "enforced")
+    throw new Error("WorkerSpec.budget.mode must be advisory or enforced");
+  for (const required of ["hardCap", "readReserve", "synthesis", "toolCalls"]) {
+    if (!Object.hasOwn(budget, required)) throw new Error(`WorkerSpec.budget.${required} is required`);
+  }
+  for (const key of ["toolCalls", "readReserve", "hardCap"]) {
+    const value2 = budget[key];
+    if (typeof value2 !== "number" || !Number.isSafeInteger(value2)) {
+      throw new Error(`WorkerSpec.budget.${key} must be a safe integer`);
+    }
+  }
+  if (budget.toolCalls <= 0) throw new Error("WorkerSpec.budget.toolCalls must be greater than zero");
+  if (budget.hardCap <= 0) throw new Error("WorkerSpec.budget.hardCap must be greater than zero");
+  if (budget.mode !== "advisory" && budget.toolCalls > budget.hardCap) {
+    throw new Error("WorkerSpec.budget.toolCalls must not exceed WorkerSpec.budget.hardCap");
+  }
+  if (budget.readReserve < 0 || budget.readReserve >= budget.toolCalls) {
+    throw new Error("WorkerSpec.budget.readReserve must be an integer in [0, toolCalls)");
+  }
+  if (typeof budget.synthesis !== "boolean") throw new Error("WorkerSpec.budget.synthesis must be a boolean");
+  if (budget.revision !== void 0) {
+    const revision = readRecord(budget.revision, "WorkerSpec.budget.revision");
+    const revisionKeys = Object.keys(revision).sort();
+    if (revisionKeys.length !== 2 || revisionKeys[0] !== "readReserve" || revisionKeys[1] !== "toolCalls") {
+      throw new Error("WorkerSpec.budget.revision must contain exactly: readReserve, toolCalls");
+    }
+    for (const key of ["toolCalls", "readReserve"]) {
+      if (typeof revision[key] !== "number" || !Number.isSafeInteger(revision[key])) {
+        throw new Error(`WorkerSpec.budget.revision.${key} must be a safe integer`);
+      }
+    }
+    if (revision.toolCalls < budget.toolCalls) {
+      throw new Error("WorkerSpec.budget.revision.toolCalls must not be smaller than WorkerSpec.budget.toolCalls");
+    }
+    if (revision.toolCalls === budget.toolCalls && revision.readReserve <= budget.readReserve) {
+      throw new Error("WorkerSpec.budget.revision must increase toolCalls or readReserve");
+    }
+    if (budget.mode !== "advisory" && revision.toolCalls > budget.hardCap) {
+      throw new Error("WorkerSpec.budget.revision.toolCalls must not exceed WorkerSpec.budget.hardCap");
+    }
+    if (revision.readReserve < 0 || revision.readReserve >= revision.toolCalls) {
+      throw new Error("WorkerSpec.budget.revision.readReserve must be an integer in [0, toolCalls)");
+    }
+  }
+}
+function validateRuntimeCapabilityDecision(value, source) {
+  const caps = readRecord(value, source);
+  for (const key of ["chat", "tools", "reasoning", "vision", "streaming"]) {
+    if (typeof caps[key] !== "boolean") throw new Error(`${source}.${key} must be a boolean`);
+  }
+  for (const key of ["contextWindow", "maxTokens"]) {
+    const n = caps[key];
+    if (typeof n !== "number" || !Number.isFinite(n) || n < 0)
+      throw new Error(`${source}.${key} must be a non-negative finite number`);
+  }
+}
+function validateRuntimeResolution(value) {
+  if (value === void 0) return;
+  const resolution = readRecord(value, "WorkerSpec.runtimeResolution");
+  readString(resolution.targetId, "WorkerSpec.runtimeResolution.targetId");
+  readString(resolution.runtimeId, "WorkerSpec.runtimeResolution.runtimeId");
+  readEnum(resolution.runtimeKind, "WorkerSpec.runtimeResolution.runtimeKind", RUNTIME_KINDS);
+  readEnum(resolution.apiFamily, "WorkerSpec.runtimeResolution.apiFamily", RUNTIME_API_FAMILIES);
+  readEnum(resolution.auth, "WorkerSpec.runtimeResolution.auth", RUNTIME_AUTHS);
+  if (typeof resolution.authRequired !== "boolean") {
+    throw new Error("WorkerSpec.runtimeResolution.authRequired must be a boolean");
+  }
+  readString(resolution.wireModelId, "WorkerSpec.runtimeResolution.wireModelId");
+  readEnum(resolution.requestedThinkingLevel, "WorkerSpec.runtimeResolution.requestedThinkingLevel", THINKING_LEVELS);
+  readEnum(resolution.effectiveThinkingLevel, "WorkerSpec.runtimeResolution.effectiveThinkingLevel", THINKING_LEVELS);
+  validateRuntimeCapabilityDecision(resolution.capabilities, "WorkerSpec.runtimeResolution.capabilities");
+  const thinking = readRecord(resolution.thinking, "WorkerSpec.runtimeResolution.thinking");
+  readEnum(thinking.mechanism, "WorkerSpec.runtimeResolution.thinking.mechanism", THINKING_MECHANISMS);
+  readString(thinking.display, "WorkerSpec.runtimeResolution.thinking.display", { allowEmpty: true });
+  for (const level of readStringArray(
+    thinking.supportedLevels,
+    "WorkerSpec.runtimeResolution.thinking.supportedLevels"
+  )) {
+    readEnum(level, "WorkerSpec.runtimeResolution.thinking.supportedLevels[]", THINKING_LEVELS);
+  }
+  readEnum(
+    thinking.budgetEnforcement,
+    "WorkerSpec.runtimeResolution.thinking.budgetEnforcement",
+    THINKING_BUDGET_ENFORCEMENTS
+  );
+  readEnum(thinking.noticeKind, "WorkerSpec.runtimeResolution.thinking.noticeKind", THINKING_NOTICE_KINDS);
+  readString(thinking.notice, "WorkerSpec.runtimeResolution.thinking.notice", { allowEmpty: true });
+  readRecord(resolution.request, "WorkerSpec.runtimeResolution.request");
+  readRecord(resolution.response, "WorkerSpec.runtimeResolution.response");
+  if (!Array.isArray(resolution.diagnostics)) {
+    throw new Error("WorkerSpec.runtimeResolution.diagnostics must be an array");
+  }
+  for (let index = 0; index < resolution.diagnostics.length; index += 1) {
+    const diag = readRecord(resolution.diagnostics[index], `WorkerSpec.runtimeResolution.diagnostics[${index}]`);
+    readEnum(diag.severity, `WorkerSpec.runtimeResolution.diagnostics[${index}].severity`, RUNTIME_RESOLUTION_SEVERITIES);
+    readString(diag.code, `WorkerSpec.runtimeResolution.diagnostics[${index}].code`);
+    readString(diag.message, `WorkerSpec.runtimeResolution.diagnostics[${index}].message`);
+  }
+}
+function validateMiddlewareSnapshot(value) {
+  const snapshot = readRecord(value, "WorkerSpec.middlewareSnapshot");
+  if (snapshot.version !== 1) throw new Error("WorkerSpec.middlewareSnapshot version must be 1");
+  if (!Array.isArray(snapshot.rules)) throw new Error("WorkerSpec.middlewareSnapshot.rules must be an array");
+  for (let index = 0; index < snapshot.rules.length; index += 1) {
+    const source = `WorkerSpec.middlewareSnapshot.rules[${index}]`;
+    const rule = readRecord(snapshot.rules[index], source);
+    readString(rule.id, `${source}.id`);
+    if (rule.source !== "builtin") throw new Error(`${source}.source must be builtin`);
+    readString(rule.description, `${source}.description`);
+    if (typeof rule.enabled !== "boolean") throw new Error(`${source}.enabled must be a boolean`);
+    for (const hook of readStringArray(rule.hooks, `${source}.hooks`)) {
+      readEnum(hook, `${source}.hooks[]`, MIDDLEWARE_HOOKS);
+    }
+    for (const kind of readStringArray(rule.effectKinds, `${source}.effectKinds`)) {
+      readEnum(kind, `${source}.effectKinds[]`, MIDDLEWARE_EFFECT_KINDS);
+    }
+  }
+}
+function validateProtectedArtifactState(value) {
+  const state = readRecord(value, "WorkerSpec.protectedArtifactState");
+  if (state.version !== WORKER_PROTECTED_ARTIFACT_STATE_VERSION) {
+    throw new Error(
+      `WorkerSpec.protectedArtifactState version ${String(state.version)} is unsupported; expected ${WORKER_PROTECTED_ARTIFACT_STATE_VERSION}`
+    );
+  }
+  if (!Array.isArray(state.artifacts)) {
+    throw new Error("WorkerSpec.protectedArtifactState.artifacts must be an array");
+  }
+  const sources = ["validation", "middleware", "user", "session"];
+  for (let index = 0; index < state.artifacts.length; index += 1) {
+    const source = `WorkerSpec.protectedArtifactState.artifacts[${index}]`;
+    const artifact = readRecord(state.artifacts[index], source);
+    readString(artifact.path, `${source}.path`);
+    readString(artifact.protectedAt, `${source}.protectedAt`);
+    readString(artifact.reason, `${source}.reason`);
+    readEnum(artifact.source, `${source}.source`, sources);
+    readOptionalString(artifact, "validationCommand", source);
+    readOptionalNumber(artifact, "validationExitCode", source);
+  }
+}
+function parseWorkerSpec(value) {
+  const spec = readRecord(value, "WorkerSpec");
+  if (spec.specVersion !== WORKER_SPEC_VERSION) {
+    throw new Error(
+      `WorkerSpec version ${String(spec.specVersion)} is unsupported (expected version ${WORKER_SPEC_VERSION}). Re-dispatch the request to generate a valid attested, budget-bearing worker specification.`
+    );
+  }
+  if (spec.budget === void 0) {
+    throw new Error(`WorkerSpec version ${WORKER_SPEC_VERSION} requires budget`);
+  }
+  if (typeof spec.settingsFingerprint !== "string" || !/^[0-9a-f]{64}$/.test(spec.settingsFingerprint)) {
+    throw new Error(`WorkerSpec version ${WORKER_SPEC_VERSION} requires settingsFingerprint as a sha256 hex digest`);
+  }
+  const runtime = readRecord(spec.runtime, "WorkerSpec.runtime");
+  if (runtime.version !== WORKER_RUNTIME_DESCRIPTOR_VERSION) {
+    throw new Error(
+      `WorkerSpec.runtime version ${String(runtime.version)} is unsupported; expected ${WORKER_RUNTIME_DESCRIPTOR_VERSION}`
+    );
+  }
+  const runtimeId = readString(spec.runtimeId, "WorkerSpec.runtimeId");
+  const runtimeRefId = readString(runtime.id, "WorkerSpec.runtime.id");
+  if (runtimeId !== runtimeRefId) {
+    throw new Error(`WorkerSpec runtime id mismatch: runtimeId=${runtimeId} runtime.id=${runtimeRefId}`);
+  }
+  const runtimeAliases = runtime.aliases === void 0 ? [] : readStringArray(runtime.aliases, "WorkerSpec.runtime.aliases");
+  const runtimeKind = readEnum(runtime.kind, "WorkerSpec.runtime.kind", RUNTIME_KINDS);
+  const runtimeApiFamily = readEnum(runtime.apiFamily, "WorkerSpec.runtime.apiFamily", RUNTIME_API_FAMILIES);
+  readEnum(runtime.auth, "WorkerSpec.runtime.auth", RUNTIME_AUTHS);
+  readString(spec.systemPrompt, "WorkerSpec.systemPrompt", { allowEmpty: true });
+  readWorkerPromptMessages(spec.dynamicPromptMessages, "WorkerSpec.dynamicPromptMessages");
+  if (spec.contextSeed !== void 0) {
+    parseWorkerContextSeed(spec.contextSeed);
+    if (runtimeKind !== "http") throw new Error("worker context: native history seeds require an HTTP/Pi runtime");
+  }
+  readOptionalString(spec, "promptSignature", "WorkerSpec");
+  readOptionalString(spec, "toolSignature", "WorkerSpec");
+  readOptionalString(spec, "dynamicHash", "WorkerSpec");
+  readString(spec.agentId, "WorkerSpec.agentId");
+  readString(spec.task, "WorkerSpec.task");
+  validateTarget(spec.target, runtimeId, runtimeAliases);
+  readString(spec.wireModelId, "WorkerSpec.wireModelId");
+  readOptionalString(spec, "sessionId", "WorkerSpec");
+  readOptionalString(spec, "apiKey", "WorkerSpec");
+  readOptionalEnum(spec, "thinkingLevel", "WorkerSpec", THINKING_LEVELS);
+  if (spec.modelCapabilities !== void 0)
+    validateCapabilityPatch(spec.modelCapabilities, "WorkerSpec.modelCapabilities");
+  if (spec.responseSchema !== void 0) {
+    assertValidResponseSchema(spec.responseSchema, "WorkerSpec.responseSchema");
+    if (!runtimeSpeaksResponseSchemaDialect({ id: runtimeId, kind: runtimeKind, apiFamily: runtimeApiFamily })) {
+      throw new Error("WorkerSpec.responseSchema is supported only by the native llamacpp runtime");
+    }
+    const structuredOutputs = spec.modelCapabilities === void 0 ? void 0 : readRecord(spec.modelCapabilities, "WorkerSpec.modelCapabilities").structuredOutputs;
+    if (structuredOutputs !== "json-schema") {
+      throw new Error("WorkerSpec.responseSchema requires resolved JSON-schema model capability");
+    }
+  }
+  validateAllowedTools(spec.allowedTools);
+  if (spec.helperResult !== void 0) {
+    if (spec.helperResult !== true) throw new Error("WorkerSpec.helperResult must be true when present");
+    const contract = readRecord(spec.resultContract, "WorkerSpec.resultContract");
+    if (!INTERNAL_HELPER_RESULT_KINDS.includes(contract.kind)) {
+      throw new Error("WorkerSpec.helperResult requires a supported internal JSON result contract");
+    }
+  }
+  validateWorkerBudget(spec.budget);
+  validateProtectedModels(spec.protectedModels);
+  validateRuntimeResolution(spec.runtimeResolution);
+  if (spec.middlewareSnapshot !== void 0) validateMiddlewareSnapshot(spec.middlewareSnapshot);
+  if (spec.protectedArtifactState !== void 0) validateProtectedArtifactState(spec.protectedArtifactState);
+  if (spec.noSkills !== void 0 && typeof spec.noSkills !== "boolean") {
+    throw new Error("WorkerSpec.noSkills must be a boolean");
+  }
+  if (spec.turnConstraints !== void 0) snapshotTurnConstraints(spec.turnConstraints);
+  if (spec.skillPaths !== void 0) {
+    readStringArray(spec.skillPaths, "WorkerSpec.skillPaths");
+  }
+  if (spec.agentSkills !== void 0) {
+    for (const name of readStringArray(spec.agentSkills, "WorkerSpec.agentSkills")) {
+      if (name.trim().length === 0) throw new Error("WorkerSpec.agentSkills entries must be non-empty strings");
+    }
+  }
+  if (spec.trustProjectCompatRoots !== void 0 && typeof spec.trustProjectCompatRoots !== "boolean") {
+    throw new Error("WorkerSpec.trustProjectCompatRoots must be a boolean");
+  }
+  if (spec.gitCommitAttribution !== void 0 && typeof spec.gitCommitAttribution !== "boolean") {
+    throw new Error("WorkerSpec.gitCommitAttribution must be a boolean");
+  }
+  readOptionalEnum(spec, "toolProfile", "WorkerSpec", TOOL_PROFILE_NAMES);
+  readOptionalEnum(spec, "product", "WorkerSpec", WORKER_PRODUCTS);
+  if (spec.onPermission !== void 0 && spec.onPermission !== "deny" && spec.onPermission !== "fail" && spec.onPermission !== "escalate") {
+    throw new Error('WorkerSpec.onPermission must be "deny", "fail", or "escalate"');
+  }
+  if (spec.escalation !== void 0) {
+    const escalation = readRecord(spec.escalation, "WorkerSpec.escalation");
+    const timeoutMs = escalation.timeoutMs;
+    if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      throw new Error("WorkerSpec.escalation.timeoutMs must be a positive finite number");
+    }
+    if (escalation.fallback !== "deny" && escalation.fallback !== "fail") {
+      throw new Error('WorkerSpec.escalation.fallback must be "deny" or "fail"');
+    }
+  }
+  if (spec.autonomy !== void 0) {
+    readEnum(spec.autonomy, "WorkerSpec.autonomy", SPEC_AUTONOMY_LEVELS);
+  }
+  if (spec.ledger !== void 0) {
+    const ledger = readRecord(spec.ledger, "WorkerSpec.ledger");
+    readString(ledger.id, "WorkerSpec.ledger.id");
+    if (typeof ledger.sequence !== "number" || !Number.isSafeInteger(ledger.sequence) || ledger.sequence < 0) {
+      throw new Error("WorkerSpec.ledger.sequence must be a non-negative safe integer");
+    }
+  }
+  if (spec.writeRoots !== void 0) {
+    const roots = readStringArray(spec.writeRoots, "WorkerSpec.writeRoots");
+    if (roots.length === 0) throw new Error("WorkerSpec.writeRoots must be a non-empty array when present");
+    for (const root of roots) {
+      if (root.trim().length === 0) throw new Error("WorkerSpec.writeRoots entries must be non-empty strings");
+    }
+  }
+  return spec;
+}
+function validateRehydratedWorkerRuntime(spec, runtime) {
+  const expected = spec.runtime;
+  if (runtime.id !== expected.id) {
+    throw new Error(`WorkerSpec runtime rehydration mismatch for id: expected ${expected.id}, got ${runtime.id}`);
+  }
+  if (runtime.kind !== expected.kind) {
+    throw new Error(`WorkerSpec runtime rehydration mismatch for kind: expected ${expected.kind}, got ${runtime.kind}`);
+  }
+  if (runtime.apiFamily !== expected.apiFamily) {
+    throw new Error(
+      `WorkerSpec runtime rehydration mismatch for apiFamily: expected ${expected.apiFamily}, got ${runtime.apiFamily}`
+    );
+  }
+  if (runtime.auth !== expected.auth) {
+    throw new Error(`WorkerSpec runtime rehydration mismatch for auth: expected ${expected.auth}, got ${runtime.auth}`);
+  }
+}
+
+// src/domains/context/worker/snapshot.ts
+init_esm_shims();
+function captureWorkerContext(source, messages) {
+  const conversation = messages.filter((message) => message.role !== "system");
+  const interrupted = (message) => message.role === "assistant" && (message.stopReason === "error" || message.stopReason === "aborted");
+  const interruptedIds = new Set(
+    conversation.filter(interrupted).flatMap(messageToolCalls).map((call) => call.id)
+  );
+  const visible = conversation.filter(
+    (message) => !interrupted(message) && !(message.role === "toolResult" && interruptedIds.has(message.toolCallId))
+  );
+  const end = completeHistoryLength(visible, true);
+  const snapshot = {
+    version: 1,
+    source: structuredClone(source),
+    messages: structuredClone(visible.slice(0, end)),
+    excludedTailMessages: visible.length - end,
+    excludedInterruptedMessages: conversation.length - visible.length
+  };
+  return { ...snapshot, contentHash: contextHash(snapshot) };
+}
+
+// src/engine/antigravity/subprocess-runtime.ts
+init_esm_shims();
+import { spawn as spawn2 } from "node:child_process";
+
+// src/engine/external-subprocess.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+async function* readBoundedLines(readable, options) {
+  let segments = [];
+  let lineBytes = 0;
+  let totalBytes = 0;
+  let discarding = false;
+  const finishLine = () => {
+    if (discarding) {
+      segments = [];
+      lineBytes = 0;
+      discarding = false;
+      return { kind: "oversized" };
+    }
+    if (lineBytes === 0) return { kind: "line", line: "" };
+    const joined = Buffer.concat(segments, lineBytes);
+    segments = [];
+    lineBytes = 0;
+    const end = joined.at(-1) === 13 ? joined.length - 1 : joined.length;
+    return { kind: "line", line: joined.subarray(0, end).toString("utf8") };
+  };
+  for await (const raw of readable) {
+    const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(String(raw));
+    totalBytes += chunk.byteLength;
+    if (totalBytes > options.maxTotalBytes) throw new Error("external stdout exceeded the cumulative output limit");
+    let offset = 0;
+    while (offset < chunk.length) {
+      const newline = chunk.indexOf(10, offset);
+      const end = newline === -1 ? chunk.length : newline;
+      const piece = chunk.subarray(offset, end);
+      if (!discarding && piece.length > 0) {
+        if (lineBytes + piece.length > options.maxLineBytes) {
+          segments = [];
+          lineBytes = 0;
+          discarding = true;
+        } else {
+          segments.push(piece);
+          lineBytes += piece.length;
+        }
+      }
+      if (newline === -1) break;
+      const line = finishLine();
+      if (line) yield line;
+      offset = newline + 1;
+    }
+  }
+  if (discarding || lineBytes > 0) {
+    const line = finishLine();
+    if (line) yield line;
+  }
+}
+async function readStderr(child) {
+  let tail = Buffer.alloc(0);
+  for await (const chunk of child.stderr) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    tail = Buffer.concat([tail, bytes]);
+    if (tail.byteLength > 8192) tail = tail.subarray(tail.byteLength - 8192);
+  }
+  return boundedExternalDiagnostic(tail.toString("utf8"));
+}
+function createProcessTreeTerminator(child, graceMs = 1500, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const spawnKiller = options.spawn ?? spawn;
+  let sent = false;
+  let timer = null;
+  const signal = (name) => {
+    if (child.pid && platform !== "win32") {
+      try {
+        process.kill(-child.pid, name);
+        return;
+      } catch {
+      }
+    }
+    if (platform === "win32" && child.pid !== void 0 && Number.isSafeInteger(child.pid) && child.pid > 0) {
+      const args = ["/PID", String(child.pid), "/T", ...name === "SIGKILL" ? ["/F"] : []];
+      const killer = spawnKiller("taskkill.exe", args, { stdio: "ignore", windowsHide: true });
+      killer.once("error", () => {
+        if (child.exitCode === null) child.kill(name);
+      });
+      return;
+    }
+    if (child.exitCode !== null) return;
+    child.kill(name);
+  };
+  return {
+    terminate() {
+      if (sent) return;
+      sent = true;
+      signal("SIGTERM");
+      timer = setTimeout(() => {
+        timer = null;
+        signal("SIGKILL");
+      }, graceMs);
+    },
+    cleanup() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+        signal("SIGKILL");
+      }
+    }
+  };
+}
+function waitForClose(child) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (code) => {
+      if (settled) return;
+      settled = true;
+      resolve(code);
+    };
+    child.once("error", () => finish(1));
+    child.once("close", (code) => finish(code ?? 1));
+  });
+}
+
+// src/engine/antigravity/subprocess-runtime.ts
+var ANTIGRAVITY_BINARY = "agy";
+var ANTIGRAVITY_MAX_STREAM_LINE_BYTES = 1024 * 1024;
+var ANTIGRAVITY_MAX_STREAM_BYTES = 8 * 1024 * 1024;
+var ANTIGRAVITY_MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
+var ANTIGRAVITY_MAX_PROMPT_BYTES = 4 * 1024 * 1024;
+var MAX_PROTOCOL_DIAGNOSTICS = 32;
+var MAX_CONVERSATION_ID_BYTES = 4096;
+function antigravitySubprocessConfigForAutonomy(level, env = process.env) {
+  if (level === "full-auto" && env.CLIO_CODER_ALLOW_EXTERNAL_FULL_ACCESS === "1") {
+    return {
+      extraArgs: ["--dangerously-skip-permissions"],
+      dangerousBypass: true,
+      externalMode: "bypassPermissions"
+    };
+  }
+  if (level === "suggest") {
+    throw new Error(
+      "antigravity-code runtime cannot enforce autonomy 'suggest': it cannot park tool calls for approval. Dispatch to a native or claude-sdk worker, or use read-only or auto-edit."
+    );
+  }
+  if (level === "read-only") {
+    return { extraArgs: ["--mode", "plan", "--sandbox"], dangerousBypass: false, externalMode: "plan+sandbox" };
+  }
+  return { extraArgs: ["--mode", "accept-edits"], dangerousBypass: false, externalMode: "accept-edits" };
+}
+function buildAntigravityPrompt(input) {
+  const parts = [];
+  const systemPrompt = input.systemPrompt.trim();
+  if (systemPrompt.length > 0) parts.push(systemPrompt);
+  for (const message of input.dynamicPromptMessages ?? []) {
+    const body = message.body.trim();
+    if (body.length > 0) parts.push(body);
+  }
+  parts.push(input.task);
+  return parts.join("\n\n");
+}
+function buildAgyStdinLine(input) {
+  const content = buildAntigravityPrompt(input);
+  if (Buffer.byteLength(content, "utf8") > ANTIGRAVITY_MAX_PROMPT_BYTES) {
+    throw new Error(`Antigravity work order exceeded ${ANTIGRAVITY_MAX_PROMPT_BYTES} bytes`);
+  }
+  return `${JSON.stringify({ event: "user", message: { content } })}
+`;
+}
+function buildAgyArgs(input, gateEnv = process.env) {
+  assertToolProfileEnforceable(input.toolProfile, "antigravity-code");
+  const permission = antigravitySubprocessConfigForAutonomy(input.autonomy, gateEnv);
+  const args = [
+    ...permission.extraArgs,
+    "--input-format",
+    "stream-json",
+    "--output-format",
+    "stream-json",
+    "--disable-slash-commands"
+  ];
+  if (input.wireModelId.trim().length > 0) args.push("--model", input.wireModelId.trim());
+  if (typeof input.sessionId === "string" && input.sessionId.length > 0) {
+    if (Buffer.byteLength(input.sessionId, "utf8") > MAX_CONVERSATION_ID_BYTES) {
+      throw new Error(`Antigravity sessionId exceeded ${MAX_CONVERSATION_ID_BYTES} bytes`);
+    }
+    if (new RegExp("\\p{Cc}", "u").test(input.sessionId)) {
+      throw new Error("Antigravity sessionId must not contain control characters");
+    }
+    args.push("--conversation", input.sessionId);
+  }
+  return args;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function parseAntigravityStreamLine(line) {
+  let decoded;
+  try {
+    decoded = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const envelope = record(decoded);
+  if (!envelope || typeof envelope.event !== "string") return null;
+  if (envelope.event === "init") {
+    return {
+      event: "init",
+      conversationId: typeof envelope.conversation_id === "string" ? envelope.conversation_id : null,
+      model: typeof envelope.model === "string" ? envelope.model : null
+    };
+  }
+  if (envelope.event === "step_update") {
+    const update = record(envelope.step_update);
+    if (!update) return null;
+    if (update.step_type !== "agent_response" || typeof update.text_delta !== "string") {
+      return { event: "other" };
+    }
+    return {
+      event: "text",
+      conversationId: typeof update.conversation_id === "string" ? update.conversation_id : null,
+      delta: update.text_delta
+    };
+  }
+  if (envelope.event === "result") {
+    const result = record(envelope.result);
+    return result ? { event: "result", result } : null;
+  }
+  return { event: "other" };
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.min(value, Number.MAX_SAFE_INTEGER) : 0;
+}
+function normalizeUsage(raw) {
+  const source = record(raw) ?? {};
+  const input = finite(source.input_tokens);
+  const output = finite(source.output_tokens);
+  const cacheRead = finite(source.cache_read_tokens);
+  const reasoningTokens = finite(source.thinking_tokens);
+  const usage = {
+    input,
+    output,
+    cacheRead,
+    cacheWrite: 0,
+    totalTokens: finite(source.total_tokens) || input + output + reasoningTokens,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  };
+  if (reasoningTokens > 0) usage.reasoningTokens = reasoningTokens;
+  return usage;
+}
+function appendBoundedText(current, delta) {
+  if (Buffer.byteLength(current, "utf8") + Buffer.byteLength(delta, "utf8") > ANTIGRAVITY_MAX_RESPONSE_BYTES) {
+    throw new Error(`Antigravity response exceeded ${ANTIGRAVITY_MAX_RESPONSE_BYTES} bytes`);
+  }
+  return current + delta;
+}
+function boundedProviderField(value, field) {
+  if (typeof value !== "string") return "";
+  if (Buffer.byteLength(value, "utf8") > ANTIGRAVITY_MAX_RESPONSE_BYTES) {
+    throw new Error(`Antigravity terminal ${field} exceeded ${ANTIGRAVITY_MAX_RESPONSE_BYTES} bytes`);
+  }
+  return value;
+}
+function boundedConversationId(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  return Buffer.byteLength(value, "utf8") <= MAX_CONVERSATION_ID_BYTES ? value : null;
+}
+function protocolFailure(state, detail) {
+  if (state.protocolDiagnostics.length < MAX_PROTOCOL_DIAGNOSTICS) state.protocolDiagnostics.push(detail);
+}
+function emitTextDelta(emit, state, delta) {
+  if (delta.length === 0) return;
+  state.text = appendBoundedText(state.text, delta);
+  if (!state.started) {
+    state.started = true;
+    emit({
+      type: "message_start",
+      message: buildAssistantMessage({
+        model: state.model,
+        text: "",
+        result: null,
+        conversationId: null,
+        exitCode: 0,
+        aborted: false,
+        diagnostic: ""
+      })
+    });
+  }
+  emit({
+    type: "message_update",
+    assistantMessageEvent: { type: "text_delta", contentIndex: 0, delta }
+  });
+}
+async function readStream(child, emit, state, requestedConversationId) {
+  for await (const bounded of readBoundedLines(child.stdout, {
+    maxLineBytes: ANTIGRAVITY_MAX_STREAM_LINE_BYTES,
+    maxTotalBytes: ANTIGRAVITY_MAX_STREAM_BYTES
+  })) {
+    if (bounded.kind === "oversized") {
+      protocolFailure(state, "oversized structured output line");
+      continue;
+    }
+    const line = bounded.line;
+    if (!line.trim()) continue;
+    const event = parseAntigravityStreamLine(line);
+    if (!event) {
+      protocolFailure(state, "unreadable structured output line");
+      continue;
+    }
+    if (state.terminalSeen) {
+      protocolFailure(state, "event after terminal result");
+      continue;
+    }
+    switch (event.event) {
+      case "init":
+        if (state.initSeen) {
+          protocolFailure(state, "duplicate init event");
+          break;
+        }
+        state.initSeen = true;
+        if (requestedConversationId && event.conversationId !== requestedConversationId) {
+          protocolFailure(state, "requested conversation was not resumed");
+        }
+        state.conversationId = boundedConversationId(event.conversationId);
+        if (event.model?.trim()) state.model = event.model.trim();
+        break;
+      case "text":
+        if (!state.initSeen) {
+          protocolFailure(state, "text event before init");
+          break;
+        }
+        state.conversationId = boundedConversationId(event.conversationId) ?? state.conversationId;
+        emitTextDelta(emit, state, event.delta);
+        break;
+      case "result":
+        if (!state.initSeen) {
+          protocolFailure(state, "terminal result before init");
+          break;
+        }
+        state.terminalSeen = true;
+        state.result = event.result;
+        state.conversationId = boundedConversationId(event.result.conversation_id) ?? state.conversationId;
+        break;
+      case "other":
+        if (!state.initSeen) protocolFailure(state, "event before init");
+        break;
+    }
+  }
+}
+function resultDiagnostic(input) {
+  if (input.aborted) return "Antigravity run was cancelled";
+  if (input.spawnError) return input.spawnError;
+  if (input.streamError) return input.streamError;
+  if (input.protocolDiagnostics.length > 0) {
+    return `Antigravity structured output violated the protocol: ${input.protocolDiagnostics.join("; ")}`;
+  }
+  if (input.result === null) {
+    return "Antigravity CLI ended without a terminal stream result. Update `agy` and verify stream-json support.";
+  }
+  if (input.result.status !== "SUCCESS") {
+    const providerError = boundedProviderField(input.result.error, "error").trim();
+    return providerError || `Antigravity returned terminal status ${String(input.result.status ?? "missing")}`;
+  }
+  if (input.exitCode !== 0) return `Antigravity returned SUCCESS but exited with status ${input.exitCode}`;
+  if (typeof input.result.response !== "string") return "Antigravity SUCCESS result omitted its required response";
+  return "";
+}
+function buildAssistantMessage(input) {
+  const succeeded = !input.aborted && input.exitCode === 0 && input.result?.status === "SUCCESS" && typeof input.result.response === "string" && input.diagnostic.length === 0;
+  const message = {
+    role: "assistant",
+    content: [{ type: "text", text: input.text }],
+    api: "external-agent-subprocess",
+    provider: "antigravity",
+    model: input.model,
+    usage: normalizeUsage(input.result?.usage),
+    stopReason: input.aborted ? "aborted" : succeeded ? "stop" : "error",
+    timestamp: Date.now()
+  };
+  if (input.conversationId) message.responseId = input.conversationId;
+  if (input.diagnostic) message.errorMessage = boundedExternalDiagnostic(input.diagnostic);
+  return message;
+}
+function startAntigravityWorkerRun(input, emit, dependencies = {}) {
+  const sourceEnv = dependencies.environment ?? process.env;
+  const args = buildAgyArgs(input, sourceEnv);
+  const stdinLine = buildAgyStdinLine(input);
+  const workspaceRoot = dependencies.workspaceRoot ?? process.cwd();
+  const cwd = resolveSafeCwd(input.cwd, workspaceRoot);
+  const child = spawn2(dependencies.binary ?? ANTIGRAVITY_BINARY, args, {
+    cwd,
+    env: buildSafeToolEnv({}, sourceEnv),
+    detached: process.platform !== "win32",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const streamState = {
+    started: false,
+    text: "",
+    model: input.wireModelId,
+    result: null,
+    conversationId: null,
+    initSeen: false,
+    terminalSeen: false,
+    protocolDiagnostics: []
+  };
+  let aborted = false;
+  let spawnError = "";
+  let streamError = "";
+  const terminator = createProcessTreeTerminator(child, dependencies.killGraceMs ?? 1500);
+  const abort = () => {
+    if (child.exitCode !== null) return;
+    aborted = true;
+    terminator.terminate();
+  };
+  const onAbort = () => abort();
+  if (input.signal?.aborted) abort();
+  else input.signal?.addEventListener("abort", onAbort, { once: true });
+  child.once("error", (cause) => {
+    spawnError = cause.code === "ENOENT" ? "Antigravity CLI (`agy`) is not installed or not on PATH." : boundedExternalDiagnostic(cause.message);
+  });
+  child.stdin.on("error", (cause) => {
+    if (!aborted) spawnError ||= boundedExternalDiagnostic(`could not send work order to Antigravity: ${cause.message}`);
+  });
+  child.stdin.end(stdinLine);
+  const promise = (async () => {
+    emit({ type: "agent_start" });
+    try {
+      const stderrPromise = readStderr(child);
+      const stdoutPromise = readStream(child, emit, streamState, input.sessionId).catch((cause) => {
+        streamError = boundedExternalDiagnostic(cause instanceof Error ? cause.message : String(cause));
+        terminator.terminate();
+      });
+      const exitCode = await waitForClose(child);
+      await stdoutPromise;
+      const stderr = await stderrPromise.catch(
+        (cause) => boundedExternalDiagnostic(cause instanceof Error ? cause.message : String(cause))
+      );
+      let terminalResponse = "";
+      try {
+        terminalResponse = boundedProviderField(streamState.result?.response, "response");
+      } catch (cause) {
+        streamError ||= boundedExternalDiagnostic(cause instanceof Error ? cause.message : String(cause));
+      }
+      let diagnostic = "";
+      try {
+        diagnostic = resultDiagnostic({
+          result: streamState.result,
+          exitCode,
+          spawnError,
+          stderr,
+          protocolDiagnostics: streamState.protocolDiagnostics,
+          streamError,
+          aborted
+        });
+      } catch (cause) {
+        diagnostic = boundedExternalDiagnostic(cause instanceof Error ? cause.message : String(cause));
+      }
+      const finalText = terminalResponse || streamState.text;
+      const finalMessage = buildAssistantMessage({
+        model: streamState.model,
+        text: finalText,
+        result: streamState.result,
+        conversationId: streamState.conversationId,
+        exitCode,
+        aborted,
+        diagnostic
+      });
+      if (!streamState.started) emit({ type: "message_start", message: finalMessage });
+      emit({ type: "message_end", message: finalMessage });
+      const messages = [finalMessage];
+      emit({ type: "agent_end", messages });
+      if (finalMessage.stopReason === "error" && diagnostic && !aborted) {
+        process.stderr.write(`[worker:antigravity-code] ${boundedExternalDiagnostic(diagnostic)}
+`);
+      }
+      return { messages, exitCode: finalMessage.stopReason === "stop" ? 0 : 1 };
+    } finally {
+      terminator.cleanup();
+      input.signal?.removeEventListener("abort", onAbort);
+    }
+  })();
+  return { promise, abort };
+}
+
+// src/engine/claude/subprocess-runtime.ts
+init_esm_shims();
+import { spawn as spawn3 } from "node:child_process";
+
+// src/engine/claude/session-id.ts
+init_esm_shims();
+var CLAUDE_CODE_SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isClaudeCodeSessionId(value) {
+  return typeof value === "string" && CLAUDE_CODE_SESSION_ID_PATTERN.test(value.trim());
+}
+
+// src/engine/claude/subprocess-runtime.ts
+var READ_ONLY_CLAUDE_TOOLS = ["Read", "Grep", "Glob", "LS", "WebFetch", "WebSearch"];
+var CLAUDE_BINARY = "claude";
+var CLAUDE_MAX_STREAM_LINE_BYTES = 1024 * 1024;
+var CLAUDE_MAX_STREAM_BYTES = 8 * 1024 * 1024;
+function claudeSubprocessPermissionConfigForAutonomy(level, env = process.env) {
+  if (level === "full-auto" && env.CLIO_CODER_ALLOW_EXTERNAL_FULL_ACCESS === "1") {
+    return {
+      permissionMode: "bypassPermissions",
+      extraArgs: ["--allow-dangerously-skip-permissions"],
+      dangerousBypass: true
+    };
+  }
+  if (level === "read-only") {
+    return {
+      permissionMode: "plan",
+      extraArgs: ["--tools", READ_ONLY_CLAUDE_TOOLS.join(",")],
+      dangerousBypass: false
+    };
+  }
+  if (level === "suggest") {
+    throw new Error(
+      "claude-code runtime cannot enforce autonomy 'suggest': it cannot park tool calls for approval. Dispatch to a native or claude-sdk worker, or use read-only or auto-edit."
+    );
+  }
+  if (level === "auto-edit") {
+    return { permissionMode: "acceptEdits", extraArgs: [], dangerousBypass: false };
+  }
+  return { permissionMode: "default", extraArgs: [], dangerousBypass: false };
+}
+function buildClaudeCodePrompt(input) {
+  const parts = (input.dynamicPromptMessages ?? []).map((message) => message.body.trim()).filter(Boolean);
+  parts.push(input.task);
+  return parts.join("\n\n");
+}
+function buildClaudeCodeArgs(input, gateEnv = process.env) {
+  assertToolProfileEnforceable(input.toolProfile, "claude-code");
+  const permission = claudeSubprocessPermissionConfigForAutonomy(input.autonomy, gateEnv);
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--include-partial-messages",
+    "--no-session-persistence",
+    "--permission-mode",
+    permission.permissionMode,
+    ...permission.extraArgs
+  ];
+  if (input.wireModelId.trim().length > 0) args.push("--model", input.wireModelId);
+  const systemPrompt = input.systemPrompt.trim();
+  if (systemPrompt.length > 0) args.push("--append-system-prompt", systemPrompt);
+  if (isClaudeCodeSessionId(input.sessionId)) args.push("--session-id", input.sessionId.trim());
+  return args;
+}
+function finite2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function normalizeUsage2(raw, totalCostUsd = 0) {
+  const record2 = typeof raw === "object" && raw !== null ? raw : {};
+  const input = finite2(record2.input_tokens) + finite2(record2.inputTokens) + finite2(record2.input) + finite2(record2.prompt_tokens) + finite2(record2.promptTokens);
+  const output = finite2(record2.output_tokens) + finite2(record2.outputTokens) + finite2(record2.output) + finite2(record2.completion_tokens) + finite2(record2.completionTokens);
+  const cacheRead = finite2(record2.cache_read_input_tokens) + finite2(record2.cacheReadInputTokens) + finite2(record2.cacheRead) + finite2(record2.cacheReadTokens);
+  const cacheWrite = finite2(record2.cache_creation_input_tokens) + finite2(record2.cacheCreationInputTokens) + finite2(record2.cacheWrite) + finite2(record2.cacheWriteTokens);
+  const totalTokens = input + output + cacheRead + cacheWrite;
+  const total = finite2(totalCostUsd) + finite2(record2.costUSD) + finite2(record2.cost_usd);
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    totalTokens,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total }
+  };
+}
+function nestedRecord(record2, key) {
+  const value = record2[key];
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function extractContentText(content) {
+  if (!Array.isArray(content)) return "";
+  let out = "";
+  for (const block of content) {
+    if (typeof block !== "object" || block === null) continue;
+    const record2 = block;
+    if (record2.type === "text" && typeof record2.text === "string") out += record2.text;
+  }
+  return out;
+}
+function extractDelta(record2) {
+  const delta = nestedRecord(record2, "delta");
+  if (delta && typeof delta.text === "string") return delta.text;
+  if (delta && typeof delta.thinking === "string") return "";
+  const contentBlock = nestedRecord(record2, "content_block");
+  if (contentBlock && contentBlock.type === "text" && typeof contentBlock.text === "string") return contentBlock.text;
+  if (typeof record2.delta === "string") return record2.delta;
+  return "";
+}
+function assistantTextFromEvent(record2) {
+  const message = nestedRecord(record2, "message");
+  if (message) return extractContentText(message.content);
+  return extractContentText(record2.content);
+}
+function resultText(record2) {
+  if (!record2) return "";
+  return typeof record2.result === "string" ? record2.result : "";
+}
+function resultError(record2, stderr) {
+  if (record2) {
+    if (typeof record2.error === "string") return record2.error;
+    if (Array.isArray(record2.errors)) return record2.errors.map(String).join("; ");
+    if (record2.subtype !== void 0 && record2.subtype !== "success") return String(record2.subtype);
+  }
+  return stderr.trim();
+}
+function buildAssistantMessage2(input) {
+  const transportError = input.transportError ?? "";
+  const failed = input.exitCode !== 0 || transportError.length > 0;
+  const errorMessage = !failed ? "" : transportError || resultError(input.result, input.stderr);
+  const message = {
+    role: "assistant",
+    content: [{ type: "text", text: input.text }],
+    api: "claude-code-subprocess",
+    provider: "anthropic",
+    model: input.model,
+    usage: normalizeUsage2(input.result?.usage, finite2(input.result?.total_cost_usd)),
+    stopReason: input.aborted ? "aborted" : failed ? "error" : "stop",
+    timestamp: Date.now()
+  };
+  if (typeof input.result?.request_id === "string") message.responseId = input.result.request_id;
+  if (typeof input.result?.model === "string") message.responseModel = input.result.model;
+  if (errorMessage.length > 0) message.errorMessage = boundedExternalDiagnostic(errorMessage);
+  return message;
+}
+function emitTextDelta2(emit, state, delta) {
+  if (delta.length === 0) return;
+  state.text += delta;
+  const message = buildAssistantMessage2({
+    model: state.model,
+    text: state.text,
+    result: null,
+    exitCode: 0,
+    aborted: false,
+    stderr: ""
+  });
+  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
+    }
+  });
+}
+async function readJsonLines(child, emit, state) {
+  for await (const bounded of readBoundedLines(child.stdout, {
+    maxLineBytes: CLAUDE_MAX_STREAM_LINE_BYTES,
+    maxTotalBytes: CLAUDE_MAX_STREAM_BYTES
+  })) {
+    if (bounded.kind === "oversized") {
+      throw new Error(`claude stream-json line exceeded ${CLAUDE_MAX_STREAM_LINE_BYTES} bytes`);
+    }
+    const trimmed = bounded.line.trim();
+    if (trimmed.length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) continue;
+    const record2 = parsed;
+    if (record2.type === "system" && typeof record2.model === "string") state.model = record2.model;
+    if (record2.type === "result") {
+      state.result = record2;
+      continue;
+    }
+    if (record2.type === "assistant") {
+      const text = assistantTextFromEvent(record2);
+      if (text.length > 0 && text.length >= state.text.length) state.text = text;
+      continue;
+    }
+    emitTextDelta2(emit, state, extractDelta(record2));
+  }
+}
+function startClaudeCodeWorkerRun(input, emit, dependencies = {}) {
+  const sourceEnv = dependencies.environment ?? process.env;
+  const args = buildClaudeCodeArgs(input, sourceEnv);
+  const prompt = buildClaudeCodePrompt(input);
+  const workspaceRoot = dependencies.workspaceRoot ?? process.cwd();
+  const cwd = resolveSafeCwd(input.cwd, workspaceRoot);
+  const child = spawn3(dependencies.binary ?? CLAUDE_BINARY, args, {
+    cwd,
+    env: buildSafeToolEnv({}, sourceEnv),
+    detached: process.platform !== "win32",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const streamState = {
+    started: false,
+    text: "",
+    model: input.wireModelId,
+    result: null
+  };
+  let aborted = false;
+  let settled = false;
+  let transportError = "";
+  const terminator = createProcessTreeTerminator(child, dependencies.killGraceMs ?? 1500);
+  const abort = () => {
+    if (settled) return;
+    aborted = true;
+    terminator.terminate();
+  };
+  const onAbort = () => abort();
+  if (input.signal?.aborted) abort();
+  else input.signal?.addEventListener("abort", onAbort, { once: true });
+  child.once("error", (cause) => {
+    transportError ||= cause.code === "ENOENT" ? "Claude Code CLI (`claude`) is not installed or not on PATH." : cause.message;
+  });
+  child.stdin.on("error", (cause) => {
+    if (!aborted) transportError ||= `could not send prompt to Claude Code CLI: ${cause.message}`;
+  });
+  child.stdin.end(prompt);
+  const promise = (async () => {
+    emit({ type: "agent_start" });
+    try {
+      const stderrPromise = readStderr(child);
+      const stdoutPromise = readJsonLines(child, emit, streamState).catch((cause) => {
+        transportError ||= cause instanceof Error ? cause.message : String(cause);
+        terminator.terminate();
+      });
+      const exitCode = await waitForClose(child);
+      await stdoutPromise;
+      const stderr = await stderrPromise.catch(() => "");
+      const finalText = streamState.text || resultText(streamState.result) || (exitCode === 0 ? "" : resultError(streamState.result, stderr));
+      const finalMessage = buildAssistantMessage2({
+        model: streamState.model,
+        text: finalText,
+        result: streamState.result,
+        exitCode,
+        aborted,
+        stderr,
+        transportError
+      });
+      if (!streamState.started) emit({ type: "message_start", message: finalMessage });
+      emit({ type: "message_end", message: finalMessage });
+      const messages = [finalMessage];
+      emit({ type: "agent_end", messages });
+      if (finalMessage.stopReason === "error" && finalMessage.errorMessage && !aborted) {
+        process.stderr.write(`[worker:claude-code] ${finalMessage.errorMessage}
+`);
+      }
+      return { messages, exitCode: finalMessage.stopReason === "stop" ? 0 : 1 };
+    } finally {
+      settled = true;
+      terminator.cleanup();
+      input.signal?.removeEventListener("abort", onAbort);
+    }
+  })();
+  return { promise, abort };
+}
+
+// src/domains/agents/result-contract-filesystem.ts
+init_esm_shims();
+import { existsSync, readFileSync, statSync } from "node:fs";
+function nodeResultContractFilesystem() {
+  return {
+    readFile(filePath) {
+      try {
+        return readFileSync(filePath, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    pathExists(filePath) {
+      return existsSync(filePath);
+    },
+    isDirectory(filePath) {
+      return statSync(filePath, { throwIfNoEntry: false })?.isDirectory() === true;
+    }
+  };
+}
+
+// src/domains/safety/run-effects.ts
+init_esm_shims();
+import path from "node:path";
+var ENUMERABLE_ACTION_CLASSES = /* @__PURE__ */ new Set(["read", "write"]);
+function toolWritesOpaquely(toolName) {
+  return !ENUMERABLE_ACTION_CLASSES.has(classify({ tool: toolName }).actionClass);
+}
+var GIT_PATH_MUTATIONS = /* @__PURE__ */ new Set(["mv", "rm"]);
+function gitPathOperands(command) {
+  const targets = [];
+  for (const segment of commandArgumentSegments(command)) {
+    if (segment[0] !== "git") continue;
+    const subcommand = segment[1];
+    if (subcommand === void 0 || !GIT_PATH_MUTATIONS.has(subcommand)) continue;
+    for (const token of segment.slice(2)) {
+      if (token.startsWith("-")) continue;
+      targets.push(token);
+    }
+  }
+  return targets;
+}
+function commandOf(args) {
+  const command = args?.command;
+  return typeof command === "string" && command.length > 0 ? command : null;
+}
+function mutationTargets(toolName, args) {
+  if (toolName !== ToolNames.Bash) return toolMutationPaths(toolName, args);
+  const command = commandOf(args);
+  if (command === null) return [];
+  return [...extractCommandWriteTargets(command), ...extractCommandDeleteTargets(command), ...gitPathOperands(command)];
+}
+function validationCommandOf(toolName, args, scope) {
+  if (toolName === ToolNames.Bash) {
+    const command = commandOf(args);
+    if (command === null) return null;
+    const detected = detectValidationCommand(command, scope);
+    return detected.kind === "validation" ? detected.matched : null;
+  }
+  return typedValidationSummary(toolName, { args: args ?? {} });
+}
+function createRunEffectsRecorder(cwd, options = {}) {
+  const pending = /* @__PURE__ */ new Map();
+  const mutatedPaths = /* @__PURE__ */ new Set();
+  const failedMutationPaths = /* @__PURE__ */ new Set();
+  const validationCommands = /* @__PURE__ */ new Set();
+  const verificationCommands = /* @__PURE__ */ new Set();
+  const writeRecordDowngrades = /* @__PURE__ */ new Map();
+  return {
+    start(toolCallId, toolName, args) {
+      const paths = mutationTargets(toolName, args);
+      const validationCommand = validationCommandOf(toolName, args, "finish-contract");
+      const verificationCommand = validationCommandOf(toolName, args, "grounding");
+      const opaque = toolWritesOpaquely(toolName);
+      if (!opaque && paths.length === 0 && validationCommand === null && verificationCommand === null) return;
+      const base = typeof args?.cwd === "string" && args.cwd.length > 0 ? path.resolve(cwd, args.cwd) : cwd;
+      pending.set(toolCallId, {
+        tool: toolName,
+        toolCallId,
+        paths: paths.map((target) => path.resolve(base, target)),
+        validationCommand,
+        verificationCommand,
+        opaque
+      });
+    },
+    finish(toolCallId, failed) {
+      const effects = pending.get(toolCallId);
+      pending.delete(toolCallId);
+      if (effects === void 0) return;
+      if (failed) {
+        for (const target of effects.paths) failedMutationPaths.add(target);
+        return;
+      }
+      if (effects.opaque) {
+        const downgrade = {
+          reason: "opaque_tool_succeeded",
+          tool: effects.tool,
+          toolCallId: effects.toolCallId
+        };
+        const recordWasComplete = writeRecordDowngrades.size === 0;
+        writeRecordDowngrades.set(effects.toolCallId, downgrade);
+        if (recordWasComplete) options.onWriteRecordDowngraded?.({ ...downgrade });
+      }
+      for (const target of effects.paths) mutatedPaths.add(target);
+      if (effects.validationCommand !== null) validationCommands.add(effects.validationCommand);
+      if (effects.verificationCommand !== null) verificationCommands.add(effects.verificationCommand);
+    },
+    snapshot() {
+      return {
+        mutatedPaths: new Set(mutatedPaths),
+        failedMutationPaths: new Set([...failedMutationPaths].filter((target) => !mutatedPaths.has(target))),
+        validationCommands: new Set(validationCommands),
+        verificationCommands: new Set(verificationCommands),
+        writeRecordComplete: writeRecordDowngrades.size === 0,
+        writeRecordDowngrades: [...writeRecordDowngrades.values()].map((entry) => ({ ...entry }))
+      };
+    }
+  };
+}
+
+// src/engine/claude/tool-safety.ts
+init_esm_shims();
+import nodePath from "node:path";
+import { performance } from "node:perf_hooks";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(record2, ...keys) {
+  for (const key of keys) {
+    const value = record2[key];
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return void 0;
+}
+function pathArgs(input) {
+  const path2 = stringField(input, "file_path", "filePath", "path", "notebook_path", "source", "target");
+  return path2 ? { ...input, path: path2 } : { ...input };
+}
+function searchArgs(input, globKey) {
+  const base = stringField(input, "path", "file_path", "filePath");
+  const glob = globKey === null ? void 0 : stringField(input, globKey);
+  if (glob !== void 0 && (nodePath.isAbsolute(glob) || glob.split("/").includes(".."))) {
+    const literal = glob.split("/");
+    const firstMagic = literal.findIndex((segment) => /[*?[\]{}]/u.test(segment));
+    const prefix = (firstMagic === -1 ? literal.slice(0, -1) : literal.slice(0, firstMagic)).join("/") || "/";
+    return { ...input, path: base === void 0 || nodePath.isAbsolute(prefix) ? prefix : nodePath.join(base, prefix) };
+  }
+  return base === void 0 ? { ...input } : { ...input, path: base };
+}
+function commandArgs(input, cwd) {
+  const command = stringField(input, "command", "cmd", "shell", "input", "description") ?? JSON.stringify(input);
+  return { ...input, command, cwd: stringField(input, "cwd") ?? cwd };
+}
+function dynamicToolName(name) {
+  return name.trim().length > 0 ? `claude:${name}` : "claude:unknown";
+}
+var CLAUDE_TOOL_TO_CLIO = {
+  Bash: ToolNames.Bash,
+  Read: ToolNames.Read,
+  NotebookRead: ToolNames.Read,
+  Edit: ToolNames.Edit,
+  MultiEdit: ToolNames.Edit,
+  Write: ToolNames.Write,
+  Grep: ToolNames.Grep,
+  Glob: ToolNames.Find,
+  LS: ToolNames.Ls,
+  Ls: ToolNames.Ls,
+  WebFetch: ToolNames.WebFetch,
+  WebSearch: ToolNames.WebFetch,
+  Task: ToolNames.Dispatch,
+  // TodoWrite mediates as the tasks tool: both are session-scoped plan
+  // bookkeeping that never mutates the workspace, so it classifies read and
+  // is narrowed away exactly when the profile lacks tasks.
+  TodoWrite: ToolNames.Tasks
+};
+var CLAUDE_CANONICAL_TOOLS = new Set(Object.values(CLAUDE_TOOL_TO_CLIO));
+function isClaudeCanonicalTool(name) {
+  return CLAUDE_CANONICAL_TOOLS.has(name);
+}
+function claudeToolsOutsideProfile(allowedTools) {
+  return Object.entries(CLAUDE_TOOL_TO_CLIO).filter(([, clioName]) => !allowedTools.has(clioName)).map(([claudeName]) => claudeName);
+}
+function mapClaudeToolCall(toolName, input, cwd) {
+  switch (toolName) {
+    case "Bash":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Bash, args: commandArgs(input, cwd), known: true };
+    case "Read":
+    case "NotebookRead":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Read, args: pathArgs(input), known: true };
+    case "Edit":
+    case "MultiEdit":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Edit, args: pathArgs(input), known: true };
+    case "Write":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Write, args: pathArgs(input), known: true };
+    case "Grep":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Grep, args: searchArgs(input, "glob"), known: true };
+    case "Glob":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Find, args: searchArgs(input, "pattern"), known: true };
+    case "LS":
+    case "Ls":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Ls, args: searchArgs(input, null), known: true };
+    case "WebFetch":
+    case "WebSearch":
+      return { claudeToolName: toolName, clioToolName: ToolNames.WebFetch, args: { ...input }, known: true };
+    case "Task":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Dispatch, args: { ...input }, known: true };
+    case "TodoWrite":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Tasks, args: { ...input }, known: true };
+    default:
+      return { claudeToolName: toolName, clioToolName: dynamicToolName(toolName), args: { ...input }, known: false };
+  }
+}
+function readsOutsideWorkspace(decision) {
+  return decision.policy?.readScope === "outside-workspace";
+}
+function toAutonomyBlock(decision, level, call) {
+  const actionClass = decision.classification.actionClass;
+  return {
+    kind: "block",
+    classification: decision.classification,
+    rejection: autonomyDenyRejection(level, call.tool, actionClass, readsOutsideWorkspace(decision)),
+    ...decision.policy !== void 0 ? { policy: decision.policy } : {}
+  };
+}
+function toAutonomyAsk(decision, level, call) {
+  const actionClass = decision.classification.actionClass;
+  return {
+    kind: "ask",
+    classification: decision.classification,
+    rejection: autonomyAskRejection(level, call.tool, actionClass, void 0, readsOutsideWorkspace(decision)),
+    ...decision.policy !== void 0 ? { policy: decision.policy } : {}
+  };
+}
+function rejectionText(decision) {
+  if (decision.kind === "allow") return decision.policy?.reasonCode ?? "allowed";
+  return decision.rejection.short;
+}
+function budgetDenial(input, mapped, call, reason) {
+  const classification = input.safety.classify(call);
+  const rejection = { short: reason, detail: reason, hints: [] };
+  const blocked = { kind: "block", classification, rejection };
+  input.safety.audit.recordToolCall?.({
+    tool: mapped.clioToolName,
+    classification,
+    decision: "denied",
+    args: mapped.args,
+    reasons: [reason],
+    reasonCode: "worker-budget"
+  });
+  return {
+    kind: "deny",
+    mapped,
+    decision: blocked,
+    reason,
+    reasonCode: "worker-budget",
+    permissionRequired: false
+  };
+}
+function evaluateClaudeToolPermission(input) {
+  const mapped = mapClaudeToolCall(input.toolName, input.input, input.cwd);
+  const call = { tool: mapped.clioToolName, args: mapped.args };
+  const attempt = input.budgetGate?.attempt(mapped.clioToolName);
+  if (attempt?.kind === "deny") return budgetDenial(input, mapped, call, attempt.reason);
+  if (input.allowedTools !== void 0 && mapped.known && !input.allowedTools.has(mapped.clioToolName)) {
+    const classification = input.safety.classify(call);
+    const rejection = {
+      short: `${mapped.clioToolName} is not in this worker's tool profile`,
+      detail: `Tool '${mapped.clioToolName}' is outside the dispatched worker's admitted tool surface, so the request is denied. Use only the tools granted to this run.`,
+      hints: []
+    };
+    const blocked = { kind: "block", classification, rejection };
+    input.safety.audit.recordToolCall?.({
+      tool: mapped.clioToolName,
+      classification,
+      decision: "denied",
+      args: mapped.args,
+      reasons: [rejection.detail],
+      reasonCode: "tool-profile"
+    });
+    return {
+      kind: "deny",
+      mapped,
+      decision: blocked,
+      reason: rejection.short,
+      reasonCode: "tool-profile",
+      permissionRequired: false
+    };
+  }
+  const decision = input.safety.evaluate(call);
+  const level = input.autonomy ?? DEFAULT_AUTONOMY_LEVEL;
+  if (decision.kind === "block") {
+    return { kind: "deny", mapped, decision, reason: rejectionText(decision), permissionRequired: false };
+  }
+  if (decision.kind === "ask") {
+    if (level === "read-only") {
+      const blocked = toAutonomyBlock(decision, level, call);
+      return {
+        kind: "deny",
+        mapped,
+        decision: blocked,
+        reason: rejectionText(blocked),
+        reasonCode: `autonomy:${level}`,
+        permissionRequired: false
+      };
+    }
+    return { kind: "deny", mapped, decision, reason: rejectionText(decision), permissionRequired: true };
+  }
+  const actionClass = decision.classification.actionClass;
+  const disposition = mapAutonomy(level, actionClass, {
+    executeRecognized: decision.policy?.execRecognition !== "unrecognized",
+    ...readsOutsideWorkspace(decision) ? { readOutsideWorkspace: true } : {}
+  });
+  if (disposition === "allow") {
+    const admission = input.budgetGate?.admit(mapped.clioToolName);
+    if (admission?.kind === "deny") return budgetDenial(input, mapped, call, admission.reason);
+    return { kind: "allow", mapped, decision, reason: decision.policy?.reasonCode ?? "allowed" };
+  }
+  if (disposition === "deny") {
+    const blocked = toAutonomyBlock(decision, level, call);
+    return {
+      kind: "deny",
+      mapped,
+      decision: blocked,
+      reason: rejectionText(blocked),
+      reasonCode: `autonomy:${level}`,
+      permissionRequired: false
+    };
+  }
+  const ask = toAutonomyAsk(decision, level, call);
+  return {
+    kind: "deny",
+    mapped,
+    decision: ask,
+    reason: rejectionText(ask),
+    reasonCode: `autonomy:${level}`,
+    permissionRequired: true
+  };
+}
+function finishDecision(decision) {
+  if (decision.kind === "allow") return "allowed";
+  if (decision.kind === "ask") return "permission_requested";
+  return "blocked";
+}
+function emitToolFinish(emit, mapped, startedAtClock, decision, outcome, reason, reasonCode, toolCallId) {
+  const event = {
+    tool: mapped.clioToolName,
+    ...toolCallId !== void 0 ? { toolCallId } : {},
+    posture: "operating",
+    durationMs: Math.round(performance.now() - startedAtClock),
+    outcome,
+    actionClass: decision.classification.actionClass,
+    decision: finishDecision(decision)
+  };
+  if (reason.length > 0 && outcome !== "ok") event.reason = reason;
+  if (decision.policy?.ruleId !== void 0) event.ruleId = decision.policy.ruleId;
+  const finalReasonCode = reasonCode ?? decision.policy?.reasonCode;
+  if (finalReasonCode !== void 0) event.reasonCode = finalReasonCode;
+  if (decision.policy?.policySource !== void 0) event.policySource = decision.policy.policySource;
+  emit({ type: "clio_coder_tool_finish", payload: event });
+}
+function emitClaudeToolPermissionDecision(input) {
+  const startedAt = Date.now();
+  const startedAtClock = performance.now();
+  const decision = evaluateClaudeToolPermission(input);
+  const toolCallId = input.toolCallId?.trim() ? input.toolCallId : void 0;
+  const action = describeCallAction(decision.mapped.clioToolName, decision.mapped.args);
+  const start = {
+    tool: decision.mapped.clioToolName,
+    ...toolCallId !== void 0 ? { toolCallId } : {},
+    posture: "operating",
+    startedAt,
+    ...action !== null ? { action } : {}
+  };
+  input.emit({ type: "clio_coder_tool_start", payload: start });
+  if (decision.kind === "allow") {
+    emitToolFinish(
+      input.emit,
+      decision.mapped,
+      startedAtClock,
+      decision.decision,
+      "ok",
+      decision.reason,
+      decision.reasonCode,
+      toolCallId
+    );
+    return decision;
+  }
+  if (decision.permissionRequired) {
+    const mode = input.onPermission ?? "deny";
+    input.emit({
+      type: "clio_coder_permission_resolved",
+      payload: {
+        tool: decision.mapped.clioToolName,
+        actionClass: decision.decision.classification.actionClass,
+        mode,
+        reason: mode === "fail" ? `permission required for ${decision.mapped.clioToolName}; workers.onPermission=fail ends this run` : `permission denied by policy: Claude SDK workers run non-interactively; ${decision.reason}`
+      }
+    });
+  }
+  emitToolFinish(
+    input.emit,
+    decision.mapped,
+    startedAtClock,
+    decision.decision,
+    "blocked",
+    decision.reason,
+    decision.reasonCode,
+    toolCallId
+  );
+  return decision;
+}
+function coerceToolInput(value) {
+  return isRecord(value) ? value : {};
+}
+
+export {
+  captureWorkerContext,
+  antigravitySubprocessConfigForAutonomy,
+  startAntigravityWorkerRun,
+  isClaudeCodeSessionId,
+  claudeSubprocessPermissionConfigForAutonomy,
+  startClaudeCodeWorkerRun,
+  isClaudeCanonicalTool,
+  claudeToolsOutsideProfile,
+  emitClaudeToolPermissionDecision,
+  coerceToolInput,
+  WORKER_SPEC_VERSION,
+  WORKER_PROTECTED_ARTIFACT_STATE_VERSION,
+  WORKER_EXIT_PERMISSION_REQUIRED,
+  DEFAULT_ESCALATION_TIMEOUT_MS,
+  DEFAULT_ESCALATION_FALLBACK,
+  serializeWorkerRuntimeDescriptor,
+  parseWorkerSpec,
+  validateRehydratedWorkerRuntime,
+  nodeResultContractFilesystem,
+  createRunEffectsRecorder
+};
+//# sourceMappingURL=chunk-R7FGRZNF.js.map