@iowarp/clio-coder 0.4.2 → 0.4.4

package/dist/{chunk-JBCS7CRR.js → chunk-EL24TAU4.js}

@@ -1,30 +1,30 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   inspectEvidence
-} from "./chunk-I66ZTYNP.js";
+} from "./chunk-NRO2BJRH.js";
 import {
   TASK_MEMORY_CONTENT_MAX_CHARS,
   TASK_MEMORY_DEFAULT_KNOWLEDGE_CAP,
   TASK_MEMORY_DEFAULT_PROCEDURAL_CAP,
   TASK_MEMORY_TELEMETRY_FILE,
   parseTaskMemoryTelemetryRecord
-} from "./chunk-I66EAJFY.js";
+} from "./chunk-2WZ546HR.js";
+import {
+  canonicalizeExistingPath
+} from "./chunk-ECH6PKUQ.js";
 import {
   createRedactionTally,
   redactSecretsText
 } from "./chunk-4BJ5BYCE.js";
-import {
-  canonicalizeExistingPath
-} from "./chunk-ECH6PKUQ.js";
 import {
   ceilChars
-} from "./chunk-CWVRRIEI.js";
-import {
-  clioStateDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-NZMNUPZZ.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
+import {
+  clioStateDir
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -1557,4 +1557,4 @@ export {
   taskMemoryTracePath,
   createTaskMemoryTrace
 };
-//# sourceMappingURL=chunk-JBCS7CRR.js.map
+//# sourceMappingURL=chunk-EL24TAU4.js.map

package/dist/{chunk-TPEQIQIE.js → chunk-ELWDPP3Y.js}

@@ -1,25 +1,25 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  compileFleetExecutionPlan
-} from "./chunk-DZAW46HP.js";
 import {
   discoverAgentRecipes
-} from "./chunk-CRFOIAX3.js";
+} from "./chunk-7UGL4MB5.js";
+import {
+  compileFleetExecutionPlan
+} from "./chunk-LTIKRKFL.js";
 import {
   loadFleetCommands,
   loadFleetContract,
   renderFleetPrompt
-} from "./chunk-3F7VUY77.js";
+} from "./chunk-OEJSLEPW.js";
 import {
   requestExecutionRole,
   withAttemptRole
 } from "./chunk-H7IXIC72.js";
 import {
   normalizeAgentSpec
-} from "./chunk-PGF63K6I.js";
+} from "./chunk-KFV5L5SK.js";
 import {
   readSettings
-} from "./chunk-34BHNEE3.js";
+} from "./chunk-GHS5EBTQ.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -105,4 +105,4 @@ function inspectFleet(name, vars) {
 export {
   inspectFleet
 };
-//# sourceMappingURL=chunk-TPEQIQIE.js.map
+//# sourceMappingURL=chunk-ELWDPP3Y.js.map

package/dist/{chunk-NDINPTJ4.js → chunk-ELZVTCGV.js}

@@ -20,7 +20,7 @@ var import_yaml = __toESM(require_dist(), 1);
 import { existsSync } from "node:fs";
 import { isAbsolute, join, normalize, relative } from "node:path";
 var FRONTMATTER_BLOCK = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
-var LIST_FIELDS = ["sources", "symbols", "tests", "invariants", "validate"];
+var LIST_FIELDS = ["sources", "symbols", "tests", "invariants", "validate", "decisions"];
 var SUMMARY_MAX_CHARS = 240;
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -92,7 +92,8 @@ ${block}`, { schema: "core", uniqueKeys: true });
     symbols: stringList(authored.symbols),
     tests: [],
     invariants: stringList(authored.invariants),
-    validate: stringList(authored.validate)
+    validate: stringList(authored.validate),
+    ...authored.decisions === void 0 ? {} : { decisions: stringList(authored.decisions) }
   };
   const unresolvedPaths = [];
   for (const field of ["sources", "tests"]) {
@@ -113,7 +114,7 @@ function renderList(name, values) {
 function renderFrontmatter(metadata) {
   const lines = [`title: ${JSON.stringify(metadata.title)}`];
   if (metadata.summary.length > 0) lines.push(`summary: ${JSON.stringify(metadata.summary)}`);
-  for (const field of LIST_FIELDS) lines.push(...renderList(field, metadata[field]));
+  for (const field of LIST_FIELDS) lines.push(...renderList(field, metadata[field] ?? []));
   return `---
 ${lines.join("\n")}
 ---
