hippo-memory 2.0.0 → 2.1.0

package/dist/util/net.js

@@ -0,0 +1,19 @@
+// Two loopback rules for two inputs: a URL hostname and a socket's remote address.
+const IPV4_LOOPBACK = /^127(?:\.(?:25[0-5]|2[0-4]\d|1?\d?\d)){3}$/;
+const MAPPED_PREFIX = '::ffff:';
+/** A URL hostname that stays on this machine: localhost, ::1 (bracketed or not) or any 127.0.0.0/8 address. */
+export function isLoopbackHost(hostname) {
+    return hostname === 'localhost' || hostname === '[::1]' || hostname === '::1' || IPV4_LOOPBACK.test(hostname);
+}
+/** A socket remote address on this machine; Node reports a dual-stack IPv4 peer as '::ffff:127.x.x.x'. */
+export function isLoopbackAddress(remoteAddress) {
+    if (!remoteAddress)
+        return false;
+    if (remoteAddress === '::1')
+        return true;
+    const plain = remoteAddress.toLowerCase().startsWith(MAPPED_PREFIX)
+        ? remoteAddress.slice(MAPPED_PREFIX.length)
+        : remoteAddress;
+    return IPV4_LOOPBACK.test(plain);
+}
+//# sourceMappingURL=net.js.map

package/dist/util/real-path.d.ts

@@ -1,3 +1,4 @@
-/** Dereferences symlinks and junctions and normalises case on Windows; falls back to path.resolve when the path does not exist yet. */
+/** Dereferences symlinks and junctions and normalises case on Windows; falls back to path.resolve when the path does
+ * not exist yet. */
 export declare function realpathOrResolve(p: string): string;
 //# sourceMappingURL=real-path.d.ts.map

package/dist/util/real-path.js

@@ -1,14 +1,15 @@
 // Leaf module: path canonicalisation shared by project identity and the importers.
 import * as fs from 'fs';
 import * as path from 'path';
-import { errorMessage, log } from './log.js';
-/** Dereferences symlinks and junctions and normalises case on Windows; falls back to path.resolve when the path does not exist yet. */
+import { errorMessage, log, errorFields } from './log.js';
+/** Dereferences symlinks and junctions and normalises case on Windows; falls back to path.resolve when the path does
+ * not exist yet. */
 export function realpathOrResolve(p) {
     try {
         return fs.realpathSync.native(p);
     }
     catch (err) {
-        log.debug(`realpath fell back to resolve for ${p}: ${errorMessage(err)}`);
+        log.debug(`realpath fell back to resolve for ${p}: ${errorMessage(err)}`, errorFields(err));
         return path.resolve(p);
     }
 }

package/dist/util/request-scope.d.ts

@@ -10,7 +10,10 @@ export interface RequestScope {
 }
 /** How long a request may run: 120 s, or HIPPO_REQUEST_DEADLINE_MS, where 0 turns the deadline off. */
 export declare function requestDeadlineMs(): number;
