@retaw106/mmc-oc 0.0.0-stage → 1.2.2

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

@@ -0,0 +1,76 @@
+import type { Database } from "../../../shared/sqlite";
+/**
+ * Single-row pool probe for the maintenance launch gate. The semantics are
+ * the pipeline's pool waterline (`defaultLoadPool` → `getMemoriesByProject`):
+ * `status IN ('active', 'permanent')` with NO expiry filter — stranded
+ * expired rows belong to the maintainer's archive mandate, so a project
+ * holding only those must still be eligible, and a fully archived project
+ * must not (plan 10 gate-3 alignment finding; both hosts read through this
+ * one function).
+ */
+export declare function countMaintenancePool(db: Database, projectPath: string): number;
+/**
+ * Storage attachment for the automatic memory-maintenance task (plan 10,
+ * P1/F2). Owns the `mmc-maint` schedule row in `task_schedule_state` and the
+ * task's run telemetry rows in `dream_runs`.
+ */
+/** The `task_schedule_state.task` value owned by the memory-maintenance task. */
+export declare const MAINTENANCE_TASK = "mmc-maint";
+/**
+ * The only schedule columns this module may write. `undefined` = not provided
+ * (keep the current value); explicit `null` = clear the column.
+ */
+export interface MaintenanceSchedulePatch {
+    lastRunAt?: number | null;
+    nextDueAt?: number | null;
+    lastStatus?: string | null;
+    lastError?: string | null;
+    retryCount?: number;
+}
+export interface MaintenanceSchedule {
+    lastRunAt: number | null;
+    nextDueAt: number | null;
+    lastStatus: string | null;
+    lastError: string | null;
+    retryCount: number;
+}
+export interface MaintenanceRunInput {
+    projectPath: string;
+    startedAt: number;
+    finishedAt: number;
+    holderId: string;
+    /** JSON: per-stage entries incl. budget{budget,spent,finalizeFired,banked} (decision 16). */
+    tasksJson: string;
+    tasksSucceeded: number;
+    tasksFailed: number;
+    /** JSON: change counters + affected memory ids; NULL when nothing changed. */
+    memoryChangesJson: string | null;
+    parentSessionId: string | null;
+}
+export interface MaintenanceRunRecord extends MaintenanceRunInput {
+    id: number;
+}
+/**
+ * D10 anti-borrowing red line (plan decision 14): this module writes ONLY the
+ * five semantically-matching columns declared in `MaintenanceSchedulePatch`.
+ * `schedule` stays NULL (never stuffed with JSON), and `last_checked_commit` /
+ * `last_broad_run_at` / `retrospective_watermark_ms` are upstream's
+ * historically borrowed columns whose semantics this task does not adopt —
+ * they are never read or written here.
+ */
+export declare function getMaintenanceSchedule(db: Database, projectPath: string): MaintenanceSchedule | null;
+/**
+ * Upsert the `mmc-maint` schedule row. Columns absent from the patch keep
+ * their current value (a first insert leaves them NULL); only the five
+ * writable columns are ever touched — see the D10 red-line note above.
+ */
+export declare function writeMaintenanceSchedule(db: Database, projectPath: string, patch: MaintenanceSchedulePatch): void;
+/**
+ * Insert one maintenance run telemetry row. `smart_notes_surfaced` /
+ * `smart_notes_pending` are dreamer-era counters the maintenance task never
+ * produces; decision 16 pins them to 0.
+ */
+export declare function insertMaintenanceRun(db: Database, run: MaintenanceRunInput): number;
+/** Newest-first run telemetry for one project (matches the finished_at DESC index). */
+export declare function getRecentMaintenanceRuns(db: Database, projectPath: string, limit: number): MaintenanceRunRecord[];
+//# sourceMappingURL=schedule-storage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-storage.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory-maintainer/schedule-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAO9E;AAED;;;;GAIG;AAEH,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,cAAc,CAAC;AAE5C;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACrC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAChC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,6FAA6F;IAC7F,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,oBAAqB,SAAQ,mBAAmB;IAC7D,EAAE,EAAE,MAAM,CAAC;CACd;AAuBD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAClC,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,GACpB,mBAAmB,GAAG,IAAI,CAgB5B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACpC,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,wBAAwB,GAChC,IAAI,CA6BN;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,mBAAmB,GAAG,MAAM,CAqBnF;AAED,uFAAuF;AACvF,wBAAgB,wBAAwB,CACpC,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GACd,oBAAoB,EAAE,CAuBxB"}

package/dist/features/magic-context/memory-maintainer/schedule.d.ts

