@iowarp/clio-coder 0.4.6 → 0.4.7

package/dist/{chunk-K2HL3GBL.js → chunk-T4TY5GG3.js}

@@ -2,10 +2,13 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   gateRouteCorrelation,
   isExecutionRole
-} from "./chunk-LY4N4TTL.js";
+} from "./chunk-3LXJOICS.js";
+import {
+  canonicalJson
+} from "./chunk-VQD7NH7Z.js";
 import {
   isAgentCapabilityClass
-} from "./chunk-OQM5IVJY.js";
+} from "./chunk-34XHRVKG.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -188,6 +191,146 @@ function explainRouteDecision(decision, intent) {
   };
 }
 
+// src/worker/context-seed.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+var WORKER_CONTEXT_MAX_BYTES = 512 * 1024;
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseWorkerContextProvenance(value) {
+  const fail = () => {
+    throw new Error("worker context: malformed provenance");
+  };
+  if (!record2(value)) return fail();
+  const p = value;
+  const fields = [
+    "version",
+    "mode",
+    "source",
+    "snapshotHash",
+    "contentHash",
+    "messageCount",
+    "estimatedTokens",
+    "bytes",
+    "omittedMessages",
+    "excludedTailMessages",
+    "excludedInterruptedMessages",
+    "selectedRefs"
+  ];
+  if (Object.keys(p).some((key) => !fields.includes(key))) fail();
+  if (p.version !== 1 || p.mode !== "fork" && p.mode !== "splice" || !record2(p.source)) fail();
+  const source = p.source;
+  if (Object.keys(source).some((key) => !["sessionId", "leafTurnId", "cwd"].includes(key))) fail();
+  if (typeof source.sessionId !== "string" || !source.sessionId || typeof source.cwd !== "string" || !source.cwd || source.leafTurnId !== null && typeof source.leafTurnId !== "string")
+    fail();
+  for (const key of ["snapshotHash", "contentHash"])
+    if (typeof p[key] !== "string" || !/^[a-f0-9]{64}$/u.test(p[key])) fail();
+  for (const key of [
+    "messageCount",
+    "estimatedTokens",
+    "bytes",
+    "omittedMessages",
+    "excludedTailMessages",
+    "excludedInterruptedMessages"
+  ])
+    if (!Number.isSafeInteger(p[key]) || p[key] < 0) fail();
+  if (!Array.isArray(p.selectedRefs) || p.selectedRefs.some((ref) => typeof ref !== "string" || !/^(tool:.+|message:[0-9]+)$/u.test(ref)) || new Set(p.selectedRefs).size !== p.selectedRefs.length)
+    fail();
+  return structuredClone(p);
+}
+function parseWorkerContextSeed(value) {
+  const fail = () => {
+    throw new Error("worker context: malformed or digest-mismatched seed");
+  };
+  if (Buffer.byteLength(JSON.stringify(value) ?? "", "utf8") > WORKER_CONTEXT_MAX_BYTES) fail();
+  if (!record2(value) || !record2(value.provenance) || !Array.isArray(value.messages)) return fail();
+  const p = parseWorkerContextProvenance(value.provenance);
+  for (const message of value.messages) {
+    if (!record2(message) || !["user", "assistant", "toolResult"].includes(String(message.role)) || !Number.isFinite(message.timestamp))
+      fail();
+    if (message.role === "user" && typeof message.content === "string") continue;
+    if (!Array.isArray(message.content)) return fail();
+    for (const block of message.content) {
+      if (!record2(block)) return fail();
+      switch (block.type) {
+        case "text":
+          if (typeof block.text !== "string") fail();
+          break;
+        case "thinking":
+          if (message.role !== "assistant" || typeof block.thinking !== "string") fail();
+          break;
+        case "image":
+          if (message.role === "assistant" || typeof block.data !== "string" || typeof block.mimeType !== "string") fail();
+          break;
+        case "toolCall":
+          if (message.role !== "assistant" || typeof block.id !== "string" || typeof block.name !== "string" || !record2(block.arguments))
+            fail();
+          break;
+        default:
+          fail();
+      }
+    }
+    if (message.role === "toolResult" && (typeof message.toolCallId !== "string" || typeof message.toolName !== "string" || typeof message.isError !== "boolean"))
+      fail();
+    if (message.role === "assistant") {
+      if (!["stop", "length", "toolUse"].includes(String(message.stopReason))) fail();
+      if (message.api !== void 0 && typeof message.api !== "string" || message.provider !== void 0 && typeof message.provider !== "string" || message.model !== void 0 && typeof message.model !== "string" || message.usage !== void 0 && !record2(message.usage))
+        return fail();
+      if (record2(message.usage)) {
+        for (const field of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"])
+          if (message.usage[field] !== void 0 && (typeof message.usage[field] !== "number" || !Number.isFinite(message.usage[field]) || message.usage[field] < 0))
+            fail();
+      }
+    }
+  }
+  const seed = value;
+  completeHistoryLength(seed.messages);
+  if (p.mode === "splice" && (seed.messages.length !== 1 || seed.messages[0]?.role !== "user")) fail();
+  const { contentHash: digest, ...identity } = seed.provenance;
+  if (contextHash({ ...identity, messages: seed.messages }) !== digest || p.messageCount !== seed.messages.length || p.bytes !== Buffer.byteLength(JSON.stringify(seed.messages), "utf8"))
+    fail();
+  return structuredClone(seed);
+}
+function seededWorkerMessages(seed) {
+  if (seed === void 0) return [];
+  const parsed = parseWorkerContextSeed(seed);
+  return parsed.provenance.mode === "fork" ? parsed.messages : [];
+}
+function contextHash(value) {
+  return createHash("sha256").update(`clio-coder.worker-context:1:${canonicalJson(value)}`).digest("hex");
+}
+function messageToolCalls(message) {
+  if (message.role !== "assistant") return [];
+  return message.content.filter((block) => block.type === "toolCall");
+}
+function completeHistoryLength(messages, allowPendingTail = false) {
+  let batchStart = -1;
+  const pending = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, message] of messages.entries()) {
+    if (message.role === "toolResult") {
+      if (!pending.delete(message.toolCallId)) throw new Error("worker context: orphaned or duplicate tool result");
+      continue;
+    }
+    if (pending.size > 0) throw new Error("worker context: incomplete historical tool batch");
+    if (message.role !== "user" && message.role !== "assistant")
+      throw new Error("worker context: unsupported message role");
+    if (message.role === "assistant" && (message.stopReason === "error" || message.stopReason === "aborted"))
+      throw new Error("worker context: interrupted assistant message cannot seed a worker");
+    const calls = messageToolCalls(message);
+    if (calls.length > 0) batchStart = index;
+    for (const call of calls) {
+      if (!call.id || seen.has(call.id)) throw new Error("worker context: duplicate or empty tool call id");
+      seen.add(call.id);
+      pending.add(call.id);
+    }
+  }
+  if (pending.size === 0) return messages.length;
+  if (allowPendingTail) return batchStart;
+  throw new Error("worker context: seed contains an unfinished tool batch");
+}
+
 // src/domains/dispatch/route-policy.ts
 init_esm_shims();
 var ROUTE_POLICY_VERSION = "route-policy/4";
