@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/features/magic-context/fail-closed-block.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Loud fail-closed blocking when Magic Context cannot operate on a session the
+ * user enabled it for (schema fence, storage open/migration failure).
+ *
+ * Motivation: a schema-fence refusal used to unregister hooks and silently fall
+ * through to native compaction — the user saw a 136%+ overflow with zero signal.
+ * When blocking is armed, the harness transform throws an actionable error every
+ * primary-session pass instead of degrading quietly.
+ *
+ * Transient SQLite contention (BUSY/LOCKED) is intentionally NOT handled here —
+ * those stay fail-open pass-through in the outer transform wrappers.
+ */
+import type { ProcessKind, ProcessProbeEvidence } from "../../shared/rpc-utils";
+export declare const FAIL_CLOSED_DOCTOR_COMMAND = "npx @retaw106/mmc-oc@latest doctor";
+/** How often a blocked transform pass re-attempts storage open (1 = every pass). */
+export declare const FAIL_CLOSED_REPROBE_EVERY_N = 5;
+export type FailClosedProcessKind = ProcessKind;
+export interface FailClosedBlockingProcess {
+    /** The detected kind of process holding the shared database. */
+    kind?: FailClosedProcessKind;
+    /** Legacy callers may still provide the old display label. */
+    harness?: string;
+    pid: number;
+    /** Epoch milliseconds from the process identity probe, when available. */
+    startTime?: number | null;
+    /** Raw command line from the process probe, when available. */
+    commandLine?: string | null;
+}
+/**
+ * Preserve the old enumerable blocker shape while carrying fresh probe details
+ * to the diagnostic formatter. This keeps legacy reason snapshots stable while
+ * still making the evidence available through normal property access.
+ */
+export declare function attachFailClosedBlockingProcessEvidence(process: FailClosedBlockingProcess, evidence: ProcessProbeEvidence): FailClosedBlockingProcess;
+export type FailClosedReason = {
+    kind: "migration_guard";
+    persistedVersion: number;
+    supportedVersion: number;
+    blockingProcesses: readonly FailClosedBlockingProcess[];
+    unreadableFile?: string;
+    unreadableArm?: "parse" | "io";
+} | {
+    kind: "schema_fence";
+    persistedVersion: number;
+    supportedVersion: number;
+} | {
+    kind: "storage_failure";
+    cause: string;
+};
+export declare class FailClosedBlockingError extends Error {
+    readonly code = "FAIL_CLOSED_BLOCKING";
+    readonly reason: FailClosedReason;
+    constructor(message: string, reason: FailClosedReason, options?: {
+        cause?: unknown;
+    });
+}
+export declare function formatFailClosedBlockingProcesses(processes: readonly FailClosedBlockingProcess[]): string;
+export declare function formatFailClosedBlockingMessage(reason: FailClosedReason): string;
+/**
+ * One-line form of {@link formatFailClosedBlockingMessage} for surfaces that
+ * must stay short or that leave the machine (a toast, a notice stored in the
+ * conversation): it names each blocking process by kind and PID but leaves out
+ * their command lines, which only the log and doctor need.
+ */
+export declare function formatFailClosedBlockingSummary(reason: FailClosedReason): string;
+export declare function createFailClosedBlockingError(reason: FailClosedReason, options?: {
+    cause?: unknown;
+}): FailClosedBlockingError;
+export declare function isFailClosedBlockingError(error: unknown): error is FailClosedBlockingError;
+/**
+ * Whether this transform/context pass should skip the loud block.
+ * Primary user sessions are never exempt; internal OpenCode agents, Magic
+ * Context hidden children, and Pi subagent processes are.
+ */
+export declare function shouldBypassFailClosedBlock(input: {
+    agent?: string | null;
+    isInternalChildSession?: boolean;
+    isPiSubagentEnv?: boolean;
+}): boolean;
+export declare function resolveAgentNameFromMessages(messages: ReadonlyArray<{
+    info?: unknown;
+} | null | undefined>): string | undefined;
+export interface FailClosedController {
+    arm(reason: FailClosedReason): void;
+    clear(): void;
+    isArmed(): boolean;
+    getReason(): FailClosedReason | null;
+    /**
+     * Enforce the gate for one transform/context pass.
+     * - No-op when unarmed, when blocking is disabled, or when the pass is exempt.
+     * - Periodically re-probes storage; clears and returns when reopen succeeds.
+     * - Otherwise throws {@link FailClosedBlockingError}.
+     */
+    enforce(input: {
+        blockingEnabled: boolean;
+        exempt: boolean;
+        tryReopen?: () => boolean | Promise<boolean>;
+    }): void | Promise<void>;
+}
+/**
+ * Process-local controller shared by the boot path (arms on deterministic
+ * inoperability) and the per-turn transform (enforces / re-probes).
+ */
+export declare function createFailClosedController(options?: {
+    reprobeEveryN?: number;
+}): FailClosedController;
+/** Hook-init classification so boot can arm the gate only for storage failures. */
+export type HookInitFailure = {
+    type: "storage";
+    reason: FailClosedReason;
+} | {
+    type: "no_project";
+};
+export declare function recordHookInitFailure(failure: HookInitFailure): void;
+export declare function clearHookInitFailure(): void;
+export declare function getLastHookInitFailure(): HookInitFailure | null;
+//# sourceMappingURL=fail-closed-block.d.ts.map