@@ -0,0 +1,90 @@
+import type { Database } from "../../../shared/sqlite";
+/**
+ * Trigger eligibility and backoff/cooldown accounting for the memory-
+ * maintenance task (plan 10 §4.2, decisions 5-10, P1/F3).
+ *
+ * `evaluateEligibility` is a pure function over cheap reads only (in-memory
+ * flags + one schedule row + one pool count + the coverage completion record);
+ * the P2 hook wiring assembles the input and never blocks a transform pass.
+ * `applyRunOutcome` persists the run result: the schedule row carries the
+ * retry/backoff state, the coverage key carries the completion record. Errors
+ * are never written as success (D4), and `next_due_at` is always lifted past
+ * the inter-run cooldown (decision 10).
+ */
+/** Coverage rounds are spaced ≥24h from the last full-pool completion (D3). */
+export declare const DEFAULT_COVERAGE_INTERVAL_MS: number;
+export interface MaintenanceCooldownConfig {
+    /** Minimum cooldown between two runs of the same project (decision 10; default 30min). */
+    interRunMs: number;
+    /** Failure backoff applied in order (decision 10; default [15m, 1h, 4h]). */
+    backoffScheduleMs: number[];
+    /** Upper bound for backoff delays (decision 10; default 24h). */
+    backoffCapMs: number;
+    /** Failed attempts before the task re-arms behind the cap (never permanently abandoned). */
+    maxRetries: number;
+    /** Coverage interval; defaults to DEFAULT_COVERAGE_INTERVAL_MS (24h). */
+    coverageIntervalMs?: number;
+}
+export interface EligibilityInput {
+    nowMs: number;
+    projectActive: boolean;
+    /** A coverage round with `completedAt` exists (decision 8: absent → due immediately). */
+    hasCompletionRecord: boolean;
+    lastCompletedAt: number | null;
+    /** `task_schedule_state.next_due_at` (backoff / cooldown gate). */
+    nextDueAt: number | null;
+    poolCount: number;
+    runInFlight: boolean;
+    historianInFlight: boolean;
+    paused: boolean;
+    compactionEnabled: boolean;
+    /** Recursion guard (decision 6): a maintenance hidden child never re-triggers. */
+    isChildSession: boolean;
+    coverageIntervalMs?: number;
+}
+export interface EligibilityVerdict {
+    eligible: boolean;
+    /** First failing clause, or "eligible". Stable, greppable identifiers. */
+    reason: string;
+}
+/**
+ * Eligibility (plan §4.2, decisions 5-8): project active ∧ now ≥
+ * next_eligible_at ∧ non-empty pool ∧ no run in flight ∧ historian avoidance ∧
+ * not paused ∧ compaction on ∧ not a child session. next_eligible_at: with a
+ * completion record = max(lastCompletedAt + coverageInterval, nextDueAt);
+ * without one = nextDueAt alone (first run is due immediately, but a backoff
+ * written by a previous failed run still gates).
+ */
+export declare function evaluateEligibility(input: EligibilityInput): EligibilityVerdict;
+export type RunOutcome = "round_completed" | "budget_exhausted" | "zero_progress" | "circuit_broken" | "failure" | "partial";
+export interface ApplyRunOutcomeOptions {
+    nowMs: number;
+    cooldowns: MaintenanceCooldownConfig;
+    /** Failure-family detail for `last_error`; never written for success outcomes. */
+    reason?: string | null;
+    /**
+     * D4 in-lock revalidation: invoked INSIDE the BEGIN IMMEDIATE transaction
+     * before any write. Return false (or throw) to abort the outcome write —
+     * the pipeline passes a lease holder+generation check so a stale holder
+     * cannot record an outcome after losing the lease.
+     */
+    verifyOwnership?: () => boolean;
+}
+/**
+ * Persist one finished run (plan decisions 8/10/14):
+ *   - round_completed → coverage `completedAt` recorded, retryCount reset,
+ *     nextDue = completion + coverage interval;
+ *   - partial (progress, round open, budget remaining) → nextDue = inter-run
+ *     cooldown, retryCount untouched (no punitive backoff, plan §4.2);
+ *   - failure / budget_exhausted / zero_progress / circuit_broken → the same
+ *     backoff accounting: backoffSchedule[retryCount] while under maxRetries,
+ *     then the cap cooldown with a re-arm (retryCount → 0, never abandoned);
+ *   - zero_progress additionally terminates an unproductive round (the
+ *     pipeline only assigns it when the round has banked nothing — see the
+ *     pipeline outcome rules);
+ *   - every nextDue is lifted past the inter-run cooldown.
+ *
+ * All writes land in one short BEGIN IMMEDIATE transaction.
+ */
+export declare function applyRunOutcome(db: Database, projectPath: string, outcome: RunOutcome, opts: ApplyRunOutcomeOptions): void;
+//# sourceMappingURL=schedule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory-maintainer/schedule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAIvD;;;;;;;;;;;GAWG;AAEH,+EAA+E;AAC/E,eAAO,MAAM,4BAA4B,QAAsB,CAAC;AAEhE,MAAM,WAAW,yBAAyB;IACtC,0FAA0F;IAC1F,UAAU,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC;IACrB,4FAA4F;IAC5F,UAAU,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,OAAO,CAAC;IACvB,yFAAyF;IACzF,mBAAmB,EAAE,OAAO,CAAC;IAC7B,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,mEAAmE;IACnE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,kFAAkF;IAClF,cAAc,EAAE,OAAO,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,kBAAkB;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,kBAAkB,CAmB/E;AAED,MAAM,MAAM,UAAU,GAChB,iBAAiB,GACjB,kBAAkB,GAClB,eAAe,GACf,gBAAgB,GAChB,SAAS,GACT,SAAS,CAAC;AAShB,MAAM,WAAW,sBAAsB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,yBAAyB,CAAC;IACrC,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,OAAO,CAAC;CACnC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC3B,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,sBAAsB,GAC7B,IAAI,CA+DN"}

