@fabiofiorita/porcelain 0.63.4 → 0.65.0

package/server/drizzle/0002_backfill_comment_authors.sql

@@ -0,0 +1,25 @@
+-- Comment messages written before authorship was introduced have no `author`.
+-- Drizzle runs this migration in one transaction. Only the missing field is
+-- added: existing author values, timestamps, anchors and message order remain
+-- untouched, and no timestamp is fabricated for legacy data.
+UPDATE comment_threads
+SET data = json_set(
+  data,
+  '$.messages',
+  (
+    SELECT json_group_array(
+      CASE
+        WHEN json_type(value, '$.author') IS NULL
+          THEN json_set(value, '$.author', 'reviewer')
+        ELSE value
+      END
+      ORDER BY CAST(key AS INTEGER)
+    )
+    FROM json_each(data, '$.messages')
+  )
+)
+WHERE EXISTS (
+  SELECT 1
+  FROM json_each(data, '$.messages')
+  WHERE json_type(value, '$.author') IS NULL
+);

package/server/drizzle/0003_pairing_and_devices.sql

@@ -0,0 +1,23 @@
+CREATE TABLE `devices` (
+	`id` text PRIMARY KEY NOT NULL,
+	`label` text NOT NULL,
+	`platform` text NOT NULL,
+	`secret_hash` text NOT NULL,
+	`created_at` text NOT NULL,
+	`last_seen_at` text NOT NULL,
+	`last_seen_address` text,
+	`revoked_at` text
+);
+--> statement-breakpoint
+CREATE TABLE `pairing_grants` (
+	`id` text PRIMARY KEY NOT NULL,
+	`label` text NOT NULL,
+	`secret_hash` text NOT NULL,
+	`addresses` text DEFAULT '[]' NOT NULL,
+	`created_at` text NOT NULL,
+	`expires_at` text NOT NULL,
+	`redeemed_at` text,
+	`revoked_at` text
+);
+--> statement-breakpoint
+CREATE INDEX `pairing_grants_expires` ON `pairing_grants` (`expires_at`);

package/server/drizzle/0004_worktrees_from_git.sql

