hippo-memory 1.68.0 → 1.70.0

package/dist/api/remember.js

@@ -1,13 +1,14 @@
 // Write path: remember stores one memory after secret vetting and, for untrusted content, the instruction check.
-import { writeEntry } from '../store/entry-writes.js';
-import { detectInstruction } from '../instruction-detect.js';
-import { quarantineScopeFor, recordQuarantine } from '../quarantine.js';
-import { createMemory } from '../memory.js';
-import { loadConfig } from '../config.js';
-import { vetSecrets } from '../secret-detect.js';
-import { assertCallerProject } from '../project-identity.js';
-import { BadRequestError } from '../api-errors.js';
-import { assertClientScope, personalScopeOf } from '../recall-scope.js';
+import { stampOriginProject } from '../store/entry-row.js';
+import { detectInstruction } from './instruction-detect.js';
+import { quarantineScopeFor } from '../trust/quarantine.js';
+import { createMemory } from '../core/memory.js';
+import { loadConfig } from '../core/config.js';
+import { vetSecrets } from '../util/secret-detect.js';
+import { assertCallerProject } from '../core/project-identity.js';
+import { BadRequestError } from '../core/api-errors.js';
+import { assertClientScope, personalScopeOf } from '../store/recall-scope.js';
+import { andThen, notPorted, onStore } from './on-store.js';
 /** The scope a write lands in: the caller's own personal scope when asked for, else the client's, which may not be a personal one. */
 function rememberScope(ctx, opts) {
     if (!opts.personal) {
@@ -24,7 +25,7 @@ function rememberScope(ctx, opts) {
     }
     return own;
 }
-export function remember(ctx, opts) {
+function prepareRemember(ctx, opts) {
     if (opts.project)
         assertCallerProject(opts.project);
     const requestedScope = rememberScope(ctx, opts);
@@ -39,29 +40,39 @@ export function remember(ctx, opts) {
         tenantId: ctx.tenantId,
         baseHalfLifeDays: loadConfig(ctx.hippoRoot).defaultHalfLifeDays,
     });
-    // writeEntry threads ctx.actor.subject into its internal audit hook, so exactly
-    // one 'remember' event lands in the log with the supplied actor.
-    const afterWrite = detection.flagged
-        ? (db, memoryId) => {
-            recordQuarantine(db, {
-                tenantId: ctx.tenantId,
-                memoryId,
-                originalScope: requestedScope,
-                reason: detection.reason ?? 'unknown',
-                actor: ctx.actor.subject,
-            });
-            opts.afterWrite?.(db, memoryId);
-        }
-        : opts.afterWrite;
     // Aliases only widen what a reader matches; a row has one origin. A personal row's '' follows its owner into every project.
     const origin = opts.personal ? '' : opts.project?.name;
     const stamped = origin !== undefined ? { ...entry, origin_project: origin } : entry;
-    writeEntry(ctx.hippoRoot, stamped, { actor: ctx.actor.subject, afterWrite });
+    return { entry: stamped, requestedScope, detection, warnings: vetted.warnings };
+}
+function rememberResult(ctx, prepared, written) {
+    const { entry, detection, warnings } = prepared;
     const result = { id: entry.id, kind: entry.kind, tenantId: ctx.tenantId };
     if (detection.flagged)
         result.quarantined = { reason: detection.reason ?? 'unknown' };
-    if (vetted.warnings.length > 0)
-        result.warnings = vetted.warnings;
+    if (warnings.length > 0)
+        result.warnings = [...warnings];
+    if (written?.outcome === 'duplicate')
+        result.duplicate = { memoryId: written.memoryId };
     return result;
 }
+/** A flagged row's review record, which the store writes in the row's own transaction. */
+function quarantineOf({ requestedScope, detection }) {
+    return detection.flagged ? { originalScope: requestedScope, reason: detection.reason ?? 'unknown' } : undefined;
+}
+/** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's subject.
+ *  A write that carries a connector event or untrusted content goes through connectorWrites, which commits its companion rows with it. */
+export function remember(ctx, opts) {
+    return onStore(ctx, (port) => {
+        const entryWrites = port.entryWrites ?? notPorted(port, 'entryWrites');
+        const prepared = prepareRemember(ctx, opts);
+        // A store writes origin_project as given, so the served folder's fallback is stamped here.
+        const write = { entry: stampOriginProject(ctx.hippoRoot, prepared.entry), actor: ctx.actor.subject };
+        if (opts.untrusted !== true && opts.event === undefined)
+            return andThen(entryWrites.writeEntry(write), () => rememberResult(ctx, prepared));
+        const connectorWrites = port.connectorWrites ?? notPorted(port, 'connectorWrites');
+        const written = connectorWrites.writeConnectorEntry({ ...write, event: opts.event, quarantine: quarantineOf(prepared) });
+        return andThen(written, (outcome) => rememberResult(ctx, prepared, outcome));
+    });
+}
 //# sourceMappingURL=remember.js.map

package/dist/api/session-owners.d.ts

@@ -0,0 +1,4 @@
+import { type Context } from './types.js';
+/** Binds `sessionId` to the caller's owner on first use; a session another owner holds is a 409, so the client can set it aside. */
+export declare function bindSessionOwner(ctx: Context, sessionId: string): void;
+//# sourceMappingURL=session-owners.d.ts.map

package/dist/api/session-owners.js

@@ -0,0 +1,17 @@
+// A session id belongs to the first owner that binds it, so one developer's client cannot write into another's session.
+import { ConflictError } from '../core/api-errors.js';
+import { ownerOrSubject } from './types.js';
+import { sessionOwnerOrBind } from '../store/sessions.js';
+import { assertTenantId } from '../store/tenant.js';
+import { DAY_MS } from '../util/time.js';
+/** Bindings older than this are pruned when a new session binds. */
+const BINDING_RETENTION_DAYS = 90;
+/** Binds `sessionId` to the caller's owner on first use; a session another owner holds is a 409, so the client can set it aside. */
+export function bindSessionOwner(ctx, sessionId) {
+    assertTenantId('bindSessionOwner', ctx.tenantId);
+    const owner = ownerOrSubject(ctx.actor);
+    const bound = sessionOwnerOrBind(ctx.hippoRoot, { tenantId: ctx.tenantId, sessionId, owner, retentionMs: BINDING_RETENTION_DAYS * DAY_MS });
+    if (bound !== owner)
+        throw new ConflictError('session id belongs to another caller');
+}
+//# sourceMappingURL=session-owners.js.map

package/dist/api/sleep-run.d.ts

@@ -1,13 +1,13 @@
 import { loadAllEntries } from '../store/entry-reads.js';
 import { deleteEntry } from '../store/delete-and-batch.js';
-import { auditMemories } from '../audit.js';
-import { autoShare } from '../shared.js';
+import { auditMemories } from '../store/audit.js';
+import { autoShare } from '../sharing/shared.js';
 import { consolidate } from '../consolidate/sleep.js';
-import { loadConfig } from '../config.js';
-import { deduplicateStore } from '../dedupe.js';
-import { computeAmbientState } from '../ambient.js';
-import { loadPendingExtractionTenants } from '../graph/read.js';
-import { type ExtractResult } from '../graph-extract.js';
+import { loadConfig } from '../core/config.js';
+import { deduplicateStore } from '../consolidate/dedupe.js';
+import { computeAmbientState } from '../core/ambient.js';
+import { loadPendingExtractionTenants } from '../store/graph-queue.js';
+import { type ExtractResult } from '../graph/extract.js';
 import type { Context } from './types.js';
 import type { SleepOpts, SleepResult } from './sleep.js';
 /** Test-only seam: `runSleep` overrides force a phase to throw into emitSleepAudit's `partial: true` row; production never sets them. */

package/dist/api/sleep-run.js

@@ -1,17 +1,17 @@
 // The sleep pipeline behind `sleep`, with its phase dependencies injectable; kept out of the package root.
-import { openHippoDb, closeHippoDb } from '../db.js';
 import { loadAllEntries } from '../store/entry-reads.js';
 import { deleteEntry, memoriesBackingObjects } from '../store/delete-and-batch.js';
-import { appendAuditEvent, reportAuditWriteFailure, auditMemories } from '../audit.js';
-import { autoShare } from '../shared.js';
+import { reportAuditWriteFailure, auditMemories } from '../store/audit.js';
+import { sqliteSyncStore } from '../store/sqlite/store.js';
+import { autoShare } from '../sharing/shared.js';
 import { consolidate } from '../consolidate/sleep.js';
 import { failedUnitOf } from '../store/delete-and-batch.js';
-import { loadConfig } from '../config.js';
-import { deduplicateStore } from '../dedupe.js';
-import { computeAmbientState } from '../ambient.js';
-import { loadPendingExtractionTenants } from '../graph/read.js';
-import { markPendingProcessedUpTo } from '../graph/write.js';
-import { extractGraphChunked } from '../graph-extract.js';
+import { loadConfig } from '../core/config.js';
+import { deduplicateStore } from '../consolidate/dedupe.js';
+import { computeAmbientState } from '../core/ambient.js';
+import { loadPendingExtractionTenants, markPendingProcessedUpTo } from '../store/graph-queue.js';
+import { extractGraphChunked } from '../graph/extract.js';
+import { errorMessage } from '../util/log.js';
 const DEFAULT_SLEEP_PHASES = {
     consolidate,
     deduplicateStore,
@@ -60,7 +60,7 @@ async function runSleepPhases(ctx, opts, phases, counts) {
     if (dedupResult.removed > 0)
         result.deduped = dedupSummary(dedupResult);
     // Phase 3: Quality audit (remove junk, report warnings; a dry run skips rows earlier phases would remove).
-    counts.auditDeleted = runQualityAudit(ctx, phases, dryRun, consolidateResult, dedupResult, result);
+    counts.auditDeleted = runQualityAudit(ctx, phases, { dryRun, consolidateResult, dedupResult, result });
     if (dryRun)
         return result;
     // Phase 4: Auto-share high-transfer-score memories to global.
@@ -80,10 +80,7 @@ function snapshotDirtyTenants(ctx, phases, dryRun) {
             snapshot.dirtyTenants = phases.loadPendingExtractionTenants(ctx.hippoRoot);
         }
         catch (snapErr) {
-            // SAFETY: this is a best-effort log message only; property access on
-            // any JS value is safe (undefined if absent), preserving the existing
-            // lenient formatting even when something non-Error was thrown.
-            snapshot.error = snapErr.message;
+            snapshot.error = errorMessage(snapErr);
         }
     }
     return snapshot;
@@ -118,8 +115,8 @@ function dedupSummary(dedupResult) {
         crossDups,
     };
 }
-/** Returns how many audit errors were deleted, or would be under dryRun. */
-function runQualityAudit(ctx, phases, dryRun, consolidateResult, dedupResult, result) {
+function runQualityAudit(ctx, phases, options) {
+    const { dryRun, consolidateResult, dedupResult, result } = options;
     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, memoriesBackingObjects(ctx.hippoRoot));
@@ -180,49 +177,45 @@ async function drainGraphQueue(ctx, phases, snapshot, result) {
                 `graph: dirty-tenant snapshot failed (skipped graph refresh): ${snapshot.error}`,
             ];
         }
-        let gTenants = 0;
-        let gEntities = 0;
-        let gRelations = 0;
+        const rebuilt = { tenants: 0, entities: 0, relations: 0 };
         // dirtyTenants was snapshotted before the memory-deleting phases above.
         for (const { tenantId, maxPendingId } of snapshot.dirtyTenants) {
-            try {
-                const ext = await phases.extractGraph(ctx.hippoRoot, tenantId);
-                // Count the rebuild as soon as it succeeds — it happened regardless of
-                // the drain-mark below.
-                gTenants += 1;
-                gEntities += ext.entities;
-                gRelations += ext.relations;
-                if (ext.skipped) {
-                    result.details = [
-                        ...(result.details ?? []),
-                        `graph: ${ext.skipped} stale op(s) skipped for a tenant; the next sleep redoes them`,
-                    ];
-                }
-                // Watermark drain: only items enqueued before this rebuild started are marked; later arrivals stay pending.
-                // Marked only after the last chunk, so a run stopped between chunks leaves the tenant for the next one.
-                markPendingProcessedUpTo(ctx.hippoRoot, tenantId, maxPendingId);
-            }
-            catch (tenantErr) {
-                // SAFETY: this is a best-effort log message only; property access
-                // on any JS value is safe (undefined if absent), preserving the
-                // existing lenient formatting even when something non-Error was thrown.
-                result.details = [
-                    ...(result.details ?? []),
-                    `graph: extract failed for a dirty tenant (left pending): ${tenantErr.message}`,
-                ];
-            }
+            await rebuildDirtyTenant(ctx, phases, { tenantId, maxPendingId }, rebuilt, result);
         }
-        if (gTenants > 0) {
-            result.graph = { tenants: gTenants, entities: gEntities, relations: gRelations };
+        if (rebuilt.tenants > 0) {
+            result.graph = rebuilt;
         }
     }
     catch (graphErr) {
-        // SAFETY: this is a best-effort log message only; property access on
-        // any JS value is safe (undefined if absent), preserving the existing
-        // lenient formatting even when something non-Error was thrown.
         result.details = [
             ...(result.details ?? []),
-            `graph: drain phase failed (skipped): ${graphErr.message}`,
+            `graph: drain phase failed (skipped): ${errorMessage(graphErr)}`,
+        ];
+    }
+}
+/** Rebuilds one dirty tenant's graph into `rebuilt` and drains its queue; a failure is a detail line and the tenant stays pending. */
+async function rebuildDirtyTenant(ctx, phases, dirty, rebuilt, result) {
+    try {
+        const ext = await phases.extractGraph(ctx.hippoRoot, dirty.tenantId);
+        // Count the rebuild as soon as it succeeds — it happened regardless of
+        // the drain-mark below.
+        rebuilt.tenants += 1;
+        rebuilt.entities += ext.entities;
+        rebuilt.relations += ext.relations;
+        if (ext.skipped) {
+            result.details = [
+                ...(result.details ?? []),
+                `graph: ${ext.skipped} stale op(s) skipped for a tenant; the next sleep redoes them`,
+            ];
+        }
+        // Watermark drain: only items enqueued before this rebuild started are marked; later arrivals stay pending.
+        // Marked only after the last chunk, so a run stopped between chunks leaves the tenant for the next one.
+        markPendingProcessedUpTo(ctx.hippoRoot, dirty.tenantId, dirty.maxPendingId);
+    }
+    catch (tenantErr) {
+        result.details = [
+            ...(result.details ?? []),
+            `graph: extract failed for a dirty tenant (left pending): ${errorMessage(tenantErr)}`,
         ];
     }
 }
