@cleocode/core 2026.9.23 → 2026.9.25

package/dist/store/twin-collapse.d.ts

@@ -45,13 +45,17 @@
  * | every other key (`schemaVersion`, `version`, `focus_state`, `focus_state:<session>`, `project_meta`, `project`, `parallel_state`, `activeSession`, `reconcile.<task>.release`, any unknown key) | none: the bare value |
  *
  * - **Initial collapse**, when the bare table holds at least one carried key:
- *   every bare key is carried under the rules, and a key only the twin holds
- *   is a frozen copy and is DROPPED (listed in the receipt, marker and log).
- *   The exceptions are `task_id_sequence` and `sqlite_snapshot_gate` (a
- *   counter must not move back) and the collapse keys. `file_meta` is dropped
- *   only when the bare table lacks it; when both have it the field rule
- *   applies. When the bare table holds no carried key (a fresh lineage, e.g.
- *   after exodus landed legacy rows in the twin), nothing is dropped.
+ *   every bare key is carried under the rules (the bare value wins every key
+ *   both hold). A key only the twin holds is KEPT, never dropped (the union
+ *   rule, T12535 audit 2026-09-29): it is listed as `kept` in the receipt and
+ *   marker. When a key's twin value would be replaced by a different result,
+ *   the twin value is copied to `twin_collapse_archive:<key>` in
+ *   `tasks_schema_meta` (listed as `archived`; doctor shows it), so nothing
+ *   unique is left only in the snapshot. `focus_state` merges instead: the
+ *   bare value's current fields win and `sessionNotes` is the union of both,
+ *   deduplicated by `(timestamp, note)` ({@link mergeFocusState}); its twin
+ *   value is archived as well. The pre-collapse snapshot holds the store
+ *   before any change and is pinned (never rotated).
  * - **Incremental re-merge**, per bare key whose hash changed since the last
  *   merge:
  *   - twin unchanged since the last merge → the bare value (counter fields
@@ -68,9 +72,13 @@
  * `sticky_tags` → `brain_sticky_tags` (rows are `(sticky_id, tag)`, both the
  * key, so a collision is two identical rows and one is kept):
  *
- * - Initial collapse, when the bare table has rows: the twin is made equal to
- *   the bare set; frozen twin-only rows are dropped and listed. A bare tag whose
- *   note no longer exists is not carried (`skipped`; it stays in the bare table).
+ * - Initial collapse: bare tags are added. A twin-only tag the note's
+ *   `tags_json` names is kept (listed as `kept`). One it does not name leaves
+ *   the junction (which follows `tags_json`, the value every reader displays)
+ *   and is recorded under `twin_collapse_archive:sticky_tags` in
+ *   `brain_schema_meta` (listed as `archived`); adding it to `tags_json` would
+ *   change the tags the user sees. A bare tag whose note no longer exists is
+ *   not carried (`skipped`; it stays in the bare table).
  * - Incremental re-merge, per sticky id whose bare tag-set hash changed: if
  *   the twin's set for that id is unchanged since the last merge, the twin
  *   set is made equal to the bare set (additions AND removals propagate);
@@ -82,12 +90,58 @@
  *   tag filter can never disagree with the displayed tags. A conflict is still
  *   recorded for `cleo doctor`.
  *
+ * `attachments` + `attachment_refs` → `docs_attachments` + `docs_attachment_refs`
+ * merge as ONE pair, in one transaction (a doc and its refs never diverge).
+ * The bare rows are authoritative over the columns both tables share, except
+ * `ref_count`, which is derived: after every merge it is recomputed as the
+ * number of refs in `docs_attachment_refs`, whoever wrote them (never carried,
+ * never max'd). Rows are keyed `d:<id>` and `r:<attachment_id, owner_type,
+ * owner_id>` in the marker hashes.
+ *
+ * - Initial collapse: the twins are made equal to the bare tables, even when
+ *   the bare tables are empty (the older build never showed a twin-only row);
+ *   frozen twin-only rows are dropped and listed.
+ * - Incremental re-merge, per bare doc whose hash moved (see {@link planDocs}):
+ *   twin changed too → conflict, the twin wins; bare row gone → the twin row
+ *   goes unless a ref or a supersedes link still names it (`kept`); the
+ *   content (sha256) already belongs to another twin row → merged into that
+ *   row: the bare id is aliased to it (`twin_collapse_alias:attachments`) and
+ *   its refs follow; the slug already belongs to another twin row → carried
+ *   under `<slug>-<n>` (`renamed`). Natural keys are checked against the state
+ *   after the merge, so a merge never fails on them. Per bare ref whose hash
+ *   moved: added → added (aliased), removed → removed unless this build
+ *   changed it since.
+ * - Change detection: AFTER triggers on the bare tables (`t12535_track_*`)
+ *   bump `twin_collapse_seq:attachments` on every write, the older build's
+ *   included. An open compares that counter with the marker's instead of
+ *   re-hashing every doc; a missing trigger falls back to the full compare.
+ * - Union shape: migration `20260929000000_t12535-docs-attachments-union-shape`
+ *   adds the bare-only `display_alias` column and indexes; the UNIQUE slug and
+ *   sha256 indexes are dropped and re-created by the merge itself around the
+ *   row changes. Every merge ends with them in place, or rolls back.
+ * - The `supersedes` / `superseded_by` self-FKs are checked at commit
+ *   (`PRAGMA defer_foreign_keys`), so a chain merges in any row order.
+ * - A bare row that violates a twin CHECK (e.g. a non-ISO `created_at`) fails
+ *   the merge; the docs pair opens degraded (docs writes refused, everything
+ *   else writable) and `cleo doctor twin-collapse` shows the cause.
+ * - Blobs: after each merge every twin doc's blob gets a keep-link (and is
+ *   restored from it if the older build unlinked it), see `blob-keep.ts`.
+ * - Freeze (option (a), D11160): every merge installs BEFORE
+ *   INSERT/UPDATE/DELETE triggers on the bare docs tables that abort an
+ *   older build's write with the upgrade message ({@link docsFrozenMessage}).
+ *   This build never writes them, so there is no bypass. Every open checks the freeze and change
+ *   triggers and re-installs missing ones (a rebuild or restore drops them);
+ *   `cleo doctor` reports them missing. The (b) defences above cover the time
+ *   a freeze is missing.
+ *
  * ## Contract
  *
  * 1. **Snapshot first** (initial collapse only, only when the merge changes
  *    the twin). The free space is checked before the `VACUUM INTO`. One
  *    snapshot covers every pair collapsing in this open, registered as a
- *    `migration` backup (`cleo backup list`, rotation).
+ *    PINNED `migration` backup: `cleo backup list` shows it, rotation never
+ *    deletes it, and a snapshot an earlier build wrote unpinned is pinned at
+ *    the next open (`cleo doctor` lists an unpinned one).
  * 2. **Atomic.** Each pair merges, verifies and writes its marker in one
  *    `BEGIN IMMEDIATE` transaction, the marker re-read under the write lock.
  *    Any failure rolls back: both tables byte-identical.
@@ -125,6 +179,8 @@
  * @task T12535
  */
 import type { DatabaseSync } from 'node:sqlite';
+import type { NodeSQLiteDatabase } from 'drizzle-orm/node-sqlite';
+import { z } from 'zod';
 import { CleoError } from '../errors.js';
 /** Prefix of the marker key holding a pair's collapse state. */
 export declare const TWIN_COLLAPSE_MARKER_PREFIX = "twin_collapse:";
@@ -158,10 +214,22 @@ export interface TwinCollapseReceipt {
     readonly deleted: number;
     /** Bare rows not carried by rule (dead keys, tags of deleted notes). */
     readonly skipped: number;
-    /** Frozen twin rows the initial collapse dropped (keys, or `sticky_id\ttag`). */
+    /** Twin rows the initial collapse dropped (none since the union rule; kept for old markers). */
     readonly dropped: readonly string[];
     /** Keys (or sticky ids) both builds changed since the last merge; the twin was kept. */
     readonly conflicts: readonly string[];
+    /** Docs: bare rows merged into the twin row holding the same content (`<bare id> -> <twin id>`). */
+    readonly merged: readonly string[];
+    /** Docs: rows carried under a free slug because another doc holds theirs. */
+    readonly renamed: readonly string[];
+    /**
+     * Rows kept by the union rule: twin-only keys / sticky tags the initial
+     * collapse carried over, and (docs) twin rows the bare side deleted that a
+     * ref or link still names.
+     */
+    readonly kept: readonly string[];
+    /** Keys whose replaced twin value was copied to `twin_collapse_archive:<key>`. */
+    readonly archived: readonly string[];
 }
 /**
  * The value a `schema_meta` key gets when the bare side is authoritative (the
@@ -206,6 +274,73 @@ export declare function mirrorCounterToBare(db: DatabaseSync, key: string): void
  * @task T12535
  */
 export declare function bareCounterOf(db: DatabaseSync, key: string): number;
+/** Prefix of the key holding a twin value the initial collapse replaced. */
+export declare const TWIN_COLLAPSE_ARCHIVE_PREFIX = "twin_collapse_archive:";
+/**
+ * `focus_state` when both tables hold it: the bare value's current fields
+ * win, and the session-note history is the union of both
+ * (`sessionNotes`, deduplicated by `(timestamp, note)`, sorted by timestamp).
+ * The twin may hold months of notes the bare copy never saw (178 KB on the
+ * cleocode Linux store). A value that is not a JSON object stays the bare one
+ * (the replaced twin value is archived either way).
+ *
+ * @param bare - The bare value.
+ * @param twin - The twin value.
+ * @returns The merged value.
+ * @task T12535
+ */
+export declare function mergeFocusState(bare: string, twin: string): string;
+/** Key of the bare→twin id aliases (bare rows merged into a twin row by sha256). */
+export declare const DOCS_ALIAS_KEY = "twin_collapse_alias:attachments";
+/** Key the bare-side change triggers bump on every write to the bare docs tables. */
+export declare const DOCS_CHANGE_SEQ_KEY = "twin_collapse_seq:attachments";
+/**
+ * The message an older build's write to a frozen bare docs table aborts with.
+ * It names the release that moved the docs, what fails (docs, changesets, and
+ * the IVTR playbook provenance an older build attaches when a playbook run
+ * finalises), and the upgrade command.
+ *
+ * It must never read as contention or corruption to an older build: those
+ * retry on `sqlite_busy` / `database is locked` and restore backups on
+ * `database disk image is malformed`, so none of those words appear (pinned by
+ * a test, see {@link DOCS_FROZEN_FORBIDDEN}).
+ */
+export declare function docsFrozenMessage(version: string | null): string;
+/** Key recording the version of the build that first froze this store's bare docs tables. */
+export declare const DOCS_FROZEN_BY_KEY = "twin_collapse_frozen_by:attachments";
+/**
+ * The version the freeze message names: the first RELEASE build that froze
+ * (or later opened) this store, recorded under {@link DOCS_FROZEN_BY_KEY}.
+ *
+ * Why recorded, not a literal: the release that ships the freeze was not
+ * known when the code was written (2026.9.23 shipped without it). Why not the
+ * running build's version: a trigger outlives the build that wrote it, and a
+ * development build (a worktree, or the main checkout) reports the PREVIOUS
+ * release's version, which cannot read the store. So only a published build
+ * (running from an installed package, i.e. under `node_modules`) records its
+ * version, and never the unreadable `0.0.0` fallback. Until one does, the
+ * message names no version and points at `@latest`; the first release build
+ * to open the store records itself and the triggers are re-written.
+ *
+ * @param db - The project `cleo.db` connection.
+ * @returns The version to name, or `null` (no release build has frozen or
+ *   opened this store yet).
+ * @task T12535
+ */
+export declare function docsFrozenVersion(db: DatabaseSync): string | null;
+/**
+ * Test only: make this process count as a published build with `version`
+ * (or restore the real detection with `undefined`).
+ *
+ * @param override - The build to pretend to be.
+ * @task T12535
+ */
+export declare function setFreezeBuildForTests(override: {
+    published: boolean;
+    version: string;
+} | undefined): void;
+/** Phrases the freeze message must never contain (older builds' retry and recovery matchers). */
+export declare const DOCS_FROZEN_FORBIDDEN: readonly string[];
 /** Why a collapse failed, as carried by `E_TWIN_COLLAPSE_FAILED`. */
 export interface TwinCollapseFailure {
     /** The bare tables whose collapse did not complete. */
@@ -233,18 +368,24 @@ export interface TwinCollapseFailure {
  */
 export declare function twinCollapseFailureOf(db: DatabaseSync): TwinCollapseFailure | undefined;
 /**
- * Refuse a write before its first statement when the store is degraded by a
- * failed twin collapse. The write accessors of the collapsed tables
- * (`tasks_schema_meta`, and sticky notes and tags) call it at entry, so a
- * degraded store never takes a partial write (e.g. a sticky's `tags_json`
- * without its tag rows). The shadows' TEMP triggers stay as the backstop.
- *
- * @param handle - The connection the write would use (a `DatabaseSync`, or a
- *   drizzle instance's `$client`); anything else is not checked.
- * @throws {CleoError} `E_TWIN_COLLAPSE_FAILED` when the connection is degraded.
+ * Refuse a write before its first statement when the collapse of the table it
+ * writes failed. The write accessors of the collapsed tables
+ * (`tasks_schema_meta`, sticky notes and tags, the docs tables) call it at
+ * entry, so a degraded store never takes a partial write (e.g. a sticky's
+ * `tags_json` without its tag rows). Only the failed pairs are blocked: a
+ * docs merge failure leaves task and sticky writes alone. The shadows' TEMP
+ * triggers stay as the backstop.
+ *
+ * @param handle - The connection the write would use: the native
+ *   `DatabaseSync`, or a drizzle instance (its `$client` is checked).
+ *   `null`/`undefined` (no bound handle) is not checked.
+ * @param table - The bare table whose pair the write belongs to.
+ * @throws {CleoError} `E_TWIN_COLLAPSE_FAILED` when that pair's collapse failed.
  * @task T12535
  */
-export declare function assertTwinCollapseWritable(handle: unknown): void;
+export declare function assertTwinCollapseWritable(handle: DatabaseSync | NodeSQLiteDatabase | null | undefined, table: TwinCollapseTable): void;
+/** The bare tables a failed collapse can block writes for. */
+export type TwinCollapseTable = 'schema_meta' | 'sticky_tags' | 'attachments';
 /**
  * Build the `E_TWIN_COLLAPSE_FAILED` error for a failure.
  *
@@ -306,6 +447,30 @@ export interface TwinCollapseStatus {
     readonly conflicts: readonly string[];
     /** When those conflicts were recorded. */
     readonly conflictsAt: string | null;
+    /** Docs: bare rows the last merge folded into the twin row with the same content. */
+    readonly merged: readonly string[];
+    /** Docs: rows the last merge carried under a free slug. */
+    readonly renamed: readonly string[];
+    /** Twin-only rows the initial collapse carried over (union rule). */
+    readonly kept: readonly string[];
+    /** Keys whose replaced twin value is archived under `twin_collapse_archive:<key>`. */
+    readonly archived: readonly string[];
+    /**
+     * Whether the pair's triggers on the bare tables (the freeze against older
+     * builds, the change counter) are all in place; `null` when the pair has
+     * none or is not collapsed yet. Missing ones are re-installed at the next open.
+     */
+    readonly guardsIntact: boolean | null;
+    /**
+     * Whether the collapse snapshot is pinned (never rotated); `null` when there
+     * is no snapshot on disk.
+     */
+    readonly snapshotPinned: boolean | null;
+    /**
+     * `true` when the marker names a pre-collapse snapshot that is no longer on
+     * disk: the only copy of the store before the collapse is gone.
+     */
+    readonly snapshotMissing: boolean;
     /** The recorded failure, when the last attempt failed. */
     readonly failure: TwinCollapseFailure | null;
 }
@@ -317,4 +482,267 @@ export interface TwinCollapseStatus {
  * @task T12535
  */
 export declare function inspectTwinCollapse(db: DatabaseSync): TwinCollapseStatus[];
+/** Prefix of a recovery receipt key: `twin_collapse_recovery:<recoveredAt>`. */
+export declare const TWIN_COLLAPSE_RECOVERY_PREFIX = "twin_collapse_recovery:";
+/** Error code of a recovery or rollback that cannot proceed; nothing was written. */
+export declare const E_TWIN_COLLAPSE_RECOVER = "E_TWIN_COLLAPSE_RECOVER";
+/** One twin value the recovery archives. */
+export interface TwinCollapseRecoveryArchive {
+    /** The `schema_meta` key. */
+    readonly key: string;
+    /** Where the value is written (`twin_collapse_archive:<key>`, or a suffixed key). */
+    readonly archiveKey: string;
+    /** `dropped`: only the twin held the key; `replaced`: the bare value won it. */
+    readonly reason: 'dropped' | 'replaced';
+    /** Length of the archived value, in characters. */
+    readonly length: number;
+}
+/** What {@link planTwinCollapseRecovery} found, and what an apply would write. */
+export interface TwinCollapseRecoveryPlan {
+    /** The pre-collapse snapshot the `schema_meta` marker records; `null`: never collapsed. */
+    readonly snapshot: string | null;
+    /** Whether that snapshot is on disk. */
+    readonly snapshotExists: boolean;
+    /**
+     * Whether that snapshot is pinned (its sidecar says `pinned: true`), so
+     * rotation never deletes it. An apply refuses an unpinned snapshot unless
+     * the caller pins it first (`--pin-snapshot`).
+     */
+    readonly snapshotPinned: boolean;
+    /** Twin `schema_meta` values to archive. */
+    readonly archive: readonly TwinCollapseRecoveryArchive[];
+    /** Session notes the live `focus_state` gains from the twin history. */
+    readonly focusNotesAdded: number;
+    /** Twin-only sticky tags (`sticky_id\ttag`) to archive. */
+    readonly stickyArchived: readonly string[];
+    /** Where those tags go: `twin_collapse_archive:sticky_tags`, or a suffixed key. */
+    readonly stickyArchiveKey: string;
+    /** Receipt keys of earlier applies that were not rolled back. */
+    readonly receipts: readonly string[];
+    /** Whether an apply would write anything. */
+    readonly changes: boolean;
+    /**
+     * The path the markers record, when the store moved (`/mnt` → `/home`,
+     * Linux → Mac) and the snapshot was found by file name in the store's own
+     * backup directory instead (T12788); `null` otherwise. An apply re-points
+     * the markers at {@link snapshot}.
+     */
+    readonly movedFrom: string | null;
+}
+/** Options of {@link planTwinCollapseRecovery}. */
+export interface TwinCollapseRecoveryPlanOptions {
+    /** The snapshot file to use in place of the markers' path (a moved store, T12788). */
+    readonly snapshotPath?: string;
+}
+declare const RecoveryReceiptShape: z.ZodObject<{
+    task: z.ZodLiteral<"T12727">;
+    id: z.ZodString;
+    recoveredAt: z.ZodString;
+    snapshot: z.ZodNullable<z.ZodString>;
+    archived: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        archiveKey: z.ZodString;
+        sha: z.ZodString;
+    }, z.core.$strip>>;
+    focusNotesAdded: z.ZodNumber;
+    stickyArchived: z.ZodArray<z.ZodString>;
+    stickyArchiveKey: z.ZodString;
+    before: z.ZodObject<{
+        focusState: z.ZodNullable<z.ZodString>;
+        stickyArchive: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    after: z.ZodObject<{
+        focusState: z.ZodNullable<z.ZodString>;
+        stickyArchive: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    rolledBackAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Receipt an apply records under `twin_collapse_recovery:<recoveredAt>`
+ * (never over an earlier one). `before` holds the values the apply replaced,
+ * `after` the sha256 of what it wrote, so `--rollback` can undo it.
+ */
+export type TwinCollapseRecoveryReceipt = z.infer<typeof RecoveryReceiptShape>;
+/**
+ * Plan the recovery of the twin values a 2026.9.21 collapse dropped or
+ * replaced, from the pre-collapse snapshot its marker records (T12727).
+ *
+ * The 9.21 initial collapse was bare-authoritative: it deleted keys and
+ * sticky tags only the twin held and overwrote twin values with the bare
+ * ones, keeping them only in that snapshot. This compares the snapshot's
+ * twin and bare tables (read-only; a pair whose table the snapshot lacks is
+ * skipped) and plans, for every twin value that is not live and not archived:
+ * - `schema_meta`: the twin value is written to `twin_collapse_archive:<key>`
+ *   (a suffixed key when that name already holds another value, so nothing is
+ *   overwritten); for `focus_state` the twin's session notes are also merged
+ *   into the live value ({@link mergeFocusState}: live current fields win,
+ *   notes deduplicated by `(timestamp, note)` and sorted);
+ * - `sticky_tags`: twin-only tags are added to
+ *   `twin_collapse_archive:sticky_tags` in `brain_schema_meta` (a suffixed key
+ *   when that row is not a list of tags).
+ * The notes are merged once: not again after an apply that was not rolled
+ * back, nor when the twin value is already archived, so notes pruned after a
+ * recovery stay pruned. A second apply plans nothing.
+ *
+ * @param live - The project `cleo.db` connection (read-only is enough).
+ * @param snapshot - The snapshot, opened read-only, or `null` when missing.
+ * @returns The plan.
+ * @task T12727
+ */
+export declare function planTwinCollapseRecovery(live: DatabaseSync, snapshot: DatabaseSync | null, options?: TwinCollapseRecoveryPlanOptions): TwinCollapseRecoveryPlan;
+/**
+ * Apply a recovery in one `BEGIN IMMEDIATE` transaction on the live store.
+ *
+ * The plan is recomputed INSIDE the transaction from the live values read
+ * under the write lock, so a note written after `plan` was built is merged,
+ * never lost; `plan` is the preview the caller showed. Writes the archive
+ * keys, the merged `focus_state`, the sticky archive, and a new receipt.
+ * Nothing is written when there is nothing to recover. Never touches the
+ * snapshot.
+ *
+ * @param live - The project `cleo.db` connection, outside a transaction.
+ * @param plan - From {@link planTwinCollapseRecovery} on the same connection.
+ * @returns The plan applied and its receipt (`null` when nothing was written).
+ * @throws {CleoError} {@link E_TWIN_COLLAPSE_RECOVER} when the recorded
+ *   snapshot is missing (nothing is written).
+ * @task T12727
+ */
+export declare function applyTwinCollapseRecovery(live: DatabaseSync, plan: TwinCollapseRecoveryPlan, onRepoint?: (repoint: TwinCollapseSnapshotRepoint) => void): {
+    readonly plan: TwinCollapseRecoveryPlan;
+    readonly receipt: TwinCollapseRecoveryReceipt | null;
+    readonly repointed: TwinCollapseSnapshotRepoint | null;
+};
+/** Markers re-pointed from a moved store's old snapshot path (T12788). */
+export interface TwinCollapseSnapshotRepoint {
+    /** The path the markers recorded. */
+    readonly from: string;
+    /** The file in the store's own backup directory they name now. */
+    readonly to: string;
+    /** The marker keys rewritten (`<kvTable>:twin_collapse:<table>`). */
+    readonly markers: readonly string[];
+}
+/** The error for a recorded snapshot that is not on disk. */
+export declare function missingSnapshot(path: string | null): CleoError;
+/** The error for a recorded snapshot rotation could still delete. */
+export declare function unpinnedSnapshot(path: string | null): CleoError;
+/**
+ * Pin the recorded pre-collapse snapshot before a recovery
+ * (`--pin-snapshot`): writes its `.meta.json` sidecar only, never the snapshot.
+ *
+ * @param path - The snapshot the marker records.
+ * @returns Whether it is pinned now.
+ * @task T12727
+ */
+export declare function pinRecoverySnapshot(path: string): boolean;
+/** What {@link rollbackTwinCollapseRecovery} undid. */
+export interface TwinCollapseRecoveryRollback {
+    /** The receipt key. */
+    readonly id: string;
+    /** Archive keys deleted (they still held what the recovery wrote). */
+    readonly archiveDeleted: readonly string[];
+    /** Archive keys left alone (changed since; not the recovery's value any more). */
+    readonly archiveKept: readonly string[];
+    /**
+     * `restored`: `focus_state` was unchanged since, so the pre-merge value is
+     * back; `notes-removed`: it changed since, so only the notes the recovery
+     * added were removed; `none`: the recovery did not touch it.
+     */
+    readonly focusState: 'restored' | 'notes-removed' | 'none';
+    /** Session notes removed from `focus_state`. */
+    readonly notesRemoved: number;
+    /** Sticky rows removed from the sticky archive. */
+    readonly stickyRemoved: number;
+}
+/**
+ * Undo one recovery apply (`cleo doctor twin-collapse --rollback <id>`), in
+ * one `BEGIN IMMEDIATE` transaction:
+ * - archive keys it wrote are deleted when they still hold that value;
+ * - `focus_state` is restored to its pre-merge value when unchanged since,
+ *   else only the notes the recovery added are removed (notes written since
+ *   stay);
+ * - the sticky archive is restored when unchanged since, else only the rows
+ *   the recovery added are removed;
+ * - the receipt is kept, stamped `rolledBackAt`.
+ *
+ * @param live - The project `cleo.db` connection, outside a transaction.
+ * @param id - The receipt key (`twin_collapse_recovery:<recoveredAt>`).
+ * @returns What was undone.
+ * @throws {CleoError} {@link E_TWIN_COLLAPSE_RECOVER} when the receipt is
+ *   unknown or already rolled back (nothing is written).
+ * @task T12727
+ */
+export declare function rollbackTwinCollapseRecovery(live: DatabaseSync, id: string): TwinCollapseRecoveryRollback;
+/** Error code of a snapshot release that cannot proceed; nothing was written. */
+export declare const E_TWIN_COLLAPSE_RELEASE = "E_TWIN_COLLAPSE_RELEASE";
+/** What {@link planSnapshotRelease} found for one pre-collapse snapshot. */
+export interface TwinCollapseSnapshotReleasePlan {
+    /** The snapshot path the markers record, or `null` when none matches. */
+    readonly snapshot: string | null;
+    /** Marker keys that reference it (`<kvTable>:twin_collapse:<table>`). */
+    readonly markers: readonly string[];
+    /** Whether the snapshot is on disk. */
+    readonly exists: boolean;
+    /** Bytes reclaimed once it rotates (the file plus any `-wal`/`-shm`). */
+    readonly bytes: number;
+    /**
+     * `recovered`: a recovery apply (not rolled back) read this snapshot and
+     * nothing is left to recover; `no-recovery-needed`: it holds nothing the
+     * live store lacks; `null`: not releasable (see `blockers`).
+     */
+    readonly basis: 'recovered' | 'no-recovery-needed' | null;
+    /** Recovery receipts (not rolled back) that read this snapshot. */
+    readonly receipts: readonly string[];
+    /** Why it cannot be released; empty when it can. */
+    readonly blockers: readonly string[];
+    /** The path the markers record when the store moved and {@link snapshot} is the local file (T12788). */
+    readonly movedFrom: string | null;
+}
+/**
+ * Plan releasing a pre-collapse snapshot (T12767): which markers reference
+ * it, how many bytes it holds, and whether it may be released. It may only
+ * after a verified recovery or a no-recovery-needed check: the recovery plan
+ * against it ({@link planTwinCollapseRecovery}) must find nothing left to
+ * recover, and only the `schema_meta` / `sticky_tags` markers (the pairs the
+ * recovery covers) may reference it.
+ *
+ * @param live - The project `cleo.db` connection (read-only is enough).
+ * @param id - The snapshot: its backup id (`migration-<timestamp>`), file name or path.
+ * @param snapshot - The snapshot opened read-only, or `null` when it is not on disk.
+ * @returns The plan.
+ * @task T12767
+ */
+export declare function planSnapshotRelease(live: DatabaseSync, id: string, snapshot: DatabaseSync | null, options?: TwinCollapseRecoveryPlanOptions): TwinCollapseSnapshotReleasePlan;
+/** The release refusal for a plan with blockers. */
+export declare function releaseRefused(id: string, plan: TwinCollapseSnapshotReleasePlan): CleoError;
+/** What {@link releaseTwinCollapseSnapshot} did. */
+export interface TwinCollapseSnapshotRelease {
+    readonly snapshot: string;
+    /** Marker keys whose snapshot reference was cleared. */
+    readonly markers: readonly string[];
+    readonly basis: 'recovered' | 'no-recovery-needed';
+    readonly bytes: number;
+    readonly releasedAt: string;
+    /** The path the markers recorded, when the store moved (T12788); `null` otherwise. */
+    readonly movedFrom: string | null;
+}
+/**
+ * Release a pre-collapse snapshot, in one `BEGIN IMMEDIATE` transaction: the
+ * plan is re-checked under the write lock, each referencing marker's
+ * `snapshot` is cleared (so an open no longer pins it and rotation no longer
+ * keeps it), its sidecar pin is released, and `audit` records the release
+ * before the commit (a failed audit write refuses it). The snapshot file is
+ * never touched; it rotates normally from then on.
+ *
+ * @param live - The project `cleo.db` connection, outside a transaction.
+ * @param id - The snapshot: backup id, file name or path.
+ * @param snapshot - The snapshot opened read-only, or `null`.
+ * @param audit - Appends the audit row; throws to refuse.
+ * @returns What was released.
+ * @throws {CleoError} {@link E_TWIN_COLLAPSE_RELEASE} when it may not be released.
+ * @task T12767
+ */
+export declare function releaseTwinCollapseSnapshot(live: DatabaseSync, id: string, snapshot: DatabaseSync | null, audit: (release: TwinCollapseSnapshotRelease & {
+    receipts: readonly string[];
+}) => void, options?: TwinCollapseRecoveryPlanOptions): TwinCollapseSnapshotRelease;
+export {};
 //# sourceMappingURL=twin-collapse.d.ts.map

package/dist/store/twin-collapse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"twin-collapse.d.ts","sourceRoot":"","sources":["../../src/store/twin-collapse.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"twin-collapse.d.ts","sourceRoot":"","sources":["../../src/store/twin-collapse.ts"],"names":[],"mappings":"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"}