@iowarp/clio-coder 0.3.7 → 0.3.9

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

@@ -827,9 +827,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 +846,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 +877,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 +892,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 +949,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 +995,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 +1130,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 +1155,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 +1166,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 +1190,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 +1201,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 +1212,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 +1220,9 @@ function createRenderTrace(path, now = () => performance.now(), writerOptions =
         at: at(),
         bytes,
         visualExpected
-      });
+      };
+      inputRing.push(record);
+      writer?.enqueue(record);
       return inputSeq;
     },
     beginFrame(fields) {
@@ -1205,8 +1270,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 +1307,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 +1317,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 +1330,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 +1578,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 +2273,10 @@ export {
   formatRuntimeResolutionDiagnostic,
   runtimeResolutionDiagnosticLine,
   showClioOverlayFrame,
+  MUTATION_PREVIEW_KEY,
   permissionHintEntries,
   ClioEditor,
+  writeInputWedgeDump,
   getActiveRenderTrace,
   createProcessInteractiveShell,
   validateKeybindings,
@@ -2198,4 +2286,4 @@ export {
   formatPlatformKeybindingNotice,
   createKeybindingManager
 };
-//# sourceMappingURL=chunk-5C3AQNDW.js.map
+//# sourceMappingURL=chunk-NNNWO6F2.js.map

package/dist/{chunk-UFQ3F4FW.js → chunk-NQ6UCCOD.js}

@@ -4,14 +4,14 @@ import {
   listChecks,
   runProjectCheck,
   runScriptCheck
-} from "./chunk-PD3MESLB.js";
+} from "./chunk-P3JGPQFL.js";
 import {
   BROWSER_MODES,
   maxOutputArg,
   prepareVerifyArguments,
   timeoutArg,
   verifyToolSurface
-} from "./chunk-JNXPYBB4.js";
+} from "./chunk-CA42X6KT.js";
 import {
   escapeRegExp
 } from "./chunk-VG7TBQIY.js";
@@ -28,7 +28,7 @@ import {
 import {
   combineSafeOutput,
   runCommandVector
-} from "./chunk-D4MDIG46.js";
+} from "./chunk-B5CSFE7B.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -633,4 +633,4 @@ var verifyTool = {
 export {
   verifyTool
 };
-//# sourceMappingURL=chunk-UFQ3F4FW.js.map
+//# sourceMappingURL=chunk-NQ6UCCOD.js.map

package/dist/chunk-NUGM5KR6.js

