@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/worker/entry.js

@@ -1,86 +1,90 @@
 #!/usr/bin/env node
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  assertRegisteredBuiltinTools,
   createEngineAgent,
   createLoopGuardRegistration,
   createProtectedArtifactsRegistration,
-  effectiveToolNames,
   isLockedSynthesisFallbackOnly,
   isLoopGuardSynthesisBackstopReason,
   isReserveAdmittedTool,
   lockedSynthesisFallbackText,
   lockedSynthesisRepromptMessages,
+  lockedSynthesisSystemPrompt,
   patchWorkerRequestPayload,
-  registerCoreTools,
-  registerHarnessExtensionTools,
-  resolveAgentTools,
   resolveDeliveryTools,
   sanitizeLockedSynthesisMessage,
+  supportsNamedToolChoice,
   workerLoopBlockBudget
-} from "../chunk-ZF6CV4WZ.js";
-import {
-  createMiddlewareContractFromSnapshot,
-  createMiddlewareToolChoiceControl,
-  shouldRequestStalledTurnContinuation
-} from "../chunk-VPWGADBG.js";
+} from "../chunk-GRHOXDKB.js";
 import {
   readLayeredSettings
-} from "../chunk-W72LLZAV.js";
-import "../chunk-ACCECAH4.js";
-import "../chunk-HBJQQTKM.js";
-import "../chunk-JABWPKFY.js";
-import "../chunk-HCVKSGNZ.js";
-import "../chunk-PNJE7JPS.js";
-import "../chunk-L4RUTLRL.js";
-import "../chunk-PPIFDSBK.js";
-import "../chunk-TCUOGIL2.js";
-import "../chunk-PP23PZEV.js";
-import "../chunk-3A3CUMKA.js";
-import "../chunk-XCUDZQLX.js";
-import "../chunk-K2BLQC5E.js";
+} from "../chunk-ZNUZ3EXD.js";
 import {
   DEFAULT_ESCALATION_FALLBACK,
   DEFAULT_ESCALATION_TIMEOUT_MS,
   WORKER_EXIT_PERMISSION_REQUIRED,
   claudeToolsOutsideProfile,
   coerceToolInput,
-  createRegistry,
   createRunEffectsRecorder,
   emitClaudeToolPermissionDecision,
   isClaudeCodeSessionId,
   nodeResultContractFilesystem,
   parseWorkerSpec,
-  runtimeSpeaksResponseSchemaDialect,
   startAntigravityWorkerRun,
   startClaudeCodeWorkerRun,
   validateRehydratedWorkerRuntime
-} from "../chunk-4ATBOFRP.js";
+} from "../chunk-R7FGRZNF.js";
+import "../chunk-DOUISWEE.js";
+import "../chunk-VKHLUZNO.js";
+import {
+  INTERNAL_HELPER_RESULT_TOOL,
+  attestedToolSignature,
+  createMiddlewareToolChoiceControl,
+  createWorkerSafety,
+  createWorkerToolRegistry,
+  resolveAgentTools,
+  runtimeSpeaksResponseSchemaDialect,
+  shouldRequestStalledTurnContinuation
+} from "../chunk-OQ2EOAHA.js";
+import "../chunk-NDPF2N2L.js";
+import "../chunk-7QXCO3AF.js";
 import {
   contextHash,
   messageToolCalls,
   seededWorkerMessages
-} from "../chunk-MO65K5CH.js";
-import "../chunk-KOAHT3N2.js";
-import {
-  CONFIRMED_SCOPE,
-  READONLY_SCOPE,
-  WORKSPACE_SCOPE,
-  createLoopState,
-  isSubset,
-  observe
-} from "../chunk-AY4XE6GN.js";
-import "../chunk-555E2WVV.js";
+} from "../chunk-T33IYTZM.js";
 import "../chunk-OH3YYA3B.js";
-import "../chunk-6TKOFFGE.js";
-import {
-  effectiveToolCall
-} from "../chunk-2JBZYUPY.js";
+import "../chunk-VESL6DQY.js";
+import "../chunk-FD3IAHQM.js";
 import {
   describeCallTarget
 } from "../chunk-XNIZBOFV.js";
 import "../chunk-XZWSP67B.js";
-import "../chunk-H6IUCY6Q.js";
+import "../chunk-BRCOSE7O.js";
+import "../chunk-55RMDDFM.js";
+import "../chunk-L4N3DWNW.js";
+import "../chunk-TDGYTWM6.js";
+import "../chunk-CTFPFW3H.js";
+import {
+  effectiveToolCall
+} from "../chunk-DE2LU267.js";
+import "../chunk-YYLCPDCC.js";
+import "../chunk-EFSEIZE6.js";
+import "../chunk-KBUTSJSR.js";
+import "../chunk-YBUECLAF.js";
+import "../chunk-CRHPCPZP.js";
+import "../chunk-FFYTC2KQ.js";
+import "../chunk-UJD5MPP6.js";
+import "../chunk-DZLR4UEH.js";
+import "../chunk-OPD7GL6F.js";
+import "../chunk-733ZBT5P.js";
+import "../chunk-GHXGMFQ5.js";
+import "../chunk-KECNXMDE.js";
+import "../chunk-WXA2CFJO.js";
+import "../chunk-6CTHLZFB.js";
+import "../chunk-2KUBKL63.js";
+import "../chunk-MYI32N4R.js";
+import "../chunk-X6FLVUM5.js";
 import {
   FileKnowledgeBase,
   applyModelCapabilityPatch,
@@ -91,86 +95,47 @@ import {
   resolveProviderKnowledgeBaseRoots,
   resolveReservedOutputTokens,
   setGlobalDefaultMaxOutputTokens,
+  setModelLoadReportSink,
   setProtectedModelsProvider,
   setResidencyNoticeSink
-} from "../chunk-4HFJKRGZ.js";
+} from "../chunk-EYTLV3W3.js";
 import "../chunk-MCJKEGHO.js";