package/dist/features/magic-context/merged-reasoning-decisions.d.ts

@@ -0,0 +1,6 @@
+export declare const MERGED_REASONING_PARTS_PREFIX = "__merged_reasoning_parts_v1__:";
+export type FrozenReasoningPart = string | number;
+/** Stable host part ids are preferred; adapters without ids use the part index. */
+export declare function decodeMergedReasoningParts(value: string): [string, FrozenReasoningPart[]] | null;
+export declare function readFrozenMergedReasoningParts(ids: ReadonlySet<string>): Map<string, FrozenReasoningPart[]>;
+//# sourceMappingURL=merged-reasoning-decisions.d.ts.map

package/dist/features/magic-context/merged-reasoning-decisions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merged-reasoning-decisions.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/merged-reasoning-decisions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,mCAAmC,CAAC;AAC9E,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,MAAM,CAAC;AAElD,mFAAmF;AACnF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,GAAG,IAAI,CA2BhG;AAMD,wBAAgB,8BAA8B,CAC1C,GAAG,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,GAAG,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,CA0BpC"}

package/dist/features/magic-context/message-fts-rowid-map.d.ts

@@ -0,0 +1,50 @@
+import type { Database } from "../../shared/sqlite";
+export declare const MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE = 100;
+/**
+ * Load user/assistant message rows (joined through the rowid map) for an
+ * ordinal range — the canonical FTS chunk-load query for message search.
+ * (Lived in compartment-chunk-embedding.ts before the embedding stack was
+ * removed; the FTS5 path it serves is retained.)
+ */
+export declare const MESSAGE_FTS_CHUNK_LOAD_SQL = "SELECT map.message_ordinal AS messageOrdinal, fts.role, fts.content\n FROM message_fts_rowid_map AS map\n CROSS JOIN message_history_fts AS fts\n   ON fts.rowid = map.fts_rowid\n WHERE map.session_id = ?\n   AND map.message_ordinal BETWEEN ? AND ?\n   AND fts.role IN ('user', 'assistant')\n ORDER BY map.message_ordinal ASC";
+export interface MessageFtsRowidMapBackfillProgress {
+    processed: number;
+    watermarkRowid: number;
+    completed: boolean;
+}
+/** Record the FTS row identity in the caller's message-index transaction. */
+export declare function recordMessageFtsRowid(db: Database, sessionId: string, messageOrdinal: number, ftsRowid: number | bigint, messageTimeMs?: number | null): void;
+/** Fill a missing indexed timestamp without changing the FTS row identity. */
+export declare function recordIndexedMessageTime(db: Database, sessionId: string, messageOrdinal: number, messageTimeMs: number | null | undefined): void;
+/**
+ * Map one bounded rowid-ascending FTS window and persist its watermark atomically.
+ * The rowid constraint is an FTS5 point/range access; it never filters an
+ * UNINDEXED identity column.
+ */
+export declare function backfillMessageFtsRowidMapBatch(db: Database, batchSize?: number): MessageFtsRowidMapBackfillProgress;
+/** Drain legacy FTS rows in bounded turns so SQLite never owns the host loop. */
+export declare function runMessageFtsRowidMapBackfill(db: Database): Promise<void>;
+/** Coalesce OpenCode and Pi startup attempts sharing one in-process DB handle. */
+export declare function startMessageFtsRowidMapBackfill(db: Database): Promise<void>;
+/**
+ * A partially backfilled span is readable only when the ordinary source table
+ * proves every ordinal is known and every indexable source row already has a
+ * map entry. Legacy spans without complete source metadata wait for the global
+ * rowid backfill to finish.
+ */
+export declare function messageFtsOrdinalRangeIsMapped(db: Database, sessionId: string, startOrdinal: number, endOrdinal: number): boolean;
+export declare function getMessageFtsRowidMapBackfillProgress(db: Database): MessageFtsRowidMapBackfillProgress;
+/**
+ * Delete the FTS rows of whole sessions that the rowid map cannot reach yet.
+ *
+ * Whole-session clears delete FTS rows through `message_fts_rowid_map`. Rows
+ * written before the map existed get their map entry only when the bounded
+ * backfill reaches them, and the backfill walks rowids in ascending order, so
+ * every such unmapped row sits above its watermark. Until the backfill
+ * completes, a clear also sweeps that rowid range for the sessions; otherwise
+ * the rows outlive the clear, get mapped later, and surface in search as stale
+ * duplicates forever, even after the session is deleted. The rowid bound keeps
+ * the sweep to the part of the table the backfill has not reached.
+ */
+export declare function deleteUnmappedMessageFtsRows(db: Database, sessionIds: readonly string[]): void;
+//# sourceMappingURL=message-fts-rowid-map.d.ts.map

