hippo-memory 1.72.0 → 2.1.0

package/dist/capture/compaction-spool.js

@@ -8,7 +8,9 @@ import { isSqliteBusy } from '../db/busy.js';
 import { errorMessage } from '../util/log.js';
 const STAMP_DIGITS = 13;
 export const SPOOL_DIR = 'compactions-spool';
-/** Starts the log line of a step that broke with an unexpected error, so the session-start banner counts it; a set-aside file is counted
+/**
+ * Starts the log line of a step that broke with an unexpected error, so the session-start banner counts it; a set-aside
+ * file is counted
  * by its `.bad` name instead. */
 export const SPOOL_PROBLEM = 'spool problem: ';
 const LOCK = 'replay.lock';
@@ -29,18 +31,16 @@ const BAD = /^([\w-]+)\.(?:\w+\.)?bad$/;
 const BAD_TMP = /^[\w-]+\.\w+\.bad\.[0-9a-f]{8}\.tmp$/;
 const NEW_STEM = /^(\d{13})-[0-9a-f]{8}$/;
 const LEGACY_STEM_TIME = /-(\d+)$/;
-let fsx = fs;
-/** Test-only seam, so a test can make one fs call fail; null restores the real fs. */
-export function _setSpoolFsForTests(next) {
-    fsx = next ?? fs;
-}
 const stamp = (ms) => String(Math.trunc(ms)).padStart(STAMP_DIGITS, '0');
 const isTime = (value) => typeof value === 'number' && Number.isFinite(value);
 const idle = new Int32Array(new SharedArrayBuffer(4));
 function errCode(cause) {
     return cause instanceof Error && 'code' in cause && isStringValue(cause.code) ? cause.code : '';
 }
