hippo-memory 1.61.0 → 1.63.0

package/dist/capture/extract.js

@@ -12,24 +12,13 @@ import { duplicateKey } from '../same-text.js';
 import { isContentWorthStoring } from '../audit.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.
+// Each pattern carries TWO capture groups: group 1 is the discriminating keyword (plus its
+// trailing separator, verbatim), group 2 the content after it, so a negation like "never" survives
+// ("Never use X" must not store as "use X"). `extractFromPatterns` joins group1 + a clause-bounded
+// group2 (`boundToClause`), so group 2 may reach {1,500}. The keyword keeps its own group because
+// keywords like "error:" end in a colon that is not a prose clause boundary.
+// `PREFERENCE_PATTERNS[0]` is the exception: its two groups are the content spans either side of
+// "instead of"/"over"/"not"; 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,
@@ -49,9 +38,8 @@ const ERROR_PATTERNS = [
     /((?: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.
+// PREFERENCE_PATTERNS[0] keeps its match[1]-only, unbounded shape; extractFromPatterns
+// checks for 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,
@@ -72,52 +60,20 @@ export function splitSentences(text) {
         .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);
 }
+/** The last plausible CLOSING single quote, or -1. Mirror of the opener rule in `boundToClause`: a closer sits tight
+ * against its literal and is never followed by a letter, which is what makes "user's" an apostrophe. */
 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.
+    // ONE pass, not one per apostrophe: a rescan per apostrophe goes quadratic
+    // on a transcript full of elisions ("keep 'em", "wait 'til", ...).
     //
-    // 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 -
+    // A quote CLOSES THE SIDE IT IS TIGHT AGAINST, so the test needs both
+    // neighbours: 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.
+    // so no forward-only rule can separate them.
     //
     //   never a closer   next is a letter/digit      "user's", "keep 'em"
     //   closer           prev is non-whitespace      "'a, b' to", "'a, b'-style"
@@ -137,11 +93,10 @@ function lastCloserIndex(full) {
         // "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.
+        // pair across the clause boundary.
         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:
+        // Punctuation splits in two:
         //   , ; : ! ? ) ] }  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
@@ -156,17 +111,12 @@ function lastCloserIndex(full) {
     }
     return -1;
 }
+/** Cuts `full` (keyword + content) at the first prose `,;:` or `[.!?]` followed by whitespace, scanning from `searchFrom` so a keyword's
+ * own colon never counts; the whitespace rule keeps `.env` whole and `maxLen` truncates a long span the 500-char gate would drop. */
 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:
+    // Depth-awareness matters because memories are full of code; a naive scan cuts
     //   "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.
+    // and the fragment PASSES the write gate, since code punctuation reads as "specific".
     //
     // So: a separator only ends the clause at bracket depth zero and outside
     // quotes. Unbalanced closers are tolerated (depth floors at 0) because
@@ -222,15 +172,8 @@ function boundToClause(full, searchFrom, maxLen = 200) {
     return bounded;
 }
 function closesQuote(full, i, 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.
+    // Closing uses the SAME shape test as opening, else a possessive INSIDE a literal closes it early:
+    //   "Always pass 'user's a, b list' to the parser."  ->  "Always pass 'user's a"
     return full[i] === quote && (quote !== "'" || !isLetterOrDigit(full[i + 1]));
 }
 function opensSingleQuote(full, i, lastCloser) {
@@ -242,7 +185,6 @@ function opensSingleQuote(full, i, lastCloser) {
     //     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
@@ -257,7 +199,7 @@ function opensSingleQuote(full, i, lastCloser) {
     // 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.
+    // an elided form simply has no partner.
     // ...and the partner must LOOK like a closer, not merely be another
     // apostrophe. Distance cannot separate the two cases - both put a `'`
     // far downstream:
@@ -268,7 +210,7 @@ function opensSingleQuote(full, i, lastCloser) {
     //     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.
+    // a letter) after. "user's" fails it on both counts.
     return atBoundary && lastCloser > i;
 }
 function cleanExtract(raw) {
@@ -276,7 +218,7 @@ function cleanExtract(raw) {
         .replace(/^[:\s-]+/, '')
         .replace(/[.!?,;:\s]+$/, '')
         .trim();
-    // T2 trailing cleanup: clause-bounding can cut inside a parenthetical and
+    // 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
@@ -316,51 +258,31 @@ function extractFromPatterns(sentence, patterns, category, tag) {
         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.
+                // PREFERENCE_PATTERNS[0] skips clause-bounding (see comment at its definition).
                 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
+                // The keyword is kept 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:",
+                // "always"), because dropping those inverts the meaning. 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).
+                // (the 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.
+                // ONLY colon-terminated labels are dropped: dropping "the X is/was" leaves a residue starting
+                // with "to ", which isFragment rejects, so "The plan is to ship on Friday" would store nothing.
                 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.
+                // Scan the UNTRUNCATED remainder, not match[2]: a quoted literal whose closer sits past the
+                // 500-char group cap would read as prose; boundToClause caps its OUTPUT, so this costs nothing.
+                // Group 2's REAL offset from the regex engine: DECISION_PATTERNS carry an uncaptured subject
+                // ("we ", "let's ") ahead of group 1, so `match.index + rawPrefix.length` lands inside the keyword.
                 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;

package/dist/capture-error.d.ts

@@ -1,4 +1,4 @@
-import type { JsonValue } from './working-memory.js';
+import type { JsonValue } from './json.js';
 /** Why a failure was not stored, or `stored`. */
 export type CaptureErrorOutcome = 'stored' | 'duplicate' | 'skipped-interrupt' | 'skipped-routine' | 'skipped-invalid';
 /** Which routine check skipped a failure; the log keeps it so declines can be told apart from empty searches. */

package/dist/capture-error.js

@@ -1,6 +1,6 @@
 // `hippo capture-error`, run by the Claude Code PostToolUseFailure hook: routine failures and repeats are not
 // stored, because error memories decay slowly and would crowd out real lessons; what is stored stays `observed`
-// until outcome feedback confirms it. Every failure, stored or not, goes to the failure log (ROADMAP CD13).
+// until outcome feedback confirms it. Every failure, stored or not, goes to the failure log.
 import { createMemory } from './memory.js';
 import { writeEntry } from './store/entry-writes.js';
 import { loadContentsWithTag } from './store/entry-reads.js';

package/dist/churn-git.d.ts

@@ -1,4 +1,4 @@
-/** Git subprocess helpers for FE2 churn-staleness (src/invalidation.ts). */
+/** Git subprocess helpers for churn-staleness (src/invalidation.ts). */
 /** A real git failure (not git grep's expected exit-1-no-match). Callers abort the whole run on this. */
 export declare class GitReadError extends Error {
 }

package/dist/churn-git.js

@@ -1,4 +1,4 @@
-/** Git subprocess helpers for FE2 churn-staleness (src/invalidation.ts). */
+/** Git subprocess helpers for churn-staleness (src/invalidation.ts). */
 import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as os from 'os';

package/dist/cli/audit.js

@@ -9,7 +9,7 @@ import { pruneAuditLog, parseOlderThanFlag } from '../audit-prune.js';
 import { printError } from './output.js';
 import { requireInit, resolveAuthRoot } from './shared.js';
 // ---------------------------------------------------------------------------
-// Audit log subcommands (A5 stub auth — `hippo audit list`)
+// Audit log subcommands (`hippo audit list`)
 // ---------------------------------------------------------------------------
 const VALID_AUDIT_OPS = new Set(AUDIT_OPS);
 function formatAuditRow(ev) {
@@ -23,8 +23,7 @@ function cmdAuditList(hippoRoot, flags) {
     const tenantId = resolveTenantId({});
     const opFlag = typeof flags['op'] === 'string' ? flags['op'] : undefined;
     if (opFlag && !VALID_AUDIT_OPS.has(opFlag)) {
-        // Regenerate from Set to prevent future drift (v1.11.5: pre-v1.11.5 message
-        // was hand-maintained and had drifted — missed 'auth_revoke' and 'outcome').
+        // Built from the Set so the message cannot drift from the valid ops.
         const expected = Array.from(VALID_AUDIT_OPS).join(' | ');
         printError(`Unknown --op value: ${opFlag}. Expected one of: ${expected}.`);
         process.exit(1);
@@ -115,7 +114,7 @@ function cmdAuditLog(hippoRoot, args, flags) {
     process.exit(1);
 }
 export function handleAudit({ hippoRoot, args, flags }) {
-    // `audit list` and `audit prune` -> A5 audit-log subcommands.
+    // `audit list` and `audit prune` -> audit-log subcommands.
     // Other forms (no sub, --fix) keep the existing memory-quality auditor
     // for backwards compatibility.
     if (args[0] === 'list' || args[0] === 'prune') {

package/dist/cli/auth.js

@@ -6,16 +6,14 @@ import { resolveTenantId } from '../tenant.js';
 import { printError } from './output.js';
 import { resolveAuthRoot } from './shared.js';
 // ---------------------------------------------------------------------------
-// Auth subcommands (A5 stub auth)
+// Auth subcommands
 // ---------------------------------------------------------------------------
 function cmdAuthCreate(hippoRoot, flags) {
     const root = resolveAuthRoot(hippoRoot, flags);
     const tenantFlag = typeof flags['tenant'] === 'string' ? flags['tenant'] : undefined;
     const labelFlag = typeof flags['label'] === 'string' ? flags['label'] : undefined;
     const asJson = Boolean(flags['json']);
-    // v1.12.3: --role flag surfaces the api_keys.role column added v1.12.0
-    // sub-1. Accepts 'admin' | 'member' only; anything else exits 1 with a
-    // typed error so a typo doesn't silently default to admin.
+    // Accepts 'admin' | 'member' only; anything else exits 1 so a typo doesn't silently default to admin.
     const roleFlag = typeof flags['role'] === 'string' ? flags['role'] : undefined;
     let role = 'admin';
     if (roleFlag !== undefined) {
@@ -57,7 +55,6 @@ function formatKeyRow(item) {
     const label = item.label ?? '-';
     const created = item.createdAt;
     const revoked = item.revokedAt ?? '-';
-    // v1.12.3: role column surfaced
     return `${item.keyId}  ${item.tenantId}  ${item.role}  ${label}  ${created}  ${revoked}`;
 }
 function cmdAuthList(hippoRoot, flags) {
@@ -111,7 +108,7 @@ function cmdAuthRevoke(hippoRoot, keyId, flags) {
     }
     console.log(`Revoked ${keyId} at ${revokedAt}`);
 }
-/** EI2: `hippo auth grant|ungrant <key_id> <scope>`, routed through api so the tenant, restricted-scope and audit checks live in one place. */
+/** `hippo auth grant|ungrant <key_id> <scope>`, routed through api so the tenant, restricted-scope and audit checks live in one place. */
 function cmdAuthScopeGrant(hippoRoot, keyId, scope, grant, flags) {
     const ctx = keyContext(resolveAuthRoot(hippoRoot, flags), keyId);
     try {