hippo-memory 2.0.0 → 2.1.0

package/dist/capture/compaction-items-caller.js

@@ -1,4 +1,5 @@
-// PostCompact for a caller on another machine: the items it parsed become rows under its owner and project, and a retried request id writes nothing twice.
+// PostCompact for a caller on another machine: the items it parsed become rows under its owner and project, and a
+// retried request id writes nothing twice.
 import { BadRequestError } from '../core/api-errors.js';
 import { COMPACTION_ITEM_MAX_CHARS } from '../util/compaction-items.js';
 import { saveCallerItems } from '../store/compaction-caller.js';
@@ -17,8 +18,13 @@ export function saveCompactionItemsForCaller(ctx, req) {
     if (callerInHoldout(ctx, req.sessionId))
         return { written: 0 };
     const written = saveCallerItems(ctx.hippoRoot, ctx.tenantId, {
-        sessionId: req.sessionId, trigger: req.trigger, requestId: req.requestId, project: req.project.name, items: scrubCompactionItems(req.items),
-        owner: key.owner, origins: key.project,
+        sessionId: req.sessionId,
+        trigger: req.trigger,
+        requestId: req.requestId,
+        project: req.project.name,
+        items: scrubCompactionItems(req.items),
+        owner: key.owner,
+        origins: key.project,
     }, (message) => log.info(`post-compact: ${message}`));
     return { written };
 }

package/dist/capture/compaction-record.d.ts

@@ -9,8 +9,8 @@ interface ScrubbedSummary {
 }
 /** What the record keeps of a compact_summary: the scrubbed body, and every parsed item scrubbed. */
 export declare function readCompactionText(compactSummary: string): ScrubbedSummary;