@@ -0,0 +1,165 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/providers/registry.ts
+init_esm_shims();
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+var RUNTIME_KINDS = ["http", "sdk", "subprocess"];
+var RUNTIME_AUTHS = ["api-key", "oauth", "aws-sdk", "vertex-adc", "claude-cli", "none"];
+function createRuntimeRegistry() {
+  const byId = /* @__PURE__ */ new Map();
+  const canonical = /* @__PURE__ */ new Set();
+  const register = (desc) => {
+    const ids = [desc.id, ...desc.aliases ?? []];
+    const conflict = ids.find((id) => byId.has(id));
+    if (conflict) {
+      throw new Error(`runtime id '${conflict}' already registered`);
+    }
+    for (const id of ids) byId.set(id, desc);
+    canonical.add(desc.id);
+  };
+  const get = (id) => byId.get(id) ?? null;
+  const list = () => Array.from(canonical, (id) => byId.get(id)).filter((entry) => entry !== void 0);
+  const clear = () => {
+    byId.clear();
+    canonical.clear();
+  };
+  const loadFromDir = async (dir, beforeImport) => {
+    let entries;
+    try {
+      const stat = statSync(dir);
+      if (!stat.isDirectory()) return [];
+      entries = readdirSync(dir);
+    } catch {
+      return [];
+    }
+    const loaded = [];
+    for (const name of entries) {
+      if (!name.endsWith(".js")) continue;
+      const full = join(dir, name);
+      const desc = await importDescriptor(full, pathToFileURL(full).href, beforeImport);
+      if (desc === null) continue;
+      try {
+        register(desc);
+        loaded.push(desc.id);
+      } catch (err) {
+        process.stderr.write(`[providers] runtime plugin ${full} rejected: ${describeError(err)}
+`);
+      }
+    }
+    return loaded;
+  };
+  const loadFromPackage = async (packageName, beforeImport) => {
+    let mod;
+    try {
+      await beforeImport?.();
+      mod = await import(packageName);
+    } catch (err) {
+      process.stderr.write(`[providers] runtime package ${packageName} failed to import: ${describeError(err)}
+`);
+      return [];
+    }
+    const exported = mod.clioRuntimes;
+    if (!Array.isArray(exported)) {
+      process.stderr.write(`[providers] runtime package ${packageName} has no 'clioRuntimes' array export
+`);
+      return [];
+    }
+    const loaded = [];
+    for (const candidate of exported) {
+      const validation = validateRuntimeDescriptor(candidate);
+      if (!validation.ok) {
+        process.stderr.write(
+          `[providers] runtime package ${packageName} exported an invalid descriptor: ${validation.reason}
+`
+        );
+        continue;
+      }
+      try {
+        register(validation.descriptor);
+        loaded.push(validation.descriptor.id);
+      } catch (err) {
+        process.stderr.write(`[providers] runtime package ${packageName} id conflict: ${describeError(err)}
+`);
+      }
+    }
+    return loaded;
+  };
+  return { register, get, list, clear, loadFromDir, loadFromPackage };
+}
+var singleton = null;
+function getRuntimeRegistry() {
+  if (singleton === null) singleton = createRuntimeRegistry();
+  return singleton;
+}
+async function importDescriptor(file, href, beforeImport) {
+  let mod;
+  try {
+    await beforeImport?.();
+    mod = await import(href);
+  } catch (err) {
+    process.stderr.write(`[providers] runtime plugin ${file} failed to import: ${describeError(err)}
+`);
+    return null;
+  }
+  const candidate = mod.default;
+  const validation = validateRuntimeDescriptor(candidate);
+  if (!validation.ok) {
+    process.stderr.write(
+      `[providers] runtime plugin ${file} has invalid default-export RuntimeDescriptor: ${validation.reason}
+`
+    );
+    return null;
+  }
+  return validation.descriptor;
+}
+function validateRuntimeDescriptor(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: "descriptor must be an object" };
+  }
+  const v = value;
+  if (typeof v.id !== "string" || v.id.trim().length === 0) {
+    return { ok: false, reason: "id must be a non-empty string" };
+  }
+  if (v.aliases !== void 0 && (!Array.isArray(v.aliases) || v.aliases.some((alias) => typeof alias !== "string" || alias.trim().length === 0))) {
+    return { ok: false, reason: "aliases must be non-empty strings when present" };
+  }
+  if (typeof v.displayName !== "string" || v.displayName.trim().length === 0) {
+    return { ok: false, reason: "displayName must be a non-empty string" };
+  }
+  if (typeof v.kind !== "string" || !RUNTIME_KINDS.includes(v.kind)) {
+    return { ok: false, reason: `kind must be one of: ${RUNTIME_KINDS.join(", ")}` };
+  }
+  if (typeof v.apiFamily !== "string" || v.apiFamily.trim().length === 0) {
+    return { ok: false, reason: "apiFamily must be a non-empty string" };
+  }
+  if (typeof v.auth !== "string" || !RUNTIME_AUTHS.includes(v.auth)) {
+    return { ok: false, reason: `auth must be one of: ${RUNTIME_AUTHS.join(", ")}` };
+  }
+  if (typeof v.defaultCapabilities !== "object" || v.defaultCapabilities === null || Array.isArray(v.defaultCapabilities)) {
+    return { ok: false, reason: "defaultCapabilities must be an object" };
+  }
+  if (typeof v.synthesizeModel !== "function") {
+    return { ok: false, reason: "synthesizeModel must be a function" };
+  }
+  for (const field of ["probe", "probeModels", "complete", "infill", "embed", "rerank"]) {
+    if (v[field] !== void 0 && typeof v[field] !== "function") {
+      return { ok: false, reason: `${field} must be a function when present` };
+    }
+  }
+  return { ok: true, descriptor: value };
+}
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+
+export {
+  createRuntimeRegistry,
+  getRuntimeRegistry
+};
+//# sourceMappingURL=chunk-NUGM5KR6.js.map

