hippo-memory 1.71.0 → 2.0.0

package/dist/store/token-ledger.d.ts

@@ -82,13 +82,6 @@ interface ModelTagged {
 }
 /** Claude Code writes its own API errors and limit notices as assistant lines from this model; no model call made them. */
 export declare function isSyntheticMessage(message: ModelTagged): boolean;
-/** A hook payload's non-empty `session_id`, or null; with `requiredSource`, also null when its `source` differs. */
-export declare function hookPayloadSessionId(stdinText: string | undefined, requiredSource?: string | null): string | null;
-/** A hook payload's string `field` as sent, or null when the payload or the field is missing or not a string. */
-export declare function hookPayloadString(stdinText: string | undefined, field: string): string | null;
-/** Whether a hook fired inside a sub-agent, the only payload with `agent_id` (https://code.claude.com/docs/en/hooks#common-input-fields).
- *  Its `session_id` is the parent's, so a sub-agent's blocks and compactions must not count as the parent's. */
-export declare function isSubagentPayload(stdinText: string | undefined): boolean;
 /** Tokens hippo sent and skipped in one session, for {@link tokensBySession}. */
 export interface SessionTokens {
     sessionId: string;

package/dist/store/token-ledger.js

@@ -90,41 +90,6 @@ export function summarizeTokenUse(db, tenantId, sinceIso) {
 export function isSyntheticMessage(message) {
     return message.model === '<synthetic>';
 }
-/** A Claude Code hook payload on stdin as a JSON object; null when empty, malformed or not an object. */
-function parseHookPayload(stdinText) {
-    if (!stdinText || stdinText.trim() === '')
-        return null;
-    try {
-        // SAFETY: JSON.parse returns a JSON value by definition.
-        const payload = JSON.parse(stdinText.trim());
-        return isJsonObjectLiteral(payload) ? payload : null;
-    }
-    catch {
-        // Malformed is one of the null cases the docblock names.
-        return null;
-    }
-}
-/** A hook payload's non-empty `session_id`, or null; with `requiredSource`, also null when its `source` differs. */
-export function hookPayloadSessionId(stdinText, requiredSource = null) {
-    const payload = parseHookPayload(stdinText);
-    const sessionId = payload?.session_id;
-    if (!payload || !isJsonString(sessionId) || sessionId.trim() === '')
-        return null;
-    if (requiredSource !== null && payload.source !== requiredSource)
-        return null;
-    return sessionId;
-}
-/** A hook payload's string `field` as sent, or null when the payload or the field is missing or not a string. */
-export function hookPayloadString(stdinText, field) {
-    const value = parseHookPayload(stdinText)?.[field];
-    return isJsonString(value) ? value : null;
-}
-/** Whether a hook fired inside a sub-agent, the only payload with `agent_id` (https://code.claude.com/docs/en/hooks#common-input-fields).
- *  Its `session_id` is the parent's, so a sub-agent's blocks and compactions must not count as the parent's. */
-export function isSubagentPayload(stdinText) {
-    const agentId = parseHookPayload(stdinText)?.agent_id;
-    return isJsonString(agentId) && agentId.trim() !== '';
-}
 /** Ledger totals per session id since `sinceIso`, across surfaces; hook rows carry the host's session id (the transcript file name), so they join to its
  * usage records. */
 export function tokensBySession(db, tenantId, sinceIso) {

package/dist/store/vector-index.js

@@ -1,11 +1,15 @@
 // Owns hippo.db's stored vectors, the identity of the model that built them, and the particle rows: every read and write of the three.
 import { getMeta, setMeta, withWriteScope } from '../db/index.js';
 import { onHandle } from './open.js';
-import { DEFAULT_EMBEDDING_MODEL } from './embeddings/local.js';
-import { float32ToBuffer, initializeParticle, loadPhysicsState, resetAllPhysicsState, savePhysicsState } from '../db/physics-state.js';
+import { DEFAULT_EMBEDDING_MODEL } from '../embeddings/local.js';
+import { loadPhysicsState, resetAllPhysicsState, savePhysicsState } from '../db/physics-state.js';
+import { initializeParticle } from '../core/physics.js';
+import { float32ToBuffer } from '../util/vector-codec.js';
 import { EMBEDDING_MODEL_META_KEY, deleteOrphanVectors, hasStoredVectors, loadVectors, loadVectorViews, replaceAllVectors, storedVectorDims, storedVectorIds, upsertVectors, } from '../db/vector-store.js';
-import { chunked, selectEntriesByIds } from './entry-reads.js';
+import { selectEntriesByIds } from './entry-reads.js';
+import { chunked } from '../util/chunked.js';
 import { MEMORY_SELECT_COLUMNS, rowToEntry } from './rows.js';
+import { placeholders } from '../util/sql.js';
 const MAX_BACKFILL_PAGE = 500;
 /** The model the index was built by: the stored identity, else the default model when vectors exist. */
 export function indexedModel(state) {
@@ -97,7 +101,7 @@ function ownedIds(db, ids, tenantId) {
     const owned = new Set();
     for (const chunk of chunked([...new Set(ids)])) {
         // SAFETY: the SELECT names one column, id.
-        const rows = db.prepare(`SELECT id FROM memories WHERE +tenant_id = ? AND id IN (${chunk.map(() => '?').join(', ')})`).all(tenantId, ...chunk);
+        const rows = db.prepare(`SELECT id FROM memories WHERE +tenant_id = ? AND id IN (${placeholders(chunk.length)})`).all(tenantId, ...chunk);
         for (const row of rows)
             owned.add(row.id);
     }

package/dist/support-bundle.js

@@ -5,10 +5,9 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { pathToFileURL } from 'url';
-import { findHippoStoreDir, isGlobalStoreRoot } from './core/project-identity.js';
+import { findHippoStoreDir, isGlobalStoreRoot, isInitialized } from './core/project-identity.js';
 import { realpathOrResolve } from './util/real-path.js';
 import { getGlobalRoot } from './sharing/global-store.js';
-import { isInitialized } from './store/open.js';
 import { readStoreInventory } from './store/diagnostics.js';
 import { runDoctor } from './doctor.js';
 import { loadConfig } from './core/config.js';
@@ -21,7 +20,7 @@ export const TAIL_MAX_LINES = 200;
 const TAIL_MAX_LINE_CHARS = 2000;
 // Greedy on purpose: complete key blocks are redacted first, so any END left is an orphan and what precedes it may be key body.
 const ORPHAN_KEY_END_RE = /^[\s\S]*-----END [A-Z ]*PRIVATE KEY-----/;
-// The other env vars hippo reads outside the HIPPO_ prefix (src/store/embeddings/provider.ts, connectors/*).
+// The other env vars hippo reads outside the HIPPO_ prefix (src/embeddings/provider.ts, connectors/*).
 const OTHER_ENV_NAMES = [
     'ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'VOYAGE_API_KEY', 'COHERE_API_KEY', 'TYPESAFE_API_KEY',
     'GITHUB_TOKEN', 'GITHUB_WEBHOOK_SECRET', 'GITHUB_WEBHOOK_SECRET_PREVIOUS',

package/dist/trust/reject-flow.js

@@ -1,8 +1,8 @@
 // The reject, unreject and list flow the CLI verbs and the api functions share: the rules and their wording live here,
 // and src/store/rejected-values.ts runs each one on a single handle.
 import { BadRequestError } from '../core/api-errors.js';
-import { isPersonalScope } from '../store/recall-scope.js';
-import { mergedSuccessor } from '../consolidate/merged-row.js';
+import { isPersonalScope } from '../core/recall-scope.js';
+import { mergedSuccessor } from '../core/merged-row.js';
 import { normalizeValueForRejection } from '../store/rejection.js';
 import { applyRejection, liftRejection, loadRejectedValues, } from '../store/rejected-values.js';
 function assertRejectOpts(opts) {

package/dist/util/agent-homes.d.ts

@@ -0,0 +1,15 @@
+type Env = Readonly<Record<string, string | undefined>>;
+export declare function homeDir(): string;
+/** Codex's config folder: $CODEX_HOME, else ~/.codex, as the Codex hooks docs describe. */
+export declare function codexHomeDir(home?: string, env?: Env): string;
+/** Claude Code's config folder, where it reads settings.json: $CLAUDE_CONFIG_DIR when set and non-empty, else
+ * ~/.claude under os.homedir(), as Claude Code does (a HOME that differs from the profile must not move it). */
+export declare function claudeConfigDir(home?: string, env?: Env): string;
+/** VS Code's user-data resolution: portable install first, then the app-data override, then the platform default. */
+export declare function vscodeDataFolders(ctx: {
+    readonly env: Env;
+    readonly home: string;
+    readonly platform: NodeJS.Platform;
+}): string[];
+export {};
+//# sourceMappingURL=agent-homes.d.ts.map

package/dist/util/agent-homes.js

@@ -0,0 +1,34 @@
+// Where the agent tools keep their config and data, shared by the hook installers and the agent-memory readers.
+import * as os from 'os';
+import * as path from 'path';
+import { envHomeDir, processEnv } from './env.js';
+const VSCODE_PRODUCTS = ['Code', 'Code - Insiders'];
+export function homeDir() {
+    return envHomeDir() || os.homedir();
+}
+/** Codex's config folder: $CODEX_HOME, else ~/.codex, as the Codex hooks docs describe. */
+export function codexHomeDir(home = homeDir(), env = processEnv()) {
+    return env.CODEX_HOME || path.join(home, '.codex');
+}
+/** Claude Code's config folder, where it reads settings.json: $CLAUDE_CONFIG_DIR when set and non-empty, else
+ * ~/.claude under os.homedir(), as Claude Code does (a HOME that differs from the profile must not move it). */
+export function claudeConfigDir(home = os.homedir(), env = processEnv()) {
+    return env.CLAUDE_CONFIG_DIR || path.join(home, '.claude');
+}
+/** VS Code's user-data resolution: portable install first, then the app-data override, then the platform default. */
+export function vscodeDataFolders(ctx) {
+    const { env, home, platform } = ctx;
+    if (env.VSCODE_PORTABLE)
+        return [path.join(env.VSCODE_PORTABLE, 'user-data')];
+    let appData;
+    if (env.VSCODE_APPDATA)
+        appData = env.VSCODE_APPDATA;
+    else if (platform === 'win32')
+        appData = env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    else if (platform === 'darwin')
+        appData = path.join(home, 'Library', 'Application Support');
+    else
+        appData = env.XDG_CONFIG_HOME || path.join(home, '.config');
+    return VSCODE_PRODUCTS.map((product) => path.join(appData, product));
+}
+//# sourceMappingURL=agent-homes.js.map

package/dist/util/anthropic-messages.d.ts

@@ -13,9 +13,12 @@ export type AnthropicMessageFailure = {
 } | {
     kind: 'http';
     status: number;
+    detail: string;
 } | {
     kind: 'unreadable';
     message: string;
+} | {
+    kind: 'empty';
 };
 export type AnthropicMessageResult = {
     ok: true;
@@ -24,7 +27,9 @@ export type AnthropicMessageResult = {
     ok: false;
     failure: AnthropicMessageFailure;
 };
-/** The reply's first text block, trimmed (empty when the reply has none); never throws. */
+/** True for a failure the next call would repeat, so a caller looping over items should stop rather than retry. */
+export declare function isPermanentFailure(failure: AnthropicMessageFailure): boolean;
+/** The reply's first text block, trimmed; a reply with no text is a failure of kind 'empty'. Never throws. */
 export declare function sendAnthropicMessage(req: AnthropicMessageRequest): Promise<AnthropicMessageResult>;
 /** The text extraction and DAG summaries hand to their `onError` callback. */
 export declare function describeMessageFailure(failure: AnthropicMessageFailure): string;

package/dist/util/anthropic-messages.js

@@ -1,20 +1,37 @@
 /** The one Anthropic Messages client: sends one user prompt and returns the reply text or a typed failure the caller reacts to. */
-import { fetchWithRetry, llmTimeoutMs } from './http-retry.js';
+import { fetchWithRetry, llmTimeoutMs, llmTotalMs } from './http-retry.js';
 import { errorMessage } from './log.js';
-import { readCappedJson } from './capped-json.js';
+import { readCappedJson, readCappedText } from './capped-json.js';
 import { isJsonObject, isJsonString } from './json.js';
+import { redactSecretsStrict } from './secret-detect.js';
 const MESSAGES_URL = 'https://api.anthropic.com/v1/messages';
 const API_VERSION = '2023-06-01';
 const DEFAULT_MODEL = 'claude-sonnet-4-6';
 // Callers ask for at most 1,200 tokens, a reply of a few KB; 1 MiB leaves room for a verbose envelope.
 const MAX_REPLY_BYTES = 1024 * 1024;
+// The error body names the cause (bad key, no credit, unknown model) in its first line or two.
+const ERROR_SNIPPET_CHARS = 256;
+const UTF8_MAX_BYTES_PER_CHAR = 4;
+// A bad or missing key, no credit, no permission, an unknown model: every later call gets the same answer.
+const PERMANENT_STATUSES = new Set([401, 402, 403, 404]);
 /** The first content block's text, trimmed; empty when the reply has no such block. */
 function firstText(reply) {
     const first = Array.isArray(reply.content) ? reply.content[0] : undefined;
     const text = isJsonObject(first) ? first.text : undefined;
     return isJsonString(text) ? text.trim() : '';
 }
-/** The reply's first text block, trimmed (empty when the reply has none); never throws. */
+/** True for a failure the next call would repeat, so a caller looping over items should stop rather than retry. */
+export function isPermanentFailure(failure) {
+    return failure.kind === 'http' && PERMANENT_STATUSES.has(failure.status);
+}
+/** The start of a failed reply's body, on one line with any key-shaped text masked; empty when the body cannot be read. */
+async function errorSnippet(res) {
+    // The status is the failure reported; a body that cannot be read only costs its snippet.
+    const body = await readCappedText(res, ERROR_SNIPPET_CHARS * UTF8_MAX_BYTES_PER_CHAR).catch(() => '');
+    // Masked before the cut, so a key that straddles the cut is never left half shown.
+    return redactSecretsStrict(body.replace(/\s+/g, ' ').trim()).slice(0, ERROR_SNIPPET_CHARS);
+}
+/** The reply's first text block, trimmed; a reply with no text is a failure of kind 'empty'. Never throws. */
 export async function sendAnthropicMessage(req) {
     let res;
     try {
@@ -30,18 +47,19 @@ export async function sendAnthropicMessage(req) {
                 max_tokens: req.maxTokens,
                 messages: [{ role: 'user', content: req.prompt }],
             }),
-        }, { timeoutMs: llmTimeoutMs(), fetchFn: req.fetcher ?? fetch });
+        }, { timeoutMs: llmTimeoutMs(), totalMs: llmTotalMs(), fetchFn: req.fetcher ?? fetch });
     }
     catch (err) {
         return { ok: false, failure: { kind: 'request', message: errorMessage(err) } };
     }
     if (!res.ok)
-        return { ok: false, failure: { kind: 'http', status: res.status } };
+        return { ok: false, failure: { kind: 'http', status: res.status, detail: await errorSnippet(res) } };
     try {
         const data = await readCappedJson(res, MAX_REPLY_BYTES);
         if (!isJsonObject(data))
             return { ok: false, failure: { kind: 'unreadable', message: 'the reply is not a JSON object' } };
-        return { ok: true, text: firstText(data) };
+        const text = firstText(data);
+        return text === '' ? { ok: false, failure: { kind: 'empty' } } : { ok: true, text };
     }
     catch (err) {
         return { ok: false, failure: { kind: 'unreadable', message: errorMessage(err) } };
@@ -51,8 +69,9 @@ export async function sendAnthropicMessage(req) {
 export function describeMessageFailure(failure) {
     switch (failure.kind) {
         case 'request': return `request failed: ${failure.message}`;
-        case 'http': return `HTTP ${failure.status}`;
+        case 'http': return failure.detail ? `HTTP ${failure.status}: ${failure.detail}` : `HTTP ${failure.status}`;
         case 'unreadable': return `unparseable response: ${failure.message}`;
+        case 'empty': return 'the reply held no text';
     }
 }
 //# sourceMappingURL=anthropic-messages.js.map

package/dist/util/atomic-write.d.ts

@@ -1,4 +1,7 @@
 /** Replaces `file` through a flushed temp file and a rename, so a reader, or a crash at any point, finds the old content or the new, whole.
- *  A file with other hard links, or a rename the platform refuses (logged), is written in place: a crash mid-write can leave it truncated. */
-export declare function writeFileAtomic(file: string, text: string): void;
+ *  A file with other hard links, or a rename the platform refuses (logged), is written in place: a crash mid-write can leave it truncated.
+ *  `durable: false` skips the fsyncs for derived files that can be rebuilt; a reader still never sees a torn file. */
+export declare function writeFileAtomic(file: string, text: string, opts?: {
+    readonly durable?: boolean;
+}): void;
 //# sourceMappingURL=atomic-write.d.ts.map

package/dist/util/atomic-write.js

@@ -53,13 +53,14 @@ function removeTemp(tmp) {
     }
 }
 /** Flushed before the rename, or a crash soon after could leave the file's name on bytes that never reached the disk. */
-function writeFlushed(tmp, text, old) {
+function writeFlushed(tmp, text, old, durable) {
     const fd = fs.openSync(tmp, 'w', (old?.mode ?? 0o666) & 0o777);
     try {
         fs.writeFileSync(fd, text, 'utf8');
         if (old)
             keepAccess(tmp, old);
-        fs.fsyncSync(fd);
+        if (durable)
+            fs.fsyncSync(fd);
     }
     finally {
         fs.closeSync(fd);
@@ -82,17 +83,18 @@ function flushFolder(dir) {
         log.warn(`could not flush the folder ${dir} to disk after replacing a file in it: ${errorMessage(err)}`);
     }
 }
-function replaceViaTemp(target, text, old) {
+function replaceViaTemp(target, text, old, durable) {
     const tmp = `${target}.${process.pid}.tmp`;
     try {
-        writeFlushed(tmp, text, old);
+        writeFlushed(tmp, text, old, durable);
         renameOnto(tmp, target);
     }
     catch (err) {
         removeTemp(tmp);
         throw err;
     }
-    flushFolder(path.dirname(target));
+    if (durable)
+        flushFolder(path.dirname(target));
 }
 /** The pre-rename write: it truncates first, so it is only the fallback, but it needs just a writable file and keeps hard links together. */
 function writeInPlace(target, text) {
@@ -109,8 +111,10 @@ function writeInPlace(target, text) {
     }
 }
 /** Replaces `file` through a flushed temp file and a rename, so a reader, or a crash at any point, finds the old content or the new, whole.
- *  A file with other hard links, or a rename the platform refuses (logged), is written in place: a crash mid-write can leave it truncated. */
-export function writeFileAtomic(file, text) {
+ *  A file with other hard links, or a rename the platform refuses (logged), is written in place: a crash mid-write can leave it truncated.
+ *  `durable: false` skips the fsyncs for derived files that can be rebuilt; a reader still never sees a torn file. */
+export function writeFileAtomic(file, text, opts = {}) {
+    const durable = opts.durable !== false;
     const target = writeTarget(file);
     const old = fs.statSync(target, { throwIfNoEntry: false });
     if (old === undefined) {
@@ -126,7 +130,7 @@ export function writeFileAtomic(file, text) {
         return;
     }
     try {
-        replaceViaTemp(target, text, old);
+        replaceViaTemp(target, text, old, durable);
     }
     catch (err) {
         if (!(err instanceof Error) || !REPLACE_REFUSALS.includes(errnoCode(err)))

package/dist/util/chunked.d.ts

@@ -0,0 +1,3 @@
+/** `items` in consecutive slices of at most `size`. */
+export declare function chunked<T>(items: readonly T[], size?: number): T[][];
+//# sourceMappingURL=chunked.d.ts.map

package/dist/util/chunked.js

@@ -0,0 +1,10 @@
+/** Ids per `IN (...)` list: far under SQLite's bound-parameter limit, with room for the tenant filter. */
+const ID_CHUNK = 500;
+/** `items` in consecutive slices of at most `size`. */
+export function chunked(items, size = ID_CHUNK) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size)
+        out.push(items.slice(i, i + size));
+    return out;
+}
+//# sourceMappingURL=chunked.js.map

package/dist/util/ellipsize.d.ts

@@ -0,0 +1,3 @@
+/** `text` cut to `max` characters plus a marker, or unchanged when it already fits. */
+export declare function truncateWithEllipsis(text: string, max: number, marker?: string): string;
+//# sourceMappingURL=ellipsize.d.ts.map

package/dist/util/ellipsize.js

@@ -0,0 +1,5 @@
+/** `text` cut to `max` characters plus a marker, or unchanged when it already fits. */
+export function truncateWithEllipsis(text, max, marker = '...') {
+    return text.length > max ? `${text.slice(0, max)}${marker}` : text;
+}
+//# sourceMappingURL=ellipsize.js.map

package/dist/util/env.d.ts

@@ -22,6 +22,8 @@ export declare function envHippoHome(): string | undefined;
 export declare function envXdgDataHome(): string | undefined;
 export declare function envHomeDir(): string | undefined;
 export declare function envPath(): string | undefined;
+/** The extensions win32 tries on a bare command name, in order. */
+export declare function envPathExt(): string | undefined;
 export declare function envModelCache(): string | undefined;
 export declare function envHippoSessionId(): string | undefined;
 export declare function envClaudeCodeSessionId(): string | undefined;
@@ -34,6 +36,7 @@ export declare const DEFAULT_TENANT_ID = "default";
 export declare function envTenant(): string;
 export declare function envSkipAutoIntegrations(): boolean;
 export declare function envSkipPostinstall(): boolean;
+export declare function envSkipSchedule(): boolean;
 export declare function envMcpStdio(): boolean;
 /** `1` or `true`, so `0` and `false` turn it off; `true` stays on for anyone who set it that way. */
 export declare function envRequireServer(): boolean;
@@ -46,15 +49,21 @@ export declare function envPort(): string | undefined;
 /** How long a client waits for a running server's /health before writing to the store directly; server-detect.ts holds the default. */
 export declare function envHealthProbeMs(): number | undefined;
 export declare function envRequireAuth(): boolean;
-/** `1` lets a request made on this machine in with no key, as host admin; HIPPO_REQUIRE_AUTH=1 wins over it. */
+/** `1` lets a request made on this machine in with no key; HIPPO_REQUIRE_AUTH=1 wins over it. */
 export declare function envAllowKeylessLocal(): boolean;
+/** The role a keyless local request gets: `admin` (host admin) only when asked for by name, else `member`. */
+export declare function envKeylessLocalRole(): 'admin' | 'member';
+/** `1` lets a non-loopback bind start without TLS, for TLS that ends at a proxy in front. */
+export declare function envAllowCleartext(): boolean;
 export declare function envV1Rps(): string | undefined;
+/** Requests per second each authenticated caller may make; `0` turns the per-caller limit off. */
+export declare function envCallerRps(): string | undefined;
 /** How long a request body may take to arrive; http-util.ts holds the default. */
 export declare function envBodyTimeoutMs(): number | undefined;
 /** How long POST /v1/sleep lets its consolidation run; server/sleep-offload.ts holds the default. */
 export declare function envSleepTimeoutMs(): number | undefined;
 /** How long a /v1 or /mcp request may run before the server answers 504, and a stdio MCP
- * request before its timeout error; 0 for no deadline; server/deadline.ts holds the default. */
+ * request before its timeout error; 0 for no deadline; util/request-scope.ts holds the default. */
 export declare function envRequestDeadlineMs(): number | undefined;
 /** How many store calls may wait for one worker thread before the next is refused; store/sqlite/executor.ts holds the default. */
 export declare function envStoreQueueMax(): number | undefined;
@@ -62,6 +71,7 @@ export declare function envStoreQueueMax(): number | undefined;
 export declare function envDailyStepTimeoutMs(): number | undefined;
 export declare function envApiKey(): string | undefined;
 export declare function envClientIpHeader(): string | undefined;
+/** The peers whose HIPPO_CLIENT_IP_HEADER is believed: IPs or CIDRs, or `*` for any peer. */
 export declare function envTrustedProxies(): string | undefined;
 /** Paths to the PEM certificate and key `hippo serve` answers HTTPS with; the --tls-cert and --tls-key flags win. */
 export declare function envTlsCert(): string | undefined;

package/dist/util/env.js

@@ -64,6 +64,8 @@ export function envHippoHome() { return raw('HIPPO_HOME')?.trim(); }
 export function envXdgDataHome() { return raw('XDG_DATA_HOME')?.trim(); }
 export function envHomeDir() { return raw('HOME') || raw('USERPROFILE'); }
 export function envPath() { return raw('PATH'); }
+/** The extensions win32 tries on a bare command name, in order. */
+export function envPathExt() { return raw('PATHEXT'); }
 export function envModelCache() { return trimmed('HIPPO_MODEL_CACHE'); }
 // Session, scope and tenant.
 export function envHippoSessionId() { return trimmed('HIPPO_SESSION_ID'); }
@@ -80,6 +82,7 @@ export function envTenant() {
 // Install and CLI switches.
 export function envSkipAutoIntegrations() { return isOne('HIPPO_SKIP_AUTO_INTEGRATIONS'); }
 export function envSkipPostinstall() { return isOne('HIPPO_SKIP_POSTINSTALL'); }
+export function envSkipSchedule() { return isOne('HIPPO_SKIP_SCHEDULE'); }
 export function envMcpStdio() { return isOne('HIPPO_MCP_STDIO'); }
 /** `1` or `true`, so `0` and `false` turn it off; `true` stays on for anyone who set it that way. */
 export function envRequireServer() { return isOneOrTrue('HIPPO_REQUIRE_SERVER'); }
@@ -93,15 +96,21 @@ export function envPort() { return raw('HIPPO_PORT'); }
 /** How long a client waits for a running server's /health before writing to the store directly; server-detect.ts holds the default. */
 export function envHealthProbeMs() { return positiveInt('HIPPO_HEALTH_PROBE_MS'); }
 export function envRequireAuth() { return isOne('HIPPO_REQUIRE_AUTH'); }
-/** `1` lets a request made on this machine in with no key, as host admin; HIPPO_REQUIRE_AUTH=1 wins over it. */
+/** `1` lets a request made on this machine in with no key; HIPPO_REQUIRE_AUTH=1 wins over it. */
 export function envAllowKeylessLocal() { return isOne('HIPPO_ALLOW_KEYLESS_LOCAL'); }
+/** The role a keyless local request gets: `admin` (host admin) only when asked for by name, else `member`. */
+export function envKeylessLocalRole() { return trimmed('HIPPO_KEYLESS_LOCAL_ROLE')?.toLowerCase() === 'admin' ? 'admin' : 'member'; }
+/** `1` lets a non-loopback bind start without TLS, for TLS that ends at a proxy in front. */
+export function envAllowCleartext() { return isOne('HIPPO_ALLOW_CLEARTEXT'); }
 export function envV1Rps() { return raw('HIPPO_V1_RPS'); }
+/** Requests per second each authenticated caller may make; `0` turns the per-caller limit off. */
+export function envCallerRps() { return trimmed('HIPPO_CALLER_RPS'); }
 /** How long a request body may take to arrive; http-util.ts holds the default. */
 export function envBodyTimeoutMs() { return positiveInt('HIPPO_BODY_TIMEOUT_MS'); }
 /** How long POST /v1/sleep lets its consolidation run; server/sleep-offload.ts holds the default. */
 export function envSleepTimeoutMs() { return positiveInt('HIPPO_SLEEP_TIMEOUT_MS'); }
 /** How long a /v1 or /mcp request may run before the server answers 504, and a stdio MCP
- * request before its timeout error; 0 for no deadline; server/deadline.ts holds the default. */
+ * request before its timeout error; 0 for no deadline; util/request-scope.ts holds the default. */
 export function envRequestDeadlineMs() { return nonNegativeInt('HIPPO_REQUEST_DEADLINE_MS'); }
 /** How many store calls may wait for one worker thread before the next is refused; store/sqlite/executor.ts holds the default. */
 export function envStoreQueueMax() { return positiveInt('HIPPO_STORE_QUEUE_MAX'); }
@@ -109,6 +118,7 @@ export function envStoreQueueMax() { return positiveInt('HIPPO_STORE_QUEUE_MAX')
 export function envDailyStepTimeoutMs() { return positiveInt('HIPPO_DAILY_STEP_TIMEOUT_MS'); }
 export function envApiKey() { return raw('HIPPO_API_KEY'); }
 export function envClientIpHeader() { return raw('HIPPO_CLIENT_IP_HEADER')?.trim().toLowerCase(); }
+/** The peers whose HIPPO_CLIENT_IP_HEADER is believed: IPs or CIDRs, or `*` for any peer. */
 export function envTrustedProxies() { return raw('HIPPO_TRUSTED_PROXIES'); }
 /** Paths to the PEM certificate and key `hippo serve` answers HTTPS with; the --tls-cert and --tls-key flags win. */
 export function envTlsCert() { return trimmed('HIPPO_TLS_CERT'); }

package/dist/util/format.d.ts

@@ -0,0 +1,5 @@
+/** A 0..1 fraction as a percentage with one decimal, e.g. 0.256 -> "25.6%". */
+export declare function pct(fraction: number): string;
+/** Rounds to one decimal place. */
+export declare function round1(value: number): number;
+//# sourceMappingURL=format.d.ts.map

package/dist/util/format.js

@@ -0,0 +1,10 @@
+// Number-to-text helpers shared by report and eval output.
+/** A 0..1 fraction as a percentage with one decimal, e.g. 0.256 -> "25.6%". */
+export function pct(fraction) {
+    return (fraction * 100).toFixed(1) + '%';
+}
+/** Rounds to one decimal place. */
+export function round1(value) {
+    return Math.round(value * 10) / 10;
+}
+//# sourceMappingURL=format.js.map

package/dist/util/hook-payload.d.ts

@@ -0,0 +1,8 @@
+/** A hook payload's non-empty `session_id`, or null; with `requiredSource`, also null when its `source` differs. */
+export declare function hookPayloadSessionId(stdinText: string | undefined, requiredSource?: string | null): string | null;
+/** A hook payload's string `field` as sent, or null when the payload or the field is missing or not a string. */
+export declare function hookPayloadString(stdinText: string | undefined, field: string): string | null;
+/** Whether a hook fired inside a sub-agent, the only payload with `agent_id` (https://code.claude.com/docs/en/hooks#common-input-fields).
+ *  Its `session_id` is the parent's, so a sub-agent's blocks and compactions must not count as the parent's. */
+export declare function isSubagentPayload(stdinText: string | undefined): boolean;
+//# sourceMappingURL=hook-payload.d.ts.map

package/dist/util/hook-payload.js

@@ -0,0 +1,37 @@
+import { isJsonObjectLiteral, isJsonString } from './json.js';
+/** A Claude Code hook payload on stdin as a JSON object; null when empty, malformed or not an object. */
+function parseHookPayload(stdinText) {
+    if (!stdinText || stdinText.trim() === '')
+        return null;
+    try {
+        // SAFETY: JSON.parse returns a JSON value by definition.
+        const payload = JSON.parse(stdinText.trim());
+        return isJsonObjectLiteral(payload) ? payload : null;
+    }
+    catch {
+        // Malformed is one of the null cases the docblock names.
+        return null;
+    }
+}
+/** A hook payload's non-empty `session_id`, or null; with `requiredSource`, also null when its `source` differs. */
+export function hookPayloadSessionId(stdinText, requiredSource = null) {
+    const payload = parseHookPayload(stdinText);
+    const sessionId = payload?.session_id;
+    if (!payload || !isJsonString(sessionId) || sessionId.trim() === '')
+        return null;
+    if (requiredSource !== null && payload.source !== requiredSource)
+        return null;
+    return sessionId;
+}
+/** A hook payload's string `field` as sent, or null when the payload or the field is missing or not a string. */
+export function hookPayloadString(stdinText, field) {
+    const value = parseHookPayload(stdinText)?.[field];
+    return isJsonString(value) ? value : null;
+}
+/** Whether a hook fired inside a sub-agent, the only payload with `agent_id` (https://code.claude.com/docs/en/hooks#common-input-fields).
+ *  Its `session_id` is the parent's, so a sub-agent's blocks and compactions must not count as the parent's. */
+export function isSubagentPayload(stdinText) {
+    const agentId = parseHookPayload(stdinText)?.agent_id;
+    return isJsonString(agentId) && agentId.trim() !== '';
+}
+//# sourceMappingURL=hook-payload.js.map

package/dist/util/http-retry.d.ts

@@ -4,6 +4,8 @@ export interface RetryPolicy {
     timeoutMs: number;
     /** Total attempts including the first. */
     attempts?: number;
+    /** Limit on the whole call, waits included: an attempt is cut short at it and no retry starts whose wait would reach it. */
+    totalMs?: number;
     baseDelayMs?: number;
     /** A Retry-After longer than this hands the response back, so a caller with its own long pause keeps it. */
     maxDelayMs?: number;
@@ -15,9 +17,13 @@ export interface RetryPolicy {
     /** Replaces the timer between attempts. A caller `signal` that aborts still ends the wait at once. */
     sleep?: (ms: number) => Promise<void>;
     random?: () => number;
+    /** Replaces the clock `totalMs` is measured on. */
+    now?: () => number;
 }
 /** LLM calls (consolidation refine, DAG summaries, fact extraction) share one budget; `HIPPO_LLM_TIMEOUT_MS` overrides it. */
 export declare function llmTimeoutMs(): number;
+/** One LLM call with its retries: two full attempts and the longest wait between them, where three slow failures would hold a sleep for 3x the timeout. */
+export declare function llmTotalMs(): number;
 export declare function isRetryableStatus(status: number): boolean;
 /** Retry-After as milliseconds: delta-seconds or an HTTP date; null when absent or unreadable. */
 export declare function parseRetryAfterMs(header: string | null, now?: number): number | null;