hippo-memory 2.0.0 → 2.1.0

package/dist/api/continuity.d.ts

@@ -1,47 +1,50 @@
 import type { HandoffOutcome, SessionHandoff } from '../core/handoff.js';
 import type { SessionEvent, TaskSnapshot } from '../store/rows.js';
-import { appendSessionEvent, listSessionEvents, saveActiveTaskSnapshot } from '../store/sessions.js';
-import { wmClear, wmFlush, wmPush, wmRead, type WorkingMemoryItem } from '../store/working-memory.js';
-import type { Context } from './types.js';
+import type { SessionEventInput, SnapshotInput } from '../store/sessions.js';
+import type { Sessions } from '../store/index.js';
+import type { WorkingMemoryItem } from '../store/working-memory.js';
+import type { ContextWith } from './types.js';
+type Ctx = ContextWith<'sessions'>;
 /** What a snapshot save carries. */
-export type SnapshotSaveInput = Parameters<typeof saveActiveTaskSnapshot>[2];
+export type SnapshotSaveInput = SnapshotInput;
 /** What a session event append carries. */
-export type SessionEventAppendInput = Parameters<typeof appendSessionEvent>[2];
+export type SessionEventAppendInput = SessionEventInput;
 /** What a session event listing filters on. */
-export type SessionEventListOpts = NonNullable<Parameters<typeof listSessionEvents>[2]>;
+export type SessionEventListOpts = Parameters<Sessions['listEvents']>[1];
 /** Save the caller's active task snapshot. */
-export declare function snapshotSave(ctx: Context, input: SnapshotSaveInput): TaskSnapshot;
+export declare function snapshotSave(ctx: Ctx, input: SnapshotSaveInput): Promise<TaskSnapshot>;
 /** Clear the caller's active task snapshot; false when there was none. */
-export declare function snapshotClear(ctx: Context, status: string): boolean;
+export declare function snapshotClear(ctx: Ctx, status: string): Promise<boolean>;
 /** The caller's active task snapshot, or null. */
-export declare function snapshotLoad(ctx: Context): TaskSnapshot | null;
+export declare function snapshotLoad(ctx: Ctx): Promise<TaskSnapshot | null>;
 /** Append a session event in the caller's tenant. */
-export declare function sessionEventAppend(ctx: Context, event: SessionEventAppendInput): SessionEvent;
+export declare function sessionEventAppend(ctx: Ctx, event: SessionEventAppendInput): Promise<SessionEvent>;
 /** List the caller's session events. */
-export declare function sessionEventList(ctx: Context, opts: SessionEventListOpts): SessionEvent[];
+export declare function sessionEventList(ctx: Ctx, opts: SessionEventListOpts): Promise<SessionEvent[]>;
 export interface LatestContinuity {
     snapshot: TaskSnapshot | null;
     events: SessionEvent[];
 }
 /** The active snapshot plus recent events for `sessionId`, falling back to the snapshot's own session. */
-export declare function continuityLatest(ctx: Context, opts: {
+export declare function continuityLatest(ctx: Ctx, opts: {
     sessionId?: string;
     limit: number;
-}): LatestContinuity;
+}): Promise<LatestContinuity>;
 /** Stamp the outcome on the caller's handoff for `sessionId`; returns the rows stamped. */
-export declare function handoffStampOutcome(ctx: Context, sessionId: string, outcome: HandoffOutcome): number;
+export declare function handoffStampOutcome(ctx: Ctx, sessionId: string, outcome: HandoffOutcome): Promise<number>;
 /** Save a session handoff in the caller's tenant. */
-export declare function handoffSave(ctx: Context, handoff: Omit<SessionHandoff, 'updatedAt'>): SessionHandoff;
+export declare function handoffSave(ctx: Ctx, handoff: Omit<SessionHandoff, 'updatedAt'>): Promise<SessionHandoff>;
 /** The caller's latest handoff, optionally for one session. */
-export declare function handoffLatest(ctx: Context, sessionId?: string): SessionHandoff | null;
+export declare function handoffLatest(ctx: Ctx, sessionId?: string): Promise<SessionHandoff | null>;
 /** The caller's handoff by id, or null. */
-export declare function handoffById(ctx: Context, id: number): SessionHandoff | null;
+export declare function handoffById(ctx: Ctx, id: number): Promise<SessionHandoff | null>;
 /** Push a working memory entry in the caller's tenant; returns its row id. */
-export declare function workingMemoryPush(ctx: Context, opts: Omit<Parameters<typeof wmPush>[1], 'tenantId'>): number;
+export declare function workingMemoryPush(ctx: Ctx, opts: Parameters<Sessions['pushWorkingMemory']>[1]): Promise<number>;
 /** The caller's working memory entries, most important first. */
-export declare function workingMemoryRead(ctx: Context, opts: Omit<NonNullable<Parameters<typeof wmRead>[1]>, 'tenantId'>): WorkingMemoryItem[];
+export declare function workingMemoryRead(ctx: Ctx, opts: Parameters<Sessions['readWorkingMemory']>[1]): Promise<WorkingMemoryItem[]>;
 /** Delete the caller's working memory entries; returns the count. */