package/dist/features/magic-context/fail-closed-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fail-closed-block.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/fail-closed-block.ts"],"names":[],"mappings":"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"}

package/dist/features/magic-context/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./compaction";
+export * from "./compartment-storage";
+export * from "./memory";
+export * from "./range-parser";
+export * from "./scheduler";
+export * from "./search";
+export * from "./storage";
+export * from "./tagger";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/features/magic-context/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/features/magic-context/literal-probes.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Extract high-signal literal tokens ("probes") from a search query.
+ *
+ * Why this exists: `sanitizeFtsQuery` AND-joins every token, so a long natural-
+ * language query like "why did mmc-status tool calls inflate" only matches a
+ * message that contains ALL those words. A message that contains the literal
+ * symbol `/mmc-status` but not the other six words is never retrieved — pure
+ * recall loss, unfixable by ranking. Running each literal probe as its OWN FTS
+ * query (in addition to the full query) recovers those candidates.
+ *
+ * Tuned for a PROSE / CONVERSATION corpus (memories + raw chat + commit
+ * messages), NOT code: we look for the symbol/command/path/identifier shapes
+ * that appear verbatim in conversation and that a paraphrased NL query would
+ * otherwise drown. Plain prose yields zero probes, so NL queries are unaffected.
+ */
+/**
+ * Pull literal probes from a query, most-specific shapes first, deduplicated
+ * (case-insensitive) and capped. Returns [] for plain natural-language text.
+ */
+export declare function extractLiteralProbes(query: string): string[];
+/** True when a probe appears verbatim (case-insensitive) in the text. Used to
+ *  boost candidates that contain the exact literal the user searched for. */
+export declare function containsProbeVerbatim(text: string, probes: string[]): boolean;
+//# sourceMappingURL=literal-probes.d.ts.map

package/dist/features/magic-context/literal-probes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal-probes.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/literal-probes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA2BH;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA+B5D;AAED;6EAC6E;AAC7E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAI7E"}

package/dist/features/magic-context/lkg-prefix-chunks.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Layout of a persisted last-known-good (LKG) prefix in `lkg_slot_chunks`.
+ *
+ * The prefix is the exact JSON string an applied pass served, and it only ever
+ * grows by a small append between passes. Storing it as one value made SQLite
+ * rewrite the whole multi-megabyte record on every pass, because a record whose
+ * length changes is rewritten in full. Fixed-position slices keep an append to
+ * the one or two trailing slices that actually changed.
+ *
+ * The string is cut and concatenated, never re-serialized, so a loaded prefix is
+ * byte-for-byte the string that was saved.
+ */
+/** Size of one stored slice, in UTF-16 code units (JavaScript string length). */
+export declare const LKG_PREFIX_CHUNK_CHARS: number;
+/**
+ * Cut a prefix into consecutive slices of at most LKG_PREFIX_CHUNK_CHARS. A slice
+ * never ends between the two halves of a surrogate pair: SQLite stores TEXT as
+ * UTF-8, and a lone half would not survive the round trip. The boundaries depend
+ * only on the text before them, so appending to a prefix leaves every earlier
+ * slice unchanged.
+ */
+export declare function splitLkgPrefix(jsonPrefix: string): string[];
+export declare function hashLkgChunk(body: string): string;
+/** Hash of the whole prefix, derived from its slice hashes in order. */
+export declare function hashLkgChunkList(chunkHashes: readonly string[]): string;
+export interface LkgPrefixLayout {
+    readonly chunks: string[];
+    readonly chunkHashes: string[];
+    readonly chars: number;
+    readonly hash: string;
+}
+export declare function layoutLkgPrefix(jsonPrefix: string): LkgPrefixLayout;
+export interface AssembledLkgPrefix {
+    readonly jsonPrefix: string;
+    readonly chunkHashes: string[];
+    readonly hash: string;
+}
+/**
+ * Rebuild a prefix from its stored slices and check it against the slot row's
+ * count, length and hash, and each slice against its own stored hash. Returns
+ * undefined on any mismatch: a missing, extra, reordered or partially written
+ * slice must never produce a replayable prefix.
+ */
+export declare function assembleLkgPrefix(expected: {
+    chars: unknown;
+    chunks: unknown;
+    hash: unknown;
+}, rows: ReadonlyArray<{
+    chunk?: unknown;
+    hash?: unknown;
+    body?: unknown;
+}>): AssembledLkgPrefix | undefined;
+//# sourceMappingURL=lkg-prefix-chunks.d.ts.map