package/dist/features/magic-context/message-fts-rowid-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-fts-rowid-map.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/message-fts-rowid-map.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAkC,MAAM,qBAAqB,CAAC;AAIpF,eAAO,MAAM,yCAAyC,MAAM,CAAC;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,yUAOL,CAAC;AAgBnC,MAAM,WAAW,kCAAkC;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;CACtB;AA4CD,6EAA6E;AAC7E,wBAAgB,qBAAqB,CACjC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,aAAa,GAAE,MAAM,GAAG,IAAW,GACpC,IAAI,CAYN;AAED,8EAA8E;AAC9E,wBAAgB,wBAAwB,CACpC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACzC,IAAI,CAmBN;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC3C,EAAE,EAAE,QAAQ,EACZ,SAAS,SAA4C,GACtD,kCAAkC,CA6DpC;AAED,iFAAiF;AACjF,wBAAsB,6BAA6B,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAO/E;AAED,kFAAkF;AAClF,wBAAgB,+BAA+B,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAU3E;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC1C,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACnB,OAAO,CAuCT;AAED,wBAAgB,qCAAqC,CACjD,EAAE,EAAE,QAAQ,GACb,kCAAkC,CAEpC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAS9F"}

package/dist/features/magic-context/message-fts-session-filter.d.ts

@@ -0,0 +1,14 @@
+import type { Database } from "../../shared/sqlite";
+export declare const MESSAGE_FTS_SESSION_FILTER_SQL = "+message_history_fts.rowid IN (\n    SELECT fts_rowid FROM message_fts_rowid_map WHERE session_id = ?1\n) AND ";
+/**
+ * Use the sidecar only for sessions with every physical FTS row mapped. Legacy
+ * sessions retain the global MATCH query, including duplicate ordinals; no
+ * backfill, deduplication, or durable schema change happens during search.
+ *
+ * Coverage and the synchronous queries share a read transaction so another
+ * connection cannot add an unmapped row between the proof and the filtered read.
+ * Local writes and external commits invalidate the connection-local proof. Never
+ * retain a caller's uncommitted proof: total_changes does not advance on rollback.
+ */
+export declare function withMessageFtsSessionFilter<T>(db: Database, sessionId: string, read: (sessionFirst: boolean) => T): T;
+//# sourceMappingURL=message-fts-session-filter.d.ts.map

package/dist/features/magic-context/message-fts-session-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-fts-session-filter.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/message-fts-session-filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,qBAAqB,CAAC;AAO/D,eAAO,MAAM,8BAA8B,mHAEpC,CAAC;AAsCR;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EACzC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,CAAC,YAAY,EAAE,OAAO,KAAK,CAAC,GACnC,CAAC,CAyCH"}

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

@@ -0,0 +1,33 @@
+import type { RawMessage, RawMessageOrdinalAnchor } from "../../hooks/magic-context/read-session-raw";
+import { type Database } from "../../shared/sqlite";
+type FullReadMessages = ((sessionId: string) => RawMessage[]) & {
+    readPage?: (sessionId: string, afterOrdinal: number, limit: number, finalWatermark: number, after?: RawMessageOrdinalAnchor) => RawMessage[];
+    getCount?: (sessionId: string) => number;
+};
+export interface BoundedMessageReconciliationSource {
+    readPage(sessionId: string, afterOrdinal: number, limit: number, finalWatermark: number, after?: RawMessageOrdinalAnchor): RawMessage[];
+    getCount(sessionId: string): number;
+}
+export type MessageReconciliationSource = FullReadMessages | BoundedMessageReconciliationSource;
+type ReadSingleMessage = (sessionId: string, messageId: string) => RawMessage | null;
+type IncrementalMessageSource = ReadSingleMessage | RawMessage;
+export declare function scheduleReconciliation(db: Database, sessionId: string, readMessages: MessageReconciliationSource): void;
+export declare function scheduleIncrementalIndex(db: Database, sessionId: string, messageId: string, messageSource: IncrementalMessageSource): void;
+export declare function scheduleClearAndReindex(db: Database, sessionId: string, readMessages: MessageReconciliationSource): void;
+export interface MessageIndexQueueHeapStats {
+    queueLength: number;
+    reconciliationScheduled: number;
+    incrementalTimers: number;
+    pendingIncremental: number;
+    activeSessionLocks: number;
+    completedIncrementalKeys: number;
+    activeBufferMessages: number;
+    activeBufferBytes: number;
+}
+/** Live async-index holder counts used by the opt-in heap diagnostic RPC. */
+export declare function getMessageIndexQueueHeapStats(): MessageIndexQueueHeapStats;
+export declare function isSessionReconciled(sessionId: string): boolean;
+export declare function clearSessionTracking(sessionId: string): void;
+export declare function __resetMessageIndexAsyncForTests(): void;
+export {};
+//# sourceMappingURL=message-index-async.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"message-index-async.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/message-index-async.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,UAAU,EACV,uBAAuB,EAC1B,MAAM,4CAA4C,CAAC;AAGpD,OAAO,EAAE,KAAK,QAAQ,EAA8B,MAAM,qBAAqB,CAAC;AA+FhF,KAAK,gBAAgB,GAAG,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,UAAU,EAAE,CAAC,GAAG;IAC5D,QAAQ,CAAC,EAAE,CACP,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,EACtB,KAAK,CAAC,EAAE,uBAAuB,KAC9B,UAAU,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;CAC5C,CAAC;AAEF,MAAM,WAAW,kCAAkC;IAC/C,QAAQ,CACJ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,EACtB,KAAK,CAAC,EAAE,uBAAuB,GAChC,UAAU,EAAE,CAAC;IAChB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;CACvC;AAED,MAAM,MAAM,2BAA2B,GAAG,gBAAgB,GAAG,kCAAkC,CAAC;AAChG,KAAK,iBAAiB,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,UAAU,GAAG,IAAI,CAAC;AACrF,KAAK,wBAAwB,GAAG,iBAAiB,GAAG,UAAU,CAAC;AAwL/D,wBAAgB,sBAAsB,CAClC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,2BAA2B,GAC1C,IAAI,CAyBN;AAED,wBAAgB,wBAAwB,CACpC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,wBAAwB,GACxC,IAAI,CAuDN;AAED,wBAAgB,uBAAuB,CACnC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,2BAA2B,GAC1C,IAAI,CAwCN;AAED,MAAM,WAAW,0BAA0B;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,uBAAuB,EAAE,MAAM,CAAC;IAChC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,wBAAwB,EAAE,MAAM,CAAC;IACjC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;CAC7B;AAED,6EAA6E;AAC7E,wBAAgB,6BAA6B,IAAI,0BAA0B,CAoB1E;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAuB5D;AAED,wBAAgB,gCAAgC,IAAI,IAAI,CAYvD"}

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

