@martian-engineering/lossless-claw 0.5.2 → 0.6.0

package/src/compaction.ts

@@ -25,6 +25,8 @@ export interface CompactionResult {
   condensed: boolean;
   /** Escalation level used: "normal" | "aggressive" | "fallback" */
   level?: CompactionLevel;
+  /** Whether compaction was blocked by a provider auth failure */
+  authFailure?: boolean;
 }
 
 export interface CompactionConfig {
@@ -38,7 +40,7 @@ export interface CompactionConfig {
   condensedMinFanout: number;
   /** Relaxed minimum fanout for hard-trigger sweeps. */
   condensedMinFanoutHard: number;
-  /** Incremental depth passes to run after each leaf compaction (default 0). */
+  /** Incremental depth passes to run after each leaf compaction (default 1). */
   incrementalMaxDepth: number;
   /** Max source tokens to compact per leaf/condensed chunk (default 20000) */
   leafChunkTokens?: number;
@@ -50,9 +52,11 @@ export interface CompactionConfig {
   maxRounds: number;
   /** IANA timezone for timestamps in summaries (default: UTC) */
   timezone?: string;
+  /** Maximum allowed overage factor for summaries relative to target tokens (default 3). */
+  summaryMaxOverageFactor: number;
 }
 
-type CompactionLevel = "normal" | "aggressive" | "fallback";
+type CompactionLevel = "normal" | "aggressive" | "fallback" | "capped";
 type CompactionPass = "leaf" | "condensed";
 type CompactionSummarizeOptions = {
   previousSummary?: string;
@@ -86,6 +90,30 @@ function estimateTokens(content: string): number {
   return Math.ceil(content.length / 4);
 }
 
+/** Deterministically cap summary text so the persisted output stays within maxTokens. */
+function capSummaryText(
+  content: string,
+  originalTokens: number,
+  maxTokens: number,
+): string {
+  const suffixes = [
+    `\n[Capped from ${originalTokens} tokens to ~${maxTokens}]`,
+    `\n[Capped to ~${maxTokens}]`,
+    "\n[Capped]",
+    "",
+  ];
+
+  for (const suffix of suffixes) {
+    const maxChars = Math.max(0, maxTokens * 4 - suffix.length);
+    const capped = `${content.slice(0, maxChars)}${suffix}`;
+    if (estimateTokens(capped) <= maxTokens) {
+      return capped;
+    }
+  }
+
+  return content.slice(0, Math.max(0, maxTokens * 4));
+}
+
 /** Format a timestamp as `YYYY-MM-DD HH:mm TZ` for prompt source text. */
 export function formatTimestamp(value: Date, timezone: string = "UTC"): string {
   try {
@@ -150,6 +178,11 @@ const DEFAULT_LEAF_CHUNK_TOKENS = 20_000;
  * with no meaningful text.
  */
 const MEDIA_PATH_RE = /^MEDIA:\/.+$/;
+const EMBEDDED_DATA_URL_RE = /data:[^;\s"'`]+;base64,[A-Za-z0-9+/=\s]+/gi;
+const MEDIA_ATTACHMENT_PART_TYPES = new Set(["file", "snapshot"]);
+const MEDIA_ATTACHMENT_RAW_TYPES = new Set(["file", "image", "snapshot"]);
+const STRUCTURED_MEDIA_TEXT_KEYS = ["text", "caption", "alt", "title", "summary"] as const;
+const STRUCTURED_MEDIA_NESTED_KEYS = ["content", "parts", "items", "message", "messages"] as const;
 
 const CONDENSED_MIN_INPUT_RATIO = 0.1;
 
@@ -165,6 +198,140 @@ function dedupeOrderedIds(ids: Iterable<string>): string[] {
   return ordered;
 }
 
+/** Parse message-part metadata without throwing on malformed JSON. */
+function parseMessagePartMetadata(part: CreateMessagePartInput | { metadata: string | null }): Record<string, unknown> {
+  if (typeof part.metadata !== "string" || !part.metadata.trim()) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(part.metadata) as unknown;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+/** Detect whether a string is mostly binary/base64 payload and not meaningful prose. */
+function looksLikeBinaryPayload(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return false;
+  }
+  if (/^data:[^;\s"'`]+;base64,/i.test(trimmed)) {
+    return true;
+  }
+  const compact = trimmed.replace(/\s+/g, "");
+  if (compact.length < 256 || compact.length % 4 !== 0) {
+    return false;
+  }
+  if (!/^[A-Za-z0-9+/=]+$/.test(compact)) {
+    return false;
+  }
+  return !/[ .,:;!?()[\]{}]/.test(trimmed);
+}
+
+/** Strip attachment payloads from plain strings before they reach the summarizer. */
+function stripEmbeddedMediaPayloads(content: string): string {
+  const withoutDataUrls = content.replace(EMBEDDED_DATA_URL_RE, "[embedded media omitted]");
+  const sanitizedLines = withoutDataUrls
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        return false;
+      }
+      if (MEDIA_PATH_RE.test(trimmed)) {
+        return false;
+      }
+      if (looksLikeBinaryPayload(trimmed)) {
+        return false;
+      }
+      return true;
+    });
+  return sanitizedLines.join("\n").trim();
+}
+
+/** Extract human-readable text from structured content while ignoring attachment payload fields. */
+function extractSanitizedStructuredText(value: unknown, depth = 0): string[] {
+  if (depth >= 4 || value == null) {
+    return [];
+  }
+  if (typeof value === "string") {
+    const sanitized = stripEmbeddedMediaPayloads(value);
+    return sanitized ? [sanitized] : [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => extractSanitizedStructuredText(entry, depth + 1));
+  }
+  if (typeof value !== "object") {
+    return [];
+  }
+
+  const record = value as Record<string, unknown>;
+  const rawType = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+  const textFragments: string[] = [];
+
+  for (const key of STRUCTURED_MEDIA_TEXT_KEYS) {
+    const candidate = record[key];
+    if (typeof candidate !== "string") {
+      continue;
+    }
+    const sanitized = stripEmbeddedMediaPayloads(candidate);
+    if (sanitized) {
+      textFragments.push(sanitized);
+    }
+  }
+
+  if (MEDIA_ATTACHMENT_RAW_TYPES.has(rawType)) {
+    return textFragments;
+  }
+
+  for (const key of STRUCTURED_MEDIA_NESTED_KEYS) {
+    textFragments.push(...extractSanitizedStructuredText(record[key], depth + 1));
+  }
+
+  return textFragments;
+}
+
+/** Normalize message content down to human-readable text, excluding binary/media payloads. */
+function extractMeaningfulMessageText(content: string): string {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if ((trimmed.startsWith("[") && trimmed.endsWith("]")) || (trimmed.startsWith("{") && trimmed.endsWith("}"))) {
+    try {
+      const parsed = JSON.parse(trimmed) as unknown;
+      const extracted = extractSanitizedStructuredText(parsed)
+        .map((fragment) => fragment.trim())
+        .filter(Boolean);
+      return extracted.join("\n").trim();
+    } catch {
+      // Fall back to plain-text sanitation below.
+    }
+  }
+  return stripEmbeddedMediaPayloads(content);
+}
+
+/** Identify whether a stored message part represents a media attachment. */
+function isMediaAttachmentPart(part: CreateMessagePartInput | { partType: string; metadata: string | null }): boolean {
+  if (MEDIA_ATTACHMENT_PART_TYPES.has(part.partType)) {
+    return true;
+  }
+  const metadata = parseMessagePartMetadata(part);
+  const rawType =
+    typeof metadata.rawType === "string"
+      ? metadata.rawType.trim().toLowerCase()
+      : metadata.raw && typeof metadata.raw === "object" && !Array.isArray(metadata.raw) &&
+          typeof (metadata.raw as Record<string, unknown>).type === "string"
+        ? ((metadata.raw as Record<string, unknown>).type as string).trim().toLowerCase()
+        : "";
+  return MEDIA_ATTACHMENT_RAW_TYPES.has(rawType);
+}
+
 // ── CompactionEngine ─────────────────────────────────────────────────────────
 
 export class CompactionEngine {
@@ -300,6 +467,7 @@ export class CompactionEngine {
         tokensBefore,
         tokensAfter: tokensBefore,
         condensed: false,
+        authFailure: true,
       };
     }
     const tokensAfterLeaf = await this.summaryStore.getContextTokenCount(conversationId);
@@ -416,6 +584,7 @@ export class CompactionEngine {
     let level: CompactionLevel | undefined;
     let previousSummaryContent: string | undefined;
     let previousTokens = tokensBefore;
+    let hadAuthFailure = false;
 
     // Phase 1: leaf passes over oldest raw chunks outside the protected tail.
     while (true) {
@@ -433,6 +602,7 @@ export class CompactionEngine {
         input.summaryModel,
       );
       if (!leafResult) {
+        hadAuthFailure = true;
         break;
       }
       const passTokensAfter = await this.summaryStore.getContextTokenCount(conversationId);
@@ -479,6 +649,7 @@ export class CompactionEngine {
         input.summaryModel,
       );
       if (!condenseResult) {
+        hadAuthFailure = true;
         break;
       }
       const passTokensAfter = await this.summaryStore.getContextTokenCount(conversationId);
@@ -515,6 +686,7 @@ export class CompactionEngine {
       createdSummaryId,
       condensed,
       level,
+      ...(hadAuthFailure ? { authFailure: true } : {}),
     };
   }
 
@@ -528,7 +700,7 @@ export class CompactionEngine {
     currentTokens?: number;
     summarize: CompactionSummarizeFn;
     summaryModel?: string;
-  }): Promise<{ success: boolean; rounds: number; finalTokens: number }> {
+  }): Promise<{ success: boolean; rounds: number; finalTokens: number; authFailure?: boolean }> {
     const { conversationId, tokenBudget, summarize } = input;
     const targetTokens =
       typeof input.targetTokens === "number" &&
@@ -562,6 +734,15 @@ export class CompactionEngine {
         summaryModel: input.summaryModel,
       });
 
+      if (result.authFailure) {
+        return {
+          success: false,
+          rounds: round,
+          finalTokens: result.tokensAfter,
+          authFailure: true,
+        };
+      }
+
       if (result.tokensAfter <= targetTokens) {
         return {
           success: true,
@@ -1010,6 +1191,8 @@ export class CompactionEngine {
     sourceText: string;
     summarize: CompactionSummarizeFn;
     options?: CompactionSummarizeOptions;
+    /** Target token count for this summary kind (leaf or condensed). Used for hard-cap enforcement. */
+    targetTokens: number;
   }): Promise<{ content: string; level: CompactionLevel } | null> {
     const sourceText = params.sourceText.trim();
     if (!sourceText) {
@@ -1076,6 +1259,21 @@ export class CompactionEngine {
       }
     }
 
+    // Hard cap: enforce maximum summary size relative to the kind-appropriate target.
+    const summaryTokens = estimateTokens(summaryText);
+    const maxTokens = Math.ceil(params.targetTokens * this.config.summaryMaxOverageFactor);
+
+    if (summaryTokens > Math.ceil(params.targetTokens * 1.5)) {
+      console.warn(
+        `[lcm] summary exceeds target by ${Math.round((summaryTokens / params.targetTokens - 1) * 100)}%: ${summaryTokens} tokens vs target ${params.targetTokens}`,
+      );
+    }
+
+    if (summaryTokens > maxTokens) {
+      summaryText = capSummaryText(summaryText, summaryTokens, maxTokens);
+      level = "capped";
+    }
+
     return { content: summaryText, level };
   }
 
@@ -1086,10 +1284,9 @@ export class CompactionEngine {
    * attachments. This gives the summarizer enough context to produce a
    * meaningful summary instead of trying to compress raw file paths.
    *
-   * - Media-only messages (just a file path, no text): content is replaced
-   *   with "[Media attachment]" or "[Image attachment]" etc.
-   * - Media-mostly messages (any real text + attachment): content is annotated
-   *   with " [with media attachment]" suffix.
+   * - Media-only messages: content is replaced with "[Media attachment]".
+   * - Media-mostly messages: text is preserved and annotated with
+   *   " [with media attachment]".
    * - Text-only messages: returned unchanged.
    */
   private async annotateMediaContent(
@@ -1097,27 +1294,29 @@ export class CompactionEngine {
     content: string,
   ): Promise<string> {
     const parts = await this.conversationStore.getMessageParts(messageId);
-    const hasMediaParts = parts.some(
-      (p) => p.partType === "file" || p.partType === "snapshot",
-    );
+    const hasMediaParts = parts.some((part) => isMediaAttachmentPart(part));
     if (!hasMediaParts) {
       return content;
     }
 
-    // Strip MEDIA:/... paths to see how much actual text remains
-    const textWithoutPaths = content
-      .split("\n")
-      .filter((line) => !MEDIA_PATH_RE.test(line.trim()))
+    const partText = parts
+      .filter((part) => !isMediaAttachmentPart(part))
+      .map((part) => (typeof part.textContent === "string" ? part.textContent : ""))
+      .map((text) => stripEmbeddedMediaPayloads(text))
+      .map((text) => text.trim())
+      .filter(Boolean)
       .join("\n")
       .trim();
+    const fallbackText = extractMeaningfulMessageText(content);
+    const meaningfulText = (partText || fallbackText).trim();
 
-    if (textWithoutPaths.length === 0) {
-      // Media-only: replace with descriptive annotation
+    if (!meaningfulText) {
       return "[Media attachment]";
     }
-
-    // Media-mostly: keep the text, add annotation
-    return `${textWithoutPaths} [with media attachment]`;
+    if (meaningfulText.includes("[with media attachment]")) {
+      return meaningfulText;
+    }
+    return `${meaningfulText} [with media attachment]`;
   }
 
   // ── Private: Leaf Pass ───────────────────────────────────────────────────
@@ -1167,6 +1366,7 @@ export class CompactionEngine {
         previousSummary: previousSummaryContent,
         isCondensed: false,
       },
+      targetTokens: this.config.leafTargetTokens,
     });
     if (!summary) {
       console.warn(
@@ -1274,6 +1474,7 @@ export class CompactionEngine {
         isCondensed: true,
         depth: targetDepth + 1,
       },
+      targetTokens: this.config.condensedTargetTokens,
     });
     if (!condensed) {
       console.warn(

package/src/db/config.ts

@@ -12,11 +12,14 @@ export type LcmConfig = {
   skipStatelessSessions: boolean;
   contextThreshold: number;
   freshTailCount: number;
+  newSessionRetainDepth: number;
   leafMinFanout: number;
   condensedMinFanout: number;
   condensedMinFanoutHard: number;
   incrementalMaxDepth: number;
   leafChunkTokens: number;
+  /** Maximum raw parent-history tokens imported during first-time bootstrap. */
+  bootstrapMaxTokens?: number;
   leafTargetTokens: number;
   condensedTargetTokens: number;
   maxExpandTokens: number;
@@ -37,11 +40,22 @@ export type LcmConfig = {
   expansionProvider: string;
   /** Model override for lcm_expand_query sub-agent. */
   expansionModel: string;
-  autocompactDisabled: boolean;
+  /** Max time to wait for delegated lcm_expand_query sub-agent completion. */
+  delegationTimeoutMs: number;
   /** IANA timezone for timestamps in summaries (from TZ env or system default) */
   timezone: string;
   /** When true, retroactively delete HEARTBEAT_OK turn cycles from LCM storage. */
   pruneHeartbeatOk: boolean;
+  /** Hard ceiling for assembly token budget — caps runtime-provided and fallback budgets. */
+  maxAssemblyTokenBudget?: number;
+  /** Maximum allowed overage factor for summaries relative to target tokens (default 3). */
+  summaryMaxOverageFactor: number;
+  /** Custom instructions injected into all summarization prompts. */
+  customInstructions: string;
+  /** Consecutive auth failures before the compaction circuit breaker trips (default 5). */
+  circuitBreakerThreshold: number;
+  /** Cooldown in milliseconds before the circuit breaker auto-resets (default 30 min). */
+  circuitBreakerCooldownMs: number;
 };
 
 /** Safely coerce an unknown value to a finite number, or return undefined. */
@@ -54,6 +68,21 @@ function toNumber(value: unknown): number | undefined {
   return undefined;
 }
 
+/** Safely parse a finite integer from an environment string, or return undefined.
+ *  Unlike raw parseInt(), this returns undefined for NaN so ?? fallback works. */
+function parseFiniteInt(value: string | undefined): number | undefined {
+  if (value === undefined) return undefined;
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+/** Safely parse a finite float from an environment string, or return undefined. */
+function parseFiniteNumber(value: string | undefined): number | undefined {
+  if (value === undefined) return undefined;
+  const parsed = parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
 /** Safely coerce an unknown value to a boolean, or return undefined. */
 function toBool(value: unknown): boolean | undefined {
   if (typeof value === "boolean") return value;
@@ -100,6 +129,17 @@ export function resolveLcmConfig(
   pluginConfig?: Record<string, unknown>,
 ): LcmConfig {
   const pc = pluginConfig ?? {};
+  const resolvedLeafChunkTokens =
+    parseFiniteInt(env.LCM_LEAF_CHUNK_TOKENS)
+      ?? toNumber(pc.leafChunkTokens) ?? 20000;
+  const resolvedBootstrapMaxTokens =
+    parseFiniteInt(env.LCM_BOOTSTRAP_MAX_TOKENS)
+      ?? toNumber(pc.bootstrapMaxTokens)
+      ?? Math.max(6000, Math.floor(resolvedLeafChunkTokens * 0.3));
+  const envDelegationTimeoutMs =
+    env.LCM_DELEGATION_TIMEOUT_MS !== undefined
+      ? toNumber(env.LCM_DELEGATION_TIMEOUT_MS)
+      : undefined;
 
   return {
     enabled:
@@ -130,37 +170,39 @@ export function resolveLcmConfig(
         ? env.LCM_SKIP_STATELESS_SESSIONS === "true"
         : toBool(pc.skipStatelessSessions) ?? true,
     contextThreshold:
-      (env.LCM_CONTEXT_THRESHOLD !== undefined ? parseFloat(env.LCM_CONTEXT_THRESHOLD) : undefined)
+      parseFiniteNumber(env.LCM_CONTEXT_THRESHOLD)
         ?? toNumber(pc.contextThreshold) ?? 0.75,
     freshTailCount:
-      (env.LCM_FRESH_TAIL_COUNT !== undefined ? parseInt(env.LCM_FRESH_TAIL_COUNT, 10) : undefined)
-        ?? toNumber(pc.freshTailCount) ?? 32,
+      parseFiniteInt(env.LCM_FRESH_TAIL_COUNT)
+        ?? toNumber(pc.freshTailCount) ?? 64,
+    newSessionRetainDepth:
+      parseFiniteInt(env.LCM_NEW_SESSION_RETAIN_DEPTH)
+        ?? toNumber(pc.newSessionRetainDepth) ?? 2,
     leafMinFanout:
-      (env.LCM_LEAF_MIN_FANOUT !== undefined ? parseInt(env.LCM_LEAF_MIN_FANOUT, 10) : undefined)
+      parseFiniteInt(env.LCM_LEAF_MIN_FANOUT)
         ?? toNumber(pc.leafMinFanout) ?? 8,
     condensedMinFanout:
-      (env.LCM_CONDENSED_MIN_FANOUT !== undefined ? parseInt(env.LCM_CONDENSED_MIN_FANOUT, 10) : undefined)
+      parseFiniteInt(env.LCM_CONDENSED_MIN_FANOUT)
         ?? toNumber(pc.condensedMinFanout) ?? 4,
     condensedMinFanoutHard:
-      (env.LCM_CONDENSED_MIN_FANOUT_HARD !== undefined ? parseInt(env.LCM_CONDENSED_MIN_FANOUT_HARD, 10) : undefined)
+      parseFiniteInt(env.LCM_CONDENSED_MIN_FANOUT_HARD)
         ?? toNumber(pc.condensedMinFanoutHard) ?? 2,
     incrementalMaxDepth:
-      (env.LCM_INCREMENTAL_MAX_DEPTH !== undefined ? parseInt(env.LCM_INCREMENTAL_MAX_DEPTH, 10) : undefined)
-        ?? toNumber(pc.incrementalMaxDepth) ?? 0,
-    leafChunkTokens:
-      (env.LCM_LEAF_CHUNK_TOKENS !== undefined ? parseInt(env.LCM_LEAF_CHUNK_TOKENS, 10) : undefined)
-        ?? toNumber(pc.leafChunkTokens) ?? 20000,
+      parseFiniteInt(env.LCM_INCREMENTAL_MAX_DEPTH)
+        ?? toNumber(pc.incrementalMaxDepth) ?? 1,
+    leafChunkTokens: resolvedLeafChunkTokens,
+    bootstrapMaxTokens: resolvedBootstrapMaxTokens,
     leafTargetTokens:
-      (env.LCM_LEAF_TARGET_TOKENS !== undefined ? parseInt(env.LCM_LEAF_TARGET_TOKENS, 10) : undefined)
-        ?? toNumber(pc.leafTargetTokens) ?? 1200,
+      parseFiniteInt(env.LCM_LEAF_TARGET_TOKENS)
+        ?? toNumber(pc.leafTargetTokens) ?? 2400,
     condensedTargetTokens:
-      (env.LCM_CONDENSED_TARGET_TOKENS !== undefined ? parseInt(env.LCM_CONDENSED_TARGET_TOKENS, 10) : undefined)
+      parseFiniteInt(env.LCM_CONDENSED_TARGET_TOKENS)
         ?? toNumber(pc.condensedTargetTokens) ?? 2000,
     maxExpandTokens:
-      (env.LCM_MAX_EXPAND_TOKENS !== undefined ? parseInt(env.LCM_MAX_EXPAND_TOKENS, 10) : undefined)
+      parseFiniteInt(env.LCM_MAX_EXPAND_TOKENS)
         ?? toNumber(pc.maxExpandTokens) ?? 4000,
     largeFileTokenThreshold:
-      (env.LCM_LARGE_FILE_TOKEN_THRESHOLD !== undefined ? parseInt(env.LCM_LARGE_FILE_TOKEN_THRESHOLD, 10) : undefined)
+      parseFiniteInt(env.LCM_LARGE_FILE_TOKEN_THRESHOLD)
         ?? toNumber(pc.largeFileThresholdTokens)
         ?? toNumber(pc.largeFileTokenThreshold)
         ?? 25000,
@@ -176,14 +218,25 @@ export function resolveLcmConfig(
       env.LCM_EXPANSION_PROVIDER?.trim() ?? toStr(pc.expansionProvider) ?? "",
     expansionModel:
       env.LCM_EXPANSION_MODEL?.trim() ?? toStr(pc.expansionModel) ?? "",
-    autocompactDisabled:
-      env.LCM_AUTOCOMPACT_DISABLED !== undefined
-        ? env.LCM_AUTOCOMPACT_DISABLED === "true"
-        : toBool(pc.autocompactDisabled) ?? false,
+    delegationTimeoutMs: envDelegationTimeoutMs ?? toNumber(pc.delegationTimeoutMs) ?? 120000,
     timezone: env.TZ ?? toStr(pc.timezone) ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
     pruneHeartbeatOk:
       env.LCM_PRUNE_HEARTBEAT_OK !== undefined
         ? env.LCM_PRUNE_HEARTBEAT_OK === "true"
         : toBool(pc.pruneHeartbeatOk) ?? false,
+    maxAssemblyTokenBudget:
+      parseFiniteInt(env.LCM_MAX_ASSEMBLY_TOKEN_BUDGET)
+        ?? toNumber(pc.maxAssemblyTokenBudget) ?? undefined,
+    summaryMaxOverageFactor:
+      parseFiniteNumber(env.LCM_SUMMARY_MAX_OVERAGE_FACTOR)
+        ?? toNumber(pc.summaryMaxOverageFactor) ?? 3,
+    customInstructions:
+      env.LCM_CUSTOM_INSTRUCTIONS?.trim() ?? toStr(pc.customInstructions) ?? "",
+    circuitBreakerThreshold:
+      parseFiniteInt(env.LCM_CIRCUIT_BREAKER_THRESHOLD)
+        ?? toNumber(pc.circuitBreakerThreshold) ?? 5,
+    circuitBreakerCooldownMs:
+      parseFiniteInt(env.LCM_CIRCUIT_BREAKER_COOLDOWN_MS)
+        ?? toNumber(pc.circuitBreakerCooldownMs) ?? 1_800_000,
   };
 }

package/src/db/migration.ts

@@ -1,5 +1,6 @@
 import type { DatabaseSync } from "node:sqlite";
 import { getLcmDbFeatures } from "./features.js";
+import { parseUtcTimestampOrNull } from "../store/parse-utc-timestamp.js";
 
 type SummaryColumnInfo = {
   name?: string;
@@ -62,18 +63,7 @@ function ensureSummaryMetadataColumns(db: DatabaseSync): void {
 }
 
 function parseTimestamp(value: string | null | undefined): Date | null {
-  if (typeof value !== "string" || !value.trim()) {
-    return null;
-  }
-
-  const direct = new Date(value);
-  if (!Number.isNaN(direct.getTime())) {
-    return direct;
-  }
-
-  const normalized = value.includes("T") ? value : `${value.replace(" ", "T")}Z`;
-  const parsed = new Date(normalized);
-  return Number.isNaN(parsed.getTime()) ? null : parsed;
+  return parseUtcTimestampOrNull(value);
 }
 
 function isoStringOrNull(value: Date | null): string | null {
@@ -434,6 +424,8 @@ export function runLcmMigrations(
       conversation_id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id TEXT NOT NULL,
       session_key TEXT,
+      active INTEGER NOT NULL DEFAULT 1,
+      archived_at TEXT,
       title TEXT,
       bootstrapped_at TEXT,
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
@@ -579,7 +571,27 @@ export function runLcmMigrations(
     db.exec(`ALTER TABLE conversations ADD COLUMN session_key TEXT`);
   }
 
-  db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS conversations_session_key_idx ON conversations (session_key)`);
+  const hasActive = conversationColumns.some((col) => col.name === "active");
+  if (!hasActive) {
+    db.exec(`ALTER TABLE conversations ADD COLUMN active INTEGER NOT NULL DEFAULT 1`);
+  }
+
+  const hasArchivedAt = conversationColumns.some((col) => col.name === "archived_at");
+  if (!hasArchivedAt) {
+    db.exec(`ALTER TABLE conversations ADD COLUMN archived_at TEXT`);
+  }
+
+  db.exec(`UPDATE conversations SET active = 1 WHERE active IS NULL`);
+  db.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS conversations_active_session_key_idx
+    ON conversations (session_key)
+    WHERE session_key IS NOT NULL AND active = 1
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS conversations_session_key_active_created_idx
+    ON conversations (session_key, active, created_at)
+  `);
+  db.exec(`DROP INDEX IF EXISTS conversations_session_key_idx`);
   ensureSummaryDepthColumn(db);
   ensureSummaryMetadataColumns(db);
   ensureSummaryModelColumn(db);
@@ -649,4 +661,29 @@ export function runLcmMigrations(
       SELECT summary_id, content FROM summaries;
     `);
   }
+
+  // ── CJK trigram FTS table ────────────────────────────────────────────────
+  // FTS5 unicode61 (porter) tokenizer cannot segment CJK ideographs, so CJK
+  // queries currently fall back to a LIKE path with AND logic.  When the user's
+  // phrasing doesn't match the summary verbatim (e.g. "端到端测试结果" vs
+  // "端到端测试"), ALL terms must match and the query returns 0 candidates.
+  //
+  // A trigram-tokenized table indexes every 3-character substring, enabling
+  // native CJK substring matching via FTS5 MATCH with OR semantics.
+  const cjkTableExists = db
+    .prepare(
+      "SELECT 1 FROM sqlite_master WHERE type='table' AND name='summaries_fts_cjk'",
+    )
+    .get();
+  if (!cjkTableExists) {
+    db.exec(`
+      CREATE VIRTUAL TABLE summaries_fts_cjk USING fts5(
+        summary_id UNINDEXED,
+        content,
+        tokenize='trigram'
+      );
+      INSERT INTO summaries_fts_cjk(summary_id, content)
+      SELECT summary_id, content FROM summaries;
+    `);
+  }
 }