package/dist/features/magic-context/lkg-prefix-chunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lkg-prefix-chunks.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/lkg-prefix-chunks.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,iFAAiF;AACjF,eAAO,MAAM,sBAAsB,QAAY,CAAC;AAEhD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAa3D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAEvE;AAED,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAInE;AAED,MAAM,WAAW,kBAAkB;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC7B,QAAQ,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,EAC5D,IAAI,EAAE,aAAa,CAAC;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,GACzE,kBAAkB,GAAG,SAAS,CA2BhC"}

package/dist/features/magic-context/memory/constants.d.ts

@@ -0,0 +1,16 @@
+import type { MemoryCategory } from "./types";
+/**
+ * The v2 world taxonomy — the only categories agents may WRITE today. Exposed
+ * as the mmc_memory schema enum so invalid categories fail at validation
+ * instead of bouncing off a runtime check. Legacy 9-cat values remain readable
+ * (CATEGORY_PRIORITY) for pre-v2 rows but are not accepted for new writes.
+ */
+export declare const V2_MEMORY_CATEGORIES: readonly ["PROJECT_RULES", "ARCHITECTURE", "CONSTRAINTS", "CONFIG_VALUES", "NAMING"];
+export declare const PROMOTABLE_CATEGORIES: MemoryCategory[];
+export declare const CATEGORY_PRIORITY: MemoryCategory[];
+export declare const MEMORY_CATEGORY_ORDER_UNKNOWN = 99;
+export declare const MEMORY_CATEGORY_ORDER_PRIORITY: Record<MemoryCategory, number>;
+export declare const MEMORY_CATEGORY_ORDER_SQL: string;
+export declare function getMemoryCategoryOrder(category: string): number;
+export declare const CATEGORY_DEFAULT_TTL: Partial<Record<MemoryCategory, number>>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/features/magic-context/memory/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,sFAMa,CAAC;AAE/C,eAAO,MAAM,qBAAqB,EAAE,cAAc,EAYjD,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,cAAc,EAW7C,CAAC;AAEF,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAEhD,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAOrE,CAAC;AAEN,eAAO,MAAM,yBAAyB,QAEiB,CAAC;AAExD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAK/D;AAGD,eAAO,MAAM,oBAAoB,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAGxE,CAAC"}

package/dist/features/magic-context/memory/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./constants";
+export * from "./normalize-hash";
+export * from "./project-identity";
+export type { PromotedMemoryRef } from "./promotion";
+export { promoteSessionFactsDurable } from "./promotion";
+export * from "./storage-memory";
+export * from "./storage-memory-fts";
+export * from "./storage-memory-verifications";
+export * from "./types";
+export * from "./verification-paths";
+//# sourceMappingURL=index.d.ts.map

package/dist/features/magic-context/memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AACzD,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC"}

package/dist/features/magic-context/memory/memory-diagnostics.d.ts

@@ -0,0 +1,6 @@
+import type { MemoryImportanceHistogram } from "../../../shared/rpc-types";
+import type { Database } from "../../../shared/sqlite";
+export declare function emptyMemoryImportanceHistogram(): MemoryImportanceHistogram;
+/** Read the ACTIVE pool only; permanent/archived rows do not enter the denominator. */
+export declare function getActiveMemoryImportanceHistogram(db: Database, projectPath: string): MemoryImportanceHistogram;
+//# sourceMappingURL=memory-diagnostics.d.ts.map

package/dist/features/magic-context/memory/memory-diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-diagnostics.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/memory-diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,wBAAgB,8BAA8B,IAAI,yBAAyB,CAY1E;AAmCD,uFAAuF;AACvF,wBAAgB,kCAAkC,CAC9C,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,GACpB,yBAAyB,CAoB3B"}

package/dist/features/magic-context/memory/memory-selection.d.ts

