@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/chunk-TVHHYFHE.js

@@ -0,0 +1,255 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/safety/call-target.ts
+init_esm_shims();
+
+// src/domains/safety/redaction.ts
+init_esm_shims();
+function isPlainObject(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 (!isPlainObject(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 (!isPlainObject(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();
+}
+var DISPLAY_TAB_WIDTH = 4;
+var CONTROL_BYTE_PLACEHOLDER = "\xB7";
+function sanitizeMultilineDisplayText(value) {
+  const escapesStripped = value.replace(OSC_PATTERN, "").replace(CSI_PATTERN, "");
+  let neutralized = escapesStripped.length !== value.length;
+  const stripped = escapesStripped.replace(/\r\n/g, "\n");
+  let tabsExpanded = false;
+  let out = "";
+  for (const ch of stripped) {
+    if (ch === "\n") {
+      out += ch;
+      continue;
+    }
+    if (ch === "	") {
+      out += " ".repeat(DISPLAY_TAB_WIDTH);
+      tabsExpanded = true;
+      continue;
+    }
+    const code = ch.codePointAt(0) ?? 0;
+    if (code < 32 || code === 127) {
+      out += CONTROL_BYTE_PLACEHOLDER;
+      neutralized = true;
+      continue;
+    }
+    out += ch;
+  }
+  return { text: out, neutralized, tabsExpanded };
+}
+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);
+}
+
+export {
+  redactSecretString,
+  redactToolArgs,
+  sanitizeMultilineDisplayText,
+  sanitizeCallTargetText,
+  describeCallAction,
+  describeCallTarget
+};
+//# sourceMappingURL=chunk-TVHHYFHE.js.map

package/dist/{chunk-FJ3H4MN5.js → chunk-TZ3SGWZZ.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-5B2AEOW5.js";
 import {
   ToolNames
-} from "./chunk-CGKSTWHD.js";
+} from "./chunk-K6BSR66V.js";
 import {
   StringEnum
-} from "./chunk-FCSXB6T2.js";
+} from "./chunk-UOSL25KY.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -45,4 +45,4 @@ var monitorToolSurface = {
 export {
   monitorToolSurface
 };
-//# sourceMappingURL=chunk-FJ3H4MN5.js.map
+//# sourceMappingURL=chunk-TZ3SGWZZ.js.map

package/dist/{chunk-MXKJU4JB.js → chunk-U77AMWDL.js}

@@ -4,17 +4,17 @@ import {
   normalizeWriteBoundary,
   normalizeWriteBoundaryEntry,
   writeBoundaryCovers
-} from "./chunk-E77JEWSD.js";
+} from "./chunk-CTJ4RNAA.js";
 import {
   asDirectoryPathBoundary,
   pathBoundaryEntryCovers
-} from "./chunk-TTHACPOM.js";
+} from "./chunk-HHV2GANA.js";
 import {
   atomicWrite
-} from "./chunk-3BINW3FP.js";
+} from "./chunk-76ONBSIA.js";
 import {
   clioStateDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -542,6 +542,39 @@ function createCandidateWorktree(ownership, index, baseline) {
   git2(ownership.root, ["worktree", "add", "-b", branch, path, baseline]);
   return { index, branch, path };
 }
+async function createCandidateWorktreeMapped(ownership, index, baseline, mux) {
+  assertOwnership2(ownership);
+  const branch = competeBranch(ownership.group, index);
+  const path = join2(ownership.directory, `candidate-${index}`);
+  if (!isCanonicalPathInside(ownership.directory, path)) {
+    throw new Error(`candidate ${index} path escapes compete group ${ownership.group}`);
+  }
+  let fallback = "mux-unavailable";
+  if (mux?.available()) {
+    const created = await mux.worktreeCreate({
+      cwd: ownership.root,
+      branch,
+      base: baseline,
+      path,
+      label: `clio compete ${ownership.group} candidate ${index}`,
+      focus: false
+    }).catch(() => null);
+    if (created !== null) {
+      if (resolve2(created.worktree.path) !== resolve2(path) || created.worktree.branch !== branch) {
+        throw new Error(`herdr created candidate ${index} at an unexpected path or branch`);
+      }
+      return {
+        index,
+        branch,
+        path,
+        provenance: { backend: "herdr", path, branch, workspaceId: created.workspaceId }
+      };
+    }
+    fallback = "mux-operation-failed";
+  }
+  const native = createCandidateWorktree(ownership, index, baseline);
+  return { ...native, provenance: { backend: "native", path, branch, fallback } };
+}
 function commitCandidateWork(worktree, message) {
   return commitWorktreePath(worktree.path, COMPETE_COMMIT_IDENTITY, message);
 }
@@ -588,6 +621,13 @@ function removeCandidateWorktree(ownership, worktree, deleteBranch) {
     throw new Error(`failed to remove candidate ${worktree.index} from compete group ${ownership.group}`);
   }
 }
