@agenr/openclaw-plugin 3.3.0 → 2026.6.3

package/dist/chunk-IBPS64W3.js

@@ -0,0 +1,1069 @@
+import {
+  formatTargetSelectorFromParams
+} from "./chunk-U74RE3L7.js";
+
+// src/adapters/openclaw/transcript/parser.ts
+import { createHash } from "crypto";
+import * as fs2 from "fs/promises";
+
+// src/adapters/openclaw/session/session-id.ts
+import path 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 = path.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 text = getString(args.text) ?? "(unknown text)";
+    return truncateInline(text, 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, text, 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 (text.length < 1e3) {
+      return { keep: true, truncateTo: 2e3 };
+    }
+    if (/(error|failed|fail)/i.test(text)) {
+      return { keep: true, truncateTo: 2e3 };
+    }
+    return { keep: false };
+  }
+  if (text.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 normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function extractTextBlocks(content) {
+  if (typeof content === "string") {
+    const normalized = normalizeWhitespace(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 = normalizeWhitespace(block);
+      if (normalized) {
+        textBlocks.push(normalized);
+      }
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    if (typeof record.text === "string") {
+      const normalized = normalizeWhitespace(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 = normalizeWhitespace(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 normalizeWhitespace(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(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, maxChars)}
+[...truncated]`;
+}
+function isPureBase64(text) {
+  const trimmed = text.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 = normalizeWhitespace(content);
+    return normalized ? [normalized] : [];
+  }
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const textParts = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      const normalized = normalizeWhitespace(block);
+      if (normalized) {
+        textParts.push(normalized);
+      }
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    if (typeof record.text === "string") {
+      const normalized = normalizeWhitespace(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 = normalizeWhitespace(record.content);
+      if (normalized) {
+        textParts.push(normalized);
+      }
+    }
+  }
+  return textParts;
+}
+function pushMessage(messages, role, text, timestamp) {
+  messages.push({
+    index: messages.length,
+    role,
+    text,
+    timestamp
+  });
+}
+
+// src/adapters/openclaw/transcript/timestamps.ts
+import * as fs 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 fs.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 fs2.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(text) {
+  const lines = text.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 timestamp = extractTimestamp(record) ?? extractTimestamp(message);
+  if (role === "user") {
+    const extractedLabel = extractConversationLabel(message.content);
+    if (extractedLabel) {
+      state.sessionLabel = extractedLabel;
+    }
+    const text = stripOpenClawUserMetadata(message.content);
+    if (!text) {
+      return "known_skip";
+    }
+    if (isPureBase64(text)) {
+      state.stats.base64Dropped += 1;
+      return "known_skip";
+    }
+    pushMessage(state.messages, "user", text, timestamp);
+    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), timestamp);
+    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, timestamp);
+    return "accepted";
+  }
+  state.stats.toolResultsDropped += 1;
+  pushMessage(state.messages, "assistant", toolResultPlaceholder(toolName ?? "unknown", toolArgs), timestamp);
+  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 = createHash("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/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
+  };
+}
+
+export {
+  deriveOpenClawSessionIdFromFilePath,
+  parseJsonObjectLineWithDiagnostics,
+  OpenClawTranscriptParser,
+  openClawTranscriptParser,
+  parseTuiSessionKey
+};