hippo-memory 1.62.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 {

package/dist/cli/curate.d.ts

@@ -12,7 +12,7 @@ export declare function cmdUnreject(hippoRoot: string, args: string[], flags: Re
  * `"dormant": { "enabled": false }` in .hippo/config.json deletes instead).
  */
 export declare function cmdDormant(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
-/** `hippo quarantine [list] [--all] [--json] [--global]`, `quarantine approve <id>`, `quarantine reject <id>` (CD5 poisoning defence). */
+/** `hippo quarantine [list] [--all] [--json] [--global]`, `quarantine approve <id>`, `quarantine reject <id>` (poisoning defence). */
 export declare function cmdQuarantine(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
 export declare function handleForget({ hippoRoot, args, flags }: CommandContext): Promise<void>;
 export declare function handleInvalidate({ hippoRoot, args, flags }: CommandContext): void;

package/dist/cli/curate.js

@@ -20,11 +20,7 @@ export function cmdOutcome(hippoRoot, flags) {
         printError('Specify --good or --bad');
         process.exit(1);
     }
-    // Behavior fix (v1.11.3): cmdOutcome used to bypass api.outcome and do its
-    // own readEntry/writeEntry inline, which silently skipped the audit_log
-    // emission that the MCP outcome path already has via api.outcome. T6
-    // rewires through api.outcome so every successful CLI 'outcome' call now
-    // writes one audit_log row per affected id, matching MCP parity.
+    // Through api.outcome so every CLI outcome writes one audit_log row per id, as the MCP path does.
     const ctx = {
         hippoRoot,
         tenantId: resolveTenantId({}),
@@ -54,7 +50,7 @@ function cmdForget(hippoRoot, id, flags) {
         tenantId: resolveTenantId({}),
         actor: api.adminActor('cli'),
     };
-    // A3: raw memories (Slack / GitHub connector ingestion) are append-only — a
+    // Raw memories (Slack / GitHub connector ingestion) are append-only: a
     // BEFORE-DELETE trigger aborts any delete. archiveRaw is the sanctioned
     // removal path; it records ctx.actor as the archiver for provenance.
     if (flags['archive'] === true) {
@@ -175,11 +171,8 @@ export function cmdResolve(hippoRoot, args, flags) {
         return;
     }
     const forgetLoser = Boolean(flags['forget']);
-    // AT1: --reject-loser tombstones the loser's normalized digest so it
-    // cannot be re-asserted later, in addition to removing it (kind-aware).
-    // --reason defaults to a conflict-context string when omitted (resolve
-    // already has the conflict id + keepId; unlike `hippo reject`, a reason
-    // is not strictly required here).
+    // --reject-loser tombstones the loser's digest so it cannot be re-asserted, as well as removing it.
+    // --reason is optional here, unlike `hippo reject`: resolve already has the conflict id and keepId.
     const rejectLoser = Boolean(flags['reject-loser']);
     const reasonFlag = typeof flags['reason'] === 'string' ? flags['reason'] : undefined;
     const result = resolveConflict(hippoRoot, conflictId, keepId, forgetLoser, tenantId, {
@@ -198,16 +191,14 @@ export function cmdResolve(hippoRoot, args, flags) {
     console.log(`Resolved conflict ${conflictId}: kept ${keepId}, ${action} ${result.loserId}`);
 }
 // ---------------------------------------------------------------------------
-// AT1: reject / rejections / unreject
-// docs/plans/2026-08-15-at1-rejected-value-tombstone.md §4
+// reject / rejections / unreject
 // ---------------------------------------------------------------------------
 export function cmdReject(hippoRoot, args, flags) {
     // Store resolution mirrors `hippo remember`: --global writes to the
     // global store, otherwise the local store (requireInit'd via resolveAuthRoot).
     const root = resolveAuthRoot(hippoRoot, flags);
     const tenantId = resolveTenantId({});
-    // --reason is REQUIRED (plan §4, grill issue 4): the tombstone stores no
-    // content, so reason is its only human-readable identity.
+    // --reason is REQUIRED: the tombstone stores no content, so reason is its only human-readable identity.
     const reason = typeof flags['reason'] === 'string' ? flags['reason'].trim() : '';
     if (!reason) {
         printError('hippo reject requires --reason "<why>" (the tombstone stores no content; reason is its only identity).');
@@ -221,8 +212,7 @@ export function cmdReject(hippoRoot, args, flags) {
         process.exit(1);
     }
     if (memoryId && valueFlag !== undefined) {
-        // Ambiguous ask: silently preferring one form would ignore the other
-        // without feedback (code-review round-1 low).
+        // Ambiguous ask: silently preferring one form would ignore the other without feedback.
         printError('hippo reject takes EITHER a memory id OR --value, not both.');
         process.exit(1);
     }
@@ -372,7 +362,7 @@ export function cmdDormant(hippoRoot, args, flags) {
     }
     console.log('Bring one back: hippo dormant restore <id>   Delete for good: hippo dormant forget <id>');
 }
-/** `hippo quarantine [list] [--all] [--json] [--global]`, `quarantine approve <id>`, `quarantine reject <id>` (CD5 poisoning defence). */
+/** `hippo quarantine [list] [--all] [--json] [--global]`, `quarantine approve <id>`, `quarantine reject <id>` (poisoning defence). */
 export function cmdQuarantine(hippoRoot, args, flags) {
     const root = resolveAuthRoot(hippoRoot, flags);
     const ctx = {
@@ -512,12 +502,6 @@ export function handleInvalidate({ hippoRoot, args, flags }) {
         process.exit(1);
     }
     const onlyId = typeof flags['id'] === 'string' ? flags['id'] : undefined;
-    if (typeof flags['dry-run'] === 'string') {
-        // Dead: the earlier global BOOLEAN_FLAGS guard now exits first on any --dry-run=<v>.
-        // Kept as defence in depth on a destructive command.
-        printError('--dry-run takes no value');
-        process.exit(1);
-    }
     const dryRun = flags['dry-run'] === true;
     if ((target && onlyId) || (!target && !onlyId)) {
         printError('Usage: hippo invalidate "<old pattern>" [--dry-run] [--reason "<why>"]');

package/dist/cli/dag.js

@@ -26,9 +26,7 @@ export function cmdDag(hippoRoot, flags) {
         console.log(`  Unlinked facts: ${unlinked}`);
         return;
     }
-    // Tree view: v0.30 / E5 renders L3 entity profiles as roots (with L2
-    // children indented), then orphan L2 summaries (no L3 parent) at top
-    // level. Pre-E5 behavior was L2-only roots; rendering now covers L3.
+    // Tree view: L3 entity profiles as roots with L2 children indented, then orphan L2 summaries at top level.
     const profiles = entries.filter((e) => e.dag_level === 3);
     const l2List = entries.filter((e) => e.dag_level === 2);
     const orphanL2 = l2List.filter((e) => !e.dag_parent_id);
@@ -62,7 +60,7 @@ export function cmdDag(hippoRoot, flags) {
             }
         }
     }
-    // Orphan L2 summaries (no L3 parent) at top level — pre-E5 default shape.
+    // Orphan L2 summaries (no L3 parent) at top level.
     for (const summary of orphanL2) {
         const summaryTags = summary.tags.filter((t) => t !== 'dag-summary').join(', ');
         console.log(`\n📌 ${summary.content.slice(0, 80)}`);
@@ -113,8 +111,7 @@ function cmdDrillDown(hippoRoot, summaryId, flags) {
     const limit = typeof flags['limit'] === 'string' ? Number(flags['limit']) : undefined;
     // Absent stays undefined so the api default applies; the 0 fallback is unreachable.
     const budget = flags['budget'] === undefined ? undefined : parseBudgetFlag(flags['budget'], 0);
-    // v0.30 / E5: --depth N walks N levels down (default 1, hard cap 10).
-    // L4 fold: reject out-of-range explicitly (no silent clamp).
+    // --depth N walks N levels down (default 1, hard cap 10); out-of-range is rejected, never silently clamped.
     const rawDepth = typeof flags['depth'] === 'string' ? Number(flags['depth']) : undefined;
     let depth;
     if (rawDepth !== undefined) {
@@ -136,9 +133,8 @@ function cmdDrillDown(hippoRoot, summaryId, flags) {
         cost: drillCost,
     });
     if ('failure' in r) {
-        // v1.6.4: only `not_drillable` is caller-actionable. `not_found`
-        // intentionally collapses cross-tenant + scope-blocked + missing
-        // (codex round 3 P1: distinguishing scope_blocked leaked existence).
+        // Only `not_drillable` is caller-actionable. `not_found` collapses cross-tenant, scope-blocked
+        // and missing on purpose: telling scope_blocked apart would leak that the row exists.
         if (r.failure === 'not_drillable') {
             printError(`Id ${summaryId} is a leaf row, not a level-2+ summary; nothing to drill into.`);
         }

package/dist/cli/decisions.js

@@ -27,8 +27,7 @@ function parseObjectId(idRaw, noun) {
     return id;
 }
 // ---------------------------------------------------------------------------
-// E2 prediction first-class object (v0.31)
-// docs/plans/2026-05-26-e2-prediction-object.md
+// Prediction first-class object
 // ---------------------------------------------------------------------------
 function predictClose(hippoRoot, tenantId, args, flags) {
     const idRaw = args[1];
@@ -65,14 +64,9 @@ function loadPredictionList(hippoRoot, tenantId, status, classTag, limit) {
         });
     }
     if (status === 'all') {
-        // No closure-state filter; pull both via loadPredictionsByClass if class given
-        if (classTag) {
-            return predictionsModule.loadPredictionsByClass(hippoRoot, tenantId, classTag, { limit });
-        }
-        // No class filter + status=all = pull open + closed across all classes
-        // (kept simple: report open via loadOpenPredictions; closed via two
-        // class scans isn't symmetrical. v1 callers typically pass --class.)
-        return predictionsModule.loadOpenPredictions(hippoRoot, tenantId, { limit });
+        return classTag
+            ? predictionsModule.loadPredictionsByClass(hippoRoot, tenantId, classTag, { limit })
+            : predictionsModule.loadAllPredictions(hippoRoot, tenantId, { limit });
     }
     if (!predictionsModule.VALID_CLOSURE_STATES.has(status)) {
         printError(`Invalid --status: "${status}". Must be one of: open | closed | closed-unknown | all.`);
@@ -141,7 +135,7 @@ function predictShow(hippoRoot, tenantId, args) {
     console.log(`  created: ${pred.createdAt}`);
 }
 function predictBaserate(hippoRoot, tenantId, flags) {
-    // J3 reference-class / planning-fallacy detector
+    // Reference-class / planning-fallacy detector
     const classTagRaw = flags['class'];
     if (typeof classTagRaw !== 'string' || !classTagRaw.trim()) {
         printError('Usage: hippo predict baserate --class <c>');
@@ -309,16 +303,15 @@ function decideCreate(hippoRoot, tenantId, decisionText, flags) {
     }
     const contextRaw = flags['context'];
     const context = typeof contextRaw === 'string' && contextRaw ? contextRaw : undefined;
-    // A value-less `--supersedes` (parseArgs stores boolean true) is a malformed
-    // request: the user asked to supersede but gave no memory id. Reject it rather
-    // than silently creating a non-superseding decision (codex review 2026-05-28).
+    // A value-less `--supersedes` asks to supersede but gives no memory id: reject it rather
+    // than silently creating a non-superseding decision.
     if (flags['supersedes'] === true) {
         printError('--supersedes requires a memory id, e.g. hippo decide "<text>" --supersedes mem_abc123.');
         process.exit(1);
     }
     const supersedesMemId = typeof flags['supersedes'] === 'string' ? flags['supersedes'] : null;
     // Backward-compat: --supersedes takes a MEMORY id. Validate it exists and
-    // resolve it to the active decision row (if any). Grill fix: commit the
+    // resolve it to the active decision row (if any). Commit the
     // canonical table create+supersede FIRST (inside saveDecision's SAVEPOINT),
     // weaken the old memory LAST (best-effort) so a memory-write failure cannot
     // leave the memory stale without the table reflecting the supersession.
@@ -344,11 +337,8 @@ function decideCreate(hippoRoot, tenantId, decisionText, flags) {
     // 'superseded' tag. Preserves the exact pre-promotion behavior for the memory
     // mirror; the canonical table supersession already committed above.
     if (oldEntry) {
-        // Best-effort: saveDecision already committed the canonical mutation (new
-        // decision created + old row superseded). If this legacy memory-weaken
-        // throws, do NOT fail the command — a retry would find no active decision
-        // for the old memory and create a duplicate active successor. Warn instead
-        // (codex review 2026-05-28).
+        // Best-effort: saveDecision already committed. Failing here would make a retry find no active
+        // decision for the old memory and create a duplicate active successor, so warn instead.
         try {
             oldEntry.half_life_days = Math.max(1, Math.floor(oldEntry.half_life_days / 2));
             oldEntry.confidence = 'stale';
@@ -373,7 +363,6 @@ function decideCreate(hippoRoot, tenantId, decisionText, flags) {
 // Strict positive-integer parse for incident id args. parseInt() alone accepts
 // trailing junk ("1abc" -> 1), which would let a mutating subcommand (close/
 // resolve) silently hit the wrong row; require the whole arg to be digits.
-// (codex P2, 2026-05-29.)
 function parsePositiveIncidentId(idRaw) {
     const s = String(idRaw ?? '').trim();
     const id = parseInt(s, 10);

package/dist/cli/explain.js

@@ -3,6 +3,7 @@ import { confidenceFacets } from '../memory.js';
 import { isInitialized } from '../store/open.js';
 import { loadSearchEntries } from '../store/search-rows.js';
 import { loadIndex } from '../store/index-and-stats.js';
+import { DEFAULT_RECALL_BUDGET } from '../search/types.js';
 import { loadConfig } from '../config.js';
 import { dropHeldCopies } from '../same-text.js';
 import { detectScope } from '../scope.js';
@@ -27,7 +28,7 @@ function noteScopeHidden(hippoRoot, globalRoot, query, tenantId, requested) {
 }
 export async function cmdExplain(hippoRoot, query, flags) {
     requireInit(hippoRoot);
-    const budget = parseBudgetFlag(flags['budget'], 4000);
+    const budget = parseBudgetFlag(flags['budget'], DEFAULT_RECALL_BUDGET);
     const limit = parseLimitFlag(flags['limit']);
     const asJson = Boolean(flags['json']);
     const includeSuperseded = Boolean(flags['include-superseded']);

package/dist/cli/goals.js

@@ -4,7 +4,7 @@ import * as api from '../api.js';
 import { resolveTenantId } from '../tenant.js';
 import { printError } from './output.js';
 // ---------------------------------------------------------------------------
-// `hippo goal <push|list|complete|suspend|resume>` — B3 dlPFC depth (Task 10)
+// `hippo goal <push|list|complete|suspend|resume>`
 // ---------------------------------------------------------------------------
 const GOAL_POLICY_TYPES = [
     'schema-fit-biased',

package/dist/cli/init.js

@@ -242,7 +242,7 @@ function refreshShippedBlock(filePath, text, hook) {
 /** Claude Code settings hooks, Codex's hooks.json and the OpenCode plugin, under the home directory; idempotent, so re-running init adds newer hooks. */
 function installUserLevelHooks(agents, codexHint) {
     for (const hook of agents) {
-        // The Codex capture wrapper swaps the codex launcher binary, so init only points at the opt-in (issue #133).
+        // The Codex capture wrapper swaps the codex launcher binary, so init only points at the opt-in.
         if (hook === 'codex' && codexHint && !isCodexWrapperInstalled()) {
             console.log('   Codex detected. To capture Codex sessions: hippo hook install codex');
         }