@@ -0,0 +1,12 @@
+import type { Memory } from "./types";
+/** Fields that decide which equal-importance memory survives a bound render budget. */
+export type MemorySelectionCandidate = Pick<Memory, "id" | "importance" | "status" | "lastSeenAt" | "verifiedAt">;
+/**
+ * The newest evidence that a memory is still useful. Exact-dedup re-observation
+ * advances last_seen_at (and seen_count) in storage-memory.ts; verification writes
+ * verified_at. Taking the newer timestamp lets either reinforcement path carry signal.
+ */
+export declare function memoryReinforcementAt(memory: MemorySelectionCandidate): number | null;
+/** Permanent first, then importance and reinforcement recency descending. */
+export declare function compareMemorySelectionPriority(left: MemorySelectionCandidate, right: MemorySelectionCandidate): number;
+//# sourceMappingURL=memory-selection.d.ts.map

package/dist/features/magic-context/memory/memory-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-selection.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/memory-selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,uFAAuF;AACvF,MAAM,MAAM,wBAAwB,GAAG,IAAI,CACvC,MAAM,EACN,IAAI,GAAG,YAAY,GAAG,QAAQ,GAAG,YAAY,GAAG,YAAY,CAC/D,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,wBAAwB,GAAG,MAAM,GAAG,IAAI,CAKrF;AAED,6EAA6E;AAC7E,wBAAgB,8BAA8B,CAC1C,IAAI,EAAE,wBAAwB,EAC9B,KAAK,EAAE,wBAAwB,GAChC,MAAM,CAmBR"}

package/dist/features/magic-context/memory/memory-visibility.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Workspace memory visibility and ownership, in one place.
+ *
+ * Two read/write predicates decide what a project may do with a memory row:
+ *
+ *  - VISIBLE (read): the project's own memories in every category, plus a
+ *    workspace member's memories only while they are active, unexpired, marked
+ *    shareable, scoped beyond the writing project, and in a category the
+ *    workspace explicitly shares.
+ *  - OWNED (mutate): only rows that resolve to this project's identity. A
+ *    shared memory from another project is readable here and never writable
+ *    here — sharing grants reading, not editing.
+ *
+ * The mmc_memory tool and the Rust-mode memory facade both need exactly these
+ * predicates, and a second copy of the share policy would be a second place for
+ * it to drift. Both import this factory instead.
+ */
+import type { Database } from "../../../shared/sqlite";
+/** The memory fields the two predicates read. `Memory` satisfies this. */
+export interface VisibilityCandidateMemory {
+    projectPath: string;
+    category: string;
+    status: string;
+    scope: string;
+    /** SQLite INTEGER boolean: 1 = shareable, 0 = private. */
+    shareable: number;
+    expiresAt: number | null;
+}
+export interface MemoryVisibilityPolicy {
+    /** True when this project is a member of a multi-project workspace. */
+    readonly workspaced: boolean;
+    /** Canonical workspace identity for a stored project path. */
+    identityFor(storedProjectPath: string): string;
+    /** READ contract: own memories always, foreign memories only when shared. */
+    visible(memory: VisibilityCandidateMemory): boolean;
+    /** WRITE contract: the row must resolve to this project's identity. */
+    owned(memory: VisibilityCandidateMemory): boolean;
+}
+/**
+ * Build the visibility/ownership predicates for `projectIdentity`.
+ *
+ * Reads the workspace membership, identity aliases and share categories once,
+ * so a caller can classify a batch of ids without re-querying per row.
+ */
+export declare function createMemoryVisibilityPolicy(db: Database, projectIdentity: string): MemoryVisibilityPolicy;
+//# sourceMappingURL=memory-visibility.d.ts.map

package/dist/features/magic-context/memory/memory-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-visibility.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/memory-visibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAUvD,0EAA0E;AAC1E,MAAM,WAAW,yBAAyB;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACnC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,8DAA8D;IAC9D,WAAW,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/C,6EAA6E;IAC7E,OAAO,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC;IACpD,uEAAuE;IACvE,KAAK,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC;CACrD;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CACxC,EAAE,EAAE,QAAQ,EACZ,eAAe,EAAE,MAAM,GACxB,sBAAsB,CAiDxB"}

package/dist/features/magic-context/memory/normalize-hash.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeMemoryContent(content: string): string;
+export declare function computeNormalizedHash(content: string): string;
+//# sourceMappingURL=normalize-hash.d.ts.map

package/dist/features/magic-context/memory/normalize-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-hash.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/normalize-hash.ts"],"names":[],"mappings":"AAEA,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAK7D"}

package/dist/features/magic-context/memory/project-identity-cache.d.ts