@@ -0,0 +1,11 @@
+import type { Database } from "../../shared/sqlite";
+import { type MessageHistoryOrphanSweepOptions, type MessageHistoryOrphanSweepResult } from "./message-index";
+/**
+ * Scope wrapper for the background sweep. It lives beside `message-index` rather
+ * than inside it: importing the transform-pass scope helpers into
+ * `message-index.ts` itself changes the bundled module graph in a way that hits
+ * a Bun 1.4.2 packaging bug (a top-level `__promiseAll` init call is emitted
+ * without its definition, which crashes node hosts at import time).
+ */
+export declare function sweepOrphanedOpenCodeMessageIndexes(db: Database, openReadableOpenCodeDb: () => Database | null, options?: MessageHistoryOrphanSweepOptions): MessageHistoryOrphanSweepResult;
+//# sourceMappingURL=message-index-sweep.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"message-index-sweep.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/message-index-sweep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EACH,KAAK,gCAAgC,EACrC,KAAK,+BAA+B,EAEvC,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AACH,wBAAgB,mCAAmC,CAC/C,EAAE,EAAE,QAAQ,EACZ,sBAAsB,EAAE,MAAM,QAAQ,GAAG,IAAI,EAC7C,OAAO,GAAE,gCAAqC,GAC/C,+BAA+B,CAMjC"}

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