package/dist/{chunk-DMD2AGVS.js → chunk-NZU6YDNV.js}

@@ -1,16 +1,18 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   receiptResponseModelIdObservationLabel
-} from "./chunk-VREKEFLL.js";
+} from "./chunk-D73KXYPF.js";
 import {
-  adaptRunReceiptTrustStatus
-} from "./chunk-UUANF5CR.js";
+  adaptRunReceiptTrustStatus,
+  formatTrustAxes,
+  formatTrustSummary
+} from "./chunk-MLOK6ZOS.js";
 import {
   formatBudgetPolicy,
   formatBudgetReasons,
   formatBudgetRequest,
   formatEffectiveBudget
-} from "./chunk-CEYBNUGC.js";
+} from "./chunk-4H6ULJ3H.js";
 import {
   mentionsWorkerToolCallCap
 } from "./chunk-4ZG3XFUR.js";
@@ -73,9 +75,9 @@ function receiptActivityLabels(receipt, status) {
 }
 function receiptEvidenceLabels(receipt, verification, integrity) {
   const status = adaptRunReceiptTrustStatus({ ...receipt, verification }, { integrity });
-  const canonical = canonicalTrustLabel(status);
+  const canonical = canonicalTrustLabels(status);
   if (!integrity.ok) {
-    return [canonical, `receipt_integrity=FAILED reason=${JSON.stringify(integrity.reason)}`];
+    return [...canonical, `receipt_integrity=FAILED reason=${JSON.stringify(integrity.reason)}`];
   }
   const briefing = receipt.briefing === void 0 ? "briefing=none" : `briefing=bytes:${receipt.briefing.bytes} sha256:${receipt.briefing.contentHash}`;
   let projectContext = "project_context=absent";
@@ -91,7 +93,7 @@ function receiptEvidenceLabels(receipt, verification, integrity) {
     `budget_reason=${JSON.stringify(formatBudgetReasons(receipt.budget))}`
   ];
   return [
-    canonical,
+    ...canonical,
     `receipt_integrity=verified/v${receipt.integrity.version}/${receipt.integrity.algorithm}`,
     `evidence_verification=${verification.state}/${verification.basis}`,
     `host_verification=${receipt.hostVerification?.status ?? "not_requested"}`,
@@ -103,16 +105,8 @@ function receiptEvidenceLabels(receipt, verification, integrity) {
     projectContext
   ];
 }
-function canonicalTrustLabel(status) {
-  return [
-    `trust_status=v${status.version}`,
-    `artifactIntegrity:${status.artifactIntegrity.state}`,
-    `validationGrounding:${status.validationGrounding.state}`,
-    `independentReview:${status.independentReview.state}`,
-    `contextProvenance:${status.contextProvenance.state}`,
-    `autonomyEnforcement:${status.autonomyEnforcement.state}`,
-    `completionEvidence:${status.completionEvidence.state}`
-  ].join(" ");
+function canonicalTrustLabels(status) {
+  return [`trust=${JSON.stringify(formatTrustSummary(status))}`, formatTrustAxes(status)];
 }
 function workerTextLabel(status) {
   switch (status.validationGrounding.state) {
@@ -122,6 +116,14 @@ function workerTextLabel(status) {
       return "reconnaissance output (advisory leads, not validation evidence):";
     case "unknown":
       return "worker claims (validation not observable at this layer):";
+    // The three remaining states were one label. The evidence bundle tells
+    // a failed check, an inferred claim, and no validation at all apart, so
+    // the terminal must too or it hands the operator a coarser verdict than
+    // the report for the same run.
+    case "failed":
+      return "worker claims (validation failed; a check ran and did not pass):";
+    case "ungrounded":
+      return "worker claims (inferred; validation claimed, none observed):";
     default:
       return "worker claims (unverified prose):";
   }
@@ -171,4 +173,4 @@ export {
   workerTextLabel,
   workerTextNonEvidenceNotices
 };
-//# sourceMappingURL=chunk-DMD2AGVS.js.map
+//# sourceMappingURL=chunk-NZU6YDNV.js.map