hippo-memory 1.59.0 → 1.61.0

package/dist/capture.js

@@ -1,1293 +0,0 @@
-/**
- * Capture actionable items from conversation text.
- *
- * Uses heuristic pattern matching (no LLM) to extract:
- *   - Decisions ("we decided", "let's do", "going with")
- *   - Specs / requirements (bullet lists after spec/feature/plan headings)
- *   - Rules / constraints ("never", "always", "the rule is", "must")
- *   - Errors / gotchas ("error:", "bug:", "gotcha:", "watch out")
- *   - Preferences ("prefer", "use X instead of Y", "don't use")
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { createMemory, Layer } from './memory.js';
-import { duplicateKey, storedTextKeys } from './same-text.js';
-import { isContentWorthStoring } from './audit.js';
-import { isInitialized, openStore, stampOriginProject, writeEntryMirrors, loadAllEntries, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, } from './store.js';
-import { gatedWrite } from './gated-write.js';
-import { PRE_COMPACT_INSTRUCTION, compactionOrigin, parsePostCompactPayload, postCompactLine, recordCompactionStart, recordSnapshotSaved, saveCompaction, replayCompactionsAt, COMPACTION_DB_WAIT_MS, } from './compaction-record.js';
-import { getGlobalRoot, initGlobal } from './shared.js';
-import { embedMemory } from './embeddings.js';
-import { resolveTenantId } from './tenant.js';
-import { defaultPreCompactLogPath } from './hooks.js';
-import { maskEmails, redactSecretsStrict } from './secret-detect.js';
-import { RejectedValueError, checkRejectionGuard } from './rejection.js';
-import { openHippoDb, closeHippoDb } from './db.js';
-import { loadConfig } from './config.js';
-import { classifyOriginProject } from './project-identity.js';
-import { isObjectLike, isStringValue, readClaudeCodePreCompact } from './capture-contract.js';
-// Sentence-level patterns
-//
-// T1 (DF2): each pattern now carries TWO capture groups — group 1 is the
-// discriminating keyword (plus its trailing separator, verbatim), group 2 is
-// the content that follows it. Previously only the after-keyword content was
-// captured, so a negation like "never" / "must not" was discarded and a
-// prohibition inverted into an instruction ("Never use X" stored as "use X").
-// `extractFromPatterns` reassembles group1 + a clause-bounded group2 (T2, via
-// `boundToClause` below) rather than reading a single fixed-width group —
-// group 2's own reach is widened to {1,500} because the true stopping point
-// is now found by content, not counted characters. Keeping the keyword in
-// its own group (rather than folding it into one bigger capture) matters:
-// `boundToClause` must scan for a clause boundary only in group 2, never in
-// group 1 — several keywords end in their own colon ("error:", "rule:",
-// "decision:") which is not a clause boundary in the prose sense and would
-// wrongly truncate the capture down to just the keyword if scanned.
-// `PREFERENCE_PATTERNS[0]` is the one exception — its two-capture-group
-// shape means something different (two content spans either side of
-// "instead of"/"over"/"not") and is a separate, backlogged defect (see
-// docs/plans/2026-08-23-df2-capture-anchoring.md); left as-is.
-const DECISION_PATTERNS = [
-    /(?:we(?:'ve| have)?|i(?:'ve| have)?|let's)\s+(decid(?:ed|e)\s+(?:to\s+)?)(.{1,500})/i,
-    /(?:let's|we(?:'ll| will| should)?)\s+((?:go with|do|use|try|build|implement|switch to)\s+)(.{1,500})/i,
-    /((?:going|went)\s+with\s+)(.{1,500})/i,
-    /((?:the plan is|plan:)\s+)(.{1,500})/i,
-    /(decision:\s*)(.{1,500})/i,
-];
-const RULE_PATTERNS = [
-    /\b((?:never|always|must(?:\s+not)?|do(?:n't| not)\s+ever)\s+)(.{1,500})/i,
-    /((?:the rule is|rule:)\s*)(.{1,500})/i,
-    /((?:important|critical|remember):\s*)(.{1,500})/i,
-    /((?:make sure|ensure)\s+(?:to\s+)?)(.{1,500})/i,
-];
-const ERROR_PATTERNS = [
-    /((?:error|bug|gotcha|watch out|careful|warning|caveat|trap):\s*)(.{1,500})/i,
-    /((?:this broke|this breaks|this will break|broke because)\s+)(.{1,500})/i,
-    /((?:the (?:issue|problem|fix) (?:is|was))\s+)(.{1,500})/i,
-    /((?:don't forget|easy to miss):\s*)(.{1,500})/i,
-];
-// PREFERENCE_PATTERNS[0] keeps its pre-DF2 two-capture-group shape
-// (match[1]-only, unbounded) — out of scope here, backlogged. See
-// extractFromPatterns' reference check against this exact array element.
-const PREFERENCE_PATTERNS = [
-    /(?:prefer|use)\s+(.{5,100})\s+(?:instead of|over|not)\s+(.{3,100})/i,
-    /((?:don't use|avoid|skip)\s+)(.{1,500})/i,
-    /((?:we(?:'re| are)\s+using|the stack is|we use)\s+)(.{1,500})/i,
-];
-// Heading patterns that signal a following list of specs/requirements
-const SPEC_HEADING_PATTERNS = [
-    /^#+\s*(?:features?|requirements?|specs?|specifications?|plan|design|architecture|interface|api|todo|tasks?|implementation|notes?)(?:\s|:|$)/i,
-    /^(?:features?|requirements?|specs?|specifications?|plan|design|tasks?|implementation)(?:\s*:|$)/i,
-];
-// ---------------------------------------------------------------------------
-// Extraction engine
-// ---------------------------------------------------------------------------
-export function splitSentences(text) {
-    // Split on sentence boundaries, keeping reasonable chunks
-    return text
-        .split(/(?<=[.!?])\s+|\n/)
-        .map((s) => s.trim())
-        .filter((s) => s.length > 5);
-}
-/**
- * T2 (DF2): bound a keyword+content capture to its clause instead of a fixed
- * character count. `full` is `keywordPrefix + content` (already concatenated
- * so the 200-char ceiling below applies to the whole stored string, not just
- * the part after the keyword); `searchFrom` is `keywordPrefix.length`, so the
- * clause/terminator scan only ever looks INSIDE `content` — several keywords
- * end in their own colon ("error:", "rule:", "decision:") which must never
- * be mistaken for a clause boundary in the prose that follows.
- *
- * Stops at the first `,`/`;`/`:` followed by whitespace, or at a sentence
- * terminator `[.!?]` followed by whitespace or end-of-string — whichever
- * comes first — and never past `maxLen` chars total.
- *
- * The whitespace requirement on the terminator is load-bearing: a bare
- * `[.!?]` would split inside a token like `.env` / `capture.ts` / `v1.35.0`,
- * turning a full clause into a fragment that then fails the write gate and
- * is silently dropped (measured in the plan). The `maxLen` ceiling is also
- * load-bearing: without it, a clause-free span can run past the 500-char
- * gate in `extractFromPatterns` and the whole match is dropped, where today
- * it is truncated and stored.
- */
-/**
- * Does a plausible CLOSING single quote appear after `from`? Mirror of the
- * opener rule in `boundToClause`: a closer sits tight against the literal it
- * ends (non-whitespace before) and is followed by whitespace, punctuation, or
- * end-of-string - never by a letter, which is what makes "user's" an
- * apostrophe rather than a partner.
- */
-function isLetterOrDigit(ch) {
-    return ch !== undefined && /[\p{L}\p{N}]/u.test(ch);
-}
-function lastCloserIndex(full) {
-    // ONE pass, not one per apostrophe. The previous shape rescanned the whole
-    // remaining suffix at every boundary apostrophe, so a transcript full of
-    // elisions ("keep 'em", "wait 'til", ...) made extraction quadratic and
-    // could stall a moderately sized capture. Codex P2, r7.
-    //
-    // A quote CLOSES THE SIDE IT IS TIGHT AGAINST. The test needs both
-    // neighbours, and one round proved that empirically: these two have the
-    // same following character and opposite roles -
-    //   "preserve 'a, b'-style"   next '-'  -> CLOSER, content on the left
-    //   "then run '--force,"      next '-'  -> OPENER, content on the right
-    // so no forward-only rule can separate them. An earlier revision tried
-    // exactly that and broke in both directions at once (codex P1+P2, r10):
-    // it missed closers before token-joining punctuation and accepted
-    // "'.env" as a closer because a dot happened to be in its class.
-    //
-    //   never a closer   next is a letter/digit      "user's", "keep 'em"
-    //   closer           prev is non-whitespace      "'a, b' to", "'a, b'-style"
-    //   closer           next is whitespace or end   "preserve 'a, b ' exactly"
-    //   closer           next is clause punctuation  "preserve 'a, b ', then"
-    //                    that itself ends the token
-    //
-    // The last clause is what separates ", " from ".env": a dot followed by a
-    // letter joins a filename, a dot followed by space ends a sentence.
-    for (let j = full.length - 1; j >= 0; j--) {
-        if (full[j] !== "'")
-            continue;
-        const prev = full[j - 1];
-        const next = full[j + 1];
-        if (isLetterOrDigit(next))
-            continue;
-        // "tight against content" excludes an OPENING delimiter: in
-        // "call parse('--force" the paren is non-whitespace but the quote after
-        // it is an opener, and treating it as a closer let an earlier elision
-        // pair across the clause boundary. Codex P2, r11.
-        const tightBefore = prev !== undefined && !/[\s([{]/.test(prev);
-        const endsAfter = next === undefined || /\s/.test(next);
-        // Punctuation splits in two, and this is the fact the last three
-        // revisions kept rediscovering piecemeal:
-        //   , ; : ! ? ) ] }  never join tokens - they end the literal whatever
-        //                    follows, so "'echo a, b ';then" closes at the ;
-        //   . - _ / @ #      DO join tokens - "'.env" and "'--force" continue a
-        //                    filename or flag, so these only close when trailed
-        //                    by whitespace
-        const afterNext = full[j + 2];
-        const closesRegardless = next !== undefined && /[,;:!?)\]}]/.test(next);
-        const joinerThenSpace = next !== undefined && /[.\-_/@#]/.test(next) &&
-            (afterNext === undefined || /\s/.test(afterNext));
-        if (tightBefore || endsAfter || closesRegardless || joinerThenSpace)
-            return j;
-    }
-    return -1;
-}
-function boundToClause(full, searchFrom, maxLen = 200) {
-    // Scan for the first PROSE clause boundary after `searchFrom`.
-    //
-    // Depth-awareness is not a nicety here: hippo memories are full of code, and
-    // a naive scan reintroduces the exact fragment defect this whole change
-    // exists to remove. Measured before this guard existed:
-    //   "Always call build(x, y) before deploy."  ->  "Always call build(x"
-    //   "Never pass {a: 1, b: 2} to the writer."  ->  "Never pass {a"
-    // Both then PASS the write gate, because they contain code punctuation and
-    // so read as "specific" — a malformed fragment stored with high confidence.
-    // Codex review finding (P1) on this branch.
-    //
-    // So: a separator only ends the clause at bracket depth zero and outside
-    // quotes. Unbalanced closers are tolerated (depth floors at 0) because
-    // captured text often starts mid-expression.
-    const lastCloser = lastCloserIndex(full);
-    let depth = 0;
-    let quote = null;
-    let cutEnd = full.length;
-    for (let i = searchFrom; i < full.length; i++) {
-        const ch = full[i];
-        if (quote) {
-            // Closing uses the SAME shape test as opening. This was asymmetric:
-            // twelve rounds went into deciding when a quote OPENS a literal, while
-            // the close accepted any bare "'" - so the apostrophe in a possessive
-            // INSIDE a literal closed it early:
-            //   "Always pass 'user's a, b list' to the parser."
-            //     -> "Always pass 'user's a"   (master kept the whole literal)
-            // a mid-literal fragment that then PASSES the write gate, which is
-            // precisely the defect this branch exists to remove. Found by the
-            // ship-gate review after every earlier gate missed it.
-            if (ch === quote && (quote !== "'" || !isLetterOrDigit(full[i + 1]))) {
-                quote = null;
-            }
-            continue;
-        }
-        // Quote handling has to tell an APOSTROPHE from a single-quoted
-        // LITERAL, because getting either wrong reintroduces the fragment
-        // defect this change exists to remove, and both fragments PASS the
-        // write gate (code punctuation reads as "specific"):
-        //   treat every ' as a quote  -> "Always ensure it's enabled, then
-        //     restart..." never leaves quote mode, bounding disabled entirely
-        //   treat no ' as a quote     -> "Always pass 'a, b' to the parser."
-        //     cuts at the comma and stores "Always pass 'a"
-        // Both were codex P1s on this branch, in consecutive rounds.
-        //
-        // Discriminator: a ' OPENS a literal only at a word boundary - preceded
-        // by start/whitespace/open-bracket AND followed by non-whitespace. An
-        // in-word apostrophe ("it's", "user's") has letters on both sides and is
-        // just a character.
-        if (ch === '"' || ch === '`') {
-            quote = ch;
-            continue;
-        }
-        if (ch === "'") {
-            const prev = i > 0 ? full[i - 1] : undefined;
-            const next = full[i + 1];
-            const atBoundary = (prev === undefined || /[\s([{]/.test(prev)) &&
-                next !== undefined && !/\s/.test(next);
-            // Pairing is VERIFIED, not assumed. A word-boundary test alone still
-            // opens quote mode on elided forms ("keep 'em", "wait 'til"), which
-            // have no closer, so the scanner never leaves quote mode and bounding
-            // is disabled for the rest of the capture. Requiring an actual closing
-            // quote later in the string replaces a guess with a checkable fact -
-            // an elided form simply has no partner. Codex P2, this round.
-            // ...and the partner must LOOK like a closer, not merely be another
-            // apostrophe. Distance cannot separate the two cases - both put a `'`
-            // far downstream:
-            //   "Always pass '<600-char literal>' to the parser"  -> the far ' IS
-            //     the closer, and pairing must succeed
-            //   "keep 'em enabled, then <520 chars> check user's config" -> the far
-            //     ' is in-word, and pairing against it re-opens quote mode on the
-            //     elision, disabling bounding for the rest of the capture
-            // So apply the SAME shape rule already used to open a literal, mirrored:
-            // a closer has non-whitespace before it and whitespace/punctuation (not
-            // a letter) after. "user's" fails it on both counts. Codex P2, r6.
-            if (atBoundary && lastCloser > i) {
-                quote = ch;
-            }
-            continue;
-        }
-        if (ch === '(' || ch === '[' || ch === '{') {
-            depth++;
-            continue;
-        }
-        if (ch === ')' || ch === ']' || ch === '}') {
-            if (depth > 0)
-                depth--;
-            continue;
-        }
-        if (depth > 0)
-            continue;
-        const next = full[i + 1];
-        // Prose clause separator: , ; : followed by whitespace.
-        if ((ch === ',' || ch === ';' || ch === ':') && next !== undefined && /\s/.test(next)) {
-            cutEnd = i;
-            break;
-        }
-        // Sentence terminator, but only when followed by whitespace or end — a
-        // bare [.!?] splits inside .env, capture.ts, v1.35.0.
-        if ((ch === '.' || ch === '!' || ch === '?') && (next === undefined || /\s/.test(next))) {
-            cutEnd = i + 1;
-            break;
-        }
-    }
-    let bounded = full.slice(0, cutEnd);
-    if (bounded.length > maxLen)
-        bounded = bounded.slice(0, maxLen);
-    return bounded;
-}
-function cleanExtract(raw) {
-    let content = raw
-        .replace(/^[:\s-]+/, '')
-        .replace(/[.!?,;:\s]+$/, '')
-        .trim();
-    // T2 trailing cleanup: clause-bounding can cut inside a parenthetical and
-    // leave an unmatched trailing ')' (e.g. "...(two had never got entries),"
-    // bounds to "never got entries)"). Strip a trailing ')' ONLY while closes
-    // outnumber opens in the string so far — a balanced parenthetical like
-    // "always run the suite (twice)" must be left intact.
-    while (content.endsWith(')')) {
-        const opens = (content.match(/\(/g) ?? []).length;
-        const closes = (content.match(/\)/g) ?? []).length;
-        if (closes <= opens)
-            break;
-        content = content
-            .slice(0, -1)
-            .replace(/[.!?,;:\s]+$/, '')
-            .trim();
-    }
-    return content;
-}
-/** The 500-char write gate minus the 200-char bound counted from the keyword. */
-const RULE_LEAD_CAP = 300;
-/** A modal rule keeps its subject ("We must never ..."); null keeps the keyword-start form when the lead is long or the keyword sits inside a bracket. */
-function ruleLead(sentence, keywordStart, contentStart) {
-    if (keywordStart < 0 || contentStart < 0 || contentStart > RULE_LEAD_CAP)
-        return null;
-    let depth = 0;
-    for (const ch of sentence.slice(0, keywordStart)) {
-        if (ch === '(' || ch === '[' || ch === '{')
-            depth++;
-        else if ((ch === ')' || ch === ']' || ch === '}') && depth > 0)
-            depth--;
-    }
-    return depth > 0 ? null : sentence.slice(0, contentStart);
-}
-function extractFromPatterns(sentence, patterns, category, tag) {
-    for (const pat of patterns) {
-        // `d` gives per-group offsets; see the contentStart comment below.
-        const dpat = pat.flags.includes('d') ? pat : new RegExp(pat.source, pat.flags + 'd');
-        const match = dpat.exec(sentence);
-        if (match) {
-            let bounded;
-            if (pat === PREFERENCE_PATTERNS[0]) {
-                // PREFERENCE_PATTERNS[0] is the one pattern left out of T1/T2 (see
-                // comment at its definition) — its match[1] keeps its pre-DF2,
-                // unbounded shape rather than going through clause-bounding.
-                bounded = match[1] ?? match[0];
-            }
-            else {
-                // group1 = keyword + separator (verbatim, never clause-bounded);
-                // group2 = the content that follows it (clause-bounded below).
-                //
-                // T1 preserves the keyword only when it carries SEMANTIC SIGN — a
-                // negation or modality ("never", "must not", "do not ever",
-                // "always"). Dropping those inverts the meaning, which is the whole
-                // point of T1. A LABEL keyword ("decision:", "rule:", "error:",
-                // "important:") carries no sign: it only names the category, which
-                // is already recorded in `category`/`tags`, so prefixing it onto the
-                // content is duplication that also breaks value-keyed matching
-                // (AT1's rejected-value digest hashes the bare content).
-                // Discriminator: a label ends in its own colon, or is a "the X is"
-                // phrase.
-                const rawPrefix = match[1] ?? '';
-                // ONLY colon-terminated labels are dropped. Dropping "the X is/was"
-                // too left the residue starting with "to ", which isFragment then
-                // rejected outright - so "The plan is to ship on Friday" and "The fix
-                // was to bump the pool timeout" stored NOTHING, where every prior
-                // version stored them. Silent loss on two of the highest-traffic
-                // patterns, and invisible: an absent memory leaves no trace. The AT1
-                // rejected-value evidence only ever involved colon labels
-                // ("decision: "), so the narrower rule keeps that guarantee.
-                const isLabelPrefix = /:\s*$/.test(rawPrefix);
-                const keywordPrefix = isLabelPrefix ? '' : rawPrefix;
-                // Scan the UNTRUNCATED remainder, not match[2]. The patterns cap
-                // their content group at 500 chars, so a quoted literal whose closer
-                // sits past that point had no visible partner and the pairing check
-                // read the opener as prose - cutting inside the literal. That was a
-                // blindness built into the scanner's INPUT, not a bad predicate, so
-                // no further predicate could have fixed it. boundToClause already
-                // caps its OUTPUT at maxLen, so widening the input costs nothing and
-                // makes pairing decidable on the whole sentence. Codex P2, round 5.
-                // Group 2's REAL offset, read from the regex engine. Deriving it as
-                // `match.index + rawPrefix.length` assumes group 1 starts the match,
-                // but DECISION_PATTERNS carry an uncaptured subject ("we ", "let's ")
-                // ahead of it - so the offset landed inside the keyword and the
-                // widened slice duplicated text: "We decided to pin..." stored as
-                // "decided to to pin...". Real corruption of the commonest decision
-                // capture, shipped in the previous commit. Codex P1, r6.
-                const contentStart = match.indices?.[2]?.[0] ?? -1;
-                const afterKeyword = contentStart >= 0 ? sentence.slice(contentStart) : (match[2] ?? match[0]);
-                const keywordStart = match.indices?.[1]?.[0] ?? -1;
-                const lead = pat === RULE_PATTERNS[0] ? ruleLead(sentence, keywordStart, contentStart) : null;
-                bounded = lead !== null
-                    ? boundToClause(lead + afterKeyword, lead.length, keywordStart + 200)
-                    : boundToClause(keywordPrefix + afterKeyword, keywordPrefix.length);
-            }
-            const content = cleanExtract(bounded);
-            if (content.length >= 8 && content.length <= 500) {
-                return { content, category, tags: [tag, 'captured'] };
-            }
-        }
-    }
-    return null;
-}
-/** Extract spec items from bullet lists that follow spec-like headings. */
-function extractSpecSections(text) {
-    const items = [];
-    const lines = text.split('\n');
-    let inSpecSection = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Check if this line is a spec heading
-        if (SPEC_HEADING_PATTERNS.some((p) => p.test(trimmed))) {
-            inSpecSection = true;
-            continue;
-        }
-        // Another heading resets the section
-        if (/^#+\s/.test(trimmed) || /^[A-Z][a-z]+:$/.test(trimmed)) {
-            inSpecSection = false;
-            continue;
-        }
-        // Blank line after non-bullet content ends section
-        if (!trimmed && inSpecSection) {
-            // Keep going, blank lines within spec sections are ok
-            continue;
-        }
-        if (inSpecSection) {
-            const bulletMatch = trimmed.match(/^[-*]\s+(.+)/) || trimmed.match(/^\d+\.\s+(.+)/);
-            if (bulletMatch) {
-                const content = bulletMatch[1].trim();
-                if (content.length >= 8 && content.length <= 500) {
-                    items.push({
-                        content,
-                        category: 'spec',
-                        tags: ['spec', 'captured'],
-                    });
-                }
-            }
-        }
-    }
-    return items;
-}
-/**
- * Main extraction function. Scans text for actionable items using heuristics.
- */
-export function extractFromText(text) {
-    const items = [];
-    const seen = new Set();
-    const addIfNew = (item) => {
-        const norm = duplicateKey(item.content);
-        if (seen.has(norm))
-            return;
-        if (!isContentWorthStoring(item.content))
-            return;
-        seen.add(norm);
-        items.push(item);
-    };
-    // 1. Extract spec sections (bullet lists under spec headings)
-    for (const item of extractSpecSections(text)) {
-        addIfNew(item);
-    }
-    // 2. Pattern-match on individual sentences
-    const sentences = splitSentences(text);
-    for (const sentence of sentences) {
-        // Try each category in priority order
-        const decision = extractFromPatterns(sentence, DECISION_PATTERNS, 'decision', 'decision');
-        if (decision) {
-            addIfNew(decision);
-            continue;
-        }
-        const rule = extractFromPatterns(sentence, RULE_PATTERNS, 'rule', 'rule');
-        if (rule) {
-            addIfNew(rule);
-            continue;
-        }
-        const error = extractFromPatterns(sentence, ERROR_PATTERNS, 'error', 'error');
-        if (error) {
-            addIfNew(error);
-            continue;
-        }
-        const preference = extractFromPatterns(sentence, PREFERENCE_PATTERNS, 'preference', 'preference');
-        if (preference) {
-            addIfNew(preference);
-            continue;
-        }
-    }
-    return items;
-}
-/** Message for a caught value of unknown shape. `cause` names the sanctioned unknown-input case (error-cause enrichment). */
-export function errorMessage(cause) {
-    return cause instanceof Error ? cause.message : String(cause);
-}
-/**
- * Build a compact text summary from a Claude Code / OpenCode JSONL transcript.
- * Keeps plain user messages and the final chunk of assistant text, drops
- * thinking blocks, tool_use, and tool_result noise. Output is fed to the
- * existing `extractFromText` pipeline.
- *
- * 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) {
-    if (entry.isMeta === true || entry.isSidechain === true || entry.isCompactSummary === true || entry.promptSource === 'system')
-        return true;
-    const head = content.trimStart();
-    return CLAUDE_CODE_COMMAND_PREFIXES.some((p) => head.startsWith(p));
-}
-const NON_HUMAN_BLOCK_PREFIXES = ['<ide_', '[Request interrupted by user'];
-/** The human's words on a Claude Code user line, '' when none; VS Code stores prompts as text blocks, beside its own open-file, selection and interrupt blocks. */
-function humanUserText(entry, message) {
-    const content = message.content;
-    let text = '';
-    if (isStringValue(content)) {
-        text = content;
-    }
-    else if (Array.isArray(content) && !content.some((b) => isObjectLike(b) && 'type' in b && b.type === 'tool_result')) {
-        const parts = [];
-        for (const block of content) {
-            const blockText = isObjectLike(block) && 'type' in block && block.type === 'text' && 'text' in block ? block.text : undefined;
-            if (isStringValue(blockText) && !NON_HUMAN_BLOCK_PREFIXES.some((p) => blockText.trimStart().startsWith(p)))
-                parts.push(blockText);
-        }
-        text = parts.join('\n');
-    }
-    text = text.trim();
-    return text && !isNonHumanUserLine(entry, text) ? text : '';
-}
-export function collectSessionTurns(jsonl, visit) {
-    const lines = jsonl.split('\n').filter((l) => l.trim());
-    const turns = [];
-    for (const line of lines) {
-        let entry;
-        try {
-            entry = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        if (!isObjectLike(entry) || !('type' in entry))
-            continue;
-        visit?.(entry);
-        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') });
-                }
-            }
-            continue;
-        }
-        // 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') });
-        }
-    }
-    return turns;
-}
-export function summariseTranscript(jsonl) {
-    return summariseSessionTurns(collectSessionTurns(jsonl));
-}
-function summariseSessionTurns(turns) {
-    const userMessages = turns.filter((t) => t.role === 'user').map((t) => t.text);
-    const assistantTexts = turns.filter((t) => t.role === 'assistant').map((t) => t.text);
-    if (userMessages.length === 0 && assistantTexts.length === 0)
-        return '';
-    // Keep the tail: last ~20 user turns and last ~10 assistant replies.
-    // Session-end is about what was decided near the end, not at the start.
-    const tailUsers = userMessages.slice(-20);
-    const tailAssistants = assistantTexts.slice(-10);
-    return [
-        '# Session Summary',
-        '',
-        '## User Messages',
-        ...tailUsers.map((m) => `- ${m.replace(/\s+/g, ' ').slice(0, 500)}`),
-        '',
-        '## Assistant Responses',
-        ...tailAssistants.map((t) => t.slice(0, 2000)),
-    ].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/projects/<any>/`, 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.
- */
-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;
-    }
-    if (!opts.mayScan)
-        return null;
-    const home = process.env.HOME || process.env.USERPROFILE;
-    if (!home)
-        return null;
-    const projectsDir = path.join(home, '.claude', 'projects');
-    if (!fs.existsSync(projectsDir))
-        return null;
-    let newest = null;
-    try {
-        for (const entry of fs.readdirSync(projectsDir)) {
-            const subDir = path.join(projectsDir, entry);
-            const stat = fs.statSync(subDir);
-            if (!stat.isDirectory())
-                continue;
-            for (const file of fs.readdirSync(subDir)) {
-                if (!file.endsWith('.jsonl'))
-                    continue;
-                const full = path.join(subDir, file);
-                const m = fs.statSync(full).mtimeMs;
-                if (!newest || m > newest.mtime)
-                    newest = { path: full, mtime: m };
-            }
-        }
-    }
-    catch {
-        return null;
-    }
-    return newest?.path ?? null;
-}
-export function cmdCapture(hippoRoot, options) {
-    // Tee stdout/stderr to a log file when --log-file is set. Used by the
-    // SessionEnd hook so output (otherwise swallowed by TUI teardown) surfaces
-    // on the next session start via `hippo last-sleep`. Runs second in the
-    // SessionEnd sequence after `hippo sleep`, so we APPEND rather than
-    // truncate — sleep already wrote its own header + body to this file.
-    const restoreStdio = options.logFile ? beginLogTee(options.logFile) : null;
-    try {
-        cmdCaptureCore(hippoRoot, options);
-        if (options.logFile)
-            console.log('[hippo] capture complete');
-    }
-    catch (err) {
-        if (options.logFile)
-            console.log(`[hippo] capture failed: ${errorMessage(err)}`);
-        throw err;
-    }
-    finally {
-        if (restoreStdio)
-            restoreStdio();
-    }
-}
-/**
- * Append-mode tee: writes a banner line then mirrors every stdout/stderr
- * chunk to `logFile` until the returned restore function is called.
- * Failures to write the log are non-fatal; the real streams still get
- * the data.
- */
-function beginLogTee(logFile) {
-    try {
-        fs.mkdirSync(path.dirname(logFile), { recursive: true });
-        fs.appendFileSync(logFile, `[hippo] ${new Date().toISOString()} capturing session...\n`, 'utf8');
-    }
-    catch (err) {
-        console.error(`[hippo] warning: could not open log file ${logFile}: ${errorMessage(err)}`);
-        return () => { };
-    }
-    const origStdoutWrite = process.stdout.write.bind(process.stdout);
-    const origStderrWrite = process.stderr.write.bind(process.stderr);
-    const tee = (chunk) => {
-        try {
-            const buf = isStringValue(chunk) ? chunk : Buffer.from(chunk).toString('utf8');
-            fs.appendFileSync(logFile, buf, 'utf8');
-        }
-        catch {
-            // log failures are non-fatal
-        }
-    };
-    const wrapWrite = (origWrite) => {
-        const wrapped = (...args) => {
-            tee(args[0]);
-            // SAFETY: forwarding the exact arguments Node's real overloaded
-            // `write` received is safe regardless of which overload the call
-            // site used — Node dispatches on the actual argument shapes at
-            // runtime, and `StreamWriteArgs` is the union of both overloads'
-            // parameter lists.
-            return origWrite(...args);
-        };
-        // SAFETY: `wrapped` matches both real `write` overload shapes it's
-        // assigned to; TS can't verify a single implementation covers an
-        // overloaded type, but this one forwards to the real stream method.
-        return wrapped;
-    };
-    process.stdout.write = wrapWrite(origStdoutWrite);
-    process.stderr.write = wrapWrite(origStderrWrite);
-    return () => {
-        process.stdout.write = origStdoutWrite;
-        process.stderr.write = origStderrWrite;
-    };
-}
-function cmdCaptureCore(hippoRoot, options) {
-    const useGlobal = options.global;
-    const targetRoot = useGlobal ? getGlobalRoot() : hippoRoot;
-    if (useGlobal) {
-        initGlobal();
-    }
-    else {
-        if (!isInitialized(hippoRoot)) {
-            console.error(`No hippo store at ${hippoRoot} (searched ${process.cwd()} and its parents up to your home directory). Run \`hippo init\` first.`);
-            process.exit(1);
-        }
-    }
-    // Read input text
-    let text;
-    switch (options.source) {
-        case 'stdin': {
-            try {
-                text = fs.readFileSync(0, 'utf8');
-            }
-            catch {
-                console.error('No input on stdin. Pipe text in or use --file <path>.');
-                process.exit(1);
-            }
-            break;
-        }
-        case 'file': {
-            if (!options.filePath) {
-                console.error('Missing file path. Usage: hippo capture --file <path>');
-                process.exit(1);
-            }
-            if (!fs.existsSync(options.filePath)) {
-                console.error(`File not found: ${options.filePath}`);
-                process.exit(1);
-            }
-            text = fs.readFileSync(options.filePath, 'utf8');
-            break;
-        }
-        case 'last-session': {
-            let turns = options.sessionTurns;
-            if (!turns) {
-                const resolved = resolveLastSessionTranscript(options.transcriptPath, options.stdinText, { mayScan: !options.stdinTimedOut });
-                if (!resolved) {
-                    console.log('No transcript found. Pass --transcript <path> or run from a SessionEnd hook.');
-                    return;
-                }
-                turns = collectSessionTurns(fs.readFileSync(resolved, 'utf8'));
-            }
-            text = summariseSessionTurns(turns);
-            if (!text) {
-                console.log('Transcript had no user/assistant messages to summarise.');
-                return;
-            }
-            break;
-        }
-    }
-    if (!text || text.trim().length === 0) {
-        console.log('No text to capture from.');
-        return;
-    }
-    // Scrub once here, as the snapshot fields are: every source can carry a pasted token (AGENTS.md: no secrets in memories).
-    const extracted = extractFromText(maskEmails(redactSecretsStrict(text)));
-    if (extracted.length === 0) {
-        console.log('No actionable items found in the input.');
-        return;
-    }
-    // Dedup only against rows this capture's reader sees: another tenant's rows (L9), or another
-    // project's, are hidden from it, so they must not stop its own copy.
-    const stored = loadAllEntries(targetRoot, useGlobal ? undefined : options.tenantId);
-    const origin = options.originProject;
-    const keys = storedTextKeys(origin === undefined
-        ? stored
-        : stored.filter((e) => classifyOriginProject(e.origin_project, origin) !== 'cross-project'));
-    let captured = 0;
-    let skipped = 0;
-    let rejected = 0;
-    const baseHalfLifeDays = loadConfig(targetRoot).defaultHalfLifeDays;
-    // AT1 P2 fix (dry-run parity, docs/plans/2026-08-15-at1-rejected-value-tombstone.md):
-    // dry-run used to skip the guarded write branch ENTIRELY, so a tombstoned
-    // extraction printed as `[capture]` and counted toward `captured` — the
-    // preview lied about what a real run would do. Mirrors importers.ts's
-    // importEntries dry-run probe (commit 6146e82): open a read-only handle
-    // once, run the same checkRejectionGuard the real write path uses via
-    // writeEntry, never write anything.
-    const dryRunDb = options.dryRun ? openHippoDb(targetRoot) : null;
-    const writeDb = options.dryRun ? null : openStore(targetRoot);
-    try {
-        for (const item of extracted) {
-            if (keys.has(duplicateKey(item.content))) {
-                skipped++;
-                if (options.dryRun) {
-                    console.log(`  [skip] (${item.category}) ${item.content.slice(0, 80)}`);
-                }
-                continue;
-            }
-            // A3: kind defaults to 'distilled'. capture.ts extracts curated items from
-            // session output (not raw transcript chunks), so distilled is correct. If a
-            // future variant captures full raw session text, it MUST set kind: 'raw'
-            // and route deletions through archiveRawMemory(). See MEMORY_ENVELOPE.md.
-            // L9: the dedup read above is scoped by options.tenantId — the WRITE
-            // must match, or scoped-dedup-passes-then-default-tenant-write breaks
-            // the per-tenant contract. Mirror the dedup-read guard: when
-            // global: true, the global store is host-wide and tenant is irrelevant
-            // (createMemory's default 'default' applies). When global: false,
-            // options.tenantId scopes the write to the same tenant as the dedup.
-            const created = createMemory(item.content, {
-                layer: Layer.Episodic,
-                tags: item.tags,
-                source: 'capture',
-                confidence: 'observed',
-                tenantId: useGlobal ? undefined : options.tenantId,
-                baseHalfLifeDays,
-            });
-            const entry = options.originProject === undefined ? created : { ...created, origin_project: options.originProject };
-            if (options.dryRun) {
-                if (dryRunDb) {
-                    try {
-                        checkRejectionGuard(dryRunDb, entry.tenantId ?? 'default', entry.id, entry.content);
-                    }
-                    catch (err) {
-                        if (err instanceof RejectedValueError) {
-                            rejected++;
-                            console.log(`  [reject] (${item.category}) ${item.content.slice(0, 80)} - matches a rejected value`);
-                            continue;
-                        }
-                        throw err;
-                    }
-                }
-                console.log(`  [capture] (${item.category}) ${item.content}`);
-            }
-            else if (writeDb !== null) {
-                // AT1 (plan §3 containment): one rejected item must not abort the
-                // rest of this capture's items.
-                const stamped = stampOriginProject(targetRoot, entry);
-                const outcome = gatedWrite(writeDb, targetRoot, stamped);
-                if (outcome === 'skipped:rejected') {
-                    rejected++;
-                    continue;
-                }
-                if (outcome !== 'written') {
-                    skipped++;
-                    continue;
-                }
-                writeEntryMirrors(targetRoot, stamped);
-                updateStats(targetRoot, { remembered: 1 });
-                keys.add(duplicateKey(item.content)); // within-batch dedup
-                void embedMemory(targetRoot, entry);
-            }
-            captured++;
-        }
-    }
-    finally {
-        if (dryRunDb)
-            closeHippoDb(dryRunDb);
-        if (writeDb)
-            closeHippoDb(writeDb);
-    }
-    const prefix = options.dryRun ? '[dry-run] ' : '';
-    const globalPrefix = useGlobal ? '[global] ' : '';
-    console.log(`\n${prefix}${globalPrefix}Captured ${captured} items (${skipped} skipped as duplicates` +
-        (rejected > 0 ? `, ${rejected} rejected` : '') +
-        ')');
-}
-// ---------------------------------------------------------------------------
-// `hippo pre-compact` — PreCompact hook producer
-// ---------------------------------------------------------------------------
-/** Never read the whole transcript — PreCompact fires exactly when it's largest. */
-export const PRE_COMPACT_TAIL_BYTES = 256 * 1024;
-export const PRE_COMPACT_TASK_CAP = 200;
-export const PRE_COMPACT_SUMMARY_CAP = 2000;
-export const PRE_COMPACT_NEXT_STEP_CAP = 500;
-/**
- * Truncate `text` to at most `maxChars` UTF-16 code units without splitting
- * a surrogate pair at the boundary. A plain `slice(0, n)` can land between a
- * high and low surrogate, leaving an unpaired surrogate in a stored/
- * re-injected snapshot field. If the code unit at the cut point is a high
- * surrogate (0xD800-0xDBFF), back off one unit so the pair stays whole.
- */
-export function truncateCodePointSafe(text, maxChars) {
-    if (text.length <= maxChars)
-        return text;
-    let end = maxChars;
-    if (end > 0) {
-        const code = text.charCodeAt(end - 1);
-        if (code >= 0xd800 && code <= 0xdbff)
-            end -= 1;
-    }
-    return text.slice(0, end);
-}
-/**
- * Cap from the RECENT end: summariseTranscript emits user turns oldest-to-
- * newest with assistant responses after them, so a head-first cap keeps
- * stale context and drops exactly the newest working state this feature
- * exists to preserve. Keep the LAST maxChars instead, aligned forward to a
- * nearby line start, with a trim marker (codex round 3).
- */
-export function truncateKeepNewest(text, maxChars) {
-    if (text.length <= maxChars)
-        return text;
-    let start = text.length - maxChars;
-    const code = text.charCodeAt(start);
-    if (code >= 0xdc00 && code <= 0xdfff)
-        start += 1; // never start on a low surrogate
-    const nl = text.indexOf('\n', start);
-    if (nl !== -1 && nl + 1 < text.length && nl - start < 200)
-        start = nl + 1;
-    return '[...earlier turns trimmed]\n' + text.slice(start);
-}
-/**
- * Positional read of the last `capBytes` of `transcriptPath`, aligned
- * forward to the first complete JSONL line. Uses fs.openSync/readSync at a
- * byte offset rather than reading the whole file and slicing — PreCompact
- * fires exactly when transcripts are largest, so a whole-file read is the
- * one thing this path cannot do.
- *
- * Boundary handling (X14): a seek that lands mid-line must drop that
- * partial first line so every remaining line parses as complete JSON. A
- * seek that lands exactly after a '\n' already starts on a complete line
- * and must NOT drop it — doing so would silently discard one whole line on
- * every tail read whose start offset happens to align with a line break.
- * Distinguished by peeking at the single byte immediately before `start`.
- */
-export function readTranscriptTail(transcriptPath, capBytes = PRE_COMPACT_TAIL_BYTES) {
-    const size = fs.statSync(transcriptPath).size;
-    const start = Math.max(0, size - capBytes);
-    const length = size - start;
-    if (length <= 0)
-        return '';
-    const fd = fs.openSync(transcriptPath, 'r');
-    try {
-        let onLineBoundary = start === 0;
-        if (!onLineBoundary) {
-            const prevByte = Buffer.alloc(1);
-            fs.readSync(fd, prevByte, 0, 1, start - 1);
-            onLineBoundary = prevByte[0] === 0x0a; // '\n'
-        }
-        const buf = Buffer.alloc(length);
-        fs.readSync(fd, buf, 0, length, start);
-        let text = buf.toString('utf8');
-        if (!onLineBoundary) {
-            // Landed mid-line — drop the partial first line so every remaining
-            // line parses as complete JSON.
-            const nl = text.indexOf('\n');
-            text = nl === -1 ? '' : text.slice(nl + 1);
-        }
-        return text;
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-/** Most recent plain-text user message in a JSONL tail. Claude Code transcript shape only (PreCompact is claude-code-only). */
-function lastPlainUserMessage(jsonl) {
-    const lines = jsonl.split('\n').filter((l) => l.trim());
-    for (let i = lines.length - 1; i >= 0; i--) {
-        let entry;
-        try {
-            entry = JSON.parse(lines[i]);
-        }
-        catch {
-            continue;
-        }
-        if (!isObjectLike(entry))
-            continue;
-        if (!('type' in entry) || entry.type !== 'user')
-            continue;
-        // Meta/sidechain lines carry type:'user' but are not the human: after a
-        // FIRST compaction the transcript holds the compact summary as an isMeta
-        // user line, and sub-agent turns are isSidechain — deriving "task" from
-        // either yields junk on every later compaction.
-        if (('isMeta' in entry && entry.isMeta === true) || ('isSidechain' in entry && entry.isSidechain === true))
-            continue;
-        const message = 'message' in entry && isObjectLike(entry.message) ? entry.message : undefined;
-        if (!message)
-            continue;
-        const text = humanUserText(entry, message);
-        if (text)
-            return text;
-    }
-    return '';
-}
-/** Last assistant text block in a JSONL tail (skips thinking + tool_use, same as summariseTranscript). */
-function lastAssistantTextBlock(jsonl) {
-    const lines = jsonl.split('\n').filter((l) => l.trim());
-    for (let i = lines.length - 1; i >= 0; i--) {
-        let entry;
-        try {
-            entry = JSON.parse(lines[i]);
-        }
-        catch {
-            continue;
-        }
-        if (!isObjectLike(entry))
-            continue;
-        if (!('type' in entry) || entry.type !== 'assistant')
-            continue;
-        // Same meta/sidechain guard as lastPlainUserMessage: sub-agent turns
-        // (isSidechain) are not this session's next step.
-        if (('isMeta' in entry && entry.isMeta === true) || ('isSidechain' in entry && entry.isSidechain === true))
-            continue;
-        const message = 'message' in entry && isObjectLike(entry.message) ? entry.message : undefined;
-        if (!message)
-            continue;
-        const content = 'content' in message ? message.content : undefined;
-        if (!Array.isArray(content))
-            continue;
-        for (let j = content.length - 1; j >= 0; j--) {
-            const block = content[j];
-            if (isObjectLike(block)) {
-                const blockText = 'type' in block && block.type === 'text' && 'text' in block ? block.text : undefined;
-                if (isStringValue(blockText) && blockText.trim()) {
-                    return blockText.trim();
-                }
-            }
-        }
-    }
-    return '';
-}
-// Diagnostic-only log; a long-lived install must not grow it unbounded.
-const PRE_COMPACT_LOG_MAX_BYTES = 256 * 1024;
-/**
- * Log-forgery guard: messages here interpolate payload-controlled values
- * (transcript paths, session ids). Strip C0 control chars — newlines above
- * all — so a crafted value can't inject fake `[hippo] ...` log lines.
- * Exported for every `[hippo]`-prefixed log writer that interpolates
- * payload-controlled values (cli.ts appendSessionEndCloseLog) — one shared
- * guard, not per-file copies.
- */
-export function sanitizeLogMessage(message) {
-    // eslint-disable-next-line no-control-regex
-    return message.replace(/[\x00-\x1f]/g, '');
-}
-function appendPreCompactLog(logFile, message) {
-    try {
-        fs.mkdirSync(path.dirname(logFile), { recursive: true });
-        const stat = fs.existsSync(logFile) ? fs.statSync(logFile) : null;
-        if (stat && stat.size > PRE_COMPACT_LOG_MAX_BYTES) {
-            fs.writeFileSync(logFile, '', 'utf8'); // start fresh — dumb cap, no rotation
-        }
-        fs.appendFileSync(logFile, `[hippo] ${new Date().toISOString()} ${sanitizeLogMessage(message)}\n`, 'utf8');
-    }
-    catch {
-        // Diagnostic-only; a log write failure must never affect the exit-0 contract.
-    }
-}
-/** True iff `filePath` exists and is readable — checks both in one call. */
-function isReadableFile(filePath) {
-    try {
-        fs.accessSync(filePath, fs.constants.R_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** PreCompact stdout is the summariser's instructions; sent before the snapshot work because a locked store can run the hook past its 30 s limit, and via writeSync because process.exit drops buffered pipe output. */
-function printPreCompactInstruction(logFile) {
-    try {
-        fs.writeSync(1, `${PRE_COMPACT_INSTRUCTION}\n`);
-    }
-    catch (err) {
-        appendPreCompactLog(logFile, `instruction not printed: ${errorMessage(err)}`);
-    }
-}
-/** A session's task, summary and next step from its transcript tail, secrets scrubbed and capped, '' where none; null with a logged reason when nothing is derivable. */
-export function transcriptWorkingState(transcriptPath, log) {
-    let tail = '';
-    let rawTask = '';
-    let rawNextStep = '';
-    try {
-        // Compaction fires when a big tool_result lands (CX7), so the last human and assistant turns can sit
-        // megabytes back: grow the window a bounded number of times until both turns are in it.
-        const size = fs.statSync(transcriptPath).size;
-        for (const cap of [PRE_COMPACT_TAIL_BYTES, PRE_COMPACT_TAIL_BYTES * 4, PRE_COMPACT_TAIL_BYTES * 16]) {
-            if (cap > PRE_COMPACT_TAIL_BYTES)
-                log(`tail window grown to ${cap} bytes (last ${rawTask ? 'assistant' : 'user'} turn is further back)`);
-            tail = readTranscriptTail(transcriptPath, cap);
-            rawTask = lastPlainUserMessage(tail);
-            rawNextStep = lastAssistantTextBlock(tail);
-            if ((rawTask && rawNextStep) || size <= cap)
-                break;
-        }
-    }
-    catch (err) {
-        log(`skip: could not read transcript tail: ${errorMessage(err)}`);
-        return null;
-    }
-    const rawSummary = summariseTranscript(tail);
-    if (!rawTask.trim() && !rawSummary.trim() && !rawNextStep.trim()) {
-        log('skip: empty summary');
-        return null;
-    }
-    // X9: these fields skip the capture content gate and reach a prompt, so the strict scrub runs. The caps protect the
-    // re-injection token budget and never split a surrogate pair (X2); `hippo snapshot save` stays uncapped.
-    const task = maskEmails(redactSecretsStrict(rawTask));
-    const summary = maskEmails(redactSecretsStrict(rawSummary));
-    const nextStep = maskEmails(redactSecretsStrict(rawNextStep));
-    return {
-        task: task.trim() ? truncateCodePointSafe(task, PRE_COMPACT_TASK_CAP) : '',
-        summary: summary.trim() ? truncateKeepNewest(summary, PRE_COMPACT_SUMMARY_CAP) : '',
-        next_step: nextStep.trim() ? truncateCodePointSafe(nextStep, PRE_COMPACT_NEXT_STEP_CAP) : '',
-    };
-}
-/** Runs the PreCompact producer: records the compaction, asks the summariser for memories, saves a working-state snapshot. Never extracts memories itself; SessionEnd capture owns that. */
-function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile) {
-    // X3: the PreCompact hook fires in every Claude Code project, including
-    // ones that never ran `hippo init`, so gate before any store-opening call
-    // (saveActiveTaskSnapshot etc. call initStore, which would create one).
-    if (!isInitialized(hippoRoot)) {
-        appendPreCompactLog(logFile, 'skip: store not initialized');
-        return;
-    }
-    const receipt = readClaudeCodePreCompact(stdinText, stdinTimedOut);
-    if (receipt.status !== 'received') {
-        appendPreCompactLog(logFile, `skip: ${receipt.reason}`);
-        return;
-    }
-    const { sessionId, transcriptPath: payloadTranscriptPath, cwd: payloadCwd, trigger: payloadTrigger } = receipt.input;
-    // The record is the "something saved before every compaction", so it lands even when no snapshot is derivable below.
-    let recordId = null;
-    if (sessionId !== null && sessionId !== '') {
-        recordId = recordCompactionStart(hippoRoot, { sessionId, trigger: payloadTrigger, cwd: payloadCwd, transcriptPath: payloadTranscriptPath }, (message) => appendPreCompactLog(logFile, message));
-        printPreCompactInstruction(logFile);
-    }
-    // A payload transcript_path is EXCLUSIVE: never fall back to
-    // newest-transcript auto-discovery when it's missing/unreadable. That
-    // fallback would snapshot a DIFFERENT session's transcript under THIS
-    // payload's session_id — cross-session contamination with wrong linkage
-    // (verify-stage E2E finding, 2026-08-03). Auto-discovery only applies
-    // on a true manual invocation (no payload at all).
-    let transcriptPath;
-    if (payloadTranscriptPath !== null) {
-        if (isReadableFile(payloadTranscriptPath)) {
-            transcriptPath = payloadTranscriptPath;
-        }
-        else {
-            appendPreCompactLog(logFile, `skip: payload transcript_path unreadable: ${payloadTranscriptPath}`);
-            return;
-        }
-    }
-    else {
-        transcriptPath = resolveLastSessionTranscript(undefined, stdinText, { mayScan: true });
-    }
-    if (!transcriptPath) {
-        appendPreCompactLog(logFile, 'skip: no transcript resolved');
-        return;
-    }
-    // Nothing derivable skips the write, so a user-authored active snapshot is never clobbered with junk.
-    const derived = transcriptWorkingState(transcriptPath, (message) => appendPreCompactLog(logFile, message));
-    if (!derived)
-        return;
-    const tenantId = resolveTenantId({});
-    // Per-field merge (X1): a tool-heavy tail whose only user turns are
-    // tool_result arrays derives an empty task even though the summary is
-    // non-empty. Loading the existing snapshot first lets each field fall
-    // back independently instead of the whole write clobbering a
-    // user-authored field with blank text.
-    let existing = null;
-    try {
-        existing = loadActiveTaskSnapshot(hippoRoot, tenantId);
-    }
-    catch {
-        // No existing snapshot to merge against — proceed with derived-only.
-    }
-    // CX6 (codex round 2): field fallback must never move content across
-    // sessions — session A's task carried into a snapshot saved under session
-    // B's id would pass compact-resume's session gate wearing the wrong
-    // badge. Fall back only when the existing snapshot has no session, this
-    // payload has none, or they match.
-    const fallback = existing !== null &&
-        (existing.session_id === null || sessionId === null || existing.session_id === sessionId)
-        ? existing
-        : null;
-    // Carried-over fields are not re-capped, as `hippo snapshot save` stays uncapped; saveActiveTaskSnapshot scrubs every field.
-    const task = derived.task || (fallback?.task ?? '');
-    const summary = derived.summary || (fallback?.summary ?? '');
-    const nextStep = derived.next_step || (fallback?.next_step ?? '');
-    // All-empty fields (cross-session tail with nothing derivable) skip the
-    // write so a foreign session's junk never displaces the owning snapshot.
-    if (!task && !summary && !nextStep) {
-        appendPreCompactLog(logFile, 'skip: no snapshot content for this session (nothing derivable; fallback blocked or empty)');
-    }
-    else {
-        try {
-            saveActiveTaskSnapshot(hippoRoot, tenantId, {
-                task,
-                summary,
-                next_step: nextStep,
-                source: 'pre-compact',
-                session_id: sessionId,
-            });
-            appendPreCompactLog(logFile, 'snapshot saved');
-            if (recordId !== null)
-                recordSnapshotSaved(hippoRoot, recordId, (message) => appendPreCompactLog(logFile, message));
-        }
-        catch (err) {
-            appendPreCompactLog(logFile, `snapshot save failed: ${errorMessage(err)}`);
-        }
-    }
-}
-/**
- * PreCompact hook entry point. Exit code 2 on PreCompact BLOCKS compaction,
- * so this verb must exit 0 on every path — malformed stdin, missing
- * transcript, and store errors all degrade to a logged no-op rather than a
- * thrown error. Callers (src/cli.ts) must not wrap this in anything that
- * could turn a caught-and-logged failure back into a non-zero exit.
- */
-export async function cmdPreCompact(hippoRoot, options) {
-    const logFile = options.logFile ?? defaultPreCompactLogPath();
-    try {
-        runPreCompact(hippoRoot, options.stdinText, options.stdinTimedOut ?? false, logFile);
-    }
-    catch (err) {
-        appendPreCompactLog(logFile, `pre-compact failed: ${errorMessage(err)}`);
-    }
-    process.exit(0);
-}
-/** A PostCompact hook has 10 s in all; replay stops starting new records after this. */
-const POST_COMPACT_REPLAY_BUDGET_MS = 6000;
-/** PostCompact entry point: saves the summary and its items, replays earlier leftovers, returns the one line to show. Never throws, so the hook exits 0. */
-export function cmdPostCompact(hippoRoot, options) {
-    const logFile = options.logFile ?? defaultPreCompactLogPath();
-    const log = (message) => appendPreCompactLog(logFile, `post-compact: ${message}`);
-    const deadline = Date.now() + POST_COMPACT_REPLAY_BUDGET_MS;
-    try {
-        if (!isInitialized(hippoRoot)) {
-            log('skip: no hippo store');
-            return null;
-        }
-        const payload = parsePostCompactPayload(options.stdinText);
-        let line = null;
-        let storeBusy = false;
-        if (payload === null) {
-            log('skip: no PostCompact payload naming a session');
-        }
-        else {
-            const saved = saveCompaction(hippoRoot, payload, log);
-            line = postCompactLine(saved);
-            storeBusy = saved.deferred;
-            if (!storeBusy && payload.transcriptPath !== null && options.afterSave) {
-                try {
-                    options.afterSave(payload.transcriptPath, compactionOrigin(hippoRoot, payload.cwd), log);
-                }
-                catch (err) {
-                    log(`agent memory import failed: ${errorMessage(err)}`);
-                }
-            }
-        }
-        if (!storeBusy)
-            replayCompactionsAt(hippoRoot, log, { busyWaitMs: COMPACTION_DB_WAIT_MS, deadline });
-        return line;
-    }
-    catch (err) {
-        log(`failed: ${errorMessage(err)}`);
-        return null;
-    }
-}
-//# sourceMappingURL=capture.js.map