hippo-memory 1.69.0 → 1.71.0

package/dist/capture/failure-reading.js

@@ -1,8 +1,10 @@
 // What a PostToolUseFailure payload says, read with no store, so a hook with no store sends the same reading the local log keeps.
-import { redactSecretsStrict } from '../secret-detect.js';
-import { scrubForSharing } from '../share-scrub.js';
-import { blockHash } from '../token-ledger.js';
-import { truncateCodePointSafe } from '../transcript-tail.js';
+import { redactSecretsStrict } from '../util/secret-detect.js';
+import { scrubForSharing } from './share-scrub.js';
+import { blockHash } from '../util/token-text.js';
+import { truncateCodePointSafe } from '../util/transcript-tail.js';
+import { isJsonObjectLiteral } from '../util/json.js';
+const COMMAND_HEAD_WORDS = 2;
 /** The longest lesson text a reading gives, so a check of a sent one imports it instead of copying it. */
 export const FAILURE_TEXT_MAX_CHARS = 200;
 /** The user, a permission prompt or a hook said no: routine, not a lesson. */
@@ -20,12 +22,9 @@ const SHELL_TOOLS = new Set(['Bash', 'bash', 'powershell', 'run_in_terminal']);
 function isString(v) {
     return v !== undefined && v !== null && v.constructor === String;
 }
