hippo-memory 1.52.9 → 1.53.1

package/dist/agent-memories/sync.js

@@ -0,0 +1,336 @@
+// Runs the adapters and routes each container to its store: the project pass, the user pass and their call sites (plan designs 2, 8, 11).
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { errorMessage } from '../capture.js';
+import { loadConfig } from '../config.js';
+import { closeHippoDb, isSqliteBusy, openHippoDb } from '../db.js';
+import { deriveOriginProject, isGlobalStoreRoot, resolveGlobalRootDir } from '../project-identity.js';
+import { duplicateKey, heldTextKeys } from '../same-text.js';
+import { initStore, isInitialized, removeEntryMirrors, selectLiveEntriesBySourcePrefix, updateStats, writeEntryMirrors } from '../store.js';
+import { resolveTenantId } from '../tenant.js';
+import { setAsideRow, syncContainer } from './apply.js';
+import { claudeCodeAdapter, claudeTranscriptListing } from './claude-code.js';
+import { codexAdapter } from './codex.js';
+import { copilotAdapter } from './copilot.js';
+import { geminiAdapter } from './gemini.js';
+import { legacyWork } from './legacy.js';
+import { openclawAdapter } from './openclaw.js';
+import { qwenCodeAdapter } from './qwen-code.js';
+import { addTally, emptyReport, mergeReports, toolReport } from './report.js';
+import { containerId, containerPrefix, splitSource } from './source.js';
+import { AGENT_MEMORY_SOURCE_PREFIX, AGENT_MEMORY_TOOLS, isToolId, toolSourcePrefix } from './tools.js';
+export const ADAPTERS = [claudeCodeAdapter, codexAdapter, geminiAdapter, copilotAdapter, openclawAdapter, qwenCodeAdapter];
+/** Overrides config because `hippo init` creates the store in the same command that imports (plan design 11). */
+export const TOOLS_ENV = 'HIPPO_AGENT_MEMORY_TOOLS';
+export function currentMachine() {
+    return { home: os.homedir(), env: process.env, platform: process.platform };
+}
+/** init, sleep, `import --agents` and the daily runner: a local store gets its project pass then the user pass; the global store the user pass only. */
+export function importForStore(hippoRoot, opts) {
+    if (isGlobalStoreRoot(hippoRoot))
+        return importUserMemories(hippoRoot, opts);
+    const report = importProjectMemories(hippoRoot, opts);
+    mergeReports(report, importUserMemories(hippoRoot, opts));
+    return report;
+}
+/** A local store's project pass with legacy adoption; `init --scan` runs it per repository and the user pass once. */
+export function importProjectMemories(hippoRoot, opts) {
+    const ctx = context(opts.machine, { projectRoot: path.dirname(hippoRoot) });
+    return runPass({
+        scope: 'project', target: hippoRoot, invoking: hippoRoot, list: (a) => a.list(ctx, 'project'), legacy: true, originProject: undefined, handover: true,
+    }, opts);
+}
+/** Every tool's user-level memory into the global store, created on demand, with no origin. */
+export function importUserMemories(invokingRoot, opts) {
+    const ctx = context(opts.machine, {});
+    return runPass({
+        scope: 'user', target: resolveGlobalRootDir(), invoking: invokingRoot, list: (a) => a.list(ctx, 'user'), legacy: false, originProject: '', handover: false,
+    }, opts);
+}
+/** Session end in a folder with no store of its own: the session's project into the global store with its origin, then the user pass. */
+export function importAtSessionEnd(cwd, transcriptPath, opts) {
+    const globalRoot = resolveGlobalRootDir();
+    const ctx = context(opts.machine, { projectRoot: cwd, transcriptPath });
+    const report = runPass({
+        scope: 'project', target: globalRoot, invoking: globalRoot, list: (a) => a.list(ctx, 'project'), legacy: false, originProject: deriveOriginProject(cwd), handover: false,
+    }, opts);
+    mergeReports(report, importUserMemories(globalRoot, opts));
+    return report;
+}
+/** Post-compact: the transcript folder's notes only, with no git call, no legacy adoption and no user pass, as the hook has 10 seconds. */
+export function importAtCompaction(hippoRoot, transcriptPath, originProject, opts) {
+    const ctx = context(opts.machine, {});
+    return runPass({
+        scope: 'project', target: hippoRoot, invoking: hippoRoot, legacy: false, originProject, handover: false,
+        list: (a) => (a.tool === 'claude-code' ? claudeTranscriptListing(ctx, transcriptPath) : null),
+    }, opts);
+}
+function context(machine, extra) {
+    return { home: machine.home, env: machine.env, platform: machine.platform, ...extra };
+}
+/** The variable when set (empty or `none` is off); else the tools both the invoking and the target store's config allow. */
+export function allowedTools(env, invoking, target, warnings) {
+    const fromEnv = env[TOOLS_ENV];
+    if (fromEnv !== undefined) {
+        const listed = fromEnv.trim().toLowerCase() === 'none' ? [] : fromEnv.split(',').map((t) => t.trim()).filter((t) => t !== '');
+        return knownTools(listed, TOOLS_ENV, warnings);
+    }
+    const mine = configuredTools(invoking, warnings);
+    const theirs = configuredTools(target, warnings);
+    return new Set(AGENT_MEMORY_TOOLS.map((t) => t.id).filter((id) => (mine === null || mine.has(id)) && (theirs === null || theirs.has(id))));
+}
+function configuredTools(root, warnings) {
+    const tools = loadConfig(root).agentMemories.tools;
+    return tools === null ? null : knownTools(tools, 'config agentMemories.tools', warnings);
+}
+function knownTools(ids, where, warnings) {
+    const out = new Set();
+    for (const id of ids) {
+        if (isToolId(id))
+            out.add(id);
+        else
+            warnings.push(`${where}: unknown agent memory tool "${id}" ignored (known: ${AGENT_MEMORY_TOOLS.map((t) => t.id).join(', ')})`);
+    }
+    return out;
+}
+function runPass(pass, opts) {
+    const report = emptyReport();
+    const allowed = allowedTools(opts.machine.env, pass.invoking, pass.target, report.warnings);
+    const listings = ADAPTERS.filter((a) => allowed.has(a.tool)).flatMap((a) => listSafely(a, pass, report));
+    const hasItems = listings.some((l) => l.containers.some((c) => c.items.length > 0));
+    let store = null;
+    let synced = [];
+    try {
+        store = openTarget(pass.target, hasItems, opts);
+        if (store !== null)
+            synced = syncStore(pass, listings, store, opts, report);
+    }
+    catch (err) {
+        report.warnings.push(`agent memories not synced into ${pass.target}: ${isSqliteBusy(err) ? 'the store was busy' : errorMessage(err)}`);
+    }
+    finally {
+        store?.close();
+    }
+    if (pass.handover && !opts.dryRun)
+        handOver(synced, path.dirname(pass.target), opts, report);
+    return report;
+}
+function listSafely(adapter, pass, report) {
+    const tool = toolReport(report, adapter.tool);
+    let listing;
+    try {
+        listing = pass.list(adapter);
+    }
+    catch (err) {
+        report.warnings.push(`${tool.label}: ${errorMessage(err)}`);
+        return [];
+    }
+    if (listing === null)
+        return [];
+    if (!tool.homes.includes(listing.home))
+        tool.homes.push(listing.home);
+    report.warnings.push(...listing.warnings.map((w) => `${tool.label}: ${w}`));
+    for (const c of listing.containers) {
+        tool.containers.push({ scope: c.scope, path: c.path, store: pass.target, items: c.items.length, readable: c.readable });
+        report.warnings.push(...c.warnings.map((w) => `${tool.label}: ${w}`));
+    }
+    return [listing];
+}
+/** A store that does not exist yet is created only when there is something to put in it; a dry run plans against an empty stand-in. */
+function openTarget(target, hasItems, opts) {
+    const global = isGlobalStoreRoot(target);
+    if (!isInitialized(target)) {
+        if (opts.dryRun)
+            return emptyStandIn(global);
+        if (!hasItems)
+            return null;
+        initStore(target);
+    }
+    const db = openHippoDb(target, { busyWaitMs: opts.busyWaitMs });
+    return { db, root: target, global, close: () => closeHippoDb(db) };
+}
+function emptyStandIn(global) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'hippo-agent-memories-'));
+    const db = openHippoDb(root);
+    return {
+        db, root, global,
+        close: () => {
+            closeHippoDb(db);
+            fs.rmSync(root, { recursive: true, force: true });
+        },
+    };
+}
+function syncStore(pass, listings, store, opts, report) {
+    const tenantId = resolveTenantId({});
+    const legacy = pass.legacy ? legacyWork(store.db, tenantId, listings) : null;
+    const session = {
+        db: store.db,
+        hippoRoot: store.root,
+        tenantId,
+        baseHalfLifeDays: loadConfig(store.root).defaultHalfLifeDays,
+        originProject: pass.originProject,
+        isDuplicate: duplicateCheck(store, tenantId, pass.originProject, legacy?.adopted ?? new Set()),
+        dryRun: opts.dryRun === true,
+    };
+    // A project's rows in the global store are parted by origin: a worktree and its main checkout share a Claude folder.
+    const partition = store.global && pass.scope === 'project' ? pass.originProject ?? '' : null;
+    const synced = [];
+    let remembered = 0;
+    for (const listing of listings) {
+        const tool = toolOf(listing.tool);
+        const out = toolReport(report, tool.id);
+        for (const container of listing.containers) {
+            if (!container.readable) {
+                out.tally.unreadable++;
+                continue;
+            }
+            const work = containerWork(tool, container, opts.machine.platform, legacy, partition ?? '');
+            const outcome = syncOne(session, work, out, report);
+            if (outcome === null)
+                continue;
+            synced.push(work);
+            remembered += outcome.tally.imported + outcome.tally.replaced;
+            if (!session.dryRun)
+                afterCommit(store.root, outcome, report);
+        }
+        if (session.dryRun)
+            out.unlisted += unlistedRows(store.db, tenantId, tool, pass.scope, listing, opts.machine.platform, partition);
+    }
+    if (remembered > 0 && !session.dryRun)
+        bumpRemembered(store.root, remembered, report);
+    return synced;
+}
+function containerWork(tool, container, platform, legacy, origin) {
+    const none = new Map();
+    const own = tool.id === 'claude-code' ? legacy?.byContainer.get(container.path) : undefined;
+    return {
+        tool,
+        container,
+        prefix: containerPrefix(tool.id, containerId(container.path, container.scope, platform, origin)),
+        adopt: own?.adopt ?? none,
+        replace: own?.replace ?? none,
+    };
+}
+/** Null when the container was skipped: a busy store waits for the next sync, any other failure is a warning and the sync goes on. */
+function syncOne(session, work, out, report) {
+    try {
+        const outcome = syncContainer(session, work);
+        addTally(out.tally, outcome.tally);
+        return outcome;
+    }
+    catch (err) {
+        if (isSqliteBusy(err)) {
+            out.tally.busy++;
+            report.warnings.push(`${out.label}: ${work.container.path} skipped, the store was busy`);
+        }
+        else {
+            report.warnings.push(`${out.label}: ${work.container.path} not synced: ${errorMessage(err)}`);
+        }
+        return null;
+    }
+}
+function afterCommit(root, outcome, report) {
+    for (const entry of outcome.mirror)
+        writeEntryMirrors(root, entry);
+    for (const id of outcome.purge) {
+        try {
+            removeEntryMirrors(root, id);
+        }
+        catch (err) {
+            // rebuildIndex would bring the row back live, and the next sync sets it aside again.
+            report.warnings.push(`mirror of ${id} not removed: ${errorMessage(err)}`);
+        }
+    }
+}
+function bumpRemembered(root, remembered, report) {
+    try {
+        updateStats(root, { remembered });
+    }
+    catch (err) {
+        report.warnings.push(`remembered counter not updated: ${errorMessage(err)}`);
+    }
+}
+/** Design 6: only text stored by another path counts, and in the global store only rows visible where the new row goes. */
+function duplicateCheck(store, tenantId, origin, adopted) {
+    let keys = null;
+    return (text) => {
+        keys ??= otherPathKeys(store, tenantId, origin ?? '', adopted);
+        return keys.has(duplicateKey(text));
+    };
+}
+function otherPathKeys(store, tenantId, origin, adopted) {
+    const visible = store.global ? ` AND (origin_project = '' OR origin_project = ?)` : '';
+    const params = store.global ? [tenantId, AGENT_MEMORY_SOURCE_PREFIX, origin] : [tenantId, AGENT_MEMORY_SOURCE_PREFIX];
+    // SAFETY: the SELECT names the three columns of the row type.
+    const rows = store.db.prepare(`SELECT id, content, source FROM memories
+      WHERE tenant_id = ? AND superseded_by IS NULL AND substr(source, 1, ${AGENT_MEMORY_SOURCE_PREFIX.length}) != ?${visible}`).all(...params);
+    return new Set(rows.filter((r) => !adopted.has(r.id)).flatMap(heldTextKeys));
+}
+/** Dry run only: kept rows of this scope in containers this run did not list (a moved project's old folder); `partition` limits it to one origin. */
+function unlistedRows(db, tenantId, tool, scope, listing, platform, partition) {
+    const listed = listing.containers.map((c) => containerPrefix(tool.id, containerId(c.path, c.scope, platform, partition ?? '')));
+    return selectLiveEntriesBySourcePrefix(db, tenantId, `${toolSourcePrefix(tool.id)}${scope === 'project' ? 'p' : 'u'}-`)
+        .filter((row) => row.tags.includes(tool.tag) && !listed.some((p) => row.source.startsWith(p)))
+        .filter((row) => partition === null || (row.origin_project ?? '') === partition).length;
+}
+/** Design 2's handover: rows the store-less hook path left in the global store, under this project's origin, for containers its store now syncs. */
+function handOver(synced, projectRoot, opts, report) {
+    const globalRoot = resolveGlobalRootDir();
+    if (synced.length === 0 || !isInitialized(globalRoot))
+        return;
+    let db;
+    try {
+        db = openHippoDb(globalRoot, { busyWaitMs: opts.busyWaitMs });
+        const tenantId = resolveTenantId({});
+        // A folder with no git and no marker wrote as '' before its store existed, and as its own name after.
+        const origins = [...new Set([deriveOriginProject(projectRoot), ''])];
+        for (const work of synced)
+            handOverContainer(db, globalRoot, tenantId, work, origins, opts.machine.platform, report);
+    }
+    catch (err) {
+        report.warnings.push(`global copies not handed over: ${isSqliteBusy(err) ? 'the global store was busy' : errorMessage(err)}`);
+    }
+    finally {
+        if (db)
+            closeHippoDb(db);
+    }
+}
+function handOverContainer(db, root, tenantId, work, origins, platform, report) {
+    // A note the local pass could not read has no local row yet, so its global copy stays until it does.
+    const unread = new Set(work.container.skipped);
+    const mirror = [];
+    const purge = [];
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        for (const origin of origins) {
+            const prefix = containerPrefix(work.tool.id, containerId(work.container.path, work.container.scope, platform, origin));
+            for (const row of selectLiveEntriesBySourcePrefix(db, tenantId, prefix)) {
+                if (!row.tags.includes(work.tool.tag) || unread.has(splitSource(row.source, prefix).key))
+                    continue;
+                const result = setAsideRow(db, work.tool.tag, row, 'handover');
+                if (result.kind === 'untagged')
+                    mirror.push(result.entry);
+                else
+                    purge.push(result.id);
+            }
+        }
+        db.exec('COMMIT');
+    }
+    catch (err) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { /* already rolled back; keep the original error */ }
+        throw err;
+    }
+    toolReport(report, work.tool.id).tally.handedOver += mirror.length + purge.length;
+    afterCommit(root, { mirror, purge }, report);
+}
+function toolOf(id) {
+    const tool = AGENT_MEMORY_TOOLS.find((t) => t.id === id);
+    if (tool === undefined)
+        throw new Error(`agent memory sync: no tool ${id}`);
+    return tool;
+}
+//# sourceMappingURL=sync.js.map

