@dev.fast/whiteboard 0.3.4-preview.20261019.126 → 0.3.4

package/src/review-api/profile.ts

@@ -4,11 +4,8 @@ import { DatabaseSync } from "node:sqlite";
 
 import { withFileLock } from "@dev.fast/trace-core";
 
-import { CheckoutGroups } from "./checkout-groups.js";
 import { openLocalReviewStore } from "./local-data.js";
-import { groupCheckoutsAhead } from "./store-migrations.js";
 import { initializeReviewStoreSchema } from "./store-schema.js";
-import { projectOfCheckout } from "./store.js";
 
 const lockOptions = {
   retryMs: 50,
@@ -19,7 +16,7 @@ const lockOptions = {
 
 export async function openReviewProfile(
   home: string,
-  options: { manageWorkspaces: boolean; pullRequestStates?: boolean },
+  options: { manageWorkspaces: boolean },
 ) {
   await mkdir(home, { recursive: true, mode: 0o700 });
 
@@ -33,12 +30,7 @@ export async function openReviewProfile(
       ])
         await importHeadlessStore(home, source);
 
-      const database = path.join(home, "review-api.db");
-
-      return openLocalReviewStore(database, {
-        ...options,
-        checkoutOwners: await groupCheckoutsAhead(database),
-      });
+      return openLocalReviewStore(path.join(home, "review-api.db"), options);
     },
   );
 
@@ -97,7 +89,7 @@ async function importHeadlessStore(home: string, source: string) {
               `Cannot merge ${source}: the shared store already contains one of its review IDs. Both databases are unchanged.`,
             );
           database.exec(`
-          INSERT INTO repositories(id,path,name) SELECT s.id,s.path,s.name FROM headless.repositories s WHERE NOT EXISTS (SELECT 1 FROM repositories t WHERE t.path=s.path);
+          INSERT INTO repositories SELECT s.* FROM headless.repositories s WHERE NOT EXISTS (SELECT 1 FROM repositories t WHERE t.path=s.path);
           CREATE TEMP TABLE repository_ids AS SELECT s.id old_id,t.id new_id FROM headless.repositories s JOIN repositories t ON s.path=t.path;
         `);
 
@@ -122,36 +114,13 @@ async function importHeadlessStore(home: string, source: string) {
               `Cannot merge ${source}: a resource ID has different content. Both databases are unchanged.`,
             );
 
-          if (
-            database
-              .prepare(
-                "SELECT 1 FROM pragma_table_info('reviews') WHERE name='project_id'",
-              )
-              .get()
-          ) {
-            // A store with projects: file each board under its repository's,
-            // grouping the checkouts once for all of them.
-            const groups = new CheckoutGroups(database);
-
-            for (const { new_id: repositoryId } of database
-              .prepare("SELECT new_id FROM repository_ids")
-              .all())
-              projectOfCheckout(database, String(repositoryId), groups);
-            database.exec(`INSERT INTO reviews(id,version,next_id,project_id) SELECT s.id,s.version,s.next_id,p.project_id
-              FROM headless.reviews s JOIN headless.versions v ON v.review_id=s.id AND v.version=s.version
-              JOIN repository_ids r ON json_extract(v.snapshot,'$.pins.repositoryId')=r.old_id
-              JOIN repositories p ON p.id=r.new_id;`);
-          } else
-            database.exec(
-              "INSERT INTO reviews(id,version,next_id) SELECT id,version,next_id FROM headless.reviews;",
-            );
           database.exec(`
           INSERT OR IGNORE INTO resources SELECT s.id,r.new_id,s.kind,s.mime_type,s.data FROM headless.resources s JOIN repository_ids r ON s.repository_id=r.old_id;
-          INSERT INTO versions(review_id,version,snapshot,thread_id,author_kind) SELECT s.review_id,s.version,
+          INSERT INTO reviews SELECT * FROM headless.reviews;
+          INSERT INTO versions SELECT s.review_id,s.version,
             CASE WHEN json_type(s.snapshot,'$.target')='object'
               THEN json_set(s.snapshot,'$.pins.repositoryId',r.new_id,'$.target.repositoryId',r.new_id)
-              ELSE json_set(s.snapshot,'$.pins.repositoryId',r.new_id) END,
-            NULL, NULL
+              ELSE json_set(s.snapshot,'$.pins.repositoryId',r.new_id) END
             FROM headless.versions s JOIN repository_ids r ON json_extract(s.snapshot,'$.pins.repositoryId')=r.old_id;
           INSERT INTO review_attention SELECT * FROM headless.review_attention;
         `);