@@ -0,0 +1,7 @@
+import { projectDirectoryKey } from "../../../shared/project-directory-key";
+export { projectDirectoryKey };
+/** A small atomic sidecar avoids opening or migrating the store during plugin boot. */
+export declare function rememberGitIdentity(directory: string, identity: string): void;
+/** `storageDir` lets offline tools read the sidecars that sit next to a chosen `context.db`. */
+export declare function readRememberedGitIdentity(directory: string, storageDir?: string): string | undefined;
+//# sourceMappingURL=project-identity-cache.d.ts.map

package/dist/features/magic-context/memory/project-identity-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-identity-cache.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/project-identity-cache.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAK5E,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAO/B,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAU7E;AAED,gGAAgG;AAChG,wBAAgB,yBAAyB,CACrC,SAAS,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,MAAM,GACpB,MAAM,GAAG,SAAS,CAYpB"}

package/dist/features/magic-context/memory/project-identity.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Resolve a stable project identity from the working directory.
+ *
+ * Strategy:
+ *   1. Git repo with commits → root commit hash (same across worktrees, clones, forks)
+ *   2. Git repo with an unborn HEAD → directory hash until the first commit
+ *   3. Transient git failure → reuse durable identity or defer
+ *   4. No git repo → fallback to directory hash via resolveProjectIdentity()
+ *
+ * The root commit hash is immutable and survives remote renames, host
+ * migrations, and SSH/HTTPS URL changes. It is the same across all
+ * worktrees and clones of the same repository.
+ */
+import { execFileSync } from "node:child_process";
+export declare function setHomeProjectPermission(allowed: boolean): void;
+/** Skip memory work on a disallowed home project without generating repeated failures. */
+export declare function shouldSkipHomeProjectMemory(directory: string): boolean;
+/** Git failures retain their classification; confirmed unborn repositories may use directory-based identity keys. */
+export type ProjectIdentityErrorClass = "home_project_disabled" | "git_identity_unavailable" | "not_git_repo" | "no_commits" | "git_missing" | "git_timeout" | "dubious_ownership" | "permission_denied" | "unknown";
+/**
+ * Strict project identity resolution error with stable machine-readable classification.
+ */
+export declare class ProjectIdentityError extends Error {
+    readonly errorClass: ProjectIdentityErrorClass;
+    readonly rawDirectory: string;
+    constructor(errorClass: ProjectIdentityErrorClass, rawDirectory: string, message: string, cause?: Error);
+}
+/**
+ * Strictly resolve the project identity for a filesystem directory.
+ *
+ * Returns only `git:<root-commit-sha>` and never silently falls back. Failures are thrown as
+ * `ProjectIdentityError` with a stable `errorClass` so callers can distinguish deterministic
+ * non-git directories from transient git/runtime failures.
+ *
+ * The cache is process-local, keyed by `path.resolve(directory)`, and stores only successful git
+ * identities. Transient failures are never cached.
+ */
+export declare function resolveProjectIdentityStrict(directory: string, allowHomeProject?: boolean): string;
+export declare function takeDubiousOwnershipProjectIdentityWarning(directory: string): string | null;
+export declare function isUserHomeDirectory(directory: string): boolean;
+export declare function resolveProjectIdentity(directory: string, allowHomeProject?: boolean): string;
+export declare function resolveProjectIdentityOrFallback(directory: string, allowHomeProject?: boolean): string;
+/** Cheap metadata probe for user-facing commit-search availability. This avoids
+ * running `git log` on every mmc_search call while still distinguishing a true
+ * non-repository directory from a transient `dir:` identity fallback. */
+export declare function directoryHasGitMetadata(directory: string): boolean;
+/**
+ * Explain to an agent (and the user reading its tool output) why a session has no
+ * project identity. The tools only see `undefined` from the resolver; without this
+ * they reported "Could not resolve project identity" and agents blamed the absence
+ * of a git repository, which is not a cause — non-git directories resolve to a
+ * `dir:` identity. The one deliberate refusal is a session running in the home
+ * directory itself.
+ */
+export declare function describeUnresolvedProjectIdentity(directory: string): string;
+/**
+ * Whether a resolved project identity can key project-scoped state (memories,
+ * embeddings, dreamer schedules, session attribution). An unresolved directory
+ * has no identity; callers that coerce that to "" must refuse the empty string
+ * instead of using it as one more project.
+ */
+export declare function isUsableProjectIdentity(identity: string | null | undefined): identity is string;
+export declare function resolveProjectIdentityForSession(directory: string, allowHomeProject?: boolean): string | undefined;
+/**
+ * Normalize a stored project path or legacy raw filesystem path.
+ *
+ * Already-resolved `git:` / `dir:` identities are returned byte-for-byte. Raw filesystem paths are
+ * resolved through the production wrapper. Unresolved paths remain unchanged so a transient
+ * git failure cannot manufacture a new project identity during an ownership check.
+ */
+export declare function normalizeStoredProjectPath(rawOrStored: string): string;
+/**
+ * Ownership check for a memory row against the current session's resolved
+ * project identity. A memory's stored `project_path` may be a raw filesystem
+ * path (legacy) OR an already-normalized `git:`/`dir:` identity; either must
+ * match the current identity after normalization. Used by mmc_memory
+ * delete/update/archive/merge so a session can still manage memories stored
+ * under a legacy raw path that normalizes to the same project (shared by both
+ * harnesses — Pi previously used raw `===`, diverging from OpenCode).
+ */
+export declare function storedPathBelongsToIdentity(storedProjectPath: string, projectIdentity: string): boolean;
+/**
+ * Detect whether a directory belongs to a linked Git worktree. Linked worktrees
+ * have a per-worktree git dir while sharing the primary checkout's common dir.
+ * The probe is cached because authority recovery can be considered every pass.
+ */
+export declare function isLinkedGitWorktree(directory: string): boolean;
+export declare function __setProjectIdentityTestHooks(hooks: {
+    execFileSync?: typeof execFileSync;
+    homeDirectory?: () => string;
+    nowMs?: () => number;
+    onFilesystemProbe?: () => void;
+}): void;
+export declare function __clearProjectIdentityTransientCooldownForTests(directory?: string): void;
+export declare function __clearProjectIdentityResolutionCacheForTests(directory?: string): void;
+export declare function __resetProjectIdentityForTests(): void;
+//# sourceMappingURL=project-identity.d.ts.map

