@iowarp/clio-coder 0.3.4 → 0.3.6

package/dist/{chunk-ZYKPLLNQ.js → chunk-XXQNGV4M.js}

@@ -1,12 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  DEFAULT_AUTONOMY_LEVEL,
-  autonomyAskRejection,
-  autonomyDenyRejection,
-  isAutonomyLevel,
-  mapAutonomy,
   typedValidationSummary
-} from "./chunk-7RXG6QRZ.js";
+} from "./chunk-EKY57CSP.js";
 import {
   ROUTE_POLICY_VERSION,
   deriveExecutionRole,
@@ -31,6 +26,13 @@ import {
   expandPath,
   resolveReadPath
 } from "./chunk-OQE5J4C6.js";
+import {
+  DEFAULT_AUTONOMY_LEVEL,
+  autonomyAskRejection,
+  autonomyDenyRejection,
+  isAutonomyLevel,
+  mapAutonomy
+} from "./chunk-HWUFFB6L.js";
 import {
   DEFAULT_MAX_LINES,
   OBSERVATION_POLICY_SLACK_BYTES,
@@ -43,7 +45,7 @@ import {
   splitLinesForCounting,
   truncateHead,
   truncateTail
-} from "./chunk-5M54SPOL.js";
+} from "./chunk-ODFEOB4F.js";
 import {
   formatSize
 } from "./chunk-OZNBF4L3.js";
@@ -799,10 +801,13 @@ function validateAllowedTools(value) {
 }
 function validateWorkerBudget(value) {
   const budget = readRecord(value, "WorkerSpec.budget");
-  const expected = ["hardCap", "readReserve", "synthesis", "toolCalls"];
+  const expected = ["hardCap", "readReserve", "revision", "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(", ")}`);
+  if (actual.some((key) => !expected.includes(key)) || actual.some((key) => key === "revision" && budget.revision === void 0)) {
+    throw new Error(`WorkerSpec.budget may contain only: ${expected.join(", ")}`);
+  }
+  for (const required of ["hardCap", "readReserve", "synthesis", "toolCalls"]) {
+    if (!Object.hasOwn(budget, required)) throw new Error(`WorkerSpec.budget.${required} is required`);
   }
   for (const key of ["toolCalls", "readReserve", "hardCap"]) {
     const value2 = budget[key];
@@ -819,6 +824,30 @@ function validateWorkerBudget(value) {
     throw new Error("WorkerSpec.budget.readReserve must be an integer in [0, toolCalls)");
   }
   if (typeof budget.synthesis !== "boolean") throw new Error("WorkerSpec.budget.synthesis must be a boolean");
+  if (budget.revision !== void 0) {
+    const revision = readRecord(budget.revision, "WorkerSpec.budget.revision");
+    const revisionKeys = Object.keys(revision).sort();
+    if (revisionKeys.length !== 2 || revisionKeys[0] !== "readReserve" || revisionKeys[1] !== "toolCalls") {
+      throw new Error("WorkerSpec.budget.revision must contain exactly: readReserve, toolCalls");
+    }
+    for (const key of ["toolCalls", "readReserve"]) {
+      if (typeof revision[key] !== "number" || !Number.isSafeInteger(revision[key])) {
+        throw new Error(`WorkerSpec.budget.revision.${key} must be a safe integer`);
+      }
+    }
+    if (revision.toolCalls < budget.toolCalls) {
+      throw new Error("WorkerSpec.budget.revision.toolCalls must not be smaller than WorkerSpec.budget.toolCalls");
+    }
+    if (revision.toolCalls === budget.toolCalls && revision.readReserve <= budget.readReserve) {
+      throw new Error("WorkerSpec.budget.revision must increase toolCalls or readReserve");
+    }
+    if (revision.toolCalls > budget.hardCap) {
+      throw new Error("WorkerSpec.budget.revision.toolCalls must not exceed WorkerSpec.budget.hardCap");
+    }
+    if (revision.readReserve < 0 || revision.readReserve >= revision.toolCalls) {
+      throw new Error("WorkerSpec.budget.revision.readReserve must be an integer in [0, toolCalls)");
+    }
+  }
 }
 function validateRuntimeCapabilityDecision(value, source) {
   const caps = readRecord(value, source);
@@ -1042,6 +1071,293 @@ function validateRehydratedWorkerRuntime(spec, runtime) {
   }
 }
 
+// src/domains/dispatch/budget-envelope.ts
+init_esm_shims();
+var BudgetAdmissionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(`dispatch: budget admission denied (${code}): ${message}`);
+    this.name = "BudgetAdmissionError";
+    this.code = code;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clonePhase(value, prefix) {
+  if (!isRecord(value)) throw new Error(`${prefix} must be an object`);
+  for (const key of Object.keys(value)) {
+    if (key !== "toolCalls" && key !== "readReserve") throw new Error(`${prefix}.${key} is unknown`);
+  }
+  for (const key of ["toolCalls", "readReserve"]) {
+    if (!Object.hasOwn(value, key)) throw new Error(`${prefix}.${key} is required`);
+  }
+  const toolCalls = value.toolCalls;
+  if (typeof toolCalls !== "number" || !Number.isSafeInteger(toolCalls) || toolCalls <= 0) {
+    throw new Error(`${prefix}.toolCalls must be a positive safe integer`);
+  }
+  const readReserve = value.readReserve;
+  if (typeof readReserve !== "number" || !Number.isSafeInteger(readReserve) || readReserve < 0) {
+    throw new Error(`${prefix}.readReserve must be a non-negative safe integer`);
+  }
+  if (readReserve >= toolCalls) throw new Error(`${prefix}.readReserve must be less than ${prefix}.toolCalls`);
+  return { toolCalls, readReserve };
+}
+function cloneDispatchBudgetRequest(value, prefix = "budget") {
+  if (!isRecord(value)) throw new Error(`${prefix} must be an object`);
+  for (const key of Object.keys(value)) {
+    if (key !== "toolCalls" && key !== "readReserve" && key !== "retryRevision") {
+      throw new Error(`${prefix}.${key} is unknown`);
+    }
+  }
+  const phase = clonePhase({ toolCalls: value.toolCalls, readReserve: value.readReserve }, prefix);
+  const retryRevision = value.retryRevision === void 0 ? void 0 : clonePhase(value.retryRevision, `${prefix}.retryRevision`);
+  return { ...phase, ...retryRevision === void 0 ? {} : { retryRevision } };
+}
+function freezeEnvelope(envelope) {
+  Object.freeze(envelope.policy.default);
+  Object.freeze(envelope.policy.maximum);
+  Object.freeze(envelope.policy);
+  if (envelope.request !== null) {
+    if (envelope.request.retryRevision !== void 0) Object.freeze(envelope.request.retryRevision);
+    Object.freeze(envelope.request);
+  }
+  Object.freeze(envelope.effective);
+  for (const reason of envelope.reasons) Object.freeze(reason);
+  Object.freeze(envelope.reasons);
+  return Object.freeze(envelope);
+}
+function phaseWithin(candidate, maximum) {
+  return candidate.toolCalls <= maximum.toolCalls && candidate.readReserve <= maximum.readReserve;
+}
+function samePhase(left, right) {
+  return left.toolCalls === right.toolCalls && left.readReserve === right.readReserve;
+}
+function assertRequestAdmitted(input) {
+  const { request, policy, hardCap } = input;
+  const authoredMaximum = policy.maximum ?? policy;
+  if (policy.maximum === void 0 && !samePhase(request, policy)) {
+    throw new BudgetAdmissionError(
+      "exact-recipe-policy",
+      `the recipe pins ${policy.toolCalls} tool calls with a read reserve of ${policy.readReserve}`
+    );
+  }
+  if (!phaseWithin(request, authoredMaximum)) {
+    throw new BudgetAdmissionError(
+      "recipe-maximum",
+      `the requested phase ${request.toolCalls}/${request.readReserve} exceeds recipe maximum ${authoredMaximum.toolCalls}/${authoredMaximum.readReserve}`
+    );
+  }
+  if (request.toolCalls > hardCap) {
+    throw new BudgetAdmissionError(
+      "global-cap",
+      `the requested ${request.toolCalls} tool calls exceed the operator cap of ${hardCap}`
+    );
+  }
+  const ceiling = request.retryRevision;
+  if (ceiling === void 0) return;
+  if (ceiling.toolCalls < request.toolCalls || ceiling.readReserve < request.readReserve) {
+    throw new BudgetAdmissionError(
+      "ceiling-below-request",
+      `retryRevision ${ceiling.toolCalls}/${ceiling.readReserve} must not be smaller than the requested phase ${request.toolCalls}/${request.readReserve}`
+    );
+  }
+  if (policy.maximum === void 0 && !samePhase(ceiling, policy)) {
+    throw new BudgetAdmissionError(
+      "exact-recipe-policy",
+      `the recipe pins ${policy.toolCalls} tool calls with a read reserve of ${policy.readReserve}`
+    );
+  }
+  if (!phaseWithin(ceiling, authoredMaximum)) {
+    throw new BudgetAdmissionError(
+      "recipe-maximum",
+      `retryRevision ${ceiling.toolCalls}/${ceiling.readReserve} exceeds recipe maximum ${authoredMaximum.toolCalls}/${authoredMaximum.readReserve}`
+    );
+  }
+  if (ceiling.toolCalls > hardCap) {
+    throw new BudgetAdmissionError(
+      "global-cap",
+      `retryRevision ${ceiling.toolCalls} exceeds the operator cap of ${hardCap}`
+    );
+  }
+}
+function resolveToolBudgetEnvelope(input) {
+  if (!Number.isSafeInteger(input.hardCap) || input.hardCap <= 0) {
+    throw new Error("dispatch: worker tool-call cap must be a positive safe integer");
+  }
+  if (input.request !== void 0)
+    assertRequestAdmitted({ request: input.request, policy: input.policy, hardCap: input.hardCap });
+  const request = input.request === void 0 ? null : cloneDispatchBudgetRequest(input.request);
+  const base = request ?? input.policy;
+  const reasons = [];
+  let selected = base;
+  const phaseKind = input.retry ? "retry" : input.revision ? "revision" : null;
+  if (phaseKind !== null) {
+    const ceiling = request?.retryRevision;
+    if (ceiling !== void 0 && !samePhase(ceiling, base)) {
+      selected = ceiling;
+      reasons.push({
+        code: phaseKind === "retry" ? "retry-growth-authorized" : "revision-growth-authorized",
+        detail: `${phaseKind} phase grew from ${base.toolCalls}/${base.readReserve} to the preauthorized ceiling ${ceiling.toolCalls}/${ceiling.readReserve}`
+      });
+    } else {
+      reasons.push({
+        code: phaseKind === "retry" ? "retry-growth-denied" : "revision-growth-denied",
+        detail: ceiling === void 0 ? `${phaseKind} phase retained ${base.toolCalls}/${base.readReserve} because the original request declared no ceiling` : `${phaseKind} phase retained ${base.toolCalls}/${base.readReserve} because the declared ceiling did not authorize growth`
+      });
+    }
+  }
+  const revisionCeiling = phaseKind === null ? request?.retryRevision : void 0;
+  if (revisionCeiling !== void 0 && !samePhase(revisionCeiling, selected)) {
+    reasons.push({
+      code: "revision-growth-authorized",
+      detail: `a result-contract revision may grow from ${selected.toolCalls}/${selected.readReserve} to the preauthorized ceiling ${revisionCeiling.toolCalls}/${revisionCeiling.readReserve}`
+    });
+  }
+  let toolCalls = selected.toolCalls;
+  if (toolCalls > input.hardCap) {
+    reasons.push({
+      code: "global-cap-clamp",
+      detail: `tool calls were clamped from ${toolCalls} to the operator cap of ${input.hardCap}`
+    });
+    toolCalls = input.hardCap;
+  }
+  let readReserve = selected.readReserve;
+  if (!input.hasReadTool && readReserve > 0) {
+    reasons.push({
+      code: "read-reserve-unavailable-clamp",
+      detail: `read reserve was clamped from ${readReserve} to 0 because the read tool is unavailable`
+    });
+    readReserve = 0;
+  }
+  const maximumEffectiveReserve = Math.max(0, toolCalls - 1);
+  if (readReserve > maximumEffectiveReserve) {
+    reasons.push({
+      code: "read-reserve-cap-clamp",
+      detail: `read reserve was clamped from ${readReserve} to ${maximumEffectiveReserve} after the tool-call cap`
+    });
+    readReserve = maximumEffectiveReserve;
+  }
+  let effectiveRevision;
+  if (revisionCeiling !== void 0 && !samePhase(revisionCeiling, selected)) {
+    let revisionReadReserve = revisionCeiling.readReserve;
+    if (!input.hasReadTool && revisionReadReserve > 0) {
+      reasons.push({
+        code: "read-reserve-unavailable-clamp",
+        detail: `result-contract revision read reserve was clamped from ${revisionReadReserve} to 0 because the read tool is unavailable`
+      });
+      revisionReadReserve = 0;
+    }
+    effectiveRevision = { toolCalls: revisionCeiling.toolCalls, readReserve: revisionReadReserve };
+  }
+  const authoredMaximum = input.policy.maximum ?? input.policy;
+  return freezeEnvelope({
+    version: 1,
+    policy: {
+      recipeId: input.recipeId,
+      default: {
+        toolCalls: input.policy.toolCalls,
+        readReserve: input.policy.readReserve,
+        synthesis: input.policy.synthesis
+      },
+      maximum: { toolCalls: authoredMaximum.toolCalls, readReserve: authoredMaximum.readReserve },
+      exact: input.policy.maximum === void 0
+    },
+    request,
+    effective: {
+      toolCalls,
+      readReserve,
+      synthesis: input.policy.synthesis,
+      hardCap: input.hardCap,
+      ...effectiveRevision === void 0 ? {} : { revision: effectiveRevision }
+    },
+    reasons
+  });
+}
+function formatBudgetPolicy(envelope) {
+  const policy = envelope.policy;
+  const range = policy.exact ? `exact ${policy.default.toolCalls}/${policy.default.readReserve}` : `default ${policy.default.toolCalls}/${policy.default.readReserve}, max ${policy.maximum.toolCalls}/${policy.maximum.readReserve}`;
+  return `${policy.recipeId} ${range}, synthesis=${policy.default.synthesis ? "on" : "off"}`;
+}
+function formatBudgetRequest(envelope) {
+  const request = envelope.request;
+  if (request === null) return "recipe default";
+  const ceiling = request.retryRevision;
+  return ceiling === void 0 ? `${request.toolCalls}/${request.readReserve}, no retry/revision growth` : `${request.toolCalls}/${request.readReserve}, retry/revision ceiling ${ceiling.toolCalls}/${ceiling.readReserve}`;
+}
+function formatEffectiveBudget(envelope) {
+  const budget = envelope.effective;
+  const revision = budget.revision ? `, result revision ${budget.revision.toolCalls}/${budget.revision.readReserve}` : "";
+  return `${budget.toolCalls}/${budget.readReserve}${revision}, lifetime cap ${budget.hardCap}, synthesis=${budget.synthesis ? "on" : "off"}`;
+}
+function formatBudgetReasons(envelope) {
+  return envelope.reasons.length === 0 ? "none" : envelope.reasons.map((reason) => reason.code).join(",");
+}
+var BUDGET_REASON_CODES = /* @__PURE__ */ new Set([
+  "global-cap-clamp",
+  "read-reserve-unavailable-clamp",
+  "read-reserve-cap-clamp",
+  "retry-growth-authorized",
+  "retry-growth-denied",
+  "revision-growth-authorized",
+  "revision-growth-denied"
+]);
+function cloneRunToolBudgetEnvelope(value) {
+  try {
+    if (!isRecord(value) || value.version !== 1 || !isRecord(value.policy) || !isRecord(value.effective)) {
+      return void 0;
+    }
+    const recipeId = value.policy.recipeId;
+    if (typeof recipeId !== "string" || recipeId.length === 0 || typeof value.policy.exact !== "boolean") {
+      return void 0;
+    }
+    if (!isRecord(value.policy.default) || typeof value.policy.default.synthesis !== "boolean") return void 0;
+    const defaultPhase = clonePhase(
+      { toolCalls: value.policy.default.toolCalls, readReserve: value.policy.default.readReserve },
+      "budget.policy.default"
+    );
+    const maximum = clonePhase(value.policy.maximum, "budget.policy.maximum");
+    const request = value.request === null ? null : cloneDispatchBudgetRequest(value.request);
+    const effectivePhase = clonePhase(
+      { toolCalls: value.effective.toolCalls, readReserve: value.effective.readReserve },
+      "budget.effective"
+    );
+    const revision = value.effective.revision === void 0 ? void 0 : clonePhase(value.effective.revision, "budget.effective.revision");
+    if (typeof value.effective.synthesis !== "boolean" || typeof value.effective.hardCap !== "number" || !Number.isSafeInteger(value.effective.hardCap) || value.effective.hardCap <= 0 || !Array.isArray(value.reasons)) {
+      return void 0;
+    }
+    if (maximum.toolCalls < defaultPhase.toolCalls || maximum.readReserve < defaultPhase.readReserve || value.policy.exact && !samePhase(maximum, defaultPhase) || effectivePhase.toolCalls > value.effective.hardCap || value.effective.synthesis !== value.policy.default.synthesis || revision !== void 0 && (revision.toolCalls < effectivePhase.toolCalls || revision.toolCalls > value.effective.hardCap || revision.toolCalls === effectivePhase.toolCalls && revision.readReserve <= effectivePhase.readReserve)) {
+      return void 0;
+    }
+    const reasons = [];
+    for (const reason of value.reasons) {
+      if (!isRecord(reason) || typeof reason.code !== "string" || !BUDGET_REASON_CODES.has(reason.code) || typeof reason.detail !== "string") {
+        return void 0;
+      }
+      reasons.push({ code: reason.code, detail: reason.detail });
+    }
+    return freezeEnvelope({
+      version: 1,
+      policy: {
+        recipeId,
+        default: { ...defaultPhase, synthesis: value.policy.default.synthesis },
+        maximum,
+        exact: value.policy.exact
+      },
+      request,
+      effective: {
+        ...effectivePhase,
+        synthesis: value.effective.synthesis,
+        hardCap: value.effective.hardCap,
+        ...revision === void 0 ? {} : { revision }
+      },
+      reasons
+    });
+  } catch {
+    return void 0;
+  }
+}
+
 // src/domains/dispatch/gate-role-prompts.ts
 init_esm_shims();
 var REVIEWER_GATE_PROMPT = [
@@ -1096,6 +1412,219 @@ function runKindSupportsLiveSteering(kind) {
   return kind === "http" || kind === "sdk";
 }
 
+// src/domains/safety/call-target.ts
+init_esm_shims();
+
+// src/domains/safety/redaction.ts
+init_esm_shims();
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var SECRET_KEY_RE = /(?:api[-_]?key|access[-_]?key|auth(?:orization)?|credential|password|private[-_]?key|secret|token)/iu;
+var ENV_KEY_RE = /^env(?:ironment)?$/iu;
+var SECRET_STRING_RE = /(https?:\/\/[^\s/@]+:)[^\s/@]+@/giu;
+var SECRET_URL_PARAM_RE = /([?&](?:api[-_]?key|access[-_]?token|auth(?:orization)?|credential|password|secret|token)[^=\s]*=)[^&#\s]+/giu;
+var SECRET_ASSIGNMENT_RE = /(?<![A-Z0-9_])((?:[A-Z0-9_]*(?:ACCESS|API|AUTH|CREDENTIAL|KEY|PASS(?:WORD)?|PRIVATE|SECRET|TOKEN)[A-Z0-9_]*)=)[^\s;&|]+/giu;
+var SECRET_FLAG_RE = /(--?(?:[a-z0-9-]*(?:api[-_]?key|access[-_]?token|auth(?:orization)?|credential|password|secret|token)[a-z0-9-]*))(=|\s+)([^\s;&|]+)/giu;
+function redactSecretString(value) {
+  return value.replace(SECRET_STRING_RE, "$1[redacted]@").replace(SECRET_URL_PARAM_RE, "$1[redacted]").replace(SECRET_ASSIGNMENT_RE, "$1[redacted]").replace(SECRET_FLAG_RE, "$1$2[redacted]");
+}
+function isSecretArgKey(key) {
+  return SECRET_KEY_RE.test(key);
+}
+function isEnvironmentArgKey(key) {
+  return ENV_KEY_RE.test(key);
+}
+function redactEnvironmentValue(value, depth) {
+  if (depth > 8) return "[redacted nested values]";
+  if (typeof value === "string") return "[redacted]";
+  if (Array.isArray(value)) return value.map((item) => redactEnvironmentValue(item, depth + 1));
+  if (!isPlainObject2(value)) return value;
+  const out = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    out[childKey] = redactEnvironmentValue(childValue, depth + 1);
+  }
+  return out;
+}
+function redactToolArgs(value, key = "", depth = 0) {
+  if (isSecretArgKey(key)) return "[redacted]";
+  if (isEnvironmentArgKey(key)) return redactEnvironmentValue(value, depth);
+  if (typeof value === "string") return redactSecretString(value);
+  if (depth > 8) return "[redacted nested values]";
+  if (Array.isArray(value)) return value.map((item) => redactToolArgs(item, key, depth + 1));
+  if (!isPlainObject2(value)) return value;
+  const out = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    out[childKey] = redactToolArgs(childValue, childKey, depth + 1);
+  }
+  return out;
+}
+
+// src/domains/safety/call-target.ts
+var ESC_CHAR = String.fromCharCode(27);
+var BEL_CHAR = String.fromCharCode(7);
+var OSC_PATTERN = new RegExp(`${ESC_CHAR}\\][\\s\\S]*?(?:${BEL_CHAR}|${ESC_CHAR}\\\\|$)`, "g");
+var CSI_PATTERN = new RegExp(`${ESC_CHAR}\\[[0-9;?]*[0-9A-Za-z]`, "g");
+function sanitizeForDisplay(value) {
+  const stripped = value.replace(OSC_PATTERN, "").replace(CSI_PATTERN, "");
+  let out = "";
+  for (const ch of stripped) {
+    const code = ch.codePointAt(0) ?? 0;
+    out += code < 32 || code === 127 ? " " : ch;
+  }
+  return out;
+}
+function oneLine(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function sanitizeCallTargetText(value) {
+  return oneLine(sanitizeForDisplay(value));
+}
+var CALL_ACTION_OBJECT_MAX_CHARS = 64;
+var CALL_TARGET_MAX_CHARS = 120;
+var CALL_ACTION_VOCABULARY = {
+  read: { verb: "reading", field: "path" },
+  edit: { verb: "editing", field: "path" },
+  write: { verb: "writing", field: "path" },
+  ls: { verb: "listing", field: "path" },
+  bash: { verb: "running", field: "command" },
+  grep: { verb: "searching", field: "pattern" },
+  find: { verb: "finding", field: "pattern" },
+  web_fetch: { verb: "fetching", field: "url" },
+  git: { verb: "git", field: "op" },
+  verify: { verb: "verifying", field: "check" },
+  code_nav: { verb: "navigating", field: "query" },
+  context: { verb: "context", field: "scope" },
+  artifact: { verb: "writing", field: "kind" },
+  monitor: { verb: "monitoring", field: "run_id" },
+  steer: { verb: "steering", field: "run_id" },
+  tasks: { verb: "tasks", field: "action" },
+  dispatch: { verb: "dispatching", field: "agent" },
+  // ACP tool kinds. A peer names its own argument fields, so these rely on
+  // the shared allowlist below rather than on a field this side can predict.
+  execute: { verb: "running", field: "command" },
+  search: { verb: "searching", field: "query" },
+  fetch: { verb: "fetching", field: "url" },
+  delete: { verb: "deleting", field: "path" },
+  move: { verb: "moving", field: "path" },
+  think: { verb: "thinking", field: "" }
+};
+var CALL_ACTION_OBJECT_FIELDS = ["path", "file_path", "command", "pattern", "query", "url"];
+var CALL_TARGET_FIELDS = {
+  read: ["path", "offset", "limit", "tail"],
+  grep: ["pattern", "path", "mode", "glob", "ignore_case", "literal", "context", "limit", "include_ignored"],
+  find: ["pattern", "path", "order", "limit", "include_ignored"],
+  ls: ["path", "limit"],
+  code_nav: ["mode", "query", "limit"],
+  context: ["scope", "query", "name", "limit", "ref", "include_tree"],
+  credential_present: ["name", "source", "file"],
+  write: ["path"],
+  edit: ["path"],
+  bash: ["command", "cwd", "timeout_ms", "output_policy"],
+  git: ["op", "path", "cached", "stat", "name_only", "limit", "cwd", "timeout_ms", "max_output_bytes"],
+  verify: ["check", "path", "browser", "cwd", "timeout_ms", "max_output_bytes"],
+  dispatch: [
+    "list",
+    "mode",
+    "agent",
+    "target",
+    "model",
+    "node",
+    "autonomy",
+    "tool_profile",
+    "thinking_level",
+    "detach",
+    "timeout_ms"
+  ],
+  monitor: ["run_id", "mode"],
+  steer: ["run_id", "action"],
+  tasks: ["action", "id"],
+  ledger: ["action", "kind", "path", "line", "target", "passed", "since"],
+  web_fetch: ["url", "method", "timeout_ms", "max_bytes", "format"],
+  ask_user: ["action", "mode", "max_rounds", "exposure"],
+  artifact: ["kind", "path", "title"],
+  // ACP tool kinds use only fields whose meaning the protocol defines.
+  execute: ["command", "cwd"],
+  search: ["query", "path"],
+  fetch: ["url", "method"],
+  delete: ["path"],
+  move: ["path", "target"]
+};
+function boundActionObject(value) {
+  if (typeof value !== "string") return null;
+  const clean = sanitizeCallTargetText(redactSecretString(value));
+  if (clean.length === 0) return null;
+  if (clean.length <= CALL_ACTION_OBJECT_MAX_CHARS) return { object: clean, truncated: false };
+  return { object: clean.slice(0, CALL_ACTION_OBJECT_MAX_CHARS), truncated: true };
+}
+function describeCallAction(tool, args) {
+  const known = CALL_ACTION_VOCABULARY[tool];
+  const candidates = known?.field ? [known.field, ...CALL_ACTION_OBJECT_FIELDS] : [...CALL_ACTION_OBJECT_FIELDS];
+  let bounded = null;
+  if (args) {
+    for (const field of candidates) {
+      if (isSecretArgKey(field)) continue;
+      bounded = boundActionObject(args[field]);
+      if (bounded !== null) break;
+    }
+  }
+  if (known === void 0 && bounded === null) return null;
+  const verb = known?.verb ?? "calling";
+  if (bounded === null) return { verb };
+  return { verb, object: bounded.object, ...bounded.truncated ? { truncated: true } : {} };
+}
+function renderAllowedTargetValue(value) {
+  if (typeof value === "string") {
+    const rendered = sanitizeCallTargetText(redactSecretString(value));
+    return rendered.length > 0 ? rendered : null;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "boolean") return String(value);
+  return null;
+}
+function countLabel(count, singular, plural) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function summarizeUnlistedTargetValue(value) {
+  if (typeof value === "string") {
+    return `<string ${countLabel(Buffer.byteLength(value, "utf8"), "byte", "bytes")}>`;
+  }
+  if (Array.isArray(value)) return `<array ${countLabel(value.length, "item", "items")}>`;
+  if (value !== null && typeof value === "object") {
+    return `<object ${countLabel(Object.keys(value).length, "field", "fields")}>`;
+  }
+  if (value === null) return "<null 0 values>";
+  if (typeof value === "undefined") return "<undefined 0 values>";
+  return `<${typeof value} 1 value>`;
+}
+function targetFieldName(value) {
+  return sanitizeCallTargetText(value).slice(0, 32) || "field";
+}
+function describeCallTarget(tool, args) {
+  if (!args) return "";
+  const allowedFields = CALL_TARGET_FIELDS[tool] ?? [];
+  const allowed = new Set(allowedFields);
+  const parts = [];
+  for (const field of allowedFields) {
+    if (!(field in args)) continue;
+    if (isSecretArgKey(field)) {
+      parts.push(`${targetFieldName(field)}=${summarizeUnlistedTargetValue(args[field])}`);
+      continue;
+    }
+    const rendered = renderAllowedTargetValue(args[field]);
+    if (rendered === null) {
+      parts.push(`${targetFieldName(field)}=${summarizeUnlistedTargetValue(args[field])}`);
+      continue;
+    }
+    parts.push(parts.length === 0 ? rendered : `${targetFieldName(field)}=${rendered}`);
+  }
+  for (const [field, value] of Object.entries(args)) {
+    if (allowed.has(field)) continue;
+    parts.push(`${targetFieldName(field)}=${summarizeUnlistedTargetValue(value)}`);
+  }
+  return sanitizeCallTargetText(parts.join(" \xB7 ")).slice(0, CALL_TARGET_MAX_CHARS);
+}
+
 // src/engine/antigravity/subprocess-runtime.ts
 init_esm_shims();
 import { spawn as spawn2 } from "node:child_process";
@@ -2513,6 +3042,7 @@ var KNOWN_KEYS = /* @__PURE__ */ new Set([
   "target",
   "model",
   "thinkingLevel",
+  "budget",
   "node",
   "routingIntent",
   "failover",
@@ -2543,12 +3073,12 @@ 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) {
+function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateJobSpec(spec) {
   const errors = [];
-  if (!isPlainObject2(spec)) {
+  if (!isPlainObject3(spec)) {
     return { ok: false, errors: ["spec must be an object"] };
   }
   for (const key of Object.keys(spec)) {
@@ -2637,7 +3167,7 @@ function validateJobSpec(spec) {
     errors.push("failover automatic is not allowed on a plan-approved dispatch");
   }
   if ("plannedNode" in spec && spec.plannedNode !== void 0) {
-    if (!isPlainObject2(spec.plannedNode)) {
+    if (!isPlainObject3(spec.plannedNode)) {
       errors.push("plannedNode must be an object");
     } else {
       for (const key of Object.keys(spec.plannedNode)) {
@@ -2658,7 +3188,7 @@ function validateJobSpec(spec) {
     }
   }
   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)) {
+    if (!isPlainObject3(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");
     }
   }
@@ -2672,6 +3202,14 @@ function validateJobSpec(spec) {
       errors.push("thinkingLevel must be one of: off|minimal|low|medium|high|xhigh");
     }
   }
+  let budget;
+  if ("budget" in spec && spec.budget !== void 0) {
+    try {
+      budget = cloneDispatchBudgetRequest(spec.budget);
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
   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[]");
@@ -2798,6 +3336,7 @@ function validateJobSpec(spec) {
     out.reroutes = spec.reroutes.map((hop) => ({ ...hop }));
   }
   if (typeof spec.thinkingLevel === "string") out.thinkingLevel = spec.thinkingLevel;
+  if (budget !== void 0) out.budget = budget;
   if (Array.isArray(spec.requiredCapabilities)) {
     out.requiredCapabilities = spec.requiredCapabilities.map((c) => String(c));
   }
@@ -2834,7 +3373,7 @@ 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;
+    if (!isPlainObject3(candidate)) return false;
     const fields = [
       candidate.stepId,
       candidate.assignmentId,
@@ -2846,14 +3385,14 @@ function isValidPredecessorHandoffs(value) {
   });
 }
 function isValidPipelineInput(value) {
-  if (!isPlainObject2(value)) return false;
+  if (!isPlainObject3(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;
+  if (!isPlainObject3(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";
@@ -2861,7 +3400,7 @@ function isValidReroute(value) {
   return attemptOk && fromOk && toOk && reasonOk;
 }
 function isValidFailoverCandidate(value) {
-  if (!isPlainObject2(value)) return false;
+  if (!isPlainObject3(value)) return false;
   if (Object.keys(value).some((key) => key !== "agentId" && key !== "target" && key !== "model" && key !== "node")) {
     return false;
   }
@@ -2870,26 +3409,26 @@ function isValidFailoverCandidate(value) {
   );
 }
 function isValidPlannedNode(value) {
-  if (!isPlainObject2(value) || typeof value.id !== "string" || value.id.trim().length === 0) return false;
+  if (!isPlainObject3(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);
+  return isPlainObject3(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 (!isPlainObject3(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 (!isPlainObject3(subject)) return false;
       if (typeof subject.runId !== "string" || subject.runId.length === 0) return false;
       if (subject.digest !== null && typeof subject.digest !== "string") return false;
     }
@@ -2909,13 +3448,13 @@ function cloneGate(gate) {
   };
 }
 function isValidPlan(value) {
-  if (!isPlainObject2(value)) return false;
+  if (!isPlainObject3(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))
+    if (!isPlainObject3(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)) {
@@ -2930,7 +3469,7 @@ function isValidPlan(value) {
   return true;
 }
 function isValidLineage(value) {
-  if (!isPlainObject2(value)) return false;
+  if (!isPlainObject3(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;
@@ -2941,7 +3480,7 @@ function isValidLineage(value) {
 // src/engine/claude/tool-safety.ts
 init_esm_shims();
 import { performance } from "node:perf_hooks";
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringField(record2, ...keys) {
@@ -3145,9 +3684,10 @@ function finishDecision(decision) {
   if (decision.kind === "ask") return "permission_requested";
   return "blocked";
 }
-function emitToolFinish(emit, mapped, startedAtClock, decision, outcome, reason, reasonCode) {
+function emitToolFinish(emit, mapped, startedAtClock, decision, outcome, reason, reasonCode, toolCallId) {
   const event = {
     tool: mapped.clioToolName,
+    ...toolCallId !== void 0 ? { toolCallId } : {},
     posture: "operating",
     durationMs: Math.round(performance.now() - startedAtClock),
     outcome,
@@ -3165,10 +3705,14 @@ function emitClaudeToolPermissionDecision(input) {
   const startedAt = Date.now();
   const startedAtClock = performance.now();
   const decision = evaluateClaudeToolPermission(input);
+  const toolCallId = input.toolCallId?.trim() ? input.toolCallId : void 0;
+  const action = describeCallAction(decision.mapped.clioToolName, decision.mapped.args);
   const start = {
     tool: decision.mapped.clioToolName,
+    ...toolCallId !== void 0 ? { toolCallId } : {},
     posture: "operating",
-    startedAt
+    startedAt,
+    ...action !== null ? { action } : {}
   };
   input.emit({ type: "clio_tool_start", payload: start });
   if (decision.kind === "allow") {
@@ -3179,7 +3723,8 @@ function emitClaudeToolPermissionDecision(input) {
       decision.decision,
       "ok",
       decision.reason,
-      decision.reasonCode
+      decision.reasonCode,
+      toolCallId
     );
     return decision;
   }
@@ -3202,12 +3747,13 @@ function emitClaudeToolPermissionDecision(input) {
     decision.decision,
     "blocked",
     decision.reason,
-    decision.reasonCode
+    decision.reasonCode,
+    toolCallId
   );
   return decision;
 }
 function coerceToolInput(value) {
-  return isRecord(value) ? value : {};
+  return isRecord2(value) ? value : {};
 }
 
 // src/domains/dispatch/agent-candidates.ts
@@ -3384,6 +3930,11 @@ export {
   responseSchemaConflictsWithTools,
   UnsupportedResponseSchemaError,
   isResponseSchemaRejection,
+  redactSecretString,
+  redactToolArgs,
+  sanitizeCallTargetText,
+  describeCallAction,
+  describeCallTarget,
   TOOL_PROFILE_NAMES,
   isToolProfileName,
   assertToolProfileEnforceable,
@@ -3429,6 +3980,13 @@ export {
   AGENT_LEDGER_PROMPT_MAX_CHARS,
   claimConflicts,
   renderAgentLedger,
+  cloneDispatchBudgetRequest,
+  resolveToolBudgetEnvelope,
+  formatBudgetPolicy,
+  formatBudgetRequest,
+  formatEffectiveBudget,
+  formatBudgetReasons,
+  cloneRunToolBudgetEnvelope,
   REVIEWER_GATE_PROMPT,
   JUDGE_GATE_PROMPT,
   COMPETE_STANCES,
@@ -3442,4 +4000,4 @@ export {
   DISPATCH_BRIEFING_MAX_BYTES,
   validateJobSpec
 };
-//# sourceMappingURL=chunk-ZYKPLLNQ.js.map
+//# sourceMappingURL=chunk-XXQNGV4M.js.map