package/src/review-api/public-tools.ts

@@ -1,5 +1,4 @@
 import { type JsonValue, isJsonObject, isStringValue } from "@dev.fast/json";
-import { boardTitle } from "@dev.fast/review-protocol";
 
 import {
   type AuthoringTool,
@@ -79,13 +78,7 @@ export function publicResult(value: JsonValue): JsonValue {
 
       return [
         name,
-        key === "review" || key === "reviews"
-          ? publicResult(item)
-          : // A board's title as every surface shows it: an empty one is
-            // "Untitled".
-            key === "title" && "reviewId" in value && isStringValue(item)
-            ? boardTitle(item)
-            : item,
+        key === "review" || key === "reviews" ? publicResult(item) : item,
       ];
     }),
   );
@@ -105,20 +98,5 @@ export async function callPublicTool(
   if (sessionId !== undefined) fields.reviewId = sessionId;
   const result = await callAuthoringTool(client, tool, fields, signal);
 
-  return result instanceof ToolText
-    ? result
-    : withoutRepositoryIds(publicResult(result));
-}
-
-/** Agents never see repository ids. */
-function withoutRepositoryIds(value: JsonValue): JsonValue {
-  if (Array.isArray(value)) return value.map(withoutRepositoryIds);
-
-  if (!isJsonObject(value)) return value;
-
-  return Object.fromEntries(
-    Object.entries(value)
-      .filter(([key]) => key !== "repositoryId")
-      .map(([key, item]) => [key, withoutRepositoryIds(item)]),
-  );
+  return result instanceof ToolText ? result : publicResult(result);
 }

package/src/review-api/pull-request.ts

@@ -1,29 +1,18 @@
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { promisify } from "node:util";
-
-import {
-  type LocalVcsKind,
-  type VcsArg,
-  renderVcsArgs,
-  runVcs,
-} from "@dev.fast/local-vcs";
-import type { PullRequestState } from "@dev.fast/review-protocol";
+
+import type { LocalVcsKind } from "@dev.fast/local-vcs";
 import { errorMessage } from "@dev.fast/trace-core";
 
 import { ReviewInputError } from "./document.js";
 
-/** Runs one subprocess and resolves its stdout; rejects on failure or
- * timeout. git, jj and gh go through the VCS runner; Azure DevOps's az (by
- * way of cmd.exe on Windows) gets its operands checked the same way. */
+/** Runs one subprocess and resolves its stdout; rejects on failure or timeout. */
 export type RunCommand = (
-  file: "git" | "jj" | "gh" | "az" | "cmd.exe",
-  args: VcsArg[],
+  file: string,
+  args: string[],
   options: { cwd?: string; timeoutMs: number },
 ) => Promise<string>;
 
