@martian-engineering/lossless-claw 0.5.3 → 0.6.1

package/src/store/summary-store.ts

@@ -1,6 +1,7 @@
 import type { DatabaseSync } from "node:sqlite";
 import { sanitizeFts5Query } from "./fts5-sanitize.js";
 import { buildLikeSearchPlan, containsCjk, createFallbackSnippet } from "./full-text-fallback.js";
+import { parseUtcTimestamp, parseUtcTimestampOrNull } from "./parse-utc-timestamp.js";
 
 export type SummaryKind = "leaf" | "condensed";
 export type ContextItemType = "message" | "summary";
@@ -117,6 +118,16 @@ export type ConversationBootstrapStateRecord = {
   updatedAt: Date;
 };
 
+export type TranscriptGcCandidateRecord = {
+  messageId: number;
+  conversationId: number;
+  seq: number;
+  toolCallId: string;
+  toolName: string | null;
+  externalizedFileId: string | null;
+  originalByteSize: number | null;
+};
+
 // ── DB row shapes (snake_case) ────────────────────────────────────────────────
 
 interface SummaryRow {
@@ -207,6 +218,17 @@ interface ConversationBootstrapStateRow {
   updated_at: string;
 }
 
+const CJK_QUERY_SEGMENT_RE =
+  /[\u2E80-\u9FFF\u3400-\u4DBF\uF900-\uFAFF\uAC00-\uD7AF\u3040-\u309F\u30A0-\u30FF]+/g;
+const LATIN_QUERY_TOKEN_RE = /[a-zA-Z0-9][\w./-]*/g;
+interface TranscriptGcCandidateRow {
+  message_id: number;
+  conversation_id: number;
+  seq: number;
+  tool_call_id: string | null;
+  tool_name: string | null;
+  metadata: string | null;
+}
 // ── Row mappers ───────────────────────────────────────────────────────────────
 
 function toSummaryRecord(row: SummaryRow): SummaryRecord {
@@ -224,8 +246,8 @@ function toSummaryRecord(row: SummaryRow): SummaryRecord {
     content: row.content,
     tokenCount: row.token_count,
     fileIds,
-    earliestAt: row.earliest_at ? new Date(row.earliest_at) : null,
-    latestAt: row.latest_at ? new Date(row.latest_at) : null,
+    earliestAt: parseUtcTimestampOrNull(row.earliest_at),
+    latestAt: parseUtcTimestampOrNull(row.latest_at),
     descendantCount:
       typeof row.descendant_count === "number" &&
       Number.isFinite(row.descendant_count) &&
@@ -245,7 +267,7 @@ function toSummaryRecord(row: SummaryRow): SummaryRecord {
         ? Math.floor(row.source_message_token_count)
         : 0,
     model: typeof row.model === "string" ? row.model : "unknown",
-    createdAt: new Date(row.created_at),
+    createdAt: parseUtcTimestamp(row.created_at),
   };
 }
 
@@ -256,7 +278,7 @@ function toContextItemRecord(row: ContextItemRow): ContextItemRecord {
     itemType: row.item_type,
     messageId: row.message_id,
     summaryId: row.summary_id,
-    createdAt: new Date(row.created_at),
+    createdAt: parseUtcTimestamp(row.created_at),
   };
 }
 
@@ -266,7 +288,7 @@ function toSearchResult(row: SummarySearchRow): SummarySearchResult {
     conversationId: row.conversation_id,
     kind: row.kind,
     snippet: row.snippet,
-    createdAt: new Date(row.created_at),
+    createdAt: parseUtcTimestamp(row.created_at),
     rank: row.rank,
   };
 }
@@ -280,7 +302,7 @@ function toLargeFileRecord(row: LargeFileRow): LargeFileRecord {
     byteSize: row.byte_size,
     storageUri: row.storage_uri,
     explorationSummary: row.exploration_summary,
-    createdAt: new Date(row.created_at),
+    createdAt: parseUtcTimestamp(row.created_at),
   };
 }
 
