@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/chunk-DKGKUHFA.js

@@ -1,924 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  RESPONSE_SCHEMA_RUNTIME_ID
-} from "./chunk-7SS2CTV2.js";
-import {
-  hashToolCall
-} from "./chunk-GEP36Y4X.js";
-import {
-  classify,
-  protectArtifact,
-  protectedArtifactMutationBlockReason
-} from "./chunk-OLBBMFRD.js";
-import {
-  ToolNames
-} from "./chunk-CGKSTWHD.js";
-import {
-  defaultAnthropicBudgetForLevel,
-  defaultAnthropicEffortForLevel
-} from "./chunk-H6F6BYOH.js";
-import {
-  BusChannels
-} from "./chunk-Q5WJOSJ7.js";
-import {
-  GUARDRAIL_DEFAULTS,
-  resolveGuardrail,
-  workerSynthesisReserveBlockReason,
-  workerSynthesisReserveDirective,
-  workerToolCallCapExceededReason,
-  workerToolCallCapSynthesisReason
-} from "./chunk-NMOX6HFD.js";
-import {
-  init_esm_shims
-} from "./chunk-3R73A4XB.js";
-
-// src/domains/safety/protected-artifacts-registration.ts
-init_esm_shims();
-var PROTECTED_ARTIFACTS_REGISTRATION_ID = "guard.protected-artifacts";
-function createProtectedArtifactsRegistration(options = {}) {
-  let state = cloneState(options.initialState ?? { artifacts: [] });
-  let health = { kind: "healthy" };
-  const markDegraded = (reason) => {
-    if (health.kind === "degraded") return;
-    const degraded = {
-      kind: "degraded",
-      reason,
-      since: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    health = degraded;
-    try {
-      options.onDurabilityFailure?.({ ...degraded });
-    } catch {
-    }
-  };
-  const absorb = (input, context) => {
-    for (const effect of context?.priorEffects ?? []) {
-      if (effect.kind !== "protect_path") continue;
-      const artifact = artifactFromEffect(effect, input);
-      state = protectArtifact(state, artifact);
-      try {
-        emitProtect(options.onProtect, artifact, input);
-      } catch (error) {
-        markDegraded(`protected artifact persistence failed: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-  };
-  const blockReason = (input) => {
-    const toolName = input.toolName ?? "";
-    const args = input.toolArgs !== void 0 ? { ...input.toolArgs } : void 0;
-    if (health.kind === "degraded") {
-      const actionClass = classify({ tool: toolName, ...args !== void 0 ? { args } : {} }).actionClass;
-      if (actionClass !== "read") {
-        return `protected artifact durability degraded: ${health.reason}; non-read tool '${toolName}' is blocked until protection state is trustworthy`;
-      }
-    }
-    return protectedArtifactMutationBlockReason(state, toolName, args);
-  };
-  return {
-    id: PROTECTED_ARTIFACTS_REGISTRATION_ID,
-    description: "blocks mutations of protected paths and absorbs protect_path effects",
-    hooks: ["before_tool", "after_tool"],
-    state: () => cloneState(state),
-    health: () => ({ ...health }),
-    replaceState(next) {
-      state = cloneState(next);
-      health = { kind: "healthy" };
-    },
-    markDegraded,
-    evaluate(input, context) {
-      absorb(input, context);
-      if (input.hook !== "before_tool") return [];
-      const reason = blockReason(input);
-      if (reason === null) return [];
-      return [{ kind: "block_tool", reason, severity: "hard-block" }];
-    }
-  };
-}
-function artifactFromEffect(effect, input) {
-  const artifact = {
-    path: effect.path,
-    protectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    reason: effect.reason,
-    source: "middleware"
-  };
-  const validationCommand = input.metadata?.validationCommand;
-  if (typeof validationCommand === "string" && validationCommand.length > 0) {
-    artifact.validationCommand = validationCommand;
-    if (input.metadata?.validationExitCode === 0) artifact.validationExitCode = 0;
-  }
-  return artifact;
-}
-function emitProtect(sink, artifact, input) {
-  if (!sink) return;
-  const event = {
-    kind: "protect",
-    artifact: cloneArtifact(artifact),
-    toolName: input.toolName ?? ""
-  };
-  if (input.runId !== void 0) event.runId = input.runId;
-  if (input.sessionId !== void 0) event.sessionId = input.sessionId;
-  if (input.turnId !== void 0) event.turnId = input.turnId;
-  if (input.toolCallId !== void 0) event.toolCallId = input.toolCallId;
-  if (input.correlationId !== void 0) event.correlationId = input.correlationId;
-  sink(event);
-}
-function cloneState(state) {
-  let next = { artifacts: [] };
-  for (const artifact of state.artifacts) {
-    next = protectArtifact(next, artifact);
-  }
-  return next;
-}
-function cloneArtifact(artifact) {
-  const clone = {
-    path: artifact.path,
-    protectedAt: artifact.protectedAt,
-    reason: artifact.reason,
-    source: artifact.source
-  };
-  if (artifact.validationCommand !== void 0) clone.validationCommand = artifact.validationCommand;
-  if (artifact.validationExitCode !== void 0) clone.validationExitCode = artifact.validationExitCode;
-  return clone;
-}
-
-// src/engine/loop-guard.ts
-init_esm_shims();
-var LOOP_GUARD_REGISTRATION_ID = "guard.loop";
-var INTERACTIVE_LOOP_BLOCK_BUDGET = 2;
-var WORKER_LOOP_BLOCK_CALLS_PER_BLOCK = 10;
-function workerLoopBlockBudget(toolCalls) {
-  if (!Number.isSafeInteger(toolCalls) || toolCalls <= 0) return INTERACTIVE_LOOP_BLOCK_BUDGET;
-  return Math.max(INTERACTIVE_LOOP_BLOCK_BUDGET, Math.ceil(toolCalls / WORKER_LOOP_BLOCK_CALLS_PER_BLOCK));
-}
-var LOOP_SYNTHESIS_BACKSTOP_DENIALS = 2;
-var WIDE_BATCH_DENIAL_FLOOR = 32;
-var DEFAULT_WORKER_TOOL_CALL_CAP = GUARDRAIL_DEFAULTS.workerToolCallCap;
-var DEFAULT_ORCH_TURN_TOOL_CALL_BUDGET = GUARDRAIL_DEFAULTS.turnToolCallBudget;
-var ORCH_TURN_TOOL_CALL_HARD_MARGIN = 15;
-var LOOP_GUARD_TURN_LIMIT = 32;
-var SUCCEEDED_FINGERPRINT_LIMIT = 128;
-var NO_TURN_BUCKET = "no-turn";
-var SIZE_ONLY_ARG_KEYS = /* @__PURE__ */ new Set(["limit", "offset", "max_bytes", "context"]);
-var RESULT_STAGNATION_THRESHOLD = 3;
-var CROSS_ARGUMENT_RESULT_MIN_BYTES = 64;
-function stagnationFingerprint(tool, args) {
-  const reduced = {};
-  for (const [key, value] of Object.entries(args ?? {})) {
-    if (!SIZE_ONLY_ARG_KEYS.has(key)) reduced[key] = value;
-  }
-  return hashToolCall(tool, reduced);
-}
-function stagnationBlockReason(tool, identicalResults) {
-  return `loop detected: the last ${identicalResults} ${tool} calls returned byte-identical results even though size arguments (limit/offset) changed. Raising them is not producing new information. Re-read the result above, change the query or tool, or answer from what you have.`;
-}
-function crossArgumentResultMessage(tool, distinctArguments) {
-  return `loop guard: ${distinctArguments} distinct ${tool} arguments returned the same substantial result this turn. The tool may be ignoring an argument; re-read the result, change tools, or answer from what you have.`;
-}
-function loopBlockBaseReason(tool, repeatCount, priorSuccesses) {
-  const evidence = priorSuccesses > 0 ? `This exact call already succeeded ${priorSuccesses} ${priorSuccesses === 1 ? "time" : "times"} this run; its result is already in the conversation above \u2014 re-read that result before calling tools again. ` : "";
-  return `loop detected: ${tool} was called ${repeatCount} times with identical arguments among this turn's recent tool calls. Repeating the exact call is blocked. ${evidence}Change strategy: vary the arguments, use a different tool, or explain what new information you expect before retrying.`;
-}
-function synthesisLockoutDirective() {
-  return "loop guard: this turn reached its tool-call limit after repeated identical calls, so tool calls are now disabled for the rest of this turn. Everything you retrieved is already in the conversation above. Answer the operator now, in plain prose, from what you have gathered. Do not write tool-call markup such as <tool_call> blocks; tool calls are disabled and will not run.";
-}
-function synthesisBackstopReason(tool) {
-  return `loop guard: tool calls stayed disabled and ${tool} was called again instead of answering, so the turn is being stopped. Summarize what you found for the operator.`;
-}
-function workerExplorationSynthesisDirective(limit) {
-  return `worker exploration budget reached (${limit}); exploration tools are now disabled for this run. Answer in plain prose from the evidence already gathered, with live path:line citations. Do not retry or substitute another tool call.`;
-}
-function disallowedToolsText(deliveryTools) {
-  const candidates = ["code_nav", "ls", "grep", "find", "context", "git", "shell commands"];
-  const excluded = candidates.filter((tool) => !deliveryTools.includes(tool));
-  return excluded.join(", ");
-}
-function workerLiveReadReserveDirective(remaining, deliveryTools) {
-  const admitted = deliveryTools.length > 0 ? `read and ${deliveryTools.join("/")}` : "the read tool";
-  const finish = deliveryTools.length > 0 ? `Finish the work: re-read what you will cite and write it with ${deliveryTools.join(" or ")}.` : "Read a specific live file needed for the handoff.";
-  return `worker live-read reserve: broad orientation is complete and ${remaining} ${remaining === 1 ? "call remains" : "calls remain"}. Only ${admitted} ${deliveryTools.length > 0 ? "are" : "is"} admitted now. ${finish} Do not substitute ${disallowedToolsText(deliveryTools)}.`;
-}
-function workerDeliveryOnlyDirective(limit, deliveryTools) {
-  return `worker discovery budget reached (${limit}); exploration tools are disabled for the rest of this run. Only read and ${deliveryTools.join("/")} are admitted now. Write what you have with ${deliveryTools.join(" or ")} and finish. Do not substitute ${disallowedToolsText(deliveryTools)}.`;
-}
-var DEAD_TOOL_CALL_MARKUP_PATTERNS = [
-  /<tool_call>[\s\S]*?<\/tool_call>/gi,
-  /<function=[\w.-]+>[\s\S]*?<\/function>/gi,
-  /<tool_call>\s*(?:<function=|[{[])[\s\S]*$/i,
-  /<function=[\w.-]+>[\s\S]*$/i
-];
-function stripDeadToolCallMarkup(text) {
-  let out = text;
-  for (const pattern of DEAD_TOOL_CALL_MARKUP_PATTERNS) {
-    out = out.replace(pattern, "");
-  }
-  return out === text ? text : out.trim();
-}
-function lockedSynthesisFallbackText() {
-  return "[Clio Coder] loop guard: tool calls were disabled for the rest of this turn, but the reply contained only tool-call markup, which cannot run and was removed. Ask me to continue with a different approach, or narrow the request.";
-}
-function sanitizeLockedSynthesisMessage(message) {
-  if (!message || typeof message !== "object" || message.role !== "assistant") return false;
-  const record = message;
-  const stopReason = record.stopReason;
-  if (stopReason !== void 0 && stopReason !== "stop" && stopReason !== "length") return false;
-  if (!Array.isArray(record.content)) return false;
-  const blocks = record.content;
-  if (blocks.some((block) => block?.type === "toolCall")) return false;
-  let changed = false;
-  for (const block of blocks) {
-    if (block?.type !== "text" || typeof block.text !== "string") continue;
-    const stripped = stripDeadToolCallMarkup(block.text);
-    if (stripped !== block.text) {
-      block.text = stripped;
-      changed = true;
-    }
-  }
-  if (!changed) return false;
-  const remaining = blocks.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("").trim();
-  if (remaining.length === 0) {
-    const firstText = blocks.find(
-      (block) => block?.type === "text" && typeof block.text === "string"
-    );
-    if (firstText) firstText.text = lockedSynthesisFallbackText();
-    else blocks.push({ type: "text", text: lockedSynthesisFallbackText() });
-  }
-  return true;
-}
-function isLoopGuardSynthesisBackstopReason(reason) {
-  return /^loop guard: tool calls stayed disabled and .+ was called again instead of answering/.test(reason);
-}
-function readOrchTurnToolCallBudget(env = process.env) {
-  const soft = resolveGuardrail("turnToolCallBudget", env);
-  return { soft, hard: soft + ORCH_TURN_TOOL_CALL_HARD_MARGIN };
-}
-function createLoopGuardRegistration(options) {
-  const budget = options.turnBlockBudget ?? INTERACTIVE_LOOP_BLOCK_BUDGET;
-  const cap = options.toolCallCap;
-  const softLimit = options.toolCallSoftLimit !== void 0 && Number.isSafeInteger(options.toolCallSoftLimit) && options.toolCallSoftLimit > 0 && (cap === void 0 || options.toolCallSoftLimit <= cap) ? options.toolCallSoftLimit : void 0;
-  const turnBudget = options.turnToolCallBudget;
-  const synthesisLockout = options.turnSynthesisLockout === true;
-  const softReadReserve = options.toolCallSoftReadReserve ?? 0;
-  const softReadReserveThreshold = softLimit !== void 0 && softReadReserve > 0 && softLimit > softReadReserve ? softLimit - softReadReserve : null;
-  const deliveryTools = [...new Set(options.deliveryTools ?? [])];
-  const reserveAdmits = (tool) => isReserveAdmittedTool(tool, deliveryTools);
-  let softAdmittedCount = 0;
-  let softReadReserveEntered = false;
-  let reserveDenials = { denials: 0 };
-  let deniedAttempts = 0;
-  const denialBudget = cap === void 0 ? void 0 : Math.max(cap, WIDE_BATCH_DENIAL_FLOOR);
-  const boundRunDenials = (effects, input) => {
-    if (denialBudget === void 0 || !effects.some((effect) => effect.kind === "block_tool")) return effects;
-    deniedAttempts += 1;
-    if (deniedAttempts <= denialBudget) return effects;
-    return [{ kind: "block_tool", reason: synthesisBackstopReason(input.toolName ?? "unknown"), severity: "hard-block" }];
-  };
-  const reserve = options.toolCallReserve ?? 0;
-  const reserveThreshold = cap !== void 0 && reserve > 0 && cap > reserve ? cap - reserve : null;
-  let reserveDirectiveEmitted = false;
-  const blocksByTurn = /* @__PURE__ */ new Map();
-  const callsByTurn = /* @__PURE__ */ new Map();
-  const lockoutByTurn = /* @__PURE__ */ new Map();
-  let capLockout = null;
-  let softLockout = null;
-  const succeededFingerprints = /* @__PURE__ */ new Map();
-  const stagnationByTurn = /* @__PURE__ */ new Map();
-  const crossArgumentResultsByTurn = /* @__PURE__ */ new Map();
-  let count = 0;
-  const enterSoftReadReserve = () => {
-    if (softReadReserveEntered) return;
-    softReadReserveEntered = true;
-    options.onSoftReadReserve?.();
-  };
-  const bumpBoundedCounter = (store, key, limit = LOOP_GUARD_TURN_LIMIT) => {
-    if (!store.has(key)) {
-      while (store.size >= limit) {
-        const oldest = store.keys().next().value;
-        if (typeof oldest !== "string") break;
-        store.delete(oldest);
-      }
-    }
-    const next = (store.get(key) ?? 0) + 1;
-    store.set(key, next);
-    return next;
-  };
-  const resultCarriesEvidence = (details) => {
-    const observation = details?.observation;
-    if (observation === null || typeof observation !== "object" || Array.isArray(observation)) return true;
-    const record = observation;
-    return !(record.truncated === true && record.shownCount === 0);
-  };
-  const recordSuccessfulResult = (input) => {
-    if (input.metadata?.resultKind !== "ok") return;
-    if (!resultCarriesEvidence(input.toolResultDetails)) return;
-    const tool = input.toolName;
-    if (typeof tool !== "string" || tool.length === 0) return;
-    bumpBoundedCounter(succeededFingerprints, hashToolCall(tool, input.toolArgs ?? {}), SUCCEEDED_FINGERPRINT_LIMIT);
-  };
-  const recordResultForStagnation = (input) => {
-    const turnKey = input.turnId ?? NO_TURN_BUCKET;
-    const tool = input.toolName;
-    const resultFingerprint = input.metadata?.resultFingerprint;
-    if (typeof tool !== "string" || tool.length === 0 || input.metadata?.resultKind !== "ok" || typeof resultFingerprint !== "string") {
-      stagnationByTurn.delete(turnKey);
-      return;
-    }
-    const reducedFingerprint = stagnationFingerprint(tool, input.toolArgs);
-    const previous = stagnationByTurn.get(turnKey);
-    if (previous !== void 0 && previous.reducedFingerprint === reducedFingerprint && previous.resultFingerprint === resultFingerprint) {
-      previous.streak += 1;
-      return;
-    }
-    if (!stagnationByTurn.has(turnKey)) {
-      while (stagnationByTurn.size >= LOOP_GUARD_TURN_LIMIT) {
-        const oldest = stagnationByTurn.keys().next().value;
-        if (typeof oldest !== "string") break;
-        stagnationByTurn.delete(oldest);
-      }
-    }
-    stagnationByTurn.set(turnKey, { reducedFingerprint, resultFingerprint, streak: 1 });
-  };
-  const crossArgumentResultEffects = (input) => {
-    const turnKey = input.turnId ?? NO_TURN_BUCKET;
-    const tool = input.toolName;
-    const resultFingerprint = input.metadata?.resultFingerprint;
-    const resultBytes = input.metadata?.resultBytes;
-    if (typeof tool !== "string" || tool.length === 0 || input.metadata?.actionClass !== "read" || input.metadata?.resultKind !== "ok" || typeof resultFingerprint !== "string" || typeof resultBytes !== "number" || resultBytes < CROSS_ARGUMENT_RESULT_MIN_BYTES || !resultCarriesEvidence(input.toolResultDetails)) {
-      crossArgumentResultsByTurn.delete(turnKey);
-      return [];
-    }
-    const argumentFingerprint = stagnationFingerprint(tool, input.toolArgs);
-    const previous = crossArgumentResultsByTurn.get(turnKey);
-    if (previous?.tool === tool && previous.resultFingerprint === resultFingerprint) {
-      if (previous.warned) return [];
-      previous.argumentFingerprints.add(argumentFingerprint);
-      if (previous.argumentFingerprints.size >= RESULT_STAGNATION_THRESHOLD) {
-        previous.warned = true;
-        return [
-          {
-            kind: "annotate_tool_result",
-            message: crossArgumentResultMessage(tool, previous.argumentFingerprints.size),
-            severity: "warn"
-          }
-        ];
-      }
-      return [];
-    }
-    if (!crossArgumentResultsByTurn.has(turnKey)) {
-      while (crossArgumentResultsByTurn.size >= LOOP_GUARD_TURN_LIMIT) {
-        const oldest = crossArgumentResultsByTurn.keys().next().value;
-        if (typeof oldest !== "string") break;
-        crossArgumentResultsByTurn.delete(oldest);
-      }
-    }
-    crossArgumentResultsByTurn.set(turnKey, {
-      tool,
-      resultFingerprint,
-      argumentFingerprints: /* @__PURE__ */ new Set([argumentFingerprint]),
-      warned: false
-    });
-    return [];
-  };
-  const bumpTurnBlocks = (turnId) => bumpBoundedCounter(blocksByTurn, turnId);
-  const enterLockout = (input, turnKey, state) => {
-    if (!lockoutByTurn.has(turnKey)) {
-      while (lockoutByTurn.size >= LOOP_GUARD_TURN_LIMIT) {
-        const oldest = lockoutByTurn.keys().next().value;
-        if (typeof oldest !== "string") break;
-        lockoutByTurn.delete(oldest);
-      }
-    }
-    lockoutByTurn.set(turnKey, {
-      ...state,
-      denials: 0,
-      ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
-    });
-  };
-  const reachesLockoutBackstop = (state, input) => {
-    if (input.correlationId !== void 0 && state.correlationId === input.correlationId) return false;
-    state.denials += 1;
-    if (input.correlationId !== void 0) state.correlationId = input.correlationId;
-    else delete state.correlationId;
-    return state.denials > LOOP_SYNTHESIS_BACKSTOP_DENIALS;
-  };
-  const emitLoopBlocked = (input, info, at) => {
-    const payload = {
-      tool: info.tool,
-      repeatCount: info.repeatCount,
-      blocksThisTurn: info.blocksThisTurn,
-      budget,
-      interrupted: info.disposition === "stop",
-      disposition: info.disposition,
-      at,
-      ...input.turnId !== void 0 ? { turnId: input.turnId } : {}
-    };
-    options.bus?.emit(BusChannels.LoopBlocked, payload);
-  };
-  const emitBudgetEvent = (input, callsThisTurn, interrupted, at) => {
-    if (turnBudget === void 0) return;
-    const payload = {
-      tool: input.toolName ?? "unknown",
-      callsThisTurn,
-      softBudget: turnBudget.soft,
-      hardCeiling: turnBudget.hard,
-      interrupted,
-      at,
-      ...input.turnId !== void 0 ? { turnId: input.turnId } : {}
-    };
-    options.bus?.emit(BusChannels.ToolBudgetExceeded, payload);
-  };
-  const evaluateTurnBudget = (input, now) => {
-    if (turnBudget === void 0) return null;
-    const turnKey = input.turnId ?? NO_TURN_BUCKET;
-    const callsThisTurn = bumpBoundedCounter(callsByTurn, turnKey);
-    if (callsThisTurn >= turnBudget.hard) {
-      if (callsThisTurn === turnBudget.hard) emitBudgetEvent(input, callsThisTurn, true, now);
-      return [
-        {
-          kind: "block_tool",
-          reason: `tool-call budget exhausted: ${callsThisTurn} tool calls in this turn reached the hard ceiling (${turnBudget.hard}); the turn is being stopped. Summarize what you found and wait for the operator.`,
-          severity: "hard-block"
-        }
-      ];
-    }
-    if (callsThisTurn >= turnBudget.soft) {
-      if (callsThisTurn === turnBudget.soft) emitBudgetEvent(input, callsThisTurn, false, now);
-      return [
-        {
-          kind: "block_tool",
-          reason: `tool-call budget: you have made ${callsThisTurn} tool calls in this turn (soft budget ${turnBudget.soft}). Every further tool call this turn will be blocked, so do not retry this call and do not substitute another one. Summarize what you have found so far in plain text, state the single next step you propose, and wait for the operator.`,
-          severity: "hard-block"
-        }
-      ];
-    }
-    return null;
-  };
-  const blockAsLoop = (input, turnKey, tool, repeatCount, baseReason, now) => {
-    const blocksThisTurn = bumpTurnBlocks(turnKey);
-    const reachedBudget = blocksThisTurn >= budget;
-    if (synthesisLockout && reachedBudget) {
-      enterLockout(input, turnKey, { tool, repeatCount, blocksThisTurn });
-      options.onSynthesisLockout?.();
-      emitLoopBlocked(input, { tool, repeatCount, blocksThisTurn, disposition: "lockout" }, now);
-      return [{ kind: "block_tool", reason: synthesisLockoutDirective(), severity: "hard-block" }];
-    }
-    emitLoopBlocked(input, { tool, repeatCount, blocksThisTurn, disposition: reachedBudget ? "stop" : "block" }, now);
-    const reason = reachedBudget ? `${baseReason} Loop budget exhausted (${blocksThisTurn} blocks this turn); the agent is being stopped.` : baseReason;
-    return [{ kind: "block_tool", reason, severity: "hard-block" }];
-  };
-  return {
-    id: LOOP_GUARD_REGISTRATION_ID,
-    description: "blocks repeated tool calls, enforces tool-call caps, and annotates substantial identical read results across distinct arguments",
-    hooks: ["before_tool", "after_tool"],
-    callCount: () => count,
-    evaluate(input) {
-      if (input.hook === "after_tool") {
-        recordSuccessfulResult(input);
-        recordResultForStagnation(input);
-        const effects = [...crossArgumentResultEffects(input)];
-        if (softReadReserveEntered && softLockout === null && deliveryTools.length === 0 && input.toolName === ToolNames.Read) {
-          effects.push({ kind: "require_tool", toolName: ToolNames.Read });
-        }
-        if (reserveThreshold !== null && cap !== void 0 && !reserveDirectiveEmitted && count > reserveThreshold && count <= cap) {
-          reserveDirectiveEmitted = true;
-          effects.push({
-            kind: "annotate_tool_result",
-            message: workerSynthesisReserveDirective(Math.max(0, cap - count), cap),
-            severity: "warn"
-          });
-        }
-        return effects;
-      }
-      const now = options.now?.() ?? Date.now();
-      const turnKey = input.turnId ?? NO_TURN_BUCKET;
-      const decide = () => {
-        if (capLockout !== null && cap !== void 0) {
-          if (reachesLockoutBackstop(capLockout, input)) {
-            return [
-              { kind: "block_tool", reason: synthesisBackstopReason(input.toolName ?? "unknown"), severity: "hard-block" }
-            ];
-          }
-          return [{ kind: "block_tool", reason: workerToolCallCapSynthesisReason(cap), severity: "hard-block" }];
-        }
-        if (softLockout !== null && softLimit !== void 0) {
-          if (reachesLockoutBackstop(softLockout, input)) {
-            return [
-              { kind: "block_tool", reason: synthesisBackstopReason(input.toolName ?? "unknown"), severity: "hard-block" }
-            ];
-          }
-          return [{ kind: "block_tool", reason: workerExplorationSynthesisDirective(softLimit), severity: "hard-block" }];
-        }
-        const lockout = synthesisLockout ? lockoutByTurn.get(turnKey) : void 0;
-        if (lockout !== void 0) {
-          if (reachesLockoutBackstop(lockout, input)) {
-            emitLoopBlocked(
-              input,
-              {
-                tool: lockout.tool,
-                repeatCount: lockout.repeatCount,
-                blocksThisTurn: lockout.blocksThisTurn,
-                disposition: "stop"
-              },
-              now
-            );
-            return [{ kind: "block_tool", reason: synthesisBackstopReason(lockout.tool), severity: "hard-block" }];
-          }
-          return [{ kind: "block_tool", reason: synthesisLockoutDirective(), severity: "hard-block" }];
-        }
-        if (softLimit !== void 0) {
-          const spentSoftLimit = softAdmittedCount >= softLimit;
-          if (spentSoftLimit && deliveryTools.length === 0) {
-            softLockout = {
-              denials: 0,
-              ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
-            };
-            options.onSynthesisLockout?.();
-            return [{ kind: "block_tool", reason: workerExplorationSynthesisDirective(softLimit), severity: "hard-block" }];
-          }
-          const inReserve = softReadReserveThreshold !== null && softAdmittedCount >= softReadReserveThreshold;
-          if (spentSoftLimit || inReserve) {
-            enterSoftReadReserve();
-            if (!reserveAdmits(input.toolName)) {
-              if (reachesLockoutBackstop(reserveDenials, input)) {
-                softLockout = {
-                  denials: 0,
-                  ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
-                };
-                options.onSynthesisLockout?.();
-                return [{ kind: "block_tool", reason: workerExplorationSynthesisDirective(softLimit), severity: "hard-block" }];
-              }
-              return [
-                {
-                  kind: "block_tool",
-                  reason: spentSoftLimit ? workerDeliveryOnlyDirective(softLimit, deliveryTools) : workerLiveReadReserveDirective(softLimit - softAdmittedCount, deliveryTools),
-                  severity: "hard-block"
-                }
-              ];
-            }
-          }
-        }
-        if (reserveThreshold !== null && cap !== void 0 && count >= reserveThreshold && !reserveAdmits(input.toolName)) {
-          if (reachesLockoutBackstop(reserveDenials, input)) {
-            if (synthesisLockout) {
-              capLockout = {
-                denials: 0,
-                ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
-              };
-              options.onSynthesisLockout?.();
-            }
-            return [{ kind: "block_tool", reason: workerToolCallCapSynthesisReason(cap), severity: "hard-block" }];
-          }
-          return [
-            {
-              kind: "block_tool",
-              reason: workerSynthesisReserveBlockReason(input.toolName ?? "unknown", Math.max(1, cap - count), cap),
-              severity: "hard-block"
-            }
-          ];
-        }
-        count += 1;
-        reserveDenials = { denials: 0 };
-        if (softLimit !== void 0) {
-          softAdmittedCount += 1;
-          if (softReadReserveThreshold !== null && softAdmittedCount >= softReadReserveThreshold) enterSoftReadReserve();
-          if (softAdmittedCount >= softLimit) {
-            if (deliveryTools.length === 0) {
-              softLockout = {
-                denials: 0,
-                ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
-              };
-              options.onSynthesisLockout?.();
-            }
-            options.onSoftLimitFinalCallAdmitted?.(input.toolCallId);
-          }
-        }
-        if (cap !== void 0 && count > cap) {
-          if (!synthesisLockout) {
-            return [{ kind: "block_tool", reason: workerToolCallCapExceededReason(cap), severity: "hard-block" }];
-          }
-          capLockout = {
-            denials: 0,
-            ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
-          };
-          options.onSynthesisLockout?.();
-          return [{ kind: "block_tool", reason: workerToolCallCapSynthesisReason(cap), severity: "hard-block" }];
-        }
-        const fingerprint = input.metadata?.callFingerprint;
-        if (typeof fingerprint !== "string" || fingerprint.length === 0) {
-          return evaluateTurnBudget(input, now) ?? [];
-        }
-        const verdict = options.safety.observeLoop(`${turnKey}|${fingerprint}`, now);
-        if (verdict.looping) {
-          const tool = input.toolName ?? "unknown";
-          const priorSuccesses = succeededFingerprints.get(fingerprint) ?? 0;
-          return blockAsLoop(
-            input,
-            turnKey,
-            tool,
-            verdict.count,
-            loopBlockBaseReason(tool, verdict.count, priorSuccesses),
-            now
-          );
-        }
-        const toolName = input.toolName;
-        if (typeof toolName === "string" && toolName.length > 0) {
-          const entry = stagnationByTurn.get(turnKey);
-          if (entry !== void 0 && entry.streak >= RESULT_STAGNATION_THRESHOLD - 1 && entry.reducedFingerprint === stagnationFingerprint(toolName, input.toolArgs)) {
-            return blockAsLoop(
-              input,
-              turnKey,
-              toolName,
-              entry.streak + 1,
-              stagnationBlockReason(toolName, entry.streak),
-              now
-            );
-          }
-        }
-        return evaluateTurnBudget(input, now) ?? [];
-      };
-      return boundRunDenials(decide(), input);
-    }
-  };
-}
-function isReserveAdmittedTool(tool, deliveryTools) {
-  return tool === ToolNames.Read || tool !== void 0 && deliveryTools.includes(tool);
-}
-function resolveDeliveryTools(allowedTools, product) {
-  const candidates = product === "orientation" ? [ToolNames.Write, ToolNames.Edit, ToolNames.CodeNav] : [ToolNames.Write, ToolNames.Edit];
-  if (allowedTools instanceof Set) {
-    return candidates.filter((tool) => allowedTools.has(tool));
-  }
-  return candidates.filter((tool) => allowedTools.includes(tool));
-}
-
-// src/engine/agent.ts
-init_esm_shims();
-import { Agent } from "@earendil-works/pi-agent-core";
-import { streamSimple } from "@earendil-works/pi-ai/compat";
-function createEngineAgent(options = {}) {
-  const agent = new Agent({ streamFn: streamSimple, ...options });
-  return {
-    agent,
-    state: () => agent.state
-  };
-}
-
-// src/domains/safety/call-target.ts
-init_esm_shims();
-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));
-}
-function describeCallTarget(args) {
-  if (!args) return "";
-  const str = (value) => typeof value === "string" && value.trim().length > 0 ? oneLine(sanitizeForDisplay(value)).trim() || null : null;
-  const candidate = str(args.command) ?? str(args.path) ?? str(args.file_path) ?? str(args.name) ?? str(args.pattern);
-  if (candidate) return candidate;
-  try {
-    const json = JSON.stringify(args);
-    return json === "{}" || json === void 0 ? "" : oneLine(sanitizeForDisplay(json)).slice(0, 120);
-  } catch {
-    return "";
-  }
-}
-
-// src/engine/provider-payload.ts
-init_esm_shims();
-function reasoningSummaryForLevel(level) {
-  if (!level || level === "off") return void 0;
-  if (level === "minimal" || level === "low") return "concise";
-  return "detailed";
-}
-function isOpenAIResponsesApi(api) {
-  return api === "openai-codex-responses" || api === "openai-responses" || api === "azure-openai-responses";
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function namedToolDefinitions(tools, toolName) {
-  if (!Array.isArray(tools)) return null;
-  const narrowed = [];
-  for (const tool of tools) {
-    if (!isRecord(tool)) continue;
-    const directName = typeof tool.name === "string" ? tool.name : void 0;
-    const functionName = isRecord(tool.function) && typeof tool.function.name === "string" ? tool.function.name : void 0;
-    const toolSpecName = isRecord(tool.toolSpec) && typeof tool.toolSpec.name === "string" ? tool.toolSpec.name : void 0;
-    if (directName === toolName || functionName === toolName || toolSpecName === toolName) {
-      narrowed.push(tool);
-      continue;
-    }
-    if (Array.isArray(tool.functionDeclarations)) {
-      const declarations = tool.functionDeclarations.filter(
-        (declaration) => isRecord(declaration) && declaration.name === toolName
-      );
-      if (declarations.length > 0) narrowed.push({ ...tool, functionDeclarations: declarations });
-    }
-  }
-  return narrowed.length > 0 ? narrowed : null;
-}
-function numberValue(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
-}
-function patchOpenAIReasoningSummaryPayload(payload, model, thinkingLevel) {
-  if (!isOpenAIResponsesApi(model.api)) return void 0;
-  const summary = reasoningSummaryForLevel(thinkingLevel);
-  if (!summary || !isRecord(payload)) return void 0;
-  const record = payload;
-  const reasoning = record.reasoning;
-  if (!isRecord(reasoning)) return void 0;
-  return {
-    ...record,
-    reasoning: {
-      ...reasoning,
-      summary
-    }
-  };
-}
-function isAnthropicMessagesApi(api) {
-  return api === "anthropic-messages";
-}
-function anthropicThinkingLevelMap(model) {
-  return model.thinkingLevelMap;
-}
-function anthropicUsesAdaptiveThinking(model) {
-  const compat = model.compat;
-  return compat?.forceAdaptiveThinking === true;
-}
-function patchAnthropicThinkingPayload(payload, model, thinkingLevel) {
-  if (!isAnthropicMessagesApi(model.api) || model.reasoning !== true) return void 0;
-  if (!thinkingLevel || thinkingLevel === "off" || !isRecord(payload)) return void 0;
-  const record = payload;
-  const existingThinking = isRecord(record.thinking) ? record.thinking : {};
-  const display = typeof existingThinking.display === "string" ? existingThinking.display : "summarized";
-  if (anthropicUsesAdaptiveThinking(model)) {
-    const effort = defaultAnthropicEffortForLevel(thinkingLevel, anthropicThinkingLevelMap(model));
-    const existingOutputConfig = isRecord(record.output_config) ? record.output_config : {};
-    return {
-      ...record,
-      thinking: { ...existingThinking, type: "adaptive", display },
-      ...effort ? { output_config: { ...existingOutputConfig, effort } } : {}
-    };
-  }
-  const maxTokens = numberValue(record.max_tokens) ?? model.maxTokens;
-  const budgetTokens = defaultAnthropicBudgetForLevel(thinkingLevel, maxTokens);
-  if (budgetTokens === void 0) return void 0;
-  return {
-    ...record,
-    thinking: { ...existingThinking, type: "enabled", budget_tokens: budgetTokens, display }
-  };
-}
-function patchProviderThinkingPayload(payload, model, thinkingLevel) {
-  return patchOpenAIReasoningSummaryPayload(payload, model, thinkingLevel) ?? patchAnthropicThinkingPayload(payload, model, thinkingLevel);
-}
-function patchToolChoiceNonePayload(payload, model) {
-  if (!isRecord(payload)) return void 0;
-  if (!("tools" in payload) || payload.tools === void 0 || payload.tools === null) return void 0;
-  if (isAnthropicMessagesApi(model.api)) return { ...payload, tool_choice: { type: "none" } };
-  return { ...payload, tool_choice: "none" };
-}
-function patchToolSurfaceLockedPayload(payload, model) {
-  if (!isRecord(payload)) return void 0;
-  if (!("tools" in payload) || payload.tools === void 0 || payload.tools === null) return void 0;
-  if (isAnthropicMessagesApi(model.api)) return patchToolChoiceNonePayload(payload, model);
-  const stripped = { ...payload };
-  delete stripped.tools;
-  delete stripped.tool_choice;
-  return stripped;
-}
-function patchToolChoiceNamedPayload(payload, model, toolName) {
-  if (!isRecord(payload) || toolName.trim().length === 0) return void 0;
-  if (isAnthropicMessagesApi(model.api)) {
-    const tools2 = namedToolDefinitions(payload.tools, toolName);
-    if (tools2 === null) return void 0;
-    const patched = { ...payload };
-    delete patched.thinking;
-    if (isRecord(patched.output_config) && "effort" in patched.output_config) {
-      const outputConfig = { ...patched.output_config };
-      delete outputConfig.effort;
-      if (Object.keys(outputConfig).length > 0) patched.output_config = outputConfig;
-      else delete patched.output_config;
-    }
-    return { ...patched, tools: tools2, tool_choice: { type: "tool", name: toolName } };
-  }
-  if (model.api === "google-generative-ai" || model.api === "google-vertex") {
-    if (!isRecord(payload.config) || payload.config.tools === void 0 || payload.config.tools === null)
-      return void 0;
-    const tools2 = namedToolDefinitions(payload.config.tools, toolName);
-    if (tools2 === null) return void 0;
-    const toolConfig = isRecord(payload.config.toolConfig) ? payload.config.toolConfig : {};
-    return {
-      ...payload,
-      config: {
-        ...payload.config,
-        tools: tools2,
-        toolConfig: {
-          ...toolConfig,
-          functionCallingConfig: { mode: "ANY", allowedFunctionNames: [toolName] }
-        }
-      }
-    };
-  }
-  if (model.api === "bedrock-converse-stream") {
-    if (!isRecord(payload.toolConfig) || payload.toolConfig.tools === void 0 || payload.toolConfig.tools === null) {
-      return void 0;
-    }
-    const tools2 = namedToolDefinitions(payload.toolConfig.tools, toolName);
-    if (tools2 === null) return void 0;
-    return { ...payload, toolConfig: { ...payload.toolConfig, tools: tools2, toolChoice: { tool: { name: toolName } } } };
-  }
-  const tools = namedToolDefinitions(payload.tools, toolName);
-  if (tools === null) return void 0;
-  if (isOpenAIResponsesApi(model.api)) {
-    return { ...payload, tools, tool_choice: { type: "function", name: toolName } };
-  }
-  if (model.api === "mistral-conversations") {
-    return { ...payload, tools, toolChoice: { type: "function", function: { name: toolName } } };
-  }
-  return { ...payload, tools, tool_choice: { type: "function", function: { name: toolName } } };
-}
-function patchLlamaCppResponseSchemaPayload(payload, runtimeId, responseSchema) {
-  if (responseSchema === void 0) return void 0;
-  if (runtimeId !== RESPONSE_SCHEMA_RUNTIME_ID) {
-    throw new Error(`responseSchema requires the native llamacpp runtime; received '${runtimeId}'`);
-  }
-  if (!isRecord(payload)) throw new Error("cannot apply responseSchema to a non-object provider payload");
-  return {
-    ...payload,
-    response_format: {
-      // llama-server accepts schema-constrained JSON through the widely
-      // compatible json_object form; some deployed gateways silently ignore
-      // the newer json_schema discriminator while still returning HTTP 200.
-      type: "json_object",
-      schema: responseSchema
-    }
-  };
-}
-function patchWorkerRequestPayload(payload, model, options) {
-  let patched = payload;
-  let changed = false;
-  const thinkingPatched = patchProviderThinkingPayload(patched, model, options.thinkingLevel);
-  if (thinkingPatched !== void 0) {
-    patched = thinkingPatched;
-    changed = true;
-  }
-  const schemaPatched = patchLlamaCppResponseSchemaPayload(patched, options.runtimeId, options.responseSchema);
-  if (schemaPatched !== void 0) {
-    patched = schemaPatched;
-    changed = true;
-  }
-  if (options.toolSurfaceLocked === true) {
-    const lockedPatched = patchToolSurfaceLockedPayload(patched, model);
-    if (lockedPatched !== void 0) {
-      patched = lockedPatched;
-      changed = true;
-    }
-  } else if (options.toolChoiceNone === true) {
-    const toolChoicePatched = patchToolChoiceNonePayload(patched, model);
-    if (toolChoicePatched !== void 0) {
-      patched = toolChoicePatched;
-      changed = true;
-    }
-  } else if (options.toolChoiceName !== void 0) {
-    const toolChoicePatched = patchToolChoiceNamedPayload(patched, model, options.toolChoiceName);
-    if (toolChoicePatched !== void 0) {
-      patched = toolChoicePatched;
-      changed = true;
-    }
-  }
-  return changed ? patched : void 0;
-}
-
-export {
-  createProtectedArtifactsRegistration,
-  INTERACTIVE_LOOP_BLOCK_BUDGET,
-  workerLoopBlockBudget,
-  lockedSynthesisFallbackText,
-  sanitizeLockedSynthesisMessage,
-  isLoopGuardSynthesisBackstopReason,
-  readOrchTurnToolCallBudget,
-  createLoopGuardRegistration,
-  isReserveAdmittedTool,
-  resolveDeliveryTools,
-  createEngineAgent,
-  sanitizeCallTargetText,
-  describeCallTarget,
-  patchProviderThinkingPayload,
-  patchToolChoiceNonePayload,
-  patchToolChoiceNamedPayload,
-  patchWorkerRequestPayload
-};
-//# sourceMappingURL=chunk-DKGKUHFA.js.map