-import "../chunk-CTGZCEI6.js";
-import "../chunk-RL7LJYN4.js";
+import "../chunk-DVTBERFY.js";
+import "../chunk-6EJYVCTN.js";
+import "../chunk-W53XSRQE.js";
 import {
   estimateAgentContextBreakdown,
   estimateAgentMessageTokens
-} from "../chunk-SJMNU4ZS.js";
-import "../chunk-W5RM7YAH.js";
-import "../chunk-EFSEIZE6.js";
-import "../chunk-SL2RDHKO.js";
-import "../chunk-YGDMBK7O.js";
-import "../chunk-JURMQWVJ.js";
-import "../chunk-IZZI3SKQ.js";
-import "../chunk-ZKQ63XZ5.js";
-import {
-  createSafetyPolicyEngine
-} from "../chunk-IC7JXLOM.js";
-import "../chunk-X6FLVUM5.js";
-import "../chunk-GHXGMFQ5.js";
-import "../chunk-KECNXMDE.js";
-import "../chunk-WXA2CFJO.js";
-import "../chunk-KP5BPXR3.js";
-import {
-  RESULT_CONTRACT_REPAIR_LIMIT,
-  parseWorkerResultContract,
-  resultContractRepairMessages,
-  validateResultContract
-} from "../chunk-I47EJPYL.js";
-import "../chunk-XW2UZICE.js";
-import {
-  readSettings
-} from "../chunk-FPS4R2RN.js";
-import "../chunk-DVNAPPXU.js";
-import "../chunk-5EQO5NWP.js";
-import {
-  classify
-} from "../chunk-H2WSCZZT.js";
-import {
-  protectedArtifactMutationBlockReason
-} from "../chunk-SQBT46OF.js";
-import "../chunk-KQ6IDQIB.js";
-import "../chunk-L4N3DWNW.js";
-import "../chunk-YQYINEJI.js";
-import "../chunk-H72DCH3E.js";
-import "../chunk-2KUBKL63.js";
-import "../chunk-MYI32N4R.js";
-import "../chunk-R2P2U3ZS.js";
-import "../chunk-NTTS3O53.js";
-import "../chunk-M4KFUXS7.js";
-import {
-  ToolNames
-} from "../chunk-V4XJWDHR.js";
+} from "../chunk-6W75D37F.js";
 import {
   registerBuiltinRuntimes
-} from "../chunk-NPLLK3HO.js";
-import "../chunk-ZKJU55MX.js";
-import "../chunk-U2MSJ57E.js";
-import {
-  configureGuardrails,
-  guardrailValuesFromSettings,
-  isWorkerToolCallCapExceededReason,
-  isWorkerToolCallCapSynthesisReason
-} from "../chunk-C27U2TYG.js";
-import "../chunk-EM2DIQAJ.js";
-import "../chunk-ZKVMDNAN.js";
+} from "../chunk-77DCC6JZ.js";
+import "../chunk-SYF7FVBL.js";
+import "../chunk-Z4GLJ6J4.js";
 import "../chunk-VNBICSS2.js";