@@ -638,4 +639,4 @@ export {
   wikiStaleness,
   wikiStalenessAsync
 };
-//# sourceMappingURL=chunk-NDINPTJ4.js.map
+//# sourceMappingURL=chunk-ELZVTCGV.js.map

package/dist/chunk-EXLD33WO.js

@@ -0,0 +1,381 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  discoverDeclaredChecksAtRoot,
+  discoverDeclaredProjectEntriesAtRoot
+} from "./chunk-K6T2ZAMZ.js";
+import {
+  printError
+} from "./chunk-JCI2ROMZ.js";
+import {
+  DISPATCH_INTENT_TIMEOUT_MIN_MS,
+  normalizeIntentExpectedOutputs,
+  normalizeIntentVerification
+} from "./chunk-IRXAATOX.js";
+import {
+  packageDeclaredCheck
+} from "./chunk-DXKJURES.js";
+import {
+  CLIO_PROJECT_DIR
+} from "./chunk-GYV6VZOC.js";
+import {
+  atomicWrite
+} from "./chunk-HAXOFFRH.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/tasks.ts
+init_esm_shims();
+
+// src/domains/user-tasks/store.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/domains/user-tasks/acceptance.ts
+init_esm_shims();
+function normalizeUserTaskAcceptance(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("acceptance must be an object");
+  }
+  const value = raw;
+  if (Object.keys(value).some((key) => key !== "expectedOutputs" && key !== "verification")) {
+    throw new Error("acceptance contains an unknown field");
+  }
+  if (!Array.isArray(value.expectedOutputs) || !Array.isArray(value.verification)) {
+    throw new Error("acceptance requires expectedOutputs and verification arrays");
+  }
+  const checks = /* @__PURE__ */ new Map();
+  const rawVerification = value.verification.map((entry) => {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error("acceptance verification must contain check and timeoutMs");
+    }
+    const item = entry;
+    if (Object.keys(item).some((key) => key !== "check" && key !== "timeoutMs")) {
+      throw new Error("acceptance verification contains an unknown field");
+    }
+    if (typeof item.check !== "string" || typeof item.timeoutMs !== "number" || !Number.isSafeInteger(item.timeoutMs) || item.timeoutMs <= 0) {
+      throw new Error("acceptance verification requires a check and a positive integer timeoutMs");
+    }
+    checks.set(item.check.trim(), {
+      id: item.check.trim(),
+      timeoutMs: Math.max(DISPATCH_INTENT_TIMEOUT_MIN_MS, item.timeoutMs, checks.get(item.check.trim())?.timeoutMs ?? 0)
+    });
+    return { check: item.check, timeout_ms: item.timeoutMs };
+  });
+  const expectedOutputs = normalizeIntentExpectedOutputs(value.expectedOutputs);
+  if (!Array.isArray(expectedOutputs))
+    throw new Error(expectedOutputs.ok ? "invalid acceptance outputs" : expectedOutputs.message);
+  const verification = normalizeIntentVerification(rawVerification, checks);
+  if (!Array.isArray(verification))
+    throw new Error(verification.ok ? "invalid acceptance verification" : verification.message);
+  return { expectedOutputs, verification };
+}
+
+// src/domains/user-tasks/store.ts
+var USER_TASKS_FILE_VERSION = 1;
+var USER_TASKS_RELATIVE_PATH = `${CLIO_PROJECT_DIR}/user-tasks.json`;
+var UserTasksStoreError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "UserTasksStoreError";
+  }
+};
+var USER_TASK_STATUSES = ["open", "handed", "picked", "done", "dropped"];
+var FILE_KEYS = /* @__PURE__ */ new Set(["version", "nextId", "tasks"]);
+var TASK_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "title",
+  "note",
+  "acceptance",
+  "status",
+  "createdAt",
+  "updatedAt",
+  "handedSessionId",
+  "boardTaskId"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowed) {
+  return Object.keys(value).every((key) => allowed.has(key));
+}
+function isOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isUserTask(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, TASK_KEYS)) return false;
+  if (value.acceptance !== void 0) {
+    try {
+      normalizeUserTaskAcceptance(value.acceptance);
+    } catch {
+      return false;
+    }
+  }
+  return typeof value.id === "string" && /^u[1-9]\d*$/.test(value.id) && typeof value.title === "string" && value.title.trim().length > 0 && typeof value.status === "string" && USER_TASK_STATUSES.includes(value.status) && typeof value.createdAt === "string" && typeof value.updatedAt === "string" && isOptionalString(value.note) && isOptionalString(value.handedSessionId) && isOptionalString(value.boardTaskId);
+}
+function parseFile(body, path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (error) {
+    throw new UserTasksStoreError(`user tasks file is corrupt JSON: ${path}`, { cause: error });
+  }
+  if (!isRecord(parsed) || !hasOnlyKeys(parsed, FILE_KEYS)) {
+    throw new UserTasksStoreError(`user tasks file has an invalid top-level shape: ${path}`);
+  }
+  if (parsed.version !== USER_TASKS_FILE_VERSION || !Number.isSafeInteger(parsed.nextId) || parsed.nextId < 1 || !Array.isArray(parsed.tasks) || !parsed.tasks.every(isUserTask)) {
+    throw new UserTasksStoreError(`user tasks file failed schema validation: ${path}`);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  let maxId = 0;
+  for (const task of parsed.tasks) {
+    if (ids.has(task.id)) throw new UserTasksStoreError(`user tasks file contains duplicate id ${task.id}: ${path}`);
+    ids.add(task.id);
+    maxId = Math.max(maxId, Number(task.id.slice(1)));
+  }
+  if (parsed.nextId <= maxId) {
+    throw new UserTasksStoreError(`user tasks file nextId would reuse an existing id: ${path}`);
+  }
+  return {
+    version: USER_TASKS_FILE_VERSION,
+    nextId: parsed.nextId,
+    tasks: parsed.tasks.map(copyTask)
+  };
+}
+function copyTask(task) {
+  return { ...task, ...task.acceptance ? { acceptance: normalizeUserTaskAcceptance(task.acceptance) } : {} };
+}
+function initialFile() {
+  return { version: USER_TASKS_FILE_VERSION, nextId: 1, tasks: [] };
+}
+function createUserTasksStore(deps) {
+  const path = join(deps.cwd, USER_TASKS_RELATIVE_PATH);
+  const exists = deps.exists ?? existsSync;
+  const read = deps.read ?? ((target) => readFileSync(target, "utf8"));
+  const write = deps.write ?? ((target, body) => atomicWrite(target, body));
+  const now = () => (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const load = () => {
+    if (!exists(path)) return initialFile();
+    try {
+      return parseFile(read(path), path);
+    } catch (error) {
+      if (error instanceof UserTasksStoreError) throw error;
+      throw new UserTasksStoreError(`could not read user tasks file: ${path}`, { cause: error });
+    }
+  };
+  const save = (file) => {
+    try {
+      write(path, `${JSON.stringify(file, null, 2)}
+`);
+    } catch (error) {
+      throw new UserTasksStoreError(`could not write user tasks file: ${path}`, { cause: error });
+    }
+  };
+  const mutate = (id, allowed, status, sessionId) => {
+    const file = load();
+    const index = file.tasks.findIndex((task) => task.id === id);
+    const current = file.tasks[index];
+    if (!current) throw new UserTasksStoreError(`operator task ${id} was not found`);
+    if (!allowed.includes(current.status)) {
+      throw new UserTasksStoreError(`operator task ${id} is ${current.status}; it cannot move to ${status}`);
+    }
+    const updated = { ...current, status, updatedAt: now() };
+    if (status === "handed" && sessionId) updated.handedSessionId = sessionId;
+    file.tasks[index] = updated;
+    save(file);
+    return copyTask(updated);
+  };
+  const recordLink = (id, status, sessionId, boardTaskId) => {
+    const file = load();
+    const index = file.tasks.findIndex((task) => task.id === id);
+    const current = file.tasks[index];
+    if (!current) throw new UserTasksStoreError(`operator task ${id} was not found`);
+    if (current.status === "done" || current.status === "dropped") {
+      throw new UserTasksStoreError(`operator task ${id} is ${current.status}; it cannot move to ${status}`);
+    }
+    const updated = {
+      ...current,
+      status,
+      updatedAt: now(),
+      handedSessionId: sessionId,
+      boardTaskId
+    };
+    file.tasks[index] = updated;
+    save(file);
+    return copyTask(updated);
+  };
+  return {
+    path,
+    snapshot() {
+      return load().tasks.map(copyTask);
+    },
+    get(id) {
+      const task = load().tasks.find((candidate) => candidate.id === id);
+      return task ? copyTask(task) : null;
+    },
+    add(title, note, acceptance) {
+      const normalizedAcceptance = acceptance === void 0 ? void 0 : normalizeAcceptance(acceptance);
+      const normalizedTitle = title.trim();
+      if (normalizedTitle.length === 0) throw new UserTasksStoreError("operator task title cannot be empty");
+      const normalizedNote = note?.trim();
+      const file = load();
+      const timestamp = now();
+      const task = {
+        id: `u${file.nextId}`,
+        title: normalizedTitle,
+        ...normalizedNote ? { note: normalizedNote } : {},
+        ...normalizedAcceptance ? { acceptance: normalizedAcceptance } : {},
+        status: "open",
+        createdAt: timestamp,
+        updatedAt: timestamp
+      };
+      file.nextId += 1;
+      file.tasks.push(task);
+      save(file);
+      return copyTask(task);
+    },
+    setAcceptance(id, acceptance) {
+      const normalized = normalizeAcceptance(acceptance);
+      const file = load();
+      const task = file.tasks.find((item) => item.id === id);
+      if (!task) throw new UserTasksStoreError(`operator task ${id} was not found`);
+      task.acceptance = normalized;
+      task.updatedAt = now();
+      save(file);
+      return copyTask(task);
+    },
+    hand(id, sessionId) {
+      return mutate(id, ["open"], "handed", sessionId);
+    },
+    done(id) {
+      return mutate(id, ["open", "handed", "picked"], "done");
+    },
+    drop(id) {
+      return mutate(id, ["open", "handed", "picked"], "dropped");
+    },
+    recordPicked(id, sessionId, boardTaskId) {
+      return recordLink(id, "picked", sessionId, boardTaskId);
+    },
+    recordDone(id, sessionId, boardTaskId) {
+      return recordLink(id, "done", sessionId, boardTaskId);
+    },
+    reconcile(links, sessionId) {
+      const file = load();
+      let changed = false;
+      for (const [index, current] of file.tasks.entries()) {
+        if (current.status === "done" || current.status === "dropped") continue;
+        const candidates = links.filter((link2) => link2.userTaskId === current.id);
+        const completed = candidates.find((link2) => link2.status === "completed");
+        const open = candidates.find((link2) => link2.status === "active" || link2.status === "pending");
+        const link = completed ?? open;
+        if (link) {
+          const status = completed ? "done" : "picked";
+          if (current.status !== status || current.boardTaskId !== link.boardTaskId || current.handedSessionId !== sessionId) {
+            file.tasks[index] = {
+              ...current,
+              status,
+              boardTaskId: link.boardTaskId,
+              handedSessionId: sessionId,
+              updatedAt: now()
+            };
+            changed = true;
+          }
+          continue;
+        }
+        if (current.status === "picked" && current.handedSessionId === sessionId) {
+          const repaired = { ...current, status: "handed", updatedAt: now() };
+          delete repaired.boardTaskId;
+          file.tasks[index] = repaired;
+          changed = true;
+        }
+      }
+      if (changed) save(file);
+      return file.tasks.map(copyTask);
+    }
+  };
+}
+function normalizeAcceptance(raw) {
+  try {
+    return normalizeUserTaskAcceptance(raw);
+  } catch (error) {
+    throw new UserTasksStoreError(error instanceof Error ? error.message : String(error), { cause: error });
+  }
+}
+
+// src/cli/tasks.ts
+function acceptanceFromTaskFlags(cwd, expectedOutputs, verify) {
+  if (expectedOutputs.length === 0 && verify.length === 0) return void 0;
+  const discovery = discoverDeclaredChecksAtRoot(cwd, void 0);
+  if (!discovery.ok) throw new Error(discovery.reason);
+  const checks = new Map(
+    discovery.sources.flatMap((source) => source.checks.map((check) => [check.id, check]))
+  );
+  for (const entry of discoverDeclaredProjectEntriesAtRoot(cwd)) {
+    if (entry.kind === "package-script" && !checks.has(entry.id))
+      checks.set(entry.id, packageDeclaredCheck(entry.id, entry.path, ".", []));
+  }
+  const verification = verify.map((value) => {
+    const suffix = checks.has(value) ? null : /^(.*):([0-9]+)$/.exec(value);
+    const check = suffix?.[1] ?? value;
+    if (!checks.has(check))
+      throw new Error(
+        `Unknown verification check '${check}'. Known ids: ${[...checks.keys()].sort().join(", ") || "(none)"}`
+      );
+    return { check, ...suffix ? { timeout_ms: Number(suffix[2]) } : {} };
+  });
+  const outputs = normalizeIntentExpectedOutputs(expectedOutputs);
+  if (!Array.isArray(outputs)) throw new Error(outputs.ok ? "invalid expected outputs" : outputs.message);
+  const normalized = normalizeIntentVerification(verification, checks);
+  if (!Array.isArray(normalized)) throw new Error(normalized.ok ? "invalid verification" : normalized.message);
+  return { expectedOutputs: outputs, verification: normalized };
+}
+var HELP = `Usage:
+  clio-coder tasks [list]
+  clio-coder tasks add [--expect <path>] [--verify <checkId>[:timeoutMs]] <text>
+  clio-coder tasks hand|done|drop <uN>
+
+--expect and --verify are repeatable. Check ids must be declared in package.json or .clio-coder/verifiers.yaml.`;
+function runTasksCommand(args) {
+  try {
+    if (args.includes("--help") || args.includes("-h")) {
+      console.log(HELP);
+      return 0;
+    }
+    const store = createUserTasksStore({ cwd: process.cwd() });
+    const [action = "list", ...rest] = args;
+    if (action === "add") {
+      const expected = [], verify = [], title = [];
+      for (let index = 0; index < rest.length; index++) {
+        const token = rest[index] ?? "";
+        if (token === "--") {
+          title.push(...rest.slice(index + 1));
+          break;
+        }
+        if (token === "--expect" || token === "--verify") {
+          const value = rest[++index];
+          if (!value || value.startsWith("--")) throw new Error(`${token} requires a value`);
+          (token === "--expect" ? expected : verify).push(value);
+        } else if (token.startsWith("--")) throw new Error(`Unknown flag ${token}`);
+        else title.push(token);
+      }
+      const task = store.add(title.join(" "), void 0, acceptanceFromTaskFlags(process.cwd(), expected, verify));
+      console.log(`logged operator task ${task.id}: ${task.title}`);
+    } else if (action === "list" && rest.length === 0) {
+      console.log(JSON.stringify(store.snapshot(), null, 2));
+    } else if ((action === "hand" || action === "done" || action === "drop") && rest.length === 1) {
+      console.log(JSON.stringify(store[action](rest[0] ?? ""), null, 2));
+    } else throw new Error(HELP);
+    return 0;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+
+export {
+  createUserTasksStore,
+  acceptanceFromTaskFlags,
+  runTasksCommand
+};
+//# sourceMappingURL=chunk-EXLD33WO.js.map

package/dist/chunk-FEAXX7B6.js

@@ -0,0 +1,101 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  appendOutOfTurnUsageRow
+} from "./chunk-JT2RFCC5.js";
+import {
+  extractReasoningTokens
+} from "./chunk-NZMNUPZZ.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/observability/compaction-usage.ts
+init_esm_shims();
+function observedUsage(call) {
+  const raw = isRecord(call.usage) ? call.usage : {};
+  const reading = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && (call.outcome === "success" || value > 0) ? value : null;
+  const cost = isRecord(raw.cost) ? reading(raw.cost.total) : null;
+  const costUsd = cost !== null && cost > 0 ? cost : null;
+  const reasoning = extractReasoningTokens({ ...raw, reasoningTokens: void 0 });
+  return {
+    input: reading(raw.input),
+    output: reading(raw.output),
+    cacheRead: reading(raw.cacheRead),
+    cacheWrite: reading(raw.cacheWrite),
+    reasoning: reasoning !== null && reasoning > 0 ? reasoning : null,
+    totalTokens: reading(raw.totalTokens),
+    costUsd,
+    costProvenance: costUsd === null ? "unknown" : "estimated"
+  };
+}
+function recordFailedCompactionCalls(origin, calls, observability) {
+  for (const call of calls) {
+    const usage = observedUsage(call);
+    const row = {
+      label: "failed-compaction",
+      callOutcome: call.outcome,
+      sessionId: origin.sessionId,
+      repoIdentity: origin.repoIdentity,
+      timestamp: call.timestamp,
+      target: origin.target,
+      attributedModelId: origin.model,
+      usage,
+      timing: { durationMs: call.durationMs }
+    };
+    appendOutOfTurnUsageRow(origin.stateDir, row, { required: true });
+    if (!Object.values(usage).some((value) => typeof value === "number" && value > 0)) continue;
+    observability?.recordTokens(
+      origin.target,
+      origin.model,
+      usage.totalTokens ?? 0,
+      usage.costUsd ?? 0,
+      {
+        input: usage.input ?? 0,
+        output: usage.output ?? 0,
+        cacheRead: usage.cacheRead ?? 0,
+        cacheWrite: usage.cacheWrite ?? 0,
+        reasoningTokens: usage.reasoning ?? 0,
+        totalTokens: usage.totalTokens ?? 0,
+        apiCalls: 1
+      },
+      usage.costProvenance,
+      void 0,
+      "failed-compaction"
+    );
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var USAGE_FIELDS = ["input", "output", "cacheRead", "cacheWrite", "reasoning", "totalTokens", "costUsd"];
+function summarizeFailedCompactionUsage(rows) {
+  const calls = rows.filter((row) => row.label === "failed-compaction");
+  const knownUsage = Object.fromEntries(USAGE_FIELDS.map((field) => [field, null]));
+  const erroredKnownUsage = { ...knownUsage };
+  const unobservedUsageCalls = Object.fromEntries(USAGE_FIELDS.map((field) => [field, 0]));
+  for (const row of calls) {
+    for (const field of USAGE_FIELDS) {
+      const value = row.usage[field];
+      if (value === null) unobservedUsageCalls[field] += 1;
+      else {
+        knownUsage[field] = (knownUsage[field] ?? 0) + value;
+        if (row.callOutcome === "error") erroredKnownUsage[field] = (erroredKnownUsage[field] ?? 0) + value;
+      }
+    }
+  }
+  return {
+    calls: calls.length,
+    successfulCalls: calls.filter((row) => row.callOutcome === "success").length,
+    erroredCalls: calls.filter((row) => row.callOutcome === "error").length,
+    abortedCalls: calls.filter((row) => row.callOutcome === "aborted").length,
+    knownUsage,
+    erroredKnownUsage,
+    unobservedUsageCalls
+  };
+}
+
+export {
+  recordFailedCompactionCalls,
+  summarizeFailedCompactionUsage
+};
+//# sourceMappingURL=chunk-FEAXX7B6.js.map