package/dist/features/magic-context/memory/project-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-identity.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/project-identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAkDlD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAE/D;AAED,0FAA0F;AAC1F,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAgBtE;AAMD,qHAAqH;AACrH,MAAM,MAAM,yBAAyB,GAC/B,uBAAuB,GACvB,0BAA0B,GAC1B,cAAc,GACd,YAAY,GACZ,aAAa,GACb,aAAa,GACb,mBAAmB,GACnB,mBAAmB,GACnB,SAAS,CAAC;AAEhB;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,UAAU,EAAE,yBAAyB,CAAC;IAC/C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;gBAG1B,UAAU,EAAE,yBAAyB,EACrC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,KAAK;CAUpB;AA4MD;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CACxC,SAAS,EAAE,MAAM,EACjB,gBAAgB,UAAwB,GACzC,MAAM,CAoER;AA8ED,wBAAgB,0CAA0C,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM3F;AAmBD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAW9D;AAiBD,wBAAgB,sBAAsB,CAClC,SAAS,EAAE,MAAM,EACjB,gBAAgB,UAAwB,GACzC,MAAM,CAqDR;AAED,wBAAgB,gCAAgC,CAC5C,SAAS,EAAE,MAAM,EACjB,gBAAgB,UAAwB,GACzC,MAAM,CAiBR;AAmDD;;yEAEyE;AACzE,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAElE;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAoB3E;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,QAAQ,IAAI,MAAM,CAE/F;AAED,wBAAgB,gCAAgC,CAC5C,SAAS,EAAE,MAAM,EACjB,gBAAgB,UAAwB,GACzC,MAAM,GAAG,SAAS,CA6DpB;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAWtE;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACvC,iBAAiB,EAAE,MAAM,EACzB,eAAe,EAAE,MAAM,GACxB,OAAO,CAKT;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CA6B9D;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACjD,YAAY,CAAC,EAAE,OAAO,YAAY,CAAC;IACnC,aAAa,CAAC,EAAE,MAAM,MAAM,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;CAClC,GAAG,IAAI,CAKP;AAED,wBAAgB,+CAA+C,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAWxF;AAED,wBAAgB,6CAA6C,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAWtF;AAED,wBAAgB,8BAA8B,IAAI,IAAI,CAmBrD"}

package/dist/features/magic-context/memory/promotion.d.ts

@@ -0,0 +1,26 @@
+import type { Database } from "../../../shared/sqlite";
+interface SessionFact {
+    category: string;
+    content: string;
+}
+export interface PromotedMemoryRef {
+    memoryId: number;
+    content: string;
+}
+export interface PromoteSessionFactsDurableResult {
+    /** Newly inserted memories that still need embedding. */
+    newMemoryRefs: PromotedMemoryRef[];
+    /** Valid promotable facts that inserted a row or updated an existing row. */
+    factsPromoted: number;
+}
+/**
+ * Synchronously promote eligible session facts to cross-session memories.
+ *
+ * Transaction contract: callers may run this inside their publish transaction.
+ * Storage failures deliberately propagate so the enclosing publication rolls
+ * back atomically with the boundary; malformed/unpromotable facts are validation
+ * skips and do not abort the publish.
+ */
+export declare function promoteSessionFactsDurable(db: Database, sessionId: string, projectPath: string, facts: SessionFact[]): PromoteSessionFactsDurableResult;
+export {};
+//# sourceMappingURL=promotion.d.ts.map