@@ -230,34 +223,29 @@ async function drainGraphQueue(ctx, phases, snapshot, result) {
 // Its own handle; an audit failure is logged and never replaces the original phase error.
 function emitSleepAudit(ctx, opts, dryRun, counts, phaseError) {
     try {
-        const db = openHippoDb(ctx.hippoRoot);
-        try {
-            const sleepAuditMetadata = {
-                consolidationCount: counts.consolidation,
-                dedupCount: counts.dedup,
-                auditDeletedCount: counts.auditDeleted,
-                ambientTotal: counts.ambient,
-                dryRun,
-                noShare: opts.noShare ?? false,
-                partial: phaseError !== null,
-                triggeredByTenant: ctx.tenantId, // preserve for audit forensics
-            };
-            if (phaseError)
-                sleepAuditMetadata.errorMessage = phaseError.message;
-            // A flush stopped between chunks names the unit it would have committed next, so a unit that fails every night can be found.
-            const nextUnitIds = failedUnitOf(phaseError);
-            if (nextUnitIds)
-                sleepAuditMetadata.nextUnitIds = nextUnitIds;
-            appendAuditEvent(db, {
+        // Tagged '__host__' because sleep is host-wide; the actor still names the operator who ran it.
+        const sleepAuditMetadata = {
+            consolidationCount: counts.consolidation,
+            dedupCount: counts.dedup,
+            auditDeletedCount: counts.auditDeleted,
+            ambientTotal: counts.ambient,
+            dryRun,
+            noShare: opts.noShare ?? false,
+            partial: phaseError !== null,
+            triggeredByTenant: ctx.tenantId, // preserve for audit forensics
+        };
+        if (phaseError)
+            sleepAuditMetadata.errorMessage = phaseError.message;
+        // A flush stopped between chunks names the unit it would have committed next, so a unit that fails every night can be found.
+        const nextUnitIds = failedUnitOf(phaseError);
+        if (nextUnitIds)
+            sleepAuditMetadata.nextUnitIds = nextUnitIds;
+        sqliteSyncStore(ctx.hippoRoot).appendAuditEvents([{
                 tenantId: '__host__',
                 actor: ctx.actor.subject,
                 op: 'consolidate',
                 metadata: { ...sleepAuditMetadata },
-            });
-        }
-        finally {
-            closeHippoDb(db);
-        }
+            }]);
     }
     catch (auditErr) {
         // Logged, never thrown: a second failure must not mask the original phaseError.

package/dist/api/sleep.d.ts

@@ -1,4 +1,4 @@
-import type { AmbientState } from '../ambient.js';
+import type { AmbientState } from '../core/ambient.js';
 import type { Context } from './types.js';
 /** Options for `sleep`, one consolidation cycle on a SQLite store that returns counts; unlike `hippo sleep` it skips the auto-learn step. */
 export interface SleepOpts {

package/dist/api/tokens.d.ts

@@ -1,5 +1,5 @@
-import { type TokenSummary, type TokenSurface } from '../token-ledger.js';
-import { type FailureSummary } from '../failure-log.js';
+import type { TokenSummary, TokenSurface } from '../store/token-ledger.js';
+import type { FailureSummary } from '../store/failure-log.js';
 import type { Context } from './types.js';
 /**
  * Record memory text handed to an agent in the token ledger.

package/dist/api/tokens.js

@@ -1,9 +1,9 @@
 // Token-use and failure reports.
-import { openHippoDb, closeHippoDb, rethrowIfSqliteBlocked } from '../db.js';
-import { summarizeTokenUse } from '../token-ledger.js';
-import { storeFor } from '../store-port.js';
-import { summarizeFailures } from '../failure-log.js';
-import { log } from '../log.js';
+import { rethrowIfSqliteBlocked } from '../db/index.js';
+import { storeFor } from '../store/index.js';
+import { failureLogSummary, tokenUseSummary } from '../store/usage-reports.js';
+import { errorMessage, log } from '../util/log.js';
+import { DAY_MS } from '../util/time.js';
 /**
  * Record memory text handed to an agent in the token ledger.
  * Best-effort: never throws, because a ledger failure must not fail the
@@ -22,7 +22,7 @@ export async function recordTokens(ctx, surface, use) {
     }
     catch (err) {
         rethrowIfSqliteBlocked(err);
-        log.warnThenDebug('api-token-ledger', `token ledger write failed; the reply is unaffected: ${err instanceof Error ? err.message : String(err)}`);
+        log.warnThenDebug('api-token-ledger', `token ledger write failed; the reply is unaffected: ${errorMessage(err)}`);
     }
 }
 /**
@@ -31,26 +31,14 @@ export async function recordTokens(ctx, surface, use) {
  * surface, with session counts and mean tokens per session.
  */
 export function tokenSummary(ctx, opts = {}) {
-    const db = openHippoDb(ctx.hippoRoot);
-    try {
-        return summarizeTokenUse(db, ctx.tenantId, reportWindowStart(opts.days));
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    return tokenUseSummary(ctx.hippoRoot, ctx.tenantId, reportWindowStart(opts.days));
 }
 /** Failed tool calls by outcome, and repeats across sessions, over the last `days` days (default 30). */
 export function failureSummary(ctx, opts = {}) {
-    const db = openHippoDb(ctx.hippoRoot);
-    try {
-        return summarizeFailures(db, ctx.tenantId, reportWindowStart(opts.days));
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    return failureLogSummary(ctx.hippoRoot, ctx.tenantId, reportWindowStart(opts.days));
 }
 function reportWindowStart(days) {
     const span = days !== undefined && Number.isFinite(days) && days > 0 ? days : 30;
-    return new Date(Date.now() - span * 86_400_000).toISOString();
+    return new Date(Date.now() - span * DAY_MS).toISOString();
 }
 //# sourceMappingURL=tokens.js.map

package/dist/api/types.d.ts

@@ -1,5 +1,5 @@
-import { BadRequestError } from '../api-errors.js';
-import type { HippoStore } from '../store-port.js';
+import { BadRequestError } from '../core/api-errors.js';
+import type { HippoStore } from '../store/index.js';
 /**
  * Actor identity + authorization role for a Context.
  *

package/dist/api/types.js

@@ -1,5 +1,5 @@
 // Request context (caller identity and tenant) shared by every API module, plus the recall contract error.
-import { BadRequestError } from '../api-errors.js';
+import { BadRequestError } from '../core/api-errors.js';
 /**
  * Helper for building process-local Actor values (admin and host admin),
  * used by CLI and CLI-run connector Context constructors so the role

package/dist/capture/caller-session.d.ts

@@ -1,6 +1,6 @@
 import { type Context } from '../api/types.js';
-import { type DatabaseSyncLike } from '../db.js';
-import { type CallerProject } from '../prompt-hook.js';
+import { type DatabaseSyncLike } from '../db/index.js';
+import { type CallerProject } from '../api/prompt-hook.js';
 import type { ContinuityKey } from '../store/sessions.js';
 import { type WorkingState } from './working-state.js';
 /** Checks the ids, then binds the session to the caller's owner (a ConflictError when another owner holds it). Returns the key the call's rows go under. */

package/dist/capture/caller-session.js

@@ -1,13 +1,13 @@
 // The checks every caller call shares: ids, project, the session's owner and the pilot arm, all from the request, never the server's env or folder.
-import { BadRequestError } from '../api-errors.js';
+import { BadRequestError } from '../core/api-errors.js';
 import { ownerOrSubject } from '../api/types.js';
-import { closeHippoDb, openHippoDb } from '../db.js';
-import { MAX_ID_LEN } from '../http-util.js';
-import { sessionPilotArm } from '../pilot-arm.js';
-import { assertCallerIds } from '../prompt-hook.js';
-import { assertCallerProject, projectNames } from '../project-identity.js';
-import { maskEmails, redactSecretsStrict } from '../secret-detect.js';
-import { bindSessionOwner } from '../session-owners.js';
+import { closeHippoDb, openHippoDb } from '../db/index.js';
+import { MAX_ID_LEN } from '../util/http-util.js';
+import { sessionPilotArm } from '../api/pilot-arm.js';
+import { assertCallerIds } from '../api/prompt-hook.js';
+import { assertCallerProject, projectNames } from '../core/project-identity.js';
+import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
+import { bindSessionOwner } from '../api/session-owners.js';
 import { fitWorkingState, WORKING_STATE_CAPS } from './working-state.js';
 /** Checks the ids, then binds the session to the caller's owner (a ConflictError when another owner holds it). Returns the key the call's rows go under. */
 export function bindCaller(ctx, sessionId, project) {

package/dist/{capture-error.d.ts → capture/capture-error.d.ts}

@@ -1,5 +1,5 @@
-import { type CaptureErrorOutcome } from './capture/failure-reading.js';
-import type { JsonValue } from './json.js';
+import { type CaptureErrorOutcome } from '../store/failure-log.js';
+import type { JsonValue } from '../util/json.js';
 /** Store a failure as an error memory unless it is routine or a repeat, and log it either way, even when storing throws. */
 export declare function captureToolFailure(hippoRoot: string, tenantId: string, payload: JsonValue): CaptureErrorOutcome;
 /** Who sent a failure from another machine: the audit actor and the project its lesson and repeat check belong to. */

package/dist/{capture-error.js → capture/capture-error.js}

@@ -1,13 +1,13 @@
 // `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.
-import { createMemory } from './memory.js';
-import { writeEntry } from './store/entry-writes.js';
-import { loadContentsWithTag } from './store/entry-reads.js';
-import { loadConfig } from './config.js';
-import { closeHippoDb, openHippoDb } from './db.js';
-import { recordFailure } from './failure-log.js';
-import { failureHash, failureSignature, lessonFromFailure, payloadString, } from './capture/failure-reading.js';
+import { createMemory } from '../core/memory.js';
+import { writeEntry } from '../store/entry-writes.js';
+import { loadContentsWithTag } from '../store/entry-reads.js';
+import { loadConfig } from '../core/config.js';
+import { closeHippoDb, openHippoDb } from '../db/index.js';
+import { recordFailure } from '../store/failure-log.js';
+import { failureHash, failureSignature, lessonFromFailure, payloadString, } from './failure-reading.js';
 /** Store a failure as an error memory unless it is routine or a repeat, and log it either way, even when storing throws. */
 export function captureToolFailure(hippoRoot, tenantId, payload) {
     const lesson = lessonFromFailure(payload);

package/dist/{codex-patch.js → capture/codex-patch.js}

@@ -1,7 +1,7 @@
 // Files named by a Codex apply_patch call, read the way openai/codex codex-rs/apply-patch reads them
 // (parser.rs for the body, invocation.rs for the shell forms it runs as apply_patch).
 import * as path from 'path';
-import { isStringValue } from './capture-contract.js';
+import { isStringValue } from '../core/capture-contract.js';
 /** Codex prints this line only when a patch applied (apply-patch lib.rs). */
 export const PATCH_SUCCESS_LINE = 'Success. Updated the following files:';
 const BEGIN_PATCH = '*** Begin Patch';

package/dist/capture/command.d.ts

@@ -1,4 +1,4 @@
-import { type ProjectRef } from '../project-identity.js';
+import { type ProjectRef } from '../core/project-identity.js';
 import { type ExtractedItem } from './extract.js';
 import { type SessionTurn } from './transcript.js';
 export interface CaptureOptions {