@@ -235,15 +378,15 @@ var LATENCY_CLASS_ROUTE_PRIORS = {
 function routePriorForLatencyClass(latencyClass) {
   return { ...LATENCY_CLASS_ROUTE_PRIORS[latencyClass] };
 }
-function routeObservationFromHistory(record2) {
+function routeObservationFromHistory(record3) {
   return {
-    qualityLabel: record2.qualityLabel,
-    reliability: record2.reliability,
-    firstPass: record2.firstPass,
-    completedCostUsd: record2.completedCostUsd,
-    completedEndToEndMs: record2.completedPhaseTiming?.totalEndToEndMs ?? null,
-    cacheRead: record2.cacheRead,
-    queueWaitMs: record2.completedPhaseTiming?.queueWaitMs ?? null
+    qualityLabel: record3.qualityLabel,
+    reliability: record3.reliability,
+    firstPass: record3.firstPass,
+    completedCostUsd: record3.completedCostUsd,
+    completedEndToEndMs: record3.completedPhaseTiming?.totalEndToEndMs ?? null,
+    cacheRead: record3.cacheRead,
+    queueWaitMs: record3.completedPhaseTiming?.queueWaitMs ?? null
   };
 }
 var ROUTE_ESTIMATE_SHRINKAGE = 5;
@@ -389,7 +532,7 @@ function compareRankedRoutes(left, right) {
 
 // src/domains/dispatch/route-decision.ts
 init_esm_shims();
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 
 // src/domains/dispatch/route-readiness.ts
 init_esm_shims();
@@ -590,8 +733,8 @@ function sameRouteIdentity(left, right) {
   return routeCandidateKey(left) === routeCandidateKey(right);
 }
 function promptCompositionIdentity(identity, role) {
-  const persona = role.personaPrompt !== void 0 ? createHash("sha256").update(role.personaPrompt, "utf8").digest("hex") : null;
-  return createHash("sha256").update(
+  const persona = role.personaPrompt !== void 0 ? createHash2("sha256").update(role.personaPrompt, "utf8").digest("hex") : null;
+  return createHash2("sha256").update(
     JSON.stringify({
       specFingerprint: identity.specFingerprint,
       toolSignature: identity.toolSignature,
@@ -686,7 +829,7 @@ function routeDecisionHash(input) {
     input.independenceSubject.runtimeId,
     input.independenceSubject.nodeId
   ];
-  return createHash("sha256").update(
+  return createHash2("sha256").update(
     JSON.stringify([
       ROUTE_POLICY_VERSION,
       input.mode,
@@ -973,6 +1116,13 @@ function evaluateRouteDecision(decision, realized) {
 }
 
 export {
+  WORKER_CONTEXT_MAX_BYTES,
+  parseWorkerContextProvenance,
+  parseWorkerContextSeed,
+  seededWorkerMessages,
+  contextHash,
+  messageToolCalls,
+  completeHistoryLength,
   ROUTE_POLICY_VERSION,
   routePriorForLatencyClass,
   routeObservationFromHistory,
@@ -995,4 +1145,4 @@ export {
   routingIntentRejection,
   explainRouteDecision
 };
-//# sourceMappingURL=chunk-K2HL3GBL.js.map
+//# sourceMappingURL=chunk-T4TY5GG3.js.map