package/dist/features/magic-context/memory/promotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promotion.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/promotion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAMvD,UAAU,WAAW;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gCAAgC;IAC7C,yDAAyD;IACzD,aAAa,EAAE,iBAAiB,EAAE,CAAC;IACnC,6EAA6E;IAC7E,aAAa,EAAE,MAAM,CAAC;CACzB;AAWD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACtC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,WAAW,EAAE,GACrB,gCAAgC,CAwClC"}

package/dist/features/magic-context/memory/relocate-memory.d.ts

@@ -0,0 +1,58 @@
+import type { Database } from "../../../shared/sqlite";
+import type { MemoryStatus } from "./types";
+/**
+ * Memory relocation primitives shared by the v22 dir-identity backfill and the
+ * `doctor migrate-session` command (re-homing a session to a different project).
+ *
+ * All operations are collision-aware against UNIQUE(project_path, category,
+ * normalized_hash): the target identity may already hold an equivalent memory,
+ * and a blind write there would abort the surrounding transaction. MUST run
+ * inside a transaction.
+ */
+export interface RelocateMemorySelection {
+    /** Status set to operate on. Archived memories are deliberately excluded by
+     *  default — they are suppressed history, not injectable knowledge. */
+    statuses?: MemoryStatus[];
+    /** When set, restrict to memories whose `source_session_id` matches (the
+     *  "only memories originated from this session" option). */
+    sourceSessionId?: string;
+}
+/**
+ * Resolve the memory ids under `fromProjectPath` that a relocation should act
+ * on, honoring the status filter and the optional originator-session filter.
+ */
+export declare function selectRelocatableMemoryIds(db: Database, fromProjectPath: string, selection?: RelocateMemorySelection): number[];
+/**
+ * Collision-aware single-row rekey. If the target identity already holds an
+ * equivalent memory (same category + normalized_hash), merge into it (keep the
+ * larger seen_count, delete the source — embedding FK-cascades) instead of
+ * aborting the transaction on the UNIQUE violation; otherwise do the guarded
+ * UPDATE. Returns true if the row was rekeyed or merged. MUST run inside a
+ * transaction.
+ */
+export declare function rekeyMemoryRowWithCollisionMerge(db: Database, rowId: number, fromProjectPath: string, toIdentity: string): boolean;
+export interface RelocateResult {
+    /** Rows rekeyed/inserted under the target identity. */
+    relocated: number;
+    /** Rows merged into a pre-existing equivalent at the target (move only). */
+    merged: number;
+    /** Rows skipped because an equivalent already existed at the target (copy only). */
+    skipped: number;
+}
+/**
+ * MOVE a set of memory ids from `fromProjectPath` to `toIdentity`. The source
+ * project loses them. Collision-safe (merge into an existing equivalent at the
+ * target). Embeddings follow automatically (memory_id is unchanged on a rekey,
+ * FK-cascade on a merge-delete). MUST run inside a transaction.
+ */
+export declare function moveMemoriesToProject(db: Database, ids: number[], fromProjectPath: string, toIdentity: string): RelocateResult;
+/**
+ * COPY a set of memory ids under `toIdentity`, leaving the source rows intact.
+ * Each copy gets a fresh id; its embedding (if any) is duplicated. Collision-safe
+ * via INSERT OR IGNORE against the UNIQUE constraint — a row already present at
+ * the target is skipped (no duplicate). `project_path` is overridden to the
+ * target; all other columns (including source_session_id and timestamps) are
+ * preserved for provenance. MUST run inside a transaction.
+ */
+export declare function copyMemoriesToProject(db: Database, ids: number[], toIdentity: string): RelocateResult;
+//# sourceMappingURL=relocate-memory.d.ts.map

package/dist/features/magic-context/memory/relocate-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relocate-memory.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/relocate-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;;;;;;GAQG;AAEH,MAAM,WAAW,uBAAuB;IACpC;2EACuE;IACvE,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;IAC1B;gEAC4D;IAC5D,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAID;;;GAGG;AACH,wBAAgB,0BAA0B,CACtC,EAAE,EAAE,QAAQ,EACZ,eAAe,EAAE,MAAM,EACvB,SAAS,GAAE,uBAA4B,GACxC,MAAM,EAAE,CAaV;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAC5C,EAAE,EAAE,QAAQ,EACZ,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,GACnB,OAAO,CA4CT;AAED,MAAM,WAAW,cAAc;IAC3B,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;IACf,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACjC,EAAE,EAAE,QAAQ,EACZ,GAAG,EAAE,MAAM,EAAE,EACb,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,GACnB,cAAc,CAqBhB;AAeD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACjC,EAAE,EAAE,QAAQ,EACZ,GAAG,EAAE,MAAM,EAAE,EACb,UAAU,EAAE,MAAM,GACnB,cAAc,CAyBhB"}