+async function removeCandidateWorktreeMapped(ownership, worktree, deleteBranch, mux) {
+  const workspaceId = worktree.provenance?.backend === "herdr" ? worktree.provenance.workspaceId : void 0;
+  if (workspaceId && mux?.available()) {
+    await mux.worktreeRemove(workspaceId, { force: true }).catch(() => false);
+  }
+  removeCandidateWorktree(ownership, worktree, deleteBranch);
+}
 function mergeWinnerBranch(root, branch) {
   return mergeWorktreeBranch(root, branch, COMPETE_COMMIT_IDENTITY);
 }
@@ -839,6 +879,20 @@ function diffWorkspace(snapshot) {
   }
   return changes;
 }
+function describeWriteBoundaryAttributionDowngrade(downgrade) {
+  if (downgrade.reason === "opaque_tool_succeeded") {
+    const tool = downgrade.tool ?? "unknown";
+    const call = downgrade.toolCallId === null ? "" : ` (call ${downgrade.toolCallId})`;
+    return `a successful '${tool}' call${call} can write paths its arguments do not name`;
+  }
+  if (downgrade.reason === "incomplete_tool_telemetry") {
+    return downgrade.runId === null ? "tool telemetry was incomplete" : `run '${downgrade.runId}' reported incomplete tool telemetry`;
+  }
+  if (downgrade.reason === "code_step_untracked") {
+    return downgrade.stepId === null ? "a code step ran through the untracked command runner" : `code step '${downgrade.stepId}' ran through the untracked command runner`;
+  }
+  return downgrade.stepId === null ? "no usable write record was available" : `step '${downgrade.stepId}' supplied no usable write record`;
+}
 function canonicalVerdict(verdict) {
   return JSON.stringify(verdict);
 }
