@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/{chunk-TB5666IT.js → chunk-JDG2WCRO.js}

@@ -1,11 +1,11 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   verifyTool
-} from "./chunk-GU2UIAFZ.js";
+} from "./chunk-3URVFKWK.js";
 import {
   discoverDeclaredChecksAtRoot,
   discoverDeclaredProjectEntriesAtRoot
-} from "./chunk-VAWNZU7Z.js";
+} from "./chunk-YDFRH54B.js";
 import {
   parseTomlDocument,
   tomlTableAt
@@ -16,14 +16,14 @@ import {
   PROJECT_VERIFIER_CATALOG_VERSION,
   compareCodepoints,
   parseProjectVerifierCatalogText
-} from "./chunk-A2NJGIB3.js";
+} from "./chunk-5LXZXPKX.js";
 import {
   isVerificationScriptName
 } from "./chunk-UL3WSD3F.js";
 import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   resolveSafeCwd
-} from "./chunk-B5CSFE7B.js";
+} from "./chunk-BBVJUZHB.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -960,4 +960,4 @@ export {
   previewVerifierDraft,
   runVerifierAuthoringWorkflow
 };
-//# sourceMappingURL=chunk-TB5666IT.js.map
+//# sourceMappingURL=chunk-JDG2WCRO.js.map

package/dist/{chunk-N22QMJKY.js → chunk-K5C3NCBD.js}

@@ -1,18 +1,18 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   receiptResponseModelIdObservationLabel
-} from "./chunk-HLE42MG7.js";
+} from "./chunk-BUMFYQFY.js";
 import {
   adaptRunReceiptTrustStatus,
   formatTrustAxes,
   formatTrustSummary
-} from "./chunk-K4XHGFR5.js";
+} from "./chunk-B7OBL7PK.js";
 import {
   formatBudgetPolicy,
   formatBudgetReasons,
   formatBudgetRequest,
   formatEffectiveBudget
-} from "./chunk-A3WNZD3P.js";
+} from "./chunk-J4W7KFM7.js";
 import {
   mentionsWorkerToolCallCap
 } from "./chunk-4ZG3XFUR.js";
@@ -173,4 +173,4 @@ export {
   workerTextLabel,
   workerTextNonEvidenceNotices
 };
-//# sourceMappingURL=chunk-N22QMJKY.js.map
+//# sourceMappingURL=chunk-K5C3NCBD.js.map

package/dist/{chunk-CGKSTWHD.js → chunk-K6BSR66V.js}