package/dist/agent-memories/tools.d.ts

@@ -0,0 +1,33 @@
+export declare const AGENT_MEMORY_TOOLS: readonly [{
+    readonly id: "claude-code";
+    readonly tag: "claude-code-memory";
+    readonly label: "Claude Code";
+}, {
+    readonly id: "codex";
+    readonly tag: "codex-memory";
+    readonly label: "Codex";
+}, {
+    readonly id: "gemini";
+    readonly tag: "gemini-memory";
+    readonly label: "Gemini CLI";
+}, {
+    readonly id: "copilot";
+    readonly tag: "copilot-memory";
+    readonly label: "Copilot";
+}, {
+    readonly id: "openclaw";
+    readonly tag: "openclaw-memory";
+    readonly label: "OpenClaw";
+}, {
+    readonly id: "qwen-code";
+    readonly tag: "qwen-code-memory";
+    readonly label: "Qwen Code";
+}];
+export type AgentMemoryTool = (typeof AGENT_MEMORY_TOOLS)[number];
+export type ToolId = AgentMemoryTool['id'];
+export declare const AGENT_MEMORY_SOURCE_PREFIX = "agent-memory:";
+/** Every imported row of a tool has a source starting with this. */
+export declare function toolSourcePrefix(id: ToolId): string;
+export declare const AGENT_MEMORY_TAGS: readonly string[];
+export declare function isToolId(value: string): value is ToolId;
+//# sourceMappingURL=tools.d.ts.map