@@ -294,7 +316,43 @@ function toConversationBootstrapStateRecord(
     lastSeenMtimeMs: row.last_seen_mtime_ms,
     lastProcessedOffset: row.last_processed_offset,
     lastProcessedEntryHash: row.last_processed_entry_hash,
-    updatedAt: new Date(row.updated_at),
+    updatedAt: parseUtcTimestamp(row.updated_at),
+  };
+}
+
+function toTranscriptGcCandidateRecord(
+  row: TranscriptGcCandidateRow,
+): TranscriptGcCandidateRecord | null {
+  if (typeof row.tool_call_id !== "string" || row.tool_call_id.length === 0) {
+    return null;
+  }
+
+  let metadata: Record<string, unknown> | null = null;
+  try {
+    metadata =
+      typeof row.metadata === "string" && row.metadata.length > 0
+        ? (JSON.parse(row.metadata) as Record<string, unknown>)
+        : null;
+  } catch {
+    metadata = null;
+  }
+
+  if (!metadata || metadata.toolOutputExternalized !== true) {
+    return null;
+  }
+
+  return {
+    messageId: row.message_id,
+    conversationId: row.conversation_id,
+    seq: row.seq,
+    toolCallId: row.tool_call_id,
+    toolName: row.tool_name,
+    externalizedFileId:
+      typeof metadata.externalizedFileId === "string" ? metadata.externalizedFileId : null,
+    originalByteSize:
+      typeof metadata.originalByteSize === "number" && Number.isFinite(metadata.originalByteSize)
+        ? Math.max(0, Math.floor(metadata.originalByteSize))
+        : null,
   };
 }
 
@@ -400,6 +458,17 @@ export class SummaryStore {
       // compaction and assembly will still work correctly.
     }
 
+    // Also index into the CJK trigram FTS table for CJK substring search.
+    try {
+      this.db
+        .prepare(
+          `INSERT INTO summaries_fts_cjk(summary_id, content) VALUES (?, ?)`,
+        )
+        .run(input.summaryId, input.content);
+    } catch {
+      // CJK trigram FTS table may not exist yet (pre-migration); ignore.
+    }
+
     return toSummaryRecord(row);
   }
 
@@ -539,7 +608,71 @@ export class SummaryStore {
     }
     return orderedLinks;
   }
