@iowarp/clio-coder 0.3.0 → 0.3.2

package/dist/chunk-MQSRRFWA.js

@@ -0,0 +1,3428 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  DEFAULT_AUTONOMY_LEVEL,
+  autonomyAskRejection,
+  autonomyDenyRejection,
+  isAutonomyLevel,
+  mapAutonomy,
+  typedValidationSummary
+} from "./chunk-STBPMHSX.js";
+import {
+  ROUTE_POLICY_VERSION,
+  deriveExecutionRole,
+  isExecutionRole,
+  isRouteDecisionAgentSelection,
+  isRoutingIntent,
+  routePriorForLatencyClass,
+  sameRouteIdentity
+} from "./chunk-GGXXDWE4.js";
+import {
+  AGENT_AUTOMATION_AUTHORITIES,
+  agentSpecFingerprint,
+  detectValidationCommand,
+  extractCommandDeleteTargets,
+  extractCommandWriteTargets,
+  tokenizeShellLike,
+  toolMutationPaths
+} from "./chunk-5UUP6MWO.js";
+import {
+  resolveReadPath
+} from "./chunk-OQE5J4C6.js";
+import {
+  isSkillActivation
+} from "./chunk-T6YILFSB.js";
+import {
+  DEFAULT_MAX_LINES,
+  OBSERVATION_POLICY_SLACK_BYTES,
+  OBSERVE_SELF_CAPS,
+  finalizeObservation,
+  formatSize,
+  isSessionOffloadPath,
+  observationBudgetExhausted,
+  reserveObservation,
+  splitLinesForCounting,
+  truncateHead,
+  truncateTail
+} from "./chunk-VAKQQHWR.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames,
+  isBuiltinToolName
+} from "./chunk-CGKSTWHD.js";
+import {
+  THINKING_LEVELS
+} from "./chunk-ZDOOVTXZ.js";
+import {
+  GUARDRAIL_DEFAULTS,
+  GUARDRAIL_ENV_VARS,
+  resolveGuardrail
+} from "./chunk-4ZG3XFUR.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/profiles.ts
+init_esm_shims();
+var TOOL_PROFILE_NAMES = ["minimal-local", "science-local", "full-agent"];
+var CODEWIKI_TOOL_NAMES = [ToolNames.CodeNav];
+var MINIMAL_LOCAL_TOOLS = [
+  ToolNames.Read,
+  ToolNames.Grep,
+  ToolNames.Find,
+  ToolNames.Ls,
+  ToolNames.Git,
+  ToolNames.Context,
+  ToolNames.CodeNav,
+  // A narrowed read-only scout swarm is the surface that most needs to see
+  // what its peers already staked.
+  ToolNames.Ledger
+];
+var SCIENCE_LOCAL_TOOLS = [...MINIMAL_LOCAL_TOOLS, ToolNames.Verify];
+var NARROW_TOOL_PROFILES = {
+  "minimal-local": new Set(MINIMAL_LOCAL_TOOLS),
+  "science-local": new Set(SCIENCE_LOCAL_TOOLS)
+};
+function isToolProfileName(value) {
+  return TOOL_PROFILE_NAMES.includes(value);
+}
+function narrowsToolSurface(profile) {
+  return profile !== void 0 && profile in NARROW_TOOL_PROFILES;
+}
+function assertToolProfileEnforceable(profile, runtimeLabel) {
+  if (narrowsToolSurface(profile)) {
+    throw new Error(
+      `${runtimeLabel} runtime cannot enforce tool_profile '${profile}': it runs its own tool surface without Clio per-tool mediation. Dispatch to a native or claude-sdk worker, or use tool_profile full-agent.`
+    );
+  }
+}
+function applyToolProfile(tools, profile, context) {
+  const unique = uniquePreservingOrder(tools);
+  let profiled;
+  if (profile === void 0 || profile === "full-agent") {
+    profiled = unique;
+  } else {
+    const allowed = NARROW_TOOL_PROFILES[profile];
+    profiled = unique.filter((tool) => isBuiltinToolName(tool) && allowed.has(tool));
+  }
+  return applyCodewikiWorkerPolicy(profiled, context);
+}
+function uniquePreservingOrder(tools) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const tool of tools) {
+    if (seen.has(tool)) continue;
+    seen.add(tool);
+    unique.push(tool);
+  }
+  return unique;
+}
+function isCodewikiTool(tool) {
+  return CODEWIKI_TOOL_NAMES.includes(tool);
+}
+function isNavigationHeavyTask(task) {
+  if (!task) return false;
+  return /\b(?:codewiki|symbol|symbols|entry\s*points?|where\s+is|code_nav|call\s*sites?|references?|imports?|exports?|map|mapping|navigate|navigation|topology|architecture|boundar(?:y|ies)|ownership|trace|locate|find\s+(?:the\s+)?(?:implementation|definition|module|file|path))\b|(?:^|\s)(?:src|tests?|cmd|pkg|lib)\/|\.(?:[cm]?[tj]sx?|py|pyw|go|rs|c|h|cc|cpp|cxx|hpp|hh|hxx|java|rb)\b/i.test(
+    task
+  );
+}
+function applyCodewikiWorkerPolicy(tools, context) {
+  if (!context?.agentId) return tools;
+  if (context.agentId === "scout") return tools;
+  if (isNavigationHeavyTask(context.task)) return tools;
+  return tools.filter((tool) => !isCodewikiTool(tool));
+}
+
+// src/tools/network-policy.ts
+init_esm_shims();
+var NO_NETWORK_TOOLS_ENV = "CLIO_CODER_NO_NETWORK_TOOLS";
+function networkToolsDisabled(env = process.env) {
+  return env[NO_NETWORK_TOOLS_ENV] === "1";
+}
+
+// src/worker/spec-contract.ts
+init_esm_shims();
+
+// src/core/response-schema.ts
+init_esm_shims();
+var RESPONSE_SCHEMA_MAX_SERIALIZED_BYTES = 64 * 1024;
+var RESPONSE_SCHEMA_RUNTIME_ID = "llamacpp";
+function runtimeSpeaksResponseSchemaDialect(runtime) {
+  return runtime.id === RESPONSE_SCHEMA_RUNTIME_ID && runtime.kind === "http" && runtime.apiFamily === "openai-completions";
+}
+function responseSchemaConflictsWithTools(runtime, toolCount) {
+  return toolCount > 0 && runtimeSpeaksResponseSchemaDialect(runtime);
+}
+var UnsupportedResponseSchemaError = class extends Error {
+  code = "UNSUPPORTED_RESPONSE_SCHEMA";
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedResponseSchemaError";
+  }
+};
+function isResponseSchemaRejection(diagnostic) {
+  if (!diagnostic) return false;
+  const text = diagnostic.toLowerCase();
+  if (!/\b(?:400|422)\b|invalid_request_error|bad request/.test(text)) return false;
+  return /grammar|json[ _-]?schema|response[ _-]?format/.test(text);
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+var SUPPORTED_SCHEMA_KEYS = /* @__PURE__ */ new Set(["type", "properties", "required", "items", "additionalProperties"]);
+var SUPPORTED_SCHEMA_TYPES = /* @__PURE__ */ new Set(["object", "array", "string", "number", "integer", "boolean", "null"]);
+function definesToJson(value) {
+  let current = value;
+  while (current) {
+    if (Object.getOwnPropertyDescriptor(current, "toJSON")) return true;
+    current = Object.getPrototypeOf(current);
+  }
+  return false;
+}
+function jsonDataError(value) {
+  const stack = [{ value, path: "$" }];
+  const active = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    if (!frame) break;
+    if (frame.exit) {
+      active.delete(frame.exit);
+      continue;
+    }
+    const current = frame.value;
+    if (current === null || typeof current === "string" || typeof current === "boolean") continue;
+    if (typeof current === "number") {
+      if (!Number.isFinite(current)) return `${frame.path} must be a finite number`;
+      continue;
+    }
+    if (typeof current !== "object") return `${frame.path} contains a non-JSON value`;
+    if (active.has(current)) return `${frame.path} contains a circular reference`;
+    if (!Array.isArray(current) && !isPlainObject(current)) {
+      return `${frame.path} must contain only plain objects and arrays`;
+    }
+    if (definesToJson(current)) {
+      return `${frame.path} must not define toJSON`;
+    }
+    active.add(current);
+    stack.push({ value: null, path: frame.path, exit: current });
+    if (Array.isArray(current)) {
+      const descriptors2 = Object.getOwnPropertyDescriptors(current);
+      for (const [key, descriptor] of Object.entries(descriptors2)) {
+        if (key === "length" || /^(?:0|[1-9]\d*)$/.test(key)) continue;
+        if (descriptor.enumerable) return `${frame.path}.${key} is not a JSON array index`;
+      }
+      for (let index = current.length - 1; index >= 0; index -= 1) {
+        if (!Object.hasOwn(current, index)) return `${frame.path}[${index}] must not be an array hole`;
+        const descriptor = Object.getOwnPropertyDescriptor(current, String(index));
+        if (!descriptor || !("value" in descriptor)) return `${frame.path}[${index}] must be a data property`;
+        stack.push({ value: descriptor.value, path: `${frame.path}[${index}]` });
+      }
+      continue;
+    }
+    for (const symbol of Object.getOwnPropertySymbols(current)) {
+      if (Object.getOwnPropertyDescriptor(current, symbol)?.enumerable) {
+        return `${frame.path} must not contain symbol keys`;
+      }
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(current);
+    const keys = Object.keys(descriptors);
+    for (let index = keys.length - 1; index >= 0; index -= 1) {
+      const key = keys[index];
+      if (key === void 0) continue;
+      const descriptor = descriptors[key];
+      if (!descriptor?.enumerable) continue;
+      if (!("value" in descriptor)) return `${frame.path}.${key} must be a data property`;
+      stack.push({ value: descriptor.value, path: `${frame.path}.${key}` });
+    }
+  }
+  return null;
+}
+function schemaSyntaxError(value) {
+  const stack = [{ schema: value, path: "$" }];
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    if (!frame) break;
+    const { schema, path: path3 } = frame;
+    for (const key of Object.keys(schema)) {
+      if (!SUPPORTED_SCHEMA_KEYS.has(key)) return `${path3}.${key} is not supported by the llama.cpp schema subset`;
+    }
+    if (typeof schema.type !== "string" || !SUPPORTED_SCHEMA_TYPES.has(schema.type)) {
+      return `${path3}.type must be one of ${[...SUPPORTED_SCHEMA_TYPES].join(", ")}`;
+    }
+    if (schema.type === "object") {
+      if (schema.items !== void 0) return `${path3}.items is only valid for array schemas`;
+      if (schema.properties !== void 0 && !isPlainObject(schema.properties)) {
+        return `${path3}.properties must be a plain object`;
+      }
+      const properties = schema.properties ?? {};
+      for (const [name, child] of Object.entries(properties)) {
+        if (!isPlainObject(child)) return `${path3}.properties.${name} must be a schema object`;
+        stack.push({ schema: child, path: `${path3}.properties.${name}` });
+      }
+      if (schema.required !== void 0) {
+        if (!Array.isArray(schema.required) || !schema.required.every((item) => typeof item === "string")) {
+          return `${path3}.required must be an array of strings`;
+        }
+        if (new Set(schema.required).size !== schema.required.length) {
+          return `${path3}.required must not contain duplicates`;
+        }
+        for (const name of schema.required) {
+          if (!Object.hasOwn(properties, name)) return `${path3}.required names unknown property '${name}'`;
+        }
+      }
+      if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties !== "boolean") {
+        return `${path3}.additionalProperties must be a boolean`;
+      }
+      continue;
+    }
+    if (schema.type === "array") {
+      if (!isPlainObject(schema.items)) return `${path3}.items must be a schema object`;
+      if (schema.properties !== void 0 || schema.required !== void 0 || schema.additionalProperties !== void 0) {
+        return `${path3} contains object-only keywords on an array schema`;
+      }
+      stack.push({ schema: schema.items, path: `${path3}.items` });
+      continue;
+    }
+    if (schema.properties !== void 0 || schema.required !== void 0 || schema.items !== void 0 || schema.additionalProperties !== void 0) {
+      return `${path3} contains container keywords on a ${schema.type} schema`;
+    }
+  }
+  return null;
+}
+function responseSchemaValidationError(value, source = "responseSchema") {
+  try {
+    if (!isPlainObject(value)) return `${source} must be a plain object`;
+    const valueError = jsonDataError(value);
+    if (valueError) return `${source} must be JSON-serializable: ${valueError}`;
+    const syntaxError = schemaSyntaxError(value);
+    if (syntaxError) return `${source} is not an enforceable JSON schema: ${syntaxError}`;
+    const serialized = JSON.stringify(value);
+    const bytes = Buffer.byteLength(serialized, "utf8");
+    if (bytes > RESPONSE_SCHEMA_MAX_SERIALIZED_BYTES) {
+      return `${source} must be at most ${RESPONSE_SCHEMA_MAX_SERIALIZED_BYTES} serialized bytes`;
+    }
+    return null;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return `${source} could not be safely inspected: ${detail}`;
+  }
+}
+function assertValidResponseSchema(value, source = "responseSchema") {
+  const error = responseSchemaValidationError(value, source);
+  if (error) throw new Error(error);
+}
+function cloneValidatedResponseSchema(value, source = "responseSchema") {
+  assertValidResponseSchema(value, source);
+  try {
+    const serialized = JSON.stringify(value);
+    if (Buffer.byteLength(serialized, "utf8") > RESPONSE_SCHEMA_MAX_SERIALIZED_BYTES) {
+      throw new Error(`${source} changed while being validated`);
+    }
+    const cloned = JSON.parse(serialized);
+    const cloneError = responseSchemaValidationError(cloned, source);
+    if (cloneError) throw new Error(cloneError);
+    return cloned;
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith(source)) throw error;
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`${source} could not be canonically cloned: ${detail}`);
+  }
+}
+
+// src/worker/spec-contract.ts
+var WORKER_SPEC_VERSION = 3;
+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"
+];
+var RUNTIME_AUTHS = [
+  "api-key",
+  "oauth",
+  "aws-sdk",
+  "vertex-adc",
+  "claude-cli",
+  "none"
+];
+var TOOL_PROFILE_NAMES2 = [
+  "minimal-local",
+  "science-local",
+  "full-agent"
+];
+var WORKER_PRODUCTS = ["orientation"];
+var TARGET_LIFECYCLES = ["user-managed", "clio-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.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);
+  }
+  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 = ["hardCap", "readReserve", "synthesis", "toolCalls"];
+  const actual = Object.keys(budget).sort();
+  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+    throw new Error(`WorkerSpec.budget must contain exactly: ${expected.join(", ")}`);
+  }
+  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.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");
+}
+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");
+  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);
+  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.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_NAMES2);
+  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/dispatch/gate-role-prompts.ts
+init_esm_shims();
+var REVIEWER_GATE_PROMPT = [
+  "You are a strict, read-only reviewer of one implementation run.",
+  "Inspect the supplied result and repository state with read-only tools.",
+  "You cannot modify anything.",
+  "Judge only whether the work passes. Whether a failure earns another attempt is not your decision.",
+  'End with a JSON object only: {"verdict":"pass|fail","checks":[{"name":"...","passed":true,"evidence":"what you inspected and observed"}]}.',
+  "The verdict must agree with every check. Report at least one check."
+].join("\n");
+var JUDGE_GATE_PROMPT = [
+  "You are a strict, read-only judge ranking candidate implementations of the same task.",
+  "Each candidate is a git branch with its work committed; inspect the branches and worktree paths you are given with read tools.",
+  "You cannot modify anything.",
+  'End with a JSON object only: {"winner":<candidate number>,"checks":[{"name":"...","passed":true,"evidence":"what you compared and observed"}]}.',
+  "The winner must be one of the candidate numbers you were given. Report at least one check.",
+  "Report in your checks where the candidates disagreed, covering approach, files touched, and tests, not only which one won."
+].join("\n");
+var COMPETE_STANCES = [
+  "minimal-diff",
+  "test-first",
+  "refactor-tolerant",
+  "spec-literal"
+];
+var COMPETE_STANCE_LINERS = {
+  "minimal-diff": "Prefer the smallest change that satisfies the task; do not restructure surrounding code.",
+  "test-first": "Write or extend a test that fails for the stated reason first, then make it pass.",
+  "refactor-tolerant": "Reshape the surrounding code when the task exposes a bad shape, as long as existing behavior stays covered.",
+  "spec-literal": "Implement exactly what the task text states and nothing it leaves unasked."
+};
+function competeStanceLiner(stance) {
+  return `Compete stance: ${stance}. ${COMPETE_STANCE_LINERS[stance]}`;
+}
+function isBoundedGateRolePrompt(input) {
+  if (input.autonomy !== "read-only") return false;
+  if (input.role === "reviewer") return input.systemPrompt === REVIEWER_GATE_PROMPT;
+  if (input.role === "judge") return input.systemPrompt === JUDGE_GATE_PROMPT;
+  return false;
+}
+
+// src/domains/dispatch/types.ts
+init_esm_shims();
+function isRunOutcomeCode(value) {
+  return value === "vram_capacity_fit_failure" || value === "worker_tool_call_cap_exhausted" || value === "loop_guard_tools_disabled_exhausted" || value === "result_contract_exhausted" || value === "worker_final_output_missing";
+}
+var RETRYABLE_OUTCOMES = /* @__PURE__ */ new Set(["failed", "timed_out", "stalled", "spawn_failed"]);
+function isTerminalRunEnvelope(run) {
+  if (run.endedAt !== null) return true;
+  return run.status !== "queued" && run.status !== "running";
+}
+function runKindSupportsLiveSteering(kind) {
+  return kind === "http" || kind === "sdk";
+}
+
+// src/domains/session/task-board.ts
+init_esm_shims();
+import { randomUUID } from "node:crypto";
+
+// src/domains/session/entries.ts
+init_esm_shims();
+var SESSION_ENTRY_KINDS = [
+  "message",
+  "bashExecution",
+  "custom",
+  "modelChange",
+  "thinkingLevelChange",
+  "fileEntry",
+  "branchSummary",
+  "compactionSummary",
+  "sessionInfo",
+  "label",
+  "protectedArtifact",
+  "skillActivation",
+  "taskLedger",
+  "decisionLedger",
+  "workerRun"
+];
+function isRecord(value) {
+  return !!value && typeof value === "object";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isOptionalBoolean(value) {
+  return value === void 0 || typeof value === "boolean";
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isPositiveInteger(value) {
+  return isNumber(value) && Number.isInteger(value) && value > 0;
+}
+function isOptionalNumber(value) {
+  return value === void 0 || isNumber(value);
+}
+function isNullableString(value) {
+  return value === null || typeof value === "string";
+}
+function isOneOf(value, allowed) {
+  return typeof value === "string" && allowed.includes(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function hasBaseSessionEntryFields(v) {
+  return isString(v.turnId) && isNullableString(v.parentTurnId) && isString(v.timestamp);
+}
+var MESSAGE_ROLES = ["user", "assistant", "tool_call", "tool_result", "system", "checkpoint"];
+var FILE_OPERATIONS = ["read", "write", "edit", "create", "delete"];
+var COMPACTION_TRIGGERS = ["auto", "force", "overflow"];
+var PROTECTED_ARTIFACT_SOURCES = [
+  "validation",
+  "middleware",
+  "user",
+  "session"
+];
+var TASK_LEDGER_STATUSES = ["pending", "active", "completed", "blocked", "cancelled"];
+var TASK_LEDGER_EVIDENCE_STATUSES = [
+  "required",
+  "pending",
+  "passed",
+  "failed",
+  "missing"
+];
+var DECISION_STATUSES = ["active", "superseded"];
+var DECISION_INTERVIEW_STATUSES = ["complete", "cancelled"];
+var WORKER_RUN_ORIGINS = ["user", "agent"];
+var WORKER_RUN_RUNTIME_KINDS = ["clio", "acp", "claude-sdk", "claude-code"];
+function isWorkerRunRuntime(value) {
+  if (!isRecord(value)) return false;
+  return isOneOf(value.kind, WORKER_RUN_RUNTIME_KINDS) && isOptionalString(value.targetId) && isOptionalString(value.wireModelId) && isOptionalString(value.peerId);
+}
+function isTaskLedgerGoal(value) {
+  if (!isRecord(value)) return false;
+  if (!isString(value.id) || !isString(value.title)) return false;
+  if (!isOneOf(value.status, TASK_LEDGER_STATUSES)) return false;
+  if (value.parentGoalId !== void 0 && !isNullableString(value.parentGoalId)) return false;
+  const hasPairedProvenance = value.origin === "user" ? isString(value.userTaskId) && /^u[1-9]\d*$/.test(value.userTaskId) : (value.origin === void 0 || value.origin === "agent") && value.userTaskId === void 0;
+  return isOptionalString(value.description) && hasPairedProvenance;
+}
+function isTaskLedgerEvidence(value) {
+  if (!isRecord(value)) return false;
+  if (!isString(value.id) || !isString(value.description)) return false;
+  if (!isOneOf(value.status, TASK_LEDGER_EVIDENCE_STATUSES)) return false;
+  return isOptionalString(value.command) && isOptionalString(value.artifactPath) && isOptionalString(value.observedAt) && isOptionalString(value.notes);
+}
+function isDecisionRecord(value) {
+  if (!isRecord(value)) return false;
+  if (!isString(value.key) || !/^[a-z0-9]+(?:_[a-z0-9]+)*$/.test(value.key)) return false;
+  if (!isString(value.value) || !isOneOf(value.status, DECISION_STATUSES) || !isString(value.decidedAt)) return false;
+  if (!isOptionalString(value.label) || !isOptionalString(value.source_question)) return false;
+  if (!isOptionalString(value.revisedAt) || !isOptionalString(value.correction)) return false;
+  return value.status === "superseded" ? isString(value.revisedAt) : value.revisedAt === void 0 && value.correction === void 0;
+}
+function isOptionalCompactionUsage(value) {
+  if (value === void 0) return true;
+  if (!isRecord(value)) return false;
+  const cost = value.cost;
+  return isNumber(value.input) && isNumber(value.output) && isNumber(value.cacheRead) && isNumber(value.cacheWrite) && isNumber(value.reasoning) && isNumber(value.totalTokens) && isNumber(value.apiCalls) && isRecord(cost) && isNumber(cost.total);
+}
+function isProtectedArtifact(value) {
+  if (!isRecord(value)) return false;
+  return isString(value.path) && isString(value.protectedAt) && isString(value.reason) && isOneOf(value.source, PROTECTED_ARTIFACT_SOURCES) && isOptionalString(value.validationCommand) && isOptionalNumber(value.validationExitCode);
+}
+function isSessionHeader(value) {
+  if (!isRecord(value)) return false;
+  return value.type === "session" && isPositiveInteger(value.version) && isString(value.id) && isString(value.timestamp) && isString(value.cwd) && isOptionalString(value.parentSession) && isOptionalString(value.parentTurnId);
+}
+function isSessionEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (!hasBaseSessionEntryFields(v)) return false;
+  if (!isOneOf(v.kind, SESSION_ENTRY_KINDS)) return false;
+  switch (v.kind) {
+    case "message":
+      return Object.hasOwn(v, "payload") && isOneOf(v.role, MESSAGE_ROLES);
+    case "bashExecution":
+      return isString(v.command) && isString(v.output) && (v.exitCode === null || isNumber(v.exitCode)) && typeof v.cancelled === "boolean" && typeof v.truncated === "boolean" && isOptionalString(v.fullOutputPath) && isOptionalBoolean(v.excludeFromContext);
+    case "custom":
+      return isString(v.customType) && isOptionalBoolean(v.display);
+    case "modelChange":
+      return isString(v.provider) && isString(v.modelId) && isOptionalString(v.target);
+    case "thinkingLevelChange":
+      return isString(v.thinkingLevel);
+    case "fileEntry":
+      return isString(v.path) && isOneOf(v.operation, FILE_OPERATIONS) && isOptionalNumber(v.bytes) && isOptionalString(v.hash);
+    case "branchSummary":
+      return isString(v.fromTurnId) && isString(v.summary);
+    case "compactionSummary":
+      return isString(v.summary) && isNumber(v.tokensBefore) && isString(v.firstKeptTurnId) && isOptionalCompactionUsage(v.usage) && (v.trigger === void 0 || isOneOf(v.trigger, COMPACTION_TRIGGERS)) && isOptionalNumber(v.tokensAfter) && isOptionalNumber(v.messagesSummarized) && isOptionalBoolean(v.isSplitTurn);
+    case "sessionInfo":
+      return isOptionalString(v.name) && isOptionalString(v.targetTurnId) && isOptionalString(v.label);
+    case "label":
+      return isString(v.targetTurnId) && isOptionalString(v.label);
+    case "protectedArtifact":
+      return v.action === "protect" && isProtectedArtifact(v.artifact) && isOptionalString(v.toolName) && isOptionalString(v.toolCallId) && isOptionalString(v.runId) && isOptionalString(v.correlationId);
+    case "skillActivation":
+      return isSkillActivation(v.activation);
+    case "taskLedger":
+      return isOptionalString(v.boardId) && Array.isArray(v.goals) && v.goals.every(isTaskLedgerGoal) && Array.isArray(v.subgoals) && v.subgoals.every(isTaskLedgerGoal) && isStringArray(v.activeRunIds) && Array.isArray(v.requiredValidationEvidence) && v.requiredValidationEvidence.every(isTaskLedgerEvidence);
+    case "decisionLedger":
+      return isString(v.interviewId) && isOneOf(v.interviewStatus, DECISION_INTERVIEW_STATUSES) && isString(v.startedAt) && isString(v.endedAt) && isNumber(v.roundCount) && Number.isInteger(v.roundCount) && v.roundCount >= 0 && isOptionalString(v.summary) && isOptionalString(v.transcriptPath) && Array.isArray(v.decisions) && v.decisions.every(isDecisionRecord);
+    case "workerRun":
+      return isString(v.assignmentId) && isString(v.runId) && isOneOf(v.origin, WORKER_RUN_ORIGINS) && isString(v.agentId) && isWorkerRunRuntime(v.runtime) && isOptionalString(v.parentToolCallId);
+  }
+  return false;
+}
+
+// src/domains/session/task-board.ts
+var TASK_BOARD_GOAL_ID = "board";
+var LEGACY_TASK_BOARD_ID = "legacy";
+function isOpenUserTask(task) {
+  return task.origin === "user" && (task.status === "pending" || task.status === "active");
+}
+function taskBoardCounts(board) {
+  const counts = {
+    total: board.tasks.length,
+    completed: 0,
+    active: 0,
+    pending: 0,
+    blocked: 0,
+    cancelled: 0,
+    open: 0
+  };
+  for (const task of board.tasks) {
+    if (task.status === "completed") counts.completed += 1;
+    else if (task.status === "active") counts.active += 1;
+    else if (task.status === "pending") counts.pending += 1;
+    else if (task.status === "blocked") counts.blocked += 1;
+    else counts.cancelled += 1;
+  }
+  counts.open = counts.pending + counts.active;
+  return counts;
+}
+function boardStatus(tasks) {
+  const counts = taskBoardCounts({ tasks });
+  if (counts.total === 0) return "pending";
+  if (counts.active > 0) return "active";
+  if (counts.open === 0 && counts.blocked === 0) return "completed";
+  if (counts.blocked > 0 && counts.open === 0) return "blocked";
+  return "pending";
+}
+function toTaskLedgerEntryFields(board, now) {
+  const evidence = [];
+  const subgoals = board.tasks.map((task) => {
+    if (task.status === "completed" && task.evidence) {
+      evidence.push({
+        id: `${task.id}.evidence`,
+        description: task.evidence,
+        status: "passed",
+        observedAt: now.toISOString()
+      });
+    }
+    const goal = {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      parentGoalId: TASK_BOARD_GOAL_ID
+    };
+    if (task.origin) goal.origin = task.origin;
+    if (task.userTaskId) goal.userTaskId = task.userTaskId;
+    if (task.reason) goal.description = task.reason;
+    return goal;
+  });
+  return {
+    kind: "taskLedger",
+    parentTurnId: null,
+    boardId: board.boardId,
+    goals: [{ id: TASK_BOARD_GOAL_ID, title: board.title, status: boardStatus(board.tasks) }],
+    subgoals,
+    activeRunIds: [...board.activeRunIds],
+    requiredValidationEvidence: evidence
+  };
+}
+function isTaskLedgerShaped(value) {
+  return isSessionEntry(value) && value.kind === "taskLedger";
+}
+function foldTaskBoard(entries) {
+  let last = null;
+  for (const raw of entries) {
+    if (isTaskLedgerShaped(raw)) last = toEntryView(raw);
+  }
+  return last;
+}
+function foldSessionTaskHistory(entries) {
+  const boards = /* @__PURE__ */ new Map();
+  for (const [index, raw] of entries.entries()) {
+    if (!isTaskLedgerShaped(raw)) continue;
+    const view = toEntryView(raw);
+    if (!view) continue;
+    const boardId = typeof raw.boardId === "string" && raw.boardId.length > 0 ? raw.boardId : LEGACY_TASK_BOARD_ID;
+    const timestamp = typeof raw.timestamp === "string" ? raw.timestamp : "";
+    if (boardId === LEGACY_TASK_BOARD_ID) {
+      boards.set(boardId, {
+        boardId,
+        title: view.title,
+        tasks: new Map(view.tasks.map((task) => [task.id, task])),
+        lastSnapshotAt: timestamp,
+        lastIndex: index
+      });
+      continue;
+    }
+    const existing = boards.get(boardId);
+    if (!existing) {
+      boards.set(boardId, {
+        boardId,
+        title: view.title,
+        tasks: new Map(view.tasks.map((task) => [task.id, task])),
+        lastSnapshotAt: timestamp,
+        lastIndex: index
+      });
+      continue;
+    }
+    existing.title = view.title;
+    for (const task of view.tasks) existing.tasks.set(task.id, task);
+    existing.lastSnapshotAt = timestamp;
+    existing.lastIndex = index;
+  }
+  return [...boards.values()].sort((left, right) => right.lastIndex - left.lastIndex).map(({ lastIndex: _lastIndex, tasks, ...board }) => ({ ...board, tasks: [...tasks.values()] }));
+}
+function toEntryView(entry) {
+  const boardGoal = entry.goals[0];
+  if (!boardGoal) return null;
+  const evidenceByTask = /* @__PURE__ */ new Map();
+  for (const item of entry.requiredValidationEvidence) {
+    const taskId = item.id.endsWith(".evidence") ? item.id.slice(0, -".evidence".length) : item.id;
+    evidenceByTask.set(taskId, item.description);
+  }
+  return {
+    boardId: entry.boardId ?? LEGACY_TASK_BOARD_ID,
+    title: boardGoal.title,
+    tasks: entry.subgoals.map((goal) => {
+      const task = {
+        id: goal.id,
+        title: goal.title,
+        status: goal.status,
+        origin: goal.origin ?? "agent"
+      };
+      if (goal.userTaskId) task.userTaskId = goal.userTaskId;
+      if (goal.description) task.reason = goal.description;
+      const evidence = evidenceByTask.get(goal.id);
+      if (evidence) task.evidence = evidence;
+      return task;
+    }),
+    // Run linkage is process-live: the runs recorded in old entries ended
+    // with the process that dispatched them, so a refold starts empty and
+    // the historical linkage stays readable in the earlier entries.
+    activeRunIds: []
+  };
+}
+function nextTaskId(tasks) {
+  let max = 0;
+  for (const task of tasks) {
+    const match = /^t(\d+)$/.exec(task.id);
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  return max + 1;
+}
+function normalizeTitles(titles) {
+  return titles.map((title) => title.trim()).filter((title) => title.length > 0);
+}
+function applyMutation(board, mutation) {
+  if (mutation.op === "plan") {
+    const titles = normalizeTitles(mutation.tasks);
+    if (mutation.title.trim().length === 0) return { error: "plan requires a non-empty title" };
+    if (titles.length === 0) return { error: "plan requires at least one task" };
+    const retained = board?.tasks.filter(isOpenUserTask) ?? [];
+    const notes2 = [];
+    const replacedOpen = board ? taskBoardCounts(board).open - retained.length : 0;
+    if (board && replacedOpen > 0) {
+      notes2.push(`replaced board "${board.title}" with ${replacedOpen} agent task(s) still open`);
+    }
+    if (retained.length > 0) notes2.push(`preserved ${retained.length} open operator task(s)`);
+    const start = nextTaskId(retained);
+    return {
+      board: {
+        boardId: "",
+        title: mutation.title.trim(),
+        tasks: [
+          ...retained,
+          ...titles.map((title, index) => ({
+            id: `t${start + index}`,
+            title,
+            status: "pending",
+            origin: "agent"
+          }))
+        ],
+        // Runs in flight outlive a board swap: they belong to the session,
+        // so the fresh board inherits the linkage until the runs finish.
+        activeRunIds: board?.activeRunIds ?? []
+      },
+      notes: notes2
+    };
+  }
+  if (mutation.op === "pick") {
+    const title = mutation.title.trim();
+    if (title.length === 0) return { error: "pick requires a non-empty operator task title" };
+    if (!/^u[1-9]\d*$/.test(mutation.userTaskId)) return { error: "pick requires an operator task id like u3" };
+    if (board?.tasks.some(
+      (task) => task.userTaskId === mutation.userTaskId && (task.status === "pending" || task.status === "active" || task.status === "completed")
+    )) {
+      return { error: `operator task ${mutation.userTaskId} is already linked to durable board work` };
+    }
+    const tasks2 = board?.tasks ?? [];
+    const picked = {
+      id: `t${nextTaskId(tasks2)}`,
+      title,
+      status: "pending",
+      origin: "user",
+      userTaskId: mutation.userTaskId
+    };
+    return {
+      board: {
+        boardId: board?.boardId ?? "",
+        title: board?.title ?? "Operator tasks",
+        tasks: [...tasks2, picked],
+        activeRunIds: board?.activeRunIds ?? []
+      },
+      notes: []
+    };
+  }
+  if (board === null) return { error: 'no task board yet; declare one with action="plan" first' };
+  if (mutation.op === "add") {
+    const titles = normalizeTitles(mutation.tasks);
+    if (titles.length === 0) return { error: "add requires at least one task" };
+    const start = nextTaskId(board.tasks);
+    const added = titles.map((title, index) => ({
+      id: `t${start + index}`,
+      title,
+      status: "pending",
+      origin: "agent"
+    }));
+    return { board: { ...board, tasks: [...board.tasks, ...added] }, notes: [] };
+  }
+  const target = board.tasks.find((task) => task.id === mutation.id);
+  if (!target) return { error: `task ${mutation.id} not found on the board` };
+  if (mutation.op === "block" && mutation.reason.trim().length === 0) {
+    return { error: "block requires a reason so the ledger records why work stopped" };
+  }
+  if (mutation.op === "done") {
+    if (mutation.evidence.trim().length === 0) {
+      return {
+        error: "done requires note as the evidence that the task actually finished (the command you ran, the file:line you verified). If the work did not happen, use block with a reason or drop it."
+      };
+    }
+    if (target.status === "pending") {
+      return {
+        error: `task ${target.id} was never started, so it cannot be completed. Start it and do the work, or record the truth with block (reason) or drop.`
+      };
+    }
+  }
+  const notes = [];
+  const tasks = board.tasks.map((task) => {
+    if (task.id !== target.id) {
+      if (mutation.op === "start" && task.status === "active") {
+        notes.push(`parked ${task.id} back to pending (one task active at a time)`);
+        return { ...task, status: "pending" };
+      }
+      return task;
+    }
+    return applyStatusMutation(task, mutation);
+  });
+  return { board: { ...board, tasks }, notes };
+}
+function applyStatusMutation(task, mutation) {
+  switch (mutation.op) {
+    case "start":
+      return { ...task, status: "active" };
+    case "done": {
+      const done = { ...task, status: "completed", evidence: mutation.evidence.trim() };
+      delete done.reason;
+      return done;
+    }
+    case "block":
+      return { ...task, status: "blocked", reason: mutation.reason.trim() };
+    case "drop": {
+      const dropped = { ...task, status: "cancelled" };
+      if (mutation.reason?.trim()) dropped.reason = mutation.reason.trim();
+      return dropped;
+    }
+  }
+}
+function createTaskBoardStore(deps = {}) {
+  let cachedSessionId;
+  let dirty = true;
+  let board = null;
+  const syncToSession = () => {
+    const sessionId = deps.getSessionId?.() ?? null;
+    if (!dirty && cachedSessionId === sessionId) return;
+    dirty = false;
+    cachedSessionId = sessionId;
+    try {
+      board = deps.readEntries ? foldTaskBoard(deps.readEntries()) : null;
+    } catch {
+      board = null;
+    }
+  };
+  const persist = (next) => {
+    try {
+      deps.appendEntry?.(toTaskLedgerEntryFields(next, deps.now?.() ?? /* @__PURE__ */ new Date()));
+    } catch {
+    }
+  };
+  const mutationRequiresAcknowledgement = (current, mutation) => {
+    if (mutation.op === "pick") return true;
+    if (mutation.op === "plan") return current?.tasks.some(isOpenUserTask) ?? false;
+    if (mutation.op !== "done") return false;
+    return current?.tasks.some((task) => task.id === mutation.id && task.origin === "user") ?? false;
+  };
+  return {
+    snapshot() {
+      syncToSession();
+      return board;
+    },
+    cachedSnapshot() {
+      const sessionId = deps.getSessionId?.() ?? null;
+      return !dirty && cachedSessionId === sessionId ? board : null;
+    },
+    historySnapshot() {
+      syncToSession();
+      try {
+        return deps.readEntries ? foldSessionTaskHistory(deps.readEntries()) : [];
+      } catch {
+        return [];
+      }
+    },
+    apply(mutation) {
+      syncToSession();
+      const result = applyMutation(board, mutation);
+      if ("error" in result) return { ok: false, message: result.error };
+      const needsBoardId = mutation.op === "plan" || result.board.boardId.length === 0;
+      const nextBoard = needsBoardId ? { ...result.board, boardId: deps.createBoardId?.() ?? randomUUID() } : result.board;
+      if (mutationRequiresAcknowledgement(board, mutation)) {
+        if (!deps.appendEntry) {
+          return { ok: false, message: "durable task-ledger persistence is unavailable for operator-linked work" };
+        }
+        try {
+          deps.appendEntry(toTaskLedgerEntryFields(nextBoard, deps.now?.() ?? /* @__PURE__ */ new Date()));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { ok: false, message: `could not persist operator-linked task board: ${message}` };
+        }
+        board = nextBoard;
+        return { ok: true, board: nextBoard, notes: result.notes };
+      }
+      board = nextBoard;
+      persist(nextBoard);
+      return { ok: true, board: nextBoard, notes: result.notes };
+    },
+    attachRun(runId) {
+      syncToSession();
+      if (board === null || runId.length === 0 || board.activeRunIds.includes(runId)) return;
+      board = { ...board, activeRunIds: [...board.activeRunIds, runId] };
+      persist(board);
+    },
+    detachRun(runId) {
+      syncToSession();
+      if (board === null || !board.activeRunIds.includes(runId)) return;
+      board = { ...board, activeRunIds: board.activeRunIds.filter((id) => id !== runId) };
+      persist(board);
+    },
+    invalidate() {
+      dirty = true;
+    }
+  };
+}
+
+// src/engine/antigravity/subprocess-runtime.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+
+// src/engine/external-subprocess.ts
+init_esm_shims();
+async function readStderr(child) {
+  let stderr = "";
+  for await (const chunk of child.stderr) {
+    stderr += String(chunk);
+    if (stderr.length > 8192) stderr = stderr.slice(-8192);
+  }
+  return stderr;
+}
+function waitForClose(child) {
+  return new Promise((resolve) => {
+    child.once("error", () => resolve(1));
+    child.once("close", (code) => resolve(code ?? 1));
+  });
+}
+
+// src/engine/antigravity/subprocess-runtime.ts
+var ANTIGRAVITY_BINARY = "agy";
+var ZERO_USAGE = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 0,
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+};
+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: [], dangerousBypass: false, externalMode: "agy-settings-default" };
+}
+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 buildAgyArgs(input) {
+  assertToolProfileEnforceable(input.toolProfile, "antigravity-code");
+  const permission = antigravitySubprocessConfigForAutonomy(input.autonomy);
+  const args = ["--print", ...permission.extraArgs];
+  if (input.wireModelId.trim().length > 0) args.push("--model", input.wireModelId.trim());
+  args.push(buildAntigravityPrompt(input));
+  return args;
+}
+function buildAssistantMessage(input) {
+  const message = {
+    role: "assistant",
+    content: [{ type: "text", text: input.text }],
+    api: "google-generative-ai",
+    provider: "google",
+    model: input.model,
+    usage: ZERO_USAGE,
+    stopReason: input.aborted ? "aborted" : input.exitCode === 0 ? "stop" : "error",
+    timestamp: Date.now()
+  };
+  if (input.exitCode !== 0 && !input.aborted) {
+    const detail = input.stderr.trim();
+    if (detail.length > 0) message.errorMessage = detail;
+  }
+  return message;
+}
+function emitTextDelta(emit, state, delta) {
+  if (delta.length === 0) return;
+  state.text += delta;
+  const message = buildAssistantMessage({
+    model: state.model,
+    text: state.text,
+    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 readStdout(child, emit, state) {
+  for await (const chunk of child.stdout) {
+    emitTextDelta(emit, state, String(chunk));
+  }
+}
+function startAntigravityWorkerRun(input, emit) {
+  const args = buildAgyArgs(input);
+  const child = spawn(ANTIGRAVITY_BINARY, args, {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const streamState = { started: false, text: "", model: input.wireModelId };
+  let aborted = false;
+  let killTimer = null;
+  const abort = () => {
+    aborted = true;
+    if (child.killed) return;
+    child.kill("SIGTERM");
+    killTimer = setTimeout(() => {
+      if (!child.killed) child.kill("SIGKILL");
+    }, 1500);
+  };
+  if (input.signal) {
+    if (input.signal.aborted) abort();
+    else input.signal.addEventListener("abort", abort, { once: true });
+  }
+  const promise = (async () => {
+    emit({ type: "agent_start" });
+    const stderrPromise = readStderr(child);
+    const stdoutPromise = readStdout(child, emit, streamState);
+    const exitCode = await waitForClose(child);
+    await stdoutPromise.catch(() => {
+    });
+    const stderr = await stderrPromise.catch(() => "");
+    if (killTimer) clearTimeout(killTimer);
+    const finalText = streamState.text || (exitCode === 0 ? "" : stderr.trim());
+    const finalMessage = buildAssistantMessage({
+      model: streamState.model,
+      text: finalText,
+      exitCode,
+      aborted,
+      stderr
+    });
+    if (!streamState.started) emit({ type: "message_start", message: finalMessage });
+    emit({ type: "message_end", message: finalMessage });
+    const messages = [finalMessage];
+    emit({ type: "agent_end", messages });
+    if (exitCode !== 0 && stderr.trim().length > 0 && !aborted) {
+      process.stderr.write(`[worker:antigravity-code] ${stderr.trim()}
+`);
+    }
+    return { messages, exitCode: exitCode === 0 ? 0 : 1 };
+  })();
+  return {
+    promise,
+    abort
+  };
+}
+
+// src/engine/claude/subprocess-runtime.ts
+init_esm_shims();
+import { spawn as spawn2 } from "node:child_process";
+import { createInterface } from "node:readline";
+
+// 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"];
+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) {
+  assertToolProfileEnforceable(input.toolProfile, "claude-code");
+  const permission = claudeSubprocessPermissionConfigForAutonomy(input.autonomy);
+  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());
+  args.push(buildClaudeCodePrompt(input));
+  return args;
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function normalizeUsage(raw, totalCostUsd = 0) {
+  const record2 = typeof raw === "object" && raw !== null ? raw : {};
+  const input = finite(record2.input_tokens) + finite(record2.inputTokens) + finite(record2.input) + finite(record2.prompt_tokens) + finite(record2.promptTokens);
+  const output = finite(record2.output_tokens) + finite(record2.outputTokens) + finite(record2.output) + finite(record2.completion_tokens) + finite(record2.completionTokens);
+  const cacheRead = finite(record2.cache_read_input_tokens) + finite(record2.cacheReadInputTokens) + finite(record2.cacheRead) + finite(record2.cacheReadTokens);
+  const cacheWrite = finite(record2.cache_creation_input_tokens) + finite(record2.cacheCreationInputTokens) + finite(record2.cacheWrite) + finite(record2.cacheWriteTokens);
+  const totalTokens = input + output + cacheRead + cacheWrite;
+  const total = finite(totalCostUsd) + finite(record2.costUSD) + finite(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 errorMessage = input.exitCode === 0 ? "" : 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: normalizeUsage(input.result?.usage, finite(input.result?.total_cost_usd)),
+    stopReason: input.aborted ? "aborted" : input.exitCode === 0 ? "stop" : "error",
+    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 = 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) {
+  const rl = createInterface({ input: child.stdout });
+  for await (const line of rl) {
+    const trimmed = 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) {
+  const args = buildClaudeCodeArgs(input);
+  const child = spawn2("claude", args, {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const streamState = {
+    started: false,
+    text: "",
+    model: input.wireModelId,
+    result: null
+  };
+  let aborted = false;
+  let killTimer = null;
+  const abort = () => {
+    aborted = true;
+    if (child.killed) return;
+    child.kill("SIGTERM");
+    killTimer = setTimeout(() => {
+      if (!child.killed) child.kill("SIGKILL");
+    }, 1500);
+  };
+  if (input.signal) {
+    if (input.signal.aborted) abort();
+    else input.signal.addEventListener("abort", abort, { once: true });
+  }
+  const promise = (async () => {
+    emit({ type: "agent_start" });
+    const stderrPromise = readStderr(child);
+    const stdoutPromise = readJsonLines(child, emit, streamState);
+    const exitCode = await waitForClose(child);
+    await stdoutPromise.catch(() => {
+    });
+    const stderr = await stderrPromise.catch(() => "");
+    if (killTimer) clearTimeout(killTimer);
+    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
+    });
+    if (!streamState.started) emit({ type: "message_start", message: finalMessage });
+    emit({ type: "message_end", message: finalMessage });
+    const messages = [finalMessage];
+    emit({ type: "agent_end", messages });
+    if (exitCode !== 0 && stderr.trim().length > 0 && !aborted) {
+      process.stderr.write(`[worker:claude-code] ${stderr.trim()}
+`);
+    }
+    return { messages, exitCode: exitCode === 0 ? 0 : 1 };
+  })();
+  return {
+    promise,
+    abort
+  };
+}
+
+// src/engine/worker-runtime-capabilities.ts
+init_esm_shims();
+var WORKER_RUNTIME_MEDIATES_CLIO_DISPATCH = false;
+
+// src/tools/builtin-tool-catalog.ts
+init_esm_shims();
+
+// src/tools/read.ts
+init_esm_shims();
+import { readFileSync, statSync } from "node:fs";
+var DEFAULT_READ_MAX_BYTES = GUARDRAIL_DEFAULTS.readMaxBytes;
+var READ_MAX_BYTES_ENV = GUARDRAIL_ENV_VARS.readMaxBytes;
+var MIN_READ_CAP_BYTES = 1024;
+function readMaxBytes(env = process.env) {
+  return Math.max(MIN_READ_CAP_BYTES, resolveGuardrail("readMaxBytes", env));
+}
+var readTool = {
+  name: ToolNames.Read,
+  description: `Read a UTF-8 text file. Output is capped at ${DEFAULT_MAX_LINES} lines or ${DEFAULT_READ_MAX_BYTES / 1024}KB per call; truncated results say how to continue with offset/limit. Pass tail=N to read the last N lines (jump to EOF) instead of paging from the top.`,
+  parameters: typebox_exports.Object({
+    path: typebox_exports.String({ description: "File path (relative or absolute)." }),
+    offset: typebox_exports.Optional(typebox_exports.Number({ description: "1-indexed start line." })),
+    limit: typebox_exports.Optional(typebox_exports.Number({ description: "Max lines to read." })),
+    tail: typebox_exports.Optional(
+      typebox_exports.Number({ description: "Read the last N lines of the file (jump to EOF). Overrides offset/limit." })
+    )
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel",
+  async run(args, options) {
+    const pathArg = typeof args.path === "string" ? args.path : null;
+    if (!pathArg) return { kind: "error", message: "read: missing path argument" };
+    const filePath = resolveReadPath(pathArg);
+    const offset = typeof args.offset === "number" && args.offset > 0 ? Math.floor(args.offset) : 1;
+    const limit = typeof args.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : null;
+    const tail = typeof args.tail === "number" && args.tail > 0 ? Math.floor(args.tail) : null;
+    const reservation = isSessionOffloadPath(filePath, options?.sessionId) ? reserveObservation(readMaxBytes()) : reserveObservation(readMaxBytes(), options);
+    try {
+      const stat = statSync(filePath);
+      if (!stat.isFile()) return { kind: "error", message: `read: not a file: ${filePath}` };
+      if (stat.size > 2e7) {
+        return {
+          kind: "error",
+          message: `read: file too large (${stat.size}B > 20MB). Use grep/find to locate the relevant section or read a smaller generated/source file; use shell access only when byte-level inspection is explicitly needed.`
+        };
+      }
+      if (reservation.exhausted) {
+        return observationBudgetExhausted({
+          tool: ToolNames.Read,
+          unit: "lines",
+          reservation,
+          subject: `reading ${pathArg}`,
+          hint: "Use offset/limit in a follow-up turn or grep/find for a narrower section."
+        });
+      }
+      const content = readFileSync(filePath, "utf8");
+      const allLines = content.split("\n");
+      const totalLines = splitLinesForCounting(content).length;
+      const totalBytes = Buffer.byteLength(content, "utf8");
+      const startIndex = Math.min(offset - 1, totalLines);
+      if (tail === null && offset > 1 && startIndex >= totalLines) {
+        return {
+          kind: "error",
+          message: `read: offset ${offset} is beyond end of file (${totalLines} lines total). The file ends at line ${totalLines} and has no further content; do not page past it or re-read the tail \u2014 a read covering line ${totalLines} has already returned everything.`
+        };
+      }
+      const cap = reservation.callCapBytes;
+      if (tail !== null) {
+        const startLine = Math.max(0, totalLines - tail);
+        const tailContent = allLines.slice(startLine).join("\n");
+        const truncation2 = truncateTail(tailContent, { maxBytes: cap, maxLines: tail });
+        const shownLines = truncation2.outputLines;
+        const firstShown = Math.max(1, totalLines - shownLines + 1);
+        const truncated2 = startLine > 0 || truncation2.truncated;
+        return finalizeObservation({
+          tool: ToolNames.Read,
+          unit: "lines",
+          output: truncation2.content,
+          shownCount: shownLines,
+          totalCount: totalLines,
+          totalBytes,
+          truncated: truncated2,
+          ...truncated2 ? { next: `offset=${Math.max(1, firstShown - shownLines)} limit=${shownLines}` } : {},
+          reservation,
+          ...options ? { options } : {}
+        });
+      }
+      const selected = limit !== null ? allLines.slice(startIndex, startIndex + limit).join("\n") : allLines.slice(startIndex).join("\n");
+      const truncation = truncateHead(selected, { maxBytes: cap });
+      if (truncation.firstLineExceedsLimit) {
+        const firstLineSize = formatSize(Buffer.byteLength(allLines[startIndex] ?? "", "utf8"));
+        const linePrefix = truncateUtf8(allLines[startIndex] ?? "", cap, "\n[line truncated]");
+        const output = `${linePrefix}
+
+[Line ${startIndex + 1} is ${firstLineSize}, exceeding the ${formatSize(cap)} read limit. Showing the UTF-8 prefix only. Use grep with a narrower literal/regex or edit with exact surrounding text; use shell access only when byte-level inspection is required.]`;
+        return finalizeObservation({
+          tool: ToolNames.Read,
+          unit: "lines",
+          output,
+          shownCount: 0,
+          totalCount: totalLines,
+          totalBytes,
+          truncated: true,
+          omitNotice: true,
+          reservation,
+          ...options ? { options } : {}
+        });
+      }
+      const endDisplay = startIndex + truncation.outputLines;
+      const moreAfter = endDisplay < totalLines;
+      const truncated = truncation.truncated || limit !== null && moreAfter;
+      return finalizeObservation({
+        tool: ToolNames.Read,
+        unit: "lines",
+        output: truncation.content,
+        shownCount: truncation.outputLines,
+        totalCount: totalLines,
+        totalBytes,
+        truncated,
+        ...truncated && moreAfter ? { next: `offset=${endDisplay + 1}` } : {},
+        reservation,
+        ...options ? { options } : {}
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const code = err?.code;
+      if (code === "ENOENT") {
+        return {
+          kind: "error",
+          message: `read: ${msg}. File not found at ${pathArg}. The path may be wrong. Try: code_nav, find, or ls to locate it.`
+        };
+      }
+      return { kind: "error", message: `read: ${msg}` };
+    }
+  }
+};
+
+// src/tools/builtin-tool-catalog.ts
+function withSourceInfo(spec, sourceInfo) {
+  return { ...spec, sourceInfo };
+}
+function withMetadata(spec, metadata) {
+  return { ...spec, metadata };
+}
+var policyCap = (selfCapBytes) => selfCapBytes + OBSERVATION_POLICY_SLACK_BYTES;
+var observePolicy = (selfCapBytes, followUpHint) => ({ kind: "bounded", maxBytes: policyCap(selfCapBytes), followUpHint });
+var summaryPolicy = (followUpHint) => ({ kind: "summary", maxBytes: 16384, followUpHint });
+var exactMutationPolicy = {
+  kind: "exact",
+  maxBytes: 8192,
+  followUpHint: "Inspect the changed file or git diff for exact follow-up context."
+};
+var TOOL_METADATA = {
+  // OBSERVE: read-class, parallel, envelope + shared turn budget.
+  [ToolNames.Read]: {
+    objective: "Read exact UTF-8 file content with line and byte bounds.",
+    uiLabel: "Read",
+    retrySafety: "idempotent",
+    resultSizePolicy: observePolicy(
+      readMaxBytes(),
+      "Use offset/limit or a narrower locate/search tool call to inspect omitted content."
+    ),
+    costLatency: "local_fast"
+  },
+  [ToolNames.Grep]: {
+    objective: "Search file contents and return line-referenced matches.",
+    uiLabel: "Grep",
+    retrySafety: "idempotent",
+    resultSizePolicy: observePolicy(
+      OBSERVE_SELF_CAPS.grepContent,
+      "Refine the pattern, path, glob, context, or limit, or use mode=files, to inspect omitted matches."
+    ),
+    costLatency: "local_medium"
+  },
+  [ToolNames.Find]: {
+    objective: "Find paths by glob pattern with optional mtime ordering.",
+    uiLabel: "Find",
+    retrySafety: "idempotent",
+    resultSizePolicy: observePolicy(
+      OBSERVE_SELF_CAPS.find,
+      "Refine the pattern, path, or limit to inspect omitted paths."
+    ),
+    costLatency: "local_medium"
+  },
+  [ToolNames.Ls]: {
+    objective: "List directory entries.",
+    uiLabel: "List",
+    retrySafety: "idempotent",
+    resultSizePolicy: observePolicy(OBSERVE_SELF_CAPS.ls, "Raise limit or list a narrower directory."),
+    costLatency: "local_fast"
+  },
+  [ToolNames.CodeNav]: {
+    objective: "Navigate the codewiki index by symbol, path, entry points, outline, imports, or importers.",
+    uiLabel: "Nav",
+    retrySafety: "idempotent",
+    resultSizePolicy: observePolicy(OBSERVE_SELF_CAPS.codeNav, "Raise limit or use a narrower mode/query."),
+    costLatency: "local_fast",
+    promptHint: "Use code_nav for indexed code navigation (modes: symbol, path, entries, outline, deps, dependents, wiki)."
+  },
+  [ToolNames.Context]: {
+    objective: "Return workspace, bundled-docs, or skill context.",
+    uiLabel: "Context",
+    retrySafety: "idempotent",
+    resultSizePolicy: observePolicy(
+      Math.max(OBSERVE_SELF_CAPS.contextDocs, OBSERVE_SELF_CAPS.contextSkills, OBSERVE_SELF_CAPS.contextWorkspace),
+      "Use a narrower query or scope to inspect omitted content."
+    ),
+    costLatency: "local_fast",
+    promptHint: 'Call context with scope="skills" to list installed and marketplace skills; when one matches the task, or the operator names a skill or asks how one works, suggest the operator run /skill <name> (a marketplace skill is offered for install) and never load it uninvited. When the user message carries a skill request, first load that skill via context (scope="skills", name=<skill>) before doing anything else.'
+  },
+  [ToolNames.CredentialPresent]: {
+    objective: "Check whether a credential key is present without returning its value.",
+    uiLabel: "Credential",
+    retrySafety: "idempotent",
+    resultSizePolicy: {
+      kind: "exact",
+      maxBytes: 4096,
+      followUpHint: "Use the boolean result only; never ask to print the credential value."
+    },
+    costLatency: "local_fast"
+  },
+  // MUTATE: write-class, sequential, file-mutation queue.
+  [ToolNames.Write]: {
+    objective: "Write a complete UTF-8 file.",
+    uiLabel: "Write",
+    retrySafety: "not_retry_safe",
+    resultSizePolicy: exactMutationPolicy,
+    costLatency: "local_fast"
+  },
+  [ToolNames.Edit]: {
+    objective: "Apply exact text replacements to one file.",
+    uiLabel: "Edit",
+    retrySafety: "not_retry_safe",
+    resultSizePolicy: exactMutationPolicy,
+    costLatency: "local_fast"
+  },
+  // EXECUTE: the safe-exec spine (bash offloads its own overflow).
+  [ToolNames.Bash]: {
+    objective: "Execute an explicit shell command when narrower tools are insufficient.",
+    uiLabel: "Shell",
+    retrySafety: "unknown",
+    resultSizePolicy: summaryPolicy(
+      "Use a narrower command or a dedicated verification/read/search tool to inspect omitted output."
+    ),
+    costLatency: "local_slow"
+  },
+  [ToolNames.Git]: {
+    objective: "Read-only git inspection: status, diff, or log.",
+    uiLabel: "Git",
+    retrySafety: "idempotent",
+    resultSizePolicy: summaryPolicy("Limit the diff/log to one path or fewer commits."),
+    costLatency: "local_fast"
+  },
+  [ToolNames.Verify]: {
+    objective: "Run declared verification checks (scripts or frontend artifacts).",
+    uiLabel: "Verify",
+    retrySafety: "retry_safe",
+    resultSizePolicy: summaryPolicy(
+      "Rerun the check with narrower args or inspect the named failing file/test directly."
+    ),
+    costLatency: "local_slow"
+  },
+  // ORCHESTRATE: agent-class, receipts as evidence.
+  [ToolNames.Tasks]: {
+    objective: "Declare and track the session task board with evidence-carrying completions.",
+    uiLabel: "Tasks",
+    // A repeated plan/start/done lands on the same board state; a repeated
+    // add duplicates a task, so the surface as a whole is not retry safe.
+    retrySafety: "not_retry_safe",
+    resultSizePolicy: {
+      kind: "exact",
+      maxBytes: 8192,
+      followUpHint: 'Call tasks with action="list" to re-read the board.'
+    },
+    costLatency: "local_fast",
+    promptHint: 'When a request contains three or more distinct steps, declare the board before your first edit: tasks action="plan" with a title and the task list. Mark one task active with "start" before working it, close it with "done" plus an evidence note (what proves it works), and use "block" with a reason instead of silently stalling.'
+  },
+  [ToolNames.Ledger]: {
+    objective: "Coordinate with the peer workers of this dispatch through typed claims, findings, and reviews.",
+    uiLabel: "Ledger",
+    // A repeated post lands a second entry and spends another of the run's
+    // twenty posts, so the surface as a whole is not retry safe.
+    retrySafety: "not_retry_safe",
+    resultSizePolicy: {
+      kind: "exact",
+      maxBytes: 16384,
+      followUpHint: 'Call ledger with action="read" and a since sequence to re-read only what is new.'
+    },
+    costLatency: "local_fast"
+  },
+  [ToolNames.Dispatch]: {
+    objective: "Dispatch bounded tasks to configured Clio workers.",
+    uiLabel: "Dispatch",
+    retrySafety: "not_retry_safe",
+    resultSizePolicy: summaryPolicy(
+      "Use the dispatch receipt paths or ask a narrower worker follow-up for omitted output."
+    ),
+    costLatency: "agent",
+    promptHint: "Call dispatch with list:true only when the operator asks about agents, workers, or the fleet; never use it to inventory direct tools."
+  },
+  [ToolNames.Monitor]: {
+    objective: "Inspect dispatched runs: state, recent events, receipts.",
+    uiLabel: "Monitor",
+    retrySafety: "idempotent",
+    resultSizePolicy: summaryPolicy("Use monitor(mode=receipt) or read the receipt path for full details."),
+    costLatency: "local_fast"
+  },
+  [ToolNames.Steer]: {
+    objective: "Guide or cancel a running dispatched worker.",
+    uiLabel: "Steer",
+    retrySafety: "not_retry_safe",
+    resultSizePolicy: {
+      kind: "exact",
+      maxBytes: 4096,
+      followUpHint: "Use monitor(mode=status) to confirm the run state after steering."
+    },
+    costLatency: "local_fast"
+  },
+  // RETRIEVE: network-class.
+  [ToolNames.WebFetch]: {
+    objective: "Fetch HTTP(S) text for explicit external research.",
+    uiLabel: "Fetch",
+    retrySafety: "retry_safe",
+    resultSizePolicy: {
+      kind: "bounded",
+      maxBytes: 16384,
+      followUpHint: "Fetch a narrower URL or lower max_bytes to inspect a specific section."
+    },
+    costLatency: "network"
+  },
+  // INTERACT: operator dialogue.
+  [ToolNames.AskUser]: {
+    objective: "Ask the operator structured questions.",
+    uiLabel: "Ask",
+    retrySafety: "not_retry_safe",
+    resultSizePolicy: {
+      kind: "exact",
+      maxBytes: 2e4,
+      followUpHint: "Proceed with stated assumptions if the operator cancels or no UI is available."
+    },
+    costLatency: "local_slow",
+    promptHint: 'Use ask_user only when blocked on a decision the request does not answer; never ask about anything the operator already stated. One question per round in interview workflows, up to four tightly related questions otherwise, recommended option first. Finish with action="complete" and a compact decisions array before final prose. If cancelled, continue with defaults and do not ask again.'
+  },
+  // ARTIFACT: terminal writers.
+  [ToolNames.Artifact]: {
+    objective: "Write terminal plan/review/report documents that complete the turn.",
+    uiLabel: "Artifact",
+    retrySafety: "not_retry_safe",
+    resultSizePolicy: exactMutationPolicy,
+    costLatency: "local_fast"
+  }
+};
+function toolPromptHintsForNames(names) {
+  const seen = /* @__PURE__ */ new Set();
+  const hints = [];
+  for (const name of [...names].sort()) {
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const hint = TOOL_METADATA[name]?.promptHint?.trim();
+    if (hint) hints.push({ tool: name, hint });
+  }
+  return hints;
+}
+function withBuiltinMetadata(spec) {
+  const metadata = TOOL_METADATA[spec.name];
+  return metadata ? withMetadata(spec, metadata) : spec;
+}
+function builtin(spec, sourceInfo) {
+  return withBuiltinMetadata(withSourceInfo(spec, sourceInfo));
+}
+
+// src/domains/safety/run-effects.ts
+init_esm_shims();
+import path from "node:path";
+var GIT_PATH_MUTATIONS = /* @__PURE__ */ new Set(["mv", "rm"]);
+function gitPathOperands(command) {
+  const targets = [];
+  for (const segment of splitCommandSegments(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 splitCommandSegments(command) {
+  const segments = [];
+  let current = [];
+  for (const token of tokenizeShellLike(command)) {
+    if (token === ";" || token === "&&" || token === "||" || token === "|") {
+      if (current.length > 0) segments.push(current);
+      current = [];
+      continue;
+    }
+    current.push(token);
+  }
+  if (current.length > 0) segments.push(current);
+  return segments;
+}
+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) {
+  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();
+  return {
+    start(toolCallId, toolName, args) {
+      const paths = mutationTargets(toolName, args);
+      const validationCommand = validationCommandOf(toolName, args, "finish-contract");
+      const verificationCommand = validationCommandOf(toolName, args, "grounding");
+      if (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, {
+        paths: paths.map((target) => path.resolve(base, target)),
+        validationCommand,
+        verificationCommand
+      });
+    },
+    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;
+      }
+      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)
+      };
+    }
+  };
+}
+
+// src/domains/dispatch/route-approval.ts
+init_esm_shims();
+var APPROVED_ASSIGNMENT_ROUTE_VERSION = 1;
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function routeCandidate(value) {
+  if (!record(value) || !isExecutionRole(value.executionRole)) return false;
+  return [
+    "agentId",
+    "specFingerprint",
+    "targetId",
+    "modelId",
+    "runtimeId",
+    "nodeId",
+    "toolSignature",
+    "promptCompositionHash",
+    "endpointIdentityHash",
+    "settingsFingerprint"
+  ].every((field) => typeof value[field] === "string" && value[field].length > 0);
+}
+function isApprovedAssignmentRoute(value) {
+  if (!record(value) || value.version !== APPROVED_ASSIGNMENT_ROUTE_VERSION || !record(value.decision)) return false;
+  const decision = value.decision;
+  if (decision.mode !== "active" || !routeCandidate(decision.selected) || !routeCandidate(decision.executedRoute) || !Array.isArray(decision.approvedFallbacks) || !decision.approvedFallbacks.every(routeCandidate) || !isRouteDecisionAgentSelection(decision.agentSelection) || !Array.isArray(decision.candidateEvaluations) || !decision.candidateEvaluations.every(
+    (evaluation) => record(evaluation) && routeCandidate(evaluation.candidate) && record(evaluation.activeReadiness) && typeof evaluation.activeReadiness.ready === "boolean" && Array.isArray(evaluation.activeReadiness.gaps) && evaluation.activeReadiness.gaps.every((gap) => typeof gap === "string") && Number.isInteger(evaluation.activeReadiness.labelsNeeded)
+  ) || decision.policyVersion !== ROUTE_POLICY_VERSION || typeof decision.decisionHash !== "string" || !/^[0-9a-f]{64}$/u.test(decision.decisionHash)) {
+    return false;
+  }
+  try {
+    assertApprovedAssignmentRoute(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertApprovedAssignmentRoute(value) {
+  if (value.version !== APPROVED_ASSIGNMENT_ROUTE_VERSION) {
+    throw new Error("dispatch: unsupported active route approval version");
+  }
+  if (value.decision.policyVersion !== ROUTE_POLICY_VERSION) {
+    throw new Error("dispatch: active route approval uses an unsupported route policy");
+  }
+  if (!isRouteDecisionAgentSelection(value.decision.agentSelection)) {
+    throw new Error("dispatch: active route approval has invalid agent-selection evidence");
+  }
+  if (value.decision.mode !== "active" || !sameRouteIdentity(value.decision.selected, value.decision.executedRoute)) {
+    throw new Error("dispatch: active route approval must seal one selected and executed identity");
+  }
+  const agentSelection = value.decision.agentSelection;
+  if (agentSelection.activation !== "active") {
+    throw new Error("dispatch: active route approval has non-active agent selection evidence");
+  }
+  if (agentSelection.request === "explicit" && [value.decision.selected, ...value.decision.approvedFallbacks].some(
+    (candidate) => candidate.agentId !== agentSelection.baselineAgentId
+  )) {
+    throw new Error("dispatch: explicit route approval cannot authorize another agent");
+  }
+  if (value.decision.selected.agentId !== agentSelection.baselineAgentId) {
+    const transition = agentSelection.authorityTransition;
+    if (agentSelection.request !== "auto" || transition === null || transition.from !== agentSelection.baselineAgentId || transition.to !== value.decision.selected.agentId)
+      throw new Error("dispatch: active agent transition is not explained by the approved decision");
+  }
+  for (const candidate of [value.decision.selected, ...value.decision.approvedFallbacks]) {
+    const evaluation = value.decision.candidateEvaluations.find((entry) => sameRouteIdentity(entry.candidate, candidate));
+    if (evaluation === void 0 || evaluation.rejection !== null || !evaluation.activeReadiness.ready) {
+      throw new Error("dispatch: active route approval contains a rejected or readiness-ineligible route");
+    }
+    const agentEvaluation = agentSelection.evaluations.find(
+      (entry) => entry.agentId === candidate.agentId && entry.specFingerprint === candidate.specFingerprint && entry.executionRole === candidate.executionRole
+    );
+    if (agentEvaluation === void 0 || agentEvaluation.rejections.length > 0) {
+      throw new Error("dispatch: active route approval contains an agent rejected by hard filters");
+    }
+  }
+  if (!Number.isFinite(value.totalCostUpperBoundUsd) || value.totalCostUpperBoundUsd < 0) {
+    throw new Error("dispatch: active route approval total cost bound is invalid");
+  }
+  if (!Number.isInteger(value.deadlineMs) || value.deadlineMs <= 0) {
+    throw new Error("dispatch: active route approval deadline is invalid");
+  }
+  if (!Number.isInteger(value.maxAttempts) || value.maxAttempts < 1) {
+    throw new Error("dispatch: active route approval attempt bound is invalid");
+  }
+}
+function cloneApprovedAssignmentRoute(value) {
+  assertApprovedAssignmentRoute(value);
+  return structuredClone(value);
+}
+function approvedRouteCandidates(value) {
+  assertApprovedAssignmentRoute(value);
+  return [value.decision.selected, ...value.decision.approvedFallbacks].map((candidate) => ({
+    agentId: candidate.agentId,
+    target: candidate.targetId,
+    model: candidate.modelId,
+    node: candidate.nodeId
+  }));
+}
+function assertApprovedRecoveryCapability(approval, actual) {
+  assertApprovedAssignmentRoute(approval);
+  const approved = [approval.decision.selected, ...approval.decision.approvedFallbacks].find(
+    (candidate) => candidate.agentId === actual.agentId && candidate.targetId === actual.targetId && candidate.modelId === actual.modelId && candidate.runtimeId === actual.runtimeId && candidate.nodeId === actual.nodeId
+  );
+  if (approved === void 0 || approved.specFingerprint !== actual.specFingerprint || approved.thinkingLevel !== actual.thinkingLevel || approved.toolSignature !== actual.toolSignature || approved.endpointIdentityHash !== actual.endpointIdentityHash || approved.settingsFingerprint !== actual.settingsFingerprint) {
+    throw new Error("dispatch: recovery route capability drifted outside the active approval");
+  }
+}
+
+// src/domains/dispatch/agent-ledger.ts
+init_esm_shims();
+import { isAbsolute, relative } from "node:path";
+var AGENT_LEDGER_PROMPT_MAX_CHARS = 4e3;
+function normalizeScopePrefix(value) {
+  return value.trim().replace(/\/+$/u, "");
+}
+function prefixesOverlap(left, right) {
+  const a = normalizeScopePrefix(left);
+  const b = normalizeScopePrefix(right);
+  if (a.length === 0 || b.length === 0) return false;
+  if (a === b) return true;
+  return a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+}
+function claimConflicts(body, live, runId) {
+  if (body.kind !== "claim") return [];
+  const conflicts = [];
+  for (const entry of live) {
+    if (entry.body.kind !== "claim") continue;
+    if (runId !== void 0 && entry.runId === runId) continue;
+    const overlaps = entry.body.scope.some(
+      (peerScope) => body.scope.some((newScope) => prefixesOverlap(newScope, peerScope))
+    );
+    if (overlaps) conflicts.push(entry.id);
+  }
+  return conflicts;
+}
+function citedPathKey(path3) {
+  const trimmed = path3.trim();
+  if (trimmed.length === 0) return trimmed;
+  const absolute = isAbsolute(trimmed);
+  const candidate = absolute ? relative(process.cwd(), trimmed) : trimmed;
+  if (absolute && (candidate.length === 0 || candidate.startsWith(".."))) return trimmed;
+  const normalized = candidate.split("/").filter((segment) => segment.length > 0 && segment !== ".").join("/");
+  return normalized.length === 0 ? trimmed : normalized;
+}
+function corroboration(entries) {
+  const runsByPath = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.body.kind !== "finding") continue;
+    const path3 = entry.body.path === void 0 ? void 0 : citedPathKey(entry.body.path);
+    if (path3 === void 0) continue;
+    const runs = runsByPath.get(path3) ?? [];
+    if (!runs.includes(entry.runId)) runs.push(entry.runId);
+    runsByPath.set(path3, runs);
+  }
+  const byEntryId = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.body.kind !== "finding") continue;
+    const path3 = entry.body.path;
+    if (path3 === void 0) {
+      byEntryId.set(entry.id, "ungrounded lead");
+      continue;
+    }
+    const runs = runsByPath.get(citedPathKey(path3)) ?? [];
+    byEntryId.set(entry.id, runs.length >= 2 ? "corroborated" : "uncorroborated");
+  }
+  return { byEntryId, byPath: runsByPath };
+}
+function disputes(entries) {
+  const disputed = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.body.kind === "review" && !entry.body.passed) disputed.add(entry.body.target);
+  }
+  return disputed;
+}
+function authorKey(entry) {
+  return `${entry.agentId}\0${entry.runId}`;
+}
+function renderBody(entry, state, disputed) {
+  const marks = [];
+  if (state !== void 0) marks.push(state);
+  if (disputed) marks.push("disputed");
+  const suffix = marks.length > 0 ? ` [${marks.join(", ")}]` : "";
+  const body = entry.body;
+  if (body.kind === "claim") {
+    const conflicts = entry.conflictsWith !== void 0 && entry.conflictsWith.length > 0 ? ` (overlaps ${entry.conflictsWith.join(", ")})` : "";
+    return `${entry.id} claim ${body.scope.join(" ")}${conflicts}: ${body.intent}${suffix}`;
+  }
+  if (body.kind === "finding") {
+    const citation = body.path === void 0 ? "" : ` ${body.path}${body.line === void 0 ? "" : `:${body.line}`}`;
+    return `${entry.id} finding${citation}: ${body.claim}${suffix}`;
+  }
+  return `${entry.id} review ${body.target} ${body.passed ? "passed" : "failed"}: ${body.evidence}${suffix}`;
+}
+function renderAgentLedger(entries, opts = {}) {
+  const maxChars = opts.maxChars;
+  let visible = [...entries].sort((left, right) => left.sequence - right.sequence);
+  if (visible.length === 0) return "No peer contributions yet.";
+  for (; ; ) {
+    const text = renderAll(visible);
+    if (maxChars === void 0 || text.length <= maxChars) return text;
+    visible = visible.slice(1);
+    if (visible.length === 0) return "No peer contributions yet.";
+  }
+}
+function renderAll(entries) {
+  const states = corroboration(entries).byEntryId;
+  const disputed = disputes(entries);
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = authorKey(entry);
+    const group = groups.get(key) ?? [];
+    group.push(entry);
+    groups.set(key, group);
+  }
+  const lines = [];
+  for (const group of groups.values()) {
+    const head = group[0];
+    if (head === void 0) continue;
+    lines.push(`${head.agentId} (run ${head.runId}, node ${head.nodeId}):`);
+    for (const entry of group) {
+      lines.push(`  ${renderBody(entry, states.get(entry.id), disputed.has(entry.id))}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/domains/dispatch/execution-handoff.ts
+init_esm_shims();
+var EXECUTION_HANDOFF_MAX_ITEMS = 16;
+var EXECUTION_HANDOFF_MAX_TEXT_BYTES = 12e3;
+function truncateUtf82(value, limit) {
+  const bytes = Buffer.from(value, "utf8");
+  return bytes.length <= limit ? value : bytes.subarray(0, limit).toString("utf8");
+}
+function projectExecutionHandoffs(dependencyIds, outputs) {
+  if (dependencyIds.length > EXECUTION_HANDOFF_MAX_ITEMS)
+    throw new Error(`execution handoff: at most ${EXECUTION_HANDOFF_MAX_ITEMS} predecessors are allowed`);
+  const perItem = Math.floor(EXECUTION_HANDOFF_MAX_TEXT_BYTES / Math.max(1, dependencyIds.length));
+  return dependencyIds.map((id) => {
+    const source = outputs.get(id);
+    if (!source) throw new Error(`execution handoff: missing successful predecessor '${id}'`);
+    return { ...source, output: truncateUtf82(source.output, perItem) };
+  });
+}
+
+// src/domains/dispatch/validation.ts
+init_esm_shims();
+import path2 from "node:path";
+var DISPATCH_BRIEFING_MAX_BYTES = 12e3;
+var INTERNAL_DISPATCH_BRIEFING_MAX_BYTES = 64 * 1024;
+var KNOWN_KEYS = /* @__PURE__ */ new Set([
+  "agentId",
+  // Derived by execution-role.ts at request construction, never model-authored.
+  "executionRole",
+  "task",
+  "briefing",
+  "workerProfile",
+  "workerRuntime",
+  "delegationAgentId",
+  "target",
+  "model",
+  "thinkingLevel",
+  "node",
+  "routingIntent",
+  "failover",
+  "allowedCandidates",
+  "plannedNode",
+  "protectedArtifactRemap",
+  "reroutes",
+  "requiredCapabilities",
+  "toolProfile",
+  "denyTools",
+  "cwd",
+  "memorySection",
+  "noSkills",
+  "skillPaths",
+  "trustProjectCompatRoots",
+  "responseSchema",
+  "writeRoots",
+  "requestOrigin",
+  "pipelineInput",
+  "predecessorHandoffs",
+  "lineage",
+  "autonomy",
+  "gate",
+  "plan",
+  "competeStance"
+]);
+var VALID_COMPETE_STANCES = new Set(COMPETE_STANCES);
+var VALID_THINKING = new Set(THINKING_LEVELS);
+var VALID_REQUEST_ORIGINS = /* @__PURE__ */ new Set(["user", "agent", "internal"]);
+var VALID_FAILOVER_MODES = /* @__PURE__ */ new Set(["none", "approved", "automatic"]);
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateJobSpec(spec) {
+  const errors = [];
+  if (!isPlainObject2(spec)) {
+    return { ok: false, errors: ["spec must be an object"] };
+  }
+  for (const key of Object.keys(spec)) {
+    if (!KNOWN_KEYS.has(key)) {
+      errors.push(`unknown key: ${key}`);
+    }
+  }
+  const agentId = spec.agentId;
+  if (typeof agentId !== "string" || agentId.length === 0) {
+    errors.push("agentId must be a non-empty string");
+  }
+  const task = spec.task;
+  if (typeof task !== "string" || task.length === 0) {
+    errors.push("task must be a non-empty string");
+  }
+  if ("executionRole" in spec && !isExecutionRole(spec.executionRole)) {
+    errors.push("executionRole must be a known execution role");
+  }
+  let briefing;
+  if ("briefing" in spec && spec.briefing !== void 0) {
+    if (typeof spec.briefing !== "string") {
+      errors.push("briefing must be a string");
+    } else {
+      const normalized = spec.briefing.trim();
+      if (normalized.length > 0) {
+        const bytes = Buffer.byteLength(normalized, "utf8");
+        const maxBytes = spec.requestOrigin === "internal" ? INTERNAL_DISPATCH_BRIEFING_MAX_BYTES : DISPATCH_BRIEFING_MAX_BYTES;
+        if (bytes > maxBytes) {
+          errors.push(`briefing must be ${maxBytes} UTF-8 bytes or fewer`);
+        } else {
+          briefing = normalized;
+        }
+      }
+    }
+  }
+  if ("target" in spec && spec.target !== void 0) {
+    if (typeof spec.target !== "string" || spec.target.length === 0) {
+      errors.push("target must be a non-empty string");
+    }
+  }
+  if ("workerProfile" in spec && spec.workerProfile !== void 0) {
+    if (typeof spec.workerProfile !== "string" || spec.workerProfile.length === 0) {
+      errors.push("workerProfile must be a non-empty string");
+    }
+  }
+  if ("workerRuntime" in spec && spec.workerRuntime !== void 0) {
+    if (typeof spec.workerRuntime !== "string" || spec.workerRuntime.length === 0) {
+      errors.push("workerRuntime must be a non-empty string");
+    }
+  }
+  if ("delegationAgentId" in spec && spec.delegationAgentId !== void 0) {
+    if (typeof spec.delegationAgentId !== "string" || spec.delegationAgentId.length === 0) {
+      errors.push("delegationAgentId must be a non-empty string");
+    }
+  }
+  if ("model" in spec && spec.model !== void 0) {
+    if (typeof spec.model !== "string" || spec.model.length === 0) {
+      errors.push("model must be a non-empty string");
+    }
+  }
+  if ("node" in spec && spec.node !== void 0) {
+    if (typeof spec.node !== "string" || spec.node.trim().length === 0) {
+      errors.push("node must be a non-empty string");
+    }
+  }
+  if ("routingIntent" in spec && spec.routingIntent !== void 0 && !isRoutingIntent(spec.routingIntent)) {
+    errors.push("routingIntent must be a normalized routing intent");
+  }
+  if ("failover" in spec && spec.failover !== void 0) {
+    if (typeof spec.failover !== "string" || !VALID_FAILOVER_MODES.has(spec.failover)) {
+      errors.push("failover must be one of: none|approved|automatic");
+    }
+  }
+  if ("allowedCandidates" in spec && spec.allowedCandidates !== void 0) {
+    if (!Array.isArray(spec.allowedCandidates) || spec.allowedCandidates.length === 0 || spec.allowedCandidates.some((candidate) => !isValidFailoverCandidate(candidate))) {
+      errors.push("allowedCandidates must be a non-empty array of exact {agentId, target, model, node} tuples");
+    }
+  }
+  if (spec.failover === "approved" && (!Array.isArray(spec.allowedCandidates) || spec.allowedCandidates.length === 0)) {
+    errors.push("failover approved requires allowedCandidates");
+  }
+  if (spec.failover !== "approved" && spec.allowedCandidates !== void 0) {
+    errors.push("allowedCandidates requires failover approved");
+  }
+  if (spec.failover === "automatic" && spec.plan !== void 0) {
+    errors.push("failover automatic is not allowed on a plan-approved dispatch");
+  }
+  if ("plannedNode" in spec && spec.plannedNode !== void 0) {
+    if (!isPlainObject2(spec.plannedNode)) {
+      errors.push("plannedNode must be an object");
+    } else {
+      for (const key of Object.keys(spec.plannedNode)) {
+        if (key !== "id" && key !== "kind" && key !== "host") errors.push(`plannedNode unknown key: ${key}`);
+      }
+      if (typeof spec.plannedNode.id !== "string" || spec.plannedNode.id.trim().length === 0) {
+        errors.push("plannedNode.id must be a non-empty string");
+      }
+      if (spec.plannedNode.kind !== "local" && spec.plannedNode.kind !== "ssh") {
+        errors.push("plannedNode.kind must be local or ssh");
+      }
+      if (spec.plannedNode.kind === "ssh" && (typeof spec.plannedNode.host !== "string" || spec.plannedNode.host.trim().length === 0)) {
+        errors.push("plannedNode.host must be a non-empty string for ssh nodes");
+      }
+      if (spec.plannedNode.kind === "local" && spec.plannedNode.host !== void 0) {
+        errors.push("plannedNode.host must be absent for local nodes");
+      }
+    }
+  }
+  if ("protectedArtifactRemap" in spec && spec.protectedArtifactRemap !== void 0) {
+    if (!isPlainObject2(spec.protectedArtifactRemap) || Object.keys(spec.protectedArtifactRemap).some((key) => key !== "sourceRoot" && key !== "workerRoot") || typeof spec.protectedArtifactRemap.sourceRoot !== "string" || !path2.isAbsolute(spec.protectedArtifactRemap.sourceRoot) || typeof spec.protectedArtifactRemap.workerRoot !== "string" || !path2.isAbsolute(spec.protectedArtifactRemap.workerRoot)) {
+      errors.push("protectedArtifactRemap must carry absolute sourceRoot and workerRoot paths");
+    }
+  }
+  if ("reroutes" in spec && spec.reroutes !== void 0) {
+    if (!Array.isArray(spec.reroutes) || spec.reroutes.some((hop) => !isValidReroute(hop))) {
+      errors.push("reroutes must be an array of {attempt >= 1, fromNode (non-empty), toNode (string), reason (string)}");
+    }
+  }
+  if ("thinkingLevel" in spec && spec.thinkingLevel !== void 0) {
+    if (typeof spec.thinkingLevel !== "string" || !VALID_THINKING.has(spec.thinkingLevel)) {
+      errors.push("thinkingLevel must be one of: off|minimal|low|medium|high|xhigh");
+    }
+  }
+  if ("requiredCapabilities" in spec && spec.requiredCapabilities !== void 0) {
+    if (!Array.isArray(spec.requiredCapabilities) || spec.requiredCapabilities.some((c) => typeof c !== "string")) {
+      errors.push("requiredCapabilities must be a string[]");
+    }
+  }
+  if ("toolProfile" in spec && spec.toolProfile !== void 0) {
+    if (typeof spec.toolProfile !== "string" || !isToolProfileName(spec.toolProfile)) {
+      errors.push("toolProfile must be one of: minimal-local|science-local|full-agent");
+    }
+  }
+  if ("denyTools" in spec && spec.denyTools !== void 0) {
+    if (!Array.isArray(spec.denyTools) || spec.denyTools.some((tool) => typeof tool !== "string" || tool.length === 0)) {
+      errors.push("denyTools must be an array of non-empty strings");
+    }
+  }
+  if ("cwd" in spec && spec.cwd !== void 0) {
+    if (typeof spec.cwd !== "string" || spec.cwd.length === 0) {
+      errors.push("cwd must be a non-empty string");
+    }
+  }
+  if ("memorySection" in spec && spec.memorySection !== void 0) {
+    if (typeof spec.memorySection !== "string") {
+      errors.push("memorySection must be a string");
+    }
+  }
+  if ("noSkills" in spec && spec.noSkills !== void 0) {
+    if (typeof spec.noSkills !== "boolean") {
+      errors.push("noSkills must be a boolean");
+    }
+  }
+  if ("skillPaths" in spec && spec.skillPaths !== void 0) {
+    if (!Array.isArray(spec.skillPaths) || spec.skillPaths.some((p) => typeof p !== "string")) {
+      errors.push("skillPaths must be a string[]");
+    }
+  }
+  if ("trustProjectCompatRoots" in spec && spec.trustProjectCompatRoots !== void 0) {
+    if (typeof spec.trustProjectCompatRoots !== "boolean") {
+      errors.push("trustProjectCompatRoots must be a boolean");
+    }
+  }
+  let responseSchema;
+  if ("responseSchema" in spec && spec.responseSchema !== void 0) {
+    try {
+      responseSchema = cloneValidatedResponseSchema(spec.responseSchema);
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if ("writeRoots" in spec && spec.writeRoots !== void 0) {
+    if (!Array.isArray(spec.writeRoots) || spec.writeRoots.length === 0 || spec.writeRoots.some((root) => typeof root !== "string" || root.length === 0)) {
+      errors.push("writeRoots must be a non-empty array of non-empty strings");
+    }
+  }
+  if ("requestOrigin" in spec && spec.requestOrigin !== void 0) {
+    if (typeof spec.requestOrigin !== "string" || !VALID_REQUEST_ORIGINS.has(spec.requestOrigin)) {
+      errors.push("requestOrigin must be one of: user|agent|internal");
+    }
+  }
+  if ("pipelineInput" in spec && spec.pipelineInput !== void 0) {
+    if (!isValidPipelineInput(spec.pipelineInput)) {
+      errors.push("pipelineInput must carry fromRunId (string|null), position (integer >= 1), text (string)");
+    }
+  }
+  if ("predecessorHandoffs" in spec && spec.predecessorHandoffs !== void 0 && !isValidPredecessorHandoffs(spec.predecessorHandoffs)) {
+    errors.push(
+      `predecessorHandoffs must contain at most ${EXECUTION_HANDOFF_MAX_ITEMS} authenticated bounded terminal outputs`
+    );
+  }
+  if ("lineage" in spec && spec.lineage !== void 0) {
+    if (!isValidLineage(spec.lineage)) {
+      errors.push("lineage must carry parentRunId (string|null), rootRunId (string), attempt >= 0, depth >= 0");
+    }
+  }
+  if ("autonomy" in spec && spec.autonomy !== void 0) {
+    if (!isAutonomyLevel(spec.autonomy)) {
+      errors.push("autonomy must be one of: read-only|suggest|auto-edit|full-auto");
+    }
+  }
+  if ("gate" in spec && spec.gate !== void 0) {
+    if (!isValidGate(spec.gate)) {
+      errors.push(
+        "gate must carry role (builder|reviewer|candidate|judge), group (non-empty), cycle >= 1, optional subjects [{runId, digest|null}], optional verdict (pass|fail|revise)"
+      );
+    }
+  }
+  if ("plan" in spec && spec.plan !== void 0) {
+    if (!isValidPlan(spec.plan)) {
+      errors.push(
+        "plan must carry hash (non-empty), topology (parallel|sequential|pipeline|review|compete|detached), taskCount >= 1, approval (operator|full-auto), optional costCeilingUsd > 0"
+      );
+    }
+  }
+  if ("competeStance" in spec && spec.competeStance !== void 0) {
+    if (typeof spec.competeStance !== "string" || !VALID_COMPETE_STANCES.has(spec.competeStance)) {
+      errors.push(`competeStance must be one of ${[...VALID_COMPETE_STANCES].join("|")}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  const out = {
+    agentId,
+    task
+  };
+  if (briefing !== void 0) out.briefing = briefing;
+  if (typeof spec.workerProfile === "string") out.workerProfile = spec.workerProfile;
+  if (typeof spec.workerRuntime === "string") out.workerRuntime = spec.workerRuntime;
+  if (typeof spec.delegationAgentId === "string") out.delegationAgentId = spec.delegationAgentId;
+  if (typeof spec.target === "string") out.target = spec.target;
+  if (typeof spec.model === "string") out.model = spec.model;
+  if (typeof spec.node === "string") out.node = spec.node.trim();
+  if (isRoutingIntent(spec.routingIntent)) out.routingIntent = structuredClone(spec.routingIntent);
+  if (typeof spec.failover === "string" && VALID_FAILOVER_MODES.has(spec.failover)) {
+    out.failover = spec.failover;
+  }
+  if (Array.isArray(spec.allowedCandidates) && spec.allowedCandidates.every(isValidFailoverCandidate)) {
+    out.allowedCandidates = spec.allowedCandidates.map((candidate) => ({ ...candidate }));
+  }
+  if (isValidPlannedNode(spec.plannedNode)) out.plannedNode = { ...spec.plannedNode };
+  if (isValidProtectedArtifactRemap(spec.protectedArtifactRemap)) {
+    out.protectedArtifactRemap = { ...spec.protectedArtifactRemap };
+  }
+  if (Array.isArray(spec.reroutes) && spec.reroutes.every((hop) => isValidReroute(hop))) {
+    out.reroutes = spec.reroutes.map((hop) => ({ ...hop }));
+  }
+  if (typeof spec.thinkingLevel === "string") out.thinkingLevel = spec.thinkingLevel;
+  if (Array.isArray(spec.requiredCapabilities)) {
+    out.requiredCapabilities = spec.requiredCapabilities.map((c) => String(c));
+  }
+  if (typeof spec.toolProfile === "string" && isToolProfileName(spec.toolProfile)) out.toolProfile = spec.toolProfile;
+  if (Array.isArray(spec.denyTools)) out.denyTools = spec.denyTools.map((tool) => String(tool));
+  if (typeof spec.cwd === "string") out.cwd = spec.cwd;
+  if (typeof spec.memorySection === "string") out.memorySection = spec.memorySection;
+  if (typeof spec.noSkills === "boolean") out.noSkills = spec.noSkills;
+  if (Array.isArray(spec.skillPaths)) out.skillPaths = spec.skillPaths.map((p) => String(p));
+  if (typeof spec.trustProjectCompatRoots === "boolean") out.trustProjectCompatRoots = spec.trustProjectCompatRoots;
+  if (responseSchema) out.responseSchema = responseSchema;
+  if (Array.isArray(spec.writeRoots) && spec.writeRoots.length > 0 && spec.writeRoots.every((root) => typeof root === "string" && root.length > 0)) {
+    const jobCwd = typeof spec.cwd === "string" && spec.cwd.length > 0 ? spec.cwd : process.cwd();
+    out.writeRoots = spec.writeRoots.map((root) => path2.resolve(jobCwd, String(root)));
+  }
+  if (typeof spec.requestOrigin === "string" && VALID_REQUEST_ORIGINS.has(spec.requestOrigin)) {
+    out.requestOrigin = spec.requestOrigin;
+  }
+  if (isValidPipelineInput(spec.pipelineInput)) out.pipelineInput = spec.pipelineInput;
+  if (isValidPredecessorHandoffs(spec.predecessorHandoffs))
+    out.predecessorHandoffs = spec.predecessorHandoffs.map((handoff) => ({ ...handoff }));
+  if (isValidLineage(spec.lineage)) out.lineage = spec.lineage;
+  if (isAutonomyLevel(spec.autonomy)) out.autonomy = spec.autonomy;
+  if (isValidGate(spec.gate)) out.gate = cloneGate(spec.gate);
+  if (typeof spec.competeStance === "string" && VALID_COMPETE_STANCES.has(spec.competeStance)) {
+    out.competeStance = spec.competeStance;
+  }
+  if (isValidPlan(spec.plan)) {
+    out.plan = { ...spec.plan, source: spec.plan.source === null ? null : { ...spec.plan.source } };
+  }
+  return { ok: true, spec: out };
+}
+function isValidPredecessorHandoffs(value) {
+  if (!Array.isArray(value) || value.length > EXECUTION_HANDOFF_MAX_ITEMS || Buffer.byteLength(JSON.stringify(value), "utf8") > EXECUTION_HANDOFF_MAX_TEXT_BYTES * 2)
+    return false;
+  return value.every((candidate) => {
+    if (!isPlainObject2(candidate)) return false;
+    const fields = [
+      candidate.stepId,
+      candidate.assignmentId,
+      candidate.terminalRunId,
+      candidate.receiptDigest,
+      candidate.output
+    ];
+    return fields.every((field) => typeof field === "string") && typeof candidate.stepId === "string" && candidate.stepId.length > 0 && typeof candidate.assignmentId === "string" && candidate.assignmentId.length > 0 && typeof candidate.terminalRunId === "string" && candidate.terminalRunId.length > 0 && typeof candidate.receiptDigest === "string" && /^[a-f0-9]{64}$/.test(candidate.receiptDigest);
+  });
+}
+function isValidPipelineInput(value) {
+  if (!isPlainObject2(value)) return false;
+  const fromRunOk = value.fromRunId === null || typeof value.fromRunId === "string" && value.fromRunId.length > 0;
+  const positionOk = typeof value.position === "number" && Number.isInteger(value.position) && value.position >= 1;
+  const textOk = typeof value.text === "string";
+  return fromRunOk && positionOk && textOk;
+}
+function isValidReroute(value) {
+  if (!isPlainObject2(value)) return false;
+  const attemptOk = typeof value.attempt === "number" && Number.isInteger(value.attempt) && value.attempt >= 1;
+  const fromOk = typeof value.fromNode === "string" && value.fromNode.length > 0;
+  const toOk = typeof value.toNode === "string";
+  const reasonOk = typeof value.reason === "string";
+  return attemptOk && fromOk && toOk && reasonOk;
+}
+function isValidFailoverCandidate(value) {
+  if (!isPlainObject2(value)) return false;
+  if (Object.keys(value).some((key) => key !== "agentId" && key !== "target" && key !== "model" && key !== "node")) {
+    return false;
+  }
+  return [value.agentId, value.target, value.model, value.node].every(
+    (part) => typeof part === "string" && part.trim().length > 0
+  );
+}
+function isValidPlannedNode(value) {
+  if (!isPlainObject2(value) || typeof value.id !== "string" || value.id.trim().length === 0) return false;
+  if (value.kind === "local") return value.host === void 0;
+  return value.kind === "ssh" && typeof value.host === "string" && value.host.trim().length > 0;
+}
+function isValidProtectedArtifactRemap(value) {
+  return isPlainObject2(value) && typeof value.sourceRoot === "string" && path2.isAbsolute(value.sourceRoot) && typeof value.workerRoot === "string" && path2.isAbsolute(value.workerRoot);
+}
+var VALID_GATE_ROLES = /* @__PURE__ */ new Set(["builder", "reviewer", "candidate", "judge"]);
+var VALID_GATE_VERDICTS = /* @__PURE__ */ new Set(["pass", "fail", "revise"]);
+var VALID_PLAN_TOPOLOGIES = /* @__PURE__ */ new Set(["parallel", "sequential", "pipeline", "review", "compete", "detached", "fleet"]);
+var VALID_PLAN_APPROVALS = /* @__PURE__ */ new Set(["operator", "full-auto"]);
+function isValidGate(value) {
+  if (!isPlainObject2(value)) return false;
+  if (typeof value.role !== "string" || !VALID_GATE_ROLES.has(value.role)) return false;
+  if (typeof value.group !== "string" || value.group.length === 0) return false;
+  if (typeof value.cycle !== "number" || !Number.isInteger(value.cycle) || value.cycle < 1) return false;
+  if (value.subjects !== void 0) {
+    if (!Array.isArray(value.subjects)) return false;
+    for (const subject of value.subjects) {
+      if (!isPlainObject2(subject)) return false;
+      if (typeof subject.runId !== "string" || subject.runId.length === 0) return false;
+      if (subject.digest !== null && typeof subject.digest !== "string") return false;
+    }
+  }
+  if (value.verdict !== void 0 && (typeof value.verdict !== "string" || !VALID_GATE_VERDICTS.has(value.verdict))) {
+    return false;
+  }
+  return true;
+}
+function cloneGate(gate) {
+  return {
+    role: gate.role,
+    group: gate.group,
+    cycle: gate.cycle,
+    ...gate.subjects !== void 0 ? { subjects: gate.subjects.map((subject) => ({ ...subject })) } : {},
+    ...gate.verdict !== void 0 ? { verdict: gate.verdict } : {}
+  };
+}
+function isValidPlan(value) {
+  if (!isPlainObject2(value)) return false;
+  if (typeof value.hash !== "string" || value.hash.length === 0) return false;
+  if (typeof value.topology !== "string" || !VALID_PLAN_TOPOLOGIES.has(value.topology)) return false;
+  if (typeof value.taskCount !== "number" || !Number.isInteger(value.taskCount) || value.taskCount < 1) return false;
+  if (typeof value.approval !== "string" || !VALID_PLAN_APPROVALS.has(value.approval)) return false;
+  if (value.source !== null) {
+    if (!isPlainObject2(value.source) || value.source.kind !== "scout-transition" || typeof value.source.runId !== "string" || value.source.runId.length === 0 || typeof value.source.receiptDigest !== "string" || !/^[0-9a-f]{64}$/u.test(value.source.receiptDigest) || typeof value.source.executionPlanHash !== "string" || !/^[0-9a-f]{64}$/u.test(value.source.executionPlanHash))
+      return false;
+  }
+  if (value.approvalRequestId !== void 0 && (typeof value.approvalRequestId !== "string" || value.approvalRequestId.length === 0)) {
+    return false;
+  }
+  if (value.approvalRequestedBy !== void 0 && (typeof value.approvalRequestedBy !== "string" || value.approvalRequestedBy.length === 0)) {
+    return false;
+  }
+  if (value.costCeilingUsd !== void 0 && (typeof value.costCeilingUsd !== "number" || value.costCeilingUsd <= 0)) {
+    return false;
+  }
+  return true;
+}
+function isValidLineage(value) {
+  if (!isPlainObject2(value)) return false;
+  const parentOk = value.parentRunId === null || typeof value.parentRunId === "string" && value.parentRunId.length > 0;
+  const rootOk = typeof value.rootRunId === "string" && value.rootRunId.length > 0;
+  const attemptOk = typeof value.attempt === "number" && Number.isInteger(value.attempt) && value.attempt >= 0;
+  const depthOk = typeof value.depth === "number" && Number.isInteger(value.depth) && value.depth >= 0;
+  return parentOk && rootOk && attemptOk && depthOk;
+}
+
+// src/engine/claude/tool-safety.ts
+init_esm_shims();
+import { performance } from "node:perf_hooks";
+function isRecord2(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 path3 = stringField(input, "file_path", "filePath", "path", "notebook_path", "source", "target");
+  return path3 ? { ...input, path: path3 } : { ...input };
+}
+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: pathArgs(input), known: true };
+    case "Glob":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Find, args: pathArgs(input), known: true };
+    case "LS":
+    case "Ls":
+      return { claudeToolName: toolName, clioToolName: ToolNames.Ls, args: pathArgs(input), 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 toAutonomyBlock(decision, level, call) {
+  const actionClass = decision.classification.actionClass;
+  return {
+    kind: "block",
+    classification: decision.classification,
+    rejection: autonomyDenyRejection(level, call.tool, actionClass),
+    ...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),
+    ...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"
+  });
+  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) {
+  const event = {
+    tool: mapped.clioToolName,
+    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_tool_finish", payload: event });
+}
+function emitClaudeToolPermissionDecision(input) {
+  const startedAt = Date.now();
+  const startedAtClock = performance.now();
+  const decision = evaluateClaudeToolPermission(input);
+  const start = {
+    tool: decision.mapped.clioToolName,
+    posture: "operating",
+    startedAt
+  };
+  input.emit({ type: "clio_tool_start", payload: start });
+  if (decision.kind === "allow") {
+    emitToolFinish(
+      input.emit,
+      decision.mapped,
+      startedAtClock,
+      decision.decision,
+      "ok",
+      decision.reason,
+      decision.reasonCode
+    );
+    return decision;
+  }
+  if (decision.permissionRequired) {
+    const mode = input.onPermission ?? "deny";
+    input.emit({
+      type: "clio_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
+  );
+  return decision;
+}
+function coerceToolInput(value) {
+  return isRecord2(value) ? value : {};
+}
+
+// src/domains/dispatch/agent-candidates.ts
+init_esm_shims();
+var AGENT_CANDIDATE_LIMIT = 64;
+var TASK_TYPE_RULES = [
+  ["test", /\b(tests?|unit tests?|coverage|spec file)\b/i],
+  ["docs", /\b(documentation|docs|readme|changelog|comment|docstring)\b/i],
+  ["code_review", /\b(review|audit|critique|inspect for)\b/i],
+  ["debug", /\b(debug|fix|bug|crash|failure|broken|regression)\b/i],
+  ["refactor", /\b(refactor|clean ?up|restructure|rename|extract|simplify)\b/i],
+  ["config", /\b(config|configuration|settings|setup|install|ci pipeline|workflow file)\b/i],
+  ["research", /\b(research|investigate|explore|survey|compare|find out)\b/i],
+  ["code_read", /\b(read|explain|understand|summarize|describe|walk through|map|locate|trace)\b/i],
+  ["code_write", /\b(write|implement|add|create|build|develop|introduce)\b/i]
+];
+var DOMAIN_RULES = [
+  ["security", /\b(security|vulnerabilit|auth|credential|secret|cve)\b/i],
+  ["frontend", /\b(ui|css|react|component|frontend|tui|overlay)\b/i],
+  ["infra", /\b(docker|kubernetes|k8s|deploy|terraform|infra|slurm|cluster)\b/i],
+  ["data", /\b(dataset|etl|pipeline data|schema migration|parquet|hdf5)\b/i],
+  ["backend", /\b(api|server|endpoint|database|backend|service)\b/i]
+];
+function classifyAgentTask(task) {
+  const text = task.trim();
+  const taskType = TASK_TYPE_RULES.find(([, pattern]) => pattern.test(text))?.[0] ?? "unknown";
+  const domain = DOMAIN_RULES.find(([, pattern]) => pattern.test(text))?.[0] ?? "general";
+  const words = text.split(/\s+/u).filter(Boolean).length;
+  const complexity = words <= 6 ? "trivial" : words <= 25 ? "simple" : words <= 80 ? "moderate" : "complex";
+  const enumerated = (text.match(/(^|\n)\s*(\d+[.)]|[-*])\s+/gu) ?? []).length;
+  const conjunctions = (text.match(/\b(and then|and also|; )\b/giu) ?? []).length;
+  const estimatedSubtasks = Math.max(1, Math.min(4, enumerated > 1 ? enumerated : conjunctions > 0 ? 2 : 1));
+  return {
+    taskType,
+    complexity,
+    domain,
+    decomposable: estimatedSubtasks > 1,
+    estimatedSubtasks,
+    confidence: taskType === "unknown" ? 0.3 : 0.7
+  };
+}
+function agentRouteCandidates(input) {
+  const { request, specs } = input;
+  const byId = new Map(specs.map((spec) => [spec.id, spec]));
+  const baselineSpec = byId.get(request.agentId);
+  const auto = request.agentSelection?.mode === "auto";
+  const recovery = (request.lineage?.attempt ?? 0) > 0;
+  const allowedAgentIds = recovery ? [...new Set((request.allowedCandidates ?? []).map((candidate) => candidate.agentId))] : input.mode === "active" ? auto ? specs.filter((spec) => {
+    const role = deriveExecutionRole({
+      attempt: 0,
+      capabilityClass: spec.capabilityClass,
+      resultContractKind: spec.resultContract.kind
+    });
+    return input.activeAgentRoles.some((pair) => pair.agentId === spec.id && pair.executionRole === role);
+  }).map((spec) => spec.id) : [request.agentId] : null;
+  const baselineAuthority = baselineSpec?.capabilityClass;
+  const candidates = evaluateAgentCandidates(specs, {
+    selectionMode: auto ? "auto" : "explicit",
+    baselineAgentId: request.agentSelection?.baselineAgentId ?? request.agentId,
+    approvedAudiences: ["base", "shadow", "custom"],
+    approvedAuthorities: input.intentOverride !== void 0 ? [input.intentOverride.requestedAuthority] : auto ? request.agentSelection?.approvedAuthorities ?? [] : baselineAuthority !== void 0 && AGENT_AUTOMATION_AUTHORITIES.includes(baselineAuthority) ? [baselineAuthority] : [],
+    requiredTools: [],
+    requiredSkills: [],
+    expectedResultContractKind: input.intentOverride?.expectedResultContractKind ?? (auto ? null : baselineSpec?.resultContract.kind ?? null),
+    locality: request.routingIntent?.locality ?? "any",
+    localAgentIds: specs.map((spec) => spec.id),
+    allowedAgentIds,
+    features: classifyAgentTask(request.task)
+  });
+  const evaluations = candidates.evaluations.map((evaluation) => ({
+    ...evaluation,
+    executionRole: recovery ? "recovery" : evaluation.executionRole
+  }));
+  return {
+    evaluations,
+    dimensions: evaluations.filter((evaluation) => evaluation.rejections.length === 0).map((evaluation) => ({
+      agentId: evaluation.agentId,
+      specFingerprint: evaluation.specFingerprint,
+      executionRole: evaluation.executionRole,
+      latencyClass: byId.get(evaluation.agentId)?.latencyClass ?? "balanced",
+      coldPrior: evaluation.coldPrior
+    }))
+  };
+}
+var TASK_SIGNALS = {
+  code_read: { ids: ["scout"], tags: ["reconnaissance", "symbols", "codewiki"], contracts: ["scout-report"] },
+  research: { ids: ["researcher"], tags: ["sources", "external-context", "papers"], contracts: ["research-report"] },
+  code_review: { ids: ["verifier"], tags: ["review", "verification"], contracts: ["verifier-report"] },
+  debug: { ids: ["debugger"], tags: ["debugging", "root-cause"], contracts: ["debugger-report"] },
+  test: { ids: ["verifier", "tester"], tags: ["tests", "validation", "regression"], contracts: ["verifier-report"] },
+  docs: { ids: ["documenter"], tags: ["docs", "runbooks", "examples"], contracts: ["mutation-report"] },
+  code_write: { ids: ["coder"], tags: ["implementation", "repair"], contracts: ["mutation-report"] },
+  refactor: { ids: ["coder"], tags: ["refactor", "implementation"], contracts: ["mutation-report"] },
+  config: { ids: ["coder"], tags: ["implementation", "operations"], contracts: ["mutation-report"] }
+};
+function coldPrior(features, spec) {
+  const prior = routePriorForLatencyClass(spec.latencyClass);
+  const reasons = [`latency-class:${spec.latencyClass}`];
+  const signal = TASK_SIGNALS[features.taskType];
+  if (signal === void 0) return { prior, reasons };
+  const matches = signal.ids.includes(spec.id) || spec.tags.some((tag) => signal.tags.includes(tag)) || signal.contracts.includes(spec.resultContract.kind);
+  if (!matches) return { prior, reasons };
+  const confidence = Math.max(0, Math.min(1, features.confidence));
+  prior.qualityMean = Math.min(1, prior.qualityMean + 0.15 * confidence);
+  prior.firstPassSuccessProbability = Math.min(1, prior.firstPassSuccessProbability + 0.1 * confidence);
+  prior.reliability = Math.min(1, prior.reliability + 0.05 * confidence);
+  prior.expectedEndToEndMs *= 1 - 0.15 * confidence;
+  reasons.push(`bounded-task-feature:${features.taskType}`);
+  return { prior, reasons };
+}
+function candidateRejections(spec, intent) {
+  const rejections = [];
+  if (!intent.approvedAudiences.includes(spec.audience)) rejections.push(`audience:${spec.audience}`);
+  if (!intent.approvedAuthorities.includes(spec.capabilityClass)) {
+    rejections.push(`authority:${spec.capabilityClass}`);
+  }
+  for (const tool of intent.requiredTools) if (!spec.tools.includes(tool)) rejections.push(`required-tool:${tool}`);
+  for (const skill of intent.requiredSkills)
+    if (!spec.skills.includes(skill)) rejections.push(`required-skill:${skill}`);
+  if (intent.expectedResultContractKind !== null && spec.resultContract.kind !== intent.expectedResultContractKind) {
+    rejections.push(`result-contract:${spec.resultContract.kind}`);
+  }
+  if (intent.locality === "local-only" && !intent.localAgentIds.includes(spec.id)) rejections.push("locality:not-local");
+  if (intent.allowedAgentIds !== null && !intent.allowedAgentIds.includes(spec.id))
+    rejections.push("governance:not-approved");
+  return rejections;
+}
+function evaluateAgentCandidates(specs, intent) {
+  if (specs.length > AGENT_CANDIDATE_LIMIT) {
+    throw new Error(
+      `dispatch routing configuration error: agent candidate overflow (${specs.length}/${AGENT_CANDIDATE_LIMIT})`
+    );
+  }
+  const evaluations = specs.map((spec) => {
+    const { prior, reasons } = coldPrior(intent.features, spec);
+    return {
+      agentId: spec.id,
+      specFingerprint: agentSpecFingerprint(spec),
+      executionRole: deriveExecutionRole({
+        attempt: 0,
+        capabilityClass: spec.capabilityClass,
+        resultContractKind: spec.resultContract.kind
+      }),
+      authority: spec.capabilityClass,
+      rejections: candidateRejections(spec, intent),
+      coldPrior: prior,
+      priorReasons: reasons
+    };
+  });
+  return { evaluations, eligible: evaluations.filter((evaluation) => evaluation.rejections.length === 0) };
+}
+function agentRoleReadinessReport(entries) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = `${entry.candidate.agentId}\0${entry.candidate.specFingerprint}\0${entry.candidate.executionRole}`;
+    const group = groups.get(key) ?? [];
+    group.push(entry);
+    groups.set(key, group);
+  }
+  return [...groups.values()].map((routes) => ({
+    agentId: routes[0]?.candidate.agentId ?? "",
+    specFingerprint: routes[0]?.candidate.specFingerprint ?? "",
+    executionRole: routes[0]?.candidate.executionRole ?? "builder",
+    ready: routes.some((route) => route.report.ready),
+    candidateCount: routes.length,
+    readyCandidateCount: routes.filter((route) => route.report.ready).length,
+    routes
+  }));
+}
+
+export {
+  RESPONSE_SCHEMA_RUNTIME_ID,
+  runtimeSpeaksResponseSchemaDialect,
+  responseSchemaConflictsWithTools,
+  UnsupportedResponseSchemaError,
+  isResponseSchemaRejection,
+  TOOL_PROFILE_NAMES,
+  isToolProfileName,
+  assertToolProfileEnforceable,
+  applyToolProfile,
+  antigravitySubprocessConfigForAutonomy,
+  startAntigravityWorkerRun,
+  isClaudeCodeSessionId,
+  claudeSubprocessPermissionConfigForAutonomy,
+  startClaudeCodeWorkerRun,
+  isClaudeCanonicalTool,
+  claudeToolsOutsideProfile,
+  emitClaudeToolPermissionDecision,
+  coerceToolInput,
+  WORKER_RUNTIME_MEDIATES_CLIO_DISPATCH,
+  readMaxBytes,
+  readTool,
+  toolPromptHintsForNames,
+  builtin,
+  NO_NETWORK_TOOLS_ENV,
+  networkToolsDisabled,
+  WORKER_SPEC_VERSION,
+  WORKER_PROTECTED_ARTIFACT_STATE_VERSION,
+  WORKER_EXIT_PERMISSION_REQUIRED,
+  DEFAULT_ESCALATION_TIMEOUT_MS,
+  DEFAULT_ESCALATION_FALLBACK,
+  serializeWorkerRuntimeDescriptor,
+  parseWorkerSpec,
+  validateRehydratedWorkerRuntime,
+  createRunEffectsRecorder,
+  isApprovedAssignmentRoute,
+  assertApprovedAssignmentRoute,
+  cloneApprovedAssignmentRoute,
+  approvedRouteCandidates,
+  assertApprovedRecoveryCapability,
+  classifyAgentTask,
+  agentRouteCandidates,
+  agentRoleReadinessReport,
+  AGENT_LEDGER_PROMPT_MAX_CHARS,
+  claimConflicts,
+  renderAgentLedger,
+  REVIEWER_GATE_PROMPT,
+  JUDGE_GATE_PROMPT,
+  COMPETE_STANCES,
+  competeStanceLiner,
+  isBoundedGateRolePrompt,
+  isRunOutcomeCode,
+  RETRYABLE_OUTCOMES,
+  isTerminalRunEnvelope,
+  runKindSupportsLiveSteering,
+  projectExecutionHandoffs,
+  DISPATCH_BRIEFING_MAX_BYTES,
+  validateJobSpec,
+  isSessionHeader,
+  isSessionEntry,
+  taskBoardCounts,
+  foldSessionTaskHistory,
+  createTaskBoardStore
+};
+//# sourceMappingURL=chunk-MQSRRFWA.js.map