package/dist/agent-memories/tools.js

@@ -0,0 +1,19 @@
+// The agents whose own memories hippo imports. A leaf module: the keep rule, merge and share lists are built from it.
+export const AGENT_MEMORY_TOOLS = [
+    { id: 'claude-code', tag: 'claude-code-memory', label: 'Claude Code' },
+    { id: 'codex', tag: 'codex-memory', label: 'Codex' },
+    { id: 'gemini', tag: 'gemini-memory', label: 'Gemini CLI' },
+    { id: 'copilot', tag: 'copilot-memory', label: 'Copilot' },
+    { id: 'openclaw', tag: 'openclaw-memory', label: 'OpenClaw' },
+    { id: 'qwen-code', tag: 'qwen-code-memory', label: 'Qwen Code' },
+];
+export const AGENT_MEMORY_SOURCE_PREFIX = 'agent-memory:';
+/** Every imported row of a tool has a source starting with this. */
+export function toolSourcePrefix(id) {
+    return `${AGENT_MEMORY_SOURCE_PREFIX}${id}:`;
+}
+export const AGENT_MEMORY_TAGS = AGENT_MEMORY_TOOLS.map((t) => t.tag);
+export function isToolId(value) {
+    return AGENT_MEMORY_TOOLS.some((t) => t.id === value);
+}
+//# sourceMappingURL=tools.js.map