+  /**
+   * Return summarized tool-result messages that are safe candidates for
+   * transcript GC because they are no longer present as raw context items.
+   */
+  async listTranscriptGcCandidates(
+    conversationId: number,
+    options?: { limit?: number },
+  ): Promise<TranscriptGcCandidateRecord[]> {
+    const limit =
+      typeof options?.limit === "number" && Number.isFinite(options.limit) && options.limit > 0
+        ? Math.max(1, Math.floor(options.limit))
+        : 25;
 
+    const rows = this.db
+      .prepare(
+        `SELECT
+           m.message_id,
+           m.conversation_id,
+           m.seq,
+           mp.tool_call_id,
+           mp.tool_name,
+           mp.metadata
+         FROM messages m
+         JOIN message_parts mp
+           ON mp.message_id = m.message_id
+         WHERE m.conversation_id = ?
+           AND m.role = 'tool'
+           AND mp.part_type = 'tool'
+           AND mp.tool_call_id IS NOT NULL
+           AND mp.tool_call_id != ''
+           AND EXISTS (
+             SELECT 1
+             FROM summary_messages sm
+             WHERE sm.message_id = m.message_id
+           )
+           AND NOT EXISTS (
+             SELECT 1
+             FROM context_items ci
+             WHERE ci.conversation_id = m.conversation_id
+               AND ci.item_type = 'message'
+               AND ci.message_id = m.message_id
+           )
+         ORDER BY m.seq ASC, mp.ordinal ASC`,
+      )
+      .all(conversationId) as unknown as TranscriptGcCandidateRow[];
+
+    const seenMessageIds = new Set<number>();
+    const candidates: TranscriptGcCandidateRecord[] = [];
+    for (const row of rows) {
+      if (seenMessageIds.has(row.message_id)) {
+        continue;
+      }
+      const candidate = toTranscriptGcCandidateRecord(row);
+      if (!candidate) {
+        continue;
+      }
+      seenMessageIds.add(candidate.messageId);
+      candidates.push(candidate);
+      if (candidates.length >= limit) {
+        break;
+      }
+    }
+
+    return candidates;
+  }
   async getSummaryChildren(parentSummaryId: string): Promise<SummaryRecord[]> {
     const rows = this.db
       .prepare(
@@ -687,6 +820,45 @@ export class SummaryStore {
     return rows.map((row) => row.depth);
   }
 
+  async pruneForNewSession(conversationId: number, retainDepth: number): Promise<void> {
+    if (Number.isFinite(retainDepth) && retainDepth < 0) {
+      return;
+    }
+
+    this.db
+      .prepare(
+        `DELETE FROM context_items
+       WHERE conversation_id = ?
+         AND item_type = 'message'`,
+      )
+      .run(conversationId);
+
+    if (!Number.isFinite(retainDepth)) {
+      this.db
+        .prepare(
+          `DELETE FROM context_items
+         WHERE conversation_id = ?
+           AND item_type = 'summary'`,
+        )
+        .run(conversationId);
+      return;
+    }
+
+    this.db
+      .prepare(
+        `DELETE FROM context_items
+       WHERE conversation_id = ?
+         AND item_type = 'summary'
+         AND summary_id IN (
+           SELECT summary_id
+           FROM summaries
+           WHERE conversation_id = ?
+             AND depth < ?
+         )`,
+      )
+      .run(conversationId, conversationId, Math.floor(retainDepth));
+  }
+
   async appendContextMessage(conversationId: number, messageId: number): Promise<void> {
     const row = this.db
       .prepare(
@@ -830,10 +1002,30 @@ export class SummaryStore {
     const limit = input.limit ?? 50;
 
     if (input.mode === "full_text") {
-      // FTS5 unicode61 can return incomplete matches for CJK text, so route
-      // those queries through the existing LIKE fallback path immediately.
+      // FTS5 unicode61 cannot segment CJK ideographs, so CJK queries route
+      // through the trigram FTS table first, then fall back to LIKE with OR
+      // semantics (instead of the original AND logic which fails when the
+      // user's phrasing doesn't exactly match the summary text).
       if (containsCjk(input.query)) {
-        return this.searchLike(
+        const cjkSegments = this.extractCjkSegments(input.query);
+        const hasShortCjkSegment = cjkSegments.some((segment) => segment.length < 3);
+        if (!hasShortCjkSegment) {
+          try {
+            const trigramResults = this.searchCjkTrigram(
+              input.query,
+              limit,
+              input.conversationId,
+              input.since,
+              input.before,
+            );
+            if (trigramResults.length > 0) {
+              return trigramResults;
+            }
+          } catch {
+            // trigram table may not exist; fall through to LIKE OR
+          }
+        }
+        return this.searchLikeCjk(
           input.query,
           limit,
           input.conversationId,
@@ -950,6 +1142,183 @@ export class SummaryStore {
       conversationId: row.conversation_id,
       kind: row.kind,
       snippet: createFallbackSnippet(row.content, plan.terms),
+      createdAt: parseUtcTimestamp(row.created_at),
+      rank: 0,
+    }));
+  }
+
+  private extractCjkSegments(query: string): string[] {
+    return query.match(CJK_QUERY_SEGMENT_RE) ?? [];
+  }
+
+  private extractLatinTokens(query: string): string[] {
+    const tokens = query.match(LATIN_QUERY_TOKEN_RE) ?? [];
+    return [...new Set(tokens.map((token) => token.toLowerCase()))];
+  }
+
+  private escapeLikeTerm(term: string): string {
+    return term.replace(/([\\%_])/g, "\\$1");
+  }
+
+  // ── CJK trigram FTS search ──────────────────────────────────────────────
+  // Each CJK segment of 3+ chars is split into overlapping 4-char chunks for
+  // trigram MATCH with OR semantics within the segment. Segment groups are
+  // combined with AND, and Latin tokens are applied as LIKE filters so mixed
+  // queries still require every part of the user's intent.
+
+  /**
+   * Split a CJK string into overlapping chunks of `size` characters.
+   * E.g. "端到端测试结果" with size=4 →
+   *   ["端到端测", "到端测试", "端测试结", "测试结果"]
+   */
+  private splitCjkChunks(text: string, size: number): string[] {
+    const chunks: string[] = [];
+    for (let i = 0; i <= text.length - size; i++) {
+      const chunk = text.slice(i, i + size);
+      if (!chunks.includes(chunk)) {
+        chunks.push(chunk);
+      }
+    }
+    return chunks;
+  }
+
+  private searchCjkTrigram(
+    query: string,
+    limit: number,
+    conversationId?: number,
+    since?: Date,
+    before?: Date,
+  ): SummarySearchResult[] {
+    const cjkSegments = this.extractCjkSegments(query).filter((segment) => segment.length >= 3);
+    if (cjkSegments.length === 0) {
+      return [];
+    }
+    const latinTokens = this.extractLatinTokens(query);
+
+    // Build one OR group per CJK segment, then require every segment group and
+    // every Latin token to match so mixed queries preserve full-intent search.
+    const cjkGroups: string[] = [];
+    for (const segment of cjkSegments) {
+      const segmentTerms =
+        segment.length <= 4 ? [segment] : this.splitCjkChunks(segment, 4);
+      const groupExpr = [...new Set(segmentTerms)]
+        .map((term) => `"${term.replace(/"/g, '""')}"`)
+        .join(" OR ");
+      cjkGroups.push(`(${groupExpr})`);
+    }
+
+    const where: string[] = ["summaries_fts_cjk MATCH ?"];
+    const args: Array<string | number> = [cjkGroups.join(" AND ")];
+    for (const token of latinTokens) {
+      where.push("LOWER(s.content) LIKE ? ESCAPE '\\'");
+      args.push(`%${this.escapeLikeTerm(token)}%`);
+    }
+    if (conversationId != null) {
+      where.push("s.conversation_id = ?");
+      args.push(conversationId);
+    }
+    if (since) {
+      where.push("julianday(s.created_at) >= julianday(?)");
+      args.push(since.toISOString());
+    }
+    if (before) {
+      where.push("julianday(s.created_at) < julianday(?)");
+      args.push(before.toISOString());
+    }
+    args.push(limit);
+
+    const sql = `SELECT
+         f.summary_id,
+         s.conversation_id,
+         s.kind,
+         snippet(summaries_fts_cjk, 1, '', '', '...', 32) AS snippet,
+         rank,
+         s.created_at
+       FROM summaries_fts_cjk f
+       JOIN summaries s ON s.summary_id = f.summary_id
+       WHERE ${where.join(" AND ")}
+       ORDER BY rank
+       LIMIT ?`;
+    const rows = this.db.prepare(sql).all(...args) as unknown as SummarySearchRow[];
+    return rows.map(toSearchResult);
+  }
+
+  // ── CJK LIKE fallback ────────────────────────────────────────────────────
+  // When the trigram table is unavailable, split each CJK segment into
+  // sliding-window terms so partial matches still work. Terms within a single
+  // segment are ORed together, but each segment and Latin token still has to
+  // match so mixed queries keep full-intent semantics.
+
+  private searchLikeCjk(
+    query: string,
+    limit: number,
+    conversationId?: number,
+    since?: Date,
+    before?: Date,
+  ): SummarySearchResult[] {
+    const cjkSegments = this.extractCjkSegments(query);
+    const latinTokens = this.extractLatinTokens(query);
+    if (cjkSegments.length === 0 && latinTokens.length === 0) {
+      return [];
+    }
+
+    const cjkTerms: string[] = [];
+    const cjkClauses: string[] = [];
+    const cjkArgs: string[] = [];
+    for (const segment of cjkSegments) {
+      const segmentTerms =
+        segment.length === 1
+          ? [segment]
+          : segment.length === 2
+            ? [segment]
+            : this.splitCjkChunks(segment, 2);
+      const uniqueTerms = [...new Set(segmentTerms)];
+      cjkTerms.push(...uniqueTerms);
+      cjkClauses.push(
+        `(${uniqueTerms.map(() => `LOWER(content) LIKE ? ESCAPE '\\'`).join(" OR ")})`,
+      );
+      cjkArgs.push(
+        ...uniqueTerms.map((term) => `%${this.escapeLikeTerm(term.toLowerCase())}%`),
+      );
+    }
+
+    const latinClauses = latinTokens.map(() => `LOWER(content) LIKE ? ESCAPE '\\'`);
+    const latinArgs = latinTokens.map((token) => `%${this.escapeLikeTerm(token)}%`);
+
+    const where: string[] = [...cjkClauses, ...latinClauses];
+    const args: Array<string | number> = [...cjkArgs, ...latinArgs];
+    if (conversationId != null) {
+      where.push("conversation_id = ?");
+      args.push(conversationId);
+    }
+    if (since) {
+      where.push("julianday(created_at) >= julianday(?)");
+      args.push(since.toISOString());
+    }
+    if (before) {
+      where.push("julianday(created_at) < julianday(?)");
+      args.push(before.toISOString());
+    }
+    args.push(limit);
+
+    const rows = this.db
+      .prepare(
+        `SELECT summary_id, conversation_id, kind, depth, content, token_count, file_ids,
+                earliest_at, latest_at, descendant_count, descendant_token_count,
+                source_message_token_count, model, created_at
+         FROM summaries
+         WHERE ${where.join(" AND ")}
+         ORDER BY created_at DESC
+         LIMIT ?`,
+      )
+      .all(...args) as unknown as SummaryRow[];
+
+    const snippetTerms = cjkTerms.length > 0 ? [...new Set([...cjkTerms, ...latinTokens])] : latinTokens;
+    return rows.map((row) => ({
+      summaryId: row.summary_id,
+      conversationId: row.conversation_id,
+      kind: row.kind,
+      snippet: createFallbackSnippet(row.content, snippetTerms),
       createdAt: new Date(row.created_at),
       rank: 0,
     }));
@@ -1014,7 +1383,7 @@ export class SummaryStore {
           conversationId: row.conversation_id,
           kind: row.kind,
           snippet: match[0],
-          createdAt: new Date(row.created_at),
+          createdAt: parseUtcTimestamp(row.created_at),
           rank: 0,
         });
       }

package/src/summarize.ts

@@ -33,6 +33,16 @@ type ResolvedSummaryCandidate = SummaryResolutionCandidate & {
   model: string;
 };
 
+function buildSummarizerBreakerKey(params: {
+  candidate: ResolvedSummaryCandidate;
+  legacyAuthProfileId?: string;
+}): string {
+  const authProfileId = params.candidate.useLegacyAuthProfile
+    ? (params.legacyAuthProfileId ?? "-")
+    : "-";
+  return `provider:${params.candidate.provider};model:${params.candidate.model};authProfile:${authProfileId}`;
+}
+
 type SummaryMode = "normal" | "aggressive";
 
 const DEFAULT_LEAF_TARGET_TOKENS = 2400;
@@ -49,6 +59,18 @@ const AUTH_ERROR_TEXT_PATTERN =
   /\b401\b|unauthorized|unauthorised|invalid[_ -]?token|invalid[_ -]?api[_ -]?key|authentication failed|authorization failed|missing scope|insufficient scope|model\.request\b/i;
 const AUTH_ERROR_STATUS_KEYS = ["status", "statusCode", "status_code"] as const;
 const AUTH_ERROR_NESTED_KEYS = ["error", "response", "cause", "details", "data", "body"] as const;
+const AUTH_ERROR_TOP_LEVEL_KEYS = [
+  "error",
+  "errorMessage",
+  "status",
+  "statusCode",
+  "status_code",
+  "code",
+  "details",
+  "cause",
+  "data",
+  "body",
+] as const;
 
 type ProviderAuthFailure = {
   statusCode?: number;
@@ -411,6 +433,21 @@ function extractAuthFailureStatusCode(value: unknown, depth = 0): number | undef
   return undefined;
 }
 
+function hasTopLevelAuthInspectionKeys(value: Record<string, unknown>): boolean {
+  return AUTH_ERROR_TOP_LEVEL_KEYS.some((key) => key in value);
+}
+
+function looksLikeThrownError(value: Record<string, unknown>): boolean {
+  return (
+    (typeof value.name === "string" && /\berror\b/i.test(value.name)) ||
+    "stack" in value ||
+    (typeof value.message === "string" &&
+      !("content" in value) &&
+      !("response" in value) &&
+      !("output" in value))
+  );
+}
+
 function pickAuthInspectionValue(value: unknown): unknown {
   if (!isRecord(value)) {
     return value;
@@ -420,26 +457,43 @@ function pickAuthInspectionValue(value: unknown): unknown {
   }
 
   const subset: Record<string, unknown> = {};
-  for (const key of [
-    "error",
-    "errorMessage",
-    "message",
-    "status",
-    "statusCode",
-    "status_code",
-    "code",
-    "details",
-    "response",
-    "cause",
-  ]) {
+  const hasTopLevelAuthKeys = hasTopLevelAuthInspectionKeys(value);
+  const errorLike = value instanceof Error || looksLikeThrownError(value);
+
+  for (const key of AUTH_ERROR_TOP_LEVEL_KEYS) {
     if (key in value) {
       subset[key] = value[key];
     }
   }
-  return Object.keys(subset).length > 0 ? subset : value;
+
+  // Only inspect top-level message payloads when the envelope already looks
+  // error-shaped. Successful summary responses also use `message`.
+  if ((hasTopLevelAuthKeys || errorLike) && "message" in value) {
+    subset.message = value.message;
+  }
+
+  // `response` can carry either an error payload or successful summary text.
+  // Include it only when the surrounding or nested shape already looks like an
+  // error envelope.
+  if ("response" in value) {
+    const response = value.response;
+    if (
+      hasTopLevelAuthKeys ||
+      (isRecord(response) && hasTopLevelAuthInspectionKeys(response)) ||
+      (isRecord(response) && looksLikeThrownError(response))
+    ) {
+      subset.response = response;
+    }
+  }
+
+  return Object.keys(subset).length > 0 ? subset : {};
 }
 
-function extractProviderAuthFailure(value: unknown): ProviderAuthFailure | undefined {
+/** @internal Exported for testing only. */
+export function extractProviderAuthFailure(
+  value: unknown,
+  opts?: { requireStructuralSignal?: boolean },
+): ProviderAuthFailure | undefined {
   const inspectValue = pickAuthInspectionValue(value);
   const statusCode = extractAuthFailureStatusCode(inspectValue);
   const textParts: string[] = [];
@@ -449,7 +503,20 @@ function extractProviderAuthFailure(value: unknown): ProviderAuthFailure | undef
   const hasScopeSignal =
     missingModelRequestScope || /\b(missing|insufficient)\s+scope\b/i.test(normalizedMessage);
 
-  if (statusCode !== 401 && !hasScopeSignal && !AUTH_ERROR_TEXT_PATTERN.test(normalizedMessage)) {
+  // When requireStructuralSignal is set (e.g. checking a successful API response
+  // rather than a caught error), only detect auth failures that have a concrete
+  // structural indicator (HTTP 401 status code or an explicit provider_auth error
+  // kind).  Plain text matches in the response body are NOT sufficient — the LLM
+  // summary content may legitimately discuss auth errors without being one.
+  const hasExplicitErrorKind =
+    isRecord(value) && isRecord((value as Record<string, unknown>).error) &&
+    ((value as Record<string, unknown>).error as Record<string, unknown>).kind === "provider_auth";
+
+  if (opts?.requireStructuralSignal) {
+    if (statusCode !== 401 && !hasExplicitErrorKind) {
+      return undefined;
+    }
+  } else if (statusCode !== 401 && !hasScopeSignal && !AUTH_ERROR_TEXT_PATTERN.test(normalizedMessage)) {
     return undefined;
   }
 
@@ -1041,7 +1108,7 @@ export async function createLcmSummarizeFromLegacyParams(params: {
   deps: LcmDependencies;
   legacyParams: LcmSummarizerLegacyParams;
   customInstructions?: string;
-}): Promise<{ fn: LcmSummarizeFn; model: string } | undefined> {
+}): Promise<{ fn: LcmSummarizeFn; model: string; breakerKey: string } | undefined> {
   const resolvedCandidates = resolveSummaryCandidates(params);
   if (resolvedCandidates.length === 0) {
     console.error("[lcm] createLcmSummarize: no summary model candidates resolved");
@@ -1168,7 +1235,11 @@ export async function createLcmSummarizeFromLegacyParams(params: {
 
         try {
           const directResult = await runSummarizerCall(directApiKey, "auth-retry", reasoning);
-          const directFailure = extractProviderAuthFailure(directResult);
+          // Use requireStructuralSignal on the retry success path too — the
+          // summary text may legitimately contain auth-error phrases.
+          const directFailure = extractProviderAuthFailure(directResult, {
+            requireStructuralSignal: true,
+          });
           if (directFailure) {
             const retryAuthError = new LcmProviderAuthError({
               provider,
@@ -1186,7 +1257,11 @@ export async function createLcmSummarizeFromLegacyParams(params: {
           if (directErr instanceof LcmProviderAuthError) {
             throw directErr;
           }
-          const directFailure = extractProviderAuthFailure(directErr);
+          // Catch path: real errors carry structural signals (HTTP 401, error.kind),
+          // so requireStructuralSignal is safe here too.
+          const directFailure = extractProviderAuthFailure(directErr, {
+            requireStructuralSignal: true,
+          });
           if (directFailure) {
             const retryAuthError = new LcmProviderAuthError({
               provider,
@@ -1207,7 +1282,12 @@ export async function createLcmSummarizeFromLegacyParams(params: {
         const apiKey = await params.deps.getApiKey(provider, model, lookupOptions);
         try {
           const result = await runSummarizerCall(apiKey, label, reasoning);
-          const authFailure = extractProviderAuthFailure(result);
+          // Use requireStructuralSignal so that LLM summary text containing
+          // auth-related words (e.g. "provider auth error") is NOT mistaken
+          // for an actual API auth failure.
+          const authFailure = extractProviderAuthFailure(result, {
+            requireStructuralSignal: true,
+          });
           if (!authFailure) {
             return result;
           }
@@ -1387,5 +1467,12 @@ export async function createLcmSummarizeFromLegacyParams(params: {
     return "";
   };
 
-  return { fn, model: resolvedCandidates[0]!.model };
+  return {
+    fn,
+    model: resolvedCandidates[0]!.model,
+    breakerKey: buildSummarizerBreakerKey({
+      candidate: resolvedCandidates[0]!,
+      legacyAuthProfileId,
+    }),
+  };
 }