@@ -27,6 +27,7 @@ var ToolNames = {
   Steer: "steer",
   Tasks: "tasks",
   Ledger: "ledger",
+  Panes: "panes",
   // RETRIEVE
   WebFetch: "web_fetch",
   // INTERACT
@@ -51,4 +52,4 @@ export {
   ToolNames,
   isBuiltinToolName
 };
-//# sourceMappingURL=chunk-CGKSTWHD.js.map
+//# sourceMappingURL=chunk-K6BSR66V.js.map

package/dist/{chunk-5C3AQNDW.js → chunk-KFZI4NIL.js}

@@ -568,6 +568,70 @@ init_esm_shims();
 
 // src/interactive/overlay-frame.ts
 init_esm_shims();
+
+// src/interactive/modal-marker.ts
+init_esm_shims();
+var MODAL_MARKER_BASE_TITLE = "clio";
+function formatModalMarkerTitle(stack) {
+  const top = stack.at(-1);
+  if (top === void 0) return MODAL_MARKER_BASE_TITLE;
+  const beneath = stack.length - 1;
+  return `${MODAL_MARKER_BASE_TITLE} [modal:${top}${beneath > 0 ? `+${beneath}` : ""}]`;
+}
+function createModalMarkerRegistry() {
+  const entries = [];
+  let sink = null;
+  let published = null;
+  function activeIds() {
+    return entries.filter((entry) => entry.active).map((entry) => entry.id);
+  }
+  function publish() {
+    if (sink === null) return;
+    const title = formatModalMarkerTitle(activeIds());
+    if (published === null && title === MODAL_MARKER_BASE_TITLE) return;
+    if (title === published) return;
+    published = title;
+    sink.setTitle(title);
+  }
+  function enter(id, nextSink) {
+    if (nextSink) sink = nextSink;
+    const entry = { id, active: true };
+    entries.push(entry);
+    publish();
+    let released = false;
+    return {
+      release() {
+        if (released) return;
+        released = true;
+        const index = entries.indexOf(entry);
+        if (index !== -1) entries.splice(index, 1);
+        publish();
+      },
+      setActive(active) {
+        if (released || entry.active === active) return;
+        entry.active = active;
+        publish();
+      },
+      raise() {
+        if (released) return;
+        entry.active = true;
+        const index = entries.indexOf(entry);
+        if (index !== -1 && index !== entries.length - 1) {
+          entries.splice(index, 1);
+          entries.push(entry);
+        }
+        publish();
+      }
+    };
+  }
+  return { enter, stack: () => activeIds() };
+}
+var registry = createModalMarkerRegistry();
+function enterModal(id, sink) {
+  return registry.enter(id, sink);
+}
+
+// src/interactive/overlay-frame.ts
 var DEFAULT_SELECT_THEME = selectListTheme(clioTheme());
 var DEFAULT_SETTINGS_THEME = settingsListTheme(clioTheme());
 var FocusBox = class extends Box {
@@ -800,10 +864,10 @@ var ClioOverlayFrame = class {
   }
 };
 function showClioOverlayFrame(tui, child, options) {
-  const { title, footerHint, tone, width, visible, maxHeight, margin, ...overlayOptions } = options;
+  const { title, footerHint, tone, width, visible, maxHeight, margin, markerId, ...overlayOptions } = options;
   const boxWidth = typeof width === "number" ? width : 0;
   const frame2 = new ClioOverlayFrame(child, title, footerHint, boxWidth, frameAlignForAnchor(options.anchor), tone);
-  return tui.showOverlay(frame2, {
+  const handle = tui.showOverlay(frame2, {
     ...overlayOptions,
     ...margin !== void 0 ? { margin } : {},
     width: "100%",
@@ -816,6 +880,32 @@ function showClioOverlayFrame(tui, child, options) {
       return shown;
     }
   });
+  const marker = enterModal(markerId, modalMarkerSink(tui));
+  return {
+    hide() {
+      marker.release();
+      handle.hide();
+    },
+    setHidden(hidden) {
+      marker.setActive(!hidden);
+      handle.setHidden(hidden);
+    },
+    isHidden: () => handle.isHidden(),
+    focus() {
+      marker.raise();
+      handle.focus();
+    },
+    // A pure passthrough on purpose. The engine hands focus to the next
+    // visible capturing overlay, which is another modal, so the stack is
+    // unchanged; the surface that gives the keyboard back to the composer
+    // does it by hiding, which `setHidden` already reports.
+    unfocus: (unfocusOptions) => unfocusOptions ? handle.unfocus(unfocusOptions) : handle.unfocus(),
+    isFocused: () => handle.isFocused()
+  };
+}
+function modalMarkerSink(tui) {
+  const terminal = tui.terminal;
+  return typeof terminal?.setTitle === "function" ? terminal : null;
 }
 function resolveRowSize(value, termHeight) {
   if (typeof value === "number") return Math.max(1, Math.floor(value));
@@ -827,9 +917,14 @@ function resolveRowSize(value, termHeight) {
 
 // src/interactive/permission-hint.ts
 init_esm_shims();
-function permissionHintEntries(composerHasDraft = false) {
+var MUTATION_PREVIEW_KEY = "v";
+function permissionHintEntries(composerHasDraft = false, inspection = "none") {
   return [
     composerHasDraft ? { key: "Backspace", verb: "clear the draft to allow", short: "clear draft", critical: true } : { key: "Enter", verb: "allow once", short: "allow", critical: true },
+    ...inspection === "none" ? [] : inspection === "open" ? [
+      { key: "\u2191\u2193", verb: "scroll", critical: false },
+      { key: MUTATION_PREVIEW_KEY, verb: "hide mutation", short: "hide", critical: false }
+    ] : [{ key: MUTATION_PREVIEW_KEY, verb: "inspect mutation", short: "inspect", critical: false }],
     { key: "s", verb: "stop turn", short: "stop", critical: true },
     // With a draft, deny and stop are the only immediate answers, so Esc
     // outranks the narrowing that would otherwise drop it first.
@@ -841,6 +936,8 @@ function permissionHintEntries(composerHasDraft = false) {
 var REVERSE_VIDEO_BLANK = `${String.fromCharCode(27)}[7m ${String.fromCharCode(27)}[0m`;
 var EMPTY_PROMPT = "Ask Clio\u2026  / for commands";
 var CONFIRM_PROMPT = "A parked call is waiting for your decision";
+var PREPARING_PROMPT = "Clio has your prompt and is preparing the turn";
+var COMPACTING_PROMPT = "Clio has your prompt and is compacting the context first";
 var MIN_HINT_WIDTH = 60;
 function hasScrollIndicator(line) {
   const stripped = stripTerminalSequences(line);
@@ -870,7 +967,12 @@ function styledRailLabel(theme, chrome) {
 }
 function composerMode(chrome, text) {
   if (chrome.isAwaitingApproval?.() ?? false) return "CONFIRM";
-  if (!(chrome.isStreaming?.() ?? false)) return "MESSAGE";
+  if (!(chrome.isStreaming?.() ?? false)) {
+    const preparation = chrome.getTurnPreparation?.() ?? "idle";
+    if (preparation === "compacting") return "COMPACTING";
+    if (preparation === "preparing") return "PREPARING";
+    return "MESSAGE";
+  }
   const willSteer = chrome.willEnterSteer?.(text) ?? text.trim().length > 0;
   return willSteer ? "STEER" : "FOLLOW-UP";
 }
@@ -880,14 +982,20 @@ function lowerRailHint(theme, chrome) {
     `${chrome.getSubmitKeyLabel?.() ?? "Enter"} send \xB7 ${chrome.getNewlineKeyLabel?.() ?? "Shift+Enter"} newline`
   );
 }
-function confirmRailHint(theme, width, hasDraft) {
-  return theme.fg("warning", fitHintEntries(permissionHintEntries(hasDraft), Math.max(1, width - 3)));
+function confirmRailHint(theme, width, hasDraft, inspection) {
+  return theme.fg("warning", fitHintEntries(permissionHintEntries(hasDraft, inspection), Math.max(1, width - 3)));
 }
 function modeToken(mode) {
-  if (mode === "STEER") return "action";
+  if (mode === "STEER" || mode === "PREPARING" || mode === "COMPACTING") return "action";
   if (mode === "CONFIRM") return "warning";
   return "accentDeep";
 }
+function emptyPromptFor(mode) {
+  if (mode === "CONFIRM") return CONFIRM_PROMPT;
+  if (mode === "PREPARING") return PREPARING_PROMPT;
+  if (mode === "COMPACTING") return COMPACTING_PROMPT;
+  return EMPTY_PROMPT;
+}
 function renderEmptyPrompt(line, width, theme, text = EMPTY_PROMPT) {
   const cursorAt = line.indexOf(REVERSE_VIDEO_BLANK);
   if (cursorAt < 0) return line;
@@ -931,12 +1039,12 @@ var ClioEditor = class extends Editor {
       });
     }
     if (text.length === 0 && lines[1]) {
-      lines[1] = renderEmptyPrompt(lines[1], safeWidth, theme, mode === "CONFIRM" ? CONFIRM_PROMPT : EMPTY_PROMPT);
+      lines[1] = renderEmptyPrompt(lines[1], safeWidth, theme, emptyPromptFor(mode));
     }
     const bottomRail = findBottomRail(lines, safeWidth);
     if (bottomRail >= 0 && mode === "CONFIRM") {
       lines[bottomRail] = rule(theme, safeWidth, {
-        right: confirmRailHint(theme, safeWidth, text.length > 0),
+        right: confirmRailHint(theme, safeWidth, text.length > 0, this.chrome.getPermissionInspection?.() ?? "none"),
         fillToken: "frameStrong",
         rightRaw: true,
         rightTail: theme.style("frameStrong", "\u2500", { bold: true })
@@ -977,10 +1085,49 @@ init_esm_shims();
 
 // src/interactive/render-trace.ts
 init_esm_shims();
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { appendFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
 var RENDER_TRACE_VERSION = 2;
+var INPUT_WEDGE_RING_CAPACITY = 256;
+var INPUT_WEDGE_DUMP_DIRNAME = "input-wedge";
+var INPUT_WEDGE_DUMP_RETAINED = 5;
+function createRing(capacity) {
+  const slots = [];
+  let next = 0;
+  return {
+    push(value) {
+      if (slots.length < capacity) slots.push(value);
+      else slots[next] = value;
+      next = (next + 1) % capacity;
+    },
+    toArray() {
+      if (slots.length < capacity) return [...slots];
+      return [...slots.slice(next), ...slots.slice(0, next)];
+    }
+  };
+}
+function classifyInputWedge(inputIngress, frames) {
+  const newest = [...inputIngress].reverse().find((record) => record.visualExpected) ?? inputIngress.at(-1);
+  if (newest === void 0) return "no-input-recorded";
+  return frames.some((frame2) => frame2.inputHighWater >= newest.inputSeq) ? "input-committed" : "input-not-committed";
+}
+function writeInputWedgeDump(stateDir, snapshot) {
+  const directory = join(stateDir, INPUT_WEDGE_DUMP_DIRNAME);
+  mkdirSync(directory, { recursive: true });
+  const stamp = new Date(snapshot.atEpochMs).toISOString().replace(/[:.]/gu, "-");
+  const path = join(directory, `${stamp}-${snapshot.pid}.json`);
+  writeFileSync(path, `${JSON.stringify(snapshot, null, 2)}
+`, "utf8");
+  try {
+    const existing = readdirSync(directory).filter((name) => name.endsWith(".json")).sort();
+    for (const name of existing.slice(0, Math.max(0, existing.length - INPUT_WEDGE_DUMP_RETAINED))) {
+      rmSync(join(directory, name), { force: true });
+    }
+  } catch {
+  }
+  return path;
+}
 function createAsyncTraceWriter(path, options = {}) {
   const maxRecords = options.maxRecords ?? 4096;
   const batchRecords = options.batchRecords ?? 128;
@@ -1073,11 +1220,16 @@ function renderTracePath(env = process.env) {
   return raw && raw.length > 0 ? raw : null;
 }
 function createRenderTrace(path, now = () => performance.now(), writerOptions = {}) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, "", "utf8");
+  if (path !== null) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, "", "utf8");
+  }
   const openedAt = now();
+  const openedAtEpochMs = Date.now();
   const at = () => rounded(now() - openedAt);
-  const writer = createAsyncTraceWriter(path, { ...writerOptions, recordTime: at });
+  const writer = path === null ? null : createAsyncTraceWriter(path, { ...writerOptions, recordTime: at });
+  const inputRing = createRing(INPUT_WEDGE_RING_CAPACITY);
+  const frameRing = createRing(INPUT_WEDGE_RING_CAPACITY);
   let frameSeq = 0;
   let writeSeq = 0;
   let eventSeq = 0;
@@ -1093,7 +1245,7 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
   let firstCommitDelivered = false;
   const ranges = /* @__PURE__ */ new Map();
   const pendingDrains = /* @__PURE__ */ new Map();
-  writer.enqueue({ type: "trace_start", version: RENDER_TRACE_VERSION, at: 0 });
+  writer?.enqueue({ type: "trace_start", version: RENDER_TRACE_VERSION, at: 0 });
   const trace = {
     recordPanelRender(metrics) {
       pendingPanel = metrics;
@@ -1104,12 +1256,13 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
     },
     recordVisibleEvent(fields) {
       eventSeq += 1;
+      if (writer === null) return eventSeq;
       const key = `${generation}:${fields.kind}:${fields.contentIndex}`;
       const previous = ranges.get(key) ?? { codeUnits: 0, graphemes: 0 };
       const graphemes = graphemeCount(fields.delta);
       const next = { codeUnits: previous.codeUnits + fields.delta.length, graphemes: previous.graphemes + graphemes };
       ranges.set(key, next);
-      writer.enqueue({
+      writer?.enqueue({
         type: "event_ingress",
         version: RENDER_TRACE_VERSION,
         eventSeq,
@@ -1127,7 +1280,7 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
     },
     recordQueue(sequence, action) {
       queueDepth = Math.max(0, queueDepth + (action === "admit" ? 1 : -1));
-      writer.enqueue({
+      writer?.enqueue({
         type: "queue",
         version: RENDER_TRACE_VERSION,
         eventSeq: sequence,
@@ -1138,7 +1291,7 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
     },
     recordPanelApplied(sequence) {
       panelHighWater = Math.max(panelHighWater, sequence);
-      writer.enqueue({
+      writer?.enqueue({
         type: "panel",
         version: RENDER_TRACE_VERSION,
         eventSeq: sequence,
@@ -1149,7 +1302,7 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
     recordInputIngress(action, bytes, visualExpected = action !== "no-visual-change") {
       inputSeq += 1;
       if (visualExpected) inputHighWater = inputSeq;
-      writer.enqueue({
+      const record = {
         type: "input_ingress",
         version: RENDER_TRACE_VERSION,
         inputSeq,
@@ -1157,7 +1310,9 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
         at: at(),
         bytes,
         visualExpected
-      });
+      };
+      inputRing.push(record);
+      writer?.enqueue(record);
       return inputSeq;
     },
     beginFrame(fields) {
@@ -1205,8 +1360,9 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
         },
         commits: frame2.commits
       };
-      writer.enqueue(record);
+      writer?.enqueue(record);
       if (frame2.commits.length > 0) {
+        frameRing.push(record);
         lastCommitAt = frame2.commits.at(-1)?.at ?? endAt;
         if (!firstCommitDelivered) {
           firstCommitDelivered = true;
@@ -1241,6 +1397,7 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
         backpressured: !fields.returned
       };
       currentFrame?.commits.push(commit);
+      if (writer === null) return writeSeq;
       writer.enqueue({ type: "terminal_write", version: RENDER_TRACE_VERSION, frameId, ...commit });
       if (!fields.returned) pendingDrains.set(writeSeq, { frameId, at: commit.at });
       return writeSeq;
@@ -1250,7 +1407,7 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
       if (!pending) return;
       pendingDrains.delete(writeId);
       const drainAt = at();
-      writer.enqueue({
+      writer?.enqueue({
         type: "terminal_drain",
         version: RENDER_TRACE_VERSION,
         writeId,
@@ -1263,7 +1420,28 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
     onFirstFrameCommit(listener) {
       firstCommitListener = listener;
     },
-    close: () => writer.close()
+    snapshotInputWedge() {
+      const inputIngress = inputRing.toArray();
+      const frames = frameRing.toArray();
+      const nowAt = at();
+      const lastIngressAt = inputIngress.at(-1)?.at;
+      const lastFrame = frames.at(-1);
+      const lastFrameCommitAt = lastFrame?.commits.at(-1)?.at ?? lastFrame?.endAt;
+      return {
+        version: RENDER_TRACE_VERSION,
+        capacity: INPUT_WEDGE_RING_CAPACITY,
+        pid: process.pid,
+        openedAtEpochMs,
+        atEpochMs: Date.now(),
+        at: nowAt,
+        classification: classifyInputWedge(inputIngress, frames),
+        msSinceLastInputIngress: lastIngressAt === void 0 ? null : rounded(nowAt - lastIngressAt),
+        msSinceLastCommittedFrame: lastFrameCommitAt === void 0 ? null : rounded(nowAt - lastFrameCommitAt),
+        inputIngress,
+        frames
+      };
+    },
+    close: () => writer?.close() ?? Promise.resolve()
   };
   return trace;
 }
@@ -1490,20 +1668,18 @@ function createProcessInteractiveShell(options = {}) {
   let restoreRoot = null;
   let backpressure = null;
   let observedBackpressure = false;
-  if (tracePath) {
-    let candidate = null;
-    try {
-      candidate = createRenderTrace(tracePath);
-      restoreStdout = traceProcessStdout(candidate);
-      activeRenderTrace = candidate;
-    } catch {
-      restoreStdout?.();
-      restoreStdout = null;
-      void candidate?.close().catch(() => {
-      });
-      activeRenderTrace = null;
-    }
-  } else activeRenderTrace = null;
+  let candidate = null;
+  try {
+    candidate = createRenderTrace(tracePath);
+    restoreStdout = traceProcessStdout(candidate);
+    activeRenderTrace = candidate;
+  } catch {
+    restoreStdout?.();
+    restoreStdout = null;
+    void candidate?.close().catch(() => {
+    });
+    activeRenderTrace = null;
+  }
   const trace = activeRenderTrace;
   if (trace && options.onFirstFrameCommit) trace.onFirstFrameCommit(options.onFirstFrameCommit);
   let firstFrameDelivered = false;
@@ -2187,8 +2363,10 @@ export {
   formatRuntimeResolutionDiagnostic,
   runtimeResolutionDiagnosticLine,
   showClioOverlayFrame,
+  MUTATION_PREVIEW_KEY,
   permissionHintEntries,
   ClioEditor,
+  writeInputWedgeDump,
   getActiveRenderTrace,
   createProcessInteractiveShell,
   validateKeybindings,
@@ -2198,4 +2376,4 @@ export {
   formatPlatformKeybindingNotice,
   createKeybindingManager
 };
-//# sourceMappingURL=chunk-5C3AQNDW.js.map
+//# sourceMappingURL=chunk-KFZI4NIL.js.map

package/dist/chunk-KMVISBZR.js

@@ -0,0 +1,132 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/eval/schema/suite.ts
+init_esm_shims();
+var EVAL_SUITE_V2_VERSION = 2;
+var CANONICAL_METRICS = [
+  "tokens.input",
+  "tokens.output",
+  "tokens.total",
+  "tokens.cacheRead",
+  "tokens.cacheWrite",
+  // False when the runner observed no provider usage at all. The counts above
+  // are absent in that case rather than zero, so a gate on cost can require
+  // measurement instead of reading silence as free.
+  "tokens.measured",
+  "latency.wallMs",
+  "latency.modelMs",
+  "tools.totalCalls",
+  "tools.failed",
+  "tools.blocked",
+  "tools.read.distinctPaths",
+  "tools.read.outsideAllowed",
+  "tools.read.decoyHits",
+  "tools.calls.dispatch",
+  "tools.blocked.bash",
+  "claims.unsupported",
+  "completion.reported",
+  "context.indexedFiles",
+  "context.coverage",
+  "context.structuralHash",
+  "context.digestTokens",
+  "context.clioMdBytes",
+  "context.initMode",
+  "context.initParserOutcome",
+  "context.initFallback",
+  "context.initPromptBytes",
+  "context.initOutputBytes",
+  "context.initTargetId",
+  "context.initModelId",
+  "context.initRuntimeId",
+  "context.initRuntimeKind",
+  "context.initThinkingLevel",
+  "context.initStructuredOutputMode",
+  "verifier.exitCode",
+  "patch.bytes",
+  "patch.filesChanged",
+  "patch.testFilesModified",
+  "result.pass",
+  "result.failureClass",
+  // Receipt-derived evidence metrics. Sourced only from the sealed receipt
+  // (never dispatch/monitor prose labels); absent receipt leaves them
+  // unresolved so gates fail closed.
+  "evidence.verification",
+  "evidence.firstPassSuccess",
+  "cost.usd",
+  // Invariant checks: what Clio promised about its own machinery, read from
+  // the journal the item's run left behind. These are true or false about
+  // Clio and say nothing about whether the model solved the task. A check
+  // the runner could not compute is absent, so a threshold on it fails
+  // closed rather than reading silence as compliance.
+  "receipt.count",
+  "receipt.rootCount",
+  "receipt.sealed",
+  "receipt.integrityValid",
+  "receipt.outcomeMatchesExit",
+  "ledger.formatVersion",
+  "ledger.toolPairsUnmatched",
+  "ledger.assistantBetweenCallAndResult",
+  "ledger.sessionCount",
+  "continuity.compactionSummaryPresent",
+  "continuity.answeredFromPreCompaction",
+  "continuity.turnsAfterCompaction",
+  "process.attestedWorkers",
+  "process.orphanedChildren",
+  // Write-boundary enforcement, read from the verdicts the run sealed. The
+  // promise is not that nothing escaped the allowlist; it is that Clio saw what
+  // did, named it, rolled back what git could restore, and left a signed record
+  // against the baseline it measured.
+  "boundary.verdictCount",
+  "boundary.verdictSealed",
+  "boundary.violationsDetected",
+  "boundary.violationsRolledBack",
+  "boundary.rollbackIncomplete",
+  // Bounded loops. The declared bound is the promise: attempts never exceed it,
+  // every attempt after the first seals its own recovery receipt, and a bound
+  // spent without a pass reports loop_bound_exhausted rather than a false green.
+  // `loop.resolved` is the model's result, measured beside them and never a gate.
+  "loop.count",
+  "loop.attemptsSpent",
+  "loop.repairsSpent",
+  "loop.resolved",
+  "loop.reasonExhausted",
+  // The terminal reason is one Clio declares and agrees with `resolved`. This
+  // is the promise that holds across every ending, including the ones that
+  // never spend the bound, so it is the one a suite can gate unconditionally.
+  "loop.reasonDeclared",
+  "loop.unneededNodes",
+  "loop.skippedNodes",
+  "loop.receiptsMatchRepairs",
+  "receipt.recoveryCount",
+  // Receipt-derived accounting. A different observation from `tokens.*` above,
+  // with a different provenance: what Clio sealed and authenticated, rather
+  // than what a provider was watched reporting on the runner's own stdout. A
+  // surface that publishes no usage stream (`clio-coder fleet run --json` drains its
+  // workers' events) still seals the cost, so this is how a bounded loop's cost
+  // is read. The two are never merged, and this family never enters
+  // `summary.tokens`. Counts appear only beside `measured: true`; an
+  // incomplete or unauthenticated receipt set reports false and no counts.
+  "receiptUsage.measured",
+  "receiptUsage.receiptCount",
+  "receiptUsage.totalTokens",
+  "receiptUsage.costUsd",
+  "stream.messageUpdateCount",
+  "stream.usageDoubleCounted",
+  "stream.segmentUsageMatchesMessages",
+  // The task outcome: whether the model solved the workload. Its exit code is
+  // recorded beside the machinery invariants so a failed final result can still
+  // say "the grader failed and Clio behaved" rather than conflating the two.
+  "task.exitCode",
+  "task.solved"
+];
+var CANONICAL_METRIC_PREFIXES = ["tools.calls.", "tools.blocked."];
+
+export {
+  EVAL_SUITE_V2_VERSION,
+  CANONICAL_METRICS,
+  CANONICAL_METRIC_PREFIXES
+};
+//# sourceMappingURL=chunk-KMVISBZR.js.map

package/dist/{chunk-WXY7KU3G.js → chunk-LDQ2ZF2M.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-ZGVHUX3M.js";
 import {
   BusChannels
-} from "./chunk-TT36MB5S.js";
+} from "./chunk-HLW2MRKE.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -226,4 +226,4 @@ export {
   runWithBudget,
   getTerminationCoordinator
 };
-//# sourceMappingURL=chunk-WXY7KU3G.js.map
+//# sourceMappingURL=chunk-LDQ2ZF2M.js.map

package/dist/{chunk-XN3L4EYL.js → chunk-LQ3DZAMX.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";
@@ -43,4 +43,4 @@ export {
   CODE_NAV_MAX_LIMIT,
   codeNavToolSurface
 };
-//# sourceMappingURL=chunk-XN3L4EYL.js.map
+//# sourceMappingURL=chunk-LQ3DZAMX.js.map