-import "../chunk-B5GGDIHT.js";
 import {
   getRuntimeRegistry
-} from "../chunk-SRCEQKQS.js";
-import "../chunk-JIYWMQZ5.js";
+} from "../chunk-2WVPJF3Z.js";
+import "../chunk-27YTM2CV.js";
 import {
   engineStreamSimple,
-  registerFauxFromEnv
-} from "../chunk-UIU7MGZ3.js";
-import "../chunk-DXVMLM3Z.js";
+  registerFauxFromEnv,
+  resolvedRequestContext
+} from "../chunk-L7G7K4I2.js";
+import "../chunk-ALJWT6O6.js";
+import {
+  deleteInjectedCompileCacheFrom
+} from "../chunk-4WV4PI66.js";
+import "../chunk-HMN2C6YL.js";
 import {
+  agentSkillToolPolicy
+} from "../chunk-I4Y4WKZR.js";
+import "../chunk-UZVYEF57.js";
+import "../chunk-O3VV6IVK.js";
+import "../chunk-EKV4UBCM.js";
+import "../chunk-UHW5V7HC.js";
+import {
+  RESULT_CONTRACT_REPAIR_LIMIT,
   UNKNOWN_RESOURCE,
   WORKER_PROTOCOL_VERSION,
   WORKER_RESOURCE_LABEL_MAX,
@@ -178,38 +143,61 @@ import {
   canonicalJson,
   encodeControlFrame,
   endpointIdentityHash,
+  internalHelperResultSchema,
   knownResource,
   parseAgentLedgerBody,
   parseAgentLedgerEntry,
-  toolSignatureOf,
+  parseWorkerResultContract,
+  resultContractRepairMessages,
+  resultContractRepairUserMessage,
+  resultContractShape,
+  validateResultContract,
+  validateStructuredHelperResult,
   withinFrameBudget,
   workerSpecDigest
-} from "../chunk-VQD7NH7Z.js";
+} from "../chunk-LNOXCGN2.js";
+import "../chunk-BJH6WFIB.js";
+import "../chunk-5EQO5NWP.js";
+import "../chunk-VYRQHORQ.js";
+import "../chunk-P4GNZPXO.js";
+import "../chunk-R2P2U3ZS.js";
+import "../chunk-NTTS3O53.js";
+import "../chunk-C2CPOIH2.js";
+import "../chunk-MGLRTOCK.js";
+import "../chunk-M4KFUXS7.js";
 import {
-  deleteInjectedCompileCacheFrom
-} from "../chunk-CKK25WN3.js";
-import "../chunk-XTQ7MEJG.js";
+  ToolNames
+} from "../chunk-V4XJWDHR.js";
+import {
+  readSettings
+} from "../chunk-56XP4FJU.js";
+import "../chunk-QZTTRSJE.js";
+import "../chunk-U2MSJ57E.js";
+import {
+  configureGuardrails,
+  guardrailValuesFromSettings,
+  isWorkerToolCallCapExceededReason,
+  isWorkerToolCallCapSynthesisReason
+} from "../chunk-C27U2TYG.js";
+import "../chunk-B5GGDIHT.js";
+import "../chunk-O63U2I6I.js";
+import "../chunk-M2IPMWCN.js";
 import {
   setGitCommitAttributionEnabled,
   withManagedGitCommitAttributionEnvironment
-} from "../chunk-LTR5QCLS.js";
+} from "../chunk-XS2QPZJE.js";
 import "../chunk-6EXUUOSN.js";
 import {
   AI_AGENT_NAME
 } from "../chunk-ZTNFYMIO.js";
-import {
-  agentSkillToolPolicy
-} from "../chunk-NBPA5QM6.js";
-import {
-  DEFAULT_AUTONOMY_LEVEL
-} from "../chunk-EM2WNQS2.js";
-import "../chunk-O3VV6IVK.js";
-import "../chunk-DVJL77SO.js";
-import "../chunk-3RDHGNU7.js";
-import "../chunk-UHW5V7HC.js";
+import "../chunk-53OXPRI6.js";
+import "../chunk-2EMLKSCX.js";
 import "../chunk-KMF54VH3.js";
+import "../chunk-DVJL77SO.js";
 import "../chunk-SER7RRAE.js";