@@ -0,0 +1,146 @@
+-- Worktrees stop being stored: Git lists them and their ids are derived from
+-- the project and the filesystem identity of the administrative Git directory.
+--
+-- Everything here runs in the one transaction Drizzle wraps this file in, so a
+-- crash leaves the old ids intact rather than a half-rewritten database. The
+-- derivation is registered on the connection as `porcelain_worktree_id` before
+-- migrations run; it is the same function the server uses at runtime.
+--
+-- Rows whose old id cannot be mapped keep it. That happens when the worktree
+-- had no recorded identity (it was unavailable at the last refresh) or had
+-- already left the active table, and there is nothing to derive from. They are
+-- not matched by path: a worktree deleted and recreated at the same path is a
+-- different worktree, which is the whole reason ids are derived. They keep
+-- their data. Where the project they belonged to can still be determined they
+-- are seeded into worktree_presence and follow the same observed-absence rule
+-- as everything else; where it cannot, they have no presence row, so nothing
+-- collects them and nothing deletes them with a project. In practice
+-- project_worktrees held a row for every worktree ever listed, so that set
+-- should be empty.
+CREATE TABLE `worktree_presence` (
+  `worktree_id` text PRIMARY KEY NOT NULL,
+  `project_id` text NOT NULL,
+  `missing_since` text,
+  FOREIGN KEY (`project_id`) REFERENCES `inventory_projects`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX `worktree_presence_project` ON `worktree_presence` (`project_id`);
+--> statement-breakpoint
+-- The mapping, computed once from data already stored. No filesystem access.
+CREATE TEMPORARY TABLE `worktree_id_migration` AS
+SELECT
+  `id` AS `old_id`,
+  `project_id`,
+  porcelain_worktree_id(`project_id`, `metadata_identity`) AS `new_id`
+FROM `worktrees`
+WHERE `metadata_identity` IS NOT NULL;
+--> statement-breakpoint
+UPDATE `reviewed_files`
+SET `worktree_id` = (
+  SELECT `new_id` FROM `worktree_id_migration` WHERE `old_id` = `reviewed_files`.`worktree_id`
+)
+WHERE `worktree_id` IN (SELECT `old_id` FROM `worktree_id_migration`);
+--> statement-breakpoint
+UPDATE `artifacts`
+SET `worktree_id` = (
+  SELECT `new_id` FROM `worktree_id_migration` WHERE `old_id` = `artifacts`.`worktree_id`
+)
+WHERE `worktree_id` IN (SELECT `old_id` FROM `worktree_id_migration`);
+--> statement-breakpoint
+UPDATE `review_layer_sets`
+SET `worktree_id` = (
+  SELECT `new_id` FROM `worktree_id_migration` WHERE `old_id` = `review_layer_sets`.`worktree_id`
+)
+WHERE `worktree_id` IN (SELECT `old_id` FROM `worktree_id_migration`);
+--> statement-breakpoint
+-- A comment thread carries its worktree twice: the column it is looked up by
+-- and the id inside the stored thread that is returned to the client.
+UPDATE `comment_threads`
+SET
+  `worktree_id` = (
+    SELECT `new_id` FROM `worktree_id_migration` WHERE `old_id` = `comment_threads`.`worktree_id`
+  ),
+  `data` = json_set(
+    `data`,
+    '$.worktreeId',
+    (SELECT `new_id` FROM `worktree_id_migration` WHERE `old_id` = `comment_threads`.`worktree_id`)
+  )
+WHERE `worktree_id` IN (SELECT `old_id` FROM `worktree_id_migration`);
+--> statement-breakpoint
+-- Archived layers have no worktree column at all: the source worktree is only
+-- inside the payload, so leaving it would return an id nothing resolves.
+UPDATE `commit_review_layer_sets`
+SET `data` = json_set(
+  `data`,
+  '$.sourceWorktreeId',
+  (
+    SELECT `new_id` FROM `worktree_id_migration`
+    WHERE `old_id` = json_extract(`commit_review_layer_sets`.`data`, '$.sourceWorktreeId')
+  )
+)
+WHERE json_extract(`data`, '$.sourceWorktreeId') IN (SELECT `old_id` FROM `worktree_id_migration`);
+--> statement-breakpoint
+-- An unexpired preparation and a recovered receipt both name their worktree in
+-- a durable value; an upgrade must not strand a Git action in flight.
+UPDATE `git_action_preparations`
+SET `value` = json_set(
+  `value`,
+  '$.worktreeId',
+  (
+    SELECT `new_id` FROM `worktree_id_migration`
+    WHERE `old_id` = json_extract(`git_action_preparations`.`value`, '$.worktreeId')
+  )
+)
+WHERE json_extract(`value`, '$.worktreeId') IN (SELECT `old_id` FROM `worktree_id_migration`);
+--> statement-breakpoint
+UPDATE `git_action_receipts`
+SET `value` = json_set(
+  `value`,
+  '$.worktreeId',
+  (
+    SELECT `new_id` FROM `worktree_id_migration`
+    WHERE `old_id` = json_extract(`git_action_receipts`.`value`, '$.worktreeId')
+  )
+)
+WHERE json_extract(`value`, '$.worktreeId') IN (SELECT `old_id` FROM `worktree_id_migration`);
+--> statement-breakpoint
+-- Presence rows for everything that now has review data, mapped or not. A
+-- worktree present in Git clears `missing_since` on the first listing; one
+-- that is gone has it set by the first listing that succeeds without it.
+INSERT OR IGNORE INTO `worktree_presence` (`worktree_id`, `project_id`, `missing_since`)
+SELECT `worktree_id`, `project_id`, NULL FROM (
+  SELECT `worktree_id`, (
+    SELECT `project_id` FROM `worktree_id_migration` WHERE `new_id` = `reviewed_files`.`worktree_id`
+    UNION ALL
+    SELECT `project_id` FROM `project_worktrees` WHERE `worktree_id` = `reviewed_files`.`worktree_id`
+    LIMIT 1
+  ) AS `project_id` FROM `reviewed_files`
+  UNION
+  SELECT `worktree_id`, (
+    SELECT `project_id` FROM `worktree_id_migration` WHERE `new_id` = `artifacts`.`worktree_id`
+    UNION ALL
+    SELECT `project_id` FROM `project_worktrees` WHERE `worktree_id` = `artifacts`.`worktree_id`
+    LIMIT 1
+  ) AS `project_id` FROM `artifacts`
+  UNION
+  SELECT `worktree_id`, (
+    SELECT `project_id` FROM `worktree_id_migration` WHERE `new_id` = `review_layer_sets`.`worktree_id`
+    UNION ALL
+    SELECT `project_id` FROM `project_worktrees` WHERE `worktree_id` = `review_layer_sets`.`worktree_id`
+    LIMIT 1
+  ) AS `project_id` FROM `review_layer_sets`
+  UNION
+  SELECT `worktree_id`, (
+    SELECT `project_id` FROM `worktree_id_migration` WHERE `new_id` = `comment_threads`.`worktree_id`
+    UNION ALL
+    SELECT `project_id` FROM `project_worktrees` WHERE `worktree_id` = `comment_threads`.`worktree_id`
+    LIMIT 1
+  ) AS `project_id` FROM `comment_threads`
+)
+WHERE `project_id` IS NOT NULL;
+--> statement-breakpoint
+DROP TABLE `worktree_id_migration`;
+--> statement-breakpoint
+DROP TABLE `project_worktrees`;
+--> statement-breakpoint
+DROP TABLE `worktrees`;

package/server/drizzle/0005_names_and_status.sql

@@ -0,0 +1,31 @@
+-- Project names come from `origin`, and each worktree can show a status dot.
+--
+-- Three changes, one transaction:
+--
+--  * `named_by_owner` records who chose a project's name. Every existing name
+--    was derived from a folder, so they all start as not owner-chosen and the
+--    next registration replaces them with the repository's own name.
+--  * `comment_threads` gains a monotonic `revision`, seeded from the sequence
+--    it already had, and `last_agent_revision`, which is that revision when
+--    the last message is the agent's. That is what the yellow dot asks about.
+--  * `comment_reads` records how far the owner has actually seen. It is only
+--    ever advanced by an explicit act, never by a background list.
+ALTER TABLE `inventory_projects` ADD `named_by_owner` integer DEFAULT 0 NOT NULL;
+--> statement-breakpoint
+ALTER TABLE `comment_threads` ADD `revision` integer DEFAULT 0 NOT NULL;
+--> statement-breakpoint
+ALTER TABLE `comment_threads` ADD `last_agent_revision` integer;
+--> statement-breakpoint
+UPDATE `comment_threads` SET `revision` = `sequence`;
+--> statement-breakpoint
+UPDATE `comment_threads`
+SET `last_agent_revision` = `revision`
+WHERE json_extract(
+  `data`,
+  '$.messages[' || (json_array_length(`data`, '$.messages') - 1) || '].author'
+) = 'agent';
+--> statement-breakpoint
+CREATE TABLE `comment_reads` (
+  `worktree_id` text PRIMARY KEY NOT NULL,
+  `seen_through` integer NOT NULL
+);

package/server/drizzle/0006_stale_reviewed_files.sql

@@ -0,0 +1 @@
+ALTER TABLE `reviewed_files` ADD `stale` integer DEFAULT 0 NOT NULL;

package/server/drizzle/0007_normalize_comment_messages.sql

@@ -0,0 +1,66 @@
+ALTER TABLE `comment_threads` RENAME TO `comment_threads_legacy`;
+--> statement-breakpoint
+CREATE TABLE `comment_threads` (
+	`sequence` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`id` text NOT NULL,
+	`worktree_id` text NOT NULL,
+	`anchor` text NOT NULL,
+	`resolved` integer NOT NULL,
+	`revision` integer NOT NULL,
+	`last_agent_revision` integer,
+	`size_bytes` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `comment_threads_normalized_id_unique` ON `comment_threads` (`id`);
+--> statement-breakpoint
+CREATE INDEX `comment_threads_worktree` ON `comment_threads` (`worktree_id`);
+--> statement-breakpoint
+CREATE TABLE `comment_messages` (
+	`sequence` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`id` text NOT NULL,
+	`thread_id` text NOT NULL,
+	`worktree_id` text NOT NULL,
+	`body` text NOT NULL,
+	`author` text NOT NULL,
+	`created_at` text,
+	FOREIGN KEY (`thread_id`) REFERENCES `comment_threads`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `comment_threads` (
+	`sequence`, `id`, `worktree_id`, `anchor`, `resolved`, `revision`,
+	`last_agent_revision`, `size_bytes`
+)
+SELECT
+	`sequence`,
+	`id`,
+	`worktree_id`,
+	json_extract(`data`, '$.anchor'),
+	CASE json_extract(`data`, '$.resolved') WHEN 1 THEN 1 ELSE 0 END,
+	`revision`,
+	`last_agent_revision`,
+	length(cast(`data` AS blob)) +
+		CASE json_extract(`data`, '$.resolved') WHEN 1 THEN 1 ELSE 0 END
+FROM `comment_threads_legacy`
+ORDER BY `sequence`;
+--> statement-breakpoint
+INSERT INTO `comment_messages` (
+	`id`, `thread_id`, `worktree_id`, `body`, `author`, `created_at`
+)
+SELECT
+	json_extract(message.value, '$.id'),
+	thread.`id`,
+	thread.`worktree_id`,
+	json_extract(message.value, '$.body'),
+	coalesce(json_extract(message.value, '$.author'), 'reviewer'),
+	json_extract(message.value, '$.createdAt')
+FROM `comment_threads_legacy` AS thread,
+	json_each(thread.`data`, '$.messages') AS message
+ORDER BY thread.`sequence`, cast(message.key AS integer);
+--> statement-breakpoint
+DROP TABLE `comment_threads_legacy`;
+--> statement-breakpoint
+CREATE INDEX `comment_messages_id` ON `comment_messages` (`id`);
+--> statement-breakpoint
+CREATE INDEX `comment_messages_thread` ON `comment_messages` (`thread_id`,`sequence`);
+--> statement-breakpoint
+CREATE INDEX `comment_messages_worktree` ON `comment_messages` (`worktree_id`);

package/server/drizzle/0008_published_reviews.sql

@@ -0,0 +1,30 @@
+CREATE TABLE `reviews` (
+	`worktree_id` text PRIMARY KEY NOT NULL,
+	`revision` integer NOT NULL,
+	`published_at` text NOT NULL,
+	`active` integer DEFAULT true NOT NULL,
+	`summary_html` text NOT NULL,
+	`summary_token` text NOT NULL,
+	`summary_secret` text NOT NULL,
+	`diagram` text,
+	`layers` text NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `reviews_summary_token_unique` ON `reviews` (`summary_token`);
+--> statement-breakpoint
+CREATE TABLE `reviewed_layers` (
+	`worktree_id` text NOT NULL,
+	`layer_id` text NOT NULL,
+	`fingerprint` text NOT NULL,
+	`reviewed_at` text NOT NULL,
+	`stale` integer DEFAULT false NOT NULL,
+	PRIMARY KEY(`worktree_id`, `layer_id`)
+);
+--> statement-breakpoint
+CREATE INDEX `reviewed_layers_worktree` ON `reviewed_layers` (`worktree_id`);
+--> statement-breakpoint
+DROP TABLE `artifacts`;
+--> statement-breakpoint
+DROP TABLE `review_layer_sets`;
+--> statement-breakpoint
+DROP TABLE `commit_review_layer_sets`;

package/server/drizzle/0009_drop_unused_git_action_tables.sql

@@ -0,0 +1,5 @@
+-- Git actions keep only their receipts; nothing reads or writes blocks or
+-- preparations any more.
+DROP TABLE `git_action_blocks`;
+--> statement-breakpoint
+DROP TABLE `git_action_preparations`;

package/server/drizzle/0010_cascade_deletes_through_foreign_keys.sql

@@ -0,0 +1,207 @@
+-- Deleting a project or collecting an absent worktree becomes one DELETE: every
+-- row that belongs to a project or a worktree names its parent with a foreign
+-- key that cascades.
+--
+--  * inventory_projects owns worktree_presence, project_file_preferences and
+--    git_action_receipts. Receipts gain a `project_id` column copied from the
+--    stored receipt, because a foreign key needs a column.
+--  * worktree_presence owns everything keyed by worktree: reviews, reviewed
+--    files and layers, comment threads, comment messages and comment reads. It
+--    is the only table that knows which project a worktree belongs to, so a
+--    project removal reaches review data through it.
+--
+-- SQLite cannot add a foreign key to an existing table, so each child is
+-- rebuilt. Migrations run with foreign key enforcement off and a
+-- foreign_key_check before commit, so dropping a parent here cascades nothing.
+-- Rows whose parent no longer exists are deleted: nothing could reach them and
+-- nothing would ever remove them.
+--
+-- inventory_projects is rebuilt too, so its `named_by_owner` column matches the
+-- schema: no default, and the same 0/1 check as the other flags.
+CREATE TABLE `__new_inventory_projects` (
+	`id` text PRIMARY KEY NOT NULL,
+	`name` text NOT NULL,
+	`named_by_owner` integer NOT NULL,
+	`common_directory` text NOT NULL,
+	`repository_identity` text NOT NULL,
+	`available` integer NOT NULL,
+	`position` integer NOT NULL,
+	CONSTRAINT "project_id_present" CHECK("__new_inventory_projects"."id" IS NOT NULL),
+	CONSTRAINT "project_available" CHECK("__new_inventory_projects"."available" IN (0, 1)),
+	CONSTRAINT "project_named_by_owner" CHECK("__new_inventory_projects"."named_by_owner" IN (0, 1))
+);
+--> statement-breakpoint
+INSERT INTO `__new_inventory_projects` ("id", "name", "named_by_owner", "common_directory", "repository_identity", "available", "position")
+SELECT "id", "name", "named_by_owner", "common_directory", "repository_identity", "available", "position" FROM `inventory_projects`;
+--> statement-breakpoint
+DROP TABLE `inventory_projects`;
+--> statement-breakpoint
+ALTER TABLE `__new_inventory_projects` RENAME TO `inventory_projects`;
+--> statement-breakpoint
+CREATE UNIQUE INDEX `inventory_projects_repository_identity_unique` ON `inventory_projects` (`repository_identity`);
+--> statement-breakpoint
+DELETE FROM `worktree_presence` WHERE `project_id` NOT IN (SELECT `id` FROM `inventory_projects`);
+--> statement-breakpoint
+CREATE TABLE `__new_project_file_preferences` (
+	`project_id` text NOT NULL,
+	`path` text NOT NULL,
+	`pinned` integer NOT NULL,
+	`hidden` integer NOT NULL,
+	PRIMARY KEY(`project_id`, `path`),
+	FOREIGN KEY (`project_id`) REFERENCES `inventory_projects`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT "project_preference_pinned" CHECK("__new_project_file_preferences"."pinned" IN (0, 1)),
+	CONSTRAINT "project_preference_hidden" CHECK("__new_project_file_preferences"."hidden" IN (0, 1))
+);
+--> statement-breakpoint
+INSERT INTO `__new_project_file_preferences` ("project_id", "path", "pinned", "hidden")
+SELECT "project_id", "path", "pinned", "hidden" FROM `project_file_preferences`
+WHERE `project_id` IN (SELECT `id` FROM `inventory_projects`);
+--> statement-breakpoint
+DROP TABLE `project_file_preferences`;
+--> statement-breakpoint
+ALTER TABLE `__new_project_file_preferences` RENAME TO `project_file_preferences`;
+--> statement-breakpoint
+CREATE TABLE `__new_git_action_receipts` (
+	`request_id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`value` text NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `inventory_projects`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_git_action_receipts` ("request_id", "project_id", "value")
+SELECT "request_id", json_extract("value", '$.projectId'), "value" FROM `git_action_receipts`
+WHERE json_extract("value", '$.projectId') IN (SELECT `id` FROM `inventory_projects`);
+--> statement-breakpoint
+DROP TABLE `git_action_receipts`;
+--> statement-breakpoint
+ALTER TABLE `__new_git_action_receipts` RENAME TO `git_action_receipts`;
+--> statement-breakpoint
+CREATE INDEX `git_action_receipts_project` ON `git_action_receipts` (`project_id`);
+--> statement-breakpoint
+CREATE TABLE `__new_reviews` (
+	`worktree_id` text PRIMARY KEY NOT NULL,
+	`revision` integer NOT NULL,
+	`published_at` text NOT NULL,
+	`active` integer DEFAULT true NOT NULL,
+	`summary_html` text NOT NULL,
+	`summary_token` text NOT NULL,
+	`summary_secret` text NOT NULL,
+	`diagram` text,
+	`layers` text NOT NULL,
+	FOREIGN KEY (`worktree_id`) REFERENCES `worktree_presence`(`worktree_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_reviews` ("worktree_id", "revision", "published_at", "active", "summary_html", "summary_token", "summary_secret", "diagram", "layers")
+SELECT "worktree_id", "revision", "published_at", "active", "summary_html", "summary_token", "summary_secret", "diagram", "layers" FROM `reviews`
+WHERE `worktree_id` IN (SELECT `worktree_id` FROM `worktree_presence`);
+--> statement-breakpoint
+DROP TABLE `reviews`;
+--> statement-breakpoint
+ALTER TABLE `__new_reviews` RENAME TO `reviews`;
+--> statement-breakpoint
+CREATE UNIQUE INDEX `reviews_summary_token_unique` ON `reviews` (`summary_token`);
+--> statement-breakpoint
+CREATE TABLE `__new_reviewed_files` (
+	`worktree_id` text NOT NULL,
+	`path` text NOT NULL,
+	`fingerprint` text NOT NULL,
+	`reviewed_at` text NOT NULL,
+	`stale` integer DEFAULT false NOT NULL,
+	PRIMARY KEY(`worktree_id`, `path`),
+	FOREIGN KEY (`worktree_id`) REFERENCES `worktree_presence`(`worktree_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_reviewed_files` ("worktree_id", "path", "fingerprint", "reviewed_at", "stale")
+SELECT "worktree_id", "path", "fingerprint", "reviewed_at", "stale" FROM `reviewed_files`
+WHERE `worktree_id` IN (SELECT `worktree_id` FROM `worktree_presence`);
+--> statement-breakpoint
+DROP TABLE `reviewed_files`;
+--> statement-breakpoint
+ALTER TABLE `__new_reviewed_files` RENAME TO `reviewed_files`;
+--> statement-breakpoint
+CREATE INDEX `reviewed_files_worktree` ON `reviewed_files` (`worktree_id`);
+--> statement-breakpoint
+CREATE TABLE `__new_reviewed_layers` (
+	`worktree_id` text NOT NULL,
+	`layer_id` text NOT NULL,
+	`fingerprint` text NOT NULL,
+	`reviewed_at` text NOT NULL,
+	`stale` integer DEFAULT false NOT NULL,
+	PRIMARY KEY(`worktree_id`, `layer_id`),
+	FOREIGN KEY (`worktree_id`) REFERENCES `worktree_presence`(`worktree_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_reviewed_layers` ("worktree_id", "layer_id", "fingerprint", "reviewed_at", "stale")
+SELECT "worktree_id", "layer_id", "fingerprint", "reviewed_at", "stale" FROM `reviewed_layers`
+WHERE `worktree_id` IN (SELECT `worktree_id` FROM `worktree_presence`);
+--> statement-breakpoint
+DROP TABLE `reviewed_layers`;
+--> statement-breakpoint
+ALTER TABLE `__new_reviewed_layers` RENAME TO `reviewed_layers`;
+--> statement-breakpoint
+CREATE INDEX `reviewed_layers_worktree` ON `reviewed_layers` (`worktree_id`);
+--> statement-breakpoint
+CREATE TABLE `__new_comment_threads` (
+	`sequence` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`id` text NOT NULL,
+	`worktree_id` text NOT NULL,
+	`anchor` text NOT NULL,
+	`resolved` integer NOT NULL,
+	`revision` integer NOT NULL,
+	`last_agent_revision` integer,
+	`size_bytes` integer NOT NULL,
+	FOREIGN KEY (`worktree_id`) REFERENCES `worktree_presence`(`worktree_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_comment_threads` ("sequence", "id", "worktree_id", "anchor", "resolved", "revision", "last_agent_revision", "size_bytes")
+SELECT "sequence", "id", "worktree_id", "anchor", "resolved", "revision", "last_agent_revision", "size_bytes" FROM `comment_threads`
+WHERE `worktree_id` IN (SELECT `worktree_id` FROM `worktree_presence`);
+--> statement-breakpoint
+DROP TABLE `comment_threads`;
+--> statement-breakpoint
+ALTER TABLE `__new_comment_threads` RENAME TO `comment_threads`;
+--> statement-breakpoint
+CREATE UNIQUE INDEX `comment_threads_normalized_id_unique` ON `comment_threads` (`id`);
+--> statement-breakpoint
+CREATE INDEX `comment_threads_worktree` ON `comment_threads` (`worktree_id`);
+--> statement-breakpoint
+CREATE TABLE `__new_comment_messages` (
+	`sequence` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`id` text NOT NULL,
+	`thread_id` text NOT NULL,
+	`worktree_id` text NOT NULL,
+	`body` text NOT NULL,
+	`author` text NOT NULL,
+	`created_at` text,
+	FOREIGN KEY (`thread_id`) REFERENCES `comment_threads`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`worktree_id`) REFERENCES `worktree_presence`(`worktree_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_comment_messages` ("sequence", "id", "thread_id", "worktree_id", "body", "author", "created_at")
+SELECT "sequence", "id", "thread_id", "worktree_id", "body", "author", "created_at" FROM `comment_messages`
+WHERE `thread_id` IN (SELECT `id` FROM `comment_threads`)
+	AND `worktree_id` IN (SELECT `worktree_id` FROM `worktree_presence`);
+--> statement-breakpoint
+DROP TABLE `comment_messages`;
+--> statement-breakpoint
+ALTER TABLE `__new_comment_messages` RENAME TO `comment_messages`;
+--> statement-breakpoint
+CREATE INDEX `comment_messages_id` ON `comment_messages` (`id`);
+--> statement-breakpoint
+CREATE INDEX `comment_messages_thread` ON `comment_messages` (`thread_id`,`sequence`);
+--> statement-breakpoint
+CREATE INDEX `comment_messages_worktree` ON `comment_messages` (`worktree_id`);
+--> statement-breakpoint
+CREATE TABLE `__new_comment_reads` (
+	`worktree_id` text PRIMARY KEY NOT NULL,
+	`seen_through` integer NOT NULL,
+	FOREIGN KEY (`worktree_id`) REFERENCES `worktree_presence`(`worktree_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_comment_reads` ("worktree_id", "seen_through")
+SELECT "worktree_id", "seen_through" FROM `comment_reads`
+WHERE `worktree_id` IN (SELECT `worktree_id` FROM `worktree_presence`);
+--> statement-breakpoint
+DROP TABLE `comment_reads`;
+--> statement-breakpoint
+ALTER TABLE `__new_comment_reads` RENAME TO `comment_reads`;

package/server/drizzle/0011_receipts_per_worktree.sql

@@ -0,0 +1,35 @@
+-- A Git action receipt belongs to its worktree: collecting the worktree
+-- removes it through a foreign key, as it already does for review data.
+--
+-- The worktree id was only inside the stored receipt, so it is copied into a
+-- column. A receipt whose worktree has no presence row yet is not dropped:
+-- its worktree is seeded into worktree_presence under the receipt's project
+-- and follows the same observed-absence rule as every other worktree.
+-- SQLite cannot add a foreign key to an existing table, so the table is
+-- rebuilt, with foreign key enforcement off and a foreign_key_check before
+-- commit as for every migration.
+INSERT OR IGNORE INTO `worktree_presence` (`worktree_id`, `project_id`, `missing_since`)
+SELECT DISTINCT json_extract(`value`, '$.worktreeId'), `project_id`, NULL
+FROM `git_action_receipts`
+WHERE json_type(`value`, '$.worktreeId') = 'text';
+--> statement-breakpoint
+CREATE TABLE `__new_git_action_receipts` (
+	`request_id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`worktree_id` text NOT NULL,
+	`value` text NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `inventory_projects`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`worktree_id`) REFERENCES `worktree_presence`(`worktree_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_git_action_receipts` ("request_id", "project_id", "worktree_id", "value")
+SELECT "request_id", "project_id", json_extract("value", '$.worktreeId'), "value" FROM `git_action_receipts`
+WHERE json_type("value", '$.worktreeId') = 'text';
+--> statement-breakpoint
+DROP TABLE `git_action_receipts`;
+--> statement-breakpoint
+ALTER TABLE `__new_git_action_receipts` RENAME TO `git_action_receipts`;
+--> statement-breakpoint
+CREATE INDEX `git_action_receipts_project` ON `git_action_receipts` (`project_id`);
+--> statement-breakpoint
+CREATE INDEX `git_action_receipts_worktree` ON `git_action_receipts` (`worktree_id`);

package/server/drizzle/0012_receipts_as_columns.sql

@@ -0,0 +1,68 @@
+-- A Git action receipt is stored in columns, like every other table: the
+-- fields the store filters and orders by (state, finished_at, dismissed_at)
+-- are queried directly instead of through json_extract, and project_id and
+-- worktree_id are no longer stored twice. Only the nested values stay JSON:
+-- the intent, the expectation, the result and the progress lines.
+--
+-- Every receipt is copied from its stored value. A receipt written before a
+-- field existed takes the value the current code would have read: an action
+-- from its intent, an empty expectation, no progress, and a refresh required,
+-- which is the cautious answer when the outcome is unknown. A value without a
+-- state, an intent or an acceptance time is no receipt at all and is dropped.
+-- SQLite cannot change a column list in place, so the table is rebuilt, with
+-- foreign key enforcement off and a foreign_key_check before commit as for
+-- every migration.
+CREATE TABLE `__new_git_action_receipts` (
+	`request_id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`worktree_id` text NOT NULL,
+	`action` text NOT NULL,
+	`state` text NOT NULL,
+	`reason` text,
+	`message` text,
+	`refresh_required` integer NOT NULL,
+	`accepted_at` text NOT NULL,
+	`finished_at` text,
+	`dismissed_at` text,
+	`intent` text NOT NULL,
+	`expected` text NOT NULL,
+	`result` text,
+	`progress` text NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `inventory_projects`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`worktree_id`) REFERENCES `worktree_presence`(`worktree_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_git_action_receipts` (
+	"request_id", "project_id", "worktree_id", "action", "state", "reason",
+	"message", "refresh_required", "accepted_at", "finished_at", "dismissed_at",
+	"intent", "expected", "result", "progress"
+)
+SELECT
+	"request_id",
+	"project_id",
+	"worktree_id",
+	COALESCE(json_extract("value", '$.action'), json_extract("value", '$.intent.action')),
+	json_extract("value", '$.state'),
+	json_extract("value", '$.reason'),
+	json_extract("value", '$.message'),
+	COALESCE(json_extract("value", '$.refreshRequired'), 1),
+	json_extract("value", '$.acceptedAt'),
+	json_extract("value", '$.finishedAt'),
+	json_extract("value", '$.dismissedAt'),
+	json_extract("value", '$.intent'),
+	COALESCE(json_extract("value", '$.expected'), '{}'),
+	json_extract("value", '$.result'),
+	COALESCE(json_extract("value", '$.progress'), '[]')
+FROM `git_action_receipts`
+WHERE json_type("value", '$.state') = 'text'
+	AND json_type("value", '$.intent') = 'object'
+	AND json_type("value", '$.intent.action') = 'text'
+	AND json_type("value", '$.acceptedAt') = 'text';
+--> statement-breakpoint
+DROP TABLE `git_action_receipts`;
+--> statement-breakpoint
+ALTER TABLE `__new_git_action_receipts` RENAME TO `git_action_receipts`;
+--> statement-breakpoint
+CREATE INDEX `git_action_receipts_project` ON `git_action_receipts` (`project_id`);
+--> statement-breakpoint
+CREATE INDEX `git_action_receipts_worktree` ON `git_action_receipts` (`worktree_id`);

package/server/drizzle/0013_monotonic_comment_revision.sql

@@ -0,0 +1,21 @@
+-- Comment revisions are handed out from one counter that only grows. The next
+-- revision used to be the highest revision still stored plus one, so deleting
+-- the threads that held it, by collecting a worktree or removing a project,
+-- handed the same numbers out again, and a comments-seen mark or a client that
+-- had seen the old numbers took the new threads for seen.
+--
+-- The counter starts above every revision a thread, an agent reply or a
+-- comments-seen mark still names. Numbers already reused before this migration
+-- cannot be told apart and stay as they are.
+CREATE TABLE `comment_revision` (
+	`singleton` integer PRIMARY KEY NOT NULL,
+	`revision` integer NOT NULL,
+	CONSTRAINT "comment_revision_singleton" CHECK("comment_revision"."singleton" = 1)
+);
+--> statement-breakpoint
+INSERT INTO `comment_revision` (`singleton`, `revision`)
+SELECT 1, MAX(
+	COALESCE((SELECT MAX(`revision`) FROM `comment_threads`), 0),
+	COALESCE((SELECT MAX(`last_agent_revision`) FROM `comment_threads`), 0),
+	COALESCE((SELECT MAX(`seen_through`) FROM `comment_reads`), 0)
+);

package/server/drizzle/0014_reviewed_layers_without_stale.sql

@@ -0,0 +1 @@
+ALTER TABLE `reviewed_layers` DROP COLUMN `stale`;