-export declare function workingMemoryClear(ctx: Context, opts: Omit<NonNullable<Parameters<typeof wmClear>[1]>, 'tenantId'>): number;
+export declare function workingMemoryClear(ctx: Ctx, opts: Parameters<Sessions['clearWorkingMemory']>[1]): Promise<number>;
 /** Flush the caller's working memory at session end; returns the count. */
-export declare function workingMemoryFlush(ctx: Context, opts: Omit<NonNullable<Parameters<typeof wmFlush>[1]>, 'tenantId'>): number;
+export declare function workingMemoryFlush(ctx: Ctx, opts: Parameters<Sessions['clearWorkingMemory']>[1]): Promise<number>;
+export {};
 //# sourceMappingURL=continuity.d.ts.map

package/dist/api/continuity.js

@@ -1,66 +1,64 @@
 // Where-you-left-off ops: task snapshot, session events, handoffs and working memory.
-import { appendSessionEvent, clearActiveTaskSnapshot, listSessionEvents, loadActiveTaskSnapshot, saveActiveTaskSnapshot, } from '../store/sessions.js';
-import { loadHandoffById, loadLatestHandoff, saveSessionHandoff, stampHandoffOutcome } from '../store/handoffs.js';
-import { wmClear, wmFlush, wmPush, wmRead } from '../store/working-memory.js';
 /** Save the caller's active task snapshot. */
 export function snapshotSave(ctx, input) {
-    return saveActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId, input);
+    return ctx.store.sessions.saveSnapshot(ctx.tenantId, input, null);
 }
 /** Clear the caller's active task snapshot; false when there was none. */
 export function snapshotClear(ctx, status) {
-    return clearActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId, status);
+    return ctx.store.sessions.clearSnapshot(ctx.tenantId, status);
 }
 /** The caller's active task snapshot, or null. */
 export function snapshotLoad(ctx) {
-    return loadActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId);
+    return ctx.store.sessions.loadSnapshot(ctx.tenantId, null);
 }
 /** Append a session event in the caller's tenant. */
 export function sessionEventAppend(ctx, event) {
-    return appendSessionEvent(ctx.hippoRoot, ctx.tenantId, event);
+    return ctx.store.sessions.appendEvent(ctx.tenantId, event);
 }
 /** List the caller's session events. */
 export function sessionEventList(ctx, opts) {
-    return listSessionEvents(ctx.hippoRoot, ctx.tenantId, opts);
+    return ctx.store.sessions.listEvents(ctx.tenantId, opts);
 }
 /** The active snapshot plus recent events for `sessionId`, falling back to the snapshot's own session. */