@@ -893,6 +947,15 @@ function enforceWriteBoundary(input) {
   const changes = diffWorkspace(input.snapshot);
   const outside = changes.filter((change) => !writeBoundaryCovers(allow, change.path));
   const attributionComplete = input.attribution?.complete === true;
+  const attributionDowngrades = attributionComplete ? [] : input.attribution?.downgrades !== void 0 && input.attribution.downgrades.length > 0 ? input.attribution.downgrades.map((entry) => ({ ...entry })) : [
+    {
+      reason: "write_record_unavailable",
+      tool: null,
+      toolCallId: null,
+      runId: null,
+      stepId: input.stepIds.length === 1 ? input.stepIds[0] ?? null : null
+    }
+  ];
   const recorded = /* @__PURE__ */ new Set();
   for (const target of input.attribution?.recorded ?? []) {
     const relativeTarget = repoRelative(input.snapshot.root, target);
@@ -914,7 +977,7 @@ function enforceWriteBoundary(input) {
     `Unauthorized paths: ${violations.map((change) => change.path).join(", ")}.`,
     `Declared writes: ${describeWriteBoundary(allow)}.`,
     status === "rolled-back" ? "Those paths were rolled back to the baseline commit." : `Rollback is incomplete; the working tree is left as the step made it. Unrestorable: ${unrecoverable.map((entry) => `${entry.path} (${entry.reason})`).join("; ")}.`,
-    attributionComplete ? "Each was blamed on this window because a run in it recorded writing that path." : "This window had no complete write record, so every change outside the declaration was blamed on it.",
+    attributionComplete ? "Each was blamed on this window because a run in it recorded writing that path." : `Attribution was incomplete because ${attributionDowngrades.map(describeWriteBoundaryAttributionDowngrade).join("; ")}, so every change outside the declaration was blamed on this window.`,
     "If the change was legitimate, widen the step's `writes:` declaration to cover it."
   ];
   const concurrentDetail = unattributed.length === 0 ? [] : [
@@ -934,6 +997,7 @@ function enforceWriteBoundary(input) {
     violations: violations.map((change) => change.path),
     unattributed: unattributed.map((change) => change.path),
     attributionComplete,
+    attributionDowngrades,
     rolledBack,
     unrecoverable,
     status,
@@ -1024,16 +1088,32 @@ function createWriteBoundaryEnforcer(input) {
     const recordedWritesFor = input.recordedWritesFor;
     if (recordedWritesFor === void 0) return void 0;
     const recorded = /* @__PURE__ */ new Set();
+    const downgrades = [];
     let complete = true;
     for (const stepId of stepIds) {
       const observed = recordedWritesFor(stepId);
       if (observed === null) {
         complete = false;
+        downgrades.push({
+          reason: "write_record_unavailable",
+          tool: null,
+          toolCallId: null,
+          runId: null,
+          stepId
+        });
         continue;
       }
-      for (const target of observed) recorded.add(target);
+      if (!("recorded" in observed)) {
+        for (const target of observed) recorded.add(target);
+        continue;
+      }
+      for (const target of observed.recorded) recorded.add(target);
+      if (!observed.complete) complete = false;
+      for (const downgrade of observed.downgrades ?? []) {
+        downgrades.push({ ...downgrade, stepId: downgrade.stepId ?? stepId });
+      }
     }
-    return { recorded: [...recorded].sort(), complete };
+    return { recorded: [...recorded].sort(), complete, downgrades };
   };
   return {
     begin(window, stepIds) {
@@ -1083,18 +1163,19 @@ export {
   settleCompeteGroupRun,
   markCompeteGroupCleanupReady,
   markCompeteGroupWinnerPreserved,
-  createCandidateWorktree,
+  createCandidateWorktreeMapped,
   commitCandidateWork,
   candidateDiffStat,
   protectedPathsChangedByCompeteBranch,
-  removeCandidateWorktree,
+  removeCandidateWorktreeMapped,
   mergeWinnerBranch,
   cleanupCompeteGroup,
   settleRecoveredCompeteDecision,
   recoverCleanupReadyCompeteGroups,
   WRITE_BOUNDARY_VIOLATION_REASON,
   captureWorkspaceSnapshot,
+  describeWriteBoundaryAttributionDowngrade,
   preflightWriteBoundaries,
   createWriteBoundaryEnforcer
 };
-//# sourceMappingURL=chunk-MXKJU4JB.js.map
+//# sourceMappingURL=chunk-U77AMWDL.js.map

package/dist/{chunk-5DHKRSMQ.js → chunk-ULC6OTWO.js}

@@ -1,25 +1,29 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  loadFragments,
   loadOperatorProfile,
   loadProjectRules,
   renderOperatorProfile,
   selectActiveRules
-} from "./chunk-WSB3FPX7.js";
+} from "./chunk-I5VEOC6I.js";
+import {
+  loadFragments
+} from "./chunk-VAZSBTKF.js";
 import {
   compile,
-  compileWorker,
+  compileWorker
+} from "./chunk-BUMFYQFY.js";
+import {
   sha256
-} from "./chunk-TLQJPP24.js";
+} from "./chunk-B7OBL7PK.js";
 import {
   classifyProjectPreload
 } from "./chunk-JVCV3ICN.js";
 import {
   isUserVisibleAgent
-} from "./chunk-AOCYTWAV.js";
+} from "./chunk-DYJP44XW.js";
 import {
   BusChannels
-} from "./chunk-TT36MB5S.js";
+} from "./chunk-HLW2MRKE.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -655,4 +659,4 @@ export {
   createPromptsDomainModule,
   SchedulingDomainModule
 };
-//# sourceMappingURL=chunk-5DHKRSMQ.js.map
+//# sourceMappingURL=chunk-ULC6OTWO.js.map

package/dist/{chunk-RWSI4YD7.js → chunk-UM7N4G5A.js}

@@ -2,7 +2,7 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   cwdHash,
   sessionPaths
-} from "./chunk-3BINW3FP.js";
+} from "./chunk-76ONBSIA.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -170,14 +170,6 @@ function buildContextLedger(input) {
     });
   }
   const meter = [...groups];