@@ -0,0 +1,88 @@
+import type { RawMessage } from "../../hooks/magic-context/read-session-raw";
+import type { Database } from "../../shared/sqlite";
+export interface MessageHistoryOrphanSweepResult {
+    status: "swept" | "cooldown" | "source_unavailable" | "unavailable";
+    scanned: number;
+    deleted: number;
+    cursor: string;
+}
+export interface MessageHistoryOrphanSweepOptions {
+    batchSize?: number;
+    now?: number;
+    safetyAgeMs?: number;
+    cooldownMs?: number;
+    unavailableReprobeMs?: number;
+}
+export declare const MESSAGE_HISTORY_ORPHAN_SWEEP_BATCH_SIZE = 200;
+export declare const MESSAGE_HISTORY_ORPHAN_SAFETY_AGE_MS: number;
+export declare const MESSAGE_HISTORY_ORPHAN_SWEEP_COOLDOWN_MS: number;
+export declare const MESSAGE_HISTORY_ORPHAN_UNAVAILABLE_REPROBE_MS: number;
+/**
+ * Everything the search index keeps from one message. A caller that has to hold
+ * a whole session's worth of index input keeps these instead of the messages:
+ * the indexable text is a small fraction of a message's parts.
+ */
+export interface MessageIndexSource {
+    id: string;
+    ordinal: number;
+    role: string;
+    createdAt: number | null | undefined;
+    sourceVersion: string;
+    contentHash: string;
+    content: string;
+}
+export declare function toMessageIndexSource(message: RawMessage): MessageIndexSource;
+export declare function getMessageIndexSourceIdentity(message: RawMessage): string;
+export declare function isMessageIndexSourceCurrent(db: Database, sessionId: string, message: RawMessage): boolean;
+export declare function getLastIndexedOrdinal(db: Database, sessionId: string): number;
+/**
+ * The message id the index recorded at one ordinal position, or null when that
+ * position has no source row. `message_history_source` is written for every
+ * covered ordinal (indexable or not), so a contiguous covered range answers at
+ * each of its positions; used by reconciliation's misalignment detection.
+ */
+export declare function getIndexedMessageIdAtOrdinal(db: Database, sessionId: string, ordinal: number): string | null;
+/**
+ * Cheap IDF-lite denominator derived from the session's primary-keyed index
+ * tracker. Message ordinals are contiguous through the watermark, so the small
+ * approximation error from non-indexable rows is preferable to scanning the
+ * global FTS row store for an exact count.
+ */
+export declare function getIndexedMessageCorpusSize(db: Database, sessionId: string, maxOrdinal: number | null): number;
+export declare function getDirtyIndexFloor(db: Database, sessionId: string): number | null;
+/**
+ * Persist the earliest ordinal that an incremental write could leave missing.
+ * Callers set this before the FTS transaction so a crash or write failure leaves
+ * a durable reconciliation floor instead of an uncovered watermark.
+ */
+export declare function markMessageIndexDirty(db: Database, sessionId: string, floorOrdinal: number): void;
+export declare function getMessageIndexReconciliationStartOrdinal(db: Database, sessionId: string): number;
+export declare function isMessageIndexReconciledThrough(db: Database, sessionId: string, finalWatermark: number): boolean;
+export declare function deleteIndexedMessage(db: Database, sessionId: string, messageId: string): number;
+/**
+ * Drop every indexed document, its rowid mapping, the progress watermark and the
+ * derived compression depth for one session. The caller must already hold a
+ * transaction; use `clearIndexedMessages` when it does not.
+ */
+export declare function clearIndexedMessagesInTransaction(db: Database, sessionId: string): void;
+export declare function clearIndexedMessages(db: Database, sessionId: string): void;
+export declare function getIndexableContent(role: string, parts: unknown[]): string;
+export declare function indexSingleMessage(db: Database, sessionId: string, message: RawMessage): boolean;
+export declare function indexMessagesAfterOrdinal(db: Database, sessionId: string, messages: RawMessage[], _lastIndexedOrdinal: number, finalWatermark?: number): number;
+/**
+ * `indexMessagesAfterOrdinal` for input already reduced to index sources. The
+ * slice may be any contiguous part of the session: the watermark advances over
+ * the ordinals it covers and the first one it does not is left as the dirty
+ * floor, so consecutive slices, each in its own transaction, rebuild a session
+ * exactly as one call with every source would.
+ */
+export declare function indexSourcesAfterOrdinal(db: Database, sessionId: string, sources: readonly MessageIndexSource[], finalWatermark: number): number;
+export declare function ensureMessagesIndexed(db: Database, sessionId: string, readMessages: (sessionId: string) => RawMessage[]): void;
+/**
+ * Delete old OpenCode session state that no longer exists in OpenCode's
+ * authoritative session table. One bounded keyset page is processed per call;
+ * the cursor survives restarts and only resets after a complete pass. Pi rows
+ * need a separate sweep against Pi's session files and are excluded here.
+ */
+export declare function sweepOrphanedOpenCodeMessageIndexes(db: Database, openReadableOpenCodeDb: () => Database | null, options?: MessageHistoryOrphanSweepOptions): MessageHistoryOrphanSweepResult;
+//# sourceMappingURL=message-index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"message-index.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/message-index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4CAA4C,CAAC;AAE7E,OAAO,KAAK,EAAE,QAAQ,EAAkC,MAAM,qBAAqB,CAAC;AA8BpF,MAAM,WAAW,+BAA+B;IAC5C,MAAM,EAAE,OAAO,GAAG,UAAU,GAAG,oBAAoB,GAAG,aAAa,CAAC;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gCAAgC;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,eAAO,MAAM,uCAAuC,MAAM,CAAC;AAC3D,eAAO,MAAM,oCAAoC,QAAsB,CAAC;AACxE,eAAO,MAAM,wCAAwC,QAAiB,CAAC;AACvE,eAAO,MAAM,6CAA6C,QAAsB,CAAC;AAyQjF;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,UAAU,GAAG,kBAAkB,CAW5E;AAMD,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CASzE;AAED,wBAAgB,2BAA2B,CACvC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,UAAU,GACpB,OAAO,CAYT;AA8BD,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAG7E;AAeD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CACxC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CAMf;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACvC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAAG,IAAI,GAC1B,MAAM,CAGR;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKjF;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CASjG;AAuBD,wBAAgB,yCAAyC,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAIjG;AAED,wBAAgB,+BAA+B,CAC3C,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,GACvB,OAAO,CAGT;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAU/F;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAOvF;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAO1E;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAsB1E;AAyFD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CA4ChG;AAED,wBAAgB,yBAAyB,CACrC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,UAAU,EAAE,EACtB,mBAAmB,EAAE,MAAM,EAC3B,cAAc,GAAE,MAAwB,GACzC,MAAM,CAER;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACpC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,SAAS,kBAAkB,EAAE,EACtC,cAAc,EAAE,MAAM,GACvB,MAAM,CAER;AAqHD,wBAAgB,qBAAqB,CACjC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,UAAU,EAAE,GAClD,IAAI,CAmBN;AAwDD;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAC/C,EAAE,EAAE,QAAQ,EACZ,sBAAsB,EAAE,MAAM,QAAQ,GAAG,IAAI,EAC7C,OAAO,GAAE,gCAAqC,GAC/C,+BAA+B,CA+HjC"}

package/dist/features/magic-context/message-time-backfill.d.ts

@@ -0,0 +1,19 @@
+import type { RawMessage } from "../../hooks/magic-context/read-session-raw";
+import type { Database } from "../../shared/sqlite";
+export declare const MESSAGE_TIME_BACKFILL_BATCH_SIZE = 500;
+export interface MessageTimeBackfillProgress {
+    processed: number;
+    cursorSessionId: string;
+    cursorOrdinal: number;
+    completed: boolean;
+}
+export type MessageTimeBackfillReader = ((sessionId: string) => RawMessage[]) & {
+    readPage?: (sessionId: string, afterOrdinal: number, limit: number, finalWatermark: number) => RawMessage[];
+};
+/** Fill one durable cursor window. Host reads happen before the atomic update/cursor commit. */
+export declare function backfillMessageTimesBatch(db: Database, reader: MessageTimeBackfillReader, batchSize?: number): MessageTimeBackfillProgress;
+/** Drain durable legacy rows in bounded turns, yielding between SQLite write windows. */
+export declare function runMessageTimeBackfill(db: Database, reader: MessageTimeBackfillReader): Promise<void>;
+export declare function startMessageTimeBackfill(db: Database, reader: MessageTimeBackfillReader): Promise<void>;
+export declare function getMessageTimeBackfillProgress(db: Database): MessageTimeBackfillProgress;
+//# sourceMappingURL=message-time-backfill.d.ts.map

