@oar-sh/oar 0.9.11 → 0.9.12

package/server/services/background-task-store.mjs

@@ -12,16 +12,59 @@
  * post). `reported` remembers which workers this runtime has heard from
  * about their tasks at all: until then "no set" means "not told yet", not
  * "no tasks".
+ *
+ * Ended tasks: a task that leaves the set while it names an `outputPath` (a
+ * shell or Monitor task with a console) is kept as an ended row for an hour,
+ * at most 20 per key, so the panel can still show how it ended and open its
+ * output. A settle post (`settle`) says how; one that arrives before the set
+ * drops the task is kept until it does. Memory only, like the sets.
+ *
+ * Health: the health poller's last reading per live task (`setHealth`), served
+ * with the task rows (`withHealth`) and carried onto the ended row, where the
+ * poller's reading after the end replaces it (`setEndedHealth`).
  */
 
 import { backgroundTaskDigest, sameBackgroundTaskDigest } from '../../shared/worker-runtime/background-task-digest.mjs';
+import { TASK_OUTPUT_LIMITS } from '../../shared/task-output-text.mjs';
 
 function keyOf(value) {
   return String(value || '').trim();
 }
 
-export function createBackgroundTaskStore({ now = () => Date.now() } = {}) {
+const ENDED_STATUSES = new Set(['completed', 'failed', 'stopped', 'unknown']);
+
+/** A worker's word for how a task ended, as one of completed, failed, stopped, unknown. */
+export function normalizeEndedTaskStatus(status, exitCode = null) {
+  const text = String(status || '').trim().toLowerCase();
+  if (ENDED_STATUSES.has(text)) return text;
+  if (['complete', 'done', 'success', 'succeeded', 'ok', 'exited'].includes(text)) {
+    return Number.isInteger(exitCode) && exitCode !== 0 ? 'failed' : 'completed';
+  }
+  if (['error', 'errored', 'failure'].includes(text)) return 'failed';
+  if (['killed', 'cancelled', 'canceled', 'aborted', 'interrupted', 'timeout', 'timed_out'].includes(text)) return 'stopped';
+  if (Number.isInteger(exitCode)) return exitCode === 0 ? 'completed' : 'failed';
+  return 'unknown';
+}
+
+function exitCodeOf(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const number = Number(value);
+  return Number.isInteger(number) ? number : null;
+}
+
+export function createBackgroundTaskStore({
+  now = () => Date.now(),
+  endedKeepMs = TASK_OUTPUT_LIMITS.endedKeepMs,
+  endedMax = TASK_OUTPUT_LIMITS.endedMax,
+} = {}) {
   const sets = new Map();
+  // key → Map(taskId → ended row), newest last.
+  const endedRows = new Map();
+  // key → Map(taskId → { status, exitCode, outputPath, at }): how a task
+  // ended, told before the set dropped it.
+  const settledAhead = new Map();
+  // key → Map(taskId → the health poller's last reading).
+  const healthByKey = new Map();
   const reported = new Set();
   // key → the order of the newest set applied, `{ epoch, seq }` as the
   // worker numbered it. `epoch` names the worker process; it is compared
@@ -39,11 +82,159 @@ export function createBackgroundTaskStore({ now = () => Date.now() } = {}) {
       const id = keyOf(conversationId);
       if (!id) return;
       reported.add(id);
-      if (!Array.isArray(tasks) || tasks.length === 0) {
+      const next = Array.isArray(tasks) ? tasks : [];
+      const nextIds = new Set(next.map((task) => keyOf(task?.taskId)).filter(Boolean));
+      // Tasks that left the set with a console become ended rows.
+      for (const task of sets.get(id)?.tasks || []) {
+        const taskId = keyOf(task?.taskId);
+        if (!taskId || nextIds.has(taskId) || !task?.outputPath) continue;
+        const ahead = settledAhead.get(id)?.get(taskId) || null;
+        addEnded(id, {
+          ...task,
+          ...(ahead?.steps !== undefined ? { steps: ahead.steps } : {}),
+          status: ahead?.status || 'unknown',
+          exitCode: ahead ? ahead.exitCode : (task.exitCode ?? null),
+          health: healthByKey.get(id)?.get(taskId) || task.health || undefined,
+        });
+      }
+      // A task back in the set (a resync after a restart) is not ended.
+      for (const taskId of nextIds) {
+        endedRows.get(id)?.delete(taskId);
+        settledAhead.get(id)?.delete(taskId);
+      }
+      const health = healthByKey.get(id);
+      if (health) {
+        for (const taskId of [...health.keys()]) if (!nextIds.has(taskId)) health.delete(taskId);
+        if (!health.size) healthByKey.delete(id);
+      }
+      if (next.length === 0) {
         sets.delete(id);
         return;
       }
-      sets.set(id, { tasks, updatedAt: now() });
+      sets.set(id, { tasks: next, updatedAt: now() });
+    },
+    /**
+     * How a task ended (`/api/background-task-settled`): updates its ended
+     * row, or is kept for the moment the set drops it, or, for a task this
+     * runtime never saw live that names its output, becomes an ended row of
+     * its own. Returns the ended row when there is one.
+     */
+    settle(conversationId, taskId, { status, exitCode, outputPath, description, taskType, startedAt, outputKind, steps } = {}) {
+      const id = keyOf(conversationId);
+      const task = keyOf(taskId);
+      if (!id || !task) return null;
+      prune(id);
+      const code = exitCodeOf(exitCode);
+      const normalized = normalizeEndedTaskStatus(status, code);
+      const stepCount = Number.isInteger(steps) && steps >= 0 ? steps : undefined;
+      const existing = endedRows.get(id)?.get(task);
+      if (existing) {
+        existing.status = normalized;
+        existing.exitCode = code;
+        if (!existing.outputPath && outputPath) {
+          existing.outputPath = outputPath;
+          if (existing.outputKind !== 'file' && existing.outputKind !== 'spool') existing.outputKind = outputKind === 'spool' ? 'spool' : 'file';
+        }
+        if (stepCount !== undefined) existing.steps = stepCount;
+        return existing;
+      }
+      const live = (sets.get(id)?.tasks || []).find((entry) => keyOf(entry?.taskId) === task);
+      if (live) {
+        let ahead = settledAhead.get(id);
+        if (!ahead) settledAhead.set(id, ahead = new Map());
+        ahead.set(task, { status: normalized, exitCode: code, steps: stepCount, at: now() });
+        // The first path a task names wins. A row that had none was read
+        // from a snapshot (or not at all): from now on it is the file.
+        if (outputPath && !live.outputPath) {
+          live.outputPath = outputPath;
+          if (live.outputKind !== 'file' && live.outputKind !== 'spool') live.outputKind = outputKind === 'spool' ? 'spool' : 'file';
+        }
+        return null;
+      }
+      if (!outputPath) return null;
+      return addEnded(id, {
+        taskId: task,
+        taskType: keyOf(taskType) || 'local_bash',
+        description: String(description || '').trim().slice(0, 500),
+        startedAt: Number(startedAt) || null,
+        outputPath,
+        outputKind: outputKind || 'file',
+        stoppable: false,
+        status: normalized,
+        exitCode: code,
+        ...(stepCount !== undefined ? { steps: stepCount } : {}),
+      });
+    },
+    /** The ended rows of these keys, newest first. */
+    ended(...keys) {
+      const rows = [];
+      for (const id of new Set(keys.map(keyOf).filter(Boolean))) {
+        prune(id);
+        rows.push(...(endedRows.get(id)?.values() || []));
+      }
+      return rows.sort((a, b) => b.endedAt - a.endedAt).map((row) => ({ ...row }));
+    },
+    /** The poller's last reading for a live task, or null. */
+    health(conversationId, taskId) {
+      return healthByKey.get(keyOf(conversationId))?.get(keyOf(taskId)) || null;
+    },
+    setHealth(conversationId, taskId, value) {
+      const id = keyOf(conversationId);
+      const task = keyOf(taskId);
+      if (!id || !task) return;
+      let health = healthByKey.get(id);
+      if (!value) {
+        health?.delete(task);
+        return;
+      }
+      if (!health) healthByKey.set(id, health = new Map());
+      health.set(task, value);
+    },
+    /** The keys that hold ended rows. */
+    endedKeys() {
+      return [...endedRows.keys()];
+    },
+    /**
+     * The poller's reading of an ended task's file, taken after the end: the
+     * last output (a test runner's summary) often lands between two readings
+     * of the live task. Returns false when there is no such row.
+     */
+    setEndedHealth(conversationId, taskId, value) {
+      const row = endedRows.get(keyOf(conversationId))?.get(keyOf(taskId));
+      if (!row || !value) return false;
+      row.health = value;
+      return true;
+    },
+    /** Task rows with the poller's last reading on each as `health`. */
+    withHealth(tasks, ...keys) {
+      const ids = keys.map(keyOf).filter(Boolean);
+      return (Array.isArray(tasks) ? tasks : []).map((task) => {
+        const taskId = keyOf(task?.taskId);
+        const health = ids.map((id) => healthByKey.get(id)?.get(taskId)).find(Boolean);
+        return health ? { ...task, health } : task;
+      });
+    },
+    /**
+     * A task of these keys, live or ended: `{ key, task, ended }` or null.
+     * The live set wins over an ended row.
+     */
+    findTask(keys, taskId) {
+      const task = keyOf(taskId);
+      const ids = [...new Set((Array.isArray(keys) ? keys : [keys]).map(keyOf).filter(Boolean))];
+      if (!task) return null;
+      for (const id of ids) {
+        const live = (sets.get(id)?.tasks || []).find((entry) => keyOf(entry?.taskId) === task);
+        if (live) {
+          const health = healthByKey.get(id)?.get(task);
+          return { key: id, task: health ? { ...live, health } : live, ended: false };
+        }
+      }
+      for (const id of ids) {
+        prune(id);
+        const row = endedRows.get(id)?.get(task);
+        if (row) return { key: id, task: { ...row }, ended: true };
+      }
+      return null;
     },
     get(conversationId) {
       return sets.get(keyOf(conversationId))?.tasks || [];
@@ -115,6 +306,14 @@ export function createBackgroundTaskStore({ now = () => Date.now() } = {}) {
       return true;
     },
     /** The conversation is gone: everything held for these keys goes. */
+    /**
+     * Drops expired ended rows and pending settles of every key, also of
+     * conversations nobody reads again (the per-key prune runs on reads).
+     * Called from the health poller's tick.
+     */
+    pruneAll() {
+      for (const id of new Set([...endedRows.keys(), ...settledAhead.keys()])) prune(id);
+    },
     forget(...keys) {
       for (const id of keys.map(keyOf).filter(Boolean)) {
         sets.delete(id);
@@ -122,7 +321,45 @@ export function createBackgroundTaskStore({ now = () => Date.now() } = {}) {
         applied.delete(id);
         holders.delete(id);
         announced.delete(id);
+        endedRows.delete(id);
+        settledAhead.delete(id);
+        healthByKey.delete(id);
       }
     },
   };
+
+  function prune(id) {
+    const cutoff = now() - endedKeepMs;
+    const rows = endedRows.get(id);
+    if (rows) {
+      for (const [taskId, row] of rows) if (row.endedAt < cutoff) rows.delete(taskId);
+      if (!rows.size) endedRows.delete(id);
+    }
+    const ahead = settledAhead.get(id);
+    if (ahead) {
+      for (const [taskId, entry] of ahead) if (entry.at < cutoff) ahead.delete(taskId);
+      if (!ahead.size) settledAhead.delete(id);
+    }
+  }
+
+  function addEnded(id, task) {
+    let rows = endedRows.get(id);
+    if (!rows) endedRows.set(id, rows = new Map());
+    const taskId = keyOf(task.taskId);
+    rows.delete(taskId);
+    const row = {
+      ...task,
+      taskId,
+      status: normalizeEndedTaskStatus(task.status, exitCodeOf(task.exitCode)),
+      exitCode: exitCodeOf(task.exitCode),
+      endedAt: now(),
+      stoppable: false,
+    };
+    if (!row.health) delete row.health;
+    rows.set(taskId, row);
+    settledAhead.get(id)?.delete(taskId);
+    while (rows.size > endedMax) rows.delete(rows.keys().next().value);
+    prune(id);
+    return row;
+  }
 }

package/server/services/cli-process-runner.mjs

@@ -37,10 +37,6 @@ const OTHER_ESCAPE_PATTERN = /\x1b[@-Z\\-_]/g;
 // differently-sized terminal this degrades to the pre-wrap behaviour.
 const PTY_WRAP_COLUMNS = 80;
 
-function normalizeText(value) {
-  return String(value == null ? '' : value).trim();
-}
-
 /**
  * Removes OSC sequences (including OSC-8 hyperlink wrappers), ANSI CSI
  * sequences and the CR the PTY adds to every line, leaving the human-visible
@@ -74,23 +70,10 @@ export function joinWrappedLines(value) {
   return joined.join('\n');
 }
 
-/**
- * Redacts anything token-shaped plus an exact secret the caller knows it
- * handed over (the pasted Claude login code), so an error tail can be surfaced
- * to the UI without leaking a credential. Long PKCE segments in an authorize
- * URL get caught by the generic rule too, which is fine: the URL is already
- * carried in the login payload.
- */
-export function scrubSecrets(text, submittedCode = '') {
-  let output = String(text == null ? '' : text);
-  const code = normalizeText(submittedCode);
-  if (code.length >= 4) {
-    output = output.split(code).join('[redacted]');
-  }
-  return output
-    .replace(/sk-ant-[A-Za-z0-9_-]+/g, '[redacted]')
-    .replace(/[A-Za-z0-9_-]{32,}/g, '[redacted]');
-}
+// Redacts anything token-shaped plus an exact secret the caller handed over.
+// The rules live in the shared text pipeline, which also scrubs background
+// task output (browser-safe, so it cannot import this module).
+export { scrubSecrets } from '../../shared/task-output-text.mjs';
 
 /** Collapses captured output into one short single-line tail for an error. */
 export function tailOf(text, limit = MAX_ERROR_TAIL_CHARS) {

package/server/services/conversation-history-page.mjs

@@ -0,0 +1,199 @@
+'use strict';
+
+// One page of a conversation's history, selected in SQL.
+//
+// The history route used to load every message, hydrate every reply and only
+// then cut the page out (selectConversationHistoryPage in sessions-routes.mjs),
+// so each page and each live poll paid for the whole conversation. This module
+// selects the page's rows in SQL with the same cursor rules and the same
+// pageInfo, so only the page is hydrated.
+//
+// The JS order is (timestamp in ms, then id by localeCompare). SQL orders by
+// (timestamp text, id text). The two agree when every timestamp has the fixed
+// ISO shape the relay writes (YYYY-MM-DDTHH:MM:SS.mmmZ) and every id is made
+// of lowercase letters, digits and dashes (the relay's UUIDs). A conversation
+// with any other row is not paged here: the selector returns null and the
+// caller keeps the in-memory path, which handles every shape.
+
+const ISO_TIMESTAMP_GLOB = '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9].[0-9][0-9][0-9]Z';
+const ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+const ORDERABLE_ID_PATTERN = /^[-0-9a-z]+$/;
+
+export function normalizeConversationTimestampMs(value) {
+  const text = String(value || '').trim();
+  if (!text) return 0;
+  const sqliteUtcLike = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?)$/;
+  const hasExplicitTimezone = /(?:Z|[+-]\d{2}:?\d{2})$/i.test(text);
+  let normalized = text;
+  if (!hasExplicitTimezone && sqliteUtcLike.test(text)) {
+    const [, day, time] = text.match(sqliteUtcLike) || [];
+    normalized = `${day}T${time}Z`;
+  }
+  const parsed = Date.parse(normalized);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+export function normalizeConversationHistoryLimit(value, fallback = 20) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.min(100, Math.max(1, Math.trunc(numeric)));
+}
+
+/**
+ * The pageInfo of a history page: `pageMessages` in conversation order, and
+ * whether the conversation has rows before the first and after the last.
+ */
+export function buildConversationHistoryPageInfo(pageMessages = [], { hasMoreOlder = false, hasMoreNewer = false } = {}) {
+  const firstMessage = pageMessages[0] || null;
+  const lastMessage = pageMessages[pageMessages.length - 1] || null;
+  return {
+    hasMore: hasMoreOlder,
+    hasMoreOlder,
+    hasMoreNewer,
+    nextCursor: firstMessage ? {
+      beforeMessageId: String(firstMessage.id || '').trim(),
+      beforeTimestamp: String(firstMessage.timestamp || '').trim() || null,
+    } : null,
+    olderCursor: firstMessage ? {
+      beforeMessageId: String(firstMessage.id || '').trim(),
+      beforeTimestamp: String(firstMessage.timestamp || '').trim() || null,
+    } : null,
+    newerCursor: lastMessage ? {
+      afterMessageId: String(lastMessage.id || '').trim(),
+      afterTimestamp: String(lastMessage.timestamp || '').trim() || null,
+    } : null,
+  };
+}
+
+/**
+ * The prepared statements for paging one conversation. `sharedOnly` pages
+ * over the rows a shared view shows (not hidden from shares).
+ */
+export function createConversationHistoryPageStatements(db) {
+  const messageColumns = new Set(db.prepare(`PRAGMA table_info(messages)`).all().map((column) => column.name));
+  const sharedFilter = messageColumns.has('hidden_from_shares') ? 'AND hidden_from_shares = 0' : '';
+  const hasResendColumns = messageColumns.has('source_message_id') && messageColumns.has('resend_of_message_id');
+  const build = (visibility) => {
+    const base = `FROM messages WHERE conversation_id = @conversationId ${visibility}`;
+    const older = `(timestamp < @timestamp OR (timestamp = @timestamp AND @id IS NOT NULL AND id < @id))`;
+    const newer = `(timestamp > @timestamp OR (timestamp = @timestamp AND @id IS NOT NULL AND id > @id))`;
+    return {
+      irregular: db.prepare(`
+        SELECT EXISTS (
+          SELECT 1 ${base}
+          AND NOT (timestamp GLOB '${ISO_TIMESTAMP_GLOB}' AND id <> '' AND id NOT GLOB '*[^-0-9a-z]*')
+        ) AS irregular
+      `),
+      findById: db.prepare(`SELECT id, timestamp ${base} AND id = @id`),
+      older: db.prepare(`SELECT * ${base} AND ${older} ORDER BY timestamp DESC, id DESC LIMIT @limit`),
+      newer: db.prepare(`SELECT * ${base} AND ${newer} ORDER BY timestamp ASC, id ASC LIMIT @limit`),
+      fromInclusive: db.prepare(`
+        SELECT * ${base} AND (timestamp > @timestamp OR (timestamp = @timestamp AND id >= @id))
+        ORDER BY timestamp ASC, id ASC LIMIT @limit
+      `),
+      tail: db.prepare(`SELECT * ${base} ORDER BY timestamp DESC, id DESC LIMIT @limit`),
+      existsOlder: db.prepare(`SELECT EXISTS (SELECT 1 ${base} AND ${older}) AS found`),
+      existsNewer: db.prepare(`SELECT EXISTS (SELECT 1 ${base} AND ${newer}) AS found`),
+      // What liveResendsByOriginal reads, for the whole conversation: a
+      // stopped marker on the page may have its Resend outside it.
+      resendIndex: hasResendColumns
+        ? db.prepare(`SELECT id, role, source_message_id, resend_of_message_id ${base} ORDER BY timestamp ASC`)
+        : null,
+    };
+  };
+  const all = build('');
+  const shared = build(sharedFilter);
+  return {
+    selectConversationHistoryPage(conversationId, options = {}) {
+      return selectConversationHistoryPageFromStatements(options.sharedOnly ? shared : all, conversationId, options);
+    },
+    listConversationResendIndex(conversationId, { sharedOnly = false } = {}) {
+      const statement = (sharedOnly ? shared : all).resendIndex;
+      return statement ? statement.all({ conversationId }) : [];
+    },
+  };
+}
+
+// A cursor as the in-memory selector resolves it, in the SQL shape: the
+// message's own timestamp when its id is in the conversation, else the given
+// timestamp. Null when there is no cursor; `unsupported` when the given
+// values cannot be compared in SQL the way the selector compares them.
+function resolveCursor(statements, conversationId, { messageId = '', timestamp = '' } = {}) {
+  const cursorMessageId = String(messageId || '').trim();
+  const cursorTimestampText = String(timestamp || '').trim();
+  if (cursorMessageId) {
+    const row = statements.findById.get({ conversationId, id: cursorMessageId });
+    if (row) return { id: cursorMessageId, timestamp: String(row.timestamp) };
+  }
+  if (!cursorTimestampText) return null;
+  if (cursorMessageId && !ORDERABLE_ID_PATTERN.test(cursorMessageId)) return 'unsupported';
+  let canonical = cursorTimestampText;
+  if (!ISO_TIMESTAMP_PATTERN.test(canonical)) {
+    canonical = new Date(normalizeConversationTimestampMs(cursorTimestampText)).toISOString();
+    if (!ISO_TIMESTAMP_PATTERN.test(canonical)) return 'unsupported';
+  }
+  return { id: cursorMessageId || null, timestamp: canonical };
+}
+
+/**
+ * The page of rows (raw message rows, in conversation order) and its
+ * pageInfo, by the rules of selectConversationHistoryPage; null when the
+ * conversation or the cursor cannot be paged in SQL (see the top note).
+ */
+function selectConversationHistoryPageFromStatements(statements, conversationId, {
+  limit = 20,
+  beforeMessageId = '',
+  beforeTimestamp = '',
+  afterMessageId = '',
+  afterTimestamp = '',
+  aroundMessageId = '',
+} = {}) {
+  if (statements.irregular.get({ conversationId })?.irregular) return null;
+  const pageLimit = normalizeConversationHistoryLimit(limit);
+  const aroundId = String(aroundMessageId || '').trim();
+  const requestedAroundWindow = !!aroundId;
+  const requestedAfterWindow = !!String(afterMessageId || '').trim();
+  const beforeCursor = resolveCursor(statements, conversationId, { messageId: beforeMessageId, timestamp: beforeTimestamp });
+  const afterCursor = resolveCursor(statements, conversationId, { messageId: afterMessageId, timestamp: afterTimestamp });
+  if (beforeCursor === 'unsupported' || afterCursor === 'unsupported') return null;
+
+  let rows = [];
+  if (aroundId) {
+    const anchor = statements.findById.get({ conversationId, id: aroundId });
+    if (anchor) {
+      // Enough rows on both sides for the in-memory window rules to give the
+      // same window as over the whole conversation.
+      const before = statements.older
+        .all({ conversationId, timestamp: anchor.timestamp, id: anchor.id, limit: pageLimit - 1 })
+        .reverse();
+      const fromAnchor = statements.fromInclusive
+        .all({ conversationId, timestamp: anchor.timestamp, id: anchor.id, limit: pageLimit });
+      const local = [...before, ...fromAnchor];
+      const aroundIndex = before.length;
+      const halfWindow = Math.floor((pageLimit - 1) / 2);
+      let start = Math.max(0, aroundIndex - halfWindow);
+      const end = Math.min(local.length, start + pageLimit);
+      if ((end - start) < pageLimit) start = Math.max(0, end - pageLimit);
+      rows = local.slice(start, end);
+    }
+  }
+  if (!rows.length && !requestedAroundWindow && afterCursor) {
+    rows = statements.newer.all({ conversationId, ...afterCursor, limit: pageLimit });
+  }
+  if (!rows.length && !requestedAfterWindow && !requestedAroundWindow) {
+    rows = (beforeCursor
+      ? statements.older.all({ conversationId, ...beforeCursor, limit: pageLimit })
+      : statements.tail.all({ conversationId, limit: pageLimit })
+    ).reverse();
+  }
+
+  const first = rows[0] || null;
+  const last = rows[rows.length - 1] || null;
+  const hasMoreOlder = first
+    ? !!statements.existsOlder.get({ conversationId, timestamp: first.timestamp, id: first.id })?.found
+    : false;
+  const hasMoreNewer = last
+    ? !!statements.existsNewer.get({ conversationId, timestamp: last.timestamp, id: last.id })?.found
+    : false;
+  return { rows, pageInfo: buildConversationHistoryPageInfo(rows, { hasMoreOlder, hasMoreNewer }) };
+}

package/server/services/relay-prompt-sanitizer.mjs

@@ -100,12 +100,17 @@ function whitespaceFlexiblePattern(value) {
     .join('\\s+');
 }
 
+// The patterns depend only on the mode, so they are built once per mode and
+// reused: a long conversation sanitises every message on each history load.
+const PROMPT_PREFIX_PATTERN_CACHE = new Map();
+
 function buildPromptPrefixPatterns(mode) {
   const requestedMode = String(mode || '').trim().toLowerCase();
-  const modes = requestedMode && MODE_MARKERS[requestedMode]
-    ? [requestedMode]
-    : Object.keys(MODE_MARKERS);
-  return modes.flatMap((key) => {
+  const cacheKey = requestedMode && MODE_MARKERS[requestedMode] ? requestedMode : '';
+  const cached = PROMPT_PREFIX_PATTERN_CACHE.get(cacheKey);
+  if (cached) return cached;
+  const modes = cacheKey ? [cacheKey] : Object.keys(MODE_MARKERS);
+  const patterns = modes.flatMap((key) => {
     const marker = MODE_MARKERS[key];
     const currentFullPrefix = `${marker} ${MODE_INSTRUCTIONS[key]} ${RELAY_TOOL_GUIDANCE}`;
     const legacyFullPrefix = `${marker} ${LEGACY_MODE_INSTRUCTIONS[key]} ${RELAY_TOOL_GUIDANCE}`;
@@ -115,6 +120,8 @@ function buildPromptPrefixPatterns(mode) {
       new RegExp(`^${whitespaceFlexiblePattern(marker)}\\s*`, 'i'),
     ];
   });
+  PROMPT_PREFIX_PATTERN_CACHE.set(cacheKey, patterns);
+  return patterns;
 }
 
 function stripAttachmentPromptArtifacts(text) {