agenr 1.9.2 → 2.0.0

package/dist/cli.js

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
-import "./chunk-ETQPUJGS.js";
+import {
+  composeProcedureRecallText,
+  computeProcedureRevisionHash,
+  computeProcedureSourceHash
+} from "./chunk-ZYADFKX3.js";
 import {
   applyClaimExtractionResultToEntry,
   backfillEpisodeEmbeddings,
@@ -27,7 +31,7 @@ import {
   tokenizeGroundingText,
   validateEntriesWithIndexes,
   validateSupersessionRules
-} from "./chunk-I6A6DPNF.js";
+} from "./chunk-XD3446YW.js";
 import {
   DEFAULT_CLAIM_EXTRACTION_CONCURRENCY,
   DEFAULT_SURGEON_CONTEXT_LIMIT,
@@ -66,6 +70,7 @@ import {
   mapEntryRow,
   mergeExplicitClaimKeyMetadata,
   normalizeManualClaimKeyUpdate,
+  parseAndNormalizeProcedureYaml,
   projectClaimCentricRecallEntry,
   readBoolean,
   readConfig,
@@ -86,7 +91,7 @@ import {
   updateEntry,
   validateTemporalValidityRange,
   writeConfig
-} from "./chunk-EMRMV2QR.js";
+} from "./chunk-Y2BC7RCE.js";
 import {
   compactClaimKey,
   describeClaimKeyNormalizationFailure,
@@ -97,7 +102,7 @@ import {
   normalizeClaimKeySegment,
   recall,
   resolveClaimSlotPolicy
-} from "./chunk-GUDCFFRV.js";
+} from "./chunk-MEHOGUZE.js";
 
 // src/cli/main.ts
 import { Command } from "commander";
@@ -230,8 +235,8 @@ function formatUnknownError(error) {
 }
 
 // src/cli/commands/ingest.ts
-import path8 from "path";
-import * as clack3 from "@clack/prompts";
+import path10 from "path";
+import * as clack4 from "@clack/prompts";
 
 // src/core/ingestion/parser.ts
 var IMPORTANCE_TIER_MAP = {
@@ -2965,20 +2970,20 @@ function registerIngestEpisodesCommand(parent) {
         embedding: embeddingSetup.port,
         createSummaryLlm: () => createEpisodeIngestSummaryLlm(provider, modelId, llmApiKey)
       };
-      const spinner5 = commandInput.verbose ? null : clack2.spinner();
-      spinner5?.start(`Generating episodes... (0/${plan.candidates.length})`);
+      const spinner6 = commandInput.verbose ? null : clack2.spinner();
+      spinner6?.start(`Generating episodes... (0/${plan.candidates.length})`);
       const execution = await executeEpisodeIngestPlan(plan, executionPorts, {
         concurrency: commandInput.concurrency,
         genVersion: CLI_EPISODE_GENERATOR_VERSION,
         onProgress: (completed, total, session) => {
-          if (spinner5) {
-            spinner5.message(`Generating episodes... (${completed}/${total})`);
+          if (spinner6) {
+            spinner6.message(`Generating episodes... (${completed}/${total})`);
           } else {
             reportEpisodeProgress(completed, total, session);
           }
         }
       });
-      spinner5?.stop("Episode ingest complete.");
+      spinner6?.stop("Episode ingest complete.");
       if (!commandInput.verbose) {
         for (const session of execution.sessions.filter((result) => result.action === "failed")) {
           clack2.log.error(formatEpisodeProgressLine(void 0, void 0, session));
@@ -3054,19 +3059,19 @@ async function runEpisodeEmbeddingBackfill(params) {
     clack2.outro(`Dry run complete: ${missingEpisodes.length} ${pluralize(missingEpisodes.length, "episode")} need embeddings.`);
     return;
   }
-  const spinner5 = params.options.verbose ? null : clack2.spinner();
-  spinner5?.start(`Embedding episodes... (0/${missingEpisodes.length})`);
+  const spinner6 = params.options.verbose ? null : clack2.spinner();
+  spinner6?.start(`Embedding episodes... (0/${missingEpisodes.length})`);
   const result = await backfillEpisodeEmbeddings(ports, {
     concurrency: params.options.concurrency,
     onProgress: (completed, total, episode, status) => {
-      if (spinner5) {
-        spinner5.message(`Embedding episodes... (${completed}/${total})`);
+      if (spinner6) {
+        spinner6.message(`Embedding episodes... (${completed}/${total})`);
       } else {
         clack2.log.step(`${completed}/${total} ${episode.sourceId ?? episode.id}: ${status}`);
       }
     }
   });
-  spinner5?.stop("Episode embedding backfill complete.");
+  spinner6?.stop("Episode embedding backfill complete.");
   const estimatedCost = estimateEpisodeEmbeddingCost(result.estimatedInputTokens, embeddingModel);
   const summaryParts = [`Done: ${result.embedded} ${pluralize(result.embedded, "episode")} embedded.`];
   if (result.failed > 0) {
@@ -3285,6 +3290,503 @@ function parseEpisodeIngestConcurrency(value) {
   return parseIntegerInRange(value, "Concurrency", MIN_EPISODE_INGEST_CONCURRENCY, MAX_EPISODE_INGEST_CONCURRENCY);
 }
 
+// src/cli/commands/ingest-procedures.ts
+import path9 from "path";
+import * as clack3 from "@clack/prompts";
+import "commander";
+
+// src/adapters/files/procedure-files.ts
+import fs6 from "fs/promises";
+import path8 from "path";
+var PROCEDURE_FILE_PATTERN = /^.+\.ya?ml$/iu;
+async function discoverProcedureFiles(targetPath, options = {}) {
+  const resolvedTargetPath = path8.resolve(targetPath);
+  const stat = await fs6.stat(resolvedTargetPath);
+  if (stat.isFile()) {
+    return matchesProcedureFileName(path8.basename(resolvedTargetPath)) ? [resolvedTargetPath] : [];
+  }
+  const recursive = options.recursive ?? true;
+  const entries = recursive ? await fs6.readdir(resolvedTargetPath, { recursive: true, withFileTypes: true }) : await fs6.readdir(resolvedTargetPath, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && matchesProcedureFileName(entry.name)).map((entry) => path8.resolve(entry.parentPath ?? resolvedTargetPath, entry.name)).sort((left, right) => left.localeCompare(right));
+}
+async function readProcedureFile(filePath) {
+  return fs6.readFile(filePath, "utf-8");
+}
+var LocalProcedureFiles = class {
+  /**
+   * Discovers procedure YAML files from a target file or directory path.
+   *
+   * @param targetPath - File or directory to inspect for procedure files.
+   * @param options - Optional discovery flags.
+   * @returns Sorted absolute procedure file paths.
+   */
+  async discoverFiles(targetPath, options) {
+    return discoverProcedureFiles(targetPath, options);
+  }
+  /**
+   * Reads one raw procedure YAML file from disk.
+   *
+   * @param filePath - Absolute procedure file path.
+   * @returns Raw UTF-8 procedure source text.
+   */
+  async readFile(filePath) {
+    return readProcedureFile(filePath);
+  }
+};
+var localProcedureFiles = new LocalProcedureFiles();
+function matchesProcedureFileName(fileName) {
+  return PROCEDURE_FILE_PATTERN.test(fileName.trim());
+}
+
+// src/app/procedures/sync/service/execute.ts
+import { randomUUID } from "crypto";
+async function executeProcedureSync(plan, ports) {
+  const invalidItems = plan.items.filter((item) => item.action === "invalid");
+  if (invalidItems.length > 0) {
+    throw new Error(formatInvalidPlanError(invalidItems));
+  }
+  const itemsNeedingEmbeddings = plan.items.filter(
+    (item) => item.action === "create" || item.action === "supersede"
+  );
+  const embeddings = itemsNeedingEmbeddings.length > 0 ? await ports.embedding.embed(itemsNeedingEmbeddings.map((item) => item.candidate.recallText)) : [];
+  if (embeddings.length !== itemsNeedingEmbeddings.length) {
+    throw new Error(`Procedure embedding count mismatch: expected ${itemsNeedingEmbeddings.length}, received ${embeddings.length}.`);
+  }
+  const embeddingByFilePath = /* @__PURE__ */ new Map();
+  itemsNeedingEmbeddings.forEach((item, index) => {
+    const embedding = embeddings[index];
+    if (!embedding) {
+      throw new Error(`Missing embedding for procedure file ${item.candidate.filePath}.`);
+    }
+    embeddingByFilePath.set(item.candidate.filePath, embedding);
+  });
+  const items = await ports.db.withTransaction(async (db) => {
+    const executionItems = [];
+    for (const item of plan.items) {
+      switch (item.action) {
+        case "create": {
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          const stored = await db.upsertProcedure(
+            buildProcedureRecord({
+              candidate: item.candidate,
+              id: randomUUID(),
+              createdAt: now,
+              updatedAt: now,
+              embedding: embeddingByFilePath.get(item.candidate.filePath),
+              retired: false
+            })
+          );
+          executionItems.push({
+            action: "created",
+            filePath: item.candidate.filePath,
+            procedureKey: item.candidate.procedure.procedure_key,
+            procedureId: stored.id
+          });
+          break;
+        }
+        case "update_source_only": {
+          const stored = await db.upsertProcedure(
+            buildProcedureRecord({
+              candidate: item.candidate,
+              existing: item.existing,
+              id: item.existing.id,
+              createdAt: item.existing.created_at,
+              updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              embedding: item.existing.embedding,
+              retired: false
+            })
+          );
+          executionItems.push({
+            action: "updated_source_only",
+            filePath: item.candidate.filePath,
+            procedureKey: item.candidate.procedure.procedure_key,
+            procedureId: stored.id
+          });
+          break;
+        }
+        case "supersede": {
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          const replacementId = randomUUID();
+          const staged = buildProcedureRecord({
+            candidate: item.candidate,
+            id: replacementId,
+            createdAt: now,
+            updatedAt: now,
+            embedding: embeddingByFilePath.get(item.candidate.filePath),
+            retired: true
+          });
+          await db.upsertProcedure(staged);
+          const superseded = await db.supersedeProcedure(item.existing.id, replacementId, "procedure revision updated");
+          if (!superseded) {
+            throw new Error(`Failed to supersede active procedure ${item.existing.id} for ${item.candidate.procedure.procedure_key}.`);
+          }
+          const activated = await db.upsertProcedure({
+            ...staged,
+            retired: false,
+            retired_at: void 0,
+            retired_reason: void 0,
+            superseded_by: void 0,
+            updated_at: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          executionItems.push({
+            action: "superseded",
+            filePath: item.candidate.filePath,
+            procedureKey: item.candidate.procedure.procedure_key,
+            procedureId: activated.id,
+            previousProcedureId: item.existing.id
+          });
+          break;
+        }
+        case "unchanged":
+          executionItems.push({
+            action: "unchanged",
+            filePath: item.candidate.filePath,
+            procedureKey: item.candidate.procedure.procedure_key,
+            procedureId: item.existing.id
+          });
+          break;
+        case "invalid":
+          throw new Error(`Invalid procedure plan item for ${item.filePath}: ${item.error}`);
+      }
+    }
+    return executionItems;
+  });
+  return {
+    plan,
+    items,
+    totals: summarizeExecution(items)
+  };
+}
+function buildProcedureRecord(params) {
+  const { candidate, existing } = params;
+  return {
+    id: params.id,
+    ...candidate.procedure,
+    recall_text: candidate.recallText,
+    revision_hash: candidate.revisionHash,
+    source_hash: candidate.sourceHash,
+    source_file: candidate.filePath,
+    embedding: params.embedding ?? existing?.embedding,
+    retired: params.retired,
+    retired_at: existing?.retired_at,
+    retired_reason: existing?.retired_reason,
+    superseded_by: existing?.superseded_by,
+    created_at: params.createdAt,
+    updated_at: params.updatedAt
+  };
+}
+function summarizeExecution(items) {
+  return items.reduce(
+    (totals, item) => {
+      switch (item.action) {
+        case "created":
+          totals.created += 1;
+          break;
+        case "updated_source_only":
+          totals.updatedSourceOnly += 1;
+          break;
+        case "superseded":
+          totals.superseded += 1;
+          break;
+        case "unchanged":
+          totals.unchanged += 1;
+          break;
+      }
+      return totals;
+    },
+    {
+      created: 0,
+      updatedSourceOnly: 0,
+      superseded: 0,
+      unchanged: 0
+    }
+  );
+}
+function formatInvalidPlanError(invalidItems) {
+  const details = invalidItems.map((item) => `${item.filePath}: ${item.error}`).join(" | ");
+  return `Procedure sync plan contains ${invalidItems.length} invalid file(s): ${details}`;
+}
+
+// src/app/procedures/sync/service/prepare.ts
+async function prepareProcedureSync(targetPath, ports) {
+  const files = await ports.files.discoverFiles(targetPath);
+  const discoveredItems = await Promise.all(files.map((filePath) => prepareCandidateForFile(filePath, ports)));
+  const duplicateKeys = collectDuplicateProcedureKeys(discoveredItems);
+  const planItems = [];
+  for (const discoveredItem of discoveredItems) {
+    if ("action" in discoveredItem) {
+      planItems.push(discoveredItem);
+      continue;
+    }
+    const duplicates = duplicateKeys.get(discoveredItem.procedure.procedure_key);
+    if (duplicates && duplicates.length > 1) {
+      planItems.push({
+        action: "invalid",
+        filePath: discoveredItem.filePath,
+        error: formatDuplicateProcedureKeyError(discoveredItem.procedure.procedure_key, duplicates)
+      });
+      continue;
+    }
+    const existing = await ports.db.findActiveProcedureByKey(discoveredItem.procedure.procedure_key);
+    planItems.push(classifyProcedureCandidate(discoveredItem, existing));
+  }
+  return {
+    targetPath,
+    files,
+    items: planItems,
+    totals: summarizePlan(planItems, files.length)
+  };
+}
+async function prepareCandidateForFile(filePath, ports) {
+  try {
+    const sourceText = await ports.files.readFile(filePath);
+    const procedure = parseAndNormalizeProcedureYaml(sourceText, filePath);
+    return {
+      filePath,
+      procedure,
+      recallText: composeProcedureRecallText(procedure),
+      revisionHash: computeProcedureRevisionHash(procedure),
+      sourceHash: computeProcedureSourceHash(sourceText)
+    };
+  } catch (error) {
+    return {
+      action: "invalid",
+      filePath,
+      error: formatUnknownError3(error)
+    };
+  }
+}
+function collectDuplicateProcedureKeys(items) {
+  const filesByProcedureKey = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if ("action" in item) {
+      continue;
+    }
+    const files = filesByProcedureKey.get(item.procedure.procedure_key) ?? [];
+    files.push(item.filePath);
+    filesByProcedureKey.set(item.procedure.procedure_key, files);
+  }
+  return new Map(Array.from(filesByProcedureKey.entries()).filter(([, files]) => files.length > 1));
+}
+function classifyProcedureCandidate(candidate, existing) {
+  if (!existing) {
+    return {
+      action: "create",
+      candidate
+    };
+  }
+  if (existing.revision_hash !== candidate.revisionHash) {
+    return {
+      action: "supersede",
+      candidate,
+      existing
+    };
+  }
+  if (existing.source_hash !== candidate.sourceHash || existing.source_file !== candidate.filePath) {
+    return {
+      action: "update_source_only",
+      candidate,
+      existing
+    };
+  }
+  return {
+    action: "unchanged",
+    candidate,
+    existing
+  };
+}
+function summarizePlan(items, discoveredCount) {
+  return items.reduce(
+    (totals, item) => {
+      switch (item.action) {
+        case "create":
+          totals.create += 1;
+          break;
+        case "update_source_only":
+          totals.updateSourceOnly += 1;
+          break;
+        case "supersede":
+          totals.supersede += 1;
+          break;
+        case "unchanged":
+          totals.unchanged += 1;
+          break;
+        case "invalid":
+          totals.invalid += 1;
+          break;
+      }
+      return totals;
+    },
+    {
+      discovered: discoveredCount,
+      create: 0,
+      updateSourceOnly: 0,
+      supersede: 0,
+      unchanged: 0,
+      invalid: 0
+    }
+  );
+}
+function formatDuplicateProcedureKeyError(procedureKey, filePaths) {
+  return `Duplicate procedure_key "${procedureKey}" found in ${filePaths.join(", ")}.`;
+}
+function formatUnknownError3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/cli/commands/ingest-procedures.ts
+var DEFAULT_PROCEDURE_SYNC_PATH = "procedures";
+function registerIngestProceduresCommand(parent) {
+  parent.command("procedures [path]").description("Sync repo-authored procedure YAML files into the knowledge database").option("--dry-run", "Discover, validate, normalize, and diff without writing").option("--verbose", "Show detailed per-file planning and execution output").action(async (targetPath, options) => {
+    let database = null;
+    const commandInput = normalizeIngestProceduresCommand(targetPath, options);
+    setVerbose(commandInput.verbose);
+    clack3.intro(banner());
+    try {
+      const config = readConfig();
+      const dbPath = config.dbPath;
+      const resolvedTargetPath = path9.resolve(commandInput.targetPath);
+      database = await createDatabase(dbPath);
+      if (commandInput.verbose) {
+        clack3.log.step(`Preparing procedure sync for ${resolvedTargetPath}...`);
+      }
+      const plan = await prepareProcedureSync(commandInput.targetPath, {
+        files: localProcedureFiles,
+        db: database
+      });
+      if (plan.files.length === 0) {
+        clack3.log.warn(`No procedure files found at ${resolvedTargetPath}.`);
+        clack3.outro("Nothing to sync.");
+        return;
+      }
+      printProcedureSyncSummary({
+        targetPath: resolvedTargetPath,
+        dbPath,
+        dryRun: commandInput.dryRun,
+        plan
+      });
+      if (commandInput.verbose) {
+        printVerboseProcedurePlan(plan.items);
+      }
+      if (commandInput.dryRun) {
+        if (plan.totals.invalid > 0) {
+          process.exitCode = 1;
+        }
+        clack3.outro(`Dry run complete: ${formatProcedurePlanTail(plan)}.`);
+        return;
+      }
+      if (plan.totals.invalid > 0) {
+        throw new Error(`Procedure sync blocked: ${plan.totals.invalid} invalid file(s) must be fixed before writing.`);
+      }
+      const embedding = createEmbeddingClient(resolveEmbeddingApiKey(config), resolveEmbeddingModel(config));
+      const spinner6 = commandInput.verbose ? null : clack3.spinner();
+      spinner6?.start(`Syncing procedures... (${countPlannedWrites(plan.items)} writes planned)`);
+      const execution = await executeProcedureSync(plan, {
+        db: database,
+        embedding
+      });
+      spinner6?.stop("Procedure sync complete.");
+      if (commandInput.verbose) {
+        printVerboseProcedureExecution(execution.items);
+      }
+      clack3.outro(`Done: ${formatProcedureExecutionTail(execution)}.`);
+    } catch (error) {
+      process.exitCode = 1;
+      clack3.log.error(formatUnknownError4(error));
+      clack3.outro(ui.error("Procedure sync failed"));
+    } finally {
+      await database?.close();
+    }
+  });
+}
+function normalizeIngestProceduresCommand(targetPath, options) {
+  return {
+    targetPath: normalizeOptionalString3(targetPath) ?? DEFAULT_PROCEDURE_SYNC_PATH,
+    verbose: options.verbose === true,
+    dryRun: options.dryRun === true
+  };
+}
+function printProcedureSyncSummary(params) {
+  const lines = [
+    formatLabel("Target", params.targetPath),
+    formatLabel("Database", params.dbPath),
+    formatLabel("Files", `${params.plan.totals.discovered} ${pluralize2(params.plan.totals.discovered, "file")} discovered`),
+    formatLabel(
+      "Plan",
+      `${params.plan.totals.create} create | ${params.plan.totals.updateSourceOnly} source update | ${params.plan.totals.supersede} supersede | ${params.plan.totals.unchanged} unchanged | ${params.plan.totals.invalid} invalid`
+    )
+  ];
+  if (params.dryRun) {
+    lines.push(formatLabel("Mode", "dry run"));
+  }
+  clack3.log.info(lines.join("\n"));
+}
+function printVerboseProcedurePlan(items) {
+  for (const item of items) {
+    switch (item.action) {
+      case "invalid":
+        clack3.log.error(`[invalid] ${item.filePath}: ${item.error}`);
+        break;
+      case "create":
+        clack3.log.step(`[create] ${item.candidate.procedure.procedure_key}: ${item.candidate.filePath}`);
+        break;
+      case "update_source_only":
+        clack3.log.step(`[update_source_only] ${item.candidate.procedure.procedure_key}: ${item.candidate.filePath} -> reuse ${item.existing.id}`);
+        break;
+      case "supersede":
+        clack3.log.step(`[supersede] ${item.candidate.procedure.procedure_key}: ${item.existing.id} -> new revision`);
+        break;
+      case "unchanged":
+        clack3.log.step(`[unchanged] ${item.candidate.procedure.procedure_key}: ${item.candidate.filePath}`);
+        break;
+    }
+  }
+}
+function printVerboseProcedureExecution(items) {
+  for (const item of items) {
+    switch (item.action) {
+      case "created":
+        clack3.log.step(`[created] ${item.procedureKey}: ${item.procedureId}`);
+        break;
+      case "updated_source_only":
+        clack3.log.step(`[updated_source_only] ${item.procedureKey}: ${item.procedureId}`);
+        break;
+      case "superseded":
+        clack3.log.step(`[superseded] ${item.procedureKey}: ${item.previousProcedureId} -> ${item.procedureId}`);
+        break;
+      case "unchanged":
+        clack3.log.step(`[unchanged] ${item.procedureKey}: ${item.procedureId}`);
+        break;
+    }
+  }
+}
+function countPlannedWrites(items) {
+  return items.filter((item) => item.action === "create" || item.action === "update_source_only" || item.action === "supersede").length;
+}
+function formatProcedurePlanTail(plan) {
+  return [
+    `${plan.totals.create} create`,
+    `${plan.totals.updateSourceOnly} source update`,
+    `${plan.totals.supersede} supersede`,
+    `${plan.totals.unchanged} unchanged`,
+    `${plan.totals.invalid} invalid`
+  ].join(", ");
+}
+function formatProcedureExecutionTail(execution) {
+  return [
+    `${execution.totals.created} created`,
+    `${execution.totals.updatedSourceOnly} source updated`,
+    `${execution.totals.superseded} superseded`,
+    `${execution.totals.unchanged} unchanged`
+  ].join(", ");
+}
+function pluralize2(value, singular, plural) {
+  return value === 1 ? singular : plural ?? `${singular}s`;
+}
+function formatUnknownError4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/cli/commands/ingest.ts
 var MIN_INGEST_CONCURRENCY = 1;
 var MAX_INGEST_CONCURRENCY = 50;
@@ -3292,6 +3794,7 @@ function registerIngestCommand(program2) {
   const ingestCommand = program2.command("ingest").description("Ingest OpenClaw transcripts and derived memory artifacts");
   registerIngestEntriesCommand(ingestCommand);
   registerIngestEpisodesCommand(ingestCommand);
+  registerIngestProceduresCommand(ingestCommand);
 }
 function registerIngestEntriesCommand(parent) {
   const ingestCommand = parent.command("entries <path>", { isDefault: true }).description("Ingest OpenClaw session files into the knowledge database").option("--verbose", "Show detailed progress").option("--dry-run", "Parse and extract without storing").addOption(new Option2("--whole-file <mode>", "Whole-file mode: auto|force|never").choices(["auto", "force", "never"]).default("auto")).option("--skip-dedup", "Skip within-batch semantic dedup").addOption(new Option2("--concurrency <n>", "Max files to extract in parallel").argParser(parseConcurrency));
@@ -3300,7 +3803,7 @@ function registerIngestEntriesCommand(parent) {
     let db = null;
     const commandInput = normalizeIngestEntriesCommand(targetPath, options);
     setVerbose(commandInput.verbose);
-    clack3.intro(banner());
+    clack4.intro(banner());
     try {
       const config = readConfig();
       const dbPath = config.dbPath;
@@ -3319,20 +3822,20 @@ function registerIngestEntriesCommand(parent) {
       const claimApiKey = claimModel ? resolveLlmApiKey(config, claimModel.provider) : void 0;
       const sharedEmbedding = createEmbeddingClient(resolveEmbeddingApiKey(config), resolveEmbeddingModel(config));
       if (commandInput.verbose) {
-        clack3.log.step(`Discovering transcript files in ${path8.resolve(commandInput.targetPath)}...`);
+        clack4.log.step(`Discovering transcript files in ${path10.resolve(commandInput.targetPath)}...`);
       }
       const files = await localTranscriptFiles.discoverFiles(commandInput.targetPath);
       if (files.length === 0) {
-        clack3.log.warn(`No transcript files found at ${path8.resolve(commandInput.targetPath)}.`);
-        clack3.outro("Nothing to ingest.");
+        clack4.log.warn(`No transcript files found at ${path10.resolve(commandInput.targetPath)}.`);
+        clack4.outro("Nothing to ingest.");
         return;
       }
-      clack3.log.info(
+      clack4.log.info(
         [
           formatLabel("Extraction model", `${provider}/${modelId}`),
           formatLabel("Dedup model", commandInput.skipDedup ? "skipped" : `${dedupProvider}/${dedupModelId}`),
           formatLabel("Database", dbPath),
-          formatLabel("Files", `${files.length} ${pluralize2(files.length, "file")} found`),
+          formatLabel("Files", `${files.length} ${pluralize3(files.length, "file")} found`),
           formatLabel("Whole-file", commandInput.wholeFile),
           formatLabel("Within-batch dedup", commandInput.skipDedup ? "skipped" : "enabled"),
           formatLabel("Embeddings", "stored"),
@@ -3340,11 +3843,11 @@ function registerIngestEntriesCommand(parent) {
         ].join("\n")
       );
       if (commandInput.dryRun) {
-        clack3.log.warn("Dry run mode - no entries will be stored.");
+        clack4.log.warn("Dry run mode - no entries will be stored.");
       }
       const useVerboseBulkWriteProgress = commandInput.verbose && !commandInput.dryRun;
-      const spinner5 = useVerboseBulkWriteProgress ? null : clack3.spinner();
-      spinner5?.start(`Processing transcripts... (0/${files.length} extracted)`);
+      const spinner6 = useVerboseBulkWriteProgress ? null : clack4.spinner();
+      spinner6?.start(`Processing transcripts... (0/${files.length} extracted)`);
       const ingestResult = await ingestDiscoveredFiles(
         files,
         {
@@ -3367,23 +3870,23 @@ function registerIngestEntriesCommand(parent) {
           skipDedup: commandInput.skipDedup,
           extractionContext: config.extractionContext,
           onExtractionProgress: (completed, total) => {
-            spinner5?.message(`Processing transcripts... (${completed}/${total} extracted)`);
+            spinner6?.message(`Processing transcripts... (${completed}/${total} extracted)`);
           },
           onStageProgress: (event) => {
-            spinner5?.message(progressMessageForIngestStage(event));
+            spinner6?.message(progressMessageForIngestStage(event));
           },
           onDedupProgress: (event) => {
-            spinner5?.message(progressMessageForDedup(event));
+            spinner6?.message(progressMessageForDedup(event));
           },
           onClaimExtractionProgress: (event) => {
-            spinner5?.message(progressMessageForClaimExtraction(event));
+            spinner6?.message(progressMessageForClaimExtraction(event));
           },
           onBulkWriteProgress: useVerboseBulkWriteProgress ? reportBulkWriteProgress : (event) => {
-            spinner5?.message(progressMessageForBulkWrite(event.phase));
+            spinner6?.message(progressMessageForBulkWrite(event.phase));
           }
         }
       );
-      spinner5?.stop("Ingest pipeline complete.");
+      spinner6?.stop("Ingest pipeline complete.");
       const extractionRuns = ingestResult.extractionRuns;
       const extractedResults = extractionRuns.map(({ result }) => result);
       const extractedSuccesses = extractedResults.filter((result) => result.skipped !== true && result.error === void 0);
@@ -3396,7 +3899,7 @@ function registerIngestEntriesCommand(parent) {
         printDedupSummary(dedupResult, taggedEntries, commandInput, dedupUsage.totalCost);
       }
       if (claimKeyHealth) {
-        clack3.log.info(formatClaimKeyHealthSummary(claimKeyHealth));
+        clack4.log.info(formatClaimKeyHealthSummary(claimKeyHealth));
       }
       const totals = {
         stored: 0,
@@ -3419,9 +3922,9 @@ function registerIngestEntriesCommand(parent) {
           totals.skippedFiles += 1;
           if (commandInput.verbose) {
             printVerboseFileDetails(result, commandInput, usage);
-            clack3.log.step(buildSkippedMessage(path8.basename(result.file)));
+            clack4.log.step(buildSkippedMessage(path10.basename(result.file)));
           } else {
-            clack3.log.step(buildSkippedMessage(path8.basename(result.file)));
+            clack4.log.step(buildSkippedMessage(path10.basename(result.file)));
           }
           continue;
         }
@@ -3430,7 +3933,7 @@ function registerIngestEntriesCommand(parent) {
           if (commandInput.verbose) {
             printVerboseFileDetails(result, commandInput, usage);
           }
-          clack3.log.error(buildFailureMessage(path8.basename(result.file), result, commandInput, usage, index === 0));
+          clack4.log.error(buildFailureMessage(path10.basename(result.file), result, commandInput, usage, index === 0));
           continue;
         }
         const storeResult = result.storeResult ?? emptyStoreResult2();
@@ -3440,23 +3943,23 @@ function registerIngestEntriesCommand(parent) {
         if (commandInput.verbose) {
           printVerboseFileDetails(result, commandInput, usage);
         }
-        clack3.log.step(buildSuccessMessage(path8.basename(result.file), result, commandInput, usage, index === 0));
+        clack4.log.step(buildSuccessMessage(path10.basename(result.file), result, commandInput, usage, index === 0));
       }
-      const summaryParts = [`${totals.stored} ${pluralize2(totals.stored, "entry", "entries")} stored`, `${totals.deduped} deduped`];
+      const summaryParts = [`${totals.stored} ${pluralize3(totals.stored, "entry", "entries")} stored`, `${totals.deduped} deduped`];
       if (totals.rejected > 0) {
         summaryParts.push(`${totals.rejected} rejected`);
       }
       if (totals.skippedFiles > 0) {
-        summaryParts.push(`${totals.skippedFiles} ${pluralize2(totals.skippedFiles, "file")} skipped`);
+        summaryParts.push(`${totals.skippedFiles} ${pluralize3(totals.skippedFiles, "file")} skipped`);
       }
       if (totals.failedFiles > 0) {
-        summaryParts.push(`${totals.failedFiles} ${pluralize2(totals.failedFiles, "file")} failed`);
+        summaryParts.push(`${totals.failedFiles} ${pluralize3(totals.failedFiles, "file")} failed`);
       }
       if (totals.warnings > 0) {
-        summaryParts.push(`${totals.warnings} ${pluralize2(totals.warnings, "warning")}`);
+        summaryParts.push(`${totals.warnings} ${pluralize3(totals.warnings, "warning")}`);
       }
       if (usageTotals.calls > 0) {
-        clack3.log.info(
+        clack4.log.info(
           [
             formatLabel(
               "Tokens",
@@ -3468,11 +3971,11 @@ function registerIngestEntriesCommand(parent) {
         );
       }
       const dryRunSuffix = commandInput.dryRun ? " Dry run only." : "";
-      clack3.outro(`Done: ${summaryParts.join(", ")}. (${formatCost2(usageTotals.totalCost)}, ${formatDurationMs2(Date.now() - startedAt)})${dryRunSuffix}`);
+      clack4.outro(`Done: ${summaryParts.join(", ")}. (${formatCost2(usageTotals.totalCost)}, ${formatDurationMs2(Date.now() - startedAt)})${dryRunSuffix}`);
     } catch (error) {
       process.exitCode = 1;
-      clack3.log.error(formatUnknownError3(error));
-      clack3.outro(ui.error("Ingest failed"));
+      clack4.log.error(formatUnknownError5(error));
+      clack4.outro(ui.error("Ingest failed"));
     } finally {
       await db?.close();
     }
@@ -3544,15 +4047,15 @@ function printVerboseFileDetails(result, options, usage) {
   }
   const fileLabel = result.file;
   if (result.skipped) {
-    clack3.log.step(`${fileLabel}: skipped because the ingest hash matched.`);
+    clack4.log.step(`${fileLabel}: skipped because the ingest hash matched.`);
     return;
   }
   if (result.error) {
     for (const chunkDetail of result.chunkDetails) {
-      clack3.log.step(formatChunkDetail(result.file, chunkDetail));
+      clack4.log.step(formatChunkDetail(result.file, chunkDetail));
     }
     const lines2 = [
-      `${fileLabel}: ${result.messageCount} ${pluralize2(result.messageCount, "message")} parsed before failure`,
+      `${fileLabel}: ${result.messageCount} ${pluralize3(result.messageCount, "message")} parsed before failure`,
       `${fileLabel}: extraction ${result.successfulChunks}/${result.chunkCount} chunks succeeded`
     ];
     const usageLine2 = formatVerboseUsageLine(fileLabel, usage);
@@ -3560,19 +4063,19 @@ function printVerboseFileDetails(result, options, usage) {
       lines2.push(usageLine2);
     }
     lines2.push(`${fileLabel}: duration ${formatDurationMs2(result.durationMs)}`);
-    clack3.log.step(lines2.join("\n"));
+    clack4.log.step(lines2.join("\n"));
     for (const warning of result.warnings) {
       if (warning !== result.error) {
-        clack3.log.warn(`${fileLabel}: ${warning}`);
+        clack4.log.warn(`${fileLabel}: ${warning}`);
       }
     }
     return;
   }
   for (const chunkDetail of result.chunkDetails) {
-    clack3.log.step(formatChunkDetail(result.file, chunkDetail));
+    clack4.log.step(formatChunkDetail(result.file, chunkDetail));
   }
   const lines = [
-    `${fileLabel}: ${result.messageCount} ${pluralize2(result.messageCount, "message")} parsed`,
+    `${fileLabel}: ${result.messageCount} ${pluralize3(result.messageCount, "message")} parsed`,
     `${fileLabel}: extraction ${result.successfulChunks}/${result.chunkCount} chunks succeeded`,
     `${fileLabel}: store ${formatStoreSummary(result)}`
   ];
@@ -3581,15 +4084,15 @@ function printVerboseFileDetails(result, options, usage) {
     lines.push(usageLine);
   }
   lines.push(`${fileLabel}: duration ${formatDurationMs2(result.durationMs)}`);
-  clack3.log.step(lines.join("\n"));
+  clack4.log.step(lines.join("\n"));
   for (const warning of result.warnings) {
-    clack3.log.warn(`${fileLabel}: ${warning}`);
+    clack4.log.warn(`${fileLabel}: ${warning}`);
   }
 }
 function buildSuccessMessage(fileLabel, result, options, usage, isFirstFile) {
   const storeResult = result.storeResult ?? emptyStoreResult2();
   const details = [
-    `${result.messageCount} ${pluralize2(result.messageCount, "message")}`,
+    `${result.messageCount} ${pluralize3(result.messageCount, "message")}`,
     `${result.entriesExtracted} extracted`,
     `${storeResult.stored} stored`
   ];
@@ -3600,7 +4103,7 @@ function buildSuccessMessage(fileLabel, result, options, usage, isFirstFile) {
     details.push(`${storeResult.rejected} rejected`);
   }
   if (result.failedChunks > 0) {
-    details.push(`${result.failedChunks} chunk ${pluralize2(result.failedChunks, "failure")}`);
+    details.push(`${result.failedChunks} chunk ${pluralize3(result.failedChunks, "failure")}`);
   }
   if (options.dryRun === true) {
     details.push("dry run");
@@ -3625,7 +4128,7 @@ function formatStoreSummary(result) {
   const storeResult = result.storeResult ?? emptyStoreResult2();
   const parts = [`${storeResult.stored} stored`, `${storeResult.skipped} deduped`, `${storeResult.rejected} rejected`];
   if (result.failedChunks > 0) {
-    parts.push(`${result.failedChunks} chunk ${pluralize2(result.failedChunks, "failure")}`);
+    parts.push(`${result.failedChunks} chunk ${pluralize3(result.failedChunks, "failure")}`);
   }
   return parts.join(", ");
 }
@@ -3652,12 +4155,12 @@ function formatVerboseUsageLine(fileLabel, usage) {
   if (usage.fileCost === 0 && usage.fileCalls === 0) {
     return void 0;
   }
-  return `${fileLabel}: cost ${formatCost2(usage.fileCost)} (${usage.fileCalls} ${pluralize2(usage.fileCalls, "LLM call")})`;
+  return `${fileLabel}: cost ${formatCost2(usage.fileCost)} (${usage.fileCalls} ${pluralize3(usage.fileCalls, "LLM call")})`;
 }
-function formatUnknownError3(error) {
+function formatUnknownError5(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function pluralize2(value, singular, plural) {
+function pluralize3(value, singular, plural) {
   return value === 1 ? singular : plural ?? `${singular}s`;
 }
 function getDisplayResult(result, storeResults) {
@@ -3683,33 +4186,33 @@ function collectTaggedEntries2(results) {
 }
 function printDedupSummary(dedupResult, taggedEntries, options, dedupCost) {
   if (taggedEntries.length === 0) {
-    clack3.log.step("Dedup: 0 entries extracted, nothing to arbitrate.");
+    clack4.log.step("Dedup: 0 entries extracted, nothing to arbitrate.");
     return;
   }
   if (options.skipDedup === true) {
-    clack3.log.step(`Dedup: skipped (--skip-dedup), ${taggedEntries.length} ${pluralize2(taggedEntries.length, "entry", "entries")} passed through.`);
+    clack4.log.step(`Dedup: skipped (--skip-dedup), ${taggedEntries.length} ${pluralize3(taggedEntries.length, "entry", "entries")} passed through.`);
     return;
   }
-  clack3.log.step(
-    `Dedup: ${dedupResult.inputCount} ${pluralize2(dedupResult.inputCount, "entry", "entries")} -> ${dedupResult.clustersArbitrated} similar ${pluralize2(dedupResult.clustersArbitrated, "cluster")} found (similarity > ${formatThreshold(dedupResult.similarityThreshold)})`
+  clack4.log.step(
+    `Dedup: ${dedupResult.inputCount} ${pluralize3(dedupResult.inputCount, "entry", "entries")} -> ${dedupResult.clustersArbitrated} similar ${pluralize3(dedupResult.clustersArbitrated, "cluster")} found (similarity > ${formatThreshold(dedupResult.similarityThreshold)})`
   );
-  clack3.log.step(
-    `Dedup: ${dedupResult.clustersArbitrated} ${pluralize2(dedupResult.clustersArbitrated, "cluster")} arbitrated (${dedupResult.llmCalls} ${pluralize2(dedupResult.llmCalls, "LLM call")})`
+  clack4.log.step(
+    `Dedup: ${dedupResult.clustersArbitrated} ${pluralize3(dedupResult.clustersArbitrated, "cluster")} arbitrated (${dedupResult.llmCalls} ${pluralize3(dedupResult.llmCalls, "LLM call")})`
   );
-  clack3.log.step(
-    `Dedup: ${dedupResult.survivors.length} ${pluralize2(dedupResult.survivors.length, "entry", "entries")} survived, ${dedupResult.removedCount} removed (${formatCost2(dedupCost)})`
+  clack4.log.step(
+    `Dedup: ${dedupResult.survivors.length} ${pluralize3(dedupResult.survivors.length, "entry", "entries")} survived, ${dedupResult.removedCount} removed (${formatCost2(dedupCost)})`
   );
   for (const warning of dedupResult.warnings) {
-    clack3.log.warn(`Dedup: ${warning}`);
+    clack4.log.warn(`Dedup: ${warning}`);
   }
   if (options.verbose !== true) {
     return;
   }
   for (const [clusterIndex, detail] of dedupResult.clusterDetails.entries()) {
-    clack3.log.step(formatDedupClusterDetail(clusterIndex, detail, taggedEntries));
+    clack4.log.step(formatDedupClusterDetail(clusterIndex, detail, taggedEntries));
   }
-  clack3.log.step(
-    `Dedup: ${dedupResult.singletonsPassedThrough} ${pluralize2(dedupResult.singletonsPassedThrough, "singleton")} passed through (no similar neighbors)`
+  clack4.log.step(
+    `Dedup: ${dedupResult.singletonsPassedThrough} ${pluralize3(dedupResult.singletonsPassedThrough, "singleton")} passed through (no similar neighbors)`
   );
 }
 function formatDedupClusterDetail(clusterIndex, detail, taggedEntries) {
@@ -3718,7 +4221,7 @@ function formatDedupClusterDetail(clusterIndex, detail, taggedEntries) {
     localIndexByOriginal.set(entryIndex, localIndex);
   });
   const lines = [
-    `Dedup cluster ${clusterIndex + 1} (${detail.entryIndices.length} ${pluralize2(detail.entryIndices.length, "entry", "entries")}, max similarity ${detail.maxSimilarity.toFixed(2)}):`
+    `Dedup cluster ${clusterIndex + 1} (${detail.entryIndices.length} ${pluralize3(detail.entryIndices.length, "entry", "entries")}, max similarity ${detail.maxSimilarity.toFixed(2)}):`
   ];
   for (const [localIndex, originalIndex] of detail.entryIndices.entries()) {
     const taggedEntry = taggedEntries.find((entry2) => entry2.originalIndex === originalIndex);
@@ -3778,11 +4281,11 @@ function progressMessageForIngestStage(event) {
     case "claim_extraction_start":
       return "Extracting claim keys...";
     case "store_start":
-      return `Running store pipeline for ${event.totalEntries} ${pluralize2(event.totalEntries, "entry", "entries")}...`;
+      return `Running store pipeline for ${event.totalEntries} ${pluralize3(event.totalEntries, "entry", "entries")}...`;
   }
 }
 function progressMessageForDedup(event) {
-  return `Deduplicating entries... ${event.completedClusters}/${event.totalClusters} ${pluralize2(event.totalClusters, "cluster")} arbitrated (${event.completedEntries}/${event.totalEntries} entries covered)`;
+  return `Deduplicating entries... ${event.completedClusters}/${event.totalClusters} ${pluralize3(event.totalClusters, "cluster")} arbitrated (${event.completedEntries}/${event.totalEntries} entries covered)`;
 }
 function progressMessageForClaimExtraction(event) {
   switch (event.phase) {
@@ -3807,16 +4310,16 @@ function progressMessageForBulkWrite(phase) {
 function reportBulkWriteProgress(event) {
   switch (event.phase) {
     case "prepare_start":
-      clack3.log.step("Store: dropping FTS triggers and vector index for bulk writes...");
+      clack4.log.step("Store: dropping FTS triggers and vector index for bulk writes...");
       break;
     case "store_complete":
-      clack3.log.step("Store phase complete.");
+      clack4.log.step("Store phase complete.");
       break;
     case "finalize_start":
-      clack3.log.step("Store: rebuilding FTS and vector index...");
+      clack4.log.step("Store: rebuilding FTS and vector index...");
       break;
     case "finalize_complete":
-      clack3.log.step(`Store: indexes rebuilt (${formatDurationMs2(event.durationMs ?? 0)}).`);
+      clack4.log.step(`Store: indexes rebuilt (${formatDurationMs2(event.durationMs ?? 0)}).`);
       break;
   }
 }
@@ -3870,33 +4373,33 @@ import { getModels } from "@mariozechner/pi-ai";
 
 // src/cli/ui.ts
 import os2 from "os";
-import path9 from "path";
-import * as clack4 from "@clack/prompts";
+import path11 from "path";
+import * as clack5 from "@clack/prompts";
 function createCliPrompts() {
   return {
-    intro: (message) => clack4.intro(message),
-    outro: (message) => clack4.outro(message),
-    note: (message, title) => clack4.note(message, title),
-    cancel: (message) => clack4.cancel(message),
-    isCancel: clack4.isCancel,
+    intro: (message) => clack5.intro(message),
+    outro: (message) => clack5.outro(message),
+    note: (message, title) => clack5.note(message, title),
+    cancel: (message) => clack5.cancel(message),
+    isCancel: clack5.isCancel,
     select: async (options) => {
-      return await clack4.select({
+      return await clack5.select({
         message: options.message,
         options: options.options,
         ...options.initialValue !== void 0 ? { initialValue: options.initialValue } : {}
       });
     },
     confirm: async (options) => {
-      return await clack4.confirm(options);
+      return await clack5.confirm(options);
     },
     password: async (options) => {
-      return await clack4.password(options);
+      return await clack5.password(options);
     },
     text: async (options) => {
-      return await clack4.text(options);
+      return await clack5.text(options);
     },
-    spinner: () => clack4.spinner(),
-    log: clack4.log
+    spinner: () => clack5.spinner(),
+    log: clack5.log
   };
 }
 var cliPrompts = createCliPrompts();
@@ -3909,12 +4412,12 @@ function resolveUserPath2(value) {
     return os2.homedir();
   }
   if (trimmed.startsWith("~/")) {
-    return path9.join(os2.homedir(), trimmed.slice(2));
+    return path11.join(os2.homedir(), trimmed.slice(2));
   }
   if (trimmed.startsWith("~\\")) {
-    return path9.join(os2.homedir(), trimmed.slice(2));
+    return path11.join(os2.homedir(), trimmed.slice(2));
   }
-  return path9.resolve(trimmed);
+  return path11.resolve(trimmed);
 }
 function formatPathForDisplay(filePath) {
   const home = os2.homedir();
@@ -3999,7 +4502,7 @@ async function withTimeout(promise, timeoutMs, message) {
   });
   return await Promise.race([promise, timeout]);
 }
-function formatUnknownError4(error) {
+function formatUnknownError6(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
@@ -4285,7 +4788,7 @@ function getSetupReadiness(config, env = process.env) {
   } catch (error) {
     return {
       ready: false,
-      guidance: formatUnknownError4(error)
+      guidance: formatUnknownError6(error)
     };
   }
 }
@@ -4629,14 +5132,14 @@ async function selectAuthModel(prompts, runtime, auth, existingModel) {
 async function verifyManualPrimaryCredential(prompts, runtime, auth, provider, initialApiKey, probeModel) {
   let apiKey = initialApiKey;
   while (true) {
-    const spinner5 = prompts.spinner();
-    spinner5.start(`Testing ${describeAuthMethod(auth)}...`);
+    const spinner6 = prompts.spinner();
+    spinner6.start(`Testing ${describeAuthMethod(auth)}...`);
     const result = await runtime.testLlmConnection(provider, probeModel, apiKey);
     if (result.ok) {
-      spinner5.stop(ui.success("Connection verified"));
+      spinner6.stop(ui.success("Connection verified"));
       return { apiKey, verified: true };
     }
-    spinner5.stop(ui.error(`Connection failed: ${result.error ?? "unknown error"}`));
+    spinner6.stop(ui.error(`Connection failed: ${result.error ?? "unknown error"}`));
     const action = await prompts.select({
       message: "The provider connection test failed. What do you want to do?",
       options: [
@@ -4667,14 +5170,14 @@ async function verifyManualPrimaryCredential(prompts, runtime, auth, provider, i
 }
 async function verifyDetectedPrimaryCredential(prompts, runtime, auth, provider, apiKey, probeModel) {
   while (true) {
-    const spinner5 = prompts.spinner();
-    spinner5.start(`Testing ${describeAuthMethod(auth)}...`);
+    const spinner6 = prompts.spinner();
+    spinner6.start(`Testing ${describeAuthMethod(auth)}...`);
     const result = await runtime.testLlmConnection(provider, probeModel, apiKey);
     if (result.ok) {
-      spinner5.stop(ui.success("Connection verified"));
+      spinner6.stop(ui.success("Connection verified"));
       return { apiKey, verified: true };
     }
-    spinner5.stop(ui.error(`Connection failed: ${result.error ?? "unknown error"}`));
+    spinner6.stop(ui.error(`Connection failed: ${result.error ?? "unknown error"}`));
     const action = await prompts.select({
       message: "The provider connection test failed. What do you want to do?",
       options: [
@@ -4693,14 +5196,14 @@ async function verifyDetectedPrimaryCredential(prompts, runtime, auth, provider,
 }
 async function verifySharedEmbeddingKey(prompts, runtime, apiKey) {
   while (true) {
-    const spinner5 = prompts.spinner();
-    spinner5.start(`Testing embeddings with OpenAI ${EMBEDDING_MODEL}...`);
+    const spinner6 = prompts.spinner();
+    spinner6.start(`Testing embeddings with OpenAI ${EMBEDDING_MODEL}...`);
     const result = await runtime.testEmbeddingConnection(apiKey, EMBEDDING_MODEL);
     if (result.ok) {
-      spinner5.stop(ui.success("Embeddings verified"));
+      spinner6.stop(ui.success("Embeddings verified"));
       return { verified: true };
     }
-    spinner5.stop(ui.error(`Embeddings test failed: ${result.error ?? "unknown error"}`));
+    spinner6.stop(ui.error(`Embeddings test failed: ${result.error ?? "unknown error"}`));
     const action = await prompts.select({
       message: "The embeddings test failed. What do you want to do?",
       options: [
@@ -4720,14 +5223,14 @@ async function verifySharedEmbeddingKey(prompts, runtime, apiKey) {
 async function verifySeparateEmbeddingKey(prompts, runtime, initialApiKey) {
   let apiKey = initialApiKey;
   while (true) {
-    const spinner5 = prompts.spinner();
-    spinner5.start(`Testing embeddings with OpenAI ${EMBEDDING_MODEL}...`);
+    const spinner6 = prompts.spinner();
+    spinner6.start(`Testing embeddings with OpenAI ${EMBEDDING_MODEL}...`);
     const result = await runtime.testEmbeddingConnection(apiKey, EMBEDDING_MODEL);
     if (result.ok) {
-      spinner5.stop(ui.success("Embeddings verified"));
+      spinner6.stop(ui.success("Embeddings verified"));
       return { apiKey, verified: true };
     }
-    spinner5.stop(ui.error(`Embeddings test failed: ${result.error ?? "unknown error"}`));
+    spinner6.stop(ui.error(`Embeddings test failed: ${result.error ?? "unknown error"}`));
     const action = await prompts.select({
       message: "The embeddings test failed. What do you want to do?",
       options: [
@@ -4865,7 +5368,7 @@ var defaultSetupRuntime = {
     } catch (error) {
       return {
         ok: false,
-        error: formatUnknownError4(error)
+        error: formatUnknownError6(error)
       };
     }
   },
@@ -4880,7 +5383,7 @@ var defaultSetupRuntime = {
     } catch (error) {
       return {
         ok: false,
-        error: formatUnknownError4(error)
+        error: formatUnknownError6(error)
       };
     }
   },
@@ -4935,7 +5438,7 @@ async function runSetupCommand() {
     prompts.outro(`Next: ${ui.bold('agenr recall "test"')} or ${ui.bold("agenr ingest <path>")}`);
   } catch (error) {
     process.exitCode = 1;
-    prompts.log.error(formatUnknownError4(error));
+    prompts.log.error(formatUnknownError6(error));
     prompts.outro(ui.error("Setup failed"));
   }
 }
@@ -4987,8 +5490,8 @@ function formatTokenCount(tokens) {
 
 // src/cli/commands/init/external-commands.ts
 import { execFile, execFileSync } from "child_process";
-import fs6 from "fs/promises";
-import path10 from "path";
+import fs7 from "fs/promises";
+import path12 from "path";
 var OPENCLAW_PLUGIN_PACKAGE = "@agenr/agenr-plugin";
 function execAsync(command, args, options) {
   return new Promise((resolve, reject) => {
@@ -5085,10 +5588,10 @@ async function restartOpenClawGateway() {
   }
 }
 async function writeOpenClawPluginConfig(stateDir, config) {
-  const openclawConfigPath = path10.join(stateDir, "openclaw.json");
+  const openclawConfigPath = path12.join(stateDir, "openclaw.json");
   let root = {};
   try {
-    const raw = await fs6.readFile(openclawConfigPath, "utf8");
+    const raw = await fs7.readFile(openclawConfigPath, "utf8");
     const parsed = JSON.parse(raw);
     if (isRecord(parsed)) {
       root = parsed;
@@ -5114,13 +5617,13 @@ async function writeOpenClawPluginConfig(stateDir, config) {
   } else {
     delete entryConfig.configPath;
   }
-  await fs6.mkdir(stateDir, { recursive: true });
-  await fs6.writeFile(openclawConfigPath, `${JSON.stringify(root, null, 2)}
+  await fs7.mkdir(stateDir, { recursive: true });
+  await fs7.writeFile(openclawConfigPath, `${JSON.stringify(root, null, 2)}
 `, "utf8");
   return openclawConfigPath;
 }
 function shouldPersistPluginConfigPath(dbPath, configPath) {
-  return path10.dirname(dbPath) !== path10.dirname(configPath);
+  return path12.dirname(dbPath) !== path12.dirname(configPath);
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -5147,21 +5650,21 @@ function ensureArrayOfStrings(target, key) {
 }
 
 // src/cli/commands/init/openclaw-detect.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import os3 from "os";
-import path11 from "path";
+import path13 from "path";
 function resolveDefaultOpenClawStateDir() {
-  return path11.join(os3.homedir(), ".openclaw");
+  return path13.join(os3.homedir(), ".openclaw");
 }
-function detectOpenClawInstallation(env = process.env, existsSyncFn = fs7.existsSync) {
+function detectOpenClawInstallation(env = process.env, existsSyncFn = fs8.existsSync) {
   const envStateDir = normalizeOptionalString5(env.OPENCLAW_STATE_DIR) ?? normalizeOptionalString5(env.OPENCLAW_HOME);
   const source = envStateDir ? "environment" : "default";
   const stateDir = envStateDir ? resolveUserPath2(envStateDir) : resolveDefaultOpenClawStateDir();
   return {
     detected: envStateDir !== void 0 || existsSyncFn(stateDir),
     stateDir,
-    configPath: path11.join(stateDir, "openclaw.json"),
-    sessionsRoot: path11.join(stateDir, "agents"),
+    configPath: path13.join(stateDir, "openclaw.json"),
+    sessionsRoot: path13.join(stateDir, "agents"),
     source
   };
 }
@@ -5171,8 +5674,8 @@ function normalizeOptionalString5(value) {
 }
 
 // src/cli/commands/init/session-scanner.ts
-import fs8 from "fs/promises";
-import path12 from "path";
+import fs9 from "fs/promises";
+import path14 from "path";
 async function scanSessionFiles(sessionsRoot, recentDays = 7) {
   const result = {
     totalFiles: 0,
@@ -5197,7 +5700,7 @@ async function scanSessionFiles(sessionsRoot, recentDays = 7) {
     }
     let stat;
     try {
-      stat = await fs8.stat(filePath);
+      stat = await fs9.stat(filePath);
     } catch (error) {
       if (isMissingPathError(error)) {
         continue;
@@ -5215,7 +5718,7 @@ async function scanSessionFiles(sessionsRoot, recentDays = 7) {
   return result;
 }
 function isSessionTranscriptPath(filePath) {
-  return filePath.split(path12.sep).includes("sessions");
+  return filePath.split(path14.sep).includes("sessions");
 }
 function isMissingPathError(error) {
   return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
@@ -5341,7 +5844,7 @@ async function runInitWizard(options = {}) {
             });
             prompts.log.info(`Updated ${formatPathForDisplay(openclawConfigPath)} to enable agenr as the active memory plugin.`);
           } catch (error) {
-            const message = formatUnknownError5(error);
+            const message = formatUnknownError7(error);
             pluginStatus = `Plugin installed, but OpenClaw config update failed: ${message}`;
             prompts.log.warn(`OpenClaw config update failed: ${message}`);
           }
@@ -5358,18 +5861,18 @@ async function runInitWizard(options = {}) {
       scanSpinner.start("Scanning existing OpenClaw sessions...");
       sessionScan = await runtime.scanSessionFiles(detection.sessionsRoot);
       scanSpinner.stop(
-        `Found ${sessionScan.totalFiles} ${pluralize2(sessionScan.totalFiles, "session")} under ${formatPathForDisplay(detection.sessionsRoot)}.`
+        `Found ${sessionScan.totalFiles} ${pluralize3(sessionScan.totalFiles, "session")} under ${formatPathForDisplay(detection.sessionsRoot)}.`
       );
       if (sessionScan.totalFiles === 0) {
         sessionStatus = "No sessions found";
         ingestStatus = "Skipped - no sessions found";
         prompts.log.info("No existing OpenClaw session transcripts were found. You can ingest later once sessions exist.");
       } else if (!setupReady) {
-        sessionStatus = `${sessionScan.totalFiles} ${pluralize2(sessionScan.totalFiles, "session")} found (${sessionScan.recentFiles.length} from last 7 days)`;
+        sessionStatus = `${sessionScan.totalFiles} ${pluralize3(sessionScan.totalFiles, "session")} found (${sessionScan.recentFiles.length} from last 7 days)`;
         ingestStatus = "Skipped - current auth still needs credentials";
         prompts.log.warn(setupReadiness.guidance ?? "Skipping bulk ingest until agenr can resolve working LLM credentials for the selected auth profile.");
       } else {
-        sessionStatus = `${sessionScan.totalFiles} ${pluralize2(sessionScan.totalFiles, "session")} found (${sessionScan.recentFiles.length} from last 7 days)`;
+        sessionStatus = `${sessionScan.totalFiles} ${pluralize3(sessionScan.totalFiles, "session")} found (${sessionScan.recentFiles.length} from last 7 days)`;
         const { provider: extractionProvider, modelId } = resolveModel(activeConfig, "extraction");
         const providerForCost = normalizeSetupProvider(extractionProvider);
         const showUsdEstimate = hasMeteredIngestCost(activeConfig.auth);
@@ -5389,11 +5892,11 @@ async function runInitWizard(options = {}) {
         } else {
           const filesToIngest = ingestChoice === "recent" ? sessionScan.recentFiles : sessionScan.allFiles;
           const ingestResult = await runtime.runBulkIngest(filesToIngest, activeConfig, prompts);
-          ingestStatus = `${ingestResult.filesProcessed} ${pluralize2(ingestResult.filesProcessed, "session")} processed, ${ingestResult.storedEntries} ${pluralize2(ingestResult.storedEntries, "entry", "entries")} stored`;
+          ingestStatus = `${ingestResult.filesProcessed} ${pluralize3(ingestResult.filesProcessed, "session")} processed, ${ingestResult.storedEntries} ${pluralize3(ingestResult.storedEntries, "entry", "entries")} stored`;
           prompts.log.info(
             [
-              formatLabel("Ingested", `${ingestResult.filesProcessed} ${pluralize2(ingestResult.filesProcessed, "session")}`),
-              formatLabel("Stored", `${ingestResult.storedEntries} ${pluralize2(ingestResult.storedEntries, "entry", "entries")}`),
+              formatLabel("Ingested", `${ingestResult.filesProcessed} ${pluralize3(ingestResult.filesProcessed, "session")}`),
+              formatLabel("Stored", `${ingestResult.storedEntries} ${pluralize3(ingestResult.storedEntries, "entry", "entries")}`),
               formatLabel("Failures", `${ingestResult.failedFiles}`),
               formatLabel("Cost", formatCostUsd(ingestResult.totalCostUsd))
             ].join("\n")
@@ -5422,14 +5925,14 @@ async function runInitWizard(options = {}) {
     prompts.outro(buildNextSteps(detection, pluginStatus, gatewayStatus, sessionScan));
   } catch (error) {
     process.exitCode = 1;
-    prompts.log.error(formatUnknownError5(error));
+    prompts.log.error(formatUnknownError7(error));
     prompts.outro(ui.error("Init failed"));
   }
 }
 async function runBulkIngest(files, config, prompts) {
   let database = null;
-  const spinner5 = prompts.spinner();
-  spinner5.start(`Ingesting ${files.length} ${pluralize2(files.length, "session")}... (0/${files.length} extracted)`);
+  const spinner6 = prompts.spinner();
+  spinner6.start(`Ingesting ${files.length} ${pluralize3(files.length, "session")}... (0/${files.length} extracted)`);
   try {
     database = await createDatabase(config.dbPath ?? resolveDbPath(config));
     const { provider, modelId } = resolveModel(config, "extraction");
@@ -5457,17 +5960,17 @@ async function runBulkIngest(files, config, prompts) {
         claimExtractionConfig,
         extractionContext: config.extractionContext,
         onExtractionProgress: (completed, total) => {
-          spinner5.message(`Ingesting sessions... (${completed}/${total} extracted)`);
+          spinner6.message(`Ingesting sessions... (${completed}/${total} extracted)`);
         },
         onBulkWriteProgress: (event) => {
-          spinner5.message(progressMessageForBulkWrite2(event.phase));
+          spinner6.message(progressMessageForBulkWrite2(event.phase));
         }
       }
     );
     const storedEntries = Array.from(result.storeResults.values()).reduce((total, fileResult) => total + (fileResult.storeResult?.stored ?? 0), 0);
     const failedFiles = result.extractionRuns.filter((run) => run.result.error !== void 0).length;
     const totalCostUsd = result.extractionRuns.reduce((total, run) => total + run.usage.totalCost, 0) + result.dedupUsage.totalCost;
-    spinner5.stop(`Ingest complete: ${storedEntries} ${pluralize2(storedEntries, "entry", "entries")} stored.`);
+    spinner6.stop(`Ingest complete: ${storedEntries} ${pluralize3(storedEntries, "entry", "entries")} stored.`);
     return {
       filesProcessed: files.length,
       storedEntries,
@@ -5480,7 +5983,7 @@ async function runBulkIngest(files, config, prompts) {
 }
 function buildIngestChoiceMessage(scan, modelId, recentCost, fullCost, showUsdEstimate) {
   const lines = [
-    `Found ${scan.totalFiles} ${pluralize2(scan.totalFiles, "session")} (${scan.recentFiles.length} from last 7 days).`,
+    `Found ${scan.totalFiles} ${pluralize3(scan.totalFiles, "session")} (${scan.recentFiles.length} from last 7 days).`,
     "",
     showUsdEstimate ? `Estimated extraction cost with ${modelId}:` : `Estimated transcript volume with ${modelId}:`
   ];
@@ -5571,7 +6074,7 @@ function progressMessageForBulkWrite2(phase) {
       return "Bulk ingest finalization complete...";
   }
 }
-function formatUnknownError5(error) {
+function formatUnknownError7(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
@@ -5583,11 +6086,11 @@ function registerInitCommand(program2) {
 }
 
 // src/cli/commands/recall.ts
-import * as clack5 from "@clack/prompts";
+import * as clack6 from "@clack/prompts";
 import { InvalidArgumentError as InvalidArgumentError4, Option as Option3 } from "commander";
 function registerRecallCommand(program2) {
   program2.command("recall <query>").description("Search the knowledge database with the v1 hybrid recall pipeline").addOption(new Option3("--limit <n>", "Max results").argParser(parsePositiveInteger).default(10)).addOption(new Option3("--threshold <n>", "Minimum score cutoff").argParser(parseUnitInterval).default(0)).addOption(new Option3("--budget <n>", "Max token budget").argParser(parsePositiveInteger)).addOption(new Option3("--types <types>", "Comma-separated entry types").argParser(parseEntryTypes)).addOption(new Option3("--tags <tags>", "Comma-separated tags").argParser(parseCsvList)).option("--since <date>", "Only entries after this date (ISO or relative like 7d)").option("--until <date>", "Only entries before this date").option("--around <date>", "Bias results toward this date").option("--as-of <date>", "Resolve current vs prior state at this reference time").addOption(new Option3("--around-radius <n>", "Gaussian radius in days").argParser(parsePositiveNumber).default(14)).option("--verbose", "Show score breakdowns").action(async (query, options) => {
-    clack5.intro(banner());
+    clack6.intro(banner());
     let db = null;
     try {
       const commandInput = normalizeRecallCommand(query, options);
@@ -5597,8 +6100,8 @@ function registerRecallCommand(program2) {
       db = await createDatabase(dbPath);
       const adapter = createRecallAdapter(db, embeddingClient);
       let lastTraceSummary;
-      const spinner5 = clack5.spinner();
-      spinner5.start("Searching knowledge...");
+      const spinner6 = clack6.spinner();
+      spinner6.start("Searching knowledge...");
       const results = await recall(commandInput.request, adapter, {
         trace: {
           reportSummary(summary) {
@@ -5606,24 +6109,24 @@ function registerRecallCommand(program2) {
           }
         }
       });
-      spinner5.stop(`Found ${results.length} ${pluralize3(results.length, "result")}.`);
+      spinner6.stop(`Found ${results.length} ${pluralize4(results.length, "result")}.`);
       if (lastTraceSummary?.degraded.active) {
         for (const notice of lastTraceSummary.degraded.notices) {
-          clack5.log.warn(notice);
+          clack6.log.warn(notice);
         }
       }
       if (results.length === 0) {
-        clack5.outro("No matching entries found.");
+        clack6.outro("No matching entries found.");
         return;
       }
       for (const result of results) {
-        clack5.log.step(formatResult(result, commandInput.verbose, commandInput.request.asOf));
+        clack6.log.step(formatResult(result, commandInput.verbose, commandInput.request.asOf));
       }
-      clack5.outro(`Recall complete: ${results.length} ${pluralize3(results.length, "result")}.`);
+      clack6.outro(`Recall complete: ${results.length} ${pluralize4(results.length, "result")}.`);
     } catch (error) {
       process.exitCode = 1;
-      clack5.log.error(formatUnknownError6(error));
-      clack5.outro(ui.error("Recall failed"));
+      clack6.log.error(formatUnknownError8(error));
+      clack6.outro(ui.error("Recall failed"));
     } finally {
       await db?.close();
     }
@@ -5710,10 +6213,10 @@ function formatProvenance(projected) {
   ].filter((value) => value !== void 0);
   return parts.join("  ");
 }
-function pluralize3(value, singular, plural) {
+function pluralize4(value, singular, plural) {
   return value === 1 ? singular : plural ?? `${singular}s`;
 }
-function formatUnknownError6(error) {
+function formatUnknownError8(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
@@ -5721,13 +6224,13 @@ function formatUnknownError6(error) {
 import { InvalidArgumentError as InvalidArgumentError5, Option as Option4 } from "commander";
 
 // src/app/scenarios/claim-keys/runtime.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-import path19 from "path";
+import path21 from "path";
 import { getModel as getModel2 } from "@mariozechner/pi-ai";
 
 // src/adapters/db/surgeon-run-log.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/core/surgeon/domain/pass-types.ts
 var SURGEON_PASS_TYPES = ["claim_key_quality", "proposal_resolution", "retirement", "supersession"];
@@ -5766,7 +6269,7 @@ function resolveSurgeonProposalApplyTarget(proposal) {
 var SURGEON_RUN_STATUSES = ["running", "completed", "failed", "aborted", "budget_exhausted", "cost_capped", "no_work", "stalled"];
 var SURGEON_PROPOSAL_REVIEW_STATUSES = ["open", "applied", "rejected"];
 async function createSurgeonRun(executor, run) {
-  const id = randomUUID();
+  const id = randomUUID2();
   const startedAt = normalizeTimestamp(run.startedAt) ?? (/* @__PURE__ */ new Date()).toISOString();
   await executor.execute({
     sql: `
@@ -5844,7 +6347,7 @@ async function logSurgeonAction(executor, action) {
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `,
     args: [
-      action.id.trim().length > 0 ? action.id.trim() : randomUUID(),
+      action.id.trim().length > 0 ? action.id.trim() : randomUUID2(),
       action.runId.trim(),
       action.actionType,
       entryIds[0] ?? null,
@@ -5943,7 +6446,7 @@ async function logSurgeonProposal(executor, proposal) {
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `,
     args: [
-      proposal.id.trim().length > 0 ? proposal.id.trim() : randomUUID(),
+      proposal.id.trim().length > 0 ? proposal.id.trim() : randomUUID2(),
       proposal.runId.trim(),
       logicalIssue.groupId,
       logicalIssue.issueKind,
@@ -7209,9 +7712,9 @@ function createSurgeonPort(executor) {
 }
 
 // src/app/surgeon/service.ts
-import { randomUUID as randomUUID8 } from "crypto";
-import fs10 from "fs";
-import path14 from "path";
+import { randomUUID as randomUUID9 } from "crypto";
+import fs11 from "fs";
+import path16 from "path";
 import { runAgentLoop } from "@mariozechner/pi-agent-core";
 
 // src/core/surgeon/domain/run-presets.ts
@@ -7269,7 +7772,7 @@ function normalizeUsageAmount(value) {
 }
 
 // src/app/surgeon/claim-key-quality.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/core/claim-key-slot-resonance.ts
 var FAMILY_GENERIC_TOKEN_MIN_COUNT = 3;
@@ -8445,7 +8948,7 @@ async function runClaimKeyQualityPass(options, deps) {
     }
     applyClaimKeyLifecycle(actual, lifecycle);
     await deps.port.logRunAction({
-      id: randomUUID2(),
+      id: randomUUID3(),
       runId: options.runId,
       actionType: "update_entry",
       entryIds: [entryId],
@@ -8472,7 +8975,7 @@ async function runClaimKeyQualityPass(options, deps) {
   async function persistProposal(proposal, audit) {
     await deps.port.logRunProposal(proposal);
     await deps.port.logRunAction({
-      id: randomUUID2(),
+      id: randomUUID3(),
       runId: options.runId,
       actionType: "flag_review",
       entryIds: proposal.entryIds,
@@ -9357,7 +9860,7 @@ function restoreClaimKeyLifecycle(entry, snapshot) {
 }
 function createProposal(input) {
   return {
-    id: randomUUID2(),
+    id: randomUUID3(),
     ...input,
     entryIds: normalizeStringArray3(input.entryIds),
     currentClaimKeys: normalizeStringArray3(input.currentClaimKeys),
@@ -9689,9 +10192,9 @@ function createSupersessionReviewTracker(input) {
       progress = createEmptySupersessionProgress(input);
       entryToClusterKeys = /* @__PURE__ */ new Map();
     },
-    recordPage({ scope, claimKeyTotal, subjectTotal, clusters }) {
-      const normalizedClaimKeyRemaining = normalizeCount(claimKeyTotal);
-      const normalizedSubjectRemaining = normalizeCount(subjectTotal);
+    recordPage({ scope, claimKeyRemaining, subjectRemaining, clusters }) {
+      const normalizedClaimKeyRemaining = normalizeCount(claimKeyRemaining);
+      const normalizedSubjectRemaining = normalizeCount(subjectRemaining);
       const nextClaimKeyViewed = new Set(progress.claimKeyViewedKeys);
       const nextSubjectViewed = new Set(progress.subjectViewedKeys);
       const nextEntryMap = cloneEntryClusterMap(entryToClusterKeys);
@@ -9873,7 +10376,7 @@ function normalizeOptionalCount(value) {
 }
 
 // src/app/surgeon/proposal-review.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 async function loadActiveProposalEntries(proposal, getEntry2) {
   const activeEntries = [];
   const inactiveEntryIds = [];
@@ -9913,7 +10416,7 @@ async function applyProposalToEntries(input, deps) {
   }
   if (updatedEntryIds.length > 0) {
     await deps.logRunAction({
-      id: randomUUID3(),
+      id: randomUUID4(),
       runId: input.actionRunId ?? input.proposal.runId,
       actionType: "update_entry",
       entryIds: updatedEntryIds,
@@ -9937,8 +10440,8 @@ async function applyProposalToEntries(input, deps) {
 }
 
 // src/app/surgeon/trace-logger.ts
-import fs9 from "fs";
-import path13 from "path";
+import fs10 from "fs";
+import path15 from "path";
 var TRACE_MAX_STRING_LENGTH = 320;
 var TRACE_MAX_ARRAY_ITEMS = 12;
 var TRACE_MAX_OBJECT_KEYS = 20;
@@ -10146,8 +10649,8 @@ function appendTrace(tracePath, payload, logger) {
     return;
   }
   try {
-    fs9.mkdirSync(path13.dirname(tracePath), { recursive: true });
-    fs9.appendFileSync(tracePath, `${JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...payload })}
+    fs10.mkdirSync(path15.dirname(tracePath), { recursive: true });
+    fs10.appendFileSync(tracePath, `${JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...payload })}
 `, "utf8");
   } catch (error) {
     logger.warn(`failed to write trace file ${tracePath}: ${formatError2(error)}`);
@@ -10557,7 +11060,7 @@ function getSurgeonSupersessionPassPrompt() {
 }
 
 // src/app/surgeon/tools/complete.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { Type } from "@sinclair/typebox";
 
 // src/app/surgeon/tools/shared.ts
@@ -10616,7 +11119,7 @@ function createCompletePassTool(deps) {
           deps.completionGuards?.supersession.markAdjudicated([entryId]);
         }
         await deps.recordRunAction({
-          id: randomUUID4(),
+          id: randomUUID5(),
           runId: deps.runId,
           actionType: "skip",
           entryIds: entryId ? [entryId] : [],
@@ -11207,7 +11710,7 @@ function normalizeOptionalString10(value) {
 }
 
 // src/app/surgeon/tools/supersession-claim.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { Type as Type7 } from "@sinclair/typebox";
 var ASSIGN_CLAIM_KEY_SCHEMA = Type7.Object({
   entry_id: Type7.String({ minLength: 1 }),
@@ -11286,7 +11789,7 @@ function createAssignClaimKeyTool(deps) {
       if (updated) {
         deps.completionGuards?.supersession.markAdjudicated([entry.id]);
         await deps.recordRunAction({
-          id: randomUUID5(),
+          id: randomUUID6(),
           runId: deps.runId,
           actionType: "update_entry",
           entryIds: [entry.id],
@@ -11307,7 +11810,7 @@ function createAssignClaimKeyTool(deps) {
 }
 
 // src/app/surgeon/tools/supersession-link.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { Type as Type8 } from "@sinclair/typebox";
 var LINK_SUPERSESSION_SCHEMA = Type8.Object({
   old_entry_id: Type8.String({ minLength: 1, description: "Entry being superseded." }),
@@ -11418,7 +11921,7 @@ function createLinkSupersessionTool(deps) {
       }
       deps.completionGuards?.supersession.markAdjudicated([oldEntryId, newEntryId]);
       await deps.recordRunAction({
-        id: randomUUID6(),
+        id: randomUUID7(),
         runId: deps.runId,
         actionType: "resolve_conflict",
         entryIds: [oldEntryId, newEntryId],
@@ -11519,10 +12022,13 @@ function createQuerySupersessionCandidatesTool(deps) {
       const subjectClusterCount = scope === "claim_key" ? progress?.subjectClustersRemaining ?? counts.subjectCount : pendingSubjectClusters.length;
       const allClusters = scope === "claim_key" ? pendingClaimKeyClusters : scope === "subject" ? pendingSubjectClusters : [...pendingClaimKeyClusters, ...pendingSubjectClusters];
       const clusters = allClusters.slice(offset, offset + limit);
+      const remainingClusters = allClusters.slice(Math.min(allClusters.length, offset + clusters.length));
+      const claimKeyRemaining = scope === "subject" ? claimKeyClusterCount : countClustersByGrouping(remainingClusters, "claim_key");
+      const subjectRemaining = scope === "claim_key" ? subjectClusterCount : countClustersByGrouping(remainingClusters, "subject");
       deps.completionGuards?.supersession.recordPage({
         scope,
-        claimKeyTotal: claimKeyClusterCount,
-        subjectTotal: subjectClusterCount,
+        claimKeyRemaining,
+        subjectRemaining,
         clusters
       });
       if (clusters.length === 0) {
@@ -11590,9 +12096,18 @@ function normalizeOptionalString11(value) {
   const normalized = value?.trim();
   return normalized ? normalized : void 0;
 }
+function countClustersByGrouping(clusters, groupedBy) {
+  let count = 0;
+  for (const cluster of clusters) {
+    if (cluster.groupedBy === groupedBy) {
+      count += 1;
+    }
+  }
+  return count;
+}
 
 // src/app/surgeon/tools/supersession-validity.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { Type as Type10 } from "@sinclair/typebox";
 var SET_VALIDITY_SCHEMA = Type10.Object({
   entry_id: Type10.String({ minLength: 1 }),
@@ -11701,7 +12216,7 @@ function createSetValidityTool(deps) {
       if (updated) {
         deps.completionGuards?.supersession.markAdjudicated([entry.id]);
         await deps.recordRunAction({
-          id: randomUUID7(),
+          id: randomUUID8(),
           runId: deps.runId,
           actionType: "update_entry",
           entryIds: [entry.id],
@@ -12561,7 +13076,7 @@ async function runSurgeon(options, deps) {
               const entryIds = extractEntryIds(context.args);
               const reasoning = extractActionReasoning(context.assistantMessage, context.args, context.result.details, context.toolCall.name);
               const action = {
-                id: randomUUID8(),
+                id: randomUUID9(),
                 runId,
                 actionType,
                 entryIds,
@@ -12684,8 +13199,8 @@ function resolveTracePath(tracePath, passType, runId) {
     return void 0;
   }
   try {
-    if (fs10.statSync(tracePath).isDirectory()) {
-      return path14.join(tracePath, `surgeon-${passType}-${runId}.jsonl`);
+    if (fs11.statSync(tracePath).isDirectory()) {
+      return path16.join(tracePath, `surgeon-${passType}-${runId}.jsonl`);
     }
   } catch {
     return tracePath;
@@ -12901,7 +13416,7 @@ async function runProposalResolutionPass(input, deps) {
     }
     if (!input.apply) {
       await deps.recordRunAction({
-        id: randomUUID8(),
+        id: randomUUID9(),
         runId: input.runId,
         actionType: "update_entry",
         entryIds: proposalEntryIds,
@@ -13687,7 +14202,7 @@ function isFixtureError(value) {
 
 // src/app/scenarios/claim-keys/fixture-loader.ts
 import { readFile } from "fs/promises";
-import path16 from "path";
+import path18 from "path";
 
 // src/app/scenarios/claim-keys/validation/shared.ts
 var SUPPORTED_PROPOSAL_SCOPES = ["single_entry", "cluster"];
@@ -14017,12 +14532,12 @@ function readRequiredTrue(value, label, filePath) {
 
 // src/app/scenarios/claim-keys/validation/scenario-root.ts
 import { existsSync } from "fs";
-import path15 from "path";
+import path17 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var SCENARIO_ROOT_SEGMENTS = ["tests", "scenarios", "claim-keys"];
 function getDefaultClaimKeyScenarioRoot(options = {}) {
-  const moduleDirectory = path15.dirname(fileURLToPath2(options.moduleUrl ?? import.meta.url));
-  const startDirectories = Array.from(/* @__PURE__ */ new Set([path15.resolve(options.cwd ?? process.cwd()), moduleDirectory]));
+  const moduleDirectory = path17.dirname(fileURLToPath2(options.moduleUrl ?? import.meta.url));
+  const startDirectories = Array.from(/* @__PURE__ */ new Set([path17.resolve(options.cwd ?? process.cwd()), moduleDirectory]));
   for (const startDirectory of startDirectories) {
     const discovered = findScenarioRootFrom(startDirectory);
     if (discovered) {
@@ -14044,24 +14559,24 @@ function readOptionalRelativeFixturePath(value, label, filePath, rootDir) {
   return readRelativeFixturePath(value, label, filePath, rootDir);
 }
 function normalizeFixturePath(relativePath, rootDir, filePath, label) {
-  if (path15.isAbsolute(relativePath)) {
+  if (path17.isAbsolute(relativePath)) {
     throw new Error(`Invalid scenario ${filePath}: ${label} must be relative to the scenario root.`);
   }
-  const resolved = path15.resolve(rootDir, relativePath);
-  const relative = path15.relative(rootDir, resolved);
-  if (relative.startsWith("..") || path15.isAbsolute(relative)) {
+  const resolved = path17.resolve(rootDir, relativePath);
+  const relative = path17.relative(rootDir, resolved);
+  if (relative.startsWith("..") || path17.isAbsolute(relative)) {
     throw new Error(`Invalid scenario ${filePath}: ${label} must stay inside the scenario root.`);
   }
-  return relative.split(path15.sep).join("/");
+  return relative.split(path17.sep).join("/");
 }
 function findScenarioRootFrom(startDirectory) {
-  let currentDirectory = path15.resolve(startDirectory);
+  let currentDirectory = path17.resolve(startDirectory);
   while (true) {
-    const candidate = path15.join(currentDirectory, ...SCENARIO_ROOT_SEGMENTS);
+    const candidate = path17.join(currentDirectory, ...SCENARIO_ROOT_SEGMENTS);
     if (existsSync(candidate)) {
       return candidate;
     }
-    const parentDirectory = path15.dirname(currentDirectory);
+    const parentDirectory = path17.dirname(currentDirectory);
     if (parentDirectory === currentDirectory) {
       return void 0;
     }
@@ -14404,7 +14919,7 @@ async function loadSeedFixtureEntries(rootDir, relativePath) {
   if (!relativePath) {
     return null;
   }
-  const parsed = await readJsonFile(path16.join(rootDir, relativePath));
+  const parsed = await readJsonFile(path18.join(rootDir, relativePath));
   const seedEntries = readSeedEntries(parsed, relativePath);
   if (!seedEntries) {
     throw new Error(`Seed fixture ${relativePath} must contain an array.`);
@@ -14467,7 +14982,7 @@ async function readArrayFixture(rootDir, relativePath) {
   if (!relativePath) {
     return null;
   }
-  const parsed = await readJsonFile(path16.join(rootDir, relativePath));
+  const parsed = await readJsonFile(path18.join(rootDir, relativePath));
   if (!Array.isArray(parsed)) {
     throw new Error(`Fixture file ${relativePath} must contain a JSON array.`);
   }
@@ -14521,7 +15036,7 @@ function readExtractionImportance(value, label, filePath) {
 
 // src/app/scenarios/claim-keys/load-scenarios.ts
 import { readdir, readFile as readFile2 } from "fs/promises";
-import path17 from "path";
+import path19 from "path";
 
 // src/app/scenarios/claim-keys/validation/expectations.ts
 var EXPECTATION_KEYS = /* @__PURE__ */ new Set(["warnings", "rows", "rowCount", "proposals", "storeResult", "surgeonSummary"]);
@@ -14783,13 +15298,13 @@ function validateClaimKeyScenario(input, filePath, rootDir = getDefaultClaimKeyS
 async function discoverScenarioFiles(rootDir) {
   const files = [];
   for (const kind of SUPPORTED_KINDS2) {
-    const directory = path17.join(rootDir, kind);
+    const directory = path19.join(rootDir, kind);
     const entries = await readdir(directory, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".json")) {
         continue;
       }
-      files.push(path17.join(directory, entry.name));
+      files.push(path19.join(directory, entry.name));
     }
   }
   return files.sort();
@@ -14807,11 +15322,11 @@ async function readScenarioJsonFile(filePath) {
 
 // src/app/scenarios/claim-keys/sandbox.ts
 import { mkdir, rm } from "fs/promises";
-import path18 from "path";
+import path20 from "path";
 var SANDBOX_DB_FILENAME = "knowledge.db";
 async function createClaimKeyScenarioSandbox(root) {
-  const resolvedRoot = path18.resolve(root);
-  const dbPath = path18.join(resolvedRoot, SANDBOX_DB_FILENAME);
+  const resolvedRoot = path20.resolve(root);
+  const dbPath = path20.join(resolvedRoot, SANDBOX_DB_FILENAME);
   await mkdir(resolvedRoot, { recursive: true });
   await removeDatabaseFiles(dbPath);
   const database = await createDatabase(dbPath);
@@ -14833,7 +15348,7 @@ async function removeDatabaseFiles(dbPath) {
 }
 
 // src/app/scenarios/claim-keys/seed.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 var DEFAULT_SCENARIO_CREATED_AT = "2026-04-01T10:00:00.000Z";
 function buildClaimKeyScenarioSeedEntry(seedEntry) {
   const seedClaimKey = normalizeOptionalString12(seedEntry.claim_key);
@@ -14843,7 +15358,7 @@ function buildClaimKeyScenarioSeedEntry(seedEntry) {
   const createdAt = seedEntry.created_at?.trim() || validatedInput.created_at || DEFAULT_SCENARIO_CREATED_AT;
   const updatedAt = seedEntry.updated_at?.trim() || createdAt;
   return {
-    id: seedEntry.id?.trim() || randomUUID9(),
+    id: seedEntry.id?.trim() || randomUUID10(),
     type: validatedInput.type,
     subject: validatedInput.subject,
     content: validatedInput.content,
@@ -15002,7 +15517,7 @@ async function listClaimKeyScenariosRuntime(options = {}) {
 }
 async function runClaimKeyScenariosRuntime(options = {}) {
   const runId = buildRunId();
-  const artifactRoot = path19.resolve(DEFAULT_ARTIFACT_ROOT, runId);
+  const artifactRoot = path21.resolve(DEFAULT_ARTIFACT_ROOT, runId);
   await mkdir2(artifactRoot, { recursive: true });
   let scenarios;
   try {
@@ -15054,11 +15569,11 @@ function filterClaimKeyScenarios(scenarios, options) {
 }
 async function runOneClaimKeyScenario(scenario, options) {
   const startedAt = Date.now();
-  const scenarioArtifactRoot = path19.join(options.artifactRoot, scenario.id);
-  const sandboxRoot = path19.join(scenarioArtifactRoot, "sandbox");
+  const scenarioArtifactRoot = path21.join(options.artifactRoot, scenario.id);
+  const sandboxRoot = path21.join(scenarioArtifactRoot, "sandbox");
   const warnings = [];
   await mkdir2(scenarioArtifactRoot, { recursive: true });
-  await writeJson(path19.join(scenarioArtifactRoot, "scenario.json"), scenario);
+  await writeJson(path21.join(scenarioArtifactRoot, "scenario.json"), scenario);
   let actual = {
     warnings: [],
     rows: [],
@@ -15171,7 +15686,7 @@ async function runIngestScenario(scenario, database, warnings, rootDir) {
     throw new Error(`Scenario ${scenario.id} is missing extraction fixture responses.`);
   }
   const result = await ingestPath(
-    path19.join(rootDir, scenario.input.transcriptFile),
+    path21.join(rootDir, scenario.input.transcriptFile),
     {
       files: localTranscriptFiles,
       transcript: openClawTranscriptParser,
@@ -15313,20 +15828,20 @@ async function loadLatestSurgeonProposals(database, runId) {
   }));
 }
 async function writeScenarioArtifacts(scenarioArtifactRoot, actual, assertionResults, diffSummary) {
-  await writeJson(path19.join(scenarioArtifactRoot, "actual.json"), actual);
-  await writeJson(path19.join(scenarioArtifactRoot, "diff.json"), {
+  await writeJson(path21.join(scenarioArtifactRoot, "actual.json"), actual);
+  await writeJson(path21.join(scenarioArtifactRoot, "diff.json"), {
     assertions: assertionResults,
     diffSummary
   });
-  await writeJson(path19.join(scenarioArtifactRoot, "warnings.json"), actual.warnings);
+  await writeJson(path21.join(scenarioArtifactRoot, "warnings.json"), actual.warnings);
   if (actual.storeResult) {
-    await writeJson(path19.join(scenarioArtifactRoot, "store-result.json"), actual.storeResult);
+    await writeJson(path21.join(scenarioArtifactRoot, "store-result.json"), actual.storeResult);
   }
   if (actual.surgeonSummary) {
-    await writeJson(path19.join(scenarioArtifactRoot, "surgeon-summary.json"), actual.surgeonSummary);
+    await writeJson(path21.join(scenarioArtifactRoot, "surgeon-summary.json"), actual.surgeonSummary);
   }
   if (actual.proposals.length > 0) {
-    await writeJson(path19.join(scenarioArtifactRoot, "proposals.json"), actual.proposals);
+    await writeJson(path21.join(scenarioArtifactRoot, "proposals.json"), actual.proposals);
   }
 }
 async function writeJson(filePath, value) {
@@ -15334,7 +15849,7 @@ async function writeJson(filePath, value) {
 `, "utf8");
 }
 function buildRunId() {
-  return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/gu, "-")}-${randomUUID10().slice(0, 8)}`;
+  return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/gu, "-")}-${randomUUID11().slice(0, 8)}`;
 }
 function toConfigurationError(error) {
   if (error instanceof ClaimKeyScenarioConfigurationError) {
@@ -15361,7 +15876,7 @@ function registerScenariosCommand(program2, deps = {}) {
 ` : renderScenarioList(scenarios));
     } catch (error) {
       process.exitCode = error instanceof ClaimKeyScenarioConfigurationError ? 2 : 1;
-      stderr.write(`Scenario list failed: ${formatUnknownError7(error)}
+      stderr.write(`Scenario list failed: ${formatUnknownError9(error)}
 `);
     }
   });
@@ -15384,7 +15899,7 @@ function registerScenariosCommand(program2, deps = {}) {
 ` : renderScenarioRunSummary(summary));
     } catch (error) {
       process.exitCode = error instanceof ClaimKeyScenarioConfigurationError ? 2 : 1;
-      stderr.write(`Scenario run failed: ${formatUnknownError7(error)}
+      stderr.write(`Scenario run failed: ${formatUnknownError9(error)}
 `);
     }
   });
@@ -15449,7 +15964,7 @@ function parseScenarioKind(value) {
   }
   return normalized;
 }
-function formatUnknownError7(error) {
+function formatUnknownError9(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
@@ -15458,7 +15973,7 @@ import { InvalidArgumentError as InvalidArgumentError6, Option as Option5 } from
 
 // src/app/surgeon/runtime.ts
 import { copyFile, mkdir as mkdir3 } from "fs/promises";
-import path20 from "path";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { getModel as getModel3 } from "@mariozechner/pi-ai";
 var DEFAULT_SURGEON_PROVIDER = "openai";
@@ -15703,7 +16218,7 @@ async function backupDatabaseFile(dbPath) {
   }
   const sourcePath = resolveFilesystemPath(dbPath);
   const backupPath = `${sourcePath}.surgeon-backup-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replaceAll(".", "-")}`;
-  await mkdir3(path20.dirname(backupPath), { recursive: true });
+  await mkdir3(path22.dirname(backupPath), { recursive: true });
   await copyFile(sourcePath, backupPath);
   await copySidecarIfPresent(`${sourcePath}-wal`, `${backupPath}-wal`);
   await copySidecarIfPresent(`${sourcePath}-shm`, `${backupPath}-shm`);
@@ -15721,12 +16236,12 @@ async function copySidecarIfPresent(sourcePath, targetPath) {
 }
 function resolveFilesystemPath(value) {
   if (!value.startsWith("file:")) {
-    return path20.resolve(value);
+    return path22.resolve(value);
   }
   try {
     return fileURLToPath3(value);
   } catch {
-    return path20.resolve(value.slice("file:".length));
+    return path22.resolve(value.slice("file:".length));
   }
 }
 function isMissingFileError2(error) {
@@ -15778,7 +16293,7 @@ function registerSurgeonCommand(program2) {
 ` : renderRunResult(result, commandInput.apply));
     } catch (error) {
       process.exitCode = 1;
-      process.stderr.write(`Surgeon run failed: ${formatUnknownError8(error)}
+      process.stderr.write(`Surgeon run failed: ${formatUnknownError10(error)}
 `);
     } finally {
       display?.dispose();
@@ -15793,7 +16308,7 @@ function registerSurgeonCommand(program2) {
       process.stdout.write(renderStatus(result));
     } catch (error) {
       process.exitCode = 1;
-      process.stderr.write(`Failed to load surgeon status: ${formatUnknownError8(error)}
+      process.stderr.write(`Failed to load surgeon status: ${formatUnknownError10(error)}
 `);
     }
   });
@@ -15807,7 +16322,7 @@ function registerSurgeonCommand(program2) {
       process.stdout.write(renderHistory(runs, limit));
     } catch (error) {
       process.exitCode = 1;
-      process.stderr.write(`Failed to load surgeon history: ${formatUnknownError8(error)}
+      process.stderr.write(`Failed to load surgeon history: ${formatUnknownError10(error)}
 `);
     }
   });
@@ -15834,7 +16349,7 @@ function registerSurgeonCommand(program2) {
       );
     } catch (error) {
       process.exitCode = 1;
-      process.stderr.write(`Failed to load surgeon backlog: ${formatUnknownError8(error)}
+      process.stderr.write(`Failed to load surgeon backlog: ${formatUnknownError10(error)}
 `);
     }
   });
@@ -15847,7 +16362,7 @@ function registerSurgeonCommand(program2) {
       process.stdout.write(renderActions(runId, actions));
     } catch (error) {
       process.exitCode = 1;
-      process.stderr.write(`Failed to load surgeon actions: ${formatUnknownError8(error)}
+      process.stderr.write(`Failed to load surgeon actions: ${formatUnknownError10(error)}
 `);
     }
   });
@@ -15860,7 +16375,7 @@ function registerSurgeonCommand(program2) {
       process.stdout.write(renderProposals(runId, proposals));
     } catch (error) {
       process.exitCode = 1;
-      process.stderr.write(`Failed to load surgeon proposals: ${formatUnknownError8(error)}
+      process.stderr.write(`Failed to load surgeon proposals: ${formatUnknownError10(error)}
 `);
     }
   });
@@ -15879,7 +16394,7 @@ function registerSurgeonCommand(program2) {
       process.stdout.write(renderProposalReviewResult(result));
     } catch (error) {
       process.exitCode = 1;
-      process.stderr.write(`Failed to review surgeon proposal: ${formatUnknownError8(error)}
+      process.stderr.write(`Failed to review surgeon proposal: ${formatUnknownError10(error)}
 `);
     }
   });
@@ -16004,7 +16519,7 @@ function aggregatePasses(passes) {
   return order.map((passType) => aggregates.get(passType)).filter((value) => value !== void 0);
 }
 function formatPassAggregateLine(aggregate) {
-  const metricParts = [`${aggregate.runs} ${pluralize4(aggregate.runs, "pass")}`, `${aggregate.actionsTaken} ${pluralize4(aggregate.actionsTaken, "action")}`];
+  const metricParts = [`${aggregate.runs} ${pluralize5(aggregate.runs, "pass")}`, `${aggregate.actionsTaken} ${pluralize5(aggregate.actionsTaken, "action")}`];
   if (aggregate.entriesRetired > 0) {
     metricParts.push(`${aggregate.entriesRetired} retired`);
   }
@@ -16022,7 +16537,7 @@ function extractPassSummarySnippet(summary) {
   const candidate = lines.find((line) => !line.endsWith(":") && !line.startsWith("- ")) ?? lines.find((line) => line.startsWith("- "))?.slice(2) ?? lines[0] ?? null;
   return candidate ? truncateDisplayText(candidate, 100) : null;
 }
-function pluralize4(count, singular, plural) {
+function pluralize5(count, singular, plural) {
   if (count === 1) {
     return singular;
   }
@@ -16588,7 +17103,7 @@ function formatElapsed(elapsedMs2) {
 function formatUsd2(value) {
   return `$${value.toFixed(4)}`;
 }
-function formatUnknownError8(error) {
+function formatUnknownError10(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function normalizeOptionalBudget(value) {
@@ -16599,15 +17114,15 @@ function formatOptionalCount(value) {
 }
 function formatPassContextSummary(event) {
   const activeEntryCount = formatOptionalCount(event.workingSetSize);
-  const activeEntriesSummary = `${activeEntryCount} active ${pluralize4(activeEntryCount, "entry", "entries")}`;
+  const activeEntriesSummary = `${activeEntryCount} active ${pluralize5(activeEntryCount, "entry", "entries")}`;
   if (event.passType === "proposal_resolution") {
     const eligibleProposalCount = formatOptionalCount(event.eligibleProposalBacklogCount);
-    return `${activeEntriesSummary} | Proposal backlog: ${eligibleProposalCount} eligible ${pluralize4(eligibleProposalCount, "proposal")}`;
+    return `${activeEntriesSummary} | Proposal backlog: ${eligibleProposalCount} eligible ${pluralize5(eligibleProposalCount, "proposal")}`;
   }
   if (event.passType === "supersession") {
     const claimKeyClusterCount = formatOptionalCount(event.supersessionClaimKeyCount);
     const subjectClusterCount = formatOptionalCount(event.supersessionSubjectCount);
-    return `${activeEntriesSummary} | Supersession remaining: ${claimKeyClusterCount} claim_key ${pluralize4(claimKeyClusterCount, "cluster")}, ${subjectClusterCount} subject ${pluralize4(subjectClusterCount, "cluster")}`;
+    return `${activeEntriesSummary} | Supersession remaining: ${claimKeyClusterCount} claim_key ${pluralize5(claimKeyClusterCount, "cluster")}, ${subjectClusterCount} subject ${pluralize5(subjectClusterCount, "cluster")}`;
   }
   if (event.passType === "retirement") {
     const actionableCount = formatOptionalCount(event.retirementAvailableActionableCount);
@@ -16693,7 +17208,7 @@ function registerTraceCommand(program2) {
       process.stdout.write(options.json === true ? renderTraceJson(trace) : renderTrace(trace));
     } catch (error) {
       process.exitCode = 1;
-      process.stderr.write(`Failed to load trace: ${formatUnknownError9(error)}
+      process.stderr.write(`Failed to load trace: ${formatUnknownError11(error)}
 `);
     }
   });
@@ -16851,7 +17366,7 @@ function truncate2(value, maxChars) {
   }
   return `${value.slice(0, maxChars - 3).trimEnd()}...`;
 }
-function formatUnknownError9(error) {
+function formatUnknownError11(error) {
   return error instanceof Error ? error.message : String(error);
 }