package/dist/features/magic-context/message-time-backfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-time-backfill.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/message-time-backfill.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4CAA4C,CAAC;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,eAAO,MAAM,gCAAgC,MAAM,CAAC;AAgBpD,MAAM,WAAW,2BAA2B;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,UAAU,EAAE,CAAC,GAAG;IAC5E,QAAQ,CAAC,EAAE,CACP,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,KACrB,UAAU,EAAE,CAAC;CACrB,CAAC;AAgEF,gGAAgG;AAChG,wBAAgB,yBAAyB,CACrC,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,yBAAyB,EACjC,SAAS,SAAmC,GAC7C,2BAA2B,CA2D7B;AAED,yFAAyF;AACzF,wBAAsB,sBAAsB,CACxC,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,yBAAyB,GAClC,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAgB,wBAAwB,CACpC,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,yBAAyB,GAClC,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,QAAQ,GAAG,2BAA2B,CAExF"}

package/dist/features/magic-context/migration-v2-write-split.d.ts

@@ -0,0 +1,62 @@
+import type { Database } from "../../shared/sqlite";
+/**
+ * Migration v2 (upstream v94, renumbered): stop rewriting two multi-megabyte records on every pass.
+ *
+ * SQLite rewrites a whole record whenever its length changes. The LKG slot's
+ * `json_prefix` and the replay document in `session_meta.trailing_blank_decisions`
+ * both grow a little on every new message, so each pass rewrote megabytes of
+ * `context.db` (the LKG row and the whole `session_meta` record that carries the
+ * document). This migration moves the growing parts into rows that change
+ * independently:
+ *
+ * - the LKG prefix into fixed-position slices in `lkg_slot_chunks`, with the
+ *   slice count, length and hash kept on the (now small) `lkg_slots` row;
+ * - each trailing-blank decision into its own `session_replay_decisions` row,
+ *   leaving only the envelope (version and other namespaces) in the column.
+ */
+/**
+ * Slices of each LKG prefix, in order; see lkg-prefix-chunks.ts. `hash` is the
+ * slice's SHA-256, which a save compares to decide whether the slice changed.
+ * It precedes `body` so reading it never walks the body's overflow pages.
+ */
+export declare const LKG_SLOT_CHUNKS_DDL = "\n    CREATE TABLE IF NOT EXISTS lkg_slot_chunks (\n        session_id TEXT NOT NULL,\n        chunk INTEGER NOT NULL,\n        hash TEXT NOT NULL,\n        body TEXT NOT NULL,\n        PRIMARY KEY (session_id, chunk)\n    );\n";
+/** One trailing-blank replay decision per assistant message. */
+export declare const SESSION_REPLAY_DECISIONS_DDL = "\n    CREATE TABLE IF NOT EXISTS session_replay_decisions (\n        session_id TEXT NOT NULL,\n        message_id TEXT NOT NULL,\n        decision TEXT NOT NULL,\n        PRIMARY KEY (session_id, message_id)\n    ) WITHOUT ROWID;\n";
+/** The `lkg_slots` layout from migration v2 on, without the prefix itself. */
+export declare const LKG_SLOTS_DDL: string;
+/**
+ * Rebuild `lkg_slots` without `json_prefix`, moving each prefix into slices.
+ *
+ * The LKG is a recovery cache: the next applied pass of a session recaptures
+ * its slot. It matters most right after this migration, because the restart
+ * that applies it also restarts the Rust module, and while the module reopens
+ * its own store the LKG slot is what a session replays. So slots captured in the
+ * last day, the sessions that can send a pass in that window, are moved, and
+ * older ones are dropped. Moving every slot would rewrite the whole cache (about
+ * 700 MB on a large store, 34 to 73 seconds under load) while holding the write
+ * lock every other process needs to start.
+ *
+ * The prefix is sliced in JavaScript, not with SQL substr, because the slice
+ * boundaries and the hash a load verifies must be computed exactly as
+ * saveLkgSlotToDb computes them.
+ */
+export declare function splitLkgSlotPrefixes(db: Database, now?: number): void;
+/**
+ * Move every trailing-blank decision out of the replay document into
+ * `session_replay_decisions`.
+ *
+ * The version test replicates `parseReplayDocument`: a document is the v2
+ * envelope when it has a `version` key whose value is not itself a valid
+ * decision. A v1 document is the flat map, which may contain an assistant whose
+ * id is literally "version". Only documents that parse strictly are moved. A
+ * document that does not (malformed JSON, an invalid decision, an unknown
+ * envelope version) stays in the column untouched, so that session keeps exactly
+ * today's behaviour: lenient readers still see its valid entries and strict
+ * writers still refuse it.
+ *
+ * Afterwards a v2 column holds the envelope with an empty `trailingBlank`, and
+ * its other namespaces (`piNative`, `cacheTtlPolicy`) are unchanged. A v1
+ * column, which has no other namespaces, is emptied.
+ */
+export declare function splitReplayDecisions(db: Database): void;
+//# sourceMappingURL=migration-v2-write-split.d.ts.map