-/** A caller's items scrubbed as readCompactionText scrubs a summary's, since another machine's scrub is not trusted; cut after it, as a
- * mask can run longer than what it hides. */
+/** A caller's items scrubbed as readCompactionText scrubs a summary's, since another machine's scrub is not trusted;
+ * cut after it, as a mask can run longer than what it hides. */
 export declare function scrubCompactionItems(items: readonly string[]): string[];
 export interface PostCompactPayload {
     sessionId: string;
@@ -20,7 +20,8 @@ export interface PostCompactPayload {
     /** null when Claude Code sent none; the transcript fills the record later. */
     compactSummary: string | null;
 }
-/** The PostCompact work: record the summary, then write its items. Each step is independent; a busy store spools or defers. Never throws. */
+/** The PostCompact work: record the summary, then write its items. Each step is independent; a busy store spools or
+ * defers. Never throws. */
 export declare function saveCompaction(hippoRoot: string, payload: PostCompactPayload, log: Log): CompactionSaveResult;
 /** The one line PostCompact prints, or null when nothing was saved. */
 export declare function postCompactLine(result: CompactionSaveResult): string | null;

package/dist/capture/compaction-record.js

@@ -6,13 +6,14 @@ import { importSpool, spool } from './compaction-spool.js';
 import { replayStoredCompactions, saveCompactionAt, } from '../store/compactions-record.js';
 import { resolveTenantId } from '../store/tenant.js';
 import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
-import { errorMessage, reportCompactionFailure } from '../util/log.js';
+import { errorFields, errorMessage, reportCompactionFailure } from '../util/log.js';
 import { readTranscriptTail, truncateCodePointSafe } from '../util/transcript-tail.js';
 /** Tested verbatim: Claude Code hands PreCompact stdout to the summariser as instructions. */
-export const PRE_COMPACT_INSTRUCTION = "In your summary, add a last section titled 'Memories for hippo'. List, one per line starting with '- ', each lesson learned, decision made (with its " +
-    "reason) and correction the user gave in this session that should outlive it. Write each as a standalone sentence that names its subject. Leave out " +
-    "anything an earlier summary already listed under 'Memories for hippo', and anything this session already saved with `hippo remember`. Write '- none' " +
-    "if nothing new remains.";
+export const PRE_COMPACT_INSTRUCTION = "In your summary, add a last section titled 'Memories for hippo'. List, one per line starting with '- ', " +
+    "each lesson learned, decision made (with its reason) and correction the user gave in this session that " +
+    "should outlive it. Write each as a standalone sentence that names its subject. Leave out anything an " +
+    "earlier summary already listed under 'Memories for hippo', and anything this session already saved with " +
+    "`hippo remember`. Write '- none' if nothing new remains.";
 const SUMMARY_MAX_CHARS = 256 * 1024;
 const TRANSCRIPT_TAIL_CAPS = [1 << 20, 8 << 20, 64 << 20];
 function scrub(text) {
@@ -22,10 +23,14 @@ function scrub(text) {
 export function readCompactionText(compactSummary) {
     const body = compactSummaryBody(compactSummary);
     const parsed = parseCompactionItems(body);
-    return { summary: truncateCodePointSafe(scrub(body), SUMMARY_MAX_CHARS), items: parsed.items.map(scrub), found: parsed.found };
+    return {
+        summary: truncateCodePointSafe(scrub(body), SUMMARY_MAX_CHARS),
+        items: parsed.items.map(scrub),
+        found: parsed.found,
+    };
 }
-/** A caller's items scrubbed as readCompactionText scrubs a summary's, since another machine's scrub is not trusted; cut after it, as a
- * mask can run longer than what it hides. */
+/** A caller's items scrubbed as readCompactionText scrubs a summary's, since another machine's scrub is not trusted;
+ * cut after it, as a mask can run longer than what it hides. */
 export function scrubCompactionItems(items) {
     return items.map((item) => truncateCodePointSafe(scrub(item), COMPACTION_ITEM_MAX_CHARS));
 }
@@ -36,10 +41,11 @@ function spoolSummary(hippoRoot, payload, text, at, reason, result, log) {
         log(`store busy, summary spooled: ${reason}`);
     }
     catch (spoolErr) {
-        reportCompactionFailure(log, 'spool', errorMessage(spoolErr));
+        reportCompactionFailure(log, 'spool', errorMessage(spoolErr), errorFields(spoolErr));
     }
 }
-/** The PostCompact work: record the summary, then write its items. Each step is independent; a busy store spools or defers. Never throws. */
+/** The PostCompact work: record the summary, then write its items. Each step is independent; a busy store spools or
+ * defers. Never throws. */
 export function saveCompaction(hippoRoot, payload, log) {
     if (payload.compactSummary === null) {
         log('skip: payload has no compact_summary');
@@ -63,7 +69,8 @@ export function postCompactLine(result) {
     if (result.written === 0)
         return "Hippo kept this compaction's summary; it listed no new memories.";
     const noun = result.written === 1 ? 'memory' : 'memories';
-    return `Hippo saved ${result.written} ${noun} from this compaction${result.snapshotSaved ? ' and restored your task snapshot' : ''}.`;
+    const restored = result.snapshotSaved ? ' and restored your task snapshot' : '';
+    return `Hippo saved ${result.written} ${noun} from this compaction${restored}.`;
 }
 function lineText(line) {
     const content = line.message?.content;
@@ -73,7 +80,8 @@ function lineText(line) {
         return '';
     return content.map((block) => (isStringValue(block.text) ? block.text : '')).join('\n');
 }
-/** The summary Claude Code wrote into a transcript between two moments; null when it is not (yet) there or the window cannot reach back that far. */
+/** The summary Claude Code wrote into a transcript between two moments; null when it is not (yet) there or the window
+ * cannot reach back that far. */
 function transcriptSummary(transcriptPath, afterMs, beforeMs) {
     const size = fs.statSync(transcriptPath).size;
     for (const cap of TRANSCRIPT_TAIL_CAPS) {

package/dist/capture/compaction-spool.d.ts

@@ -1,7 +1,9 @@
 import type { CompactionText, Log } from '../store/compactions-record.js';
 import type { PostCompactPayload } from './compaction-record.js';
 export declare 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 declare const SPOOL_PROBLEM = "spool problem: ";
 /** Only the fs calls the spool makes, so a test can stand in for one of them. */
@@ -28,7 +30,10 @@ export interface SpooledCompaction {
     text: CompactionText;
     at: Date;
 }
-/** Records one spooled compaction; it calls `recorded` once the store holds the summary, so the file is done even if a later step throws. */
+/**
+ * Records one spooled compaction; it calls `recorded` once the store holds the summary, so the file is done even if a
+ * later step throws.
+ */
 export type SpoolImporter = (spooled: SpooledCompaction, recorded: () => void) => void;
 export declare function spool(hippoRoot: string, tenantId: string, payload: PostCompactPayload, text: CompactionText, at: Date, fsx?: SpoolFs): void;
 /** null when the text is not a spooled compaction. */
@@ -38,8 +43,14 @@ export interface SpoolCounts {
     stale: number;
     bad: number;
 }
-/** What doctor reports, read only: files a replay should have taken by now, claims and tmp files a dead process left, and `.bad` files. */
+/**
+ * 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 declare function spoolCounts(hippoRoot: string, now: Date, waitingAfterMs: number, fsx?: SpoolFs): SpoolCounts;
-/** 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. */
+/**
+ * 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 declare function importSpool(hippoRoot: string, tenantId: string, log: Log, deadline: number, importOne: SpoolImporter, fsx?: SpoolFs): number;
 //# sourceMappingURL=compaction-spool.d.ts.map

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';
@@ -35,7 +37,10 @@ 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 {
@@ -52,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);
@@ -121,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) : [];
@@ -182,7 +195,10 @@ function createLock(fsx, 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. */
+/**
+ * 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');
@@ -218,7 +234,9 @@ function ownsLock(fsx, dir, token, log) {
     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. */
+/**
+ * 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(fsx, lock, log);
@@ -227,7 +245,10 @@ function releaseLock(fsx, dir, mine, log) {
     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. */
+/**
+ * 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.
@@ -247,12 +268,14 @@ function recoverStaleClaims(fsx, 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(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`);
+            log(`spool file ${claim.name} was claimed by a replayer that never finished ${MAX_ATTEMPTS} times, set aside as ` +
+                `.bad`);
         }
     }
     return putBackOne;
@@ -274,13 +297,20 @@ function writeBad(fsx, 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. */
+/**
+ * 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(fsx, dir, { stem, cause, text, log, what })) {
         putBack(fsx, dir, claim, stem, attempt, log);
         return false;
@@ -288,7 +318,10 @@ function moveBad(fsx, dir, claim, options) {
     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. */
+/**
+ * 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;
@@ -300,8 +333,12 @@ function promoteTmp(fsx, 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`);
@@ -325,10 +362,14 @@ function promoteTmp(fsx, dir, names, tenantId, log) {
 /** Removes a claim once the store holds its summary; a claim left behind is imported again, so the log says so. */
 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. */
+/**
+ * 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;
@@ -407,7 +448,10 @@ function mtimeOf(fsx, 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. */
+/**
+ * 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);
@@ -433,7 +477,10 @@ export function spoolCounts(hippoRoot, now, waitingAfterMs, fsx = fs) {
     }
     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. */
+/**
+ * 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))

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

package/dist/capture/failure-reading.d.ts

@@ -1,6 +1,9 @@
 import { type JsonValue } from '../util/json.js';
 import type { CaptureErrorOutcome, RoutineRule } from '../store/failure-log.js';
-/** What {@link lessonFromFailure} read from a payload; `detail` is the finer failure-log key (untruncated, command head). */
+/**
+ * What {@link lessonFromFailure} read from a payload; `detail`
+ * is the finer failure-log key (untruncated, command head).
+ */
 export type FailureReading = {
     text: string;
     detail: string;
@@ -22,10 +25,14 @@ export declare function payloadString(payload: JsonValue, key: 'session_id' | 't
 export declare function failureSignature(text: string): string;
 /** The hash the failure log stores for a lesson text or a detail; one function so every writer counts repeats alike. */
 export declare function failureHash(text: string): string;
-/** The memory text for a failure payload, or why it is not stored; a routine skip keeps its text for the log. `scrub` runs before the
+/**
+ * The memory text for a failure payload, or why it is not stored; a routine skip keeps its text for the log. `scrub`
+ * runs before the
  * cap, as a mask can be longer than what it hides. Pure. */
 export declare function lessonFromFailure(payload: JsonValue, scrub?: (text: string) => string): FailureReading;
-/** A failure as it may leave the machine: the capped lesson text and the detail's hash, never the untruncated detail. */
+/**
+ * A failure as it may leave the machine: the capped lesson text and the detail's hash, never the untruncated detail.
+ */
 export interface FailureReport {
     /** The payload's tool name; null when it named none. */
     tool: string | null;