-const execFileAsync = promisify(execFile);
-
 export interface PullRequestDeps {
   run: RunCommand;
   fetch: typeof fetch;
@@ -42,7 +31,6 @@ export interface PullRequestRecord {
   headBranch?: string;
   /** GitHub's base commit, frozen at the PR's last update. */
   baseRefOid?: string;
-  state?: PullRequestState;
 }
 
 const FETCH_TIMEOUT_MS = 120_000;
@@ -50,38 +38,35 @@ const FETCH_TIMEOUT_MS = 120_000;
 const LOCAL_TIMEOUT_MS = 30_000;
 
 export const defaultPullRequestDeps: PullRequestDeps = {
-  run: async (file, args, options) => {
-    const spawnOptions = {
-      cwd: options.cwd,
-      timeout: options.timeoutMs,
-      maxBuffer: 16 * 1024 * 1024,
-      // Never wait on ssh asking for a passphrase nobody can see.
-      env: {
-        ...process.env,
-        GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND ?? "ssh -o BatchMode=yes",
-      },
-    };
-
-    try {
-      return (
-        file === "az" || file === "cmd.exe"
-          ? await execFileAsync(file, renderVcsArgs(args), {
-              ...spawnOptions,
-              encoding: "utf8",
-            })
-          : await runVcs(file, args, spawnOptions)
-      ).stdout;
-    } catch (error) {
-      // SAFETY: execFile rejects with an ExecFileException carrying stderr.
-      const failure = error as { killed?: boolean; stderr?: string };
-
-      const reason = failure.killed
-        ? `timed out after ${options.timeoutMs / 1000}s`
-        : String(failure.stderr ?? "").trim() || errorMessage(error);
-
-      throw new Error(`${file} ${String(args[0])}: ${reason}`);
-    }
-  },
+  run: (file, args, options) =>
+    new Promise((resolve, reject) => {
+      execFile(
+        file,
+        args,
+        {
+          cwd: options.cwd,
+          timeout: options.timeoutMs,
+          maxBuffer: 16 * 1024 * 1024,
+          // Never wait on a credential or confirmation prompt nobody can see.
+          env: {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: "0",
+            GH_PROMPT_DISABLED: "1",
+            GIT_SSH_COMMAND:
+              process.env.GIT_SSH_COMMAND ?? "ssh -o BatchMode=yes",
+          },
+        },
+        (error, stdout, stderr) => {
+          if (!error) return resolve(stdout);
+
+          const reason = error.killed
+            ? `timed out after ${options.timeoutMs / 1000}s`
+            : String(stderr).trim() || error.message;
+
+          reject(new Error(`${file} ${args[0]}: ${reason}`));
+        },
+      );
+    }),
   fetch: (input, init) => fetch(input, init),
 };
 
@@ -150,62 +135,55 @@ export async function fetchPullRequest(
   const { pullRequest: pr } = input;
   const refs = pullRequestRefs(input.provider, pr);
 
-  const git = (args: VcsArg[], timeoutMs = LOCAL_TIMEOUT_MS) =>
+  const git = (args: string[], timeoutMs = LOCAL_TIMEOUT_MS) =>
     deps
       .run("git", ["--git-dir", input.gitDir, ...args], { timeoutMs })
       .then((stdout) => stdout.trim());
 
-  const fetchRefs = (...refspecs: VcsArg[]) =>
+  const fetchRefs = (...refspecs: string[]) =>
     git(
       [
         "fetch",
         "--no-tags",
         "--no-write-fetch-head",
         "--quiet",
-        { remote: input.remote },
+        input.remote,
         ...refspecs,
       ],
       FETCH_TIMEOUT_MS,
     );
 
   const commit = (ref: string) =>
-    git(["rev-parse", "--verify", "--quiet", { rev: `${ref}^{commit}` }]).catch(
+    git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]).catch(
       () => undefined,
     );
 
   const mergeBase = (left: string, right: string) =>
-    git(["merge-base", { rev: left }, { rev: right }]).catch(() => undefined);
+    git(["merge-base", left, right]).catch(() => undefined);
 
   const frozenBase = async () => {
     if (!pr.baseRefOid) return undefined;
 
     if (!(await commit(pr.baseRefOid)))
-      await fetchRefs({
-        refspec: { from: pr.baseRefOid, to: refs.frozenBase, force: true },
-      }).catch(() => undefined);
+      await fetchRefs(`+${pr.baseRefOid}:${refs.frozenBase}`).catch(
+        () => undefined,
+      );
 
     return commit(pr.baseRefOid);
   };
 
   let baseTip: string | undefined;
 
-  const pullHead: VcsArg = {
-    refspec: { from: pr.headRef, to: refs.head, force: true },
-  };
-
   try {
-    await fetchRefs(pullHead, {
-      refspec: {
-        from: `refs/heads/${pr.baseRefName}`,
-        to: refs.base,
-        force: true,
-      },
-    });
+    await fetchRefs(
+      `+${pr.headRef}:${refs.head}`,
+      `+refs/heads/${pr.baseRefName}:${refs.base}`,
+    );
     baseTip = await commit(refs.base);
   } catch (error) {
     // The base branch may be gone; the head and the frozen base suffice.
     try {
-      await fetchRefs(pullHead);
+      await fetchRefs(`+${pr.headRef}:${refs.head}`);
     } catch {
       throw new ReviewInputError(
         `Could not fetch PR #${pr.number} from remote "${input.remote}" (${pr.slug}). Check \`git fetch ${input.remote}\` works with your Git credentials, then retry. Git said: ${firstLine(errorMessage(error))}`,
@@ -254,7 +232,7 @@ export async function fetchPullRequest(
 async function indexForJj(
   rootPath: string,
   commits: string[],
-  git: (args: VcsArg[]) => Promise<string>,
+  git: (args: string[]) => Promise<string>,
   deps: PullRequestDeps,
 ) {
   const tags = commits.map(() => `refs/tags/review-index-${randomUUID()}`);
@@ -268,7 +246,7 @@ async function indexForJj(
 
   try {
     for (const [index, tag] of tags.entries())
-      await git(["update-ref", { ref: tag }, { commit: commits[index]! }]);
+      await git(["update-ref", tag, commits[index]!]);
     await jjImport();
   } finally {
     for (const tag of tags)
@@ -277,17 +255,6 @@ async function indexForJj(
   }
 }
 
-/** GitHub refused a read, as it does past a rate limit; it takes reads
- * again at `retryAt`. */
-export class GitHubRefusedRead extends ReviewInputError {
-  constructor(
-    message: string,
-    readonly retryAt: number,
-  ) {
-    super(message, 409);
-  }
-}
-
 export function firstLine(text: string) {
   return text.split("\n")[0]!.slice(0, 300);
 }

package/src/review-api/request-origin.ts

@@ -13,16 +13,6 @@ export const REVIEW_VIA_HEADER = "x-review-via";
 
 export const REVIEW_AGENT_HEADER = "x-review-agent";
 
-/** The Ask thread a request comes from. The CLI reads it from ASK_THREAD_ENV,
- * which Desktop sets for the thread's agent. */
-export const REVIEW_THREAD_HEADER = "x-review-thread";
-
-export const ASK_THREAD_ENV = "DEV_REVIEW_ASK_THREAD";
-
-/** Set by Desktop and the canvas on a command a person gave, such as a new
- * board from the sidebar; its version is credited to them. */
-export const REVIEW_PERSON_HEADER = "x-review-person";
-
 export type ReviewRequestVia = "api" | "mcp" | "other";
 
 const viaSchema = z.enum(["api", "mcp", "other"]).catch("other");

package/src/review-api/review-progress.ts

@@ -1,7 +1,5 @@
 import {
   type LensSource,
-  SelectionUnavailableError,
-  type SelectionUnavailableReason,
   comparisonKey,
   resolveDiffSelection,
   selectionKey,
@@ -17,15 +15,8 @@ import {
   UNCATEGORIZED_LENS_ID,
   lensSelections,
 } from "./diff-lenses.js";
-import {
-  type Pins,
-  anchorPins,
-  boardRepositoryId,
-  selectionReferences,
-} from "./document.js";
+import { type Pins, anchorPins, selectionReferences } from "./document.js";
 import { resolveFileLens, uncategorizedSources } from "./file-lenses.js";
-import { ReviewInputError } from "./input-error.js";
-import { textualRows } from "./lens-alignment.js";
 import type { LocalReviewData } from "./local-data.js";
 import type { ReviewStore, Snapshot } from "./store.js";
 
@@ -49,7 +40,7 @@ export const progressUpdateSchema = z.strictObject({
 
 export interface ReviewProgress {
   complete?: boolean;
-  unavailableSelections?: Record<string, SelectionUnavailableReason>;
+  unavailableSelections?: Record<string, string>;
   files: CoverageFile[];
   /** Changed files of the comparisons that references with their own pins
    * named, by `comparisonKey` and then path. They are not the document's
@@ -139,7 +130,7 @@ export async function reviewProgress(
   const alignments = new Map(comparison.alignments);
   const resolvedSelections: Record<string, FileLineRange[]> = {};
 
-  const unavailableSelections: Record<string, SelectionUnavailableReason> = {};
+  const unavailableSelections: Record<string, string> = {};
   const pendingSources = new Set<string>();
 
   const resolve = async (source: LensSource): Promise<FileLineRange[]> => {
@@ -178,8 +169,7 @@ export async function reviewProgress(
     let rows = file && ownAlignments.get(file.path);
 
     // Context-only files are absent from the changed-file stream. Read both pins
-    // and require equality rather than inventing correspondence for missing
-    // diffs; a file on one side only, such as an untracked one, is that side.
+    // and require equality rather than inventing correspondence for missing diffs.
     if (!file && counting && !own) {
       pendingSources.add(key);
 
@@ -187,43 +177,20 @@ export async function reviewProgress(
     }
 
     if (!file) {
-      const [base, head] = await Promise.all(
-        (["base", "head"] as const).map((side) =>
-          data.file(sourcePins, side, source.file).then(
-            (value) => value.text,
-            (error) => {
-              if (error instanceof ReviewInputError && error.status === 404)
-                return null;
-              throw error;
-            },
-          ),
-        ),
-      );
-
-      if (base === null && head === null)
-        throw new SelectionUnavailableError(
-          "missing_file",
-          "File is unavailable at these pins.",
-        );
-
-      if (base !== null && head !== null && base !== head)
-        throw new SelectionUnavailableError(
-          "no_alignment",
-          "Changed context file has no alignment.",
-        );
-      rows = textualRows(
-        source.file,
-        "",
-        base?.split("\n").length ?? 0,
-        head?.split("\n").length ?? 0,
+      const [base, head] = await Promise.all([
+        data.file(sourcePins, "base", source.file),
+        data.file(sourcePins, "head", source.file),
+      ]);
+
+      if (base.text !== head.text)
+        throw new Error("Changed context file has no alignment.");
+      rows = Array.from(
+        { length: base.text.split("\n").length },
+        (_, line) => [line, line] as const,
       );
     }
 
-    if (!rows)
-      throw new SelectionUnavailableError(
-        "no_alignment",
-        "File has no text alignment.",
-      );
+    if (!rows) throw new Error("File has no text alignment.");
 
     const result = resolveDiffSelection(
       source,
@@ -239,9 +206,9 @@ export async function reviewProgress(
   const resolveAvailable = async (source: LensSource) => {
     try {
       return await resolve(source);
-    } catch (error) {
+    } catch {
       unavailableSelections[selectionKey(source)] =
-        error instanceof SelectionUnavailableError ? error.reason : "other";
+        "Source links need updating at these pins";
 
       return [];
     }
@@ -287,16 +254,15 @@ export async function reviewProgress(
 
   // Peeks share alignment resolution without claiming lens coverage.
   await Promise.all(
-    selectionReferences(snapshot.document, {
-      tolerant: true,
-      repositoryId: boardRepositoryId(snapshot),
-    }).map(async ({ source }) => {
-      try {
-        await resolveAvailable(source);
-      } catch {
-        /* An unavailable peek does not hide other content. */
-      }
-    }),
+    selectionReferences(snapshot.document, { tolerant: true }).map(
+      async ({ source }) => {
+        try {
+          await resolveAvailable(source);
+        } catch {
+          /* An unavailable peek does not hide other content. */
+        }
+      },
+    ),
   );
 
   const uncategorized = counting
@@ -333,7 +299,7 @@ export async function reviewProgress(
   });
 
   const progress: ReviewProgress = {
-    complete: !counting && !pendingSources.size,
+    complete: !counting,
     files,
     referenceFiles,
     lenses,

package/src/review-api/store-schema.ts

@@ -1,55 +1,46 @@
 import type { DatabaseSync } from "node:sqlite";
 
-/** A board version's repository in SQL over `versions.snapshot`, as
- * `boardRepositoryId` reads it: its target's, else its pins'. */
-export const BOARD_REPOSITORY_ID_SQL =
-  "CASE WHEN json_valid(versions.snapshot) THEN COALESCE(json_extract(versions.snapshot,'$.target.repositoryId'),json_extract(versions.snapshot,'$.pins.repositoryId')) END";
-
-export const columnsOf = (db: DatabaseSync, table: string) =>
-  new Set(
-    db
-      .prepare("SELECT name FROM pragma_table_info(?)")
-      .all(table)
-      .map(({ name }) => String(name)),
-  );
-
-export const hasTable = (db: DatabaseSync, table: string) =>
-  Boolean(
-    db
-      .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?")
-      .get(table),
-  );
-
 export function initializeReviewStoreSchema(db: DatabaseSync): void {
   db.exec(`
     PRAGMA journal_mode=WAL;
     PRAGMA foreign_keys=ON;
-    CREATE TABLE IF NOT EXISTS reviews(id TEXT PRIMARY KEY, version INTEGER NOT NULL, next_id INTEGER NOT NULL,
-      project_id TEXT NOT NULL REFERENCES projects(id), parent_id TEXT REFERENCES reviews(id) ON DELETE SET NULL);
+    CREATE TABLE IF NOT EXISTS reviews(id TEXT PRIMARY KEY, version INTEGER NOT NULL, next_id INTEGER NOT NULL);
     CREATE TABLE IF NOT EXISTS versions(review_id TEXT REFERENCES reviews(id), version INTEGER, snapshot TEXT NOT NULL,
-      thread_id TEXT, author_kind TEXT,
       PRIMARY KEY(review_id,version));
+    DROP TABLE IF EXISTS receipts;
     CREATE TABLE IF NOT EXISTS review_attention(review_id TEXT PRIMARY KEY REFERENCES reviews(id), viewed_at TEXT, deleted_at TEXT);
-    CREATE TABLE IF NOT EXISTS projects(id TEXT PRIMARY KEY, name TEXT NOT NULL);
-    CREATE TABLE IF NOT EXISTS repositories(id TEXT PRIMARY KEY, path TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
-      project_id TEXT REFERENCES projects(id));
+    CREATE TABLE IF NOT EXISTS repositories(id TEXT PRIMARY KEY, path TEXT NOT NULL UNIQUE, name TEXT NOT NULL);
     CREATE TABLE IF NOT EXISTS resources(id TEXT PRIMARY KEY, repository_id TEXT NOT NULL REFERENCES repositories(id),
       kind TEXT NOT NULL, mime_type TEXT NOT NULL, data BLOB NOT NULL);
     CREATE TABLE IF NOT EXISTS review_coverage(review_id TEXT REFERENCES reviews(id), file TEXT, fingerprint TEXT NOT NULL, coverage TEXT NOT NULL,
       PRIMARY KEY(review_id,file));
+    DROP TABLE IF EXISTS review_viewed;
     CREATE TABLE IF NOT EXISTS comparison_stats(identity TEXT PRIMARY KEY, stats TEXT NOT NULL);
     CREATE TABLE IF NOT EXISTS server_identity(one INTEGER PRIMARY KEY CHECK(one=1), id TEXT NOT NULL);
-    CREATE TABLE IF NOT EXISTS board_dependencies(review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
-      depends_on TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE, PRIMARY KEY(review_id,depends_on));
-    CREATE INDEX IF NOT EXISTS board_dependencies_depends_on ON board_dependencies(depends_on);
-    -- A link goes with the board it is on. Where it points stays plain
-    -- text, no foreign key: a link to a deleted board stays, and reads
-    -- "Board deleted" from the deleted_boards tombstone.
-    CREATE TABLE IF NOT EXISTS board_links(from_review TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE, from_block TEXT NOT NULL,
-      to_review TEXT NOT NULL, to_block TEXT);
-    CREATE INDEX IF NOT EXISTS board_links_from ON board_links(from_review);
-    CREATE INDEX IF NOT EXISTS board_links_to ON board_links(to_review);
-    CREATE TABLE IF NOT EXISTS deleted_boards(id TEXT PRIMARY KEY, title TEXT NOT NULL, deleted_at TEXT NOT NULL,
-      project_id TEXT);
+    DROP TABLE IF EXISTS authoring_drafts;
   `);
+
+  db.exec("BEGIN IMMEDIATE");
+
+  try {
+    // Migrate the former Archive timestamp without losing recoverable boards.
+    const attentionColumns = db
+      .prepare("PRAGMA table_info(review_attention)")
+      .all();
+
+    if (attentionColumns.some((column) => column.name === "dismissed_at")) {
+      db.exec(
+        "ALTER TABLE review_attention RENAME COLUMN dismissed_at TO deleted_at",
+      );
+      // Archive had no retention limit. Give migrated boards the full recovery window.
+      db.prepare(
+        "UPDATE review_attention SET deleted_at=? WHERE deleted_at IS NOT NULL",
+      ).run(new Date().toISOString());
+    }
+
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
 }