package/dist/features/magic-context/migration-v2-write-split.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-v2-write-split.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/migration-v2-write-split.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,wOAQ/B,CAAC;AAEF,gEAAgE;AAChE,eAAO,MAAM,4BAA4B,6OAOxC,CAAC;AAsBF,8EAA8E;AAC9E,eAAO,MAAM,aAAa,QAA2B,CAAC;AAgBtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,SAAa,GAAG,IAAI,CAiDzE;AAkBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CA6DvD"}

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

@@ -0,0 +1,73 @@
+import type { Database } from "../../shared/sqlite";
+/** First version reserved for downstream migrations; upstream versions stay below it. */
+export declare const FORK_MIGRATION_VERSION_FLOOR = 10000;
+/**
+ * Versioned migration framework for magic-context's SQLite database.
+ *
+ * Each migration is a function that runs inside a transaction.
+ * Migrations are applied sequentially on startup — skipping any
+ * that have already run. This handles multi-version jumps cleanly
+ * (e.g. upgrading from 0.4 to 0.7 runs all intermediate migrations).
+ *
+ * To add a new migration:
+ * 1. Append a new entry to the MIGRATIONS array
+ * 2. The version number is the array index + 1
+ * 3. The migration runs in a transaction — if it throws, it rolls back
+ */
+interface Migration {
+    version: number;
+    description: string;
+    up: (db: Database) => void;
+}
+export declare class MigrationLockBusyError extends Error {
+    constructor(message: string);
+}
+export declare const MIGRATIONS: Migration[];
+/**
+ * Highest version in the MIGRATIONS array. `LATEST_SUPPORTED_VERSION` in
+ * storage-db.ts (the schema-fence ceiling) MUST equal this — a stale ceiling
+ * makes the DB refuse to open after the new migration applies (a real bug the
+ * project hit during v2 work). A unit test asserts the two stay in lockstep.
+ */
+export declare const LATEST_MIGRATION_VERSION: number;
+/**
+ * Detect the specific case where a sibling process already committed the
+ * same `schema_migrations` row we're about to insert. BEGIN IMMEDIATE now
+ * prevents this race for supported adapters by serializing before the version
+ * read. Keep this narrow guard as a secondary backstop for legacy or unusual
+ * transaction adapters that do not honor the requested begin mode.
+ *
+ * Important: only PRIMARY KEY conflicts on `schema_migrations` are
+ * swallowed. Any other failure (CREATE TABLE, ALTER TABLE, data heal,
+ * etc.) surfaces normally and fail-closes per contract.
+ */
+export declare function isSiblingMigrationConflict(db: Database, error: unknown, version: number): boolean;
+/**
+ * Run all pending migrations sequentially.
+ * Each migration runs in its own transaction — if it fails, only that migration rolls back.
+ * Already-applied migrations are skipped.
+ *
+ * Migration application re-reads the upstream-lane version under BEGIN IMMEDIATE
+ * before choosing one migration. Concurrent starters therefore serialize before
+ * taking a read snapshot: one applies the migration and the waiter observes the
+ * advanced version instead of failing a deferred read-to-write lock upgrade.
+ */
+export declare function runMigrations(db: Database): void;
+/**
+ * SQL fragment identifying rows whose project (or session's project) is under
+ * external authority management. Shared by the notes heal path to avoid
+ * touching rows the authority triggers would abort.
+ */
+export declare function managedAuthorityNoteRow(row: "OLD" | "NEW" | "notes"): string;
+/**
+ * Run migrations without blocking the event loop while a sibling owns SQLite's
+ * write lock. Only failures from the lock/check phase are retried; migration
+ * body failures continue to fail closed immediately.
+ */
+export interface MigrationRetryOptions {
+    retryDelaysMs?: readonly number[];
+    sleep?: (delayMs: number) => Promise<void>;
+}
+export declare function runMigrationsWithRetry(db: Database, options?: MigrationRetryOptions): Promise<void>;
+export {};
+//# sourceMappingURL=migrations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/migrations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,yFAAyF;AACzF,eAAO,MAAM,4BAA4B,QAAS,CAAC;AAEnD;;;;;;;;;;;;GAYG;AAEH,UAAU,SAAS;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAC;CAC9B;AAID,qBAAa,sBAAuB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI9B;AAYD,eAAO,MAAM,UAAU,EAAE,SAAS,EA0BjC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAGtC,CAAC;AAyBF;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAqBjG;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CA+GhD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,CAe5E;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IAClC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C;AAED,wBAAsB,sBAAsB,CACxC,EAAE,EAAE,QAAQ,EACZ,OAAO,GAAE,qBAA0B,GACpC,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/dist/features/magic-context/mock-database.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from "../../shared/sqlite";
+export declare function toDatabase<T>(db: T): Database;
+//# sourceMappingURL=mock-database.d.ts.map

package/dist/features/magic-context/mock-database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-database.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/mock-database.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,QAAQ,CAE7C"}