package/dist/agent-memories/types.d.ts

@@ -0,0 +1,42 @@
+import type { ToolId } from './tools.js';
+export type Scope = 'project' | 'user';
+/** All an adapter may know about the machine; it reads nothing else from the process, so tests can fake it all. */
+export interface AdapterContext {
+    readonly home: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly platform: NodeJS.Platform;
+    readonly projectRoot?: string;
+    /** Claude Code's transcript at a hook: its folder's `memory/` holds that session's own notes. */
+    readonly transcriptPath?: string;
+}
+export interface MemoryItem {
+    /** A path inside the container with '/' separators, or `<heading slug>/<text hash>` in a single-file store. */
+    readonly key: string;
+    readonly text: string;
+    readonly updatedAt: number;
+}
+/** A folder, or one file's memory section, that exists on disk. */
+export interface Container {
+    readonly scope: Scope;
+    readonly path: string;
+    /** False when it exists but could not be read or failed its shape check, so nothing in it is set aside. */
+    readonly readable: boolean;
+    readonly items: readonly MemoryItem[];
+    /** Keys of items on disk that were not read (too big, not text, a failed read); their rows are left alone. */
+    readonly skipped: readonly string[];
+    readonly warnings: readonly string[];
+    /** Keys made from text, so an edit is matched by heading rather than by key. */
+    readonly textKeyed: boolean;
+}
+export interface Listing {
+    readonly tool: ToolId;
+    readonly home: string;
+    readonly containers: readonly Container[];
+    /** Problems finding containers, such as a malformed index file; an unlisted container is left alone. */
+    readonly warnings: readonly string[];
+}
+export interface Adapter {
+    readonly tool: ToolId;
+    list(ctx: AdapterContext, scope: Scope): Listing;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/agent-memories/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/api.d.ts

@@ -1038,7 +1038,7 @@ export declare function getContext(ctx: Context, opts?: ContextOpts): Promise<Co
  * (consolidate + dedup + audit + share + ambient) and return structured counts.
  *
  * Extracted from `cmdSleepCore` Phase 2-6 in Episode A. NOT covered by api.sleep:
- * the cli-only auto-learn phase (Phase 1: learnFromRepo + learnFromMemoryMd),
+ * the cli-only auto-learn phase (Phase 1: learnFromRepo + the agent memory import),
  * which is intrinsically host-bound (uses `process.cwd()` / `os.homedir()`).
  * Auto-learn stays in cli.ts cmdSleepCore as a pre-api block.
  *
@@ -1195,7 +1195,7 @@ export interface SleepResult {
  * api.sleep itself will need to scope dedup / audit / delete by ctx.tenantId.
  *
  * Dedup and audit deletes each log a `forget` row with the ctx actor and a
- * `metadata.reason`. Pinned and raw rows are never auto-deleted (canAutoDelete).
+ * `metadata.reason`. Pinned, raw, kept and object-backing rows are never auto-deleted (AUTOMATIC_DELETE_SQL).
  * dryRun previews consolidate, dedup and audit, then returns before share/ambient.
  */
 /**

package/dist/api.js

@@ -8,7 +8,7 @@
  */
 import { createHash } from 'node:crypto';
 import { openHippoDb, closeHippoDb } from './db.js';
-import { writeEntry, writeEntryDbOnly, strengthenRetrieved, stampOriginProject, writeEntryMirrors, readEntry, deleteEntry, loadRecallSearchEntries, loadEntriesByIds, loadChildrenOf, loadFreshRawMemories, loadSessionRawMemories, countSessionRawMemories, DEFAULT_SEARCH_CANDIDATE_LIMIT, removeEntryMirrors, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, loadLatestHandoff, listSessionEvents, SNAPSHOT_AMBIENT_MAX_AGE_MS, loadIndex, saveIndex, loadAllEntries, loadAmbientCandidates, updateStats, isInitialized, markSummaryDirtyInTx, auditRejectionRefusal, } from './store.js';
+import { writeEntry, writeEntryDbOnly, strengthenRetrieved, stampOriginProject, writeEntryMirrors, readEntry, deleteEntry, loadRecallSearchEntries, loadEntriesByIds, loadChildrenOf, loadFreshRawMemories, loadSessionRawMemories, countSessionRawMemories, DEFAULT_SEARCH_CANDIDATE_LIMIT, removeEntryMirrors, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, loadLatestHandoff, listSessionEvents, SNAPSHOT_AMBIENT_MAX_AGE_MS, loadIndex, saveIndex, loadAllEntries, loadAmbientCandidates, updateStats, isInitialized, markSummaryDirtyInTx, auditRejectionRefusal, memoriesBackingObjects, } from './store.js';
 import { RejectedValueError } from './rejection.js';
 import { rejectValue, unrejectValue, listRejectionsForTenant } from './reject-flow.js';
 import { listDormantRows, readDormantSnapshot, deleteDormantRow, hasDormantRow, } from './dormant.js';
@@ -17,7 +17,7 @@ import { detectInstruction } from './instruction-detect.js';
 import { quarantineScopeFor, recordQuarantine, getQuarantineRow, listQuarantineRows, approveQuarantineRow, rejectQuarantineRow, } from './quarantine.js';
 import { summarizeFailures } from './failure-log.js';
 import { formatHandoffEvidenceLine } from './handoff.js';
-import { createMemory, applyOutcome, calculateStrength, Layer, CHURN_STALE_TAG, } from './memory.js';
+import { createMemory, createSuccessor, applyOutcome, calculateStrength, CHURN_STALE_TAG, COMPACTION_MEMORY_TAG, } from './memory.js';
 import { appendAuditEvent, queryAuditEvents, auditMemories, isContentWorthStoring, } from './audit.js';
 import { promoteToGlobal, getGlobalRoot, autoShare, searchBothHybrid } from './shared.js';
 import { writeRecallTrace, writeRecallTraceAtRoot, recordTraceOutcome } from './recall-trace.js';
@@ -1202,14 +1202,8 @@ export function supersede(ctx, oldId, newContent) {
     if (old.superseded_by) {
         throw new Error(`Memory ${oldId} is already superseded by ${old.superseded_by}. Supersede that one instead.`);
     }
-    const newEntry = createMemory(newContent, {
-        layer: old.layer ?? Layer.Episodic,
-        tags: [...old.tags],
-        pinned: old.pinned,
-        source: old.source,
-        confidence: 'verified',
+    const newEntry = createSuccessor(old, newContent, {
         tenantId: ctx.tenantId,
-        scope: old.scope,
         baseHalfLifeDays: loadConfig(ctx.hippoRoot).defaultHalfLifeDays,
     });
     // Race-safe transition: open a fresh db handle, BEGIN IMMEDIATE, run all
@@ -1549,13 +1543,13 @@ export async function getContext(ctx, opts = {}) {
     if (budget <= 0) {
         return { entries: [], tokens: 0 };
     }
-    // Pinned-only path is allowed against an un-initialised local store (the
-    // UserPromptSubmit hook can run in directories without a .hippo). Non-pinned
-    // path requires an initialised local store; callers should check first.
+    // Global memories do not establish a project boundary for task state.
     const hasLocal = isInitialized(ctx.hippoRoot);
     const query = (opts.q ?? '').trim() || '*';
     const globalRoot = getGlobalRoot();
     const hasGlobal = isInitialized(globalRoot);
+    const primaryIsGlobal = isGlobalStoreRoot(ctx.hippoRoot);
+    const hasLocalTaskState = hasLocal && !primaryIsGlobal;
     // v39 memory scope isolation (docs/plans/2026-07-01-memory-scope-isolation.md).
     // S2: envelope-filter parity with api.recall for AMBIENT context - private
     // scopes and quarantine buckets never inject. `requested` is deliberately
@@ -1598,7 +1592,7 @@ export async function getContext(ctx, opts = {}) {
     // unbounded; see loadFreshActiveTaskSnapshot's own doc comment for the
     // exact null/empty-id matching rules.
     const rowScope = (r) => r?.scope ?? null;
-    const rawActiveSnapshot = hasLocal
+    const rawActiveSnapshot = hasLocalTaskState
         ? loadFreshActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId, {
             sessionId: opts.currentSessionId,
         })
@@ -1609,7 +1603,7 @@ export async function getContext(ctx, opts = {}) {
         ? rawActiveSnapshot
         : null;
     // Key on the RAW snapshot: a scope-hidden active session must not fall through to another session's ambient handoff.
-    const rawSessionHandoff = !hasLocal
+    const rawSessionHandoff = !hasLocalTaskState
         ? null
         : rawActiveSnapshot?.session_id
             ? loadLatestHandoff(ctx.hippoRoot, ctx.tenantId, rawActiveSnapshot.session_id)
@@ -1623,7 +1617,7 @@ export async function getContext(ctx, opts = {}) {
         ? rawSessionHandoff
         : null;
     // Raw session id here too: each event is admitted on its own scope, same as recall and the CLI.
-    const recentSessionEvents = hasLocal && rawActiveSnapshot?.session_id
+    const recentSessionEvents = hasLocalTaskState && rawActiveSnapshot?.session_id
         ? listSessionEvents(ctx.hippoRoot, ctx.tenantId, {
             session_id: rawActiveSnapshot.session_id,
             limit: 5,
@@ -1642,14 +1636,19 @@ export async function getContext(ctx, opts = {}) {
         }
         return ambientAdmitEntry(e, currentProjectName, includeCrossProject);
     };
+    const ownSessionId = opts.currentSessionId || '';
+    // Inside admit, not after the load, so the loader's window widens past a session's own items.
+    const isOwnCompactionItem = (e) => ownSessionId !== '' &&
+        e.source_session_id === ownSessionId &&
+        e.tags.includes(COMPACTION_MEMORY_TAG);
     // Superseded rows never inject; which rows reach ambientAdmitEntry matters because it regex-scans content for secrets.
-    const admit = (e) => !e.superseded_by && ambientAdmit(e);
+    const admit = (e) => !e.superseded_by && !isOwnCompactionItem(e) && ambientAdmit(e);
     // Tenant-scoped loads (v1.11.1 lesson: NEVER resolveTenantId({}) here).
     const localLoad = hasLocal
         ? loadAmbientEntries(ctx.hippoRoot, ctx.tenantId, pinnedOnly, includeRecent, admit, recallRequest)
         : { entries: [] };
-    const globalLoad = hasGlobal
-        ? loadAmbientEntries(globalRoot, ctx.tenantId, pinnedOnly, includeRecent, admit, !isGlobalStoreRoot(ctx.hippoRoot) ? recallRequest : undefined)
+    const globalLoad = hasGlobal && !primaryIsGlobal
+        ? loadAmbientEntries(globalRoot, ctx.tenantId, pinnedOnly, includeRecent, admit, recallRequest)
         : { entries: [] };
     let localEntries = localLoad.entries;
     let globalEntries = globalLoad.entries;
@@ -1683,7 +1682,7 @@ export async function getContext(ctx, opts = {}) {
         const pinnedLocal = localPool.filter((e) => e.pinned);
         const pinnedGlobal = globalPool.filter((e) => e.pinned);
         const rankedPinned = [
-            ...pinnedLocal.map((e) => ({ entry: e, isGlobal: false })),
+            ...pinnedLocal.map((e) => ({ entry: e, isGlobal: primaryIsGlobal })),
             ...pinnedGlobal.map((e) => ({ entry: e, isGlobal: true })),
         ]
             .map(({ entry, isGlobal }) => {
@@ -1749,7 +1748,7 @@ export async function getContext(ctx, opts = {}) {
                     if (seenCandidateIds.has(e.id))
                         continue;
                     seenCandidateIds.add(e.id);
-                    candidateItems.push({ id: e.id, tokens: contentTokens(e.content), entry: e, isGlobal: false });
+                    candidateItems.push({ id: e.id, tokens: contentTokens(e.content), entry: e, isGlobal: primaryIsGlobal });
                 }
                 for (const e of globalCandidates) {
                     if (seenCandidateIds.has(e.id))
@@ -1772,7 +1771,7 @@ export async function getContext(ctx, opts = {}) {
         }
         else if (includeRecent > 0) {
             const recent = [
-                ...localPool.map((entry) => ({ entry, isGlobal: false })),
+                ...localPool.map((entry) => ({ entry, isGlobal: primaryIsGlobal })),
                 ...globalPool.map((entry) => ({ entry, isGlobal: true })),
             ]
                 // T2 (src/compare.ts) note: this already carries an explicit
@@ -1847,8 +1846,8 @@ export async function getContext(ctx, opts = {}) {
             .map((e) => ({
             entry: e,
             score: calculateStrength(e, now),
-            tokens: price(e, false),
-            isGlobal: false,
+            tokens: price(e, primaryIsGlobal),
+            isGlobal: primaryIsGlobal,
         }))
             .sort(compareScoredResults);
         const globalRanked = globalPool
@@ -1873,7 +1872,7 @@ export async function getContext(ctx, opts = {}) {
         // Real query: hybrid search (global + local) or physics+hybrid (local only).
         let results;
         const minResults = cost ? 0 : undefined; // a priced block skips an oversize top hit too, so the budget bounds it
-        if (hasGlobal) {
+        if (hasGlobal && !primaryIsGlobal) {
             // searchBothHybrid loads from the store roots itself, so the ambient
             // filter above never saw its candidates. Admission runs INSIDE the
             // search via the opt-in entryFilter, BEFORE ranking, cross-store
@@ -1901,7 +1900,7 @@ export async function getContext(ctx, opts = {}) {
         else {
             const ctxConfig = loadConfig(ctx.hippoRoot);
             const usePhysicsCtx = ctxConfig.physics?.enabled !== false;
-            const localCost = cost && ((r) => price(r.entry, false));
+            const localCost = cost && ((r) => price(r.entry, primaryIsGlobal));
             const ctxResults = usePhysicsCtx
                 ? await physicsSearch(query, localEntries, {
                     budget: left,
@@ -1921,8 +1920,8 @@ export async function getContext(ctx, opts = {}) {
             results = ctxResults.map((r) => ({
                 entry: r.entry,
                 score: r.score,
-                tokens: price(r.entry, false),
-                isGlobal: false,
+                tokens: price(r.entry, primaryIsGlobal),
+                isGlobal: primaryIsGlobal,
             }));
         }
         selectedItems = results;
@@ -1949,7 +1948,7 @@ export async function getContext(ctx, opts = {}) {
                 closeHippoDb(localDb);
             }
         }
-        if (hasGlobal) {
+        if (hasGlobal && !primaryIsGlobal) {
             const globalDb = openHippoDb(globalRoot);
             try {
                 appendAuditEvent(globalDb, {
@@ -2444,7 +2443,7 @@ export async function sleep(ctx, opts = {}) {
         // Phase 3: Quality audit (remove junk, report warnings; a dry run skips rows earlier phases would remove).
         const planned = new Set(dryRun ? [...(consolidateResult.removedIds ?? []), ...dedupResult.pairs.map((p) => p.removed)] : []);
         const allEntries = phases.loadAllEntries(ctx.hippoRoot).filter((e) => !planned.has(e.id));
-        const auditOut = phases.auditMemories(allEntries);
+        const auditOut = phases.auditMemories(allEntries, memoriesBackingObjects(ctx.hippoRoot));
         if (auditOut.issues.length > 0) {
             const errors = auditOut.issues.filter((i) => i.severity === 'error');
             const warnings = auditOut.issues.filter((i) => i.severity === 'warning');

package/dist/audit.d.ts

@@ -14,10 +14,11 @@ export interface AuditResult {
     clean: number;
 }
 export declare const STOP_WORDS: Set<string>;
-export declare function auditMemory(entry: MemoryEntry): AuditIssue | null;
-export declare function auditMemories(entries: MemoryEntry[]): AuditResult;
+export declare function auditMemory(entry: MemoryEntry, backsObject?: boolean): AuditIssue | null;
+/** `backing`: ids of memories that back an object (store.memoriesBackingObjects). */
+export declare function auditMemories(entries: MemoryEntry[], backing: ReadonlySet<string>): AuditResult;
 export declare function isContentWorthStoring(content: string): boolean;
-export declare const AUDIT_OPS: readonly ["remember", "recall", "promote", "supersede", "forget", "archive_raw", "auth_revoke", "auth_create", "outcome", "consolidate", "audit_prune", "summary_marked_dirty", "summary_marked_clean", "summary_rebuilt", "predict_create", "predict_close", "predict_baserate", "recall_autodebias_hint", "recall_autodebias_hint_no_class_match", "recall_autodebias_hint_tiebreak", "recall_anchor_detected_query_repeat", "recall_anchor_detected_memory_dominance", "recall_anchor_skipped_no_session", "recall_availability_detected", "decision_create", "decision_supersede", "decision_close", "incident_open", "incident_resolve", "incident_close", "process_create", "process_supersede", "process_close", "policy_create", "policy_supersede", "policy_close", "skill_create", "skill_supersede", "skill_close", "project_brief_create", "project_brief_supersede", "project_brief_close", "customer_note_create", "customer_note_supersede", "customer_note_close", "mv_rescue", "reject_value", "reject_refusal", "unreject_value", "conflict_resolve", "half_life_migrate", "dormant_restore", "auth_grant", "auth_ungrant", "quarantine", "quarantine_approve", "quarantine_reject"];
+export declare const AUDIT_OPS: readonly ["remember", "recall", "promote", "supersede", "forget", "archive_raw", "auth_revoke", "auth_create", "outcome", "consolidate", "audit_prune", "summary_marked_dirty", "summary_marked_clean", "summary_rebuilt", "predict_create", "predict_close", "predict_baserate", "recall_autodebias_hint", "recall_autodebias_hint_no_class_match", "recall_autodebias_hint_tiebreak", "recall_anchor_detected_query_repeat", "recall_anchor_detected_memory_dominance", "recall_anchor_skipped_no_session", "recall_availability_detected", "decision_create", "decision_supersede", "decision_close", "incident_open", "incident_resolve", "incident_close", "process_create", "process_supersede", "process_close", "policy_create", "policy_supersede", "policy_close", "skill_create", "skill_supersede", "skill_close", "project_brief_create", "project_brief_supersede", "project_brief_close", "customer_note_create", "customer_note_supersede", "customer_note_close", "mv_rescue", "reject_value", "reject_refusal", "unreject_value", "conflict_resolve", "half_life_migrate", "dormant_restore", "auth_grant", "auth_ungrant", "quarantine", "quarantine_approve", "quarantine_reject", "agent_memory_restore", "agent_memory_set_aside"];
 export type AuditOp = (typeof AUDIT_OPS)[number];
 export interface AppendAuditOpts {
     tenantId: string;