hippo-memory 1.52.6 → 1.52.8

package/dist/capture.js

@@ -18,9 +18,10 @@ import { embedMemory } from './embeddings.js';
 import { isEmbeddingConfigured } from './embedding-provider.js';
 import { resolveTenantId } from './tenant.js';
 import { defaultPreCompactLogPath } from './hooks.js';
-import { redactSecrets } from './secret-detect.js';
+import { redactSecretsStrict } from './secret-detect.js';
 import { RejectedValueError, checkRejectionGuard } from './rejection.js';
 import { openHippoDb, closeHippoDb } from './db.js';
+import { loadConfig } from './config.js';
 // Sentence-level patterns
 //
 // T1 (DF2): each pattern now carries TWO capture groups — group 1 is the
@@ -790,6 +791,7 @@ function cmdCaptureCore(hippoRoot, options) {
     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
@@ -823,6 +825,7 @@ function cmdCaptureCore(hippoRoot, options) {
                 source: 'capture',
                 confidence: 'observed',
                 tenantId: useGlobal ? undefined : options.tenantId,
+                baseHalfLifeDays,
             });
             if (options.dryRun) {
                 if (dryRunDb) {
@@ -1077,6 +1080,46 @@ export function preCompactMessage(report) {
 export function preCompactReportPath(logFile) {
     return path.join(path.dirname(logFile), 'pre-compact-last.json');
 }
+/** 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;
+    try {
+        // CX7 (codex round 2): a final record bigger than the window leaves an empty tail, as when a huge tool_result
+        // triggered compaction, so grow the window a bounded number of times until one complete line survives.
+        tail = readTranscriptTail(transcriptPath, PRE_COMPACT_TAIL_BYTES);
+        let prevCap = PRE_COMPACT_TAIL_BYTES;
+        for (const grownCap of [PRE_COMPACT_TAIL_BYTES * 4, PRE_COMPACT_TAIL_BYTES * 16]) {
+            if (tail.trim() !== '')
+                break;
+            if (fs.statSync(transcriptPath).size <= prevCap)
+                break; // already read the whole file
+            log(`tail window grown to ${grownCap} bytes (oversized final record)`);
+            tail = readTranscriptTail(transcriptPath, grownCap);
+            prevCap = grownCap;
+        }
+    }
+    catch (err) {
+        log(`skip: could not read transcript tail: ${errorMessage(err)}`);
+        return null;
+    }
+    const rawSummary = summariseTranscript(tail);
+    const rawTask = lastPlainUserMessage(tail);
+    const rawNextStep = lastAssistantTextBlock(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 = redactSecretsStrict(rawTask);
+    const summary = redactSecretsStrict(rawSummary);
+    const nextStep = 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: saves a working-state snapshot into `report`. Never extracts memories; SessionEnd capture owns that. */
 function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
     // X3: the PreCompact hook fires in every Claude Code project, including
@@ -1157,40 +1200,10 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
         appendPreCompactLog(logFile, 'skip: no transcript resolved');
         return;
     }
-    let tail;
-    try {
-        // CX7 (codex round 2): a final JSONL record larger than the window
-        // swallows the whole tail — the seek lands inside it and alignment
-        // drops everything up to its terminator, which is exactly the shape of
-        // a huge tool_result that itself triggered compaction. Grow the window
-        // a bounded number of times until at least one complete line survives.
-        tail = readTranscriptTail(transcriptPath, PRE_COMPACT_TAIL_BYTES);
-        let prevCap = PRE_COMPACT_TAIL_BYTES;
-        for (const grownCap of [PRE_COMPACT_TAIL_BYTES * 4, PRE_COMPACT_TAIL_BYTES * 16]) {
-            if (tail.trim() !== '')
-                break;
-            if (fs.statSync(transcriptPath).size <= prevCap)
-                break; // already read the whole file
-            appendPreCompactLog(logFile, `tail window grown to ${grownCap} bytes (oversized final record)`);
-            tail = readTranscriptTail(transcriptPath, grownCap);
-            prevCap = grownCap;
-        }
-    }
-    catch (err) {
-        appendPreCompactLog(logFile, `skip: could not read transcript tail: ${errorMessage(err)}`);
-        return;
-    }
-    const summaryFull = summariseTranscript(tail);
-    // Snapshot fields must never carry raw secrets, same rule X9 applies below to task/next_step.
-    const scrubbedSummary = redactSecrets(summaryFull);
-    const rawTask = lastPlainUserMessage(tail);
-    const rawNextStep = lastAssistantTextBlock(tail);
-    // Full skip only when every derived field is empty: never clobber a
-    // user-authored active snapshot with junk.
-    if (!rawTask.trim() && !summaryFull.trim() && !rawNextStep.trim()) {
-        appendPreCompactLog(logFile, 'skip: empty summary');
+    // 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
@@ -1204,15 +1217,6 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
     catch {
         // No existing snapshot to merge against — proceed with derived-only.
     }
-    // X9: scrub secret-shaped substrings out of freshly-derived text before it
-    // is capped/stored. These fields bypass the normal capture content gate
-    // (they're not extracted items), so this producer is the only place that
-    // ever sees them before they land in task_snapshots. Carried-over
-    // existing field values are NOT re-scrubbed here — they already passed
-    // through this same gate (or were set via `hippo snapshot save`, which is
-    // deliberately untouched, same as the caps below).
-    const scrubbedTask = redactSecrets(rawTask);
-    const scrubbedNextStep = redactSecrets(rawNextStep);
     // 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
@@ -1222,19 +1226,10 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
         (existing.session_id === null || sessionId === null || existing.session_id === sessionId)
         ? existing
         : null;
-    // Field caps are enforced HERE ONLY — saveActiveTaskSnapshot and the
-    // `hippo snapshot save` CLI path stay uncapped (AGENTS.md public-API
-    // preservation). Caps protect the re-injection token budget. Code-point
-    // safe (X2): never split a surrogate pair at the cut.
-    const task = scrubbedTask.trim()
-        ? truncateCodePointSafe(scrubbedTask, PRE_COMPACT_TASK_CAP)
-        : (fallback?.task ?? '');
-    const summary = scrubbedSummary.trim()
-        ? truncateKeepNewest(scrubbedSummary, PRE_COMPACT_SUMMARY_CAP)
-        : (fallback?.summary ?? '');
-    const nextStep = scrubbedNextStep.trim()
-        ? truncateCodePointSafe(scrubbedNextStep, PRE_COMPACT_NEXT_STEP_CAP)
-        : (fallback?.next_step ?? '');
+    // 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) {

package/dist/churn-git.js

@@ -10,7 +10,7 @@ export class GitReadError extends Error {
 }
 function runGit(args, repoRoot) {
     try {
-        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER });
+        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, windowsHide: true });
     }
     catch (err) {
         throw new GitReadError(`git ${args.join(' ')} failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -19,7 +19,7 @@ function runGit(args, repoRoot) {
 // git grep exits 1 for "no match" -- a normal empty result, not a failure.
 function runGitGrepOrEmpty(args, repoRoot) {
     try {
-        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER });
+        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, windowsHide: true });
     }
     catch (err) {
         // SAFETY: execFileSync attaches `status` to the thrown Error on a non-zero child exit.

package/dist/cli.d.ts

@@ -43,10 +43,7 @@ export declare function parseArgs(argv: string[]): {
     args: string[];
     flags: Record<string, string | boolean | string[]>;
 };
-/**
- * Scan for Claude Code MEMORY.md files and import new entries into hippo.
- * Looks in ~/.claude/projects/<project>/memory/ for .md files with YAML frontmatter.
- */
+/** Import new entries from the Claude Code auto memory of the store's project, the frontmatter .md files in ~/.claude/projects/<project>/memory/. */
 export declare function learnFromMemoryMd(hippoRoot: string, homeDir?: string): number;
 /**
  * Render an api.sleep result as console output, byte-identical to the