agenr 3.2.0 → 3.3.0

package/dist/cli.js

@@ -4,12 +4,6 @@ import {
   computeProcedureRevisionHash,
   computeProcedureSourceHash
 } from "./chunk-ZYADFKX3.js";
-import {
-  deriveOpenClawSessionIdFromFilePath,
-  openClawTranscriptParser,
-  parseTuiSessionKey,
-  readOpenClawSessionsStore
-} from "./chunk-ZAX3YSTU.js";
 import {
   applyClaimExtractionResultToEntry,
   backfillEpisodeEmbeddings,
@@ -25,6 +19,7 @@ import {
   evaluateClaimKeyCompactness,
   evaluateClaimKeySupport,
   executeEpisodeIngestPlan,
+  formatTargetSelectorFromParams,
   normalizeGroundingTags,
   prepareEpisodeIngest,
   previewClaimKeyExtraction,
@@ -33,7 +28,7 @@ import {
   tokenizeGroundingText,
   validateEntriesWithIndexes,
   validateSupersessionRules
-} from "./chunk-TMDNFBBC.js";
+} from "./chunk-M5M65AYP.js";
 import {
   DEFAULT_CLAIM_EXTRACTION_CONCURRENCY,
   DEFAULT_SURGEON_CONTEXT_LIMIT,
@@ -61,6 +56,7 @@ import {
   buildSurgeonProposalLifecycleRationale,
   composeEmbeddingText,
   configFileExists,
+  createAllEnabledFeatureFlagConfig,
   createDatabase,
   createEmbeddingClient,
   createLlmClient,
@@ -101,7 +97,7 @@ import {
   updateEntry,
   validateTemporalValidityRange,
   writeConfig
-} from "./chunk-FMQTRTWE.js";
+} from "./chunk-Z5X7T4QZ.js";
 import {
   compactClaimKey,
   describeClaimKeyNormalizationFailure,
@@ -230,7 +226,7 @@ function formatUnknownError(error) {
 }
 
 // src/cli/commands/ingest.ts
-import path9 from "path";
+import path11 from "path";
 import * as clack4 from "@clack/prompts";
 
 // src/core/ingestion/parser.ts
@@ -2211,8 +2207,8 @@ import path3 from "path";
 var GENERIC_TRANSCRIPT_FILE_PATTERN = /^.+\.jsonl(?:\.(?:reset|deleted)\..+)?$/iu;
 async function discoverTranscriptFiles(targetPath, options = {}) {
   const resolvedTargetPath = path3.resolve(targetPath);
-  const stat = await fs2.stat(resolvedTargetPath);
-  if (stat.isFile()) {
+  const stat2 = await fs2.stat(resolvedTargetPath);
+  if (stat2.isFile()) {
     return matchesTranscriptFileName(path3.basename(resolvedTargetPath)) ? [resolvedTargetPath] : [];
   }
   const recursive = options.recursive ?? true;
@@ -2231,6 +2227,1037 @@ function matchesTranscriptFileName(fileName) {
   return GENERIC_TRANSCRIPT_FILE_PATTERN.test(fileName.trim());
 }
 
+// src/adapters/openclaw/transcript/parser.ts
+import { createHash as createHash2 } from "crypto";
+import * as fs4 from "fs/promises";
+
+// src/adapters/openclaw/session/session-id.ts
+import path4 from "path";
+function deriveOpenClawSessionIdFromFilePath(sessionFile, logger) {
+  const normalizedSessionFile = sessionFile.trim();
+  if (normalizedSessionFile.length === 0) {
+    debugLog(logger, "session-id", "cannot derive session id from empty session file path");
+    return void 0;
+  }
+  const fileName = path4.basename(normalizedSessionFile);
+  const sessionId = fileName.replace(/\.jsonl(?:\..*)?$/i, "").trim();
+  debugLog(logger, "session-id", `derived session id "${sessionId || "<empty>"}" from file=${normalizedSessionFile}`);
+  return sessionId.length > 0 ? sessionId : void 0;
+}
+function debugLog(logger, subsystem, message) {
+  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
+}
+
+// src/adapters/openclaw/transcript/jsonl.ts
+function parseJsonObjectLineWithDiagnostics(line, lineNumber = 1) {
+  if (!line || line.trim().length === 0) {
+    return {
+      record: null
+    };
+  }
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return {
+        record: parsed
+      };
+    }
+    return {
+      record: null,
+      diagnostic: {
+        kind: "non_object_record",
+        lineNumber,
+        message: `Skipped non-object JSONL line ${lineNumber}`
+      }
+    };
+  } catch {
+    return {
+      record: null,
+      diagnostic: {
+        kind: "malformed_json",
+        lineNumber,
+        message: `Skipped malformed JSONL line ${lineNumber}`
+      }
+    };
+  }
+}
+function parseJsonlLines(raw, onRecord) {
+  const lines = raw.split(/\r?\n/);
+  const diagnostics = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]?.trim();
+    if (!line) {
+      continue;
+    }
+    const parsed = parseJsonObjectLineWithDiagnostics(line, index + 1);
+    if (parsed.diagnostic) {
+      diagnostics.push(parsed.diagnostic);
+      continue;
+    }
+    if (parsed.record) {
+      onRecord(parsed.record, index + 1);
+    }
+  }
+  return {
+    diagnostics
+  };
+}
+
+// src/adapters/openclaw/transcript/tool-summarization.ts
+var AGENR_FETCH_TARGET_MAX_CHARS = 80;
+var DEFAULT_TOOL_RESULT_DROP_NAMES = ["read", "web_fetch", "browser", "screenshot", "snapshot", "canvas", "tts"];
+var DEFAULT_TOOL_RESULT_KEEP_NAMES = ["web_search", "memory_search", "memory_get", "image"];
+var DEFAULT_TOOL_RESULT_DROP_NAME_SET = new Set(DEFAULT_TOOL_RESULT_DROP_NAMES);
+var DEFAULT_TOOL_RESULT_KEEP_NAME_SET = new Set(DEFAULT_TOOL_RESULT_KEEP_NAMES);
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function getString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function truncateInline(value, max) {
+  if (value.length <= max) {
+    return value;
+  }
+  return value.slice(0, max);
+}
+function firstStringArgValue(args, max) {
+  for (const value of Object.values(args)) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return truncateInline(value.trim(), max);
+    }
+  }
+  return void 0;
+}
+function extractAgenrStoreEntries(args) {
+  const nestedEntries = Array.isArray(args.entries) ? args.entries.flatMap((entry) => {
+    const record = asRecord(entry);
+    return record ? [record] : [];
+  }) : [];
+  if (nestedEntries.length > 0) {
+    return nestedEntries;
+  }
+  if (getString(args.type) || getString(args.subject) || getString(args.content) || getString(args.claimKey) || getString(args.claim_key) || getString(args.supersedes)) {
+    return [args];
+  }
+  return [];
+}
+function summarizeAgenrStoreEntry(entry) {
+  const type = getString(entry.type) ?? "unknown";
+  const subject = getString(entry.subject) ?? "(no subject)";
+  const claimKey = getString(entry.claimKey) ?? getString(entry.claim_key);
+  const claimKeySuffix = claimKey ? ` claim_key=${JSON.stringify(truncateInline(claimKey.trim(), 120))}` : "";
+  return `${type}: "${truncateInline(subject, 60)}"${claimKeySuffix}`;
+}
+function toolIdentifier(toolName, args) {
+  const normalizedToolName = toolName.trim().toLowerCase();
+  if (normalizedToolName === "read" || normalizedToolName === "edit" || normalizedToolName === "write") {
+    return getString(args.file_path) ?? getString(args.path) ?? getString(args.file) ?? "(unknown file)";
+  }
+  if (normalizedToolName === "exec") {
+    const command = getString(args.command) ?? getString(args.cmd) ?? "(unknown command)";
+    return truncateInline(command, 100);
+  }
+  if (normalizedToolName === "web_fetch") {
+    return getString(args.url) ?? "(unknown url)";
+  }
+  if (normalizedToolName === "web_search") {
+    return getString(args.query) ?? "(unknown query)";
+  }
+  if (normalizedToolName === "browser") {
+    const action = getString(args.action) ?? "(unknown action)";
+    const targetUrl = getString(args.targetUrl) ?? getString(args.url);
+    return targetUrl ? `${action} ${targetUrl}` : action;
+  }
+  if (normalizedToolName === "agenr_store") {
+    const entries = extractAgenrStoreEntries(args);
+    return `${entries.length} entr${entries.length === 1 ? "y" : "ies"}`;
+  }
+  if (normalizedToolName === "agenr_recall") {
+    const query = getString(args.query) ?? "(no query)";
+    return `"${truncateInline(query, 80)}"`;
+  }
+  if (normalizedToolName === "agenr_fetch") {
+    return formatTargetSelectorFromParams(args, { maxValueChars: AGENR_FETCH_TARGET_MAX_CHARS });
+  }
+  if (normalizedToolName === "message") {
+    const action = getString(args.action) ?? "(unknown action)";
+    const target = getString(args.target) ?? getString(args.to) ?? "(unknown target)";
+    return `${truncateInline(action, 80)} to ${truncateInline(target, 80)}`;
+  }
+  if (normalizedToolName === "sessions_spawn") {
+    return getString(args.label) ?? getString(args.task)?.slice(0, 60) ?? "(unknown task)";
+  }
+  if (normalizedToolName === "image") {
+    return getString(args.image) ?? getString(args.url) ?? getString(args.path) ?? "(unknown image)";
+  }
+  if (normalizedToolName === "canvas") {
+    return getString(args.action) ?? "(unknown action)";
+  }
+  if (normalizedToolName === "tts") {
+    const text2 = getString(args.text) ?? "(unknown text)";
+    return truncateInline(text2, 50);
+  }
+  return firstStringArgValue(args, 80) ?? "(unknown)";
+}
+function extractToolCallBlocks(content) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const toolCalls = [];
+  for (const block of content) {
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+    const name = getString(record.name) ?? getString(record.tool) ?? getString(record.tool_name);
+    const args = asRecord(record.arguments) ?? asRecord(record.args) ?? asRecord(record.input) ?? {};
+    const id = getString(record.id) ?? getString(record.toolCallId) ?? getString(record.tool_call_id) ?? getString(record.call_id);
+    if ((type === "toolcall" || type === "tool_call" || type === "tool_use" || type === "tooluse") && name) {
+      toolCalls.push({ name, args, id });
+      continue;
+    }
+    if (!type && name && ("arguments" in record || "args" in record || "input" in record)) {
+      toolCalls.push({ name, args, id });
+    }
+  }
+  return toolCalls;
+}
+function summarizeToolCall(call, options) {
+  const normalizedToolName = call.name.trim().toLowerCase();
+  const override = options?.overrides?.[normalizedToolName];
+  if (override) {
+    const summary = override(call);
+    if (summary) {
+      return summary;
+    }
+  }
+  const args = call.args;
+  const filePath = getString(args.file_path) ?? getString(args.path) ?? getString(args.file);
+  if (normalizedToolName === "read") {
+    return `[called Read: ${filePath ?? "(unknown file)"}]`;
+  }
+  if (normalizedToolName === "write") {
+    const content = getString(args.content) ?? getString(args.text) ?? "";
+    return `[called Write: ${filePath ?? "(unknown file)"} - ${content.length} chars]`;
+  }
+  if (normalizedToolName === "edit") {
+    const oldText = getString(args.oldText) ?? getString(args.old_string) ?? "";
+    return `[called Edit: ${filePath ?? "(unknown file)"} - replaced ${oldText.length} chars]`;
+  }
+  if (normalizedToolName === "exec") {
+    const command = getString(args.command) ?? getString(args.cmd) ?? "(unknown command)";
+    return `[called exec: ${truncateInline(command, 200)}]`;
+  }
+  if (normalizedToolName === "web_search") {
+    const query = getString(args.query) ?? "(unknown query)";
+    return `[called web_search: ${truncateInline(query, 200)}]`;
+  }
+  if (normalizedToolName === "web_fetch") {
+    const url = getString(args.url) ?? "(unknown url)";
+    return `[called web_fetch: ${truncateInline(url, 200)}]`;
+  }
+  if (normalizedToolName === "browser") {
+    const action = getString(args.action) ?? "(unknown action)";
+    return `[called browser: ${truncateInline(action, 200)}]`;
+  }
+  if (normalizedToolName === "message") {
+    const action = getString(args.action) ?? "(unknown action)";
+    const target = getString(args.target) ?? getString(args.to) ?? "(unknown target)";
+    return `[called message: ${truncateInline(action, 200)} to ${truncateInline(target, 200)}]`;
+  }
+  if (normalizedToolName === "agenr_store") {
+    const entries = extractAgenrStoreEntries(args);
+    if (entries.length === 0) {
+      return "[attempted brain store: (empty)]";
+    }
+    const summaries = entries.slice(0, 3).map(summarizeAgenrStoreEntry);
+    const countSuffix = entries.length > 3 ? ` (+${entries.length - 3} more)` : "";
+    return `[attempted brain store: ${summaries.join(", ")}${countSuffix}]`;
+  }
+  if (normalizedToolName === "agenr_recall") {
+    const query = getString(args.query) ?? "(no query)";
+    return `[recalled from brain: "${truncateInline(query, 100)}"]`;
+  }
+  if (normalizedToolName === "agenr_fetch") {
+    return `[fetched from brain: ${formatTargetSelectorFromParams(args, { maxValueChars: AGENR_FETCH_TARGET_MAX_CHARS })}]`;
+  }
+  if (normalizedToolName === "sessions_spawn") {
+    const label = getString(args.label);
+    const mode = getString(args.mode) ?? "run";
+    const model = getString(args.model);
+    const modelSuffix = model ? ` model=${model}` : "";
+    if (label) {
+      return `[spawned sub-agent: ${label} (${mode}${modelSuffix})]`;
+    }
+    const task = getString(args.task) ?? "(no task)";
+    return `[spawned sub-agent: ${truncateInline(task, 80)} (${mode}${modelSuffix})]`;
+  }
+  const relevantArgValue = firstStringArgValue(
+    Object.fromEntries(
+      Object.entries(args).filter(
+        ([key]) => !["buffer", "content", "data", "newText", "new_string", "oldText", "old_string"].includes(key) && !(normalizedToolName === "write" && key === "text")
+      )
+    ),
+    80
+  ) ?? "(no args)";
+  return `[called ${call.name}: ${relevantArgValue}]`;
+}
+function toolResultPlaceholder(toolName, args) {
+  const normalizedToolName = toolName.trim().length > 0 ? toolName.trim() : "unknown";
+  const identifier = toolIdentifier(normalizedToolName, args);
+  return `[tool result from ${normalizedToolName}: ${identifier} - filtered]`;
+}
+function shouldKeepToolResult(toolName, text2, policy) {
+  const normalizedToolName = (toolName ?? "").trim().toLowerCase();
+  const dropToolNames = policy?.dropToolNames ?? DEFAULT_TOOL_RESULT_DROP_NAME_SET;
+  const keepToolNames = policy?.keepToolNames ?? DEFAULT_TOOL_RESULT_KEEP_NAME_SET;
+  if (normalizedToolName && dropToolNames.has(normalizedToolName)) {
+    return { keep: false };
+  }
+  if (normalizedToolName && keepToolNames.has(normalizedToolName)) {
+    return { keep: true, truncateTo: 2e3 };
+  }
+  if (normalizedToolName === "exec") {
+    if (text2.length < 1e3) {
+      return { keep: true, truncateTo: 2e3 };
+    }
+    if (/(error|failed|fail)/i.test(text2)) {
+      return { keep: true, truncateTo: 2e3 };
+    }
+    return { keep: false };
+  }
+  if (text2.length < 500) {
+    return { keep: true, truncateTo: 2e3 };
+  }
+  return { keep: false };
+}
+
+// src/adapters/openclaw/transcript/message-content.ts
+var TEXT_BLOCK_TYPES = /* @__PURE__ */ new Set(["input_text", "output_text", "text"]);
+function normalizeWhitespace2(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function extractTextBlocks(content) {
+  if (typeof content === "string") {
+    const normalized = normalizeWhitespace2(content);
+    return normalized ? [normalized] : [];
+  }
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const textBlocks = [];
+  let nonTextBlockCount = 0;
+  for (const block of content) {
+    if (typeof block === "string") {
+      const normalized = normalizeWhitespace2(block);
+      if (normalized) {
+        textBlocks.push(normalized);
+      }
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    if (typeof record.text === "string") {
+      const normalized = normalizeWhitespace2(record.text);
+      if (normalized) {
+        textBlocks.push(normalized);
+      }
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+    if (typeof record.content === "string" && TEXT_BLOCK_TYPES.has(type)) {
+      const normalized = normalizeWhitespace2(record.content);
+      if (normalized) {
+        textBlocks.push(normalized);
+      }
+      continue;
+    }
+    nonTextBlockCount += 1;
+  }
+  if (textBlocks.length === 0 && nonTextBlockCount > 0) {
+    textBlocks.push(`[non-text content omitted: ${nonTextBlockCount} block${nonTextBlockCount === 1 ? "" : "s"}]`);
+  }
+  return textBlocks;
+}
+function extractRawTextBlocks(content) {
+  if (typeof content === "string") {
+    return [content];
+  }
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const textBlocks = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      textBlocks.push(block);
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    if (typeof record.text === "string") {
+      textBlocks.push(record.text);
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+    if (typeof record.content === "string" && TEXT_BLOCK_TYPES.has(type)) {
+      textBlocks.push(record.content);
+    }
+  }
+  return textBlocks;
+}
+function normalizeLabel(value) {
+  return value.trim().toLowerCase().replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeMessageText(content) {
+  return normalizeWhitespace2(extractTextBlocks(content).join("\n"));
+}
+function normalizeOpenClawRole(value) {
+  if (typeof value !== "string") {
+    return "unknown";
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "user" || normalized === "human") {
+    return "user";
+  }
+  if (normalized === "assistant" || normalized === "ai" || normalized === "developer") {
+    return "assistant";
+  }
+  if (normalized === "system") {
+    return "system";
+  }
+  if (normalized === "tool" || normalized === "toolresult" || normalized === "tool_result") {
+    return "toolResult";
+  }
+  return "unknown";
+}
+function truncateWithMarker(text2, maxChars) {
+  if (text2.length <= maxChars) {
+    return text2;
+  }
+  return `${text2.slice(0, maxChars)}
+[...truncated]`;
+}
+function isPureBase64(text2) {
+  const trimmed = text2.trim();
+  if (trimmed.length < 500) {
+    return false;
+  }
+  if (!/[+/=]/.test(trimmed)) {
+    return false;
+  }
+  return /^[A-Za-z0-9+/=\s]{500,}$/.test(trimmed);
+}
+function normalizeSessionLabel(value) {
+  const normalized = normalizeLabel(value);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function extractConversationLabel(content) {
+  const rawTextBlocks = extractRawTextBlocks(content);
+  for (const block of rawTextBlocks) {
+    const matches = block.matchAll(/```(?:json)?\s*([\s\S]*?)\s*```/gi);
+    for (const match of matches) {
+      const candidate = match[1];
+      if (!candidate) {
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(candidate);
+        const record = asRecord(parsed);
+        const conversationLabel = record ? getString(record.conversation_label) : void 0;
+        const normalizedLabel = conversationLabel ? normalizeSessionLabel(conversationLabel) : void 0;
+        if (normalizedLabel) {
+          return normalizedLabel;
+        }
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function extractAssistantTextParts(content) {
+  if (typeof content === "string") {
+    const normalized = normalizeWhitespace2(content);
+    return normalized ? [normalized] : [];
+  }
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const textParts = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      const normalized = normalizeWhitespace2(block);
+      if (normalized) {
+        textParts.push(normalized);
+      }
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    if (typeof record.text === "string") {
+      const normalized = normalizeWhitespace2(record.text);
+      if (normalized) {
+        textParts.push(normalized);
+      }
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+    if (typeof record.content === "string" && TEXT_BLOCK_TYPES.has(type)) {
+      const normalized = normalizeWhitespace2(record.content);
+      if (normalized) {
+        textParts.push(normalized);
+      }
+    }
+  }
+  return textParts;
+}
+function pushMessage(messages, role, text2, timestamp2) {
+  messages.push({
+    index: messages.length,
+    role,
+    text: text2,
+    timestamp: timestamp2
+  });
+}
+
+// src/adapters/openclaw/transcript/timestamps.ts
+import * as fs3 from "fs/promises";
+function parseTimestampValue(value) {
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed.toISOString();
+    }
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    const milliseconds = value > 1e12 ? value : value * 1e3;
+    const parsed = new Date(milliseconds);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed.toISOString();
+    }
+  }
+  return void 0;
+}
+function extractTimestamp(record) {
+  for (const field of ["timestamp", "ts", "created_at", "createdAt", "time", "date"]) {
+    const parsed = parseTimestampValue(record[field]);
+    if (parsed) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+async function getFileMtimeTimestamp(filePath) {
+  try {
+    const stat2 = await fs3.stat(filePath);
+    return parseTimestampValue(stat2.mtime.toISOString());
+  } catch {
+    return void 0;
+  }
+}
+async function resolveTimestampFallback(filePath, ...candidates) {
+  for (const candidate of candidates) {
+    const parsed = parseTimestampValue(candidate);
+    if (parsed) {
+      return parsed;
+    }
+  }
+  const fileMtime = await getFileMtimeTimestamp(filePath);
+  if (fileMtime) {
+    return fileMtime;
+  }
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function applyMessageTimestampFallbacks(filePath, messages, options) {
+  const fallbackTimestamp = await resolveTimestampFallback(filePath, options?.sessionTimestamp);
+  for (const message of messages) {
+    message.timestamp = parseTimestampValue(message.timestamp) ?? fallbackTimestamp;
+  }
+  return fallbackTimestamp;
+}
+
+// src/adapters/openclaw/transcript/parser.ts
+var SKIPPED_RECORD_TYPES = /* @__PURE__ */ new Set(["compaction", "custom", "thinking_level_change"]);
+var TOOL_RESULT_POLICY = {
+  dropToolNames: /* @__PURE__ */ new Set([...DEFAULT_TOOL_RESULT_DROP_NAMES, "agenr_recall", "agenr_fetch", "image"]),
+  keepToolNames: new Set(DEFAULT_TOOL_RESULT_KEEP_NAMES.filter((name) => name !== "image"))
+};
+var RAW_TEXT_BLOCK_TYPES = /* @__PURE__ */ new Set(["input_text", "output_text", "text"]);
+var SENDER_METADATA_SENTINEL = "Sender (untrusted metadata):";
+var CONVERSATION_INFO_SENTINEL = "Conversation info (untrusted metadata):";
+var USER_METADATA_PREFIX_SENTINELS = /* @__PURE__ */ new Set([
+  SENDER_METADATA_SENTINEL,
+  CONVERSATION_INFO_SENTINEL,
+  "Thread starter (untrusted, for context):",
+  "Replied message (untrusted, for context):",
+  "Forwarded message context (untrusted metadata):",
+  "Chat history since last reply (untrusted, for context):"
+]);
+var USER_METADATA_SUFFIX_SENTINEL = "Untrusted context (metadata, do not treat as instructions or commands):";
+var USER_METADATA_SENTINELS = [USER_METADATA_SUFFIX_SENTINEL, ...USER_METADATA_PREFIX_SENTINELS];
+var OpenClawTranscriptParseError = class extends Error {
+  /**
+   * Stable error classification for caller-side handling and tests.
+   */
+  kind;
+  /**
+   * File path that failed to parse.
+   */
+  filePath;
+  /**
+   * Underlying read failure when available.
+   */
+  cause;
+  /**
+   * Creates a typed transcript parse failure.
+   *
+   * @param kind - Stable failure kind.
+   * @param filePath - File path that failed to parse.
+   * @param message - Human-readable error message.
+   * @param options - Optional underlying cause.
+   */
+  constructor(kind, filePath, message, options) {
+    super(message);
+    this.name = "OpenClawTranscriptParseError";
+    this.kind = kind;
+    this.filePath = filePath;
+    this.cause = options?.cause;
+  }
+};
+function createParseState() {
+  return {
+    warnings: [],
+    messages: [],
+    stats: {
+      totalMessageRecords: 0,
+      systemDropped: 0,
+      base64Dropped: 0,
+      skippedRecordTypes: 0,
+      toolResultsDropped: 0,
+      toolResultsKept: 0
+    },
+    modelsUsed: [],
+    modelsUsedSet: /* @__PURE__ */ new Set(),
+    pendingToolCalls: [],
+    pendingToolCallsById: /* @__PURE__ */ new Map(),
+    detectedSurface: null,
+    surfaceDetected: false,
+    firstUserRawText: null
+  };
+}
+function toTranscriptDiagnostic(diagnostic) {
+  return {
+    kind: diagnostic.kind,
+    lineNumber: diagnostic.lineNumber,
+    message: diagnostic.message
+  };
+}
+function formatTranscriptDiagnosticWarning(diagnostic) {
+  return diagnostic.message;
+}
+async function readTranscriptFileStrict(filePath) {
+  try {
+    return await fs4.readFile(filePath, "utf8");
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      throw new OpenClawTranscriptParseError("missing_file", filePath, `Transcript file not found: ${filePath}`, { cause: error });
+    }
+    throw new OpenClawTranscriptParseError("unreadable_file", filePath, `Could not read transcript file ${filePath}: ${formatErrorMessage(error)}`, {
+      cause: error
+    });
+  }
+}
+function extractRawMessageText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  const blocks = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      blocks.push(block);
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    if (typeof record.text === "string") {
+      blocks.push(record.text);
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+    if (typeof record.content === "string" && RAW_TEXT_BLOCK_TYPES.has(type)) {
+      blocks.push(record.content);
+    }
+  }
+  return blocks.join("\n");
+}
+function stripOpenClawUserMetadata(content) {
+  const normalizedText = normalizeMessageText(content);
+  if (normalizedText.length === 0) {
+    return normalizedText;
+  }
+  const rawText = extractRawMessageText(content);
+  if (rawText.length === 0 || !USER_METADATA_SENTINELS.some((sentinel) => rawText.includes(sentinel))) {
+    return normalizedText;
+  }
+  return normalizeMessageText(stripMetadataBlocks(rawText));
+}
+function stripMetadataBlocks(text2) {
+  const lines = text2.split(/\r?\n/u);
+  let index = 0;
+  while (index < lines.length) {
+    while (index < lines.length && lines[index]?.trim().length === 0) {
+      index += 1;
+    }
+    if (index >= lines.length) {
+      return "";
+    }
+    const line = lines[index]?.trim();
+    if (line === USER_METADATA_SUFFIX_SENTINEL) {
+      return "";
+    }
+    if (!line || !USER_METADATA_PREFIX_SENTINELS.has(line)) {
+      break;
+    }
+    const nextIndex = skipMetadataJsonFence(lines, index);
+    if (nextIndex === index) {
+      break;
+    }
+    index = nextIndex;
+  }
+  const suffixIndex = lines.findIndex((line, lineIndex) => lineIndex >= index && line.trim() === USER_METADATA_SUFFIX_SENTINEL);
+  const body = suffixIndex >= 0 ? lines.slice(index, suffixIndex) : lines.slice(index);
+  return body.join("\n").trim();
+}
+function skipMetadataJsonFence(lines, startIndex) {
+  let index = startIndex + 1;
+  while (index < lines.length && lines[index]?.trim().length === 0) {
+    index += 1;
+  }
+  if (index >= lines.length || !/^```(?:json)?\s*$/iu.test(lines[index]?.trim() ?? "")) {
+    return startIndex;
+  }
+  index += 1;
+  while (index < lines.length && !/^```\s*$/u.test(lines[index]?.trim() ?? "")) {
+    index += 1;
+  }
+  if (index >= lines.length) {
+    return startIndex;
+  }
+  index += 1;
+  while (index < lines.length && lines[index]?.trim().length === 0) {
+    index += 1;
+  }
+  return index;
+}
+function addModelUsed(state, value) {
+  const modelId = getString(value);
+  if (!modelId || state.modelsUsedSet.has(modelId)) {
+    return;
+  }
+  state.modelsUsedSet.add(modelId);
+  state.modelsUsed.push(modelId);
+}
+function setDetectedSurface(state, surface) {
+  if (state.surfaceDetected || !surface) {
+    return;
+  }
+  state.detectedSurface = surface;
+  state.surfaceDetected = true;
+}
+function readInboundSurface(record) {
+  const inboundMeta = asRecord(record.inbound_meta);
+  const surface = getString(inboundMeta?.surface)?.trim().toLowerCase();
+  return surface || null;
+}
+function extractMetadataPayload(rawText, sentinel) {
+  const lines = rawText.split(/\r?\n/u);
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index]?.trim() !== sentinel) {
+      continue;
+    }
+    let fenceIndex = index + 1;
+    while (fenceIndex < lines.length && lines[fenceIndex]?.trim().length === 0) {
+      fenceIndex += 1;
+    }
+    if (fenceIndex >= lines.length || !/^```(?:json)?\s*$/iu.test(lines[fenceIndex]?.trim() ?? "")) {
+      continue;
+    }
+    fenceIndex += 1;
+    const jsonLines = [];
+    while (fenceIndex < lines.length && !/^```\s*$/u.test(lines[fenceIndex]?.trim() ?? "")) {
+      jsonLines.push(lines[fenceIndex] ?? "");
+      fenceIndex += 1;
+    }
+    if (fenceIndex >= lines.length) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(jsonLines.join("\n").trim());
+      return asRecord(parsed);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function mapKnownSurface(value) {
+  if (!value) {
+    return null;
+  }
+  if (value.includes("telegram")) {
+    return "telegram";
+  }
+  if (value.includes("signal")) {
+    return "signal";
+  }
+  if (value.includes("discord")) {
+    return "discord";
+  }
+  if (value.includes("openclaw-tui")) {
+    return "tui";
+  }
+  if (value.includes("gateway-client") || value.includes("openclaw-control-ui") || value.includes("webchat")) {
+    return "webchat";
+  }
+  return null;
+}
+function extractSenderSurface(rawText) {
+  const payload = extractMetadataPayload(rawText, SENDER_METADATA_SENTINEL);
+  if (!payload) {
+    return null;
+  }
+  const label = getString(payload.label)?.trim().toLowerCase() ?? getString(payload.id)?.trim().toLowerCase() ?? "";
+  return mapKnownSurface(label);
+}
+function extractConversationInfoSurface(rawText) {
+  const payload = extractMetadataPayload(rawText, CONVERSATION_INFO_SENTINEL);
+  if (!payload) {
+    return null;
+  }
+  const senderId = getString(payload.sender_id)?.trim().toLowerCase() ?? "";
+  return mapKnownSurface(senderId);
+}
+function inferSurfaceFromContent(firstUserRawText) {
+  const normalized = firstUserRawText?.trim().toLowerCase() ?? "";
+  if (!normalized) {
+    return null;
+  }
+  if (normalized.includes("[subagent context]")) {
+    return "subagent";
+  }
+  if (normalized.includes("heartbeat.md")) {
+    return "heartbeat";
+  }
+  return null;
+}
+function resolveToolContext(state, message) {
+  const toolCallId = getString(message.toolCallId) ?? getString(message.tool_call_id) ?? getString(message.call_id) ?? getString(message.id);
+  if (toolCallId && state.pendingToolCallsById.has(toolCallId)) {
+    const context = state.pendingToolCallsById.get(toolCallId) ?? null;
+    state.pendingToolCallsById.delete(toolCallId);
+    if (context) {
+      const queuedIndex = state.pendingToolCalls.findIndex((toolCall) => toolCall.id === toolCallId);
+      if (queuedIndex >= 0) {
+        state.pendingToolCalls.splice(queuedIndex, 1);
+      }
+    }
+    return context;
+  }
+  return state.pendingToolCalls.shift() ?? null;
+}
+function handleMessageRecord(state, record, message) {
+  state.stats.totalMessageRecords += 1;
+  const role = normalizeOpenClawRole(message.role);
+  if (!state.surfaceDetected) {
+    setDetectedSurface(state, readInboundSurface(message));
+  }
+  if (!state.surfaceDetected && role === "user") {
+    const rawText = extractRawMessageText(message.content);
+    if (state.firstUserRawText === null) {
+      state.firstUserRawText = rawText;
+    }
+    setDetectedSurface(state, extractSenderSurface(rawText));
+    if (!state.surfaceDetected) {
+      setDetectedSurface(state, extractConversationInfoSurface(rawText));
+    }
+  }
+  if (role === "system") {
+    state.stats.systemDropped += 1;
+    return "known_skip";
+  }
+  const timestamp2 = extractTimestamp(record) ?? extractTimestamp(message);
+  if (role === "user") {
+    const extractedLabel = extractConversationLabel(message.content);
+    if (extractedLabel) {
+      state.sessionLabel = extractedLabel;
+    }
+    const text2 = stripOpenClawUserMetadata(message.content);
+    if (!text2) {
+      return "known_skip";
+    }
+    if (isPureBase64(text2)) {
+      state.stats.base64Dropped += 1;
+      return "known_skip";
+    }
+    pushMessage(state.messages, "user", text2, timestamp2);
+    return "accepted";
+  }
+  if (role === "assistant") {
+    const toolCalls = extractToolCallBlocks(message.content);
+    for (const toolCall of toolCalls) {
+      state.pendingToolCalls.push(toolCall);
+      if (toolCall.id) {
+        state.pendingToolCallsById.set(toolCall.id, toolCall);
+      }
+    }
+    const assistantText = [...extractAssistantTextParts(message.content), ...toolCalls.map((toolCall) => summarizeToolCall(toolCall))].join(" ").trim();
+    addModelUsed(state, message.model);
+    if (!assistantText) {
+      return "known_skip";
+    }
+    if (isPureBase64(assistantText)) {
+      state.stats.base64Dropped += 1;
+      return "known_skip";
+    }
+    pushMessage(state.messages, "assistant", truncateWithMarker(assistantText, 5e3), timestamp2);
+    return "accepted";
+  }
+  if (role !== "toolResult") {
+    return "structurally_invalid";
+  }
+  const toolContext = resolveToolContext(state, message);
+  const toolName = getString(message.name) ?? getString(message.tool) ?? getString(record.name) ?? getString(record.tool) ?? toolContext?.name;
+  const toolArgs = toolContext?.args ?? {};
+  const toolText = normalizeMessageText(message.content);
+  if (!toolText) {
+    return "known_skip";
+  }
+  if (isPureBase64(toolText)) {
+    state.stats.base64Dropped += 1;
+    return "known_skip";
+  }
+  const decision = shouldKeepToolResult(toolName, toolText, TOOL_RESULT_POLICY);
+  if (decision.keep) {
+    state.stats.toolResultsKept += 1;
+    pushMessage(state.messages, "assistant", decision.truncateTo ? truncateWithMarker(toolText, decision.truncateTo) : toolText, timestamp2);
+    return "accepted";
+  }
+  state.stats.toolResultsDropped += 1;
+  pushMessage(state.messages, "assistant", toolResultPlaceholder(toolName ?? "unknown", toolArgs), timestamp2);
+  return "accepted";
+}
+function handleRecord(state, record) {
+  if (record.type === "session") {
+    state.sessionId = getString(record.id) ?? state.sessionId;
+    state.sessionTimestamp = extractTimestamp(record) ?? state.sessionTimestamp;
+    state.sessionLabel = normalizeSessionLabel(getString(record.conversation_label) ?? "") ?? state.sessionLabel;
+    state.workingDirectory = getString(record.cwd) ?? state.workingDirectory;
+    addModelUsed(state, record.model);
+    if (!state.surfaceDetected) {
+      setDetectedSurface(state, readInboundSurface(record));
+    }
+    return "accepted";
+  }
+  if (!state.surfaceDetected) {
+    setDetectedSurface(state, readInboundSurface(record));
+  }
+  if (record.type === "model_change") {
+    addModelUsed(state, record.modelId);
+    state.stats.skippedRecordTypes += 1;
+    return "known_skip";
+  }
+  if (typeof record.type === "string" && SKIPPED_RECORD_TYPES.has(record.type)) {
+    state.stats.skippedRecordTypes += 1;
+    return "known_skip";
+  }
+  const message = asRecord(record.message);
+  if (!message) {
+    return "structurally_invalid";
+  }
+  return handleMessageRecord(state, record, message);
+}
+function buildFilterWarning(stats) {
+  return `Filtered transcript: ${stats.toolResultsDropped} tool results dropped, ${stats.toolResultsKept} kept, ${stats.systemDropped} system dropped, ${stats.base64Dropped} base64 dropped.`;
+}
+function isFileNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+var OpenClawTranscriptParser = class {
+  /**
+   * Parses an OpenClaw JSONL transcript file into agenr transcript data.
+   *
+   * @param filePath - Absolute or relative path to the transcript file.
+   * @param options - Optional parser flags for verbose diagnostics.
+   * @returns Parsed transcript messages, warnings, and metadata.
+   */
+  async parseFile(filePath, options) {
+    const raw = await readTranscriptFileStrict(filePath);
+    const verbose = options?.verbose === true;
+    const state = createParseState();
+    const transcriptHash = createHash2("sha256").update(raw).digest("hex");
+    const diagnostics = [];
+    const jsonlResult = parseJsonlLines(raw, (record, lineNumber) => {
+      const outcome = handleRecord(state, record);
+      if (outcome === "structurally_invalid") {
+        diagnostics.push({
+          kind: "structurally_invalid_record",
+          lineNumber,
+          message: `Skipped structurally invalid transcript record on line ${lineNumber}`
+        });
+      }
+    });
+    diagnostics.push(...jsonlResult.diagnostics.map(toTranscriptDiagnostic));
+    state.warnings.push(...diagnostics.map(formatTranscriptDiagnosticWarning));
+    if (!state.surfaceDetected && state.firstUserRawText) {
+      setDetectedSurface(state, inferSurfaceFromContent(state.firstUserRawText));
+    }
+    const fallbackTimestamp = state.messages.length > 0 ? await applyMessageTimestampFallbacks(filePath, state.messages, { sessionTimestamp: state.sessionTimestamp }) : await resolveTimestampFallback(filePath, state.sessionTimestamp);
+    if (verbose) {
+      state.warnings.push(buildFilterWarning(state.stats));
+    }
+    const startedAt = state.sessionTimestamp ?? state.messages[0]?.timestamp ?? fallbackTimestamp;
+    const endedAt = state.messages[state.messages.length - 1]?.timestamp ?? state.sessionTimestamp ?? fallbackTimestamp;
+    const stableSessionId = state.sessionId ?? deriveOpenClawSessionIdFromFilePath(filePath);
+    return {
+      messages: state.messages,
+      warnings: state.warnings,
+      metadata: {
+        sessionId: state.sessionId,
+        sessionLabel: state.sessionLabel,
+        startedAt,
+        endedAt,
+        messageCount: state.messages.length,
+        transcriptHash,
+        modelsUsed: state.modelsUsed.length > 0 ? state.modelsUsed : void 0,
+        reconstructedSurface: state.detectedSurface,
+        surfaceReconstructionSource: state.surfaceDetected ? "reconstructed" : "none",
+        sourceIdentity: stableSessionId ? `openclaw-session:${stableSessionId}` : void 0,
+        sourceIdentityKind: stableSessionId ? "openclaw_session" : void 0,
+        workingDirectory: state.workingDirectory
+      }
+    };
+  }
+};
+var openClawTranscriptParser = new OpenClawTranscriptParser();
+
 // src/cli/shared/parse.ts
 import { InvalidArgumentError } from "commander";
 function normalizeOptionalString2(value) {
@@ -2365,13 +3392,13 @@ function timestamp() {
 import { InvalidArgumentError as InvalidArgumentError3, Option as Option2 } from "commander";
 
 // src/cli/commands/ingest-episodes.ts
-import fs4 from "fs/promises";
-import path6 from "path";
+import fs7 from "fs/promises";
+import path8 from "path";
 import * as clack2 from "@clack/prompts";
 import { InvalidArgumentError as InvalidArgumentError2, Option } from "commander";
 
 // src/adapters/db/episode-ingest-support.ts
-import path4 from "path";
+import path5 from "path";
 function createEpisodeIngestSupportPort(executor) {
   return {
     countEntries: async () => countRows(executor, "SELECT COUNT(*) AS count FROM entries"),
@@ -2387,7 +3414,7 @@ async function hasRelevantProvenanceMatch(executor, sampleFiles) {
   if (ingestLogMatches > 0) {
     return true;
   }
-  const basenames = Array.from(new Set(sampleFiles.map((filePath) => path4.basename(filePath))));
+  const basenames = Array.from(new Set(sampleFiles.map((filePath) => path5.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);
@@ -2410,6 +3437,171 @@ async function countRows(executor, sql, args = []) {
   return Number.isFinite(normalized) ? normalized : 0;
 }
 
+// src/adapters/openclaw/session/sessions-store-reader.ts
+import * as fs5 from "fs/promises";
+import path6 from "path";
+async function readOpenClawSessionsStore(sessionsDir, logger) {
+  if (sessionsDir.trim().length === 0) {
+    debugLog2(logger, "sessions-store-reader", "skipping sessions.json read because sessionsDir is empty");
+    return [];
+  }
+  const result = await readOpenClawSessionsStoreWithDiagnostics(sessionsDir);
+  for (const diagnostic of result.diagnostics) {
+    debugLog2(logger, "sessions-store-reader", diagnostic.message);
+  }
+  if (result.diagnostics.length === 0) {
+    debugLog2(
+      logger,
+      "sessions-store-reader",
+      `loaded sessions.json entries=${result.entries.length} path=${path6.join(path6.resolve(sessionsDir.trim()), "sessions.json")}`
+    );
+  }
+  return result.entries;
+}
+async function readOpenClawSessionsStoreWithDiagnostics(sessionsDir) {
+  const normalizedSessionsDir = sessionsDir.trim();
+  if (normalizedSessionsDir.length === 0) {
+    return {
+      entries: [],
+      diagnostics: []
+    };
+  }
+  const resolvedSessionsDir = path6.resolve(normalizedSessionsDir);
+  const sessionsJsonPath = path6.join(resolvedSessionsDir, "sessions.json");
+  try {
+    const raw = await fs5.readFile(sessionsJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed)) {
+      return {
+        entries: [],
+        diagnostics: [
+          {
+            kind: "structurally_invalid_file",
+            message: `sessions.json did not contain an object: path=${sessionsJsonPath}`,
+            path: sessionsJsonPath
+          }
+        ]
+      };
+    }
+    const entries = [];
+    for (const [sessionKey, value] of Object.entries(parsed)) {
+      const normalizedSessionKey = sessionKey.trim();
+      if (normalizedSessionKey.length === 0) {
+        continue;
+      }
+      if (!isRecord(value)) {
+        continue;
+      }
+      const sessionId = asTrimmedString(value["sessionId"]);
+      const sessionFile = asTrimmedString(value["sessionFile"]);
+      const origin = isRecord(value["origin"]) ? value["origin"] : void 0;
+      const surface = asTrimmedString(origin?.["surface"]);
+      const provider = asTrimmedString(origin?.["provider"]);
+      const chatType = asTrimmedString(value["chatType"]);
+      const updatedAt = asFiniteNumber(value["updatedAt"]);
+      entries.push({
+        sessionKey: normalizedSessionKey,
+        ...sessionId ? { sessionId } : {},
+        ...sessionFile ? { sessionFile: resolveSessionStorePath(sessionFile, resolvedSessionsDir) } : {},
+        ...surface ? { surface } : {},
+        ...provider ? { provider } : {},
+        ...chatType ? { chatType } : {},
+        ...updatedAt !== void 0 ? { updatedAt } : {}
+      });
+    }
+    return {
+      entries,
+      diagnostics: []
+    };
+  } catch (error) {
+    if (isFileNotFound2(error)) {
+      return {
+        entries: [],
+        diagnostics: [
+          {
+            kind: "missing_file",
+            message: `sessions.json missing at ${sessionsJsonPath}`,
+            path: sessionsJsonPath
+          }
+        ]
+      };
+    }
+    if (error instanceof SyntaxError) {
+      return {
+        entries: [],
+        diagnostics: [
+          {
+            kind: "malformed_json",
+            message: `sessions.json parse failed at ${sessionsJsonPath}: ${error.message}`,
+            path: sessionsJsonPath
+          }
+        ]
+      };
+    }
+    return {
+      entries: [],
+      diagnostics: [
+        {
+          kind: "unreadable_file",
+          message: `sessions.json read failed at ${sessionsJsonPath}: ${formatErrorMessage2(error)}`,
+          path: sessionsJsonPath
+        }
+      ]
+    };
+  }
+}
+function resolveSessionStorePath(candidatePath, sessionsDir) {
+  return path6.isAbsolute(candidatePath) ? path6.resolve(candidatePath) : path6.resolve(sessionsDir, candidatePath);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asTrimmedString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function asFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function debugLog2(logger, subsystem, message) {
+  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
+}
+function isFileNotFound2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function formatErrorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/adapters/openclaw/session/tui-lane.ts
+var TUI_SESSION_KEY_PATTERN = /^agent:([^:]+):([^:]+)$/i;
+var TUI_UUID_LANE_PATTERN = /^tui[a-z0-9]*-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var TUI_UUID_SUFFIX_PATTERN = /-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function parseTuiSessionKey(sessionKey) {
+  const normalizedSessionKey = sessionKey.trim();
+  if (normalizedSessionKey.length === 0) {
+    return null;
+  }
+  const match = TUI_SESSION_KEY_PATTERN.exec(normalizedSessionKey);
+  if (!match) {
+    return null;
+  }
+  const [, agentId, instanceLane] = match;
+  const normalizedAgentId = agentId?.trim();
+  const normalizedInstanceLane = instanceLane?.trim();
+  if (!normalizedAgentId || !normalizedInstanceLane || !normalizedInstanceLane.toLowerCase().startsWith("tui")) {
+    return null;
+  }
+  const stableLane = TUI_UUID_LANE_PATTERN.test(normalizedInstanceLane) ? normalizedInstanceLane.replace(TUI_UUID_SUFFIX_PATTERN, "") : normalizedInstanceLane;
+  return {
+    agentId: normalizedAgentId,
+    stableLane,
+    instanceLane: normalizedInstanceLane
+  };
+}
+
 // src/adapters/openclaw/session/session-registry.ts
 var GENERIC_AGENT_SESSION_KEY_PATTERN = /^agent:([^:]+):/i;
 async function loadOpenClawSessionRegistry(sessionsDir) {
@@ -2476,17 +3668,17 @@ function normalizeNullableString(value) {
 }
 
 // src/adapters/openclaw/session/transcript-files.ts
-import fs3 from "fs/promises";
-import path5 from "path";
+import fs6 from "fs/promises";
+import path7 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 = path5.resolve(targetPath);
-  const stat = await fs3.stat(resolvedTargetPath);
-  if (stat.isFile()) {
-    return matchesOpenClawTranscriptFile(path5.basename(resolvedTargetPath)) ? [resolvedTargetPath] : [];
+  const resolvedTargetPath = path7.resolve(targetPath);
+  const stat2 = await fs6.stat(resolvedTargetPath);
+  if (stat2.isFile()) {
+    return matchesOpenClawTranscriptFile(path7.basename(resolvedTargetPath)) ? [resolvedTargetPath] : [];
   }
-  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));
+  const entries = await fs6.readdir(resolvedTargetPath, { recursive: true, withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && matchesOpenClawTranscriptFile(entry.name)).map((entry) => path7.resolve(entry.parentPath ?? resolvedTargetPath, entry.name)).sort((left, right) => left.localeCompare(right));
 }
 var openClawTranscriptFiles = {
   discoverFiles: discoverOpenClawTranscriptFiles
@@ -2533,7 +3725,7 @@ function registerIngestEpisodesCommand(parent) {
       }
       const { provider, modelId } = resolveEpisodeModel(config, commandInput.modelOverride);
       const modelInfo = createEpisodeIngestSummaryModelInfo(provider, modelId);
-      const resolvedTargetPath = path6.resolve(normalizedTargetPath);
+      const resolvedTargetPath = path8.resolve(normalizedTargetPath);
       const sessionsDir = await resolveSessionsDirectory(resolvedTargetPath);
       const ports = await createEpisodeIngestPorts(database, sessionsDir);
       const embeddingSetup = resolveEpisodeEmbeddingSetup(config, commandInput);
@@ -2748,8 +3940,8 @@ function createEpisodeIngestSummaryLlm(provider, modelId, apiKey) {
   };
 }
 async function resolveSessionsDirectory(targetPath) {
-  const stat = await fs4.stat(targetPath);
-  return stat.isFile() ? path6.dirname(targetPath) : targetPath;
+  const stat2 = await fs7.stat(targetPath);
+  return stat2.isFile() ? path8.dirname(targetPath) : targetPath;
 }
 function resolveEpisodeDbPath(config, overridePath) {
   const normalizedOverride = normalizeOptionalString2(overridePath);
@@ -2759,7 +3951,7 @@ function resolveEpisodeDbPath(config, overridePath) {
   if (normalizedOverride === ":memory:" || normalizedOverride.startsWith("file:")) {
     return normalizedOverride;
   }
-  return path6.resolve(normalizedOverride);
+  return path8.resolve(normalizedOverride);
 }
 function resolveEpisodeModel(config, overrideRef) {
   const resolved = resolveModel(config, "episode");
@@ -2873,7 +4065,7 @@ function reportEpisodeProgress(completed, total, session) {
 }
 function formatEpisodeProgressLine(completed, total, session) {
   const prefix = completed !== void 0 && total !== void 0 ? `${completed}/${total} ` : "";
-  const fileLabel = path6.basename(session.filePath);
+  const fileLabel = path8.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}`;
@@ -2917,26 +4109,26 @@ function parseEpisodeIngestConcurrency(value) {
 }
 
 // src/cli/commands/ingest-procedures.ts
-import path8 from "path";
+import path10 from "path";
 import * as clack3 from "@clack/prompts";
 import "commander";
 
 // src/adapters/files/procedure-files.ts
-import fs5 from "fs/promises";
-import path7 from "path";
+import fs8 from "fs/promises";
+import path9 from "path";
 var PROCEDURE_FILE_PATTERN = /^.+\.ya?ml$/iu;
 async function discoverProcedureFiles(targetPath, options = {}) {
-  const resolvedTargetPath = path7.resolve(targetPath);
-  const stat = await fs5.stat(resolvedTargetPath);
-  if (stat.isFile()) {
-    return matchesProcedureFileName(path7.basename(resolvedTargetPath)) ? [resolvedTargetPath] : [];
+  const resolvedTargetPath = path9.resolve(targetPath);
+  const stat2 = await fs8.stat(resolvedTargetPath);
+  if (stat2.isFile()) {
+    return matchesProcedureFileName(path9.basename(resolvedTargetPath)) ? [resolvedTargetPath] : [];
   }
   const recursive = options.recursive ?? true;
-  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));
+  const entries = recursive ? await fs8.readdir(resolvedTargetPath, { recursive: true, withFileTypes: true }) : await fs8.readdir(resolvedTargetPath, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && matchesProcedureFileName(entry.name)).map((entry) => path9.resolve(entry.parentPath ?? resolvedTargetPath, entry.name)).sort((left, right) => left.localeCompare(right));
 }
 async function readProcedureFile(filePath) {
-  return fs5.readFile(filePath, "utf-8");
+  return fs8.readFile(filePath, "utf-8");
 }
 var LocalProcedureFiles = class {
   /**
@@ -3271,7 +4463,7 @@ function registerIngestProceduresCommand(parent) {
     try {
       const config = readConfig();
       const dbPath = config.dbPath;
-      const resolvedTargetPath = path8.resolve(commandInput.targetPath);
+      const resolvedTargetPath = path10.resolve(commandInput.targetPath);
       database = await createDatabase(dbPath);
       if (commandInput.verbose) {
         clack3.log.step(`Preparing procedure sync for ${resolvedTargetPath}...`);
@@ -3448,11 +4640,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 ${path9.resolve(commandInput.targetPath)}...`);
+        clack4.log.step(`Discovering transcript files in ${path11.resolve(commandInput.targetPath)}...`);
       }
       const files = await localTranscriptFiles.discoverFiles(commandInput.targetPath);
       if (files.length === 0) {
-        clack4.log.warn(`No transcript files found at ${path9.resolve(commandInput.targetPath)}.`);
+        clack4.log.warn(`No transcript files found at ${path11.resolve(commandInput.targetPath)}.`);
         clack4.outro("Nothing to ingest.");
         return;
       }
@@ -3548,9 +4740,9 @@ function registerIngestEntriesCommand(parent) {
           totals.skippedFiles += 1;
           if (commandInput.verbose) {
             printVerboseFileDetails(result, commandInput, usage);
-            clack4.log.step(buildSkippedMessage(path9.basename(result.file)));
+            clack4.log.step(buildSkippedMessage(path11.basename(result.file)));
           } else {
-            clack4.log.step(buildSkippedMessage(path9.basename(result.file)));
+            clack4.log.step(buildSkippedMessage(path11.basename(result.file)));
           }
           continue;
         }
@@ -3559,7 +4751,7 @@ function registerIngestEntriesCommand(parent) {
           if (commandInput.verbose) {
             printVerboseFileDetails(result, commandInput, usage);
           }
-          clack4.log.error(buildFailureMessage(path9.basename(result.file), result, commandInput, usage, index === 0));
+          clack4.log.error(buildFailureMessage(path11.basename(result.file), result, commandInput, usage, index === 0));
           continue;
         }
         const storeResult = result.storeResult ?? emptyStoreResult2();
@@ -3569,7 +4761,7 @@ function registerIngestEntriesCommand(parent) {
         if (commandInput.verbose) {
           printVerboseFileDetails(result, commandInput, usage);
         }
-        clack4.log.step(buildSuccessMessage(path9.basename(result.file), result, commandInput, usage, index === 0));
+        clack4.log.step(buildSuccessMessage(path11.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) {
@@ -3999,7 +5191,7 @@ import { getModels } from "@earendil-works/pi-ai";
 
 // src/cli/ui.ts
 import os from "os";
-import path10 from "path";
+import path12 from "path";
 import * as clack5 from "@clack/prompts";
 function createCliPrompts() {
   return {
@@ -4038,12 +5230,12 @@ function resolveUserPath(value) {
     return os.homedir();
   }
   if (trimmed.startsWith("~/")) {
-    return path10.join(os.homedir(), trimmed.slice(2));
+    return path12.join(os.homedir(), trimmed.slice(2));
   }
   if (trimmed.startsWith("~\\")) {
-    return path10.join(os.homedir(), trimmed.slice(2));
+    return path12.join(os.homedir(), trimmed.slice(2));
   }
-  return path10.resolve(trimmed);
+  return path12.resolve(trimmed);
 }
 function formatPathForDisplay(filePath) {
   const home = os.homedir();
@@ -4375,7 +5567,8 @@ function buildNextConfig(existingConfig, values) {
     provider: values.provider,
     model: values.model,
     ...nextCredentials ? { credentials: nextCredentials } : { credentials: void 0 },
-    dbPath: values.dbPath
+    dbPath: values.dbPath,
+    ...values.populateAllFeatures ? { features: createAllEnabledFeatureFlagConfig() } : {}
   };
   return applySetupStageOverrides(baseConfig, values.stageOverrides);
 }
@@ -4566,7 +5759,8 @@ async function runSetupCore(options = {}) {
     primaryCredential: primaryCredential.shouldPersist ? primaryCredential.apiKey : void 0,
     embeddingApiKey,
     stageOverrides,
-    dbPath
+    dbPath,
+    populateAllFeatures: options.populateAllFeatures
   });
   const readiness = runtime.getSetupReadiness(nextConfig);
   const ready = readiness.ready;
@@ -5116,9 +6310,9 @@ function formatTokenCount(tokens) {
 
 // src/cli/commands/init/external-commands.ts
 import { execFile, execFileSync } from "child_process";
-import fs6 from "fs/promises";
-import path11 from "path";
-var OPENCLAW_PLUGIN_PACKAGE = "@agenr/agenr-plugin";
+import fs9 from "fs/promises";
+import path13 from "path";
+var OPENCLAW_PLUGIN_PACKAGE = "@agenr/openclaw-plugin";
 function execAsync(command, args, options) {
   return new Promise((resolve, reject) => {
     const execOptions = {
@@ -5142,7 +6336,7 @@ function shouldUseShellForCommand(command, platform = process.platform) {
   if (platform !== "win32") {
     return false;
   }
-  const extension = path11.extname(command).toLowerCase();
+  const extension = path13.extname(command).toLowerCase();
   return extension === ".cmd" || extension === ".bat";
 }
 function findBinaryPath(name) {
@@ -5225,12 +6419,12 @@ async function restartOpenClawGateway() {
   }
 }
 async function writeOpenClawPluginConfig(stateDir, config) {
-  const openclawConfigPath = path11.join(stateDir, "openclaw.json");
+  const openclawConfigPath = path13.join(stateDir, "openclaw.json");
   let root = {};
   try {
-    const raw = await fs6.readFile(openclawConfigPath, "utf8");
+    const raw = await fs9.readFile(openclawConfigPath, "utf8");
     const parsed = JSON.parse(raw);
-    if (isRecord(parsed)) {
+    if (isRecord2(parsed)) {
       root = parsed;
     }
   } catch {
@@ -5254,20 +6448,20 @@ 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 fs9.mkdir(stateDir, { recursive: true });
+  await fs9.writeFile(openclawConfigPath, `${JSON.stringify(root, null, 2)}
 `, "utf8");
   return openclawConfigPath;
 }
 function shouldPersistPluginConfigPath(dbPath, configPath) {
-  return path11.dirname(dbPath) !== path11.dirname(configPath);
+  return path13.dirname(dbPath) !== path13.dirname(configPath);
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function ensureRecord(target, key) {
   const value = target[key];
-  if (isRecord(value)) {
+  if (isRecord2(value)) {
     return value;
   }
   const created = {};
@@ -5287,21 +6481,21 @@ function ensureArrayOfStrings(target, key) {
 }
 
 // src/cli/commands/init/openclaw-detect.ts
-import fs7 from "fs";
+import fs10 from "fs";
 import os2 from "os";
-import path12 from "path";
+import path14 from "path";
 function resolveDefaultOpenClawStateDir() {
-  return path12.join(os2.homedir(), ".openclaw");
+  return path14.join(os2.homedir(), ".openclaw");
 }
-function detectOpenClawInstallation(env = process.env, existsSyncFn = fs7.existsSync) {
+function detectOpenClawInstallation(env = process.env, existsSyncFn = fs10.existsSync) {
   const envStateDir = normalizeOptionalString4(env.OPENCLAW_STATE_DIR) ?? normalizeOptionalString4(env.OPENCLAW_HOME);
   const source = envStateDir ? "environment" : "default";
   const stateDir = envStateDir ? resolveUserPath(envStateDir) : resolveDefaultOpenClawStateDir();
   return {
     detected: envStateDir !== void 0 || existsSyncFn(stateDir),
     stateDir,
-    configPath: path12.join(stateDir, "openclaw.json"),
-    sessionsRoot: path12.join(stateDir, "agents"),
+    configPath: path14.join(stateDir, "openclaw.json"),
+    sessionsRoot: path14.join(stateDir, "agents"),
     source
   };
 }
@@ -5311,8 +6505,8 @@ function normalizeOptionalString4(value) {
 }
 
 // src/cli/commands/init/session-scanner.ts
-import fs8 from "fs/promises";
-import path13 from "path";
+import fs11 from "fs/promises";
+import path15 from "path";
 async function scanSessionFiles(sessionsRoot, recentDays = 7) {
   const result = {
     totalFiles: 0,
@@ -5335,9 +6529,9 @@ async function scanSessionFiles(sessionsRoot, recentDays = 7) {
     if (!isSessionTranscriptPath(filePath)) {
       continue;
     }
-    let stat;
+    let stat2;
     try {
-      stat = await fs8.stat(filePath);
+      stat2 = await fs11.stat(filePath);
     } catch (error) {
       if (isMissingPathError(error)) {
         continue;
@@ -5346,16 +6540,16 @@ async function scanSessionFiles(sessionsRoot, recentDays = 7) {
     }
     result.allFiles.push(filePath);
     result.totalFiles += 1;
-    result.totalSizeBytes += stat.size;
-    if (stat.mtimeMs >= cutoffMs) {
+    result.totalSizeBytes += stat2.size;
+    if (stat2.mtimeMs >= cutoffMs) {
       result.recentFiles.push(filePath);
-      result.recentSizeBytes += stat.size;
+      result.recentSizeBytes += stat2.size;
     }
   }
   return result;
 }
 function isSessionTranscriptPath(filePath) {
-  return filePath.split(path13.sep).includes("sessions");
+  return filePath.split(path15.sep).includes("sessions");
 }
 function isMissingPathError(error) {
   return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
@@ -5394,7 +6588,8 @@ async function runInitWizard(options = {}) {
       }
       setupResult = await runtime.runSetupCore({
         existingConfig: activeConfig,
-        prompts
+        prompts,
+        populateAllFeatures: true
       });
       if (!setupResult) {
         prompts.cancel("Init cancelled.");
@@ -5413,7 +6608,8 @@ async function runInitWizard(options = {}) {
       if (reconfigure) {
         setupResult = await runtime.runSetupCore({
           existingConfig: activeConfig,
-          prompts
+          prompts,
+          populateAllFeatures: true
         });
         if (!setupResult) {
           prompts.cancel("Init cancelled.");
@@ -5423,7 +6619,8 @@ async function runInitWizard(options = {}) {
       }
     } else {
       setupResult = await runtime.runSetupCore({
-        prompts
+        prompts,
+        populateAllFeatures: true
       });
       if (!setupResult) {
         prompts.cancel("Init cancelled.");
@@ -5679,7 +6876,7 @@ function buildNextSteps(detection, pluginStatus, gatewayStatus, sessionScan) {
     steps.push("Install OpenClaw later, then rerun `agenr init` to enable the plugin.");
   } else {
     if (!pluginStatus.toLowerCase().includes("installed")) {
-      steps.push("Install the plugin later with `openclaw plugins install @agenr/agenr-plugin`.");
+      steps.push("Install the plugin later with `openclaw plugins install @agenr/openclaw-plugin`.");
     }
     if (gatewayStatus.toLowerCase().includes("manual restart")) {
       steps.push("Run `openclaw gateway restart` after the plugin is installed.");
@@ -5902,7 +7099,7 @@ 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 path20 from "path";
+import path22 from "path";
 import { getModel } from "@earendil-works/pi-ai";
 
 // src/adapters/db/surgeon-run-log.ts
@@ -7389,8 +8586,8 @@ function createSurgeonPort(executor) {
 
 // src/app/surgeon/service.ts
 import { randomUUID as randomUUID9 } from "crypto";
-import fs10 from "fs";
-import path15 from "path";
+import fs13 from "fs";
+import path17 from "path";
 import { runAgentLoop } from "@earendil-works/pi-agent-core";
 
 // src/core/surgeon/domain/run-presets.ts
@@ -10116,8 +11313,8 @@ async function applyProposalToEntries(input, deps) {
 }
 
 // src/app/surgeon/trace-logger.ts
-import fs9 from "fs";
-import path14 from "path";
+import fs12 from "fs";
+import path16 from "path";
 var TRACE_MAX_STRING_LENGTH = 320;
 var TRACE_MAX_ARRAY_ITEMS = 12;
 var TRACE_MAX_OBJECT_KEYS = 20;
@@ -10325,8 +11522,8 @@ function appendTrace(tracePath, payload, logger) {
     return;
   }
   try {
-    fs9.mkdirSync(path14.dirname(tracePath), { recursive: true });
-    fs9.appendFileSync(tracePath, `${JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...payload })}
+    fs12.mkdirSync(path16.dirname(tracePath), { recursive: true });
+    fs12.appendFileSync(tracePath, `${JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...payload })}
 `, "utf8");
   } catch (error) {
     logger.warn(`failed to write trace file ${tracePath}: ${formatError2(error)}`);
@@ -12875,8 +14072,8 @@ function resolveTracePath(tracePath, passType, runId) {
     return void 0;
   }
   try {
-    if (fs10.statSync(tracePath).isDirectory()) {
-      return path15.join(tracePath, `surgeon-${passType}-${runId}.jsonl`);
+    if (fs13.statSync(tracePath).isDirectory()) {
+      return path17.join(tracePath, `surgeon-${passType}-${runId}.jsonl`);
     }
   } catch {
     return tracePath;
@@ -13525,7 +14722,7 @@ function toolNameToActionType(toolName) {
   return void 0;
 }
 function shouldAuditAction(actionType, details) {
-  const record = asRecord(details);
+  const record = asRecord2(details);
   if (record.success !== true) {
     return false;
   }
@@ -13535,7 +14732,7 @@ function shouldAuditAction(actionType, details) {
   return record.updated === true;
 }
 function extractEntryIds(args) {
-  const entryId = asRecord(args).entry_id;
+  const entryId = asRecord2(args).entry_id;
   return typeof entryId === "string" && entryId.trim().length > 0 ? [entryId.trim()] : [];
 }
 function extractActionReasoning(assistantMessage, args, details, toolName) {
@@ -13543,8 +14740,8 @@ function extractActionReasoning(assistantMessage, args, details, toolName) {
   if (assistantReasoning.length > 0) {
     return assistantReasoning;
   }
-  const argRecord = asRecord(args);
-  const detailRecord = asRecord(details);
+  const argRecord = asRecord2(args);
+  const detailRecord = asRecord2(details);
   const argReason = typeof argRecord.reasoning === "string" ? argRecord.reasoning.trim() : typeof argRecord.reason === "string" ? argRecord.reason.trim() : "";
   if (argReason.length > 0) {
     return argReason;
@@ -13567,7 +14764,7 @@ function formatLastRun(run) {
 function isAssistantMessage2(message) {
   return typeof message === "object" && message !== null && "role" in message && message.role === "assistant";
 }
-function asRecord(value) {
+function asRecord2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return {};
   }
@@ -13778,7 +14975,7 @@ function formatValue(value) {
 }
 
 // src/app/scenarios/claim-keys/deterministic-fixtures.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var DEFAULT_CONTEXT_WINDOW_TOKENS2 = 16e3;
 var DEFAULT_MAX_OUTPUT_TOKENS = 4e3;
 var EMBEDDING_DIMENSIONS = 1024;
@@ -13836,7 +15033,7 @@ function hashToVector(text2, dimensions) {
   const vector = [];
   let counter = 0;
   while (vector.length < dimensions) {
-    const block = createHash2("sha256").update(text2).update(String(counter)).digest();
+    const block = createHash3("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);
     }
@@ -13877,8 +15074,8 @@ function isFixtureError(value) {
 }
 
 // src/app/scenarios/claim-keys/fixture-loader.ts
-import { readFile } from "fs/promises";
-import path17 from "path";
+import { readFile as readFile3 } from "fs/promises";
+import path19 from "path";
 
 // src/app/scenarios/claim-keys/validation/shared.ts
 var SUPPORTED_PROPOSAL_SCOPES = ["single_entry", "cluster"];
@@ -14208,12 +15405,12 @@ function readRequiredTrue(value, label, filePath) {
 
 // src/app/scenarios/claim-keys/validation/scenario-root.ts
 import { existsSync } from "fs";
-import path16 from "path";
+import path18 from "path";
 import { fileURLToPath } from "url";
 var SCENARIO_ROOT_SEGMENTS = ["tests", "scenarios", "claim-keys"];
 function getDefaultClaimKeyScenarioRoot(options = {}) {
-  const moduleDirectory = path16.dirname(fileURLToPath(options.moduleUrl ?? import.meta.url));
-  const startDirectories = Array.from(/* @__PURE__ */ new Set([path16.resolve(options.cwd ?? process.cwd()), moduleDirectory]));
+  const moduleDirectory = path18.dirname(fileURLToPath(options.moduleUrl ?? import.meta.url));
+  const startDirectories = Array.from(/* @__PURE__ */ new Set([path18.resolve(options.cwd ?? process.cwd()), moduleDirectory]));
   for (const startDirectory of startDirectories) {
     const discovered = findScenarioRootFrom(startDirectory);
     if (discovered) {
@@ -14235,24 +15432,24 @@ function readOptionalRelativeFixturePath(value, label, filePath, rootDir) {
   return readRelativeFixturePath(value, label, filePath, rootDir);
 }
 function normalizeFixturePath(relativePath, rootDir, filePath, label) {
-  if (path16.isAbsolute(relativePath)) {
+  if (path18.isAbsolute(relativePath)) {
     throw new Error(`Invalid scenario ${filePath}: ${label} must be relative to the scenario root.`);
   }
-  const resolved = path16.resolve(rootDir, relativePath);
-  const relative = path16.relative(rootDir, resolved);
-  if (relative.startsWith("..") || path16.isAbsolute(relative)) {
+  const resolved = path18.resolve(rootDir, relativePath);
+  const relative = path18.relative(rootDir, resolved);
+  if (relative.startsWith("..") || path18.isAbsolute(relative)) {
     throw new Error(`Invalid scenario ${filePath}: ${label} must stay inside the scenario root.`);
   }
-  return relative.split(path16.sep).join("/");
+  return relative.split(path18.sep).join("/");
 }
 function findScenarioRootFrom(startDirectory) {
-  let currentDirectory = path16.resolve(startDirectory);
+  let currentDirectory = path18.resolve(startDirectory);
   while (true) {
-    const candidate = path16.join(currentDirectory, ...SCENARIO_ROOT_SEGMENTS);
+    const candidate = path18.join(currentDirectory, ...SCENARIO_ROOT_SEGMENTS);
     if (existsSync(candidate)) {
       return candidate;
     }
-    const parentDirectory = path16.dirname(currentDirectory);
+    const parentDirectory = path18.dirname(currentDirectory);
     if (parentDirectory === currentDirectory) {
       return void 0;
     }
@@ -14595,7 +15792,7 @@ async function loadSeedFixtureEntries(rootDir, relativePath) {
   if (!relativePath) {
     return null;
   }
-  const parsed = await readJsonFile(path17.join(rootDir, relativePath));
+  const parsed = await readJsonFile(path19.join(rootDir, relativePath));
   const seedEntries = readSeedEntries(parsed, relativePath);
   if (!seedEntries) {
     throw new Error(`Seed fixture ${relativePath} must contain an array.`);
@@ -14658,7 +15855,7 @@ async function readArrayFixture(rootDir, relativePath) {
   if (!relativePath) {
     return null;
   }
-  const parsed = await readJsonFile(path17.join(rootDir, relativePath));
+  const parsed = await readJsonFile(path19.join(rootDir, relativePath));
   if (!Array.isArray(parsed)) {
     throw new Error(`Fixture file ${relativePath} must contain a JSON array.`);
   }
@@ -14666,7 +15863,7 @@ async function readArrayFixture(rootDir, relativePath) {
 }
 async function readJsonFile(filePath) {
   try {
-    return JSON.parse(await readFile(filePath, "utf8"));
+    return JSON.parse(await readFile3(filePath, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Invalid fixture file ${filePath}: JSON parse failed - ${message}`, {
@@ -14711,8 +15908,8 @@ function readExtractionImportance(value, label, filePath) {
 }
 
 // src/app/scenarios/claim-keys/load-scenarios.ts
-import { readdir, readFile as readFile2 } from "fs/promises";
-import path18 from "path";
+import { readdir, readFile as readFile4 } from "fs/promises";
+import path20 from "path";
 
 // src/app/scenarios/claim-keys/validation/expectations.ts
 var EXPECTATION_KEYS = /* @__PURE__ */ new Set(["warnings", "rows", "rowCount", "proposals", "storeResult", "surgeonSummary"]);
@@ -14974,20 +16171,20 @@ function validateClaimKeyScenario(input, filePath, rootDir = getDefaultClaimKeyS
 async function discoverScenarioFiles(rootDir) {
   const files = [];
   for (const kind of SUPPORTED_KINDS2) {
-    const directory = path18.join(rootDir, kind);
+    const directory = path20.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(path18.join(directory, entry.name));
+      files.push(path20.join(directory, entry.name));
     }
   }
   return files.sort();
 }
 async function readScenarioJsonFile(filePath) {
   try {
-    return JSON.parse(await readFile2(filePath, "utf8"));
+    return JSON.parse(await readFile4(filePath, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Invalid scenario ${filePath}: JSON parse failed - ${message}`, {
@@ -14998,11 +16195,11 @@ async function readScenarioJsonFile(filePath) {
 
 // src/app/scenarios/claim-keys/sandbox.ts
 import { mkdir, rm } from "fs/promises";
-import path19 from "path";
+import path21 from "path";
 var SANDBOX_DB_FILENAME = "knowledge.db";
 async function createClaimKeyScenarioSandbox(root) {
-  const resolvedRoot = path19.resolve(root);
-  const dbPath = path19.join(resolvedRoot, SANDBOX_DB_FILENAME);
+  const resolvedRoot = path21.resolve(root);
+  const dbPath = path21.join(resolvedRoot, SANDBOX_DB_FILENAME);
   await mkdir(resolvedRoot, { recursive: true });
   await removeDatabaseFiles(dbPath);
   const database = await createDatabase(dbPath);
@@ -15193,7 +16390,7 @@ async function listClaimKeyScenariosRuntime(options = {}) {
 }
 async function runClaimKeyScenariosRuntime(options = {}) {
   const runId = buildRunId();
-  const artifactRoot = path20.resolve(DEFAULT_ARTIFACT_ROOT, runId);
+  const artifactRoot = path22.resolve(DEFAULT_ARTIFACT_ROOT, runId);
   await mkdir2(artifactRoot, { recursive: true });
   let scenarios;
   try {
@@ -15245,11 +16442,11 @@ function filterClaimKeyScenarios(scenarios, options) {
 }
 async function runOneClaimKeyScenario(scenario, options) {
   const startedAt = Date.now();
-  const scenarioArtifactRoot = path20.join(options.artifactRoot, scenario.id);
-  const sandboxRoot = path20.join(scenarioArtifactRoot, "sandbox");
+  const scenarioArtifactRoot = path22.join(options.artifactRoot, scenario.id);
+  const sandboxRoot = path22.join(scenarioArtifactRoot, "sandbox");
   const warnings = [];
   await mkdir2(scenarioArtifactRoot, { recursive: true });
-  await writeJson(path20.join(scenarioArtifactRoot, "scenario.json"), scenario);
+  await writeJson(path22.join(scenarioArtifactRoot, "scenario.json"), scenario);
   let actual = {
     warnings: [],
     rows: [],
@@ -15362,7 +16559,7 @@ async function runIngestScenario(scenario, database, warnings, rootDir) {
     throw new Error(`Scenario ${scenario.id} is missing extraction fixture responses.`);
   }
   const result = await ingestPath(
-    path20.join(rootDir, scenario.input.transcriptFile),
+    path22.join(rootDir, scenario.input.transcriptFile),
     {
       files: localTranscriptFiles,
       transcript: openClawTranscriptParser,
@@ -15504,20 +16701,20 @@ async function loadLatestSurgeonProposals(database, runId) {
   }));
 }
 async function writeScenarioArtifacts(scenarioArtifactRoot, actual, assertionResults, diffSummary) {
-  await writeJson(path20.join(scenarioArtifactRoot, "actual.json"), actual);
-  await writeJson(path20.join(scenarioArtifactRoot, "diff.json"), {
+  await writeJson(path22.join(scenarioArtifactRoot, "actual.json"), actual);
+  await writeJson(path22.join(scenarioArtifactRoot, "diff.json"), {
     assertions: assertionResults,
     diffSummary
   });
-  await writeJson(path20.join(scenarioArtifactRoot, "warnings.json"), actual.warnings);
+  await writeJson(path22.join(scenarioArtifactRoot, "warnings.json"), actual.warnings);
   if (actual.storeResult) {
-    await writeJson(path20.join(scenarioArtifactRoot, "store-result.json"), actual.storeResult);
+    await writeJson(path22.join(scenarioArtifactRoot, "store-result.json"), actual.storeResult);
   }
   if (actual.surgeonSummary) {
-    await writeJson(path20.join(scenarioArtifactRoot, "surgeon-summary.json"), actual.surgeonSummary);
+    await writeJson(path22.join(scenarioArtifactRoot, "surgeon-summary.json"), actual.surgeonSummary);
   }
   if (actual.proposals.length > 0) {
-    await writeJson(path20.join(scenarioArtifactRoot, "proposals.json"), actual.proposals);
+    await writeJson(path22.join(scenarioArtifactRoot, "proposals.json"), actual.proposals);
   }
 }
 async function writeJson(filePath, value) {
@@ -15649,7 +16846,7 @@ import { InvalidArgumentError as InvalidArgumentError6, Option as Option5 } from
 
 // src/app/surgeon/runtime.ts
 import { copyFile, mkdir as mkdir3 } from "fs/promises";
-import path21 from "path";
+import path23 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { getModel as getModel2 } from "@earendil-works/pi-ai";
 var DEFAULT_SURGEON_PROVIDER = "openai";
@@ -15894,7 +17091,7 @@ async function backupDatabaseFile(dbPath) {
   }
   const sourcePath = resolveFilesystemPath(dbPath);
   const backupPath = `${sourcePath}.surgeon-backup-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replaceAll(".", "-")}`;
-  await mkdir3(path21.dirname(backupPath), { recursive: true });
+  await mkdir3(path23.dirname(backupPath), { recursive: true });
   await copyFile(sourcePath, backupPath);
   await copySidecarIfPresent(`${sourcePath}-wal`, `${backupPath}-wal`);
   await copySidecarIfPresent(`${sourcePath}-shm`, `${backupPath}-shm`);
@@ -15912,12 +17109,12 @@ async function copySidecarIfPresent(sourcePath, targetPath) {
 }
 function resolveFilesystemPath(value) {
   if (!value.startsWith("file:")) {
-    return path21.resolve(value);
+    return path23.resolve(value);
   }
   try {
     return fileURLToPath2(value);
   } catch {
-    return path21.resolve(value.slice("file:".length));
+    return path23.resolve(value.slice("file:".length));
   }
 }
 function isMissingFileError2(error) {