agenr 2.0.0 → 2.1.0

package/dist/cli.js

@@ -31,7 +31,7 @@ import {
   tokenizeGroundingText,
   validateEntriesWithIndexes,
   validateSupersessionRules
-} from "./chunk-XD3446YW.js";
+} from "./chunk-DGV6D6Q3.js";
 import {
   DEFAULT_CLAIM_EXTRACTION_CONCURRENCY,
   DEFAULT_SURGEON_CONTEXT_LIMIT,
@@ -45,6 +45,7 @@ import {
   ENTRY_TYPES,
   EXPIRY_LEVELS,
   applyClaimKeyLifecycle,
+  attachCrossEncoderPort,
   authMethodToProvider,
   buildActiveEntryClause,
   buildClaimKeyLifecycleAuditDetails,
@@ -60,17 +61,19 @@ import {
   configFileExists,
   createDatabase,
   createEmbeddingClient,
+  createLlmClient,
+  createOpenAICrossEncoder,
   createRecallAdapter,
   deserializeTags,
   getAuthMethodDefinition,
   getEntry,
   getLastBulkIngestAt,
   insertEntry,
-  isAgenrAuthMethod,
   mapEntryRow,
   mergeExplicitClaimKeyMetadata,
   normalizeManualClaimKeyUpdate,
   parseAndNormalizeProcedureYaml,
+  probeLlmCredentials,
   projectClaimCentricRecallEntry,
   readBoolean,
   readConfig,
@@ -82,16 +85,20 @@ import {
   requireClaimSupportMode,
   resolveClaimExtractionConfig,
   resolveConfigPath,
+  resolveCrossEncoderApiKey,
   resolveDbPath,
   resolveEmbeddingApiKey,
   resolveEmbeddingModel,
+  resolveLlmApiKey,
+  resolveLlmCredentials,
+  resolveModel,
   retireEntry,
   supersedeEntry,
   toAgenrConfigInput,
   updateEntry,
   validateTemporalValidityRange,
   writeConfig
-} from "./chunk-Y2BC7RCE.js";
+} from "./chunk-7TDALVPY.js";
 import {
   compactClaimKey,
   describeClaimKeyNormalizationFailure,
@@ -102,7 +109,7 @@ import {
   normalizeClaimKeySegment,
   recall,
   resolveClaimSlotPolicy
-} from "./chunk-MEHOGUZE.js";
+} from "./chunk-6T5RXGIR.js";
 
 // src/cli/main.ts
 import { Command } from "commander";
@@ -235,7 +242,7 @@ function formatUnknownError(error) {
 }
 
 // src/cli/commands/ingest.ts
-import path10 from "path";
+import path9 from "path";
 import * as clack4 from "@clack/prompts";
 
 // src/core/ingestion/parser.ts
@@ -2236,378 +2243,9 @@ function matchesTranscriptFileName(fileName) {
   return GENERIC_TRANSCRIPT_FILE_PATTERN.test(fileName.trim());
 }
 
-// src/adapters/llm.ts
-import { createHash as createHash2 } from "crypto";
-import fs3 from "fs";
-import os from "os";
-import path4 from "path";
-import { createRequire as createRequire2 } from "module";
-import { completeSimple, getEnvApiKey, getModel } from "@mariozechner/pi-ai";
-var DEFAULT_REASONING = "medium";
-var require3 = createRequire2(import.meta.url);
-var getModelWithStrings = getModel;
-function probeLlmCredentials(params) {
-  const candidate = resolveCredentialCandidate(params);
-  if (!candidate) {
-    return {
-      available: false,
-      guidance: credentialSetupGuidance(params.auth)
-    };
-  }
-  return {
-    available: true,
-    source: candidate.source,
-    guidance: "Credentials available.",
-    credentials: {
-      apiKey: candidate.token,
-      source: candidate.source,
-      auth: params.auth
-    }
-  };
-}
-function resolveAuthCredentials(params) {
-  const probe = probeLlmCredentials(params);
-  if (!probe.available || !probe.credentials) {
-    throw new Error(probe.guidance);
-  }
-  return probe.credentials;
-}
-function createLlmClient(provider, modelId, options = {}) {
-  const model = getModelWithStrings(provider, modelId);
-  const metadata = {
-    model,
-    contextWindowTokens: model.contextWindow,
-    maxOutputTokens: model.maxTokens,
-    supportsReasoning: model.reasoning,
-    usage: createEmptyUsageStats2()
-  };
-  const resolvedApiKey = normalizeOptionalString2(options.apiKey);
-  const requestCompletion = async (systemPrompt, userMessage) => {
-    const response = await completeSimple(
-      model,
-      {
-        systemPrompt,
-        messages: [
-          {
-            role: "user",
-            content: userMessage,
-            timestamp: Date.now()
-          }
-        ]
-      },
-      {
-        apiKey: resolvedApiKey,
-        reasoning: metadata.supportsReasoning ? options.reasoning ?? DEFAULT_REASONING : void 0
-      }
-    );
-    accumulateUsage(metadata.usage, response.usage);
-    if (response.stopReason === "error") {
-      throw new Error(response.errorMessage ?? `LLM completion failed for ${provider}/${modelId}.`);
-    }
-    return response;
-  };
-  const complete = async (systemPrompt, userMessage) => {
-    const response = await requestCompletion(systemPrompt, userMessage);
-    return extractText(response);
-  };
-  return {
-    metadata,
-    complete,
-    completeJson: async (systemPrompt, userMessage) => {
-      const response = await requestCompletion(systemPrompt, userMessage);
-      const text2 = extractText(response);
-      return JSON.parse(stripCodeFence3(text2));
-    }
-  };
-}
-function resolveModel(config, stage) {
-  const override = stage === "extraction" ? config?.extractionModel : stage === "dedup" ? config?.dedupModel : stage === "episode" ? config?.episodeModel : config?.claimExtraction?.model ?? config?.extractionModel;
-  return {
-    provider: normalizeOptionalString2(override?.provider) ?? normalizeOptionalString2(config?.provider) ?? "openai",
-    modelId: normalizeOptionalString2(override?.model) ?? normalizeOptionalString2(config?.model) ?? defaultModelForStage(stage)
-  };
-}
-function resolveLlmCredentials(config, provider, env = process.env) {
-  const normalizedProvider = normalizeOptionalString2(provider);
-  if (!normalizedProvider) {
-    throw new Error("Provider is required to resolve LLM credentials.");
-  }
-  const auth = normalizeAuthMethod(config?.auth);
-  if (auth && authMethodToProvider(auth) === normalizedProvider) {
-    return resolveAuthCredentials({
-      auth,
-      storedCredentials: config?.credentials,
-      env
-    });
-  }
-  const fallback = resolveProviderCredentialCandidate(config, normalizedProvider, env);
-  if (fallback) {
-    return {
-      apiKey: fallback.token,
-      source: fallback.source
-    };
-  }
-  if (normalizedProvider === "openai-codex") {
-    throw new Error("No OpenAI subscription credential found. Run `codex auth` or configure `auth` as `openai-api-key`.");
-  }
-  const exampleEnv = normalizedProvider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
-  throw new Error(`No credential found for provider "${normalizedProvider}". Set the appropriate auth method in config or provide ${exampleEnv}.`);
-}
-function resolveLlmApiKey(config, provider, env = process.env) {
-  return resolveLlmCredentials(config, provider, env).apiKey;
-}
-function stripCodeFence3(text2) {
-  const trimmed = text2.trim();
-  const match = /^```(?:json)?\s*([\s\S]+?)\s*```$/i.exec(trimmed);
-  return match?.[1]?.trim() ?? trimmed;
-}
-function defaultModelForStage(stage) {
-  switch (stage) {
-    case "extraction":
-    case "episode":
-    case "claim":
-      return "gpt-5.4-mini";
-    case "dedup":
-      return "gpt-5.4-nano";
-  }
-}
-function normalizeOptionalString2(value) {
-  const trimmed = value?.trim();
-  return trimmed && trimmed.length > 0 ? trimmed : void 0;
-}
-function normalizeAuthMethod(value) {
-  const normalized = normalizeOptionalString2(value);
-  return normalized && isAgenrAuthMethod(normalized) ? normalized : void 0;
-}
-function safeReadJson(filePath) {
-  try {
-    const raw = fs3.readFileSync(filePath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function resolveHomeDir(env) {
-  const home = normalizeOptionalString2(env.HOME);
-  return home ? resolveUserPath(home) : os.homedir();
-}
-function resolveCodexHome(env) {
-  const configured = normalizeOptionalString2(env.CODEX_HOME) ?? "~/.codex";
-  const resolved = resolveUserPath(configured);
-  try {
-    return fs3.realpathSync.native(resolved);
-  } catch {
-    return resolved;
-  }
-}
-function resolveUserPath(value) {
-  const trimmed = value.trim();
-  if (trimmed === "~") {
-    return os.homedir();
-  }
-  if (trimmed.startsWith("~/")) {
-    return path4.join(os.homedir(), trimmed.slice(2));
-  }
-  if (trimmed.startsWith("~\\")) {
-    return path4.join(os.homedir(), trimmed.slice(2));
-  }
-  return path4.resolve(trimmed);
-}
-function parseCodexFromFile(env) {
-  const authPath = path4.join(resolveCodexHome(env), "auth.json");
-  const parsed = safeReadJson(authPath);
-  if (!parsed || typeof parsed !== "object") {
-    return null;
-  }
-  const record = parsed;
-  const tokens = record.tokens;
-  const accessToken = tokens?.access_token;
-  if (typeof accessToken !== "string" || !accessToken.trim()) {
-    return null;
-  }
-  return {
-    token: accessToken.trim(),
-    source: `file:${authPath}`
-  };
-}
-function resolveCodexKeychainAccount(env) {
-  const hash = createHash2("sha256").update(resolveCodexHome(env)).digest("hex");
-  return `cli|${hash.slice(0, 16)}`;
-}
-function parseCodexFromKeychain(env) {
-  if (process.platform !== "darwin") {
-    return null;
-  }
-  try {
-    const account = resolveCodexKeychainAccount(env);
-    const { execSync } = require3("node:child_process");
-    const raw = execSync(`security find-generic-password -s "Codex Auth" -a "${account}" -w`, {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5e3
-    }).trim();
-    const parsed = JSON.parse(raw);
-    const tokens = parsed.tokens;
-    const accessToken = tokens?.access_token;
-    if (typeof accessToken !== "string" || !accessToken.trim()) {
-      return null;
-    }
-    return {
-      token: accessToken.trim(),
-      source: "keychain:Codex Auth"
-    };
-  } catch {
-    return null;
-  }
-}
-function parseClaudeCredentialRecord(parsed, source) {
-  if (!parsed || typeof parsed !== "object") {
-    return null;
-  }
-  const record = parsed;
-  const claudeOauth = record.claudeAiOauth;
-  const accessToken = claudeOauth?.accessToken;
-  if (typeof accessToken !== "string" || !accessToken.trim()) {
-    return null;
-  }
-  return {
-    token: accessToken.trim(),
-    source
-  };
-}
-function parseClaudeFromFiles(env) {
-  const homeDir = resolveHomeDir(env);
-  const candidates = [path4.join(homeDir, ".claude", ".credentials.json"), path4.join(homeDir, ".claude", "credentials.json")];
-  for (const candidate of candidates) {
-    const parsed = safeReadJson(candidate);
-    const resolved = parseClaudeCredentialRecord(parsed, `file:${candidate}`);
-    if (resolved) {
-      return resolved;
-    }
-  }
-  return null;
-}
-function parseClaudeFromKeychain() {
-  if (process.platform !== "darwin") {
-    return null;
-  }
-  try {
-    const { execSync } = require3("node:child_process");
-    const raw = execSync('security find-generic-password -s "Claude Code-credentials" -w', {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5e3
-    }).trim();
-    return parseClaudeCredentialRecord(JSON.parse(raw), "keychain:Claude Code-credentials");
-  } catch {
-    return null;
-  }
-}
-function candidateFromToken(token, source) {
-  const normalized = normalizeOptionalString2(token);
-  if (!normalized) {
-    return null;
-  }
-  return {
-    token: normalized,
-    source
-  };
-}
-function resolveOpenAIApiKeyCandidate(storedCredentials, env) {
-  return candidateFromToken(env.OPENAI_API_KEY, "env:OPENAI_API_KEY") ?? candidateFromToken(storedCredentials?.openaiApiKey, "config:credentials.openaiApiKey");
-}
-function resolveAnthropicApiKeyCandidate(storedCredentials, env) {
-  return candidateFromToken(env.ANTHROPIC_API_KEY, "env:ANTHROPIC_API_KEY") ?? candidateFromToken(storedCredentials?.anthropicApiKey, "config:credentials.anthropicApiKey");
-}
-function resolveAnthropicTokenCandidate(storedCredentials, env) {
-  return candidateFromToken(env.ANTHROPIC_OAUTH_TOKEN, "env:ANTHROPIC_OAUTH_TOKEN") ?? candidateFromToken(storedCredentials?.anthropicOauthToken, "config:credentials.anthropicOauthToken");
-}
-function resolveAnthropicOauthCandidate(env) {
-  return parseClaudeFromFiles(env) ?? parseClaudeFromKeychain();
-}
-function resolveOpenAiSubscriptionCandidate(env) {
-  return parseCodexFromFile(env) ?? parseCodexFromKeychain(env);
-}
-function credentialSetupGuidance(auth) {
-  switch (auth) {
-    case "anthropic-oauth":
-      return "Claude Code credentials not found. Install Claude Code CLI and sign in with `claude`.";
-    case "anthropic-token":
-      return "No Anthropic long-lived token found. Set ANTHROPIC_OAUTH_TOKEN or save credentials.anthropicOauthToken.";
-    case "anthropic-api-key":
-      return "No Anthropic API key found. Set ANTHROPIC_API_KEY or save credentials.anthropicApiKey.";
-    case "openai-subscription":
-      return "Codex CLI credentials not found or expired. Run `codex auth`.";
-    case "openai-api-key":
-      return "No OpenAI API key found. Set OPENAI_API_KEY or save credentials.openaiApiKey.";
-  }
-}
-function resolveCredentialCandidate(params) {
-  const env = params.env ?? process.env;
-  switch (params.auth) {
-    case "anthropic-oauth":
-      return resolveAnthropicOauthCandidate(env);
-    case "anthropic-token":
-      return resolveAnthropicTokenCandidate(params.storedCredentials, env);
-    case "anthropic-api-key":
-      return resolveAnthropicApiKeyCandidate(params.storedCredentials, env);
-    case "openai-subscription":
-      return resolveOpenAiSubscriptionCandidate(env);
-    case "openai-api-key":
-      return resolveOpenAIApiKeyCandidate(params.storedCredentials, env);
-  }
-}
-function resolveProviderCredentialCandidate(config, provider, env) {
-  if (provider === "openai") {
-    return resolveOpenAIApiKeyCandidate(config?.credentials, env);
-  }
-  if (provider === "anthropic") {
-    const auth = normalizeAuthMethod(config?.auth);
-    if (auth && authMethodToProvider(auth) === "anthropic") {
-      return resolveCredentialCandidate({
-        auth,
-        storedCredentials: config?.credentials,
-        env
-      });
-    }
-    return resolveAnthropicApiKeyCandidate(config?.credentials, env);
-  }
-  const envApiKey = getEnvApiKey(provider) ?? getEnvApiKey(provider);
-  return candidateFromToken(envApiKey, `env:${provider}`);
-}
-function createEmptyUsageStats2() {
-  return {
-    calls: 0,
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadTokens: 0,
-    cacheWriteTokens: 0,
-    totalTokens: 0,
-    totalCost: 0
-  };
-}
-function accumulateUsage(target, usage) {
-  target.calls += 1;
-  target.inputTokens += usage.input;
-  target.outputTokens += usage.output;
-  target.cacheReadTokens += usage.cacheRead;
-  target.cacheWriteTokens += usage.cacheWrite;
-  target.totalTokens += usage.totalTokens;
-  target.totalCost += usage.cost.total;
-}
-function extractText(response) {
-  const blocks = [];
-  for (const contentBlock of response.content) {
-    if (contentBlock.type === "text") {
-      blocks.push(contentBlock.text);
-    }
-  }
-  return blocks.join("");
-}
-
 // src/cli/shared/parse.ts
 import { InvalidArgumentError } from "commander";
-function normalizeOptionalString3(value) {
+function normalizeOptionalString2(value) {
   const trimmed = value?.trim();
   return trimmed && trimmed.length > 0 ? trimmed : void 0;
 }
@@ -2615,7 +2253,7 @@ function normalizeStringList(values) {
   const normalizedValues = [];
   const seen = /* @__PURE__ */ new Set();
   for (const value of values ?? []) {
-    const normalized = normalizeOptionalString3(value);
+    const normalized = normalizeOptionalString2(value);
     if (!normalized || seen.has(normalized)) {
       continue;
     }
@@ -2625,7 +2263,7 @@ function normalizeStringList(values) {
   return normalizedValues.length > 0 ? normalizedValues : void 0;
 }
 function collectStringValue(value, previous) {
-  const normalized = normalizeOptionalString3(value);
+  const normalized = normalizeOptionalString2(value);
   if (!normalized) {
     throw new InvalidArgumentError("Value cannot be empty.");
   }
@@ -2677,7 +2315,7 @@ function parseUnitInterval(value) {
   return parsed;
 }
 function parseModelRef(value) {
-  const normalized = normalizeOptionalString3(value);
+  const normalized = normalizeOptionalString2(value);
   if (!normalized) {
     throw new InvalidArgumentError("Model reference cannot be empty.");
   }
@@ -2687,8 +2325,8 @@ function parseModelRef(value) {
       modelId: normalized
     };
   }
-  const provider = normalizeOptionalString3(normalized.slice(0, separatorIndex));
-  const modelId = normalizeOptionalString3(normalized.slice(separatorIndex + 1));
+  const provider = normalizeOptionalString2(normalized.slice(0, separatorIndex));
+  const modelId = normalizeOptionalString2(normalized.slice(separatorIndex + 1));
   if (!provider || !modelId) {
     throw new InvalidArgumentError(`Model reference must look like "provider/model" or "model". Received: ${value}.`);
   }
@@ -2739,13 +2377,13 @@ function timestamp() {
 import { InvalidArgumentError as InvalidArgumentError3, Option as Option2 } from "commander";
 
 // src/cli/commands/ingest-episodes.ts
-import fs5 from "fs/promises";
-import path7 from "path";
+import fs4 from "fs/promises";
+import path6 from "path";
 import * as clack2 from "@clack/prompts";
 import { InvalidArgumentError as InvalidArgumentError2, Option } from "commander";
 
 // src/adapters/db/episode-ingest-support.ts
-import path5 from "path";
+import path4 from "path";
 function createEpisodeIngestSupportPort(executor) {
   return {
     countEntries: async () => countRows(executor, "SELECT COUNT(*) AS count FROM entries"),
@@ -2761,7 +2399,7 @@ async function hasRelevantProvenanceMatch(executor, sampleFiles) {
   if (ingestLogMatches > 0) {
     return true;
   }
-  const basenames = Array.from(new Set(sampleFiles.map((filePath) => path5.basename(filePath))));
+  const basenames = Array.from(new Set(sampleFiles.map((filePath) => path4.basename(filePath))));
   const basenameClauses = basenames.map(() => "(source_file = ? OR source_file LIKE ?)").join(" OR ");
   const basenameArgs = basenames.flatMap((basename) => [basename, `%/${basename}`]);
   const entryMatches = await countRows(executor, `SELECT COUNT(*) AS count FROM entries WHERE source_file IS NOT NULL AND (${basenameClauses})`, basenameArgs);
@@ -2850,17 +2488,17 @@ function normalizeNullableString(value) {
 }
 
 // src/adapters/openclaw/session/transcript-files.ts
-import fs4 from "fs/promises";
-import path6 from "path";
+import fs3 from "fs/promises";
+import path5 from "path";
 var OPENCLAW_TRANSCRIPT_FILE_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl(?:\.(?:reset|deleted)\..+)?$/i;
 async function discoverOpenClawTranscriptFiles(targetPath) {
-  const resolvedTargetPath = path6.resolve(targetPath);
-  const stat = await fs4.stat(resolvedTargetPath);
+  const resolvedTargetPath = path5.resolve(targetPath);
+  const stat = await fs3.stat(resolvedTargetPath);
   if (stat.isFile()) {
-    return matchesOpenClawTranscriptFile(path6.basename(resolvedTargetPath)) ? [resolvedTargetPath] : [];
+    return matchesOpenClawTranscriptFile(path5.basename(resolvedTargetPath)) ? [resolvedTargetPath] : [];
   }
-  const entries = await fs4.readdir(resolvedTargetPath, { recursive: true, withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && matchesOpenClawTranscriptFile(entry.name)).map((entry) => path6.resolve(entry.parentPath ?? resolvedTargetPath, entry.name)).sort((left, right) => left.localeCompare(right));
+  const entries = await fs3.readdir(resolvedTargetPath, { recursive: true, withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && matchesOpenClawTranscriptFile(entry.name)).map((entry) => path5.resolve(entry.parentPath ?? resolvedTargetPath, entry.name)).sort((left, right) => left.localeCompare(right));
 }
 var openClawTranscriptFiles = {
   discoverFiles: discoverOpenClawTranscriptFiles
@@ -2907,7 +2545,7 @@ function registerIngestEpisodesCommand(parent) {
       }
       const { provider, modelId } = resolveEpisodeModel(config, commandInput.modelOverride);
       const modelInfo = createEpisodeIngestSummaryModelInfo(provider, modelId);
-      const resolvedTargetPath = path7.resolve(normalizedTargetPath);
+      const resolvedTargetPath = path6.resolve(normalizedTargetPath);
       const sessionsDir = await resolveSessionsDirectory(resolvedTargetPath);
       const ports = await createEpisodeIngestPorts(database, sessionsDir);
       const embeddingSetup = resolveEpisodeEmbeddingSetup(config, commandInput);
@@ -3122,18 +2760,18 @@ function createEpisodeIngestSummaryLlm(provider, modelId, apiKey) {
   };
 }
 async function resolveSessionsDirectory(targetPath) {
-  const stat = await fs5.stat(targetPath);
-  return stat.isFile() ? path7.dirname(targetPath) : targetPath;
+  const stat = await fs4.stat(targetPath);
+  return stat.isFile() ? path6.dirname(targetPath) : targetPath;
 }
 function resolveEpisodeDbPath(config, overridePath) {
-  const normalizedOverride = normalizeOptionalString3(overridePath);
+  const normalizedOverride = normalizeOptionalString2(overridePath);
   if (!normalizedOverride) {
     return config?.dbPath ?? resolveDbPath(config);
   }
   if (normalizedOverride === ":memory:" || normalizedOverride.startsWith("file:")) {
     return normalizedOverride;
   }
-  return path7.resolve(normalizedOverride);
+  return path6.resolve(normalizedOverride);
 }
 function resolveEpisodeModel(config, overrideRef) {
   const resolved = resolveModel(config, "episode");
@@ -3247,7 +2885,7 @@ function reportEpisodeProgress(completed, total, session) {
 }
 function formatEpisodeProgressLine(completed, total, session) {
   const prefix = completed !== void 0 && total !== void 0 ? `${completed}/${total} ` : "";
-  const fileLabel = path7.basename(session.filePath);
+  const fileLabel = path6.basename(session.filePath);
   const details = session.action === "failed" ? `failed (${session.error ?? "unknown error"})` : session.action;
   const usage = session.usage.totalCost > 0 ? ` ${formatCost(session.usage.totalCost)}` : "";
   return `${prefix}${fileLabel}: ${details}${usage}`;
@@ -3272,15 +2910,15 @@ function formatUnknownError2(error) {
 }
 function normalizeEpisodeIngestCommand(targetPath, options) {
   const commandInput = {
-    targetPath: normalizeOptionalString3(targetPath),
+    targetPath: normalizeOptionalString2(targetPath),
     verbose: options.verbose === true,
     dryRun: options.dryRun === true,
     regenerate: options.regenerate === true,
     embedOnly: options.embedOnly === true,
     noEmbed: options.noEmbed === true,
-    recent: normalizeOptionalString3(options.recent),
+    recent: normalizeOptionalString2(options.recent),
     concurrency: options.concurrency ?? DEFAULT_EPISODE_INGEST_CONCURRENCY,
-    dbOverride: normalizeOptionalString3(options.db),
+    dbOverride: normalizeOptionalString2(options.db),
     modelOverride: options.model ? parseModelRef(options.model) : void 0
   };
   validateEpisodeIngestOptions(commandInput);
@@ -3291,26 +2929,26 @@ function parseEpisodeIngestConcurrency(value) {
 }
 
 // src/cli/commands/ingest-procedures.ts
-import path9 from "path";
+import path8 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";
+import fs5 from "fs/promises";
+import path7 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);
+  const resolvedTargetPath = path7.resolve(targetPath);
+  const stat = await fs5.stat(resolvedTargetPath);
   if (stat.isFile()) {
-    return matchesProcedureFileName(path8.basename(resolvedTargetPath)) ? [resolvedTargetPath] : [];
+    return matchesProcedureFileName(path7.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));
+  const entries = recursive ? await fs5.readdir(resolvedTargetPath, { recursive: true, withFileTypes: true }) : await fs5.readdir(resolvedTargetPath, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && matchesProcedureFileName(entry.name)).map((entry) => path7.resolve(entry.parentPath ?? resolvedTargetPath, entry.name)).sort((left, right) => left.localeCompare(right));
 }
 async function readProcedureFile(filePath) {
-  return fs6.readFile(filePath, "utf-8");
+  return fs5.readFile(filePath, "utf-8");
 }
 var LocalProcedureFiles = class {
   /**
@@ -3645,7 +3283,7 @@ function registerIngestProceduresCommand(parent) {
     try {
       const config = readConfig();
       const dbPath = config.dbPath;
-      const resolvedTargetPath = path9.resolve(commandInput.targetPath);
+      const resolvedTargetPath = path8.resolve(commandInput.targetPath);
       database = await createDatabase(dbPath);
       if (commandInput.verbose) {
         clack3.log.step(`Preparing procedure sync for ${resolvedTargetPath}...`);
@@ -3701,7 +3339,7 @@ function registerIngestProceduresCommand(parent) {
 }
 function normalizeIngestProceduresCommand(targetPath, options) {
   return {
-    targetPath: normalizeOptionalString3(targetPath) ?? DEFAULT_PROCEDURE_SYNC_PATH,
+    targetPath: normalizeOptionalString2(targetPath) ?? DEFAULT_PROCEDURE_SYNC_PATH,
     verbose: options.verbose === true,
     dryRun: options.dryRun === true
   };
@@ -3822,11 +3460,11 @@ function registerIngestEntriesCommand(parent) {
       const claimApiKey = claimModel ? resolveLlmApiKey(config, claimModel.provider) : void 0;
       const sharedEmbedding = createEmbeddingClient(resolveEmbeddingApiKey(config), resolveEmbeddingModel(config));
       if (commandInput.verbose) {
-        clack4.log.step(`Discovering transcript files in ${path10.resolve(commandInput.targetPath)}...`);
+        clack4.log.step(`Discovering transcript files in ${path9.resolve(commandInput.targetPath)}...`);
       }
       const files = await localTranscriptFiles.discoverFiles(commandInput.targetPath);
       if (files.length === 0) {
-        clack4.log.warn(`No transcript files found at ${path10.resolve(commandInput.targetPath)}.`);
+        clack4.log.warn(`No transcript files found at ${path9.resolve(commandInput.targetPath)}.`);
         clack4.outro("Nothing to ingest.");
         return;
       }
@@ -3909,7 +3547,7 @@ function registerIngestEntriesCommand(parent) {
         failedFiles: 0,
         warnings: 0
       };
-      const usageTotals = extractionRuns.reduce((total, run) => addUsageStats(total, run.usage), createEmptyUsageStats3());
+      const usageTotals = extractionRuns.reduce((total, run) => addUsageStats(total, run.usage), createEmptyUsageStats2());
       addUsageStats(usageTotals, dedupUsage);
       let runningCost = 0;
       for (const [index, extractionRun] of extractionRuns.entries()) {
@@ -3922,9 +3560,9 @@ function registerIngestEntriesCommand(parent) {
           totals.skippedFiles += 1;
           if (commandInput.verbose) {
             printVerboseFileDetails(result, commandInput, usage);
-            clack4.log.step(buildSkippedMessage(path10.basename(result.file)));
+            clack4.log.step(buildSkippedMessage(path9.basename(result.file)));
           } else {
-            clack4.log.step(buildSkippedMessage(path10.basename(result.file)));
+            clack4.log.step(buildSkippedMessage(path9.basename(result.file)));
           }
           continue;
         }
@@ -3933,7 +3571,7 @@ function registerIngestEntriesCommand(parent) {
           if (commandInput.verbose) {
             printVerboseFileDetails(result, commandInput, usage);
           }
-          clack4.log.error(buildFailureMessage(path10.basename(result.file), result, commandInput, usage, index === 0));
+          clack4.log.error(buildFailureMessage(path9.basename(result.file), result, commandInput, usage, index === 0));
           continue;
         }
         const storeResult = result.storeResult ?? emptyStoreResult2();
@@ -3943,7 +3581,7 @@ function registerIngestEntriesCommand(parent) {
         if (commandInput.verbose) {
           printVerboseFileDetails(result, commandInput, usage);
         }
-        clack4.log.step(buildSuccessMessage(path10.basename(result.file), result, commandInput, usage, index === 0));
+        clack4.log.step(buildSuccessMessage(path9.basename(result.file), result, commandInput, usage, index === 0));
       }
       const summaryParts = [`${totals.stored} ${pluralize3(totals.stored, "entry", "entries")} stored`, `${totals.deduped} deduped`];
       if (totals.rejected > 0) {
@@ -3982,7 +3620,7 @@ function registerIngestEntriesCommand(parent) {
   });
 }
 function normalizeIngestEntriesCommand(targetPath, options) {
-  const normalizedTargetPath = normalizeOptionalString3(targetPath);
+  const normalizedTargetPath = normalizeOptionalString2(targetPath);
   if (!normalizedTargetPath) {
     throw new InvalidArgumentError3("Path cannot be empty.");
   }
@@ -4336,7 +3974,7 @@ function truncateText(text2, maxLength) {
 function isDefined3(value) {
   return value !== void 0;
 }
-function createEmptyUsageStats3() {
+function createEmptyUsageStats2() {
   return {
     calls: 0,
     inputTokens: 0,
@@ -4372,8 +4010,8 @@ function parseConcurrency(value) {
 import { getModels } from "@mariozechner/pi-ai";
 
 // src/cli/ui.ts
-import os2 from "os";
-import path11 from "path";
+import os from "os";
+import path10 from "path";
 import * as clack5 from "@clack/prompts";
 function createCliPrompts() {
   return {
@@ -4403,24 +4041,24 @@ function createCliPrompts() {
   };
 }
 var cliPrompts = createCliPrompts();
-function resolveUserPath2(value) {
+function resolveUserPath(value) {
   const trimmed = value.trim();
   if (trimmed === ":memory:" || trimmed.startsWith("file:")) {
     return trimmed;
   }
   if (trimmed === "~") {
-    return os2.homedir();
+    return os.homedir();
   }
   if (trimmed.startsWith("~/")) {
-    return path11.join(os2.homedir(), trimmed.slice(2));
+    return path10.join(os.homedir(), trimmed.slice(2));
   }
   if (trimmed.startsWith("~\\")) {
-    return path11.join(os2.homedir(), trimmed.slice(2));
+    return path10.join(os.homedir(), trimmed.slice(2));
   }
-  return path11.resolve(trimmed);
+  return path10.resolve(trimmed);
 }
 function formatPathForDisplay(filePath) {
-  const home = os2.homedir();
+  const home = os.homedir();
   const resolvedPath = filePath.trim();
   return resolvedPath.startsWith(home) ? `~${resolvedPath.slice(home.length)}` : resolvedPath;
 }
@@ -4448,50 +4086,50 @@ function validateSecret(value) {
   return value?.trim().length ? void 0 : "Value cannot be empty.";
 }
 function hasSecret(value) {
-  return normalizeOptionalString4(value) !== void 0;
+  return normalizeOptionalString3(value) !== void 0;
 }
 function formatModelRef(config) {
-  const provider = normalizeOptionalString4(config?.provider) ?? "(provider not set)";
-  const model = normalizeOptionalString4(config?.model) ?? "(model not set)";
+  const provider = normalizeOptionalString3(config?.provider) ?? "(provider not set)";
+  const model = normalizeOptionalString3(config?.model) ?? "(model not set)";
   return `${provider}/${model}`;
 }
 function hasModelOverride(config) {
-  return normalizeOptionalString4(config?.provider) !== void 0 || normalizeOptionalString4(config?.model) !== void 0;
+  return normalizeOptionalString3(config?.provider) !== void 0 || normalizeOptionalString3(config?.model) !== void 0;
 }
 function sameModelRef(left, right) {
-  return normalizeOptionalString4(left?.provider) === normalizeOptionalString4(right?.provider) && normalizeOptionalString4(left?.model) === normalizeOptionalString4(right?.model);
+  return normalizeOptionalString3(left?.provider) === normalizeOptionalString3(right?.provider) && normalizeOptionalString3(left?.model) === normalizeOptionalString3(right?.model);
 }
 function resolveStoredCredentialForAuth(config, auth) {
   switch (auth) {
     case "openai-api-key":
-      return normalizeOptionalString4(config?.credentials?.openaiApiKey);
+      return normalizeOptionalString3(config?.credentials?.openaiApiKey);
     case "anthropic-api-key":
-      return normalizeOptionalString4(config?.credentials?.anthropicApiKey);
+      return normalizeOptionalString3(config?.credentials?.anthropicApiKey);
     case "anthropic-token":
-      return normalizeOptionalString4(config?.credentials?.anthropicOauthToken);
+      return normalizeOptionalString3(config?.credentials?.anthropicOauthToken);
     case "anthropic-oauth":
     case "openai-subscription":
       return void 0;
   }
 }
 function resolveStoredEmbeddingCredential(config) {
-  return normalizeOptionalString4(config?.credentials?.openaiApiKey);
+  return normalizeOptionalString3(config?.credentials?.openaiApiKey);
 }
 function normalizeProvider(value) {
-  const normalized = normalizeOptionalString4(value);
+  const normalized = normalizeOptionalString3(value);
   if (normalized === "openai" || normalized === "openai-codex" || normalized === "anthropic") {
     return normalized;
   }
   return void 0;
 }
-function normalizeAuthMethod2(value) {
-  const normalized = normalizeOptionalString4(value);
+function normalizeAuthMethod(value) {
+  const normalized = normalizeOptionalString3(value);
   if (normalized === "openai-api-key" || normalized === "openai-subscription" || normalized === "anthropic-api-key" || normalized === "anthropic-oauth" || normalized === "anthropic-token") {
     return normalized;
   }
   return void 0;
 }
-function normalizeOptionalString4(value) {
+function normalizeOptionalString3(value) {
   const trimmed = value?.trim();
   return trimmed && trimmed.length > 0 ? trimmed : void 0;
 }
@@ -4733,7 +4371,7 @@ function hasPersistedSurgeonConfig(config) {
     return false;
   }
   const retirementConfig = config.passes?.retirement;
-  return hasModelOverride(config.model) || config.costCap !== void 0 || config.dailyCostCap !== void 0 || config.contextLimit !== void 0 || normalizeOptionalString4(config.customInstructions) !== void 0 || retirementConfig?.protectRecalledDays !== void 0 || retirementConfig?.protectMinImportance !== void 0 || retirementConfig?.skipRecentlyEvaluatedDays !== void 0;
+  return hasModelOverride(config.model) || config.costCap !== void 0 || config.dailyCostCap !== void 0 || config.contextLimit !== void 0 || normalizeOptionalString3(config.customInstructions) !== void 0 || retirementConfig?.protectRecalledDays !== void 0 || retirementConfig?.protectMinImportance !== void 0 || retirementConfig?.skipRecentlyEvaluatedDays !== void 0;
 }
 
 // src/cli/commands/setup/config.ts
@@ -4770,8 +4408,8 @@ function isSetupConfigured(config, env = process.env) {
   return getSetupReadiness(config, env).ready;
 }
 function getSetupReadiness(config, env = process.env) {
-  const provider = normalizeOptionalString4(config?.provider);
-  const model = normalizeOptionalString4(config?.model);
+  const provider = normalizeOptionalString3(config?.provider);
+  const model = normalizeOptionalString3(config?.model);
   if (!provider || !model) {
     return {
       ready: false,
@@ -4812,7 +4450,7 @@ function formatSavedConfigSummary(config, configPath, dbPath, options) {
   return lines.join("\n");
 }
 function describePrimaryCredentialConfig(config) {
-  const auth = normalizeAuthMethod2(config.auth);
+  const auth = normalizeAuthMethod(config.auth);
   if (!auth) {
     return "not set";
   }
@@ -4829,9 +4467,9 @@ function describePrimaryCredentialConfig(config) {
 }
 function describeEmbeddingConfig(config) {
   if (hasSecret(resolveStoredEmbeddingCredential(config))) {
-    return normalizeAuthMethod2(config.auth) === "openai-api-key" ? "uses the primary OpenAI key" : "separate OpenAI key configured";
+    return normalizeAuthMethod(config.auth) === "openai-api-key" ? "uses the primary OpenAI key" : "separate OpenAI key configured";
   }
-  const auth = normalizeAuthMethod2(config.auth);
+  const auth = normalizeAuthMethod(config.auth);
   if (auth && auth !== "openai-api-key") {
     return "missing separate OpenAI key";
   }
@@ -4841,7 +4479,7 @@ function mergeStoredCredentials(existingCredentials, values) {
   const next = {
     ...existingCredentials ?? {}
   };
-  const normalizedPrimaryCredential = normalizeOptionalString4(values.primaryCredential);
+  const normalizedPrimaryCredential = normalizeOptionalString3(values.primaryCredential);
   if (normalizedPrimaryCredential) {
     if (values.auth === "openai-api-key") {
       next.openaiApiKey = normalizedPrimaryCredential;
@@ -4851,7 +4489,7 @@ function mergeStoredCredentials(existingCredentials, values) {
       next.anthropicOauthToken = normalizedPrimaryCredential;
     }
   }
-  const normalizedEmbeddingApiKey = normalizeOptionalString4(values.embeddingApiKey);
+  const normalizedEmbeddingApiKey = normalizeOptionalString3(values.embeddingApiKey);
   if (normalizedEmbeddingApiKey) {
     next.openaiApiKey = normalizedEmbeddingApiKey;
   }
@@ -4877,7 +4515,7 @@ async function runSetupCore(options = {}) {
   }
   const existingConfig = options.existingConfig;
   const configPath = runtime.resolveConfigPath();
-  const auth = await selectAuthMethod(prompts, normalizeAuthMethod2(existingConfig?.auth));
+  const auth = await selectAuthMethod(prompts, normalizeAuthMethod(existingConfig?.auth));
   if (auth === null) {
     return null;
   }
@@ -4922,7 +4560,7 @@ async function runSetupCore(options = {}) {
   if (stageOverrides === null) {
     return null;
   }
-  const defaultDbPath = normalizeOptionalString4(existingConfig?.dbPath) ?? runtime.resolveDbPath(existingConfig);
+  const defaultDbPath = normalizeOptionalString3(existingConfig?.dbPath) ?? runtime.resolveDbPath(existingConfig);
   const dbPathInput = await prompts.text({
     message: "Database path:",
     initialValue: defaultDbPath,
@@ -4932,7 +4570,7 @@ async function runSetupCore(options = {}) {
   if (prompts.isCancel(dbPathInput)) {
     return null;
   }
-  const dbPath = resolveUserPath2(dbPathInput);
+  const dbPath = resolveUserPath(dbPathInput);
   const nextConfig = buildNextConfig(existingConfig, {
     auth,
     provider,
@@ -5289,9 +4927,9 @@ async function promptTaskModelOverrides(prompts, runtime, options) {
 async function promptStageOverride(prompts, runtime, options) {
   const defaultRef = `${describeAuthMethod(options.defaultAuth)} / ${options.defaultModel}`;
   const currentProvider = normalizeProvider(options.current?.provider);
-  const currentModel = normalizeOptionalString4(options.current?.model) ?? options.defaultModel;
+  const currentModel = normalizeOptionalString3(options.current?.model) ?? options.defaultModel;
   const currentAuth = resolveStageAuthChoice(currentProvider, options.defaultAuth);
-  const hasExplicitOverride = normalizeOptionalString4(options.current?.provider) !== void 0 || normalizeOptionalString4(options.current?.model) !== void 0;
+  const hasExplicitOverride = normalizeOptionalString3(options.current?.provider) !== void 0 || normalizeOptionalString3(options.current?.model) !== void 0;
   const action = await prompts.select({
     message: `${options.stage.label} model override:`,
     options: [
@@ -5490,8 +5128,8 @@ function formatTokenCount(tokens) {
 
 // src/cli/commands/init/external-commands.ts
 import { execFile, execFileSync } from "child_process";
-import fs7 from "fs/promises";
-import path12 from "path";
+import fs6 from "fs/promises";
+import path11 from "path";
 var OPENCLAW_PLUGIN_PACKAGE = "@agenr/agenr-plugin";
 function execAsync(command, args, options) {
   return new Promise((resolve, reject) => {
@@ -5588,10 +5226,10 @@ async function restartOpenClawGateway() {
   }
 }
 async function writeOpenClawPluginConfig(stateDir, config) {
-  const openclawConfigPath = path12.join(stateDir, "openclaw.json");
+  const openclawConfigPath = path11.join(stateDir, "openclaw.json");
   let root = {};
   try {
-    const raw = await fs7.readFile(openclawConfigPath, "utf8");
+    const raw = await fs6.readFile(openclawConfigPath, "utf8");
     const parsed = JSON.parse(raw);
     if (isRecord(parsed)) {
       root = parsed;
@@ -5617,13 +5255,13 @@ async function writeOpenClawPluginConfig(stateDir, config) {
   } else {
     delete entryConfig.configPath;
   }
-  await fs7.mkdir(stateDir, { recursive: true });
-  await fs7.writeFile(openclawConfigPath, `${JSON.stringify(root, null, 2)}
+  await fs6.mkdir(stateDir, { recursive: true });
+  await fs6.writeFile(openclawConfigPath, `${JSON.stringify(root, null, 2)}
 `, "utf8");
   return openclawConfigPath;
 }
 function shouldPersistPluginConfigPath(dbPath, configPath) {
-  return path12.dirname(dbPath) !== path12.dirname(configPath);
+  return path11.dirname(dbPath) !== path11.dirname(configPath);
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -5650,32 +5288,32 @@ function ensureArrayOfStrings(target, key) {
 }
 
 // src/cli/commands/init/openclaw-detect.ts
-import fs8 from "fs";
-import os3 from "os";
-import path13 from "path";
+import fs7 from "fs";
+import os2 from "os";
+import path12 from "path";
 function resolveDefaultOpenClawStateDir() {
-  return path13.join(os3.homedir(), ".openclaw");
+  return path12.join(os2.homedir(), ".openclaw");
 }
-function detectOpenClawInstallation(env = process.env, existsSyncFn = fs8.existsSync) {
-  const envStateDir = normalizeOptionalString5(env.OPENCLAW_STATE_DIR) ?? normalizeOptionalString5(env.OPENCLAW_HOME);
+function detectOpenClawInstallation(env = process.env, existsSyncFn = fs7.existsSync) {
+  const envStateDir = normalizeOptionalString4(env.OPENCLAW_STATE_DIR) ?? normalizeOptionalString4(env.OPENCLAW_HOME);
   const source = envStateDir ? "environment" : "default";
-  const stateDir = envStateDir ? resolveUserPath2(envStateDir) : resolveDefaultOpenClawStateDir();
+  const stateDir = envStateDir ? resolveUserPath(envStateDir) : resolveDefaultOpenClawStateDir();
   return {
     detected: envStateDir !== void 0 || existsSyncFn(stateDir),
     stateDir,
-    configPath: path13.join(stateDir, "openclaw.json"),
-    sessionsRoot: path13.join(stateDir, "agents"),
+    configPath: path12.join(stateDir, "openclaw.json"),
+    sessionsRoot: path12.join(stateDir, "agents"),
     source
   };
 }
-function normalizeOptionalString5(value) {
+function normalizeOptionalString4(value) {
   const trimmed = value?.trim();
   return trimmed && trimmed.length > 0 ? trimmed : void 0;
 }
 
 // src/cli/commands/init/session-scanner.ts
-import fs9 from "fs/promises";
-import path14 from "path";
+import fs8 from "fs/promises";
+import path13 from "path";
 async function scanSessionFiles(sessionsRoot, recentDays = 7) {
   const result = {
     totalFiles: 0,
@@ -5700,7 +5338,7 @@ async function scanSessionFiles(sessionsRoot, recentDays = 7) {
     }
     let stat;
     try {
-      stat = await fs9.stat(filePath);
+      stat = await fs8.stat(filePath);
     } catch (error) {
       if (isMissingPathError(error)) {
         continue;
@@ -5718,7 +5356,7 @@ async function scanSessionFiles(sessionsRoot, recentDays = 7) {
   return result;
 }
 function isSessionTranscriptPath(filePath) {
-  return filePath.split(path14.sep).includes("sessions");
+  return filePath.split(path13.sep).includes("sessions");
 }
 function isMissingPathError(error) {
   return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
@@ -6089,7 +5727,7 @@ function registerInitCommand(program2) {
 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) => {
+  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)).addOption(new Option3("--cross-encoder <state>", "Enable or disable the cross-encoder rerank stage").choices(["enabled", "disabled"])).addOption(new Option3("--cross-encoder-top-k <n>", "Top-K shortlist size for cross-encoder rerank").argParser(parsePositiveInteger)).addOption(new Option3("--cross-encoder-alpha <n>", "Blend weight for cross-encoder vs prior score (0-1)").argParser(parseUnitInterval)).option("--verbose", "Show score breakdowns").action(async (query, options) => {
     clack6.intro(banner());
     let db = null;
     try {
@@ -6098,23 +5736,37 @@ function registerRecallCommand(program2) {
       const dbPath = config.dbPath;
       const embeddingClient = createEmbeddingClient(resolveEmbeddingApiKey(config), resolveEmbeddingModel(config));
       db = await createDatabase(dbPath);
-      const adapter = createRecallAdapter(db, embeddingClient);
+      const recallPorts = createRecallAdapter(db, embeddingClient);
+      const crossEncoder = commandInput.rankingPolicy?.crossEncoder === "disabled" ? void 0 : tryCreateCrossEncoder(config);
+      const adapter = attachCrossEncoderPort(recallPorts, crossEncoder);
       let lastTraceSummary;
       const spinner6 = clack6.spinner();
       spinner6.start("Searching knowledge...");
-      const results = await recall(commandInput.request, adapter, {
+      const recallOptions = {
         trace: {
           reportSummary(summary) {
             lastTraceSummary = summary;
           }
-        }
-      });
+        },
+        ...commandInput.rankingPolicy ? { rankingPolicy: commandInput.rankingPolicy } : {}
+      };
+      const results = await recall(commandInput.request, adapter, recallOptions);
       spinner6.stop(`Found ${results.length} ${pluralize4(results.length, "result")}.`);
       if (lastTraceSummary?.degraded.active) {
         for (const notice of lastTraceSummary.degraded.notices) {
           clack6.log.warn(notice);
         }
       }
+      if (commandInput.verbose && lastTraceSummary) {
+        const crossEncoder2 = lastTraceSummary.crossEncoder;
+        if (crossEncoder2.applied) {
+          clack6.log.info(
+            `Cross-encoder reranked top-${crossEncoder2.k} (alpha=${crossEncoder2.alpha.toFixed(2)}, latencyMs=${crossEncoder2.latencyMs}, rescored=${crossEncoder2.rescoredIds.length}).`
+          );
+        } else if (crossEncoder2.degradedReason) {
+          clack6.log.info(`Cross-encoder skipped (${crossEncoder2.degradedReason}).`);
+        }
+      }
       if (results.length === 0) {
         clack6.outro("No matching entries found.");
         return;
@@ -6133,10 +5785,11 @@ function registerRecallCommand(program2) {
   });
 }
 function normalizeRecallCommand(query, options) {
-  const normalizedQuery = normalizeOptionalString3(query);
+  const normalizedQuery = normalizeOptionalString2(query);
   if (!normalizedQuery) {
     throw new InvalidArgumentError4("Query cannot be empty.");
   }
+  const rankingPolicy = buildRankingPolicy(options);
   return {
     request: {
       text: normalizedQuery,
@@ -6145,15 +5798,38 @@ function normalizeRecallCommand(query, options) {
       budget: options.budget,
       types: options.types,
       tags: normalizeStringList(options.tags),
-      since: normalizeOptionalString3(options.since),
-      until: normalizeOptionalString3(options.until),
-      around: normalizeOptionalString3(options.around),
+      since: normalizeOptionalString2(options.since),
+      until: normalizeOptionalString2(options.until),
+      around: normalizeOptionalString2(options.around),
       aroundRadius: options.aroundRadius,
-      asOf: normalizeOptionalString3(options.asOf)
+      asOf: normalizeOptionalString2(options.asOf)
     },
-    verbose: options.verbose === true
+    verbose: options.verbose === true,
+    ...rankingPolicy ? { rankingPolicy } : {}
   };
 }
+function buildRankingPolicy(options) {
+  const policy = {};
+  if (options.crossEncoder !== void 0) {
+    policy.crossEncoder = options.crossEncoder;
+  }
+  if (typeof options.crossEncoderTopK === "number") {
+    policy.crossEncoderTopK = options.crossEncoderTopK;
+  }
+  if (typeof options.crossEncoderAlpha === "number") {
+    policy.crossEncoderAlpha = options.crossEncoderAlpha;
+  }
+  return Object.keys(policy).length > 0 ? policy : void 0;
+}
+function tryCreateCrossEncoder(config) {
+  try {
+    const apiKey = resolveCrossEncoderApiKey(config);
+    const { modelId } = resolveModel(config, "cross_encoder");
+    return createOpenAICrossEncoder({ apiKey, model: modelId });
+  } catch {
+    return void 0;
+  }
+}
 function formatResult(result, verbose, asOf) {
   const projected = projectClaimCentricRecallEntry(result, {
     asOf
@@ -6171,8 +5847,9 @@ function formatResult(result, verbose, asOf) {
   }
   lines.push(`  why=${projected.whySurfaced.summary}`);
   if (verbose) {
+    const crossEncoderFragment = typeof result.scores.crossEncoder === "number" ? `  crossEncoder=${result.scores.crossEncoder.toFixed(2)}` : "";
     lines.push(
-      `  vector=${result.scores.vector.toFixed(2)}  lexical=${result.scores.lexical.toFixed(2)}  recency=${result.scores.recency.toFixed(2)}  importance=${result.scores.importance.toFixed(2)}  relevance=${result.scores.relevance.toFixed(2)}  historicalLineage=${result.scores.historicalLineage.toFixed(2)}  claimKeyTrustPenalty=${result.scores.claimKeyTrustPenalty.toFixed(2)}  claimKeyRedundancyPenalty=${result.scores.claimKeyRedundancyPenalty.toFixed(2)}`
+      `  vector=${result.scores.vector.toFixed(2)}  lexical=${result.scores.lexical.toFixed(2)}  recency=${result.scores.recency.toFixed(2)}  importance=${result.scores.importance.toFixed(2)}  relevance=${result.scores.relevance.toFixed(2)}  historicalLineage=${result.scores.historicalLineage.toFixed(2)}  claimKeyTrustPenalty=${result.scores.claimKeyTrustPenalty.toFixed(2)}  claimKeyRedundancyPenalty=${result.scores.claimKeyRedundancyPenalty.toFixed(2)}${crossEncoderFragment}`
     );
   }
   return lines.join("\n");
@@ -6226,8 +5903,8 @@ import { InvalidArgumentError as InvalidArgumentError5, Option as Option4 } from
 // src/app/scenarios/claim-keys/runtime.ts
 import { randomUUID as randomUUID11 } from "crypto";
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-import path21 from "path";
-import { getModel as getModel2 } from "@mariozechner/pi-ai";
+import path20 from "path";
+import { getModel } from "@mariozechner/pi-ai";
 
 // src/adapters/db/surgeon-run-log.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -6288,9 +5965,9 @@ async function createSurgeonRun(executor, run) {
     args: [
       id,
       run.passType,
-      normalizeOptionalString6(run.project),
+      normalizeOptionalString5(run.project),
       startedAt,
-      normalizeOptionalString6(run.model ?? void 0),
+      normalizeOptionalString5(run.model ?? void 0),
       run.dryRun ? 1 : 0,
       JSON.stringify(run.config ?? null)
     ]
@@ -6323,7 +6000,7 @@ async function completeSurgeonRun(executor, runId, result) {
       normalizeInteger(result.actionsSkipped),
       normalizeInteger(result.entriesRetired),
       JSON.stringify(result.summaryJson ?? null),
-      normalizeOptionalString6(result.error ?? void 0),
+      normalizeOptionalString5(result.error ?? void 0),
       runId.trim()
     ]
   });
@@ -6460,7 +6137,7 @@ async function logSurgeonProposal(executor, proposal) {
       proposal.eligibleForApply ? 1 : 0,
       reviewStatus,
       normalizeTimestamp(reviewedAt ?? void 0),
-      normalizeOptionalString6(reviewReason ?? void 0),
+      normalizeOptionalString5(reviewReason ?? void 0),
       normalizeInteger(appliedActionCount ?? 0),
       normalizeTimestamp(proposal.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString()
     ]
@@ -6824,7 +6501,7 @@ function normalizeEntryIds(entryIds) {
 function normalizeStringArray(values) {
   return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
 }
-function normalizeOptionalString6(value) {
+function normalizeOptionalString5(value) {
   if (value === void 0) {
     return null;
   }
@@ -6832,7 +6509,7 @@ function normalizeOptionalString6(value) {
   return trimmed.length > 0 ? trimmed : null;
 }
 function normalizeTimestamp(value) {
-  return normalizeOptionalString6(value);
+  return normalizeOptionalString5(value);
 }
 function normalizeInteger(value) {
   if (!Number.isFinite(value)) {
@@ -7125,7 +6802,7 @@ async function listRetirementCandidates(executor, query) {
 }
 async function listSupersessionCandidates(executor, query) {
   const scope = normalizeSupersessionScope(query.scope);
-  const type = normalizeOptionalString7(query.type);
+  const type = normalizeOptionalString6(query.type);
   const scopes = scope === "all" ? ["claim_key", "subject"] : [scope];
   const clusters = (await Promise.all(
     scopes.map(async (currentScope) => {
@@ -7139,7 +6816,7 @@ async function listSupersessionCandidates(executor, query) {
   return limit === null ? filteredClusters.slice(offset) : filteredClusters.slice(offset, offset + limit);
 }
 async function countSupersessionCandidates(executor, query) {
-  const type = normalizeOptionalString7(query.type);
+  const type = normalizeOptionalString6(query.type);
   const skippedEntryIds = typeof query.skipRecentlyEvaluatedDays === "number" && Number.isFinite(query.skipRecentlyEvaluatedDays) && query.skipRecentlyEvaluatedDays > 0 ? await loadRecentlySkippedSupersessionEntryIds(executor, {
     now: query.now ?? /* @__PURE__ */ new Date(),
     skipRecentlyEvaluatedDays: query.skipRecentlyEvaluatedDays
@@ -7352,17 +7029,17 @@ async function inspectSurgeonEntry(executor, entryId) {
 async function listClaimKeyQualityEntries(executor, query) {
   const whereClauses = [query.includeInactive === true ? "1 = 1" : buildActiveEntryClause("e")];
   const args = [];
-  const project = normalizeOptionalString7(query.project);
+  const project = normalizeOptionalString6(query.project);
   if (project) {
     whereClauses.push(`(e.project = ? OR ${buildTagContainsClause("e")})`);
     args.push(project, project);
   }
-  const type = normalizeOptionalString7(query.type);
+  const type = normalizeOptionalString6(query.type);
   if (type) {
     whereClauses.push("e.type = ?");
     args.push(type);
   }
-  const claimKeyPrefix = normalizeOptionalString7(query.claimKeyPrefix);
+  const claimKeyPrefix = normalizeOptionalString6(query.claimKeyPrefix);
   if (claimKeyPrefix) {
     whereClauses.push("e.claim_key LIKE ?");
     args.push(`${claimKeyPrefix}/%`);
@@ -7394,7 +7071,7 @@ function buildCandidateFilter(query) {
   const protectMinImportance = normalizeNonNegativeInteger(query.protectMinImportance);
   const protectRecalledDays = normalizeNonNegativeInteger(query.protectRecalledDays);
   const protectRecalledCutoffIso = new Date(now.getTime() - protectRecalledDays * DAY_MS).toISOString();
-  const currentRunId = normalizeOptionalString7(query.runId);
+  const currentRunId = normalizeOptionalString6(query.runId);
   const whereClauses = [buildActiveEntryClause("e"), "e.expiry <> 'core'", "e.importance < ?", "(e.last_recalled_at IS NULL OR e.last_recalled_at < ?)"];
   const args = [protectMinImportance, protectRecalledCutoffIso];
   if (currentRunId) {
@@ -7407,12 +7084,12 @@ function buildCandidateFilter(query) {
     )`);
     args.push(currentRunId, ...SURGEON_RETIREMENT_SAME_RUN_SUPPRESSION_ACTION_TYPES);
   }
-  const project = normalizeOptionalString7(query.project);
+  const project = normalizeOptionalString6(query.project);
   if (project) {
     whereClauses.push(buildTagContainsClause("e"));
     args.push(project);
   }
-  const type = normalizeOptionalString7(query.type);
+  const type = normalizeOptionalString6(query.type);
   if (type) {
     whereClauses.push("e.type = ?");
     args.push(type);
@@ -7623,7 +7300,7 @@ function normalizeNonNegativeInteger(value) {
   }
   return Math.max(0, Math.floor(value));
 }
-function normalizeOptionalString7(value) {
+function normalizeOptionalString6(value) {
   if (value === void 0) {
     return null;
   }
@@ -7713,8 +7390,8 @@ function createSurgeonPort(executor) {
 
 // src/app/surgeon/service.ts
 import { randomUUID as randomUUID9 } from "crypto";
-import fs11 from "fs";
-import path16 from "path";
+import fs10 from "fs";
+import path15 from "path";
 import { runAgentLoop } from "@mariozechner/pi-agent-core";
 
 // src/core/surgeon/domain/run-presets.ts
@@ -7994,9 +7671,9 @@ var SHADOW_BUCKET_ORDER = [
 async function runClaimKeyQualityPass(options, deps) {
   const selection = {
     includeInactive: options.includeInactive === true,
-    project: normalizeOptionalString8(options.project) ?? null,
-    type: normalizeOptionalString8(options.type) ?? null,
-    claimKeyPrefix: normalizeOptionalString8(options.claimKeyPrefix) ?? null,
+    project: normalizeOptionalString7(options.project) ?? null,
+    type: normalizeOptionalString7(options.type) ?? null,
+    claimKeyPrefix: normalizeOptionalString7(options.claimKeyPrefix) ?? null,
     entryIds: normalizeStringArray3(options.entryIds ?? [])
   };
   const executionStyle = selection.includeInactive || selection.type !== null || selection.claimKeyPrefix !== null || selection.entryIds.length > 0 ? "targeted" : "autonomous";
@@ -9231,7 +8908,7 @@ function cloneEntry(entry) {
     embedding: entry.embedding ? [...entry.embedding] : void 0
   };
 }
-function normalizeOptionalString8(value) {
+function normalizeOptionalString7(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
 }
@@ -10440,8 +10117,8 @@ async function applyProposalToEntries(input, deps) {
 }
 
 // src/app/surgeon/trace-logger.ts
-import fs10 from "fs";
-import path15 from "path";
+import fs9 from "fs";
+import path14 from "path";
 var TRACE_MAX_STRING_LENGTH = 320;
 var TRACE_MAX_ARRAY_ITEMS = 12;
 var TRACE_MAX_OBJECT_KEYS = 20;
@@ -10649,8 +10326,8 @@ function appendTrace(tracePath, payload, logger) {
     return;
   }
   try {
-    fs10.mkdirSync(path15.dirname(tracePath), { recursive: true });
-    fs10.appendFileSync(tracePath, `${JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...payload })}
+    fs9.mkdirSync(path14.dirname(tracePath), { recursive: true });
+    fs9.appendFileSync(tracePath, `${JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...payload })}
 `, "utf8");
   } catch (error) {
     logger.warn(`failed to write trace file ${tracePath}: ${formatError2(error)}`);
@@ -11547,10 +11224,10 @@ function createQueryCandidatesTool(deps) {
       const offset = normalizeOffset2(params.offset);
       const page = await deps.port.listRetirementCandidates({
         scope,
-        type: normalizeOptionalString9(params.type),
+        type: normalizeOptionalString8(params.type),
         importanceMax: params.importance_max,
         minAgeDays: params.min_age_days,
-        project: normalizeOptionalString9(params.project) ?? deps.project,
+        project: normalizeOptionalString8(params.project) ?? deps.project,
         limit,
         offset,
         protectRecalledDays: deps.protection.protectRecalledDays,
@@ -11613,7 +11290,7 @@ function normalizeOffset2(value) {
 function normalizeScope2(value) {
   return value === "all" ? "all" : "actionable";
 }
-function normalizeOptionalString9(value) {
+function normalizeOptionalString8(value) {
   const normalized = value?.trim();
   return normalized ? normalized : void 0;
 }
@@ -11639,7 +11316,7 @@ function createSimulateRecallTool(deps) {
       if (!deps.recallPorts) {
         throw new Error("Recall simulation is unavailable because no embedding-enabled recall ports are configured.");
       }
-      const excludeEntryId = normalizeOptionalString10(params.exclude_entry_id);
+      const excludeEntryId = normalizeOptionalString9(params.exclude_entry_id);
       const results = await recall(
         {
           text: params.query.trim(),
@@ -11673,17 +11350,17 @@ function createSimulationRecallPorts(inner, excludeEntryId) {
       }
       return results.filter((result) => result.entry.id !== excludeEntryId);
     },
-    async fetchPredecessors(params) {
-      if (!inner.fetchPredecessors) {
+    async expandNeighborhood(request) {
+      if (!inner.expandNeighborhood) {
         return [];
       }
-      const activeEntryIds = excludeEntryId ? params.activeEntryIds.filter((id) => id !== excludeEntryId) : params.activeEntryIds;
-      if (activeEntryIds.length === 0) {
+      const seedIds = excludeEntryId ? request.seedIds.filter((id) => id !== excludeEntryId) : request.seedIds;
+      if (seedIds.length === 0) {
         return [];
       }
-      const results = await inner.fetchPredecessors({
-        ...params,
-        activeEntryIds
+      const results = await inner.expandNeighborhood({
+        ...request,
+        seedIds
       });
       if (!excludeEntryId) {
         return results;
@@ -11704,7 +11381,7 @@ function normalizeLimit3(value) {
   }
   return Math.floor(value);
 }
-function normalizeOptionalString10(value) {
+function normalizeOptionalString9(value) {
   const normalized = value?.trim();
   return normalized ? normalized : void 0;
 }
@@ -11984,7 +11661,7 @@ function createQuerySupersessionCandidatesTool(deps) {
       const scope = normalizeScope3(params.scope);
       const limit = normalizeLimit4(params.limit);
       const offset = normalizeOffset3(params.offset);
-      const type = normalizeOptionalString11(params.type);
+      const type = normalizeOptionalString10(params.type);
       const progress = deps.completionGuards?.supersession.snapshot();
       if ((scope === "subject" || scope === "all") && shouldBlockLowerConfidenceScope(progress)) {
         return toolResult({
@@ -12092,7 +11769,7 @@ function normalizeScope3(value) {
   }
   return "claim_key";
 }
-function normalizeOptionalString11(value) {
+function normalizeOptionalString10(value) {
   const normalized = value?.trim();
   return normalized ? normalized : void 0;
 }
@@ -13199,8 +12876,8 @@ function resolveTracePath(tracePath, passType, runId) {
     return void 0;
   }
   try {
-    if (fs11.statSync(tracePath).isDirectory()) {
-      return path16.join(tracePath, `surgeon-${passType}-${runId}.jsonl`);
+    if (fs10.statSync(tracePath).isDirectory()) {
+      return path15.join(tracePath, `surgeon-${passType}-${runId}.jsonl`);
     }
   } catch {
     return tracePath;
@@ -14102,7 +13779,7 @@ function formatValue(value) {
 }
 
 // src/app/scenarios/claim-keys/deterministic-fixtures.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash2 } from "crypto";
 var DEFAULT_CONTEXT_WINDOW_TOKENS2 = 16e3;
 var DEFAULT_MAX_OUTPUT_TOKENS = 4e3;
 var EMBEDDING_DIMENSIONS = 1024;
@@ -14160,7 +13837,7 @@ function hashToVector(text2, dimensions) {
   const vector = [];
   let counter = 0;
   while (vector.length < dimensions) {
-    const block = createHash3("sha256").update(text2).update(String(counter)).digest();
+    const block = createHash2("sha256").update(text2).update(String(counter)).digest();
     for (let offset = 0; offset + 4 <= block.length && vector.length < dimensions; offset += 4) {
       vector.push(block.readInt32LE(offset) / 2147483647);
     }
@@ -14202,7 +13879,7 @@ function isFixtureError(value) {
 
 // src/app/scenarios/claim-keys/fixture-loader.ts
 import { readFile } from "fs/promises";
-import path18 from "path";
+import path17 from "path";
 
 // src/app/scenarios/claim-keys/validation/shared.ts
 var SUPPORTED_PROPOSAL_SCOPES = ["single_entry", "cluster"];
@@ -14532,12 +14209,12 @@ function readRequiredTrue(value, label, filePath) {
 
 // src/app/scenarios/claim-keys/validation/scenario-root.ts
 import { existsSync } from "fs";
-import path17 from "path";
+import path16 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var SCENARIO_ROOT_SEGMENTS = ["tests", "scenarios", "claim-keys"];
 function getDefaultClaimKeyScenarioRoot(options = {}) {
-  const moduleDirectory = path17.dirname(fileURLToPath2(options.moduleUrl ?? import.meta.url));
-  const startDirectories = Array.from(/* @__PURE__ */ new Set([path17.resolve(options.cwd ?? process.cwd()), moduleDirectory]));
+  const moduleDirectory = path16.dirname(fileURLToPath2(options.moduleUrl ?? import.meta.url));
+  const startDirectories = Array.from(/* @__PURE__ */ new Set([path16.resolve(options.cwd ?? process.cwd()), moduleDirectory]));
   for (const startDirectory of startDirectories) {
     const discovered = findScenarioRootFrom(startDirectory);
     if (discovered) {
@@ -14559,24 +14236,24 @@ function readOptionalRelativeFixturePath(value, label, filePath, rootDir) {
   return readRelativeFixturePath(value, label, filePath, rootDir);
 }
 function normalizeFixturePath(relativePath, rootDir, filePath, label) {
-  if (path17.isAbsolute(relativePath)) {
+  if (path16.isAbsolute(relativePath)) {
     throw new Error(`Invalid scenario ${filePath}: ${label} must be relative to the scenario root.`);
   }
-  const resolved = path17.resolve(rootDir, relativePath);
-  const relative = path17.relative(rootDir, resolved);
-  if (relative.startsWith("..") || path17.isAbsolute(relative)) {
+  const resolved = path16.resolve(rootDir, relativePath);
+  const relative = path16.relative(rootDir, resolved);
+  if (relative.startsWith("..") || path16.isAbsolute(relative)) {
     throw new Error(`Invalid scenario ${filePath}: ${label} must stay inside the scenario root.`);
   }
-  return relative.split(path17.sep).join("/");
+  return relative.split(path16.sep).join("/");
 }
 function findScenarioRootFrom(startDirectory) {
-  let currentDirectory = path17.resolve(startDirectory);
+  let currentDirectory = path16.resolve(startDirectory);
   while (true) {
-    const candidate = path17.join(currentDirectory, ...SCENARIO_ROOT_SEGMENTS);
+    const candidate = path16.join(currentDirectory, ...SCENARIO_ROOT_SEGMENTS);
     if (existsSync(candidate)) {
       return candidate;
     }
-    const parentDirectory = path17.dirname(currentDirectory);
+    const parentDirectory = path16.dirname(currentDirectory);
     if (parentDirectory === currentDirectory) {
       return void 0;
     }
@@ -14919,7 +14596,7 @@ async function loadSeedFixtureEntries(rootDir, relativePath) {
   if (!relativePath) {
     return null;
   }
-  const parsed = await readJsonFile(path18.join(rootDir, relativePath));
+  const parsed = await readJsonFile(path17.join(rootDir, relativePath));
   const seedEntries = readSeedEntries(parsed, relativePath);
   if (!seedEntries) {
     throw new Error(`Seed fixture ${relativePath} must contain an array.`);
@@ -14982,7 +14659,7 @@ async function readArrayFixture(rootDir, relativePath) {
   if (!relativePath) {
     return null;
   }
-  const parsed = await readJsonFile(path18.join(rootDir, relativePath));
+  const parsed = await readJsonFile(path17.join(rootDir, relativePath));
   if (!Array.isArray(parsed)) {
     throw new Error(`Fixture file ${relativePath} must contain a JSON array.`);
   }
@@ -15036,7 +14713,7 @@ function readExtractionImportance(value, label, filePath) {
 
 // src/app/scenarios/claim-keys/load-scenarios.ts
 import { readdir, readFile as readFile2 } from "fs/promises";
-import path19 from "path";
+import path18 from "path";
 
 // src/app/scenarios/claim-keys/validation/expectations.ts
 var EXPECTATION_KEYS = /* @__PURE__ */ new Set(["warnings", "rows", "rowCount", "proposals", "storeResult", "surgeonSummary"]);
@@ -15298,13 +14975,13 @@ function validateClaimKeyScenario(input, filePath, rootDir = getDefaultClaimKeyS
 async function discoverScenarioFiles(rootDir) {
   const files = [];
   for (const kind of SUPPORTED_KINDS2) {
-    const directory = path19.join(rootDir, kind);
+    const directory = path18.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(path19.join(directory, entry.name));
+      files.push(path18.join(directory, entry.name));
     }
   }
   return files.sort();
@@ -15322,11 +14999,11 @@ async function readScenarioJsonFile(filePath) {
 
 // src/app/scenarios/claim-keys/sandbox.ts
 import { mkdir, rm } from "fs/promises";
-import path20 from "path";
+import path19 from "path";
 var SANDBOX_DB_FILENAME = "knowledge.db";
 async function createClaimKeyScenarioSandbox(root) {
-  const resolvedRoot = path20.resolve(root);
-  const dbPath = path20.join(resolvedRoot, SANDBOX_DB_FILENAME);
+  const resolvedRoot = path19.resolve(root);
+  const dbPath = path19.join(resolvedRoot, SANDBOX_DB_FILENAME);
   await mkdir(resolvedRoot, { recursive: true });
   await removeDatabaseFiles(dbPath);
   const database = await createDatabase(dbPath);
@@ -15351,7 +15028,7 @@ async function removeDatabaseFiles(dbPath) {
 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);
+  const seedClaimKey = normalizeOptionalString11(seedEntry.claim_key);
   const preserveLegacyStoredClaimKey = shouldPreserveLegacyStoredClaimKey(seedClaimKey);
   const validatedInput = validateSeedStoreInput(seedEntry, preserveLegacyStoredClaimKey);
   const lifecycle = preserveLegacyStoredClaimKey ? resolveLegacySeedClaimKeyLifecycle(seedEntry) : resolveSeedClaimKeyLifecycle(seedEntry, validatedInput);
@@ -15373,11 +15050,11 @@ function buildClaimKeyScenarioSeedEntry(seedEntry) {
     quality_score: 0.5,
     recall_count: 0,
     last_recalled_at: void 0,
-    superseded_by: normalizeOptionalString12(seedEntry.superseded_by),
+    superseded_by: normalizeOptionalString11(seedEntry.superseded_by),
     valid_from: validatedInput.valid_from,
     valid_to: validatedInput.valid_to,
     claim_key: preserveLegacyStoredClaimKey ? seedClaimKey : lifecycle?.claim_key,
-    claim_key_raw: preserveLegacyStoredClaimKey ? normalizeOptionalString12(seedEntry.claim_key_raw) : lifecycle?.claim_key_raw,
+    claim_key_raw: preserveLegacyStoredClaimKey ? normalizeOptionalString11(seedEntry.claim_key_raw) : lifecycle?.claim_key_raw,
     claim_key_status: lifecycle?.claim_key_status,
     claim_key_source: lifecycle?.claim_key_source,
     claim_key_confidence: lifecycle?.claim_key_confidence,
@@ -15392,8 +15069,8 @@ function buildClaimKeyScenarioSeedEntry(seedEntry) {
     user_id: validatedInput.user_id,
     project: validatedInput.project,
     retired: seedEntry.retired ?? false,
-    retired_at: normalizeOptionalString12(seedEntry.retired_at),
-    retired_reason: normalizeOptionalString12(seedEntry.retired_reason),
+    retired_at: normalizeOptionalString11(seedEntry.retired_at),
+    retired_reason: normalizeOptionalString11(seedEntry.retired_reason),
     created_at: createdAt,
     updated_at: updatedAt
   };
@@ -15479,14 +15156,14 @@ function resolveLegacySeedClaimKeyLifecycle(seedEntry) {
   }
   return {
     claim_key: seedEntry.claim_key.trim(),
-    claim_key_raw: normalizeOptionalString12(seedEntry.claim_key_raw),
+    claim_key_raw: normalizeOptionalString11(seedEntry.claim_key_raw),
     claim_key_status: seedEntry.claim_key_status,
     claim_key_source: seedEntry.claim_key_source,
     claim_key_confidence: seedEntry.claim_key_confidence,
     claim_key_rationale: seedEntry.claim_key_rationale.trim(),
-    claim_support_source_kind: normalizeOptionalString12(seedEntry.claim_support_source_kind),
-    claim_support_locator: normalizeOptionalString12(seedEntry.claim_support_locator),
-    claim_support_observed_at: normalizeOptionalString12(seedEntry.claim_support_observed_at),
+    claim_support_source_kind: normalizeOptionalString11(seedEntry.claim_support_source_kind),
+    claim_support_locator: normalizeOptionalString11(seedEntry.claim_support_locator),
+    claim_support_observed_at: normalizeOptionalString11(seedEntry.claim_support_observed_at),
     claim_support_mode: seedEntry.claim_support_mode
   };
 }
@@ -15497,7 +15174,7 @@ function shouldPreserveLegacyStoredClaimKey(claimKey) {
   const normalized = normalizeClaimKey(claimKey);
   return !normalized.ok || normalized.value.claimKey !== claimKey;
 }
-function normalizeOptionalString12(value) {
+function normalizeOptionalString11(value) {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : void 0;
 }
@@ -15517,7 +15194,7 @@ async function listClaimKeyScenariosRuntime(options = {}) {
 }
 async function runClaimKeyScenariosRuntime(options = {}) {
   const runId = buildRunId();
-  const artifactRoot = path21.resolve(DEFAULT_ARTIFACT_ROOT, runId);
+  const artifactRoot = path20.resolve(DEFAULT_ARTIFACT_ROOT, runId);
   await mkdir2(artifactRoot, { recursive: true });
   let scenarios;
   try {
@@ -15569,11 +15246,11 @@ function filterClaimKeyScenarios(scenarios, options) {
 }
 async function runOneClaimKeyScenario(scenario, options) {
   const startedAt = Date.now();
-  const scenarioArtifactRoot = path21.join(options.artifactRoot, scenario.id);
-  const sandboxRoot = path21.join(scenarioArtifactRoot, "sandbox");
+  const scenarioArtifactRoot = path20.join(options.artifactRoot, scenario.id);
+  const sandboxRoot = path20.join(scenarioArtifactRoot, "sandbox");
   const warnings = [];
   await mkdir2(scenarioArtifactRoot, { recursive: true });
-  await writeJson(path21.join(scenarioArtifactRoot, "scenario.json"), scenario);
+  await writeJson(path20.join(scenarioArtifactRoot, "scenario.json"), scenario);
   let actual = {
     warnings: [],
     rows: [],
@@ -15686,7 +15363,7 @@ async function runIngestScenario(scenario, database, warnings, rootDir) {
     throw new Error(`Scenario ${scenario.id} is missing extraction fixture responses.`);
   }
   const result = await ingestPath(
-    path21.join(rootDir, scenario.input.transcriptFile),
+    path20.join(rootDir, scenario.input.transcriptFile),
     {
       files: localTranscriptFiles,
       transcript: openClawTranscriptParser,
@@ -15758,7 +15435,7 @@ async function runSurgeonScenario(scenario, database, _warnings, rootDir) {
     {
       port: createSurgeonPort(database),
       config: null,
-      model: getModel2("openai", "gpt-5.4-mini"),
+      model: getModel("openai", "gpt-5.4-mini"),
       now: () => SCENARIO_NOW,
       ...claimExtractionResponses ? {
         createClaimExtractionLlm: () => createFixtureLlm(claimExtractionResponses)
@@ -15828,20 +15505,20 @@ async function loadLatestSurgeonProposals(database, runId) {
   }));
 }
 async function writeScenarioArtifacts(scenarioArtifactRoot, actual, assertionResults, diffSummary) {
-  await writeJson(path21.join(scenarioArtifactRoot, "actual.json"), actual);
-  await writeJson(path21.join(scenarioArtifactRoot, "diff.json"), {
+  await writeJson(path20.join(scenarioArtifactRoot, "actual.json"), actual);
+  await writeJson(path20.join(scenarioArtifactRoot, "diff.json"), {
     assertions: assertionResults,
     diffSummary
   });
-  await writeJson(path21.join(scenarioArtifactRoot, "warnings.json"), actual.warnings);
+  await writeJson(path20.join(scenarioArtifactRoot, "warnings.json"), actual.warnings);
   if (actual.storeResult) {
-    await writeJson(path21.join(scenarioArtifactRoot, "store-result.json"), actual.storeResult);
+    await writeJson(path20.join(scenarioArtifactRoot, "store-result.json"), actual.storeResult);
   }
   if (actual.surgeonSummary) {
-    await writeJson(path21.join(scenarioArtifactRoot, "surgeon-summary.json"), actual.surgeonSummary);
+    await writeJson(path20.join(scenarioArtifactRoot, "surgeon-summary.json"), actual.surgeonSummary);
   }
   if (actual.proposals.length > 0) {
-    await writeJson(path21.join(scenarioArtifactRoot, "proposals.json"), actual.proposals);
+    await writeJson(path20.join(scenarioArtifactRoot, "proposals.json"), actual.proposals);
   }
 }
 async function writeJson(filePath, value) {
@@ -15973,12 +15650,12 @@ import { InvalidArgumentError as InvalidArgumentError6, Option as Option5 } from
 
 // src/app/surgeon/runtime.ts
 import { copyFile, mkdir as mkdir3 } from "fs/promises";
-import path22 from "path";
+import path21 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { getModel as getModel3 } from "@mariozechner/pi-ai";
+import { getModel as getModel2 } from "@mariozechner/pi-ai";
 var DEFAULT_SURGEON_PROVIDER = "openai";
 var DEFAULT_SURGEON_MODEL = "gpt-5.4-mini";
-var getModelWithStrings2 = getModel3;
+var getModelWithStrings = getModel2;
 async function runSurgeonRuntime(input) {
   const runtime = loadRuntimeConfig(input);
   const database = await createDatabase(runtime.dbPath);
@@ -15988,7 +15665,7 @@ async function runSurgeonRuntime(input) {
     const modelSelection = resolveSurgeonModel(runtime.config, input);
     const claimExtractionConfig = selection.includesClaimKeyQuality ? resolveClaimExtractionConfig(runtime.config) : { enabled: false };
     const claimModelSelection = claimExtractionConfig.enabled ? resolveModel(runtime.config, "claim") : null;
-    const model = getModelWithStrings2(modelSelection.provider, modelSelection.modelId);
+    const model = getModelWithStrings(modelSelection.provider, modelSelection.modelId);
     const credentials = resolveLlmCredentials(runtime.config, modelSelection.provider, input.env ?? process.env);
     const claimCredentials = claimModelSelection && claimModelSelection.provider === modelSelection.provider ? credentials : claimModelSelection ? resolveLlmCredentials(runtime.config, claimModelSelection.provider, input.env ?? process.env) : null;
     let recallPorts;
@@ -16114,7 +15791,7 @@ async function reviewSurgeonProposalRuntime(input) {
     if (proposal.reviewStatus !== "open") {
       throw new Error(`Proposal ${proposal.id} was already reviewed as ${proposal.reviewStatus}.`);
     }
-    const reviewReason = normalizeOptionalString13(input.reason);
+    const reviewReason = normalizeOptionalString12(input.reason);
     if (!reviewReason) {
       throw new Error("Review reason is required.");
     }
@@ -16173,8 +15850,8 @@ async function reviewSurgeonProposalRuntime(input) {
   }
 }
 function loadRuntimeConfig(input) {
-  const dbPathOverride = normalizeOptionalString13(input.dbPath) ?? normalizeOptionalString13(input.env?.AGENR_DB_PATH);
-  const configPathOverride = normalizeOptionalString13(input.env?.AGENR_CONFIG_PATH);
+  const dbPathOverride = normalizeOptionalString12(input.dbPath) ?? normalizeOptionalString12(input.env?.AGENR_DB_PATH);
+  const configPathOverride = normalizeOptionalString12(input.env?.AGENR_CONFIG_PATH);
   const config = readConfig({
     configPath: configPathOverride,
     dbPath: dbPathOverride
@@ -16187,8 +15864,8 @@ function loadRuntimeConfig(input) {
 function resolveSurgeonModel(config, input) {
   const surgeonModel = config.surgeon?.model;
   return {
-    provider: normalizeOptionalString13(input.provider) ?? normalizeOptionalString13(surgeonModel?.provider) ?? normalizeOptionalString13(config.provider) ?? DEFAULT_SURGEON_PROVIDER,
-    modelId: normalizeOptionalString13(input.model) ?? normalizeOptionalString13(surgeonModel?.model) ?? normalizeOptionalString13(config.model) ?? DEFAULT_SURGEON_MODEL
+    provider: normalizeOptionalString12(input.provider) ?? normalizeOptionalString12(surgeonModel?.provider) ?? normalizeOptionalString12(config.provider) ?? DEFAULT_SURGEON_PROVIDER,
+    modelId: normalizeOptionalString12(input.model) ?? normalizeOptionalString12(surgeonModel?.model) ?? normalizeOptionalString12(config.model) ?? DEFAULT_SURGEON_MODEL
   };
 }
 function resolveRuntimeSelection(input) {
@@ -16218,7 +15895,7 @@ async function backupDatabaseFile(dbPath) {
   }
   const sourcePath = resolveFilesystemPath(dbPath);
   const backupPath = `${sourcePath}.surgeon-backup-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replaceAll(".", "-")}`;
-  await mkdir3(path22.dirname(backupPath), { recursive: true });
+  await mkdir3(path21.dirname(backupPath), { recursive: true });
   await copyFile(sourcePath, backupPath);
   await copySidecarIfPresent(`${sourcePath}-wal`, `${backupPath}-wal`);
   await copySidecarIfPresent(`${sourcePath}-shm`, `${backupPath}-shm`);
@@ -16236,18 +15913,18 @@ async function copySidecarIfPresent(sourcePath, targetPath) {
 }
 function resolveFilesystemPath(value) {
   if (!value.startsWith("file:")) {
-    return path22.resolve(value);
+    return path21.resolve(value);
   }
   try {
     return fileURLToPath3(value);
   } catch {
-    return path22.resolve(value.slice("file:".length));
+    return path21.resolve(value.slice("file:".length));
   }
 }
 function isMissingFileError2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-function normalizeOptionalString13(value) {
+function normalizeOptionalString12(value) {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : void 0;
 }
@@ -16330,9 +16007,9 @@ function registerSurgeonCommand(program2) {
     try {
       const backlog = await loadSurgeonBacklogRuntime({
         state: options.state,
-        issueKind: normalizeOptionalString3(options.issueKind),
+        issueKind: normalizeOptionalString2(options.issueKind),
         eligibleOnly: options.eligibleOnly === true,
-        entryId: normalizeOptionalString3(options.entryId),
+        entryId: normalizeOptionalString2(options.entryId),
         limit: options.limit,
         offset: options.offset,
         env: process.env
@@ -16341,8 +16018,8 @@ function registerSurgeonCommand(program2) {
         renderBacklog(backlog, {
           state: options.state ?? "open",
           eligibleOnly: options.eligibleOnly === true,
-          issueKind: normalizeOptionalString3(options.issueKind),
-          entryId: normalizeOptionalString3(options.entryId),
+          issueKind: normalizeOptionalString2(options.issueKind),
+          entryId: normalizeOptionalString2(options.entryId),
           limit: options.limit ?? 20,
           offset: options.offset ?? 0
         })
@@ -16381,7 +16058,7 @@ function registerSurgeonCommand(program2) {
   });
   surgeonCommand.command("review <proposalId>").description("Apply or reject one open proposal").addOption(new Option5("--decision <decision>", "Review decision").choices(["apply", "reject"]).makeOptionMandatory(true)).option("--reason <text>", "Why this review decision was taken").action(async (proposalId, options) => {
     try {
-      const reason = normalizeOptionalString3(options.reason);
+      const reason = normalizeOptionalString2(options.reason);
       if (!reason) {
         throw new InvalidArgumentError6("Review reason is required.");
       }
@@ -16416,10 +16093,10 @@ function normalizeSurgeonRunCommand(options) {
     contextLimit: options.contextLimit,
     skipEvaluatedDays: options.skipEvaluatedDays,
     apply: options.apply === true,
-    model: normalizeOptionalString3(options.model),
-    provider: normalizeOptionalString3(options.provider),
+    model: normalizeOptionalString2(options.model),
+    provider: normalizeOptionalString2(options.provider),
     verbose: options.verbose === true,
-    tracePath: normalizeOptionalString3(options.trace),
+    tracePath: normalizeOptionalString2(options.trace),
     json: options.json === true
   };
 }
@@ -17140,12 +16817,12 @@ import { Option as Option6 } from "commander";
 // src/app/openclaw/inspect.ts
 async function loadOpenClawEntryTraceRuntime(input) {
   const selector = normalizeTraceSelector(input);
-  const configPathOverride = normalizeOptionalString14(input.env?.AGENR_CONFIG_PATH);
+  const configPathOverride = normalizeOptionalString13(input.env?.AGENR_CONFIG_PATH);
   const config = readConfig({
     configPath: configPathOverride,
-    dbPath: normalizeOptionalString14(input.dbPath) ?? normalizeOptionalString14(input.env?.AGENR_DB_PATH)
+    dbPath: normalizeOptionalString13(input.dbPath) ?? normalizeOptionalString13(input.env?.AGENR_DB_PATH)
   });
-  const dbPath = normalizeOptionalString14(input.dbPath) ?? normalizeOptionalString14(input.env?.AGENR_DB_PATH) ?? resolveDbPath(config);
+  const dbPath = normalizeOptionalString13(input.dbPath) ?? normalizeOptionalString13(input.env?.AGENR_DB_PATH) ?? resolveDbPath(config);
   const database = await createDatabase(dbPath);
   const repository = createOpenClawRepository(database);
   try {
@@ -17177,8 +16854,8 @@ async function resolveTraceEntryId(repository, selector) {
   return entry.id;
 }
 function normalizeTraceSelector(selector) {
-  const id = normalizeOptionalString14(selector.id);
-  const subject = normalizeOptionalString14(selector.subject);
+  const id = normalizeOptionalString13(selector.id);
+  const subject = normalizeOptionalString13(selector.subject);
   const last = selector.last === true;
   const count = (id ? 1 : 0) + (subject ? 1 : 0) + (last ? 1 : 0);
   if (count !== 1) {
@@ -17190,7 +16867,7 @@ function normalizeTraceSelector(selector) {
     last
   };
 }
-function normalizeOptionalString14(value) {
+function normalizeOptionalString13(value) {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : void 0;
 }