-  if (reserveTokens > 0) {
-    meter.push({
-      category: "reserve",
-      label: CONTEXT_CATEGORY_LABEL.reserve,
-      tokens: reserveTokens,
-      percent: percentOf(reserveTokens, window)
-    });
-  }
   if (window > 0) {
     meter.push({
       category: "free",
@@ -186,6 +178,14 @@ function buildContextLedger(input) {
       percent: percentOf(freeTokens, window)
     });
   }
+  if (reserveTokens > 0) {
+    meter.push({
+      category: "reserve",
+      label: CONTEXT_CATEGORY_LABEL.reserve,
+      tokens: reserveTokens,
+      percent: percentOf(reserveTokens, window)
+    });
+  }
   return {
     provider: input.provider ?? null,
     model: input.model ?? null,
@@ -205,7 +205,8 @@ function buildContextLedger(input) {
     groups,
     meter,
     lastCompaction: input.lastCompaction ?? null,
-    promptCache: input.promptCache ?? null
+    promptCache: input.promptCache ?? null,
+    prewarm: input.prewarm ?? null
   };
 }
 
@@ -405,6 +406,17 @@ function getLatestContextSnapshot(meta) {
   const list = getContextSnapshots(meta);
   return list.at(-1) ?? null;
 }
+function lastLoadedContextWindow(meta, providerId, modelId) {
+  const snapshots = getContextSnapshots(meta);
+  for (let i = snapshots.length - 1; i >= 0; i -= 1) {
+    const snapshot = snapshots[i];
+    if (snapshot?.contextWindowSource !== "loaded") continue;
+    if (snapshot.providerId !== providerId || snapshot.modelId !== modelId) continue;
+    const window = snapshot.effectiveContextWindow;
+    if (typeof window === "number" && Number.isFinite(window) && window > 0) return window;
+  }
+  return null;
+}
 function buildSnapshotCategories(inputs) {
   const raw = {
     system: 0,
@@ -477,6 +489,7 @@ function captureContextSnapshot(input) {
     compactionThreshold: input.compactionThreshold
   });
   return {
+    estimatedTokens: sumSplitTokens(categories),
     snapshotId: nextSnapshotId(),
     sessionId: input.sessionId,
     turnId: input.turnId,
@@ -499,8 +512,11 @@ function captureContextSnapshot(input) {
     messageRange: input.conversationMessages.length > 0 ? { start: 0, end: input.conversationMessages.length - 1 } : void 0
   };
 }
+function sumSplitTokens(categories) {
+  return SNAPSHOT_SPLIT_KEYS.reduce((sum, key) => sum + (categories[key] ?? 0), 0);
+}
 function snapshotInputTokens(snapshot) {
-  return SNAPSHOT_SPLIT_KEYS.reduce((sum, key) => sum + (snapshot.categories[key] ?? 0), 0);
+  return sumSplitTokens(snapshot.categories);
 }
 function reconcileSnapshot(snapshot, usage) {
   const exactInput = (usage.input || 0) + (usage.cacheRead || 0) + (usage.cacheWrite || 0);
@@ -580,9 +596,13 @@ function reconcileSnapshot(snapshot, usage) {
     },
     {}
   );
+  const estimatedTokens = snapshot.estimatedTokens ?? sumSplitTokens(snapshot.categories);
   return {
     ...snapshot,
     categories: updatedCategories,
+    estimatedTokens,
+    reconciledTokens: exactInput,
+    divergenceRatio: estimatedTokens > 0 ? Math.round(exactInput / estimatedTokens * 1e3) / 1e3 : void 0,
     sources: {
       total: "reconciled",
       splits: splitsSources
@@ -606,8 +626,9 @@ export {
   contextUsageSnapshot,
   appendContextSnapshot,
   getLatestContextSnapshot,
+  lastLoadedContextWindow,
   captureContextSnapshot,
   snapshotInputTokens,
   reconcileSnapshot
 };
-//# sourceMappingURL=chunk-RWSI4YD7.js.map
+//# sourceMappingURL=chunk-UM7N4G5A.js.map

package/dist/{chunk-FCSXB6T2.js → chunk-UOSL25KY.js}

@@ -210,6 +210,7 @@ registerEngineBuiltins();
 
 // src/engine/ai.ts
 var stream = engineStream;
+var streamSimple = engineStreamSimple;
 async function completeEngineText(input) {
   const response = await completeEngineSimple(
     input.model,
@@ -231,7 +232,17 @@ async function completeEngineText(input) {
   return {
     text: response.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
     inputTokens: response.usage.input,
-    outputTokens: response.usage.output
+    outputTokens: response.usage.output,
+    usage: {
+      input: response.usage.input,
+      output: response.usage.output,
+      cacheRead: response.usage.cacheRead,
+      cacheWrite: response.usage.cacheWrite,
+      reasoning: response.usage.reasoning ?? 0,
+      totalTokens: response.usage.totalTokens,
+      costUsd: response.usage.cost.total
+    },
+    backend: response.backendTimings ?? null
   };
 }
 var registered = false;
@@ -325,6 +336,7 @@ export {
   activateExternalPluginApiBridge,
   StringEnum,
   stream,
+  streamSimple,
   completeEngineText,
   ensurePiAiRegistered,
   createEngineAi,
@@ -335,4 +347,4 @@ export {
   calculateEngineCost,
   registerFauxFromEnv
 };
-//# sourceMappingURL=chunk-FCSXB6T2.js.map
+//# sourceMappingURL=chunk-UOSL25KY.js.map