-/** When a request must be answered, and the store calls it still waits on: the store ends each of those soon after `at`, with the outcome only it knows. */
+/**
+ * When a request must be answered, and the store calls it still waits on: the store ends each of those soon after `at`,
+ * with the outcome only it knows.
+ */
 export declare class RequestDeadline {
     #private;
     /** Epoch milliseconds. */
@@ -18,7 +21,10 @@ export declare class RequestDeadline {
     constructor(at: number);
     /** Counts `call` as one the request waits on until it settles. */
     track<T>(call: Promise<T>): Promise<T>;
-    /** Runs `fn` now, or once the last store call the request waits on has settled; every function registered meanwhile runs, in order. */
+    /**
+     * Runs `fn` now, or once the last store call the request waits on has settled; every function registered meanwhile
+     * runs, in order.
+     */
     onceIdle(fn: () => void): void;
 }
 export declare const requestScopes: AsyncLocalStorage<RequestScope>;
@@ -29,6 +35,8 @@ export declare function currentDeadline(): RequestDeadline | undefined;
 /** The abort signal of the request this code runs for, if it has one. */
 export declare function currentSignal(): AbortSignal | undefined;
 /** Runs `fn` with `requestId` on every log line it writes, including the ones from
- * timers and promises it starts. `deadline` reaches every store call made inside, and `signal` every check of `currentSignal`. */
+ * timers and promises it starts. `deadline` reaches every store call made inside, and `signal` every check of
+ * `currentSignal`.
+ */
 export declare function runWithRequestId<T>(requestId: string, fn: () => T, deadline?: RequestDeadline, signal?: AbortSignal): T;
 //# sourceMappingURL=request-scope.d.ts.map

package/dist/util/request-scope.js

@@ -1,4 +1,5 @@
-// The one ambient scope of a request. A leaf module, so the logger can read the request id without importing the store layer.
+// The one ambient scope of a request. A leaf module, so the logger can read the request id without importing the store
+// layer.
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { envRequestDeadlineMs } from './env.js';
 const DEFAULT_REQUEST_DEADLINE_MS = 120_000;
@@ -6,7 +7,10 @@ const DEFAULT_REQUEST_DEADLINE_MS = 120_000;
 export function requestDeadlineMs() {
     return envRequestDeadlineMs() ?? DEFAULT_REQUEST_DEADLINE_MS;
 }
-/** When a request must be answered, and the store calls it still waits on: the store ends each of those soon after `at`, with the outcome only it knows. */
+/**
+ * When a request must be answered, and the store calls it still waits on: the store ends each of those soon after `at`,
+ * with the outcome only it knows.
+ */
 export class RequestDeadline {
     /** Epoch milliseconds. */
     at;
@@ -28,7 +32,10 @@ export class RequestDeadline {
         call.then(done, done);
         return call;
     }
-    /** Runs `fn` now, or once the last store call the request waits on has settled; every function registered meanwhile runs, in order. */
+    /**
+     * Runs `fn` now, or once the last store call the request waits on has settled; every function registered meanwhile
+     * runs, in order.
+     */
     onceIdle(fn) {
         if (this.#storeCalls === 0)
             fn();
@@ -50,7 +57,9 @@ export function currentSignal() {
     return requestScopes.getStore()?.signal;
 }
 /** Runs `fn` with `requestId` on every log line it writes, including the ones from
- * timers and promises it starts. `deadline` reaches every store call made inside, and `signal` every check of `currentSignal`. */
+ * timers and promises it starts. `deadline` reaches every store call made inside, and `signal` every check of
+ * `currentSignal`.
+ */
 export function runWithRequestId(requestId, fn, deadline, signal) {
     return requestScopes.run({ requestId, deadline, signal }, fn);
 }

package/dist/util/same-text.d.ts

@@ -6,14 +6,21 @@ type Text = Pick<MemoryEntry, 'content'> & {
 export declare function duplicateKey(text: string): string;
 /** A sleep-merged row's text: a header, a blank line, then each text as a "- " bullet with its later lines indented. */
 export declare function mergedText(header: string, texts: readonly string[]): string;
-/** Each source text a sleep-merged row holds; a two-row merge by an older release kept one text whole after its header. */
+/**
+ * Each source text a sleep-merged row holds; a two-row merge by an older release kept one text whole after its header.
+ */
 export declare function heldTexts(entry: Text): string[];
 /** Keys of every text a row holds word for word: its own, plus each source text inside a sleep-merged row. */
 export declare function heldTextKeys(entry: Text): string[];
-/** The longest word of a text: every row holding the text word for word contains it, so a store lookup can filter on it. */
+/**
+ * The longest word of a text: every row holding the text word for word contains it, so a store lookup can filter on it.
+ */
 export declare function longestWord(text: string): string;
 export declare function storedTextKeys(entries: readonly Text[]): Set<string>;
-/** A final result list without copies: drops each unpinned row a sleep-merged row in the list holds word for word, and each later unpinned copy of a text. */
+/**
+ * A final result list without copies: drops each unpinned row a sleep-merged row in the list holds word for word, and
+ * each later unpinned copy of a text.
+ */
 export declare function dropHeldCopies<T>(rows: readonly T[], textOf: (row: T) => Text): T[];
 export {};
 //# sourceMappingURL=same-text.d.ts.map

package/dist/util/same-text.js

@@ -5,7 +5,9 @@ export function duplicateKey(text) {
 export function mergedText(header, texts) {
     return `${header}\n\n${texts.map((t) => `- ${t.trim().replace(/\n/g, '\n  ')}`).join('\n')}`;
 }
-/** Each source text a sleep-merged row holds; a two-row merge by an older release kept one text whole after its header. */
+/**
+ * Each source text a sleep-merged row holds; a two-row merge by an older release kept one text whole after its header.
+ */
 export function heldTexts(entry) {
     const cut = entry.content.indexOf('\n\n');
     if (entry.source !== 'consolidation' || cut < 0)
@@ -19,14 +21,19 @@ export function heldTexts(entry) {
 export function heldTextKeys(entry) {
     return [duplicateKey(entry.content), ...heldTexts(entry).map(duplicateKey)];
 }
-/** The longest word of a text: every row holding the text word for word contains it, so a store lookup can filter on it. */
+/**
+ * The longest word of a text: every row holding the text word for word contains it, so a store lookup can filter on it.
+ */
 export function longestWord(text) {
     return duplicateKey(text).split(' ').reduce((best, w) => (w.length > best.length ? w : best), '');
 }
 export function storedTextKeys(entries) {
     return new Set(entries.flatMap(heldTextKeys));
 }
-/** A final result list without copies: drops each unpinned row a sleep-merged row in the list holds word for word, and each later unpinned copy of a text. */
+/**
+ * A final result list without copies: drops each unpinned row a sleep-merged row in the list holds word for word, and
+ * each later unpinned copy of a text.
+ */
 export function dropHeldCopies(rows, textOf) {
     const held = new Set(rows.flatMap((r) => heldTextKeys(textOf(r)).slice(1)));
     const seen = new Set();

package/dist/util/secret-detect.d.ts

@@ -1,5 +1,9 @@
-/** Secret detection for memory content: conservative provider-bounded patterns (a bare `sk-` in prose must not flag). Flagged rows are never shared to
- * the global store or injected as ambient context outside their project; explicit recall is unaffected. Leaf module: no imports from store/api/shared. */
+/**
+ * Secret detection for memory content: conservative provider-bounded patterns (a bare `sk-` in prose must not flag).
+ * Flagged rows are never shared to
+ * the global store or injected as ambient context outside their project; explicit recall is unaffected. Leaf module: no
+ * imports from store/api/shared.
+ */
 /** Result of scanning one memory. `reason` names the tag or pattern that fired. */
 export interface SecretDetection {
     flagged: boolean;
@@ -12,22 +16,35 @@ export declare function detectSecret(entry: {
     content: string;
     tags: string[];
 }): SecretDetection;
-/** Replace secret-shaped substrings in free text with a redaction marker, using the same `SECRET_PATTERNS` and co-occurrence guard as `detectSecret`;
+/**
+ * Replace secret-shaped substrings in free text with a redaction marker, using the same `SECRET_PATTERNS` and
+ * co-occurrence guard as `detectSecret`;
  * for callers persisting text that skips the capture content gate (e.g. pre-compact snapshot fields). */
 export declare function redactSecrets(text: string): string;
-/** Memories never hold a raw email address (AGENTS.md); phone numbers are left alone, as their patterns misfire on ids. */
+/**
+ * Memories never hold a raw email address (AGENTS.md); phone numbers are left alone, as their patterns misfire on ids.
+ */
 export declare function maskEmails(text: string): string;
-/** Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and JWTs. */
+/**
+ * Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and
+ * JWTs.
+ */
 export declare function redactSecretsStrict(text: string): string;
 /** The text a write keeps, plus what to tell its caller about secret material in it. */
 export interface SecretVet {
     content: string;
     warnings: string[];
 }
-/** Write-time veto: `scrub` text no person typed gets capture's strict redaction; typed text is a person's own call, so it is kept and flagged. */
+/**
+ * Write-time veto: `scrub` text no person typed gets capture's strict redaction; typed text is a person's own call, so
+ * it is kept and flagged.
+ */
 export declare function vetSecrets(content: string, tags: readonly string[], scrub: boolean): SecretVet;
 /** Appended to a dead-letter row's error when `redactPayload` changed its body. */
 export declare const DLQ_REDACTED_NOTE = "secret-shaped text redacted, signature dropped; replay needs --force";
-/** `vetSecrets` redaction for a raw webhook body: JSON stays valid for replay, and an untouched body stays byte-identical so its signature still verifies. */
+/**
+ * `vetSecrets` redaction for a raw webhook body: JSON stays valid for replay, and an untouched body stays
+ * byte-identical so its signature still verifies.
+ */
 export declare function redactPayload(raw: string): string;
 //# sourceMappingURL=secret-detect.d.ts.map

package/dist/util/secret-detect.js

@@ -1,5 +1,9 @@
-/** Secret detection for memory content: conservative provider-bounded patterns (a bare `sk-` in prose must not flag). Flagged rows are never shared to
- * the global store or injected as ambient context outside their project; explicit recall is unaffected. Leaf module: no imports from store/api/shared. */
+/**
+ * Secret detection for memory content: conservative provider-bounded patterns (a bare `sk-` in prose must not flag).
+ * Flagged rows are never shared to
+ * the global store or injected as ambient context outside their project; explicit recall is unaffected. Leaf module: no
+ * imports from store/api/shared.
+ */
 /** Tags that flag a memory as secret, lower case; detectSecret folds a tag's case before the lookup. */
 export const SECRET_TAGS = new Set([
     'secret', 'api-key', 'apikey', 'credential', 'credentials',
@@ -14,7 +18,8 @@ const SECRET_PATTERNS = [
     { name: 'slack-token', re: /\bxox[baprs]-[A-Za-z0-9-]{10,}/ },
     { name: 'stripe-key', re: /\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}\b/ },
     { name: 'google-api-key', re: /\bAIza[0-9A-Za-z_-]{35}(?:\b|(?<=-))/ },
-    // hk_ is hippo's own API key (src/store/auth.ts); npm, Hugging Face, GitLab and Slack webhook shapes follow gitleaks' rules.
+    // hk_ is hippo's own API key (src/store/auth.ts); npm, Hugging Face, GitLab and Slack webhook shapes follow gitleaks'
+    // rules.
     { name: 'hippo-api-key', re: /\bhk_[a-z2-7]{24}\.[a-z2-7]{32}\b/ },
     { name: 'npm-token', re: /\bnpm_[A-Za-z0-9]{36}\b/ },
     { name: 'huggingface-token', re: /\bhf_[A-Za-z]{34}\b/ },
@@ -22,12 +27,14 @@ const SECRET_PATTERNS = [
     { name: 'google-oauth-token', re: /\bya29\.[\w-]{20,}/ },
     { name: 'slack-webhook', re: /\bhooks\.slack\.com\/(?:services|workflows|triggers)\/[A-Za-z0-9+/]{43,56}/ },
     { name: 'private-key-block', re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-    // sk-... (OpenAI/Anthropic) and sk_<vendor>_... shapes; both need a key-ish noun in the content (co-occurrence guard), so prose
+    // sk-... (OpenAI/Anthropic) and sk_<vendor>_... shapes need a key-ish noun nearby (co-occurrence guard), so prose
     // like "the sk- prefix identifies API keys" does not flag but "prod API key sk_live_..." does.
     { name: 'sk-style-key', re: /\bsk-[A-Za-z0-9_-]{20,}/ },
     { name: 'sk-underscore-key', re: /\bsk_[A-Za-z0-9]+_[A-Za-z0-9_]{6,}\b/ },
-    // Value needs 12+ token-safe chars and a digit, or `token = estimateTokens(...)` and user:password@ templates would hide code lessons from ambient context.
-    // Secret names end in the keyword (dbPassword), so the match opens there, no prefix scan; pwd and pass need a _ (OLDPWD, bypass are not secrets).
+    // Value needs 12+ token-safe chars and a digit, or `token = estimateTokens(...)` and user:password@ templates would
+    // hide code lessons from ambient context.
+    // Secret names end in the keyword (dbPassword), so the match opens there, no prefix scan; pwd and pass need a _
+    // (OLDPWD, bypass are not secrets).
     {
         name: 'secret-assignment',
         re: new RegExp(String.raw `(?:(?:api[_-]?key|access[_-]?key|private[_-]?key|secret|token|passw(?:or)?d|(?<=_)(?:pwd|pass))` +
@@ -61,7 +68,9 @@ export function detectSecret(entry) {
     }
     return { flagged: false, reason: null };
 }
-/** Replace secret-shaped substrings in free text with a redaction marker, using the same `SECRET_PATTERNS` and co-occurrence guard as `detectSecret`;
+/**
+ * Replace secret-shaped substrings in free text with a redaction marker, using the same `SECRET_PATTERNS` and
+ * co-occurrence guard as `detectSecret`;
  * for callers persisting text that skips the capture content gate (e.g. pre-compact snapshot fields). */
 export function redactSecrets(text) {
     return redactText(text, false);
@@ -69,15 +78,23 @@ export function redactSecrets(text) {
 /** Only a run's first character starts a match, so a long run is scanned once; a
  * domain's first label opens on a letter, so logo@2x.png and react@18.2.0 stay. */
 const EMAIL = /(?<![A-Za-z0-9._%+-])[A-Za-z0-9._%+-]{1,64}@[A-Za-z][A-Za-z0-9-]*(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}\b/g;
-/** Memories never hold a raw email address (AGENTS.md); phone numbers are left alone, as their patterns misfire on ids. */
+/**
+ * Memories never hold a raw email address (AGENTS.md); phone numbers are left alone, as their patterns misfire on ids.
+ */
 export function maskEmails(text) {
     return text.replace(EMAIL, '[email]');
 }
-/** Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and JWTs. */
+/**
+ * Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and
+ * JWTs.
+ */
 export function redactSecretsStrict(text) {
     return redactText(text, true);
 }
-/** Write-time veto: `scrub` text no person typed gets capture's strict redaction; typed text is a person's own call, so it is kept and flagged. */
+/**
+ * Write-time veto: `scrub` text no person typed gets capture's strict redaction; typed text is a person's own call, so
+ * it is kept and flagged.
+ */
 export function vetSecrets(content, tags, scrub) {
     const kept = scrub ? redactSecretsStrict(content) : content;
     const warnings = [];
@@ -94,7 +111,10 @@ export function vetSecrets(content, tags, scrub) {
 const JSON_STRING = /"(?:[^"\\]|\\.)*"/g;
 /** Appended to a dead-letter row's error when `redactPayload` changed its body. */
 export const DLQ_REDACTED_NOTE = 'secret-shaped text redacted, signature dropped; replay needs --force';
-/** `vetSecrets` redaction for a raw webhook body: JSON stays valid for replay, and an untouched body stays byte-identical so its signature still verifies. */
+/**
+ * `vetSecrets` redaction for a raw webhook body: JSON stays valid for replay, and an untouched body stays
+ * byte-identical so its signature still verifies.
+ */
 export function redactPayload(raw) {
     try {
         JSON.parse(raw);
@@ -109,12 +129,27 @@ export function redactPayload(raw) {
         return kept === text ? literal : JSON.stringify(kept);
     });
 }
+const PEM_BEGIN = /-----BEGIN [A-Z ]*PRIVATE KEY-----/g;
+const PEM_END = /-----END [A-Z ]*PRIVATE KEY-----/g;
+/** Each PEM/OpenSSH block through its END line, or to the end of a truncated block; one forward scan, so no ReDoS. */
+function redactPemBlocks(text) {
+    let out = '';
+    let from = 0;
+    PEM_BEGIN.lastIndex = 0;
+    for (let begin = PEM_BEGIN.exec(text); begin; begin = PEM_BEGIN.exec(text)) {
+        PEM_END.lastIndex = PEM_BEGIN.lastIndex;
+        const end = PEM_END.exec(text);
+        out += `${text.slice(from, begin.index)}[REDACTED]`;
+        from = end ? PEM_END.lastIndex : text.length;
+        PEM_BEGIN.lastIndex = from;
+    }
+    return out + text.slice(from);
+}
 function redactText(text, strict) {
     if (!text)
         return text;
-    let result = text;
-    // PEM/OpenSSH blocks first: SECRET_PATTERNS only matches BEGIN; consume through END, or to the end of a truncated block.
-    result = result.replace(/-----BEGIN [A-Z ]*PRIVATE KEY-----(?:[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----|[\s\S]*$)/g, '[REDACTED]');
+    // PEM blocks first: SECRET_PATTERNS only matches the BEGIN line.
+    let result = redactPemBlocks(text);
     for (const { name, re } of SECRET_PATTERNS) {
         if (!strict && CO_OCCURRENCE_GUARDED.has(name) && !KEYISH_CONTEXT_RE.test(text))
             continue;

package/dist/util/spawn-argv.d.ts

@@ -3,7 +3,9 @@ import { type ChildProcess, type SpawnOptions } from 'node:child_process';
 export declare function quoteCmdArg(arg: string): string;
 /** cmd.exe arguments that run a .cmd or .bat shim with every forwarded argument delivered verbatim. */
 export declare function cmdShimArgs(shimPath: string, forwardArgs: readonly string[]): string[];
-/** Spawns argv[0] with the rest as its arguments and no shell. Node refuses to start a .cmd or .bat without one (CVE-2024-27980),
+/**
+ * Spawns argv[0] with the rest as its arguments and no shell. Node refuses to start a .cmd or .bat without one
+ * (CVE-2024-27980),
  *  so on win32 such a shim runs through cmd.exe with every argument quoted for it. */
 export declare function spawnArgv(argv: readonly string[], options: SpawnOptions): ChildProcess;
 //# sourceMappingURL=spawn-argv.d.ts.map

package/dist/util/spawn-argv.js

@@ -1,10 +1,14 @@
-// Starting a command from an argv list with no shell, Windows .cmd and .bat shims included, so no argument is ever parsed as shell syntax.
+// Starting a command from an argv list with no shell, Windows .cmd and .bat shims included, so no argument is ever
+// parsed as shell syntax.
 import { spawn } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { envPath, envPathExt } from './env.js';
 /** Quotes one cmd.exe argument; each `%` leaves the quotes as `^%`, so no %NAME% pair can expand. */
 export function quoteCmdArg(arg) {
+    // cmd.exe ends the command line at CR or LF, so what follows would run as a new command.
+    if (/[\r\n]/.test(arg))
+        throw new Error('cmd.exe argument contains a CR or LF, which would start a new command');
     if (arg.length === 0)
         return '""';
     if (!/[ \t"&()^<>|%!]/.test(arg))
@@ -21,10 +25,13 @@ const DEFAULT_PATHEXT = '.COM;.EXE;.BAT;.CMD';
 function isFile(candidate) {
     return fs.statSync(candidate, { throwIfNoEntry: false })?.isFile() === true;
 }
-/** The file `command` names on win32: as given when it has a folder, else the first hit in the working folder then PATH, trying each PATHEXT. */
+/**
+ * The file `command` names on win32: as given when it has a folder, else the first hit on PATH (never the working
+ * folder, where a project file could stand in for a tool), trying each PATHEXT.
+ */
 function resolveWindowsCommand(command) {
     const exts = (envPathExt() ?? DEFAULT_PATHEXT).split(';').filter((ext) => ext.length > 0);
-    const dirs = /[\\/]/.test(command) ? [''] : [process.cwd(), ...(envPath() ?? '').split(path.delimiter).filter((dir) => dir.length > 0)];
+    const dirs = /[\\/]/.test(command) ? [''] : (envPath() ?? '').split(path.delimiter).filter((dir) => dir.length > 0);
     for (const dir of dirs) {
         const base = dir === '' ? command : path.join(dir, command);
         const candidates = path.extname(command) === '' ? exts.map((ext) => base + ext) : [base, ...exts.map((ext) => base + ext)];
@@ -34,7 +41,9 @@ function resolveWindowsCommand(command) {
     }
     return null;
 }
-/** Spawns argv[0] with the rest as its arguments and no shell. Node refuses to start a .cmd or .bat without one (CVE-2024-27980),
+/**
+ * Spawns argv[0] with the rest as its arguments and no shell. Node refuses to start a .cmd or .bat without one
+ * (CVE-2024-27980),
  *  so on win32 such a shim runs through cmd.exe with every argument quoted for it. */
 export function spawnArgv(argv, options) {
     const [command, ...args] = argv;

package/dist/util/sqlite-blocked.d.ts

@@ -1,18 +1,29 @@
-/** Thrown by a hippo.db open inside a request served from another store: the code path is not ported to the store port yet. */
+/**
+ * Thrown by a hippo.db open inside a request served from another store: the code path is not ported to the store port
+ * yet.
+ */
 export declare class SqliteBlockedError extends Error {
     readonly storeKind: string;
     constructor(storeKind: string, message?: string);
 }
-/** A store that lacks a whole group of port methods; it maps to the same 501, and the log names the group instead of hippo.db. */
+/**
+ * A store that lacks a whole group of port methods; it maps to the same 501, and the log names the group instead of
+ * hippo.db.
+ */
 export declare class StoreNotPortedError extends SqliteBlockedError {
     readonly group: string;
     constructor(storeKind: string, group: string);
 }
-/** Thrown by a hippo.db open in a folder whose marker file names the store that holds its memories, from the CLI as from a request. */
+/**
+ * Thrown by a hippo.db open in a folder whose marker file names the store that holds its memories, from the CLI as from
+ * a request.
+ */
 export declare class OtherStoreFolderError extends SqliteBlockedError {
     readonly markerPath: string;
     constructor(storeKind: string, markerPath: string);
 }
-/** First line of a best-effort catch around a hippo.db open: an unported path must fail closed, not fall back silently. */
+/**
+ * First line of a best-effort catch around a hippo.db open: an unported path must fail closed, not fall back silently.
+ */
 export declare function rethrowIfSqliteBlocked<E>(err: E): void;
 //# sourceMappingURL=sqlite-blocked.d.ts.map

package/dist/util/sqlite-blocked.js

@@ -1,14 +1,22 @@
-// A leaf module, so http-util can map this error to a 501 without importing db/open, whose migrations reach back to http-util.
-/** Thrown by a hippo.db open inside a request served from another store: the code path is not ported to the store port yet. */
+// A leaf module, so http-util can map this error to a 501 without importing db/open, whose migrations reach back to
+// http-util.
+/**
+ * Thrown by a hippo.db open inside a request served from another store: the code path is not ported to the store port
+ * yet.
+ */
 export class SqliteBlockedError extends Error {
     storeKind;
-    constructor(storeKind, message = `hippo.db is not opened while the '${storeKind}' store serves this request; this code path is not ported to the store yet`) {
+    constructor(storeKind, message = `hippo.db is not opened while the '${storeKind}' store serves this request; this code path is not ` +
+        `ported to the store yet`) {
         super(message);
         this.storeKind = storeKind;
         this.name = 'SqliteBlockedError';
     }
 }
-/** A store that lacks a whole group of port methods; it maps to the same 501, and the log names the group instead of hippo.db. */
+/**
+ * A store that lacks a whole group of port methods; it maps to the same 501, and the log names the group instead of
+ * hippo.db.
+ */
 export class StoreNotPortedError extends SqliteBlockedError {
     group;
     constructor(storeKind, group) {
@@ -17,7 +25,10 @@ export class StoreNotPortedError extends SqliteBlockedError {
         this.name = 'StoreNotPortedError';
     }
 }
-/** Thrown by a hippo.db open in a folder whose marker file names the store that holds its memories, from the CLI as from a request. */
+/**
+ * Thrown by a hippo.db open in a folder whose marker file names the store that holds its memories, from the CLI as from
+ * a request.
+ */
 export class OtherStoreFolderError extends SqliteBlockedError {
     markerPath;
     constructor(storeKind, markerPath) {
@@ -26,7 +37,9 @@ export class OtherStoreFolderError extends SqliteBlockedError {
         this.name = 'OtherStoreFolderError';
     }
 }
-/** First line of a best-effort catch around a hippo.db open: an unported path must fail closed, not fall back silently. */
+/**
+ * First line of a best-effort catch around a hippo.db open: an unported path must fail closed, not fall back silently.
+ */
 export function rethrowIfSqliteBlocked(err) {
     if (err instanceof SqliteBlockedError)
         throw err;

package/dist/util/stored-json.d.ts

@@ -4,6 +4,9 @@ export interface StoredJsonSite {
     id: string | number;
     column: string;
 }
-/** Warns the first time this row's column is found damaged (the logger caps how many), then at debug, so a row read on every recall cannot flood stderr. */
+/**
+ * Warns the first time this row's column is found damaged (the logger caps how many), then at debug, so a row read on
+ * every recall cannot flood stderr.
+ */
 export declare function warnDamagedColumn(site: StoredJsonSite, problem: 'not valid JSON' | 'wrong shape'): void;
 //# sourceMappingURL=stored-json.d.ts.map

package/dist/util/stored-json.js

@@ -1,6 +1,10 @@
-// One log line for a stored JSON column that will not read, so a reader that degrades to an empty value still leaves a trace.
+// One log line for a stored JSON column that will not read, so a reader that degrades to an empty value still leaves a
+// trace.
 import { log } from './log.js';
-/** Warns the first time this row's column is found damaged (the logger caps how many), then at debug, so a row read on every recall cannot flood stderr. */
+/**
+ * Warns the first time this row's column is found damaged (the logger caps how many), then at debug, so a row read on
+ * every recall cannot flood stderr.
+ */
 export function warnDamagedColumn(site, problem) {
     const { table, id, column } = site;
     log.warnThenDebug(`damaged-column:${table}:${id}:${column}`, `store: ${table}.${column} is ${problem}; read as empty`, { table, id, column });

package/dist/util/stream-tee.d.ts

@@ -1,3 +1,4 @@
-/** Mirrors every stdout and stderr chunk to `logFile` until the returned restore runs; an append failure warns once and never stops the real write. */
+/** Mirrors every stdout and stderr chunk to `logFile` until the returned restore runs; an append failure warns once
+ * and never stops the real write. */
 export declare function teeStdStreams(logFile: string): () => void;
 //# sourceMappingURL=stream-tee.d.ts.map

package/dist/util/stream-tee.js

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
-import { errorMessage, log } from './log.js';
-/** Mirrors every stdout and stderr chunk to `logFile` until the returned restore runs; an append failure warns once and never stops the real write. */
+import { errorMessage, log, errorFields } from './log.js';
+/** Mirrors every stdout and stderr chunk to `logFile` until the returned restore runs; an append failure warns once
+ * and never stops the real write. */
 export function teeStdStreams(logFile) {
     const origStdoutWrite = process.stdout.write.bind(process.stdout);
     const origStderrWrite = process.stderr.write.bind(process.stderr);
@@ -13,16 +14,18 @@ export function teeStdStreams(logFile) {
             if (warned)
                 return;
             warned = true;
-            log.warn(`log file ${logFile} is no longer writable; output continues without it: ${errorMessage(err)}`);
+            log.warn(`log file ${logFile} is no longer writable; output continues without it: ${errorMessage(err)}`, errorFields(err));
         }
     };
     const wrapWrite = (origWrite) => {
         const wrapped = (...args) => {
             tee(args[0]);
-            // SAFETY: forwarding the exact arguments the real overloaded `write` received is safe; `StreamWriteArgs` is the union of both overloads' parameter lists.
+            // SAFETY: forwarding the exact arguments the real overloaded `write` received is safe; `StreamWriteArgs` is the
+            // union of both overloads' parameter lists.
             return origWrite(...args);
         };
-        // SAFETY: `wrapped` matches both real `write` overload shapes; TS cannot verify one implementation covers an overloaded type.
+        // SAFETY: `wrapped` matches both real `write` overload shapes; TS cannot verify one implementation covers an
+        // overloaded type.
         return wrapped;
     };
     process.stdout.write = wrapWrite(origStdoutWrite);

package/dist/util/transcript-tail.d.ts

@@ -4,6 +4,9 @@ export declare const PRE_COMPACT_TAIL_BYTES: number;
 export declare function truncateCodePointSafe(text: string, maxChars: number): string;
 /** The last `capBytes` of a JSONL transcript, read at an offset and starting on a whole line so every line parses. */
 export declare function readTranscriptTail(transcriptPath: string, capBytes?: number): string;
-/** {@link readTranscriptTail} for a transcript the caller opened and sized, so the size and the bytes come from one file. */
+/**
+ * {@link readTranscriptTail} for a transcript the caller opened and sized, so the size and the bytes come from one
+ * file.
+ */
 export declare function readOpenTranscriptTail(fd: number, size: number, capBytes: number): string;
 //# sourceMappingURL=transcript-tail.d.ts.map

package/dist/util/transcript-tail.js

@@ -24,7 +24,10 @@ export function readTranscriptTail(transcriptPath, capBytes = PRE_COMPACT_TAIL_B
         fs.closeSync(fd);
     }
 }
-/** {@link readTranscriptTail} for a transcript the caller opened and sized, so the size and the bytes come from one file. */
+/**
+ * {@link readTranscriptTail} for a transcript the caller opened and sized, so the size and the bytes come from one
+ * file.
+ */
 export function readOpenTranscriptTail(fd, size, capBytes) {
     const start = Math.max(0, size - capBytes);
     const length = size - start;

package/dist/util/version.d.ts

@@ -1,10 +1,15 @@
-/** Single source of truth for the package version, written by scripts/sync-version.mjs; never edit by hand. Read by the db rollback guard, /health, MCP.
+/**
+ * Single source of truth for the package version, written by scripts/sync-version.mjs; never edit by hand. Read by the
+ * db rollback guard, /health, MCP.
  * A constant, not a runtime package.json read: the published bundle may lack package.json on a path ESM can resolve. */
-export declare const PACKAGE_VERSION = "2.0.0";
+export declare const PACKAGE_VERSION = "2.1.0";
 /** The floor a store takes on its first expiring key: the first release with schema
  * v53, set by hand in that release; scripts/check-expiring-keys-floor.mjs gates it. */
 export declare const EXPIRING_KEYS_MIN_BINARY = "1.64.0";
-/** The floor a store takes on its first session bind or owner snapshot: first release with v54; set by hand in that release. */
+/**
+ * The floor a store takes on its first session bind or owner snapshot: first release with v54; set by hand in that
+ * release.
+ */
 export declare const TASK_OWNER_MIN_BINARY = "1.64.0";
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export declare function compareSemver(a: string, b: string): number;

package/dist/util/version.js

@@ -1,10 +1,15 @@
-/** Single source of truth for the package version, written by scripts/sync-version.mjs; never edit by hand. Read by the db rollback guard, /health, MCP.
+/**
+ * Single source of truth for the package version, written by scripts/sync-version.mjs; never edit by hand. Read by the
+ * db rollback guard, /health, MCP.
  * A constant, not a runtime package.json read: the published bundle may lack package.json on a path ESM can resolve. */
-export const PACKAGE_VERSION = '2.0.0';
+export const PACKAGE_VERSION = '2.1.0';
 /** The floor a store takes on its first expiring key: the first release with schema
  * v53, set by hand in that release; scripts/check-expiring-keys-floor.mjs gates it. */
 export const EXPIRING_KEYS_MIN_BINARY = '1.64.0';
-/** The floor a store takes on its first session bind or owner snapshot: first release with v54; set by hand in that release. */
+/**
+ * The floor a store takes on its first session bind or owner snapshot: first release with v54; set by hand in that
+ * release.
+ */
 export const TASK_OWNER_MIN_BINARY = '1.64.0';
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export function compareSemver(a, b) {