-export function continuityLatest(ctx, opts) {
-    const snapshot = loadActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId);
-    const events = listSessionEvents(ctx.hippoRoot, ctx.tenantId, {
-        session_id: opts.sessionId || snapshot?.session_id || undefined,
+export async function continuityLatest(ctx, opts) {
+    const { sessions } = ctx.store;
+    const snapshot = await sessions.loadSnapshot(ctx.tenantId, null);
+    const events = await sessions.listEvents(ctx.tenantId, {
+        sessionId: opts.sessionId || snapshot?.session_id || undefined,
         limit: opts.limit,
     });
     return { snapshot, events };
 }
 /** Stamp the outcome on the caller's handoff for `sessionId`; returns the rows stamped. */
 export function handoffStampOutcome(ctx, sessionId, outcome) {
-    return stampHandoffOutcome(ctx.hippoRoot, ctx.tenantId, sessionId, outcome);
+    return ctx.store.sessions.stampHandoffOutcome(ctx.tenantId, sessionId, outcome);
 }
 /** Save a session handoff in the caller's tenant. */
 export function handoffSave(ctx, handoff) {
-    return saveSessionHandoff(ctx.hippoRoot, ctx.tenantId, handoff);
+    return ctx.store.sessions.saveHandoff(ctx.tenantId, handoff, null);
 }
 /** The caller's latest handoff, optionally for one session. */
 export function handoffLatest(ctx, sessionId) {
-    return loadLatestHandoff(ctx.hippoRoot, ctx.tenantId, sessionId);
+    return ctx.store.sessions.latestHandoff(ctx.tenantId, sessionId ?? null, {}, null);
 }
 /** The caller's handoff by id, or null. */
 export function handoffById(ctx, id) {
-    return loadHandoffById(ctx.hippoRoot, ctx.tenantId, id);
+    return ctx.store.sessions.handoffById(ctx.tenantId, id);
 }
 /** Push a working memory entry in the caller's tenant; returns its row id. */
 export function workingMemoryPush(ctx, opts) {
-    return wmPush(ctx.hippoRoot, { ...opts, tenantId: ctx.tenantId });
+    return ctx.store.sessions.pushWorkingMemory(ctx.tenantId, opts);
 }
 /** The caller's working memory entries, most important first. */
 export function workingMemoryRead(ctx, opts) {
-    return wmRead(ctx.hippoRoot, { ...opts, tenantId: ctx.tenantId });
+    return ctx.store.sessions.readWorkingMemory(ctx.tenantId, opts);
 }
 /** Delete the caller's working memory entries; returns the count. */
 export function workingMemoryClear(ctx, opts) {
-    return wmClear(ctx.hippoRoot, { ...opts, tenantId: ctx.tenantId });
+    return ctx.store.sessions.clearWorkingMemory(ctx.tenantId, opts);
 }
 /** Flush the caller's working memory at session end; returns the count. */
 export function workingMemoryFlush(ctx, opts) {
-    return wmFlush(ctx.hippoRoot, { ...opts, tenantId: ctx.tenantId });
+    return ctx.store.sessions.clearWorkingMemory(ctx.tenantId, opts);
 }
 //# sourceMappingURL=continuity.js.map

package/dist/api/correction-latency.d.ts

@@ -18,7 +18,9 @@ export interface CorrectionLatencyReport {
     maxMs: number | null;
     pairs: CorrectionPair[];
 }
-/** Correction latency = `new.created` minus the observation time (the extracted-from row's `created`, else `new.created`).
+/**
+ * Correction latency = `new.created` minus the observation time (the extracted-from row's `created`, else
+ * `new.created`).
  * Manual supersedes have latency 0 and are excluded from percentiles so they do not mask real lag. */
 export declare function buildCorrectionLatency(entries: MemoryEntry[]): CorrectionLatencyReport;
 //# sourceMappingURL=correction-latency.d.ts.map

package/dist/api/correction-latency.js

@@ -10,7 +10,9 @@ function percentile(sorted, q) {
         return sorted[lo];
     return sorted[lo] + (sorted[hi] - sorted[lo]) * (idx - lo);
 }
-/** Correction latency = `new.created` minus the observation time (the extracted-from row's `created`, else `new.created`).
+/**
+ * Correction latency = `new.created` minus the observation time (the extracted-from row's `created`, else
+ * `new.created`).
  * Manual supersedes have latency 0 and are excluded from percentiles so they do not mask real lag. */
 export function buildCorrectionLatency(entries) {
     const byId = new Map();

package/dist/api/error-reply.d.ts

@@ -3,6 +3,9 @@ export interface ApiErrorReply {
     status: number;
     message: string;
 }
-/** Maps by class so rewording a message never moves a status; an untyped error is a 500 whose text stays in the server log. */
+/**
+ * Maps by class so rewording a message never moves a status; an untyped error is a 500 whose text stays in the server
+ * log.
+ */
 export declare function mapApiError<E>(err: E): ApiErrorReply;
 //# sourceMappingURL=error-reply.d.ts.map

package/dist/api/error-reply.js

@@ -1,9 +1,18 @@
-// The one error-to-reply map the HTTP server and the MCP transports share, so a status never depends on which front end caught the error.
+// The one error-to-reply map the HTTP server and the MCP transports share, so a status never depends on which front end
+// caught the error.
 import { ApiError } from '../core/api-errors.js';
-import { BodyTimeoutError, BodyTooLargeError, HttpError, INTERNAL_ERROR_MESSAGE, STORE_NOT_PORTED_MESSAGE } from '../util/http-util.js';
+import { BodyTimeoutError, BodyTooLargeError, HttpError, INTERNAL_ERROR_MESSAGE, STORE_NOT_PORTED_MESSAGE, } from '../util/http-util.js';
 import { SqliteBlockedError } from '../util/sqlite-blocked.js';
-/** Maps by class so rewording a message never moves a status; an untyped error is a 500 whose text stays in the server log. */
+import { STORE_BUSY_MESSAGE } from '../store/port.js';
+import { isStoreBusy } from './busy.js';
+/**
+ * Maps by class so rewording a message never moves a status; an untyped error is a 500 whose text stays in the server
+ * log.
+ */
 export function mapApiError(err) {
+    // A held lock is a retryable 503 in every store, so the surfaces need not know SQLite's busy codes.
+    if (isStoreBusy(err))
+        return { status: 503, message: STORE_BUSY_MESSAGE };
     // An add-on can build an HttpError from any number, and writeHead throws on one outside 100-999.
     if (err instanceof HttpError && !(Number.isInteger(err.status) && err.status >= 100 && err.status <= 999)) {
         return { status: 500, message: INTERNAL_ERROR_MESSAGE };

package/dist/api/index.d.ts

@@ -4,27 +4,43 @@ export { passesCliRecallScopeFilter, ScopeForbiddenError } from '../core/recall-
 export type { TokenSummary, TokenSurface, TokenSurfaceSummary } from '../store/token-ledger.js';
 export type { FailureSummary } from '../store/failure-log.js';
 export { classifyOriginProject } from '../core/project-identity.js';
-export * from './types.js';
-export * from './remember.js';
-export * from './remember-local.js';
-export * from './recall-types.js';
-export * from './recall.js';
-export * from './assemble.js';
-export * from './drill-down.js';
-export * from './outcome.js';
-export * from './forget.js';
-export * from './conflicts.js';
-export * from './projects.js';
-export * from './promote.js';
-export * from './auth.js';
-export * from './audit.js';
-export * from './context-types.js';
-export * from './context.js';
-export * from './tokens.js';
-export * from './dormant.js';
-export * from './quarantine.js';
-export * from './sleep.js';
-export * from './goals.js';
-export * from './learn.js';
-export * from './refine.js';
+export { RecallContractError, adminActor, narrowContext, ownerOrSubject, requireHostAdmin } from './types.js';
+export type { Actor, Context, ContextWith, HippoDbContext, StoreContext } from './types.js';
+export { remember } from './memories/remember.js';
+export type { RememberLocal, RememberOpts, RememberResult } from './memories/remember.js';
+export { extractRememberedFacts, rememberLocally } from './memories/remember-local.js';
+export type { FactExtraction, FactExtractionRequest, LocalRememberInput, LocalRememberOutcome, StartedWeak, } from './memories/remember-local.js';
+export type { CliCoreInspection, CliCoreRanker, CliCoreRecall, ContinuityBlock, RecallOpts, RecallResult, RecallResultItem, RecallSuppressionSummary, ShownCliCore, ShownRanking, StoreRanking, } from './recall/types.js';
+export { retrieve } from './recall/recall.js';
+export { DEFAULT_ASSEMBLE_BUDGET, assemble } from './assemble.js';
+export type { AssembleCost, AssembleOpts, AssembleResult, AssembledContextItem } from './assemble.js';
+export { drillDown } from './objects/drill-down.js';
+export type { DrillDownChild, DrillDownCost, DrillDownFailure, DrillDownOpts, DrillDownOutcome, DrillDownResult, DrillDownSummary, } from './objects/drill-down.js';
+export { outcome, outcomeForLastRecall } from './memories/outcome.js';
+export type { OutcomeForLastRecallResult, OutcomeResult } from './memories/outcome.js';
+export { forget, reject, rejectOnHost, unreject } from './memories/forget.js';
+export type { ForgetResult, RejectOpts, RejectResult } from './memories/forget.js';
+export { listConflicts, listOpenConflicts, resolveMemoryConflict } from './memories/conflicts.js';
+export type { ResolveMemoryConflictOpts, ResolveMemoryConflictResult } from './memories/conflicts.js';
+export { listProjectNames, mergeProjectNames, repairProjectNames, repairProjectNamesOnce } from './objects/projects.js';
+export type { MergeProjectNamesOpts, MergeResult, ProjectCollision, ProjectFold, ProjectSummary, RepairResult, } from './objects/projects.js';
+export { archiveRaw, promote, supersede } from './memories/promote.js';
+export type { ArchiveRawOpts, ArchiveRawResult, PromoteResult, SupersedeOverrides, SupersedeResult, } from './memories/promote.js';
+export { DEFAULT_KEY_TTL_DAYS, MAX_TTL_DAYS, authCreate, authCreateSelf, authGrant, authKeyTenant, authListAllTenants, authListRows, authRevoke, authUngrant, } from './auth/auth.js';
+export type { AuthCreateOpts, AuthCreateResult, AuthCreateSelfOpts, AuthCreateSelfResult, AuthGrantResult, AuthRevokeResult, } from './auth/auth.js';
+export { auditList, auditMemoryQuality, computeCutoff, pruneAuditLog, removeAuditErrors, repairMemoryQuality, repairMemoryQualityOnce, } from './auth/audit.js';
+export type { AuditListOpts, AuditPass, PruneAuditOpts, PruneAuditResult } from './auth/audit.js';
+export type { ContextCost, ContextOpts, ContextResult, ContextResultEntry } from './context-types.js';
+export { DEFAULT_CONTEXT_BUDGET, NO_QUERY, ambientSecretAdmit, getContext, oneCopyPerMemory } from './context.js';
+export { failureSummary, recordTokens, tokenSummary } from './tokens.js';
+export { forgetDormant, isDormant, listDormant, restoreDormant } from './sleep/dormant.js';
+export { quarantineApprove, quarantineList, quarantineReject } from './auth/quarantine.js';
+export type { QuarantineListItem } from './auth/quarantine.js';
+export { sleep } from './sleep/sleep.js';
+export type { SleepOpts, SleepResult } from './sleep/sleep.js';
+export { goalComplete, goalList, goalPush, goalResume, goalSuspend } from './objects/goals.js';
+export type { GoalPushOpts } from './objects/goals.js';
+export { CLI_LEARN, MCP_LEARN, invalidateMemories, learn } from './sleep/learn.js';
+export type { InvalidationOptions, InvalidationResult, InvalidationTarget, LearnOpts, LearnProfile, LearnResult, } from './sleep/learn.js';
+export { REFINED_TAG, storeRefinement } from './memories/refine.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/api/index.js

@@ -7,27 +7,25 @@ export { isPrivateScope, passesScopeFilterForRecall } from '../core/recall-scope
 export { passesCliRecallScopeFilter, ScopeForbiddenError } from '../core/recall-scope.js';
 // classifyOriginProject lives in project-identity.ts (leaf) for the same reason.
 export { classifyOriginProject } from '../core/project-identity.js';
-export * from './types.js';
-export * from './remember.js';
-export * from './remember-local.js';
-export * from './recall-types.js';
-export * from './recall.js';
-export * from './assemble.js';
-export * from './drill-down.js';
-export * from './outcome.js';
-export * from './forget.js';
-export * from './conflicts.js';
-export * from './projects.js';
-export * from './promote.js';
-export * from './auth.js';
-export * from './audit.js';
-export * from './context-types.js';
-export * from './context.js';
-export * from './tokens.js';
-export * from './dormant.js';
-export * from './quarantine.js';
-export * from './sleep.js';
-export * from './goals.js';
-export * from './learn.js';
-export * from './refine.js';
+export { RecallContractError, adminActor, narrowContext, ownerOrSubject, requireHostAdmin } from './types.js';
+export { remember } from './memories/remember.js';
+export { extractRememberedFacts, rememberLocally } from './memories/remember-local.js';
+export { retrieve } from './recall/recall.js';
+export { DEFAULT_ASSEMBLE_BUDGET, assemble } from './assemble.js';
+export { drillDown } from './objects/drill-down.js';
+export { outcome, outcomeForLastRecall } from './memories/outcome.js';
+export { forget, reject, rejectOnHost, unreject } from './memories/forget.js';
+export { listConflicts, listOpenConflicts, resolveMemoryConflict } from './memories/conflicts.js';
+export { listProjectNames, mergeProjectNames, repairProjectNames, repairProjectNamesOnce } from './objects/projects.js';
+export { archiveRaw, promote, supersede } from './memories/promote.js';
+export { DEFAULT_KEY_TTL_DAYS, MAX_TTL_DAYS, authCreate, authCreateSelf, authGrant, authKeyTenant, authListAllTenants, authListRows, authRevoke, authUngrant, } from './auth/auth.js';
+export { auditList, auditMemoryQuality, computeCutoff, pruneAuditLog, removeAuditErrors, repairMemoryQuality, repairMemoryQualityOnce, } from './auth/audit.js';
+export { DEFAULT_CONTEXT_BUDGET, NO_QUERY, ambientSecretAdmit, getContext, oneCopyPerMemory } from './context.js';
+export { failureSummary, recordTokens, tokenSummary } from './tokens.js';
+export { forgetDormant, isDormant, listDormant, restoreDormant } from './sleep/dormant.js';
+export { quarantineApprove, quarantineList, quarantineReject } from './auth/quarantine.js';
+export { sleep } from './sleep/sleep.js';
+export { goalComplete, goalList, goalPush, goalResume, goalSuspend } from './objects/goals.js';
+export { CLI_LEARN, MCP_LEARN, invalidateMemories, learn } from './sleep/learn.js';
+export { REFINED_TAG, storeRefinement } from './memories/refine.js';
 //# sourceMappingURL=index.js.map

package/dist/api/instruction-detect.d.ts

@@ -1,4 +1,7 @@
-/** Prompt-injection detection for untrusted memory content. Same shape as secret-detect.ts; leaf module, no store/api/shared imports. */
+/**
+ * Prompt-injection detection for untrusted memory content. Same shape
+ * as secret-detect.ts; leaf module, no store/api/shared imports.
+ */
 export interface InstructionDetection {
     flagged: boolean;
     reason: string | null;

package/dist/api/instruction-detect.js

@@ -1,7 +1,16 @@
-/** Prompt-injection detection for untrusted memory content. Same shape as secret-detect.ts; leaf module, no store/api/shared imports. */
+/**
+ * Prompt-injection detection for untrusted memory content. Same shape
+ * as secret-detect.ts; leaf module, no store/api/shared imports.
+ */
 const INSTRUCTION_PATTERNS = [
-    { name: 'override-instructions', re: /\b(?:ignore|disregard|forget)\b[^.\n]{0,40}\b(?:previous|prior|above)\b[^.\n]{0,40}\binstructions?\b/i },
-    { name: 'role-reassignment', re: /\b(?:you are now|act as|pretend to be)\b[^.\n]{0,40}\b(?:an?\s+)?(?:ai|assistant|agent|system)\b/i },
+    {
+        name: 'override-instructions',
+        re: /\b(?:ignore|disregard|forget)\b[^.\n]{0,40}\b(?:previous|prior|above)\b[^.\n]{0,40}\binstructions?\b/i,
+    },
+    {
+        name: 'role-reassignment',
+        re: /\b(?:you are now|act as|pretend to be)\b[^.\n]{0,40}\b(?:an?\s+)?(?:ai|assistant|agent|system)\b/i,
+    },
     { name: 'chat-role-markup', re: /<\|im_start\|>|<\|system\|>|\[INST\]|<\/?system>|###\s*system\s*:/i },
     {
         name: 'system-prompt-reference',
@@ -11,16 +20,22 @@ const INSTRUCTION_PATTERNS = [
     // "always"/"never" alone (ordinary PR prose) doesn't flag without an agent-facing target nearby too.
     {
         name: 'standing-order',
-        re: /\b(?:from now on|whenever you|always|never)\b[^.\n]{0,50}\b(?:you must|(?:the ai|the assistant|the agent|claude|copilot)\s+(?:must|should|will)\b)/i
+        re: new RegExp(String.raw `\b(?:from now on|whenever you|always|never)\b[^.\n]{0,50}\b(?:you must|` +
+            String.raw `(?:the ai|the assistant|the agent|claude|copilot)\s+(?:must|should|will)\b)`, 'i'),
+    },
+    {
+        name: 'concealment',
+        re: /\b(?:do not|never|don't)\b[^.\n]{0,40}\b(?:tell|mention|reveal)\b[^.\n]{0,40}\bthe user\b/i,
     },
-    { name: 'concealment', re: /\b(?:do not|never|don't)\b[^.\n]{0,40}\b(?:tell|mention|reveal)\b[^.\n]{0,40}\bthe user\b/i },
     {
         name: 'remote-script-exec',
-        re: /\b(?:curl|wget)\b[^\n|]{0,80}\|\s*(?:sudo\s+)?(?:sh|bash|zsh)\b|\biex\s*\(\s*(?:iwr|invoke-webrequest|new-object\s+net\.webclient)/i
+        re: new RegExp(String.raw `\b(?:curl|wget)\b[^\n|]{0,80}\|\s*(?:sudo\s+)?(?:sh|bash|zsh)\b|` +
+            String.raw `\biex\s*\(\s*(?:iwr|invoke-webrequest|new-object\s+net\.webclient)`, 'i'),
     },
     {
         name: 'exfiltration',
-        re: /\b(?:send|post|upload|exfiltrate)\b[^.\n]{0,40}\b(?:secrets?|tokens?|api[- ]?keys?|credentials?|env(?:ironment)? variables?)\b/i
+        re: new RegExp(String.raw `\b(?:send|post|upload|exfiltrate)\b[^.\n]{0,40}\b` +
+            String.raw `(?:secrets?|tokens?|api[- ]?keys?|credentials?|env(?:ironment)? variables?)\b`, 'i'),
     },
     { name: 'unicode-tag-chars', re: /[\u{E0000}-\u{E007F}]/u },
 ];
@@ -30,20 +45,59 @@ const ZERO_WIDTH_RUN_RE = /[\u200B-\u200F\u2060-\u2064]{3,}/;
 const BIDI_CONTROL_RE = /[\u202A-\u202E\u2066-\u2069]/;
 // A renderer draws a reference as the character it names: decimal, hex, or one of the five names XML defines.
 const CHARACTER_REFERENCE_RE = /&(?:#(\d{1,7})|#[xX]([0-9a-fA-F]{1,6})|(amp|lt|gt|quot|apos));/g;
-const NAMED_REFERENCES = new Map([['amp', '&'], ['lt', '<'], ['gt', '>'], ['quot', '"'], ['apos', "'"]]);
-// Drawn with no width, so one inside a word splits it for a pattern and not for a reader: soft hyphen, joiners, zero-width and bidi format characters.
+const NAMED_REFERENCES = new Map([
+    ['amp', '&'],
+    ['lt', '<'],
+    ['gt', '>'],
+    ['quot', '"'],
+    ['apos', "'"],
+]);
+// Drawn with no width, so one inside a word splits it for a pattern and not for a reader: soft hyphen, joiners,
+// zero-width and bidi format characters.
 const INVISIBLE_RE = /[\u034F\u00AD\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u2069\uFEFF]/g;
-// Cyrillic, then Greek, letters drawn like a c e i j o p s x y; closed at those, so Russian or Greek prose folds into no phrase a pattern names.
+// Cyrillic, then Greek, letters drawn like a c e i j o p s x y; closed at those, so Russian or Greek prose folds into
+// no phrase a pattern names.
 const LOOKALIKES = new Map([
-    ['\u0430', 'a'], ['\u0441', 'c'], ['\u0435', 'e'], ['\u0456', 'i'], ['\u0458', 'j'], ['\u043E', 'o'], ['\u0440', 'p'], ['\u0455', 's'],
-    ['\u0445', 'x'], ['\u0443', 'y'],
-    ['\u0410', 'A'], ['\u0421', 'C'], ['\u0415', 'E'], ['\u0406', 'I'], ['\u0408', 'J'], ['\u041E', 'O'], ['\u0420', 'P'], ['\u0405', 'S'],
-    ['\u0425', 'X'], ['\u0423', 'Y'],
-    ['\u03B1', 'a'], ['\u03B5', 'e'], ['\u03B9', 'i'], ['\u03F3', 'j'], ['\u03BF', 'o'], ['\u03C1', 'p'], ['\u03C7', 'x'], ['\u03B3', 'y'],
-    ['\u0391', 'A'], ['\u0395', 'E'], ['\u0399', 'I'], ['\u037F', 'J'], ['\u039F', 'O'], ['\u03A1', 'P'], ['\u03A7', 'X'], ['\u03A5', 'Y'],
+    ['\u0430', 'a'],
+    ['\u0441', 'c'],
+    ['\u0435', 'e'],
+    ['\u0456', 'i'],
+    ['\u0458', 'j'],
+    ['\u043E', 'o'],
+    ['\u0440', 'p'],
+    ['\u0455', 's'],
+    ['\u0445', 'x'],
+    ['\u0443', 'y'],
+    ['\u0410', 'A'],
+    ['\u0421', 'C'],
+    ['\u0415', 'E'],
+    ['\u0406', 'I'],
+    ['\u0408', 'J'],
+    ['\u041E', 'O'],
+    ['\u0420', 'P'],
+    ['\u0405', 'S'],
+    ['\u0425', 'X'],
+    ['\u0423', 'Y'],
+    ['\u03B1', 'a'],
+    ['\u03B5', 'e'],
+    ['\u03B9', 'i'],
+    ['\u03F3', 'j'],
+    ['\u03BF', 'o'],
+    ['\u03C1', 'p'],
+    ['\u03C7', 'x'],
+    ['\u03B3', 'y'],
+    ['\u0391', 'A'],
+    ['\u0395', 'E'],
+    ['\u0399', 'I'],
+    ['\u037F', 'J'],
+    ['\u039F', 'O'],
+    ['\u03A1', 'P'],
+    ['\u03A7', 'X'],
+    ['\u03A5', 'Y'],
 ]);
 const GREEK_OR_CYRILLIC_RE = /[\u0370-\u03FF\u0400-\u04FF]/g;
-// A line break stays: it is the sentence bound the patterns rely on where a list or a chat message ends a line with no full stop.
+// A line break stays: it is the sentence bound the patterns rely
+// on where a list or a chat message ends a line with no full stop.
 const SPACE_RUN_RE = /[^\S\n]+/g;
 function referencedCharacter(reference, decimal, hex, name) {
     if (name !== undefined)
@@ -55,13 +109,13 @@ function referencedCharacter(reference, decimal, hex, name) {
 }
 /** `content` as a reader or a model takes it in. For matching only: what is stored is never this. */
 function screeningForm(content) {
-    return content
+    return (content
         .replace(CHARACTER_REFERENCE_RE, referencedCharacter)
         // Full-width, mathematical and enclosed letters become the plain ones, and every space character a U+0020.
         .normalize('NFKC')
         .replace(INVISIBLE_RE, '')
         .replace(GREEK_OR_CYRILLIC_RE, (letter) => LOOKALIKES.get(letter) ?? letter)
-        .replace(SPACE_RUN_RE, ' ');
+        .replace(SPACE_RUN_RE, ' '));
 }
 function matchedPattern(text) {
     for (const { name, re } of INSTRUCTION_PATTERNS) {
@@ -71,7 +125,8 @@ function matchedPattern(text) {
     return null;
 }
 export function detectInstruction(content) {
-    // The text as written goes first: a phrase in plain sight is named before any smuggling rule, and the screening form only adds flags.
+    // The text as written goes first: a phrase in plain sight is named before any smuggling rule, and the screening form
+    // only adds flags.
     const plain = matchedPattern(content);
     if (plain !== null)
         return { flagged: true, reason: plain };

package/dist/api/ledger-db.d.ts

@@ -1,17 +1,21 @@
 import { type LedgerTurn } from '../store/ledger-turn.js';
+import { type HippoStore, type StoreReach } from '../store/port.js';
 import type { LastSent, TokenSurface, TokenUse } from '../store/token-ledger.js';
-export interface LedgerRootOpts {
-    /** The store serves many people, so the global store of the user running it belongs to none of them. */
-    readonly sharedStore?: boolean;
-}
-/** `hippoRoot` when it holds a store, else the global store (the prompt hook fires where no local one exists), else null. */
-export declare function ledgerRoot(hippoRoot: string, opts?: LedgerRootOpts): string | null;
-/** Runs `call` on ledgerRoot's store root. Best-effort: undefined on any failure, because a ledger failure must not break context or recall. */
-export declare function onLedgerRoot<T>(hippoRoot: string, opts: LedgerRootOpts | undefined, call: (root: string) => T): T | undefined;
+/** The slice of a call's store reach that picks the ledger; a shared store has no `global`. */
+export type LedgerReach = Pick<StoreReach, 'hasLocal' | 'global'>;
+/** The ledger is SQLite-only: a local store needs a reach that says so and a SQLite store; no reach books nowhere. */
+export declare function ledgerReachOf(ctx: {
+    readonly reach?: StoreReach;
+    readonly store?: HippoStore;
+}, shared?: boolean): LedgerReach;
+/** `hippoRoot` when the call has a store of its own, else the global store (the prompt hook fires where none is). */
+export declare function ledgerRoot(hippoRoot: string, reach: LedgerReach): string | null;
+/** Runs `call` on ledgerRoot's store root; undefined on any failure, since a ledger failure must not break recall. */
+export declare function onLedgerRoot<T>(hippoRoot: string, reach: LedgerReach, call: (root: string) => T): T | undefined;
 /** Books one row in ledgerRoot's store, best-effort. */
-export declare function bookTokenUse(hippoRoot: string, use: TokenUse, opts?: LedgerRootOpts): void;
+export declare function bookTokenUse(hippoRoot: string, use: TokenUse, reach: LedgerReach): void;
 /** Books a turn's rows and then its delivery event on one connection of ledgerRoot's store, best-effort. */
-export declare function bookLedgerTurn(hippoRoot: string, turn: LedgerTurn, opts?: LedgerRootOpts): void;
+export declare function bookLedgerTurn(hippoRoot: string, turn: LedgerTurn, reach: LedgerReach): void;
 /** What the session last sent on `surface` in ledgerRoot's store; undefined with no ledger or a failed read. */
-export declare function ledgerLastSent(hippoRoot: string, tenantId: string, sessionId: string | null | undefined, surface: TokenSurface, opts?: LedgerRootOpts): LastSent | null | undefined;
+export declare function ledgerLastSent(hippoRoot: string, tenantId: string, sessionId: string | null | undefined, surface: TokenSurface, reach: LedgerReach): LastSent | null | undefined;
 //# sourceMappingURL=ledger-db.d.ts.map

package/dist/api/ledger-db.js

@@ -1,27 +1,25 @@
 // The store the token ledger writes to for a caller's root; context, recall and the session hooks share it.
-import { errorMessage, log } from '../util/log.js';
-import { getGlobalRoot } from '../sharing/global-store.js';
-import { lastSentOnSurface, noteLedgerRowSkipped, recordLedgerTurn } from '../store/ledger-turn.js';
-import { isInitialized } from '../core/project-identity.js';
-import { sqliteSyncStore } from '../store/sqlite/store.js';
-/** `hippoRoot` when it holds a store, else the global store (the prompt hook fires where no local one exists), else null. */
-export function ledgerRoot(hippoRoot, opts) {
-    if (isInitialized(hippoRoot))
-        return hippoRoot;
-    if (opts?.sharedStore)
-        return null;
-    const globalRoot = getGlobalRoot();
-    return isInitialized(globalRoot) ? globalRoot : null;
+import { errorMessage, log, errorFields } from '../util/log.js';
+import { lastSentOnSurface, noteLedgerRowSkipped, recordLedgerTurn, recordTokensAt, } from '../store/ledger-turn.js';
+import { hasGroup } from '../store/port.js';
+/** The ledger is SQLite-only: a local store needs a reach that says so and a SQLite store; no reach books nowhere. */
+export function ledgerReachOf(ctx, shared) {
+    const hasLocal = ctx.reach?.hasLocal === true && (ctx.store === undefined || hasGroup(ctx.store, 'localFiles'));
+    return shared === true ? { hasLocal } : { hasLocal, global: ctx.reach?.global };
 }
-/** Runs `call` on ledgerRoot's store root. Best-effort: undefined on any failure, because a ledger failure must not break context or recall. */
-export function onLedgerRoot(hippoRoot, opts, call) {
+/** `hippoRoot` when the call has a store of its own, else the global store (the prompt hook fires where none is). */
+export function ledgerRoot(hippoRoot, reach) {
+    return reach.hasLocal ? hippoRoot : (reach.global?.root ?? null);
+}
+/** Runs `call` on ledgerRoot's store root; undefined on any failure, since a ledger failure must not break recall. */
+export function onLedgerRoot(hippoRoot, reach, call) {
     let root = null;
     try {
-        root = ledgerRoot(hippoRoot, opts);
+        root = ledgerRoot(hippoRoot, reach);
     }
     catch (error) {
         // An unreadable store root means no ledger write; the ledger must never break context or recall.
-        log.debug(`token ledger skipped, store root unreadable: ${errorMessage(error)}`);
+        log.debug(`token ledger skipped, store root unreadable: ${errorMessage(error)}`, errorFields(error));
         return undefined;
     }
     if (root === null)
@@ -35,15 +33,15 @@ export function onLedgerRoot(hippoRoot, opts, call) {
     }
 }
 /** Books one row in ledgerRoot's store, best-effort. */
-export function bookTokenUse(hippoRoot, use, opts) {
-    onLedgerRoot(hippoRoot, opts, (root) => sqliteSyncStore(root).recordTokens(use));
+export function bookTokenUse(hippoRoot, use, reach) {
+    onLedgerRoot(hippoRoot, reach, (root) => recordTokensAt(root, use));
 }
 /** Books a turn's rows and then its delivery event on one connection of ledgerRoot's store, best-effort. */
-export function bookLedgerTurn(hippoRoot, turn, opts) {
-    onLedgerRoot(hippoRoot, opts, (root) => recordLedgerTurn(root, turn));
+export function bookLedgerTurn(hippoRoot, turn, reach) {
+    onLedgerRoot(hippoRoot, reach, (root) => recordLedgerTurn(root, turn));
 }
 /** What the session last sent on `surface` in ledgerRoot's store; undefined with no ledger or a failed read. */
-export function ledgerLastSent(hippoRoot, tenantId, sessionId, surface, opts) {
-    return onLedgerRoot(hippoRoot, opts, (root) => lastSentOnSurface(root, tenantId, sessionId, surface));
+export function ledgerLastSent(hippoRoot, tenantId, sessionId, surface, reach) {
+    return onLedgerRoot(hippoRoot, reach, (root) => lastSentOnSurface(root, tenantId, sessionId, surface));
 }
 //# sourceMappingURL=ledger-db.js.map