package/dist/features/magic-context/memory/storage-memory-fts.d.ts

@@ -0,0 +1,11 @@
+import type { Database } from "../../../shared/sqlite";
+import type { Memory } from "./types";
+export interface MemorySearchDateRange {
+    from: number;
+    to: number;
+}
+export declare function relaxedFtsQuery(query: string): string;
+export declare function sanitizeFtsQuery(query: string): string;
+export declare function searchMemoriesFTS(db: Database, projectPath: string, query: string, limit?: number, dateRange?: MemorySearchDateRange | null): Memory[];
+export declare function searchMemoriesFTSUnion(db: Database, projectPaths: readonly string[], query: string, limit?: number, ownIdentities?: readonly string[], shareCategories?: readonly string[] | null, dateRange?: MemorySearchDateRange | null): Memory[];
+//# sourceMappingURL=storage-memory-fts.d.ts.map

package/dist/features/magic-context/memory/storage-memory-fts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-memory-fts.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/storage-memory-fts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAkC,MAAM,wBAAwB,CAAC;AAOvF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAQtC,MAAM,WAAW,qBAAqB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACd;AA4CD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKrD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUtD;AAED,wBAAgB,iBAAiB,CAC7B,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,KAAK,SAAuB,EAC5B,SAAS,GAAE,qBAAqB,GAAG,IAAW,GAC/C,MAAM,EAAE,CAmCV;AAED,wBAAgB,sBAAsB,CAClC,EAAE,EAAE,QAAQ,EACZ,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,KAAK,EAAE,MAAM,EACb,KAAK,SAAuB,EAC5B,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,EACjC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,EAC1C,SAAS,GAAE,qBAAqB,GAAG,IAAW,GAC/C,MAAM,EAAE,CAyEV"}

package/dist/features/magic-context/memory/storage-memory-verifications.d.ts

@@ -0,0 +1,35 @@
+import type { Database } from "../../../shared/sqlite";
+export declare const MEMORY_VERIFICATION_SENTINEL = "";
+/** Records whether a no-file mapping came from the mapper or a host safety fallback. */
+export type MemoryMappingOrigin = "mapper" | "host_rejected_fallback";
+export interface MemoryVerificationState {
+    /** Real repo-root-relative backing files. Excludes the no-file sentinel. */
+    files: string[];
+    /** True when a `""` no-file sentinel row exists for this memory. */
+    hasSentinel: boolean;
+    /** The actor/disposition that established this mapping. */
+    mappingOrigin: MemoryMappingOrigin;
+    /** Max verified_at across all rows. 0 = mapped (files known) but NOT yet
+     *  content-verified (the map-memories backfill records files without checking). */
+    verifiedAt: number;
+    /** Max mapped_at across all rows — when the file mapping was established. */
+    mappedAt: number;
+}
+/**
+ * MAP (map-memories backfill): record WHICH files back a memory (or the no-file
+ * sentinel) WITHOUT content-verifying it — `verified_at=0`, `mapped_at=now`. The
+ * first verify still sees it as unverified (verified_at=0) and checks the claim.
+ */
+export declare function recordMemoryMapping(db: Database, memoryId: number, normalizedFiles: readonly string[], now: number, mappingOrigin?: MemoryMappingOrigin): number;
+/**
+ * VERIFY: replace one memory's side-table rows, marking them content-verified
+ * (`verified_at=now`, `mapped_at=now`). Callers updating multiple memories should
+ * wrap their batch in one transaction.
+ */
+export declare function recordMemoryVerifications(db: Database, memoryId: number, normalizedFiles: readonly string[], now: number): number;
+/** Memory ids (from the given set) that have NO mapping rows yet — the
+ *  map-memories backfill scope. */
+export declare function getUnmappedMemoryIds(db: Database, memoryIds: readonly number[]): number[];
+export declare function clearMemoryVerifications(db: Database, memoryId: number): void;
+export declare function getMemoryVerifications(db: Database, memoryIds: readonly number[]): Map<number, MemoryVerificationState>;
+//# sourceMappingURL=storage-memory-verifications.d.ts.map