-/** Runs one fs step, retrying a busy code briefly; '' when it ran, else the busy code it kept hitting. Any other error throws. */
+/**
+ * Runs one fs step, retrying a busy code briefly; '' when it ran, else the busy code it kept hitting. Any other error
+ * throws.
+ */
 function retryBusy(step) {
     for (let retry = 0;; retry++) {
         try {
@@ -57,7 +57,10 @@ function retryBusy(step) {
         }
     }
 }
-/** Runs one fs step: ENOENT means gone, a busy code is retried briefly, and any other error is logged and counted busy, so a replay never throws. */
+/**
+ * Runs one fs step: ENOENT means gone, a busy code is retried briefly, and any other error is logged and counted busy,
+ * so a replay never throws.
+ */
 function settleCode(step, log, what) {
     try {
         const code = retryBusy(step);
@@ -99,7 +102,7 @@ function claimOf(name) {
 function spoolFile(hippoRoot) {
     return path.join(hippoRoot, SPOOL_DIR, `${stamp(Date.now())}-${randomBytes(4).toString('hex')}.a0.json`);
 }
-export function spool(hippoRoot, tenantId, payload, text, at) {
+export function spool(hippoRoot, tenantId, payload, text, at, fsx = fs) {
     const file = spoolFile(hippoRoot);
     fsx.mkdirSync(path.dirname(file), { recursive: true });
     const body = {
@@ -126,8 +129,13 @@ export function parseSpooled(text, fallbackTenantId) {
     catch {
         return null; // a half-written spool file holds no compaction; the caller treats null as unreadable
     }
-    if (!isObjectLike(raw) || !('sessionId' in raw) || !isStringValue(raw.sessionId) || !('summary' in raw) || !isStringValue(raw.summary))
+    if (!isObjectLike(raw) ||
+        !('sessionId' in raw) ||
+        !isStringValue(raw.sessionId) ||
+        !('summary' in raw) ||
+        !isStringValue(raw.summary)) {
         return null;
+    }
     if (!('at' in raw) || !isStringValue(raw.at) || Number.isNaN(Date.parse(raw.at)))
         return null;
     const items = 'items' in raw && Array.isArray(raw.items) ? raw.items.filter(isStringValue) : [];
@@ -160,7 +168,7 @@ function parseLock(text) {
     return { pid, at: raw.at, token };
 }
 /** The lock's body; its mtime stands in for the time when the body does not parse. */
-function readLock(lock, log) {
+function readLock(fsx, lock, log) {
     let text = '';
     const read = settle(() => { text = fsx.readFileSync(lock, 'utf8'); }, log, 'spool lock not read');
     if (read !== 'done')
@@ -172,7 +180,7 @@ function readLock(lock, log) {
     const stat = settle(() => { mtime = fsx.statSync(lock).mtimeMs; }, log, 'spool lock not read');
     return stat === 'done' ? { pid: null, at: mtime, token: null } : stat;
 }
-function createLock(lock, body, log) {
+function createLock(fsx, lock, body, log) {
     try {
         fsx.writeFileSync(lock, body, { encoding: 'utf8', flag: 'wx' });
         return 'taken';
@@ -187,19 +195,22 @@ function createLock(lock, body, log) {
         return 'skip';
     }
 }
-/** This run's token and take time once it holds `replay.lock`, else null: another replayer holds it, or it could not be made. */
-function takeLock(dir, log) {
+/**
+ * This run's token and take time once it holds `replay.lock`, else null: another replayer holds it, or it could not be
+ * made.
+ */
+function takeLock(fsx, dir, log) {
     const lock = path.join(dir, LOCK);
     const token = randomBytes(8).toString('hex');
     const at = Date.now();
     const body = JSON.stringify({ pid: process.pid, at, token });
     for (let tries = 0; tries < 2; tries++) {
-        const made = createLock(lock, body, log);
+        const made = createLock(fsx, lock, body, log);
         if (made === 'taken')
             return { token, at };
         if (made === 'skip')
             break;
-        const held = readLock(lock, log);
+        const held = readLock(fsx, lock, log);
         if (held === 'gone')
             continue;
         if (held === 'busy')
@@ -216,24 +227,29 @@ function takeLock(dir, log) {
     return null;
 }
 /** False, after saying so, once `replay.lock` no longer holds this run's token or cannot be read. */
-function ownsLock(dir, token, log) {
-    const held = readLock(path.join(dir, LOCK), log);
+function ownsLock(fsx, dir, token, log) {
+    const held = readLock(fsx, path.join(dir, LOCK), log);
     if (held !== 'gone' && held !== 'busy' && held.token === token)
         return true;
     log(held === 'busy' ? 'spool lock could not be read, stopping' : 'spool left to another replayer (lock taken over)');
     return false;
 }
-/** Removes `replay.lock` only while it holds this run's token, so a run never deletes a successor's lock. Never throws. */
-function releaseLock(dir, mine, log) {
+/**
+ * Removes `replay.lock` only while it holds this run's token, so a run never deletes a successor's lock. Never throws.
+ */
+function releaseLock(fsx, dir, mine, log) {
     const lock = path.join(dir, LOCK);
-    const held = readLock(lock, log);
+    const held = readLock(fsx, lock, log);
     // A takeover needs a lock over STALE_MS old, so a busy read of one this run took more recently is still this run's.
     const ours = held === 'busy' ? Date.now() - mine.at < STALE_MS : held !== 'gone' && held.token === mine.token;
     if (ours)
         settle(() => fsx.unlinkSync(lock), log, 'spool lock not released');
 }
-/** Claim time sits in the claim's name, so a claim over STALE_MS away from now belongs to a replayer that never finished. True when one was put back. */
-function recoverStaleClaims(dir, names, log) {
+/**
+ * Claim time sits in the claim's name, so a claim over STALE_MS away from now belongs to a replayer that never
+ * finished. True when one was put back.
+ */
+function recoverStaleClaims(fsx, dir, names, log) {
     const now = Date.now();
     // A claim whose unlink stayed busy after its `.bad` landed is a spare copy, not a second failure.
     const setAside = new Set(names.flatMap((name) => BAD.exec(name)?.[1] ?? []));
@@ -252,25 +268,27 @@ function recoverStaleClaims(dir, names, log) {
         }
         else if (next < MAX_ATTEMPTS) {
             if (settle(() => fsx.renameSync(file, path.join(dir, `${claim.stem}.a${next}.json`)), log, what) === 'done') {
-                log(`spool file ${claim.name} was claimed by a replayer that never finished, put back (try ${next} of ${MAX_ATTEMPTS})`);
+                log(`spool file ${claim.name} was claimed by a replayer that never finished, put back (try ${next} of ` +
+                    `${MAX_ATTEMPTS})`);
                 putBackOne = true;
             }
         }
-        else if (moveBad(dir, file, { stem: claim.stem, attempt: claim.attempt, cause: 'interrupted', log })) {
-            log(`spool file ${claim.name} was claimed by a replayer that never finished ${MAX_ATTEMPTS} times, set aside as .bad`);
+        else if (moveBad(fsx, dir, file, { stem: claim.stem, attempt: claim.attempt, cause: 'interrupted', log })) {
+            log(`spool file ${claim.name} was claimed by a replayer that never finished ${MAX_ATTEMPTS} times, set aside as ` +
+                `.bad`);
         }
     }
     return putBackOne;
 }
 /** Returns a claim to the waiting files as `<stem>.a<attempt>.json`; one that stays busy is left for stale recovery. */
-function putBack(dir, claim, stem, attempt, log) {
+function putBack(fsx, dir, claim, stem, attempt, log) {
     const name = path.basename(claim);
     if (settle(() => fsx.renameSync(claim, path.join(dir, `${stem}.a${attempt}.json`)), log, `spool file ${name} not put back`) === 'busy') {
         log(`spool file ${name} could not be put back; it returns ${STALE_MS / MINUTE_MS} minutes after its claim`);
     }
 }
 /** Writes `<stem>.<cause>.bad` through a random temp file, so the rename replaces any torn `.bad` a crash left. */
-function writeBad(dir, options) {
+function writeBad(fsx, dir, options) {
     const { stem, cause, text, log, what } = options;
     const tmp = path.join(dir, `${stem}.${cause}.bad.${randomBytes(4).toString('hex')}.tmp`);
     const written = settle(() => fsx.writeFileSync(tmp, text, { encoding: 'utf8', flag: 'wx' }), log, what);
@@ -279,22 +297,32 @@ function writeBad(dir, options) {
         settle(() => fsx.unlinkSync(tmp), log, what);
     return moved === 'done';
 }
-/** Sets a claim aside as `.bad` before the claim goes, so a crash between leaves a whole copy; a busy write puts the claim back. */
-function moveBad(dir, claim, options) {
+/**
+ * Sets a claim aside as `.bad` before the claim goes, so a crash between leaves a whole copy; a busy write puts the
+ * claim back.
+ */
+function moveBad(fsx, dir, claim, options) {
     const { stem, attempt, cause, log, raw } = options;
     const what = `spool file ${path.basename(claim)} not set aside`;
     let text = raw ?? '';
-    if (raw === undefined && settle(() => { text = fsx.readFileSync(claim, 'utf8'); }, log, what) !== 'done')
+    if (raw === undefined &&
+        settle(() => {
+            text = fsx.readFileSync(claim, 'utf8');
+        }, log, what) !== 'done') {
         return false;
-    if (!writeBad(dir, { stem, cause, text, log, what })) {
-        putBack(dir, claim, stem, attempt, log);
+    }
+    if (!writeBad(fsx, dir, { stem, cause, text, log, what })) {
+        putBack(fsx, dir, claim, stem, attempt, log);
         return false;
     }
     settle(() => fsx.unlinkSync(claim), log, what);
     return true;
 }
-/** A tmp over STALE_MS old belongs to a spool that never renamed it: a whole one joins the waiting files, a torn one is set aside. True when one joined. */
-function promoteTmp(dir, names, tenantId, log) {
+/**
+ * A tmp over STALE_MS old belongs to a spool that never renamed it: a whole one joins the waiting files, a torn one is
+ * set aside. True when one joined.
+ */
+function promoteTmp(fsx, dir, names, tenantId, log) {
     const now = Date.now();
     let promoted = false;
     for (const name of names) {
@@ -305,8 +333,12 @@ function promoteTmp(dir, names, tenantId, log) {
         const what = `spool file ${name} not promoted`;
         let mtime = 0;
         let text = '';
-        if (settle(() => { mtime = fsx.statSync(file).mtimeMs; }, log, what) !== 'done' || Math.abs(now - mtime) <= STALE_MS)
+        if (settle(() => {
+            mtime = fsx.statSync(file).mtimeMs;
+        }, log, what) !== 'done' ||
+            Math.abs(now - mtime) <= STALE_MS) {
             continue;
+        }
         if (m === null) {
             // A `.bad` write cut off before its rename: its source goes only after that rename lands, so this copy is spare.
             settle(() => fsx.unlinkSync(file), log, `spool file ${name} not removed`);
@@ -320,7 +352,7 @@ function promoteTmp(dir, names, tenantId, log) {
                 promoted = true;
             }
         }
-        else if (writeBad(dir, { stem: m[1], cause: 'unreadable', text, log, what })) {
+        else if (writeBad(fsx, dir, { stem: m[1], cause: 'unreadable', text, log, what })) {
             settle(() => fsx.unlinkSync(file), log, what);
             log(`spool file ${name} was never finished, set aside as .bad`);
         }
@@ -328,13 +360,17 @@ function promoteTmp(dir, names, tenantId, log) {
     return promoted;
 }
 /** Removes a claim once the store holds its summary; a claim left behind is imported again, so the log says so. */
-function removeClaim(claim, name, log) {
+function removeClaim(fsx, claim, name, log) {
     const removed = settleCode(() => fsx.unlinkSync(claim), log, `spool file ${name} claim not removed`);
-    if (removed.settled === 'busy')
+    if (removed.settled === 'busy') {
         log(`spool file ${name} saved; its claim could not be removed (${removed.code}); it will be imported again`);
+    }
 }
-/** After an importer throw: a busy store stops the run with the count unchanged, any other error counts one try toward .bad. */
-function importFailed(dir, claim, entry, options) {
+/**
+ * After an importer throw: a busy store stops the run with the count unchanged, any other error counts one try toward
+ * .bad.
+ */
+function importFailed(fsx, dir, claim, entry, options) {
     const { text, recorded, cause, log } = options;
     const { name } = entry;
     const busy = isSqliteBusy(cause);
@@ -346,22 +382,22 @@ function importFailed(dir, claim, entry, options) {
         return busy ? 'stop' : 'skipped';
     }
     if (busy) {
-        putBack(dir, claim, entry.stem, entry.attempt, log);
+        putBack(fsx, dir, claim, entry.stem, entry.attempt, log);
         log(`spool file ${name} waits for the next run: the store is busy`);
         return 'stop';
     }
     const next = entry.attempt + 1;
     if (next < MAX_ATTEMPTS) {
-        putBack(dir, claim, entry.stem, next, log);
+        putBack(fsx, dir, claim, entry.stem, next, log);
         log(`spool file ${name} failed to import (try ${next} of ${MAX_ATTEMPTS}): ${errorMessage(cause)}`);
     }
-    else if (moveBad(dir, claim, { stem: entry.stem, attempt: entry.attempt, cause: 'failed', log, raw: text })) {
+    else if (moveBad(fsx, dir, claim, { stem: entry.stem, attempt: entry.attempt, cause: 'failed', log, raw: text })) {
         log(`spool file ${name} set aside as .bad after ${MAX_ATTEMPTS} tries: ${errorMessage(cause)}`);
     }
     return 'skipped';
 }
 /** Claims, reads and imports one waiting file; `stop` ends the run because the store is busy. */
-function importFile(dir, entry, tenantId, log, importOne) {
+function importFile(fsx, dir, entry, tenantId, log, importOne) {
     const { name } = entry;
     const claim = path.join(dir, `${entry.stem}.a${entry.attempt}.claim-${stamp(Date.now())}`);
     const taken = settleCode(() => fsx.renameSync(path.join(dir, name), claim), log, `spool file ${name} not claimed`);
@@ -374,12 +410,12 @@ function importFile(dir, entry, tenantId, log, importOne) {
     if (read === 'gone')
         log(`spool file ${name} vanished`);
     if (read === 'busy')
-        putBack(dir, claim, entry.stem, entry.attempt, log);
+        putBack(fsx, dir, claim, entry.stem, entry.attempt, log);
     if (read !== 'done')
         return 'skipped';
     const spooled = parseSpooled(text, tenantId);
     if (spooled === null) {
-        if (moveBad(dir, claim, { stem: entry.stem, attempt: entry.attempt, cause: 'unreadable', log, raw: text })) {
+        if (moveBad(fsx, dir, claim, { stem: entry.stem, attempt: entry.attempt, cause: 'unreadable', log, raw: text })) {
             log(`spool file ${name} is not readable, set aside as .bad`);
         }
         return 'skipped';
@@ -389,7 +425,7 @@ function importFile(dir, entry, tenantId, log, importOne) {
         if (recorded)
             return;
         recorded = true;
-        removeClaim(claim, name, log);
+        removeClaim(fsx, claim, name, log);
     };
     try {
         importOne(spooled, markRecorded);
@@ -397,10 +433,10 @@ function importFile(dir, entry, tenantId, log, importOne) {
         return 'imported';
     }
     catch (err) {
-        return importFailed(dir, claim, entry, { text, recorded, cause: err, log });
+        return importFailed(fsx, dir, claim, entry, { text, recorded, cause: err, log });
     }
 }
-function mtimeOf(file) {
+function mtimeOf(fsx, file) {
     try {
         return fsx.statSync(file).mtimeMs;
     }
@@ -412,8 +448,11 @@ function mtimeOf(file) {
         throw err;
     }
 }
-/** What doctor reports, read only: files a replay should have taken by now, claims and tmp files a dead process left, and `.bad` files. */
-export function spoolCounts(hippoRoot, now, waitingAfterMs) {
+/**
+ * What doctor reports, read only: files a replay should have taken by now, claims and tmp files a dead process left,
+ * and `.bad` files.
+ */
+export function spoolCounts(hippoRoot, now, waitingAfterMs, fsx = fs) {
     const counts = { waiting: 0, stale: 0, bad: 0 };
     const dir = path.join(hippoRoot, SPOOL_DIR);
     if (!fsx.existsSync(dir))
@@ -426,38 +465,41 @@ export function spoolCounts(hippoRoot, now, waitingAfterMs) {
         if (name.endsWith('.bad'))
             counts.bad++;
         else if (waiting !== null) {
-            const spooled = NEW_STEM.test(waiting[1]) ? created(waiting[1]) : mtimeOf(file);
+            const spooled = NEW_STEM.test(waiting[1]) ? created(waiting[1]) : mtimeOf(fsx, file);
             if (spooled !== null && at - spooled > waitingAfterMs)
                 counts.waiting++;
         }
         else if (claim !== null || TMP.test(name)) {
-            const since = claim?.claimedAt ?? mtimeOf(file);
+            const since = claim?.claimedAt ?? mtimeOf(fsx, file);
             if (since !== null && Math.abs(at - since) > STALE_MS)
                 counts.stale++;
         }
     }
     return counts;
 }
-/** One replayer at a time holds `replay.lock`, so only one process claims a file even where Windows lets two renames of it both land. */
-export function importSpool(hippoRoot, tenantId, log, deadline, importOne) {
+/**
+ * One replayer at a time holds `replay.lock`, so only one process claims a file even where Windows lets two renames of
+ * it both land.
+ */
+export function importSpool(hippoRoot, tenantId, log, deadline, importOne, fsx = fs) {
     const dir = path.join(hippoRoot, SPOOL_DIR);
     if (!fsx.existsSync(dir))
         return 0;
-    const mine = takeLock(dir, log);
+    const mine = takeLock(fsx, dir, log);
     if (mine === null)
         return 0;
     try {
-        if (!ownsLock(dir, mine.token, log))
+        if (!ownsLock(fsx, dir, mine.token, log))
             return 0;
         const names = fsx.readdirSync(dir);
-        const promoted = promoteTmp(dir, names, tenantId, log);
-        const recovered = recoverStaleClaims(dir, names, log);
+        const promoted = promoteTmp(fsx, dir, names, tenantId, log);
+        const recovered = recoverStaleClaims(fsx, dir, names, log);
         let finished = 0;
         // Only promotion and recovery add waiting names, so the folder is listed again only after one of them did.
         for (const entry of waitingFiles(promoted || recovered ? fsx.readdirSync(dir) : names)) {
-            if (Date.now() > deadline || !ownsLock(dir, mine.token, log))
+            if (Date.now() > deadline || !ownsLock(fsx, dir, mine.token, log))
                 break;
-            const outcome = importFile(dir, entry, tenantId, log, importOne);
+            const outcome = importFile(fsx, dir, entry, tenantId, log, importOne);
             if (outcome === 'imported')
                 finished++;
             if (outcome === 'stop')
@@ -466,7 +508,7 @@ export function importSpool(hippoRoot, tenantId, log, deadline, importOne) {
         return finished;
     }
     finally {
-        releaseLock(dir, mine, log);
+        releaseLock(fsx, dir, mine, log);
     }
 }
 //# sourceMappingURL=compaction-spool.js.map

package/dist/capture/copilot-transcript.d.ts

@@ -9,11 +9,19 @@ export interface CopilotTurn {
     text: string;
 }
 export declare const SESSION_ID_RE: RegExp;
-/** The Copilot CLI log for a session, `<copilotHome>/session-state/<id>/events.jsonl`; null for an unsafe id or a missing file. */
+/**
+ * The Copilot CLI log for a session, `<copilotHome>/session-state/<id>/events.jsonl`; null for an unsafe id or a
+ * missing file.
+ */
 export declare function copilotTranscriptFor(sessionId: string): string | null;
-/** True for VS Code's own chat log, `<workspaceStorage>/<id>/github.copilot-chat/transcripts/<session id>.jsonl`, in either slash and any case. */
+/**
+ * True for VS Code's own chat log, `<workspaceStorage>/<id>/github.copilot-chat/transcripts/<session id>.jsonl`, in
+ * either slash and any case.
+ */
 export declare function isVscodeTranscript(file: string | null): boolean;
-/** The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for any other line, a
+/**
+ * The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for
+ * any other line, a
  * sub-agent's included. */
 export declare function copilotTurn(line: CopilotEventLine): CopilotTurn | null;
 //# sourceMappingURL=copilot-transcript.d.ts.map

package/dist/capture/copilot-transcript.js

@@ -1,4 +1,5 @@
-// The Copilot event log: one `{type, data, id, timestamp, parentId}` object per line, written by the Copilot CLI and VS Code Local alike.
+// The Copilot event log: one `{type, data, id, timestamp, parentId}` object per line, written by the Copilot CLI and VS
+// Code Local alike.
 // Matched line by line, since the tail readers start mid-file and never see the session.start line.
 import * as fs from 'fs';
 import * as path from 'path';
@@ -6,21 +7,28 @@ import { copilotHomeDir } from '../hooks/shared.js';
 import { isObjectLike, isStringValue } from '../core/capture-contract.js';
 // A session id becomes a folder name, so anything beyond word characters and hyphens could climb out of session-state.
 export const SESSION_ID_RE = /^[\w-]+$/;
-// user.message sources that mark text hippo did not get from the human: a hidden skill injection or another agent's prompt.
+// user.message sources that mark text hippo did not get from the human: a hidden skill injection or another agent's
+// prompt.
 const INJECTED_SOURCE_PREFIXES = ['skill-', 'agent-'];
-/** The Copilot CLI log for a session, `<copilotHome>/session-state/<id>/events.jsonl`; null for an unsafe id or a missing file. */
+/**
+ * The Copilot CLI log for a session, `<copilotHome>/session-state/<id>/events.jsonl`; null for an unsafe id or a
+ * missing file.
+ */
 export function copilotTranscriptFor(sessionId) {
     if (!SESSION_ID_RE.test(sessionId))
         return null;
     const file = path.join(copilotHomeDir(), 'session-state', sessionId, 'events.jsonl');
     return fs.existsSync(file) ? file : null;
 }
-/** True for VS Code's own chat log, `<workspaceStorage>/<id>/github.copilot-chat/transcripts/<session id>.jsonl`, in either slash and any case. */
+/**
+ * True for VS Code's own chat log, `<workspaceStorage>/<id>/github.copilot-chat/transcripts/<session id>.jsonl`, in
+ * either slash and any case.
+ */
 export function isVscodeTranscript(file) {
     if (!file)
         return false;
     const parts = file.toLowerCase().split(/[\\/]/);
-    return parts.length >= 3 && parts[parts.length - 2] === 'transcripts' && parts[parts.length - 3] === 'github.copilot-chat';
+    return (parts.length >= 3 && parts[parts.length - 2] === 'transcripts' && parts[parts.length - 3] === 'github.copilot-chat');
 }
 function isSubagentLine(line, data) {
     if (isStringValue(line.agentId) && line.agentId !== '')
@@ -33,7 +41,9 @@ function isInjectedUserMessage(data) {
     const source = data.source;
     return isStringValue(source) && INJECTED_SOURCE_PREFIXES.some((prefix) => source.startsWith(prefix));
 }
-/** The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for any other line, a
+/**
+ * The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for
+ * any other line, a
  * sub-agent's included. */
 export function copilotTurn(line) {
     const role = line.type === 'user.message' ? 'user' : line.type === 'assistant.message' ? 'assistant' : null;

package/dist/capture/extract.js

@@ -31,7 +31,8 @@ const BULLET = /^(?:[-*]|\d+\.)\s+(?:\[[ xX]\]\s+)?(.+)/;
 const LABEL = /^(?:decision|rule|error|bug|gotcha|important|critical|remember|plan):/i;
 const SENTENCE_END = /[.!?]["')\]]*$/;
 const SPEC_HEADING_PATTERNS = [
-    /^#+\s*(?:features?|requirements?|specs?|specifications?|plan|design|architecture|interface|api|todo|tasks?|implementation|notes?)(?:\s|:|$)/i,
+    new RegExp(String.raw `^#+\s*(?:features?|requirements?|specs?|specifications?|plan|design|architecture|interface|api|todo|` +
+        String.raw `tasks?|implementation|notes?)(?:\s|:|$)`, 'i'),
     /^(?:features?|requirements?|specs?|specifications?|plan|design|tasks?|implementation)(?:\s*:|$)/i,
 ];
 // A list item may open a fence on its own line: "- ```".
@@ -43,7 +44,9 @@ const NO_BREAK = /(`+)[^`\n]+\1|\b(?:[Ee]\.g|[Ii]\.e|[Vv]s|[Cc]f)\.|\betc\.(?=\s
 function proseOnly(text) {
     let fence = null;
     let afterProse = false;
-    return text.split('\n').map(line => {
+    return text
+        .split('\n')
+        .map((line) => {
         const trimmed = line.trimStart();
         if (fence !== null) {
             const close = trimmed.match(FENCE_CLOSE);
@@ -58,16 +61,21 @@ function proseOnly(text) {
             afterProse = false;
             return '';
         }
-        // Quotes, table rows and indented code are not the speaker's own; indented code cannot interrupt a paragraph or list item.
+        // Quotes, table rows and indented code are not the speaker's
+        // own; indented code cannot interrupt a paragraph or list item.
         const dropped = /^\s*[>|]/.test(line) || (!afterProse && /^(?: {4}|\t)(?!\s*(?:[-*]|\d+\.)\s)/.test(line));
         afterProse = !dropped && trimmed !== '' && !/^#{1,6}(?:\s|$)/.test(trimmed);
         return dropped ? '' : line;
-    }).join('\n');
+    })
+        .join('\n');
 }
 function masked(text) {
     return text.replace(NO_BREAK, span => 'x'.repeat(span.length));
 }
-/** A lowercase line continues the line above only when that line has not ended its sentence; "e.g." at a line end has not. */
+/**
+ * A lowercase line continues the line above only when that line
+ * has not ended its sentence; "e.g." at a line end has not.
+ */
 function continues(line, previous) {
     if (previous === undefined || !/^[a-z]/.test(line) || LABEL.test(line))
         return false;
@@ -110,8 +118,10 @@ function extractFromPatterns(sentence, patterns, category) {
     if (!keyed)
         return null;
     const content = sentence
-        .replace(/^(?:decision|plan|rule|important|critical|remember|error|bug|gotcha|watch out|careful|warning|caveat|trap|don't forget|easy to miss):\s*/i, '')
-        .replace(/[.!?\s]+$/, '').trim();
+        .replace(new RegExp(String.raw `^(?:decision|plan|rule|important|critical|remember|error|bug|gotcha|watch out|careful|warning|` +
+        String.raw `caveat|trap|don't forget|easy to miss):\s*`, 'i'), '')
+        .replace(/[.!?\s]+$/, '')
+        .trim();
     return content.length <= MAX_CHARS ? { content, category, tags: [category, 'captured'] } : null;
 }
 function extractSpecSections(text) {
@@ -162,7 +172,9 @@ function extractOne(text) {
  *  The first `userTexts` texts are a person's own words; on a repeat their copy wins, so it keeps `fromUser`. */
 export function extractFromTexts(texts, userTexts = 0) {
     const seen = new Set();
-    return texts.flatMap((text, i) => extractOne(text).map((item) => (i < userTexts ? { ...item, fromUser: true } : item))).filter((item) => {
+    return texts
+        .flatMap((text, i) => extractOne(text).map((item) => (i < userTexts ? { ...item, fromUser: true } : item)))
+        .filter((item) => {
         const key = duplicateKey(item.content);
         if (seen.has(key) || !assessAutomaticMemory(item.content).accepted)
             return false;

package/dist/capture/failure-caller.js

@@ -1,14 +1,18 @@
-// PostToolUseFailure for a caller on another machine: the lesson and its log row carry the caller's owner and project, and a retried
-// request id gets the first answer.
+// PostToolUseFailure for a caller on another machine: the lesson and its log row carry the caller's owner and
+// project, and a retried request id gets the first answer.
 import { BadRequestError } from '../core/api-errors.js';
 import { storeLesson } from './capture-error.js';
 import { recordFailureAt, requestOutcomeAt, settleFailureOutcomeAt } from '../store/failure-log-at.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 import { scrubForSharing } from './share-scrub.js';
 import { truncateCodePointSafe } from '../util/transcript-tail.js';
 import { assertRequestId, bindCaller } from './caller-session.js';
 import { FAILURE_TEXT_MAX_CHARS, failureHash } from './failure-reading.js';
-const SKIPS = { 'skipped-interrupt': true, 'skipped-routine': true, 'skipped-invalid': true };
+const SKIPS = {
+    'skipped-interrupt': true,
+    'skipped-routine': true,
+    'skipped-invalid': true,
+};
 const ROUTINE_RULES = {
     declined: true,
     'os-permission': true,
@@ -16,26 +20,32 @@ const ROUTINE_RULES = {
     'search-tool': true,
     'quiet-exit': true,
 };
-/** The shapes lessonFromFailure gives: text for a lesson or a routine skip, none for an interrupt or an unreadable payload, a rule only on a routine skip. */
+/** The shapes lessonFromFailure gives: text for a lesson or a routine skip, none for an interrupt or an unreadable
+ *  payload, a rule only on a routine skip. */
 function checkedFailure(req) {
     assertRequestId(req.requestId);
-    if (req.detailHash !== null && !/^[0-9a-f]{16}$/.test(req.detailHash))
+    if (req.detailHash !== null && !/^[0-9a-f]{16}$/.test(req.detailHash)) {
         throw new BadRequestError('detail hash: 16 lowercase hex characters or null');
+    }
     const { skip, text, rule } = req;
-    if (skip !== null && !Object.hasOwn(SKIPS, skip))
+    if (skip !== null && !Object.hasOwn(SKIPS, skip)) {
         throw new BadRequestError('skip: skipped-interrupt, skipped-routine, skipped-invalid or null');
+    }
     if ((skip === 'skipped-routine') !== (rule !== null) || (rule !== null && !Object.hasOwn(ROUTINE_RULES, rule))) {
         throw new BadRequestError('rule: a routine rule on skipped-routine, else null');
     }
     if (text === null || text.trim() === '') {
-        if (skip === null || skip === 'skipped-routine')
+        if (skip === null || skip === 'skipped-routine') {
             throw new BadRequestError('text: required for a lesson or a routine skip');
+        }
         return { skip, text: null };
     }
-    if (skip === 'skipped-interrupt' || skip === 'skipped-invalid')
+    if (skip === 'skipped-interrupt' || skip === 'skipped-invalid') {
         throw new BadRequestError('text: null for an interrupt or an unreadable failure');
-    if (text.length > FAILURE_TEXT_MAX_CHARS)
+    }
+    if (text.length > FAILURE_TEXT_MAX_CHARS) {
         throw new BadRequestError(`text: at most ${FAILURE_TEXT_MAX_CHARS} characters`);
+    }
     // Scrubbed again, as the caller's scrub is not trusted, and cut after it, as a mask can be longer than what it hides.
     return { skip, text: truncateCodePointSafe(scrubForSharing(text), FAILURE_TEXT_MAX_CHARS) };
 }
@@ -43,7 +53,8 @@ export function captureFailureForCaller(ctx, req) {
     const failure = checkedFailure(req);
     const key = bindCaller(ctx, req.sessionId, req.project);
     const earlier = requestOutcomeAt(ctx.hippoRoot, ctx.tenantId, req.requestId, req.sessionId);
-    // A retry after a lost reply gets the first answer and writes nothing; one whose store failed tries the store again.
+    // A retry after a lost reply gets the first answer and writes
+    // nothing; one whose store failed tries the store again.
     if (earlier !== null && earlier !== 'store-failed')
         return { outcome: earlier };
     let logged = 'store-failed';
@@ -73,7 +84,7 @@ function logOutcome(ctx, req, key, outcome, retried) {
         });
     }
     catch (err) {
-        log.warn(`capture-error: failure not logged: ${errorMessage(err)}`);
+        log.warn(`capture-error: failure not logged: ${errorMessage(err)}`, errorFields(err));
     }
 }
 //# sourceMappingURL=failure-caller.js.map