-function isObject(v) {
-    return v !== undefined && v !== null && !Array.isArray(v) && v.constructor === Object;
-}
 /** A non-blank string field of the payload, or null. */
 export function payloadString(payload, key) {
-    if (!isObject(payload))
+    if (!isJsonObjectLiteral(payload))
         return null;
     const value = payload[key];
     return isString(value) && value.trim() !== '' ? value : null;
@@ -40,9 +39,9 @@ export function failureHash(text) {
 }
 /** 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 function lessonFromFailure(payload, scrub = (text) => text) {
-    if (!isObject(payload))
+    if (!isJsonObjectLiteral(payload))
         return { skip: 'skipped-invalid', text: null, detail: null };
-    // SAFETY: isObject narrowed payload to a plain JSON object; the fields read are all optional.
+    // SAFETY: isJsonObjectLiteral narrowed payload to a plain JSON object; the fields read are all optional.
     const p = payload;
     if (p.is_interrupt === true)
         return { skip: 'skipped-interrupt', text: null, detail: null };
@@ -51,8 +50,8 @@ export function lessonFromFailure(payload, scrub = (text) => text) {
     const tool = isString(p.tool_name) ? p.tool_name : 'tool';
     const error = redactSecretsStrict(p.error.replace(/\s+/g, ' ').trim());
     const text = truncateCodePointSafe(scrub(`${tool}: ${error}`), FAILURE_TEXT_MAX_CHARS);
-    const command = isObject(p.tool_input) && isString(p.tool_input['command']) ? p.tool_input['command'].replace(LEADING_CD, '') : '';
-    const head = command.trim().split(/\s+/).slice(0, 2).join(' ');
+    const command = isJsonObjectLiteral(p.tool_input) && isString(p.tool_input['command']) ? p.tool_input['command'].replace(LEADING_CD, '') : '';
+    const head = command.trim().split(/\s+/).slice(0, COMMAND_HEAD_WORDS).join(' ');
     const detail = `${tool}${head ? ` ${head}` : ''}: ${error}`;
     const routine = (rule) => ({ skip: 'skipped-routine', rule, text, detail });
     if (DECLINED.test(error))

package/dist/{handoff-evidence.d.ts → capture/handoff-evidence.d.ts}

@@ -1,4 +1,4 @@
-import type { HandoffEvidence } from './handoff.js';
+import type { HandoffEvidence } from '../core/handoff.js';
 export declare function collectHandoffEvidence(cwd: string, testStatus: HandoffEvidence['testStatus'], options?: {
     timeoutMs?: number;
 }): HandoffEvidence;

package/dist/{handoff-evidence.js → capture/handoff-evidence.js}

@@ -1,9 +1,10 @@
 // A handoff's git evidence, read with no store, so a hook with no store can send it with the session's end.
 import { execFileSync } from 'child_process';
+const DEFAULT_TIMEOUT_MS = 2000;
 // Best-effort git state; a missing git, non-repo cwd, or a call past timeoutMs (each call, default 2 s)
 // yields null fields rather than throw, so a hook with a hard deadline can cap a slow repo.
 export function collectHandoffEvidence(cwd, testStatus, options = {}) {
-    const timeoutMs = options.timeoutMs ?? 2000;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     let gitRef = null;
     try {
         gitRef = execFileSync('git', ['rev-parse', 'HEAD'], {

package/dist/capture/pre-compact-caller.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from '../api/types.js';
-import type { CallerProject } from '../prompt-hook.js';
+import type { CallerProject } from '../api/prompt-hook.js';
 import { type WorkingState } from './working-state.js';
 export interface CallerPreCompactRequest {
     readonly sessionId: string;

package/dist/capture/pre-compact-caller.js

@@ -1,5 +1,5 @@
-import { markSnapshotSaved, PRE_COMPACT_INSTRUCTION, startCompaction } from '../compaction-record.js';
-import { errorMessage, log } from '../log.js';
+import { markSnapshotSaved, PRE_COMPACT_INSTRUCTION, startCompaction } from './compaction-record.js';
+import { errorMessage, log } from '../util/log.js';
 import { loadActiveTaskSnapshot, saveActiveTaskSnapshot } from '../store/sessions.js';
 import { assertTrigger, bindCaller, callerInHoldout, checkedWorkingState, withCallerDb } from './caller-session.js';
 import { mergeWorkingState } from './working-state.js';

package/dist/{session-digest.d.ts → capture/session-digest.d.ts}

@@ -1,6 +1,4 @@
-import { type SessionTurn } from './capture/transcript.js';
-import { type MemoryEntry } from './memory.js';
-export declare const SESSION_DIGEST_TAG = "session-digest";
+import { type SessionTurn } from './transcript.js';
 /** Five-word runs are stock phrases; six in a row is a copied clause. */
 export declare const ECHO_WINDOW = 6;
 /** Five sentences of about 150 chars leave room for the Changed line inside the total cap. */
@@ -32,7 +30,7 @@ export declare function readSessionTranscript(transcriptPath: string, log: (mess
 /** The transcript, read once and scanned, or null with the reason logged. */
 export declare function readSessionScan(transcriptPath: string, log: (message: string) => void): SessionScan | null;
 /** Test-only seam, the scheduler's pattern: lets a test prove a network path never reaches the probe. Null restores it. */
-export declare function __setDigestExistsProbe(probe: ((p: string) => boolean) | null): void;
+export declare function _setDigestExistsProbeForTests(probe: ((p: string) => boolean) | null): void;
 /** The store root is realpath'd; transcript paths are not, and a deleted file has no realpath of its own. Null for a network path. */
 export declare function realFsPath(p: string): string | null;
 /** Repo-relative with forward slashes, '' for the root itself, null outside the repo or when the path cannot be resolved. */
@@ -54,8 +52,6 @@ export interface DigestDraft {
 }
 /** The digest text, or null when nothing survives the filters. Sentences print in reply order. */
 export declare function buildSessionDigest(sources: DigestSources): DigestDraft | null;
-/** Facts extracted from a digest and DAG summaries over one inherit its tag, but they are not the digest itself. */
-export declare function isSessionDigestRow(entry: Pick<MemoryEntry, 'source' | 'tags' | 'extracted_from'>): boolean;
 /** Same session, same row: a second worker for one session updates the digest instead of adding one. */
 export declare function sessionDigestId(tenantId: string, key: string): string;
 export interface SessionDigestOptions {

package/dist/{session-digest.js → capture/session-digest.js}

@@ -2,23 +2,23 @@
 import { createHash } from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
-import { collectSessionTurns } from './capture/transcript.js';
-import { isObjectLike, isStringValue } from './capture-contract.js';
+import { collectSessionTurns } from './transcript.js';
+import { isObjectLike, isStringValue } from '../core/capture-contract.js';
 import { PATCH_SUCCESS_LINE, patchPaths, shellPatch } from './codex-patch.js';
-import { loadConfig } from './config.js';
-import { USER_SEGMENT } from './home-path.js';
-import { errorMessage } from './log.js';
-import { createMemory, Layer } from './memory.js';
-import { RejectedValueError } from './rejection.js';
-import { maskEmails, redactSecretsStrict } from './secret-detect.js';
-import { isInitialized } from './store/open.js';
-import { writeEntry } from './store/entry-writes.js';
-import { loadAllEntries } from './store/entry-reads.js';
-import { SNAPSHOT_AMBIENT_MAX_AGE_MS } from './store/sessions.js';
-import { loadLatestHandoff } from './store/handoffs.js';
-import { isSyntheticMessage } from './token-ledger.js';
-import { readTranscriptTail } from './transcript-tail.js';
-export const SESSION_DIGEST_TAG = 'session-digest';
+import { loadConfig } from '../core/config.js';
+import { USER_SEGMENT } from '../util/home-path.js';
+import { errorMessage } from '../util/log.js';
+import { SESSION_DIGEST_TAG } from '../core/session-digest-row.js';
+import { createMemory, Layer } from '../core/memory.js';
+import { RejectedValueError } from '../store/rejection.js';
+import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
+import { isInitialized } from '../store/open.js';
+import { writeEntry } from '../store/entry-writes.js';
+import { loadLiveContentsBySourceAndTag } from '../store/entry-reads.js';
+import { SNAPSHOT_AMBIENT_MAX_AGE_MS } from '../store/sessions.js';
+import { loadLatestHandoff } from '../store/handoffs.js';
+import { isSyntheticMessage } from '../store/token-ledger.js';
+import { readOpenTranscriptTail } from '../util/transcript-tail.js';
 /** Five-word runs are stock phrases; six in a row is a copied clause. */
 export const ECHO_WINDOW = 6;
 /** Five sentences of about 150 chars leave room for the Changed line inside the total cap. */
@@ -228,11 +228,17 @@ export function scanSessionTranscript(jsonl) {
     };
 }
 export function readSessionTranscript(transcriptPath, log) {
-    const size = fs.statSync(transcriptPath).size;
-    if (size <= READ_CAP_BYTES)
-        return fs.readFileSync(transcriptPath, 'utf8');
-    log(`digest: transcript is ${size} bytes, reading its last ${READ_CAP_BYTES}`);
-    return readTranscriptTail(transcriptPath, READ_CAP_BYTES);
+    const fd = fs.openSync(transcriptPath, 'r');
+    try {
+        const size = fs.fstatSync(fd).size;
+        if (size <= READ_CAP_BYTES)
+            return fs.readFileSync(fd, 'utf8');
+        log(`digest: transcript is ${size} bytes, reading its last ${READ_CAP_BYTES}`);
+        return readOpenTranscriptTail(fd, size, READ_CAP_BYTES);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
 }
 /** The transcript, read once and scanned, or null with the reason logged. */
 export function readSessionScan(transcriptPath, log) {
@@ -246,7 +252,7 @@ export function readSessionScan(transcriptPath, log) {
 }
 let existsProbe = fs.existsSync;
 /** Test-only seam, the scheduler's pattern: lets a test prove a network path never reaches the probe. Null restores it. */
-export function __setDigestExistsProbe(probe) {
+export function _setDigestExistsProbeForTests(probe) {
     existsProbe = probe ?? fs.existsSync;
 }
 /** A \\host or //host path would make existsSync open an SMB connection to a host named in transcript text. */
@@ -430,19 +436,13 @@ export function buildSessionDigest(sources) {
         return content ? { content, sentences: kept.length, files: files.length } : null;
     }
 }
-/** Facts extracted from a digest and DAG summaries over one inherit its tag, but they are not the digest itself. */
-export function isSessionDigestRow(entry) {
-    return entry.source === SESSION_DIGEST_TAG && entry.tags.includes(SESSION_DIGEST_TAG) && !entry.extracted_from;
-}
 /** Same session, same row: a second worker for one session updates the digest instead of adding one. */
 export function sessionDigestId(tenantId, key) {
     return `mem_${createHash('sha256').update(`${SESSION_DIGEST_TAG}\n${tenantId}\n${key}`).digest('hex').slice(0, 12)}`;
 }
 /** What hippo could have injected into the session: any live digest (prompt recall reaches old ones) and the ambient handoff, never this session's own. */
 function injectedTexts(hippoRoot, opts) {
-    const digests = loadAllEntries(hippoRoot, opts.tenantId)
-        .filter((e) => isSessionDigestRow(e) && !e.superseded_by && e.source_session_id !== opts.key)
-        .map((e) => e.content);
+    const digests = loadLiveContentsBySourceAndTag(hippoRoot, opts.tenantId, SESSION_DIGEST_TAG, SESSION_DIGEST_TAG, opts.key);
     const handoff = loadLatestHandoff(hippoRoot, opts.tenantId, undefined, {
         unfinishedOnly: true,
         maxAgeMs: SNAPSHOT_AMBIENT_MAX_AGE_MS,

package/dist/capture/session-end-caller.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from '../api/types.js';
-import type { HandoffEvidence } from '../handoff.js';
-import type { CallerProject } from '../prompt-hook.js';
+import type { HandoffEvidence } from '../core/handoff.js';
+import type { CallerProject } from '../api/prompt-hook.js';
 import type { WorkingState } from './working-state.js';
 export type CallerEvidence = Pick<HandoffEvidence, 'gitRef' | 'dirtyTree' | 'testStatus'>;
 export interface CallerSessionEndRequest {

package/dist/capture/session-end-caller.js

@@ -1,5 +1,5 @@
 // SessionEnd for a caller on another machine: the owner's handoff, then the owner's snapshot for the session closed, both under its tenant and project.
-import { BadRequestError } from '../api-errors.js';
+import { BadRequestError } from '../core/api-errors.js';
 import { writeSessionEndHandoff } from '../store/handoffs.js';
 import { closeTaskSnapshotsForSession } from '../store/sessions.js';
 import { bindCaller, checkedWorkingState } from './caller-session.js';

package/dist/capture/session-texts.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from '../api/types.js';
-import { type CallerProject } from '../prompt-hook.js';
+import { type CallerProject } from '../api/prompt-hook.js';
 import { type CaptureTally } from './command.js';
 export interface SessionCaptureRequest {
     readonly sessionId: string;

package/dist/capture/session-texts.js

@@ -1,9 +1,9 @@
 // `hippo capture --last-session` for a caller whose transcript was read on another machine: its project names the rows, never the store's folder.
-import { BadRequestError } from '../api-errors.js';
-import { assertCallerIds } from '../prompt-hook.js';
-import { assertCallerProject, projectNames } from '../project-identity.js';
-import { longestWord, storedTextKeys } from '../same-text.js';
-import { scrubForSharing } from '../share-scrub.js';
+import { BadRequestError } from '../core/api-errors.js';
+import { assertCallerIds } from '../api/prompt-hook.js';
+import { assertCallerProject, projectNames } from '../core/project-identity.js';
+import { longestWord, storedTextKeys } from '../util/same-text.js';
+import { scrubForSharing } from './share-scrub.js';
 import { loadTextsHoldingWords } from '../store/candidates.js';
 import { captureExtractedItems } from './command.js';
 import { extractFromTexts } from './extract.js';

package/dist/capture/session-worker.js

@@ -4,9 +4,10 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { createHash } from 'node:crypto';
 import { homeDir } from '../hooks/shared.js';
-import { errorMessage } from '../log.js';
-import { isObjectLike, isStringValue } from '../capture-contract.js';
+import { errorMessage, log as logger } from '../util/log.js';
+import { isObjectLike, isStringValue } from '../core/capture-contract.js';
 import { SESSION_ID_RE } from './copilot-transcript.js';
+import { FINGERPRINT_HEX_CHARS } from '../util/token-text.js';
 /** Null for a missing id or one that could climb out of the sessions folder. */
 function sessionStateFiles(sessionId) {
     if (sessionId === null || !SESSION_ID_RE.test(sessionId))
@@ -73,8 +74,9 @@ function releaseSessionLock(lock) {
     try {
         fs.rmSync(lock, { force: true });
     }
-    catch {
+    catch (err) {
         // A lock left behind names this pid, which is dead once the worker exits, so the next taker clears it.
+        logger.debug(`session lock not removed: ${errorMessage(err)}`);
     }
 }
 /** False when the sessions folder cannot be written, so the caller runs unlocked as before. */
@@ -133,7 +135,7 @@ export async function runSessionWorker(sessionId, mode, work) {
     }
 }
 function turnKey(turn) {
-    return createHash('sha256').update(`${turn.role}\n${turn.text}`).digest('hex').slice(0, 16);
+    return createHash('sha256').update(`${turn.role}\n${turn.text}`).digest('hex').slice(0, FINGERPRINT_HEX_CHARS);
 }
 /** The cursor position after `turns`: how many there were and a hash of the last. */
 export function turnPosition(turns) {

package/dist/{share-scrub.js → capture/share-scrub.js}

@@ -1,6 +1,6 @@
 // The scrub for transcript text that leaves the machine it was typed on.
-import { maskHomePaths } from './home-path.js';
-import { maskEmails, redactSecretsStrict } from './secret-detect.js';
+import { maskHomePaths } from '../util/home-path.js';
+import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
 /** Secrets first, then emails, then home paths: a home-path mask could split a secret so that no pattern matches it. */
 export function scrubForSharing(text) {
     return maskHomePaths(maskEmails(redactSecretsStrict(text)));

package/dist/capture/transcript.d.ts

@@ -28,16 +28,8 @@ export declare function sessionTail(turns: readonly SessionTurn[]): {
     assistants: string[];
 };
 export declare function summariseSessionTurns(turns: readonly SessionTurn[]): string;
-/**
- * Resolve a transcript path for `--last-session`.
- *
- * Priority, where the first source present is the only one tried:
- *   1. Explicit `transcriptPath` option (from `--transcript <path>`)
- *   2. Stdin JSON payload (Claude Code / OpenCode SessionEnd hook shape)
- *   3. Most recent `.jsonl` under `<claude config dir>/projects/<any>/` (`~/.claude` unless CLAUDE_CONFIG_DIR is set), only when the caller passes `mayScan` (only the caller knows it is not a hook) and there is no path and no stdin text, because this scan spans every project on the box
- *
- * Returns null when nothing resolves, a named transcript or payload whose file is missing included. Never throws.
- */
+/** Resolve a transcript path for `--last-session`: `transcriptPath`, then the stdin JSON payload, then the newest `.jsonl` in the Claude config dir.
+ *  The scan runs only with `mayScan` (it spans every project on the box); returns null when nothing resolves, never throws. */
 export declare function resolveLastSessionTranscript(explicit: string | undefined, stdinText: string | undefined, opts: {
     mayScan: boolean;
 }): string | null;

package/dist/capture/transcript.js

@@ -1,17 +1,13 @@
-import { envHomeDir, processEnv } from '../env.js';
+import { envHomeDir, processEnv } from '../util/env.js';
 import { claudeConfigDir } from '../hooks/shared.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import { isObjectLike, isStringValue } from '../capture-contract.js';
+import { isObjectLike, isStringValue, readSessionEnd } from '../core/capture-contract.js';
 import { copilotTurn } from './copilot-transcript.js';
-/**
- * Build a compact text summary from a Claude Code / OpenCode / Copilot JSONL transcript.
- * Keeps plain user messages and the final chunk of assistant text, drops
- * thinking blocks, tool_use, and tool_result noise. Capture reads the same
- * turns through `sessionTail`, one text per turn.
- *
- * Exported for tests.
- */
+const RECENT_USER_TURNS = 20;
+const RECENT_ASSISTANT_TURNS = 10;
+/** Build a compact text summary from a Claude Code / OpenCode / Copilot JSONL transcript: plain user messages and the final assistant text chunk,
+ *  without thinking, tool_use and tool_result noise. Exported for tests. */
 /** Leading markers of the command lines Claude Code writes with type 'user'. */
 const CLAUDE_CODE_COMMAND_PREFIXES = ['<local-command-', '<command-name>', '<command-message>', '<command-args>'];
 function isNonHumanUserLine(entry, content) {
@@ -54,69 +50,69 @@ export function collectSessionTurns(jsonl, visit) {
         if (!isObjectLike(entry) || !('type' in entry))
             continue;
         visit?.(entry);
-        const copilot = copilotTurn(entry);
-        if (copilot !== null) {
-            turns.push(copilot);
-            continue;
-        }
-        if (entry.type === 'user' || entry.type === 'assistant') {
-            const message = 'message' in entry && isObjectLike(entry.message) ? entry.message : undefined;
-            if (!message)
-                continue;
-            const content = 'content' in message ? message.content : undefined;
-            if (entry.type === 'user') {
-                const text = humanUserText(entry, message);
-                if (text)
-                    turns.push({ role: 'user', text });
-            }
-            else if (Array.isArray(content)) {
-                // Keep assistant text blocks; drop thinking + tool_use
-                const chunks = [];
-                for (const block of content) {
-                    if (isObjectLike(block)) {
-                        const blockText = 'type' in block && block.type === 'text' && 'text' in block ? block.text : undefined;
-                        if (isStringValue(blockText) && blockText.trim()) {
-                            chunks.push(blockText.trim());
-                        }
-                    }
-                }
-                if (chunks.length > 0) {
-                    turns.push({ role: 'assistant', text: chunks.join('\n') });
-                }
+        const turn = copilotTurn(entry) ?? claudeCodeTurn(entry) ?? codexTurn(entry);
+        if (turn !== null)
+            turns.push(turn);
+    }
+    return turns;
+}
+/** The turn a Claude Code `user` or `assistant` line carries; null for any other line or one with no human or reply text. */
+function claudeCodeTurn(entry) {
+    if (entry.type !== 'user' && entry.type !== 'assistant')
+        return null;
+    const message = 'message' in entry && isObjectLike(entry.message) ? entry.message : undefined;
+    if (!message)
+        return null;
+    const content = 'content' in message ? message.content : undefined;
+    if (entry.type === 'user') {
+        const text = humanUserText(entry, message);
+        return text ? { role: 'user', text } : null;
+    }
+    if (!Array.isArray(content))
+        return null;
+    // Keep assistant text blocks; drop thinking + tool_use
+    const chunks = [];
+    for (const block of content) {
+        if (isObjectLike(block)) {
+            const blockText = 'type' in block && block.type === 'text' && 'text' in block ? block.text : undefined;
+            if (isStringValue(blockText) && blockText.trim()) {
+                chunks.push(blockText.trim());
             }
+        }
+    }
+    return chunks.length > 0 ? { role: 'assistant', text: chunks.join('\n') } : null;
+}
+// Codex rollout transcript shape: response_item -> payload.message
+function codexTurn(entry) {
+    if (entry.type !== 'response_item')
+        return null;
+    const payload = 'payload' in entry && isObjectLike(entry.payload) ? entry.payload : undefined;
+    if (!payload || !('type' in payload) || payload.type !== 'message')
+        return null;
+    const role = 'role' in payload ? payload.role : undefined;
+    const content = 'content' in payload ? payload.content : undefined;
+    if (!Array.isArray(content))
+        return null;
+    const chunks = [];
+    for (const block of content) {
+        if (!isObjectLike(block))
             continue;
+        const blockType = 'type' in block ? block.type : undefined;
+        const blockText = 'text' in block ? block.text : undefined;
+        if (role === 'user' && blockType === 'input_text' && isStringValue(blockText) && blockText.trim()) {
+            chunks.push(blockText.trim());
         }
-        // Codex rollout transcript shape: response_item -> payload.message
-        if (entry.type === 'response_item') {
-            const payload = 'payload' in entry && isObjectLike(entry.payload) ? entry.payload : undefined;
-            if (!payload || !('type' in payload) || payload.type !== 'message')
-                continue;
-            const role = 'role' in payload ? payload.role : undefined;
-            const content = 'content' in payload ? payload.content : undefined;
-            if (!Array.isArray(content))
-                continue;
-            const chunks = [];
-            for (const block of content) {
-                if (!isObjectLike(block))
-                    continue;
-                const blockType = 'type' in block ? block.type : undefined;
-                const blockText = 'text' in block ? block.text : undefined;
-                if (role === 'user' && blockType === 'input_text' && isStringValue(blockText) && blockText.trim()) {
-                    chunks.push(blockText.trim());
-                }
-                if (role === 'assistant' && blockType === 'output_text' && isStringValue(blockText) && blockText.trim()) {
-                    chunks.push(blockText.trim());
-                }
-            }
-            if (chunks.length === 0)
-                continue;
-            if (role === 'user')
-                turns.push({ role: 'user', text: chunks.join('\n') });
-            if (role === 'assistant')
-                turns.push({ role: 'assistant', text: chunks.join('\n') });
+        if (role === 'assistant' && blockType === 'output_text' && isStringValue(blockText) && blockText.trim()) {
+            chunks.push(blockText.trim());
         }
     }
-    return turns;
+    if (chunks.length === 0)
+        return null;
+    if (role === 'user')
+        return { role: 'user', text: chunks.join('\n') };
+    if (role === 'assistant')
+        return { role: 'assistant', text: chunks.join('\n') };
+    return null;
 }
 export function summariseTranscript(jsonl) {
     return summariseSessionTurns(collectSessionTurns(jsonl));
@@ -124,8 +120,8 @@ export function summariseTranscript(jsonl) {
 /** The last 20 user turns and last 10 replies: session-end is about what was decided near the end, not at the start. */
 export function sessionTail(turns) {
     return {
-        users: turns.filter((t) => t.role === 'user').map((t) => t.text).slice(-20),
-        assistants: turns.filter((t) => t.role === 'assistant').map((t) => t.text).slice(-10),
+        users: turns.filter((t) => t.role === 'user').map((t) => t.text).slice(-RECENT_USER_TURNS),
+        assistants: turns.filter((t) => t.role === 'assistant').map((t) => t.text).slice(-RECENT_ASSISTANT_TURNS),
     };
 }
 export function summariseSessionTurns(turns) {
@@ -143,32 +139,16 @@ export function summariseSessionTurns(turns) {
         tailAssistants.join('\n\n'),
     ].join('\n');
 }
-/**
- * Resolve a transcript path for `--last-session`.
- *
- * Priority, where the first source present is the only one tried:
- *   1. Explicit `transcriptPath` option (from `--transcript <path>`)
- *   2. Stdin JSON payload (Claude Code / OpenCode SessionEnd hook shape)
- *   3. Most recent `.jsonl` under `<claude config dir>/projects/<any>/` (`~/.claude` unless CLAUDE_CONFIG_DIR is set), only when the caller passes `mayScan` (only the caller knows it is not a hook) and there is no path and no stdin text, because this scan spans every project on the box
- *
- * Returns null when nothing resolves, a named transcript or payload whose file is missing included. Never throws.
- */
+/** Resolve a transcript path for `--last-session`: `transcriptPath`, then the stdin JSON payload, then the newest `.jsonl` in the Claude config dir.
+ *  The scan runs only with `mayScan` (it spans every project on the box); returns null when nothing resolves, never throws. */
 export function resolveLastSessionTranscript(explicit, stdinText, opts) {
     if (explicit)
         return fs.existsSync(explicit) ? explicit : null;
     if (stdinText && stdinText.trim() !== '') {
-        try {
-            const payload = JSON.parse(stdinText);
-            if (isObjectLike(payload) && 'transcript_path' in payload) {
-                const tp = payload.transcript_path;
-                if (isStringValue(tp) && fs.existsSync(tp))
-                    return tp;
-            }
-        }
-        catch {
-            // not JSON, but still a payload, so no scan
-        }
-        return null;
+        const receipt = readSessionEnd(stdinText, false);
+        // A refused payload is still a payload, so no scan.
+        const tp = receipt.status === 'received' ? receipt.input.transcriptPath : null;
+        return tp !== null && fs.existsSync(tp) ? tp : null;
     }
     if (!opts.mayScan)
         return null;

package/dist/capture/working-state.d.ts

@@ -1,7 +1,4 @@
 import type { TaskSnapshot } from '../store/rows.js';
-export declare const PRE_COMPACT_TASK_CAP = 200;
-export declare const PRE_COMPACT_SUMMARY_CAP = 2000;
-export declare const PRE_COMPACT_NEXT_STEP_CAP = 500;
 /** The longest each field of {@link transcriptWorkingState} can be, so a check of a sent working state imports these instead of copying them. */
 export declare const WORKING_STATE_CAPS: {
     readonly task: 200;

package/dist/capture/working-state.js

@@ -1,14 +1,14 @@
 // A session's working state read from its transcript tail, with no store in the imports, so a hook with no store can derive it.
 import * as fs from 'fs';
-import { maskEmails, redactSecretsStrict } from '../secret-detect.js';
-import { isObjectLike, isStringValue } from '../capture-contract.js';
-import { errorMessage } from '../log.js';
-import { PRE_COMPACT_TAIL_BYTES, readTranscriptTail, truncateCodePointSafe } from '../transcript-tail.js';
+import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
+import { isObjectLike, isStringValue } from '../core/capture-contract.js';
+import { errorMessage } from '../util/log.js';
+import { PRE_COMPACT_TAIL_BYTES, readTranscriptTail, truncateCodePointSafe } from '../util/transcript-tail.js';
 import { humanUserText, summariseTranscript } from './transcript.js';
 import { copilotTurn } from './copilot-transcript.js';
-export const PRE_COMPACT_TASK_CAP = 200;
-export const PRE_COMPACT_SUMMARY_CAP = 2000;
-export const PRE_COMPACT_NEXT_STEP_CAP = 500;
+const PRE_COMPACT_TASK_CAP = 200;
+const PRE_COMPACT_SUMMARY_CAP = 2000;
+const PRE_COMPACT_NEXT_STEP_CAP = 500;
 const TRIM_MARKER = '[...earlier turns trimmed]\n';
 /** The longest each field of {@link transcriptWorkingState} can be, so a check of a sent working state imports these instead of copying them. */
 export const WORKING_STATE_CAPS = {

package/dist/cli/api-context.d.ts

@@ -0,0 +1,3 @@
+import { type HippoDbContext } from '../api/index.js';
+export declare function cliApiContext(hippoRoot: string, tenantId: string): HippoDbContext;
+//# sourceMappingURL=api-context.d.ts.map

package/dist/cli/api-context.js

@@ -0,0 +1,6 @@
+import { adminActor } from '../api/index.js';
+// The one place the CLI names its audit actor; root is a parameter because some verbs target the global store.
+export function cliApiContext(hippoRoot, tenantId) {
+    return { hippoRoot, tenantId, actor: adminActor('cli') };
+}
+//# sourceMappingURL=api-context.js.map

package/dist/cli/audit-prune.d.ts

@@ -0,0 +1,28 @@
+/** Audit log retention pruning: opt-in per tenant because retention floors (HIPAA, SOX, GDPR) apply.
+ * The audit_prune row is written after the DELETE, so a call never prunes its own record. */
+export interface PruneAuditOpts {
+    /** Cutoff in days. Rows with `ts < (now - N days)` are deleted. */
+    olderThanDays: number;
+    /** Tenant scope. Required: prune is always tenant-scoped. */
+    tenantId: string;
+    /** When true, count matching rows but do NOT delete. Default false. */
+    dryRun?: boolean;
+    /** Actor recording the prune in the audit trail. Default 'cli'. */
+    actor?: string;
+}
+export interface PruneAuditResult {
+    /** ISO timestamp of the cutoff. Rows with ts strictly less than this were deleted. */
+    cutoff: string;
+    /** Number of audit_log rows deleted (or that would be deleted, if dryRun). */
+    count: number;
+    /** Echo back whether this was a dry run. */
+    dryRun: boolean;
+}
+/** Cutoff ISO timestamp for N days ago; exported so tests can pin "now" without mocking Date. */
+export declare function computeCutoff(days: number, now?: Date): string;
+/** Delete audit_log rows older than `olderThanDays` for `tenantId`, emitting an `audit_prune` event.
+ * Throws on non-positive days or a missing tenantId. */
+export declare function pruneAuditLog(hippoRoot: string, opts: PruneAuditOpts): PruneAuditResult;
+/** Parse `--older-than`: bare integer days (`30`) or with a `d` suffix (`30d`); throws on any other format. */
+export declare function parseOlderThanFlag(raw: string): number;
+//# sourceMappingURL=audit-prune.d.ts.map