-import "../chunk-GH5ZR6JP.js";
+import {
+  typebox_exports
+} from "../chunk-GH5ZR6JP.js";
 import "../chunk-TK2BMCBZ.js";
 import {
   clioStateDir
@@ -217,10 +205,14 @@ import {
 import {
   safeResourceWrite
 } from "../chunk-ZZFWWYLX.js";
-import "../chunk-GD55RTIW.js";
+import "../chunk-2VLYHHFT.js";
+import "../chunk-3JHUFKG7.js";
 import {
   readClioVersion
-} from "../chunk-E3LEPLQ2.js";
+} from "../chunk-ZPST2KQO.js";
+import "../chunk-JQCLXSFI.js";
+import "../chunk-PS6JAWJZ.js";
+import "../chunk-FD2I4KBR.js";
 import {
   init_esm_shims
 } from "../chunk-ECBHH7LU.js";
@@ -381,132 +373,6 @@ import path from "node:path";
 // src/engine/claude/sdk-runtime.ts
 init_esm_shims();
 
-// src/engine/worker-tools.ts
-init_esm_shims();
-function createWorkerSafety(options = {}) {
-  let loopState = createLoopState();
-  const policyEngine = createSafetyPolicyEngine({
-    ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
-    ...options.writeRoots !== void 0 ? { writeRoots: options.writeRoots } : {}
-  });
-  const protectedArtifactState = {
-    artifacts: structuredClone(options.protectedArtifactState?.artifacts ?? [])
-  };
-  return {
-    classify: (call) => classify(call),
-    evaluate(call, posture) {
-      const protectedReason = protectedArtifactMutationBlockReason(protectedArtifactState, call.tool, call.args);
-      if (protectedReason !== null) {
-        const classification2 = classify(call);
-        const rejection = {
-          short: "protected artifact blocked",
-          detail: protectedReason,
-          hints: []
-        };
-        const metadata = policyEngine.metadata(posture);
-        const policy2 = {
-          kind: "block",
-          classification: classification2,
-          tool: call.tool,
-          actionClass: classification2.actionClass,
-          reasons: [...classification2.reasons, protectedReason],
-          ruleId: "protected-artifact",
-          reasonCode: "protected-artifact",
-          cwd: metadata.cwd,
-          policySource: "builtin-classifier",
-          rejection,
-          ...posture !== void 0 ? { posture } : {}
-        };
-        return { kind: "block", classification: classification2, rejection, policy: policy2 };
-      }
-      const policy = policyEngine.evaluate(call, posture);
-      const classification = policy.classification;
-      if (policy.kind === "block") {
-        const decision = {
-          kind: "block",
-          classification,
-          rejection: policy.rejection ?? fallbackRejection(policy),
-          policy
-        };
-        if (policy.match) decision.match = policy.match;
-        return decision;
-      }
-      if (policy.kind === "ask") {
-        const decision = {
-          kind: "ask",
-          classification,
-          rejection: policy.rejection ?? fallbackRejection(policy),
-          policy
-        };
-        if (policy.match) decision.match = policy.match;
-        return decision;
-      }
-      return { kind: "allow", classification, policy };
-    },
-    observeLoop(key, now) {
-      const [next, verdict] = observe(loopState, key, now ?? Date.now());
-      loopState = next;
-      return verdict;
-    },
-    scopes: { readonly: READONLY_SCOPE, workspace: WORKSPACE_SCOPE, confirmed: CONFIRMED_SCOPE },
-    isSubset,
-    policy: {
-      metadata: (posture) => policyEngine.metadata(posture),
-      allowsObservationPath: (path2) => policyEngine.evaluate({ tool: "read", args: { path: path2 } }).reasonCode !== "path-policy:zeroAccessPaths"
-    },
-    audit: { recordCount: () => 0 }
-  };
-}
-function fallbackRejection(policy) {
-  return {
-    short: `${policy.tool} blocked: ${policy.actionClass}`,
-    detail: policy.reasons.join("\n"),
-    hints: []
-  };
-}
-function createWorkerToolRegistry(middlewareSnapshot, safety = createWorkerSafety(), skillLoaderOptions, hookRegistrations, autonomy, onMiddlewareEffects, agentLedger, workerRecall) {
-  const middleware = createMiddlewareContractFromSnapshot(middlewareSnapshot ?? { version: 1, rules: [] });
-  for (const registration2 of hookRegistrations ?? []) {
-    middleware.registerHook(registration2);
-  }
-  const registry = createRegistry({
-    safety,
-    middleware,
-    autonomy: () => autonomy ?? DEFAULT_AUTONOMY_LEVEL,
-    ...onMiddlewareEffects ? { onMiddlewareEffects } : {}
-  });
-  const registration = registerCoreTools(registry, {
-    includeLedgerTools: true,
-    ...workerRecall ? { workerRecall } : {},
-    ...agentLedger ? { agentLedger } : {},
-    // A worker cannot install a skill or reach the operator who could, so
-    // its skill listing carries installed (or bound) skills only; the
-    // marketplace is the orchestrator's to offer.
-    skillMarketplace: false,
-    getSkillLoaderOptions: () => ({
-      trustProjectCompatRoots: skillLoaderOptions?.trustProjectCompatRoots === true,
-      disableDiscovery: skillLoaderOptions?.noSkills === true,
-      ...skillLoaderOptions?.skillPaths && skillLoaderOptions.skillPaths.length > 0 ? { explicitSkillPaths: skillLoaderOptions.skillPaths } : {}
-    })
-  });
-  assertRegisteredBuiltinTools(registry, registration, false);
-  registerHarnessExtensionTools(registry);
-  return registry;
-}
-function attestedToolSignature(input) {
-  const registry = createWorkerToolRegistry();
-  return toolSignatureOf(
-    effectiveToolNames({
-      registry,
-      allowedTools: input.toolsSupported ? input.allowedTools : [],
-      includeInteractiveTools: false,
-      ...input.toolProfile !== void 0 ? { toolProfile: input.toolProfile } : {},
-      ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
-      ...input.task !== void 0 ? { task: input.task } : {}
-    })
-  );
-}
-
 // src/engine/claude/sdk-module.ts
 init_esm_shims();
 var CLAUDE_AGENT_SDK_PACKAGE = "@anthropic-ai/claude-agent-sdk";
@@ -1068,6 +934,17 @@ function startClaudeSdkWorkerRun(input, emit) {
 }
 
 // src/engine/worker-runtime.ts
+function workerPermissionCacheKey(call, decision, axis) {
+  return canonicalJson({
+    tool: call.tool,
+    args: call.args ?? {},
+    axis,
+    actionClass: decision.classification.actionClass,
+    policyReason: decision.policy?.reasonCode,
+    policySource: decision.policy?.policySource,
+    policyHash: decision.policy?.policyHash
+  });
+}
 function isAssistantMessage(message) {
   if (typeof message !== "object" || message === null) return false;
   return "role" in message && message.role === "assistant";
@@ -1096,7 +973,7 @@ function terminalContractViolation(contract, message, cwd, observedReadRanges, o
   const text = assistantMessageText(message);
   if (text === null || text.length === 0) return "missing final result";
   if (text.trim() === lockedSynthesisFallbackText()) {
-    return "the reply after the tool-call lockout held only tool-call markup and was removed; tools are off, so state the final result as plain text";
+    return "the reply after the tool-call lockout held only tool-call markup and was removed; tools are off, so emit the required terminal result format";
   }
   const stopReason = message.stopReason;
   if (shouldRequestStalledTurnContinuation({
@@ -1158,7 +1035,14 @@ function taskMessage(task) {
 }
 function promptMessagesForWorker(input) {
   const messages = (input.dynamicPromptMessages ?? []).map(promptMessage);
-  messages.push(taskMessage(input.task));
+  messages.push(
+    taskMessage(
+      input.contextSeed ? `# Your worker assignment
+You are already the dispatched ${input.agentId} worker. The preceding conversation is inherited background; its requests to dispatch a worker were addressed to the parent. Carry out the assignment below, preserving safety and operator scope constraints. Do not dispatch yourself again.
+
+${input.task}` : input.task
+    )
+  );
   return messages;
 }
 function workerProviderSupportsTools(input) {
@@ -1184,6 +1068,10 @@ function startWorkerRun(input, emit) {
   if (input.contextSeed && input.runtime.kind !== "http")
     throw new Error("worker context: history seeds require a native Pi runtime");
   if (input.resultContract !== void 0) parseWorkerResultContract(input.resultContract, "WorkerSpec.resultContract");
+  const helperSchema = input.helperResult === true && input.resultContract ? internalHelperResultSchema(input.resultContract) : null;
+  if (input.helperResult === true && (helperSchema === null || input.runtime.kind !== "http")) {
+    throw new Error("helperResult requires a supported internal JSON contract and native HTTP worker");
+  }
   if (input.runtime.id === "claude-sdk") {
     return startClaudeSdkWorkerRun(input, emit);
   }
@@ -1226,6 +1114,7 @@ function startWorkerRun(input, emit) {
   let workerModelRound = 0;
   const loopGuardRegistration = createLoopGuardRegistration({
     safety,
+    readResultMaxBytes: workerSettings.context.toolResultMaxBytes,
     toolCallCap: workerBudget.hardCap,
     toolBudgetAdvisory: workerBudget.mode === "advisory",
     toolCallSoftLimit: workerBudget.toolCalls,
@@ -1287,9 +1176,28 @@ function startWorkerRun(input, emit) {
   const contractCwd = input.cwd ?? process.cwd();
   let resultContractRepairsQueued = 0;
   let resultContractRevisionActive = false;
+  let acceptedHelperResult = null;
+  let helperTerminalPhase = false;
+  let helperTurnFailure = null;
   const pendingReadCitations = /* @__PURE__ */ new Map();
   const observedReadRanges = /* @__PURE__ */ new Map();
   const runEffects = createRunEffectsRecorder(contractCwd);
+  const acceptHelperResult = (data) => {
+    if (!input.resultContract) return "missing helper result contract";
+    const checked = validateStructuredHelperResult({
+      contract: input.resultContract,
+      data,
+      cwd: contractCwd,
+      observedReadRanges,
+      observedRunEffects: runEffects.snapshot(),
+      networkAllowed: true,
+      filesystem: nodeResultContractFilesystem()
+    });
+    if (checked.structured === null) return checked.validation.reason ?? "invalid helper result";
+    acceptedHelperResult = checked.structured;
+    emit({ type: "clio_coder_helper_result", payload: checked.structured });
+    return null;
+  };
   const recordObservedRead = (request, result) => {
     const observation = result?.details?.observation;
     if (!observation) return;
@@ -1345,12 +1253,14 @@ function startWorkerRun(input, emit) {
   };
   const tools = resolveAgentTools({
     registry,
+    ...input.turnConstraints ? { turnConstraints: input.turnConstraints } : {},
     telemetry,
     allowedTools: activeWorkerTools,
     agentId: input.agentId,
     task: input.task,
     includeInteractiveTools: false,
     invokeOptions: () => ({
+      ...input.turnConstraints ? { turnConstraints: input.turnConstraints } : {},
       correlationId: `worker-model-round-${workerModelRound}`,
       toolResultMaxBytes: workerSettings.context.toolResultMaxBytes,
       supportsImages: model.input.includes("image"),
@@ -1360,6 +1270,32 @@ function startWorkerRun(input, emit) {
       ...agentSkillPolicy ? { pendingSkillPolicy: agentSkillPolicy } : {}
     })
   });
+  const helperToolAvailable = helperSchema !== null && workerProviderSupportsTools(input);
+  const helperForcedChoiceAvailable = helperToolAvailable && supportsNamedToolChoice(model.api);
+  if (helperToolAvailable) {
+    tools.push({
+      name: INTERNAL_HELPER_RESULT_TOOL,
+      label: "Submit helper result",
+      description: "Submit the final internal result as this tool's arguments. Call alone, after gathering evidence. A validated submission finishes the run; no prose response follows.",
+      parameters: typebox_exports.Unsafe(helperSchema),
+      async execute(_id, args) {
+        if (acceptedHelperResult !== null || workerBoundFailure !== null) {
+          return {
+            content: [{ type: "text", text: "The terminal result is already sealed." }],
+            details: { kind: "error" },
+            terminate: true
+          };
+        }
+        helperTerminalPhase = true;
+        synthesisToolLock = true;
+        helperTurnFailure = acceptHelperResult(args);
+        if (helperTurnFailure !== null) {
+          return { content: [{ type: "text", text: helperTurnFailure }], details: { kind: "error" } };
+        }
+        return { content: [{ type: "text", text: "Internal result accepted." }], details: { kind: "ok" }, terminate: true };
+      }
+    });
+  }
   if (tools.length === 0 && activeWorkerTools.length > 0) {
     process.stderr.write(`[worker] warning: no tools resolved for allowed=[${activeWorkerTools.join(",")}]
 `);
@@ -1369,16 +1305,41 @@ function startWorkerRun(input, emit) {
     input.runtimeResolution?.effectiveThinkingLevel ?? input.thinkingLevel
   );
   const inheritedMessages = seededWorkerMessages(input.contextSeed);
-  const inheritedCount = inheritedMessages.length;
   const contextGuard = createWorkerContextGuard(observations.archive);
   const options = {
-    streamFn: (currentModel, currentContext, streamOptions) => {
+    beforeToolCall: async ({ assistantMessage, toolCall }) => {
+      if (helperSchema === null) return void 0;
+      if (acceptedHelperResult !== null || workerBoundFailure !== null)
+        return { block: true, reason: "The helper result is sealed.", terminate: true };
+      const calls = assistantMessage.content.filter((block) => block.type === "toolCall");
+      if (calls.some((call) => call.name === INTERNAL_HELPER_RESULT_TOOL) && calls.length !== 1) {
+        helperTurnFailure = "Submit exactly one terminal handoff, alone; mixed or duplicate handoff batches are rejected without executing work.";
+        return { block: true, reason: helperTurnFailure };
+      }
+      if ((helperTerminalPhase || synthesisToolLock) && toolCall.name !== INTERNAL_HELPER_RESULT_TOOL) {
+        helperTurnFailure = "Work tools are disabled. Submit only the internal terminal result.";
+        return { block: true, reason: helperTurnFailure };
+      }
+      return void 0;
+    },
+    afterToolCall: async ({ toolCall, result }) => toolCall.name === INTERNAL_HELPER_RESULT_TOOL && result.details?.kind === "error" ? { isError: true } : void 0,
+    shouldStopAfterTurn: () => helperSchema !== null && (acceptedHelperResult !== null || workerBoundFailure !== null),
+    streamFn: (currentModel, transcript, streamOptions) => {
+      const currentContext = resolvedRequestContext(transcript);
+      const helperPrompt = helperToolAvailable && (!(synthesisToolLock || helperTerminalPhase) || helperForcedChoiceAvailable) ? `${currentContext.systemPrompt ?? ""}
+
+# Internal helper protocol
+Return the result by calling ${INTERNAL_HELPER_RESULT_TOOL} alone with the result object as arguments. Successful submission ends the run; no narrative report is needed.${synthesisToolLock || helperTerminalPhase ? " Work tools are disabled. Earlier tool-use instructions apply only to the completed work phase; only the terminal handoff remains available. Do not invent missing evidence." : ""}` : currentContext.systemPrompt;
+      const systemPrompt = helperToolAvailable && (!(synthesisToolLock || helperTerminalPhase) || helperForcedChoiceAvailable) ? helperPrompt : synthesisToolLock ? lockedSynthesisSystemPrompt(
+        currentContext.systemPrompt ?? "",
+        input.resultContract ? resultContractShape(input.resultContract) : void 0
+      ) : currentContext.systemPrompt;
       const window = input.runtimeResolution?.capabilities.contextWindow ?? currentModel.contextWindow;
       let messages;
       try {
         messages = contextGuard({
           messages: currentContext.messages,
-          systemPrompt: currentContext.systemPrompt ?? "",
+          systemPrompt: systemPrompt ?? "",
           tools: currentContext.tools ?? [],
           contextWindow: window,
           threshold: workerSettings.context.compaction.threshold,
@@ -1398,7 +1359,11 @@ function startWorkerRun(input, emit) {
       }
       return engineStreamSimple(
         currentModel,
-        { ...currentContext, messages },
+        {
+          ...currentContext,
+          ...systemPrompt !== void 0 ? { systemPrompt } : {},
+          messages
+        },
         streamOptions
       );
     },
@@ -1416,6 +1381,7 @@ function startWorkerRun(input, emit) {
         thinkingLevel: effectiveThinkingLevel,
         ...input.responseSchema !== void 0 ? { responseSchema: input.responseSchema } : {},
         toolSurfaceLocked: synthesisToolLock,
+        ...helperToolAvailable && (synthesisToolLock || helperTerminalPhase) && supportsNamedToolChoice(currentModel.api) ? { terminalToolName: INTERNAL_HELPER_RESULT_TOOL } : {},
         toolChoiceNone: middlewareChoice.kind === "none",
         ...middlewareChoice.kind === "required" ? { toolChoiceName: middlewareChoice.toolName } : {}
       });
@@ -1424,10 +1390,57 @@ function startWorkerRun(input, emit) {
   };
   if (input.sessionId) options.sessionId = input.sessionId;
   const { agent } = createEngineAgent(options);
+  const inheritedCount = agent.state.messages.length;
   agent.followUpMode = "all";
   abortWorkerForBound = () => agent.abort();
+  const repairHelperResult = (reason) => {
+    if (!input.resultContract || acceptedHelperResult !== null || workerBoundFailure !== null) return;
+    helperTerminalPhase = true;
+    synthesisToolLock = true;
+    if (resultContractRepairsQueued >= RESULT_CONTRACT_REPAIR_LIMIT) {
+      workerBoundFailure = `result contract failed after ${RESULT_CONTRACT_REPAIR_LIMIT} bounded repair rounds: ${reason}`;
+      emit({ type: "clio_coder_run_outcome", payload: { outcomeCode: "result_contract_exhausted" } });
+      return;
+    }
+    resultContractRepairsQueued += 1;
+    const instruction = helperForcedChoiceAvailable ? `${reason} Work tools remain disabled. Repair the result by calling ${INTERNAL_HELPER_RESULT_TOOL} exactly once, alone, with the complete result object. Do not emit prose.` : reason;
+    for (const message of resultContractRepairMessages(
+      {
+        contract: input.resultContract,
+        reason: instruction,
+        attempt: resultContractRepairsQueued,
+        anchors: observedReadAnchors()
+      },
+      { provider: model.provider, api: model.api, model: model.id }
+    )) {
+      const repairMessage = helperForcedChoiceAvailable && message.role === "toolResult" ? {
+        ...message,
+        content: [
+          {
+            type: "text",
+            text: `${instruction}
+Required arguments schema: ${JSON.stringify(helperSchema)}
+Observed read ranges: ${observedReadAnchors().join(", ") || "none"}`
+          }
+        ]
+      } : message;
+      agent.followUp(repairMessage);
+    }
+  };
   const unsubscribe = agent.subscribe(async (event) => {
-    if (event.type === "turn_start") workerModelRound += 1;
+    if (event.type === "turn_start") {
+      workerModelRound += 1;
+      helperTurnFailure = null;
+    }
+    if (helperSchema !== null && event.type === "message_end" && isAssistantMessage(event.message)) {
+      const calls = event.message.content.filter((block) => block.type === "toolCall");
+      if (calls.some((call) => call.name === INTERNAL_HELPER_RESULT_TOOL)) {
+        helperTerminalPhase = true;
+        synthesisToolLock = true;
+        if (calls.length !== 1)
+          helperTurnFailure = "Submit exactly one terminal handoff, alone; mixed or duplicate batches cannot execute work.";
+      }
+    }
     if (event.type === "tool_execution_start") middlewareToolChoice.toolStarted(event.toolName);
     if (event.type === "tool_execution_start") {
       runEffects.start(event.toolCallId, event.toolName, event.args);
@@ -1449,23 +1462,41 @@ function startWorkerRun(input, emit) {
       if (request !== void 0 && event.isError !== true) recordObservedRead(request, event.result);
     }
     let repromptedThisMessage = false;
-    if (synthesisToolLock && event.type === "message_end") {
+    if (synthesisToolLock && !helperToolAvailable && event.type === "message_end") {
       const stripped = sanitizeLockedSynthesisMessage(event.message);
       if (stripped && lockedSynthesisReprompts < 1 && isLockedSynthesisFallbackOnly(event.message)) {
         lockedSynthesisReprompts += 1;
         repromptedThisMessage = true;
-        process.stderr.write("[worker] synthesis lock: reply was tool-call markup only; re-prompting once for prose\n");
-        for (const message of lockedSynthesisRepromptMessages(lockedSynthesisReprompts, {
-          provider: model.provider,
-          api: model.api,
-          model: model.id
-        })) {
-          agent.followUp(message);
+        process.stderr.write(
+          "[worker] synthesis lock: reply was tool-call markup only; re-prompting once for the required final format\n"
+        );
+        const directive = lockedSynthesisRepromptMessages(
+          lockedSynthesisReprompts,
+          { provider: model.provider, api: model.api, model: model.id },
+          input.resultContract ? resultContractShape(input.resultContract) : void 0
+        ).find((message) => message.role === "toolResult");
+        if (directive?.role === "toolResult") {
+          agent.followUp({ role: "user", content: directive.content, timestamp: Date.now() });
         }
       }
     }
     const contract = input.resultContract;
-    if (contract && !repromptedThisMessage && event.type === "message_end" && isTerminalAssistantMessage(event.message)) {
+    if (helperSchema !== null && contract && !repromptedThisMessage && event.type === "message_end" && isTerminalAssistantMessage(event.message)) {
+      const text = assistantMessageText(event.message);
+      let reason;
+      try {
+        reason = acceptHelperResult(JSON.parse(text ?? ""));
+      } catch {
+        reason = "The internal result must be a JSON object conforming to the declared contract.";
+      }
+      if (reason !== null) repairHelperResult(reason);
+    }
+    if (helperSchema !== null && event.type === "turn_end" && acceptedHelperResult === null && event.toolResults.length > 0 && (helperTerminalPhase || synthesisToolLock)) {
+      const error = event.toolResults.find((result) => result.isError);
+      const reason = helperTurnFailure ?? error?.content.filter((block) => block.type === "text").map((block) => block.text).join("\n") ?? "The terminal handoff was not accepted.";
+      repairHelperResult(reason);
+    }
+    if (helperSchema === null && contract && !repromptedThisMessage && event.type === "message_end" && isTerminalAssistantMessage(event.message)) {
       const violation = terminalContractViolation(
         contract,
         event.message,
@@ -1486,16 +1517,14 @@ function startWorkerRun(input, emit) {
           }
           const revisionToolsAvailable = (workerBudget.mode === "advisory" || resultContractRevisionActive) && !synthesisToolLock;
           if (!revisionToolsAvailable) synthesisToolLock = true;
-          const repair = resultContractRepairMessages(
-            {
-              contract,
-              reason: violation,
-              attempt: resultContractRepairsQueued,
-              anchors: observedReadAnchors(),
-              ...revisionToolsAvailable ? { toolsAvailable: true } : {}
-            },
-            { provider: model.provider, api: model.api, model: model.id }
-          );
+          const repairInput = {
+            contract,
+            reason: violation,
+            attempt: resultContractRepairsQueued,
+            anchors: observedReadAnchors(),
+            toolsAvailable: revisionToolsAvailable
+          };
+          const repair = revisionToolsAvailable ? resultContractRepairMessages(repairInput, { provider: model.provider, api: model.api, model: model.id }) : [resultContractRepairUserMessage(repairInput)];
           for (const message of repair) agent.followUp(message);
         } else if (workerBoundFailure === null) {
           workerBoundFailure = `result contract failed after ${RESULT_CONTRACT_REPAIR_LIMIT} bounded repair rounds: ${violation}`;
@@ -1522,7 +1551,6 @@ function startWorkerRun(input, emit) {
   const failReason = (tool, actionClass) => `permission required for ${tool} (${actionClass}); workers.onPermission=fail ends this run`;
   let activeEscalation = null;
   const answeredEscalations = /* @__PURE__ */ new Map();
-  const escalationCallKey = (tool, args) => `${tool}\0${canonicalJson(args ?? {})}`;
   const clearActiveEscalation = () => {
     if (activeEscalation) {
       clearTimeout(activeEscalation.timer);
@@ -1533,7 +1561,7 @@ function startWorkerRun(input, emit) {
     const active = activeEscalation;
     if (!active || active.requestId !== requestId) return false;
     clearActiveEscalation();
-    answeredEscalations.set(active.callKey, { decision, requestId });
+    answeredEscalations.set(active.callKey, { decision, requestId, source });
     if (decision === "approve") {
       emit({
         type: "clio_coder_permission_resolved",
@@ -1600,11 +1628,11 @@ function startWorkerRun(input, emit) {
   const unsubscribePermission = registry.onPermissionRequired((call, decision, meta) => {
     const actionClass = decision.classification.actionClass;
     if (escalationConfig) {
-      const callKey = escalationCallKey(call.tool, call.args);
+      const callKey = workerPermissionCacheKey(call, decision, meta.axis);
       const remembered = answeredEscalations.get(callKey);
       if (remembered !== void 0) {
         const approved = remembered.decision === "approve";
-        const reason2 = approved ? `operator approved an identical ${call.tool} call earlier in this run (request ${remembered.requestId}); the answer stands without a new prompt` : `permission denied by operator: an identical ${call.tool} call was already denied earlier in this run (request ${remembered.requestId}); the answer stands, so do not repeat this call`;
+        const reason2 = approved ? `operator approved an identical ${call.tool} call under the same permission conditions earlier in this run (request ${remembered.requestId}); the answer stands without a new prompt` : `permission denied by ${remembered.source === "timeout" ? "escalation timeout fallback" : "operator"}: an identical ${call.tool} call under the same permission conditions was already denied earlier in this run (request ${remembered.requestId}); the answer stands, so do not repeat this call`;
         emit({
           type: "clio_coder_permission_resolved",
           payload: {
@@ -1685,6 +1713,9 @@ function startWorkerRun(input, emit) {
         return { messages: agent.state.messages.slice(inheritedCount), exitCode: WORKER_EXIT_PERMISSION_REQUIRED };
       }
       const messages = agent.state.messages.slice(inheritedCount);
+      if (helperSchema !== null && acceptedHelperResult === null) {
+        return { messages, exitCode: 1 };
+      }
       const errorMessage = getTerminalAgentError(messages);
       if (errorMessage !== null) {
         if (errorMessage.length > 0) {
@@ -2143,6 +2174,7 @@ function announceWorker(spec, input) {
       toolSignature: attestedToolSignature({
         allowedTools: spec.allowedTools,
         toolsSupported: workerProviderSupportsTools(input),
+        ...spec.helperResult === true ? { helperResult: true } : {},
         ...spec.toolProfile !== void 0 ? { toolProfile: spec.toolProfile } : {},
         agentId: spec.agentId,
         task: spec.task
@@ -2159,6 +2191,12 @@ async function main() {
       emitEvent({ type: "clio_coder_run_outcome", payload: { outcomeCode: "vram_capacity_fit_failure" } });
     }
   });
+  setModelLoadReportSink((load) => {
+    emitControlFrame({
+      kind: "model_loaded",
+      load: { targetId: load.targetId, modelId: load.modelId, aliasIds: load.aliasIds }
+    });
+  });
   const demux = createWorkerStdinDemux();
   process.stdin.setEncoding("utf8");
   process.stdin.on("data", (chunk) => demux.feed(chunk));
@@ -2215,6 +2253,7 @@ async function main() {
     allowedTools: spec.allowedTools,
     budget: spec.budget,
     ...spec.noSkills !== void 0 ? { noSkills: spec.noSkills } : {},
+    ...spec.turnConstraints !== void 0 ? { turnConstraints: spec.turnConstraints } : {},
     ...spec.skillPaths !== void 0 ? { skillPaths: [...spec.skillPaths] } : {},
     ...spec.agentSkills !== void 0 ? { agentSkills: [...spec.agentSkills] } : {},
     ...spec.trustProjectCompatRoots !== void 0 ? { trustProjectCompatRoots: spec.trustProjectCompatRoots } : {},
@@ -2231,6 +2270,7 @@ async function main() {
     } : {},
     ...spec.responseSchema !== void 0 ? { responseSchema: spec.responseSchema } : {},
     ...spec.resultContract !== void 0 ? { resultContract: spec.resultContract } : {},
+    ...spec.helperResult === true ? { helperResult: true } : {},
     ...spec.product !== void 0 ? { product: spec.product } : {},
     agentLedger: ledgerPort,
     cwd: process.cwd()