mockpit 1.1.0 → 1.3.0

package/dist/server/sqlStore.d.ts

@@ -1,4 +1,4 @@
-import { type Ask, type Asset, type Comment, type CommentQuery, type CommitReplyInput, type CreateAssetInput, type CreateCommentInput, type CreateMockInput, type CreatePostInput, type CreateSessionInput, type Draft, type Knobs, type Mock, type MockKind, type Post, type PostQuery, type PostStatus, type PostVersion, type Session, type Slot, type SqlStorage, type Store, type Surface, type UpdateMockInput, type UpdatePostInput } from "./types.ts";
+import { type Ask, type Asset, type Comment, type CommentQuery, type CommitReplyInput, type CreateAssetInput, type CreateCommentInput, type CreateMockInput, type CreatePostInput, type CreateSessionInput, type Draft, type Knobs, type Mock, type MockKind, type Post, type PostQuery, type PostStatus, type PostVersion, type Session, type Embed, type Flow, type FlowStep, type ForkRef, type SqlStorage, type Store, type Surface, type UpdateMockInput, type UpdatePostInput } from "./types.ts";
 export declare class SqlStore implements Store {
     private sql;
     private assetRefCache;
@@ -26,7 +26,7 @@ export declare class SqlStore implements Store {
     private rowToPost;
     private rowToAsset;
     private rowToComment;
-    listSessions(): Promise<Session[]>;
+    listSessions(project?: string): Promise<Session[]>;
     getSession(id: string): Promise<Session | null>;
     getSessionByKey(key: string): Promise<Session | null>;
     createSession(input: CreateSessionInput): Promise<Session>;
@@ -34,6 +34,8 @@ export declare class SqlStore implements Store {
     removeSession(id: string): Promise<boolean>;
     private touch;
     markAgentSeen(sessionId: string, seq: number): Promise<void>;
+    touchAgent(sessionId: string): Promise<void>;
+    handOff(sessionId: string, seen: Pick<Session, "agentSeq" | "agentActiveAt">, toSeq: number): Promise<boolean>;
     getSetting(key: string): Promise<string | null>;
     setSetting(key: string, value: string): Promise<void>;
     listProjects(): Promise<import("./types.ts").ProjectSummary[]>;
@@ -43,6 +45,10 @@ export declare class SqlStore implements Store {
     createMock(input: CreateMockInput): Promise<Mock>;
     updateMock(id: string, patch: UpdateMockInput): Promise<Mock | null>;
     removeMock(id: string): Promise<boolean>;
+    private flowsOf;
+    private writeFlow;
+    listFlows(project: string): Promise<Flow[]>;
+    placeFlowStep(project: string, name: string, screen: FlowStep, step: number): Promise<Flow | null>;
     putDraft(mockId: string, draft: Draft | null): Promise<{
         draft: Draft | null;
         id: string;
@@ -53,7 +59,9 @@ export declare class SqlStore implements Store {
         states: string[];
         asks: Ask[];
         knobs: Knobs;
+        widths: number[];
         sessionId: string | null;
+        resolvedAt: string | null;
         createdAt: string;
         updatedAt: string;
     } | null>;
@@ -65,13 +73,14 @@ export declare class SqlStore implements Store {
     createPost(input: CreatePostInput): Promise<Post | null>;
     updatePost(id: string, patch: UpdatePostInput): Promise<{
         author?: string | undefined;
-        slots: Slot[];
+        embeds: Embed[];
         state: string | null;
         version: number;
         updatedAt: string;
         history: PostVersion[];
         from: number;
         prompt: string;
+        note?: string | undefined;
         knobs?: Knobs | undefined;
         title: string;
         surfaces: Surface[];
@@ -81,9 +90,13 @@ export declare class SqlStore implements Store {
         variant: string;
         status: PostStatus;
         createdAt: string;
+        forkedFrom?: ForkRef;
+        starred?: true;
+        acceptedVersion?: number;
+        hiddenVersions?: number[];
     } | null>;
     removePost(id: string): Promise<boolean>;
-    setPostStatus(id: string, status: PostStatus): Promise<{
+    setPostStatus(id: string, status: PostStatus, acceptedVersion?: number): Promise<{
         status: PostStatus;
         id: string;
         sessionId: string;
@@ -97,11 +110,85 @@ export declare class SqlStore implements Store {
         version: number;
         history: PostVersion[];
         knobs?: Knobs;
-        slots: Slot[];
+        note?: string;
+        embeds: Embed[];
+        forkedFrom?: ForkRef;
+        starred?: true;
+        hiddenVersions?: number[];
+        from?: number;
+        prompt?: string;
+        author?: string;
+    } | {
+        status: PostStatus;
+        acceptedVersion: number;
+        id: string;
+        sessionId: string;
+        mock: string;
+        state: string | null;
+        variant: string;
+        title: string;
+        surfaces: Surface[];
+        createdAt: string;
+        updatedAt: string;
+        version: number;
+        history: PostVersion[];
+        knobs?: Knobs;
+        note?: string;
+        embeds: Embed[];
+        forkedFrom?: ForkRef;
+        starred?: true;
+        hiddenVersions?: number[];
+        from?: number;
+        prompt?: string;
+        author?: string;
+    } | null>;
+    setPostStarred(id: string, starred: boolean): Promise<{
+        id: string;
+        sessionId: string;
+        mock: string;
+        state: string | null;
+        variant: string;
+        status: PostStatus;
+        title: string;
+        surfaces: Surface[];
+        createdAt: string;
+        updatedAt: string;
+        version: number;
+        history: PostVersion[];
+        knobs?: Knobs;
+        note?: string;
+        embeds: Embed[];
+        forkedFrom?: ForkRef;
+        acceptedVersion?: number;
+        hiddenVersions?: number[];
+        from?: number;
+        prompt?: string;
+        author?: string;
+    } | {
+        starred: true;
+        id: string;
+        sessionId: string;
+        mock: string;
+        state: string | null;
+        variant: string;
+        status: PostStatus;
+        title: string;
+        surfaces: Surface[];
+        createdAt: string;
+        updatedAt: string;
+        version: number;
+        history: PostVersion[];
+        knobs?: Knobs;
+        note?: string;
+        embeds: Embed[];
+        forkedFrom?: ForkRef;
+        acceptedVersion?: number;
+        hiddenVersions?: number[];
         from?: number;
         prompt?: string;
         author?: string;
     } | null>;
+    setVersionHidden(id: string, version: number, hidden: boolean): Promise<Post | null>;
     listComments(query: CommentQuery): Promise<Comment[]>;
     private insertComment;
     createComment(input: CreateCommentInput): Promise<Comment | null>;

package/dist/server/sqlStore.js

@@ -1,4 +1,4 @@
-import { collectAssetIds, DEFAULT_PROJECT, DEFAULT_VARIANT, hashAssetId, HISTORY_LIMIT, htmlSurface, MAX_WORKSPACE_ASSET_BYTES, newId, normalizeSurfaceIds, projectFromCwd, reservedAgent, selectEvictions, slugify, stripNul, summarizeProjects, } from "./types.js";
+import { collectAssetIds, collectAttachedIds, DEFAULT_PROJECT, DEFAULT_VARIANT, hashAssetId, HISTORY_LIMIT, htmlSurface, MAX_WORKSPACE_ASSET_BYTES, newId, normalizeSurfaceIds, projectFromCwd, reservedAgent, sameScreen, selectEvictions, slugify, stripNul, summarizeProjects, } from "./types.js";
 function parseJson(raw, fallback) {
     if (typeof raw !== "string" || !raw)
         return fallback;
@@ -14,7 +14,7 @@ const POST_COLUMNS = `
   variant TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'open', title TEXT NOT NULL,
   surfaces TEXT NOT NULL, knobs TEXT, slots TEXT NOT NULL DEFAULT '[]',
   createdAt TEXT NOT NULL, updatedAt TEXT NOT NULL, version INTEGER NOT NULL,
-  curFrom INTEGER, curPrompt TEXT, curAuthor TEXT`;
+  curFrom INTEGER, curPrompt TEXT, curAuthor TEXT, note TEXT`;
 // Store implementation on SQLite — a Durable Object's `ctx.storage.sql` in the
 // Worker, or node:sqlite via an adapter on Node (see server/sqliteStorage.ts).
 // One workspace = one database, so plain SQL with no tenant columns.
@@ -65,13 +65,14 @@ export class SqlStore {
       CREATE TABLE IF NOT EXISTS sessions (
         id TEXT PRIMARY KEY, agent TEXT NOT NULL, title TEXT, cwd TEXT,
         createdAt TEXT NOT NULL, lastActiveAt TEXT NOT NULL,
-        agentSeq INTEGER NOT NULL DEFAULT 0, project TEXT, key TEXT
+        agentSeq INTEGER NOT NULL DEFAULT 0, project TEXT, key TEXT, agentActiveAt TEXT
       );
       CREATE TABLE IF NOT EXISTS mocks (
         id TEXT PRIMARY KEY, project TEXT NOT NULL, slug TEXT NOT NULL, title TEXT NOT NULL,
         kind TEXT NOT NULL DEFAULT 'component', states TEXT NOT NULL DEFAULT '[]',
         asks TEXT NOT NULL DEFAULT '[]', knobs TEXT NOT NULL DEFAULT '{}', draft TEXT,
-        sessionId TEXT, createdAt TEXT NOT NULL, updatedAt TEXT NOT NULL
+        sessionId TEXT, createdAt TEXT NOT NULL, updatedAt TEXT NOT NULL,
+        widths TEXT NOT NULL DEFAULT '[]'
       );
       CREATE TABLE IF NOT EXISTS posts (${POST_COLUMNS});
       CREATE TABLE IF NOT EXISTS post_versions (
@@ -95,14 +96,34 @@ export class SqlStore {
       CREATE TABLE IF NOT EXISTS settings (
         key TEXT PRIMARY KEY, value TEXT NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS flows (
+        project TEXT NOT NULL, name TEXT NOT NULL, steps TEXT NOT NULL DEFAULT '[]',
+        createdAt TEXT NOT NULL, updatedAt TEXT NOT NULL,
+        PRIMARY KEY (project, name)
+      );
     `);
         this.addMissing("sessions", {
             agentSeq: "INTEGER NOT NULL DEFAULT 0",
             project: "TEXT",
             key: "TEXT",
+            agentActiveAt: "TEXT",
         });
+        this.addMissing("mocks", { widths: "TEXT NOT NULL DEFAULT '[]'", resolvedAt: "TEXT" });
         if (legacy)
             this.migrateLegacy();
+        // After the legacy lift, which rebuilds posts from POST_COLUMNS alone.
+        const pinned = this.columns("posts").has("acceptedVersion");
+        this.addMissing("posts", {
+            note: "TEXT",
+            forkedFrom: "TEXT",
+            starred: "INTEGER NOT NULL DEFAULT 0",
+            acceptedVersion: "INTEGER",
+            hiddenVersions: "TEXT",
+        });
+        // Before the pin, accepted meant "its latest": freeze that as the version in use.
+        if (!pinned) {
+            this.sql.exec("UPDATE posts SET acceptedVersion = version WHERE status = 'accepted'");
+        }
         this.createIndexes();
     }
     createIndexes() {
@@ -381,6 +402,8 @@ export class SqlStore {
             lastActiveAt: r.lastActiveAt,
             agentSeq: r.agentSeq ?? 0,
             project: r.project ?? null,
+            agentActiveAt: r.agentActiveAt ?? null,
+            keyed: r.key != null,
         };
     }
     rowToMock(r) {
@@ -393,14 +416,17 @@ export class SqlStore {
             states: parseJson(r.states, []),
             asks: parseJson(r.asks, []),
             knobs: parseJson(r.knobs, {}),
+            widths: parseJson(r.widths, []),
             draft: parseJson(r.draft, null),
             sessionId: r.sessionId ?? null,
+            resolvedAt: r.resolvedAt ?? null,
             createdAt: r.createdAt,
             updatedAt: r.updatedAt,
         };
     }
     rowToPost(r, history) {
         const knobs = parseJson(r.knobs, null);
+        const hidden = parseJson(r.hiddenVersions, []);
         return {
             id: r.id,
             sessionId: r.sessionId,
@@ -415,7 +441,15 @@ export class SqlStore {
             version: r.version,
             history,
             ...(knobs ? { knobs } : {}),
-            slots: parseJson(r.slots, []),
+            ...(r.note == null ? {} : { note: r.note }),
+            // The column keeps its first name, from when embeds were called slots.
+            embeds: parseJson(r.slots, []),
+            ...(r.forkedFrom == null ? {} : { forkedFrom: parseJson(r.forkedFrom, null) }),
+            ...(r.starred ? { starred: true } : {}),
+            ...(r.status === "accepted" && r.acceptedVersion != null
+                ? { acceptedVersion: r.acceptedVersion }
+                : {}),
+            ...(hidden.length ? { hiddenVersions: hidden } : {}),
             ...(r.curFrom == null ? {} : { from: r.curFrom }),
             ...(r.curPrompt == null ? {} : { prompt: r.curPrompt }),
             ...(r.curAuthor == null ? {} : { author: r.curAuthor }),
@@ -458,11 +492,13 @@ export class SqlStore {
         };
     }
     // --- sessions ---
-    async listSessions() {
-        return this.sql
-            .exec("SELECT * FROM sessions ORDER BY lastActiveAt DESC")
-            .toArray()
-            .map((r) => this.rowToSession(r));
+    async listSessions(project) {
+        const rows = project === undefined
+            ? this.sql.exec("SELECT * FROM sessions ORDER BY lastActiveAt DESC").toArray()
+            : this.sql
+                .exec("SELECT * FROM sessions WHERE project = ? ORDER BY lastActiveAt DESC", project)
+                .toArray();
+        return rows.map((r) => this.rowToSession(r));
     }
     async getSession(id) {
         const rows = this.sql.exec("SELECT * FROM sessions WHERE id = ?", id).toArray();
@@ -485,8 +521,10 @@ export class SqlStore {
             lastActiveAt: now,
             agentSeq: 0,
             project: stripNul(input.project)?.trim() || projectFromCwd(stripNul(input.cwd ?? null)) || null,
+            agentActiveAt: now,
+            keyed: !!stripNul(input.key)?.trim(),
         };
-        this.sql.exec("INSERT INTO sessions (id, agent, title, cwd, createdAt, lastActiveAt, agentSeq, project, key) VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)", session.id, session.agent, session.title, session.cwd, session.createdAt, session.lastActiveAt, session.project, stripNul(input.key)?.trim() || null);
+        this.sql.exec("INSERT INTO sessions (id, agent, title, cwd, createdAt, lastActiveAt, agentSeq, project, key, agentActiveAt) VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?)", session.id, session.agent, session.title, session.cwd, session.createdAt, session.lastActiveAt, session.project, stripNul(input.key)?.trim() || null, session.agentActiveAt);
         return session;
     }
     async renameSession(id, title) {
@@ -528,6 +566,14 @@ export class SqlStore {
     async markAgentSeen(sessionId, seq) {
         this.sql.exec("UPDATE sessions SET agentSeq = ? WHERE id = ? AND agentSeq < ?", seq, sessionId, seq);
     }
+    async touchAgent(sessionId) {
+        this.sql.exec("UPDATE sessions SET agentActiveAt = ? WHERE id = ?", new Date().toISOString(), sessionId);
+    }
+    async handOff(sessionId, seen, toSeq) {
+        return (this.sql
+            .exec("UPDATE sessions SET agentSeq = ? WHERE id = ? AND agentSeq = ? AND agentActiveAt IS ? AND agentSeq < ? RETURNING id", toSeq, sessionId, seen.agentSeq, seen.agentActiveAt, toSeq)
+            .toArray().length > 0);
+    }
     // --- settings ---
     async getSetting(key) {
         return this.settingSync(key);
@@ -570,12 +616,14 @@ export class SqlStore {
             states: (input.states ?? []).map((s) => stripNul(s)),
             asks: [],
             knobs: input.knobs ?? {},
+            widths: input.widths ?? [],
             draft: null,
             sessionId: input.sessionId ?? null,
+            resolvedAt: null,
             createdAt: now,
             updatedAt: now,
         };
-        this.sql.exec("INSERT INTO mocks (id, project, slug, title, kind, states, asks, knobs, draft, sessionId, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?, '[]', ?, NULL, ?, ?, ?)", mock.id, mock.project, mock.slug, mock.title, mock.kind, JSON.stringify(mock.states), JSON.stringify(mock.knobs), mock.sessionId, mock.createdAt, mock.updatedAt);
+        this.sql.exec("INSERT INTO mocks (id, project, slug, title, kind, states, asks, knobs, widths, draft, sessionId, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?, '[]', ?, ?, NULL, ?, ?, ?)", mock.id, mock.project, mock.slug, mock.title, mock.kind, JSON.stringify(mock.states), JSON.stringify(mock.knobs), JSON.stringify(mock.widths), mock.sessionId, mock.createdAt, mock.updatedAt);
         return mock;
     }
     async updateMock(id, patch) {
@@ -589,29 +637,86 @@ export class SqlStore {
             ...(patch.states !== undefined && { states: patch.states.map((s) => stripNul(s)) }),
             ...(patch.asks !== undefined && { asks: patch.asks }),
             ...(patch.knobs !== undefined && { knobs: patch.knobs }),
+            ...(patch.widths !== undefined && { widths: patch.widths }),
             ...(patch.sessionId !== undefined && { sessionId: patch.sessionId }),
+            ...(patch.resolvedAt !== undefined && { resolvedAt: patch.resolvedAt }),
             updatedAt: new Date().toISOString(),
         };
-        this.sql.exec("UPDATE mocks SET title = ?, kind = ?, states = ?, asks = ?, knobs = ?, sessionId = ?, updatedAt = ? WHERE id = ?", next.title, next.kind, JSON.stringify(next.states), JSON.stringify(next.asks), JSON.stringify(next.knobs), next.sessionId, next.updatedAt, id);
+        this.sql.exec("UPDATE mocks SET title = ?, kind = ?, states = ?, asks = ?, knobs = ?, widths = ?, sessionId = ?, resolvedAt = ?, updatedAt = ? WHERE id = ?", next.title, next.kind, JSON.stringify(next.states), JSON.stringify(next.asks), JSON.stringify(next.knobs), JSON.stringify(next.widths), next.sessionId, next.resolvedAt, next.updatedAt, id);
+        if (patch.asks !== undefined)
+            this.invalidateAssetRefs();
         return next;
     }
     async removeMock(id) {
-        if (!(await this.getMock(id)))
+        const mock = await this.getMock(id);
+        if (!mock)
             return false;
         this.atomic(() => {
             this.sql.exec("DELETE FROM comments WHERE mockId = ?", id);
             this.sql.exec("DELETE FROM post_versions WHERE postId IN (SELECT id FROM posts WHERE mockId = ?)", id);
             this.sql.exec("DELETE FROM posts WHERE mockId = ?", id);
             this.sql.exec("DELETE FROM mocks WHERE id = ?", id);
+            for (const flow of this.flowsOf(mock.project)) {
+                const steps = flow.steps.filter((x) => x.mock !== mock.slug);
+                if (steps.length !== flow.steps.length)
+                    this.writeFlow(flow, steps);
+            }
         });
         this.invalidateAssetRefs();
         return true;
     }
+    // --- flows ---
+    flowsOf(project) {
+        return this.sql
+            .exec("SELECT * FROM flows WHERE project = ? ORDER BY createdAt, rowid", project)
+            .toArray()
+            .map((r) => ({
+            project: r.project,
+            name: r.name,
+            steps: parseJson(r.steps, []),
+            createdAt: r.createdAt,
+            updatedAt: r.updatedAt,
+        }));
+    }
+    // An emptied flow is deleted rather than kept as a name with nothing to walk.
+    writeFlow(flow, steps) {
+        if (steps.length === 0) {
+            this.sql.exec("DELETE FROM flows WHERE project = ? AND name = ?", flow.project, flow.name);
+            return null;
+        }
+        const next = { ...flow, steps, updatedAt: new Date().toISOString() };
+        this.sql.exec("INSERT INTO flows (project, name, steps, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?) ON CONFLICT(project, name) DO UPDATE SET steps = excluded.steps, updatedAt = excluded.updatedAt", next.project, next.name, JSON.stringify(next.steps), next.createdAt, next.updatedAt);
+        return next;
+    }
+    async listFlows(project) {
+        return this.flowsOf(project);
+    }
+    async placeFlowStep(project, name, screen, step) {
+        const clean = { mock: stripNul(screen.mock), state: stripNul(screen.state) };
+        const label = stripNul(name);
+        return this.atomic(() => {
+            const now = new Date().toISOString();
+            const flow = this.flowsOf(project).find((f) => f.name === label) ?? {
+                project,
+                name: label,
+                steps: [],
+                createdAt: now,
+                updatedAt: now,
+            };
+            const steps = flow.steps.filter((x) => !sameScreen(x, clean));
+            if (step > 0)
+                steps.splice(Math.min(step, steps.length + 1) - 1, 0, clean);
+            if (steps.length === 0 && flow.steps.length === 0)
+                return null;
+            return this.writeFlow(flow, steps);
+        });
+    }
     async putDraft(mockId, draft) {
         const mock = await this.getMock(mockId);
         if (!mock)
             return null;
         this.sql.exec("UPDATE mocks SET draft = ? WHERE id = ?", draft ? JSON.stringify(draft) : null, mockId);
+        this.invalidateAssetRefs();
         return { ...mock, draft };
     }
     touchMock(mockId, at) {
@@ -674,12 +779,14 @@ export class SqlStore {
             version: 1,
             history: [],
             ...(input.knobs ? { knobs: input.knobs } : {}),
-            slots: input.slots ?? [],
+            ...(stripNul(input.note ?? "").trim() ? { note: stripNul(input.note ?? "").trim() } : {}),
+            embeds: input.embeds ?? [],
+            ...(input.forkedFrom ? { forkedFrom: input.forkedFrom } : {}),
             ...(input.from === undefined ? {} : { from: input.from }),
             ...(input.prompt === undefined ? {} : { prompt: stripNul(input.prompt) }),
             ...(input.author === undefined ? {} : { author: stripNul(input.author) }),
         };
-        this.sql.exec("INSERT INTO posts (id, sessionId, mockId, state, variant, status, title, surfaces, knobs, slots, createdAt, updatedAt, version, curFrom, curPrompt, curAuthor) VALUES (?, ?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)", post.id, post.sessionId, post.mock, post.state, post.variant, post.title, JSON.stringify(post.surfaces), post.knobs ? JSON.stringify(post.knobs) : null, JSON.stringify(post.slots), post.createdAt, post.updatedAt, post.from ?? null, post.prompt ?? null, post.author ?? null);
+        this.sql.exec("INSERT INTO posts (id, sessionId, mockId, state, variant, status, title, surfaces, knobs, slots, createdAt, updatedAt, version, curFrom, curPrompt, curAuthor, note, forkedFrom) VALUES (?, ?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?)", post.id, post.sessionId, post.mock, post.state, post.variant, post.title, JSON.stringify(post.surfaces), post.knobs ? JSON.stringify(post.knobs) : null, JSON.stringify(post.embeds), post.createdAt, post.updatedAt, post.from ?? null, post.prompt ?? null, post.author ?? null, post.note ?? null, post.forkedFrom ? JSON.stringify(post.forkedFrom) : null);
         this.touch(input.sessionId);
         this.touchMock(post.mock, now);
         this.addAssetRefs(post.surfaces);
@@ -701,13 +808,17 @@ export class SqlStore {
                 ...(post.prompt === undefined ? {} : { prompt: post.prompt }),
                 ...(post.author === undefined ? {} : { author: post.author }),
             };
+            // The version in use is kept past the limit: export and embeds resolve to it.
+            const pin = post.acceptedVersion ?? -1;
             const history = [...post.history, archived];
-            if (history.length > HISTORY_LIMIT)
-                history.shift();
+            const prunable = history.filter((h) => h.version !== pin);
+            if (prunable.length > HISTORY_LIMIT)
+                history.splice(history.indexOf(prunable[0]), 1);
             const title = patch.title !== undefined ? stripNul(patch.title).trim() || post.title : post.title;
             const surfaces = patch.surfaces !== undefined ? normalizeSurfaceIds(patch.surfaces) : post.surfaces;
             const knobs = patch.knobs === undefined ? post.knobs : (patch.knobs ?? undefined);
-            const slots = patch.slots ?? post.slots;
+            const note = patch.note === undefined ? post.note : stripNul(patch.note).trim() || undefined;
+            const embeds = patch.embeds ?? post.embeds;
             const state = patch.state === undefined ? post.state : patch.state;
             const version = post.version + 1;
             const updatedAt = new Date().toISOString();
@@ -715,22 +826,23 @@ export class SqlStore {
             const from = patch.from ?? post.version;
             const prompt = stripNul(patch.prompt ?? "");
             const author = patch.author === undefined ? null : stripNul(patch.author);
-            this.sql.exec("UPDATE posts SET title = ?, surfaces = ?, knobs = ?, slots = ?, state = ?, updatedAt = ?, version = ?, curFrom = ?, curPrompt = ?, curAuthor = ? WHERE id = ? AND version = ?", title, JSON.stringify(surfaces), knobs ? JSON.stringify(knobs) : null, JSON.stringify(slots), state, updatedAt, version, from, prompt, author, id, post.version);
+            this.sql.exec("UPDATE posts SET title = ?, surfaces = ?, knobs = ?, note = ?, slots = ?, state = ?, updatedAt = ?, version = ?, curFrom = ?, curPrompt = ?, curAuthor = ? WHERE id = ? AND version = ?", title, JSON.stringify(surfaces), knobs ? JSON.stringify(knobs) : null, note ?? null, JSON.stringify(embeds), state, updatedAt, version, from, prompt, author, id, post.version);
             const affected = this.sql.exec("SELECT changes() AS n").one().n;
             if (affected > 0) {
                 this.insertVersion(id, archived);
-                this.sql.exec("DELETE FROM post_versions WHERE postId = ? AND version <= ?", id, version - 1 - HISTORY_LIMIT);
+                this.sql.exec("DELETE FROM post_versions WHERE postId = ? AND version <= ? AND version != ?", id, version - 1 - HISTORY_LIMIT, pin);
                 this.touch(post.sessionId);
                 this.touchMock(post.mock, updatedAt);
                 if (patch.surfaces !== undefined)
                     this.addAssetRefs(surfaces);
-                const { knobs: _knobs, author: _author, ...rest } = post;
+                const { knobs: _knobs, note: _note, author: _author, ...rest } = post;
                 return {
                     ...rest,
                     title,
                     surfaces,
                     ...(knobs ? { knobs } : {}),
-                    slots,
+                    ...(note ? { note } : {}),
+                    embeds,
                     state,
                     version,
                     updatedAt,
@@ -754,12 +866,36 @@ export class SqlStore {
         this.invalidateAssetRefs();
         return true;
     }
-    async setPostStatus(id, status) {
+    async setPostStatus(id, status, acceptedVersion) {
+        const post = await this.getPost(id);
+        if (!post)
+            return null;
+        const pin = status === "accepted" ? (acceptedVersion ?? post.version) : null;
+        this.sql.exec("UPDATE posts SET status = ?, acceptedVersion = ? WHERE id = ?", status, pin, id);
+        const { acceptedVersion: _, ...rest } = post;
+        return pin === null ? { ...rest, status } : { ...rest, status, acceptedVersion: pin };
+    }
+    async setPostStarred(id, starred) {
         const post = await this.getPost(id);
         if (!post)
             return null;
-        this.sql.exec("UPDATE posts SET status = ? WHERE id = ?", status, id);
-        return { ...post, status };
+        this.sql.exec("UPDATE posts SET starred = ? WHERE id = ?", starred ? 1 : 0, id);
+        const { starred: _, ...rest } = post;
+        return starred ? { ...rest, starred: true } : rest;
+    }
+    async setVersionHidden(id, version, hidden) {
+        const post = await this.getPost(id);
+        if (!post)
+            return null;
+        const set = new Set(post.hiddenVersions ?? []);
+        if (hidden)
+            set.add(version);
+        else
+            set.delete(version);
+        const list = [...set].sort((a, b) => a - b);
+        this.sql.exec("UPDATE posts SET hiddenVersions = ? WHERE id = ?", list.length ? JSON.stringify(list) : null, id);
+        const { hiddenVersions: _, ...rest } = post;
+        return list.length ? { ...rest, hiddenVersions: list } : rest;
     }
     // --- comments ---
     async listComments(query) {
@@ -826,6 +962,8 @@ export class SqlStore {
             return null;
         const comment = this.rowToComment(rows[0]);
         this.sql.exec("DELETE FROM comments WHERE id = ?", id);
+        if (comment.kind === "reply")
+            this.invalidateAssetRefs();
         this.touch(comment.sessionId);
         return comment;
     }
@@ -844,13 +982,22 @@ export class SqlStore {
                 postVersion: input.payload.version,
                 payload: input.payload,
             });
-            this.sql.exec("UPDATE mocks SET asks = ?, draft = NULL WHERE id = ?", JSON.stringify(input.asks), input.mockId);
-            for (const id of input.accept) {
-                this.sql.exec("UPDATE posts SET status = 'accepted' WHERE id = ? AND mockId = ?", id, input.mockId);
+            this.sql.exec(input.keepDraft
+                ? "UPDATE mocks SET asks = ? WHERE id = ?"
+                : "UPDATE mocks SET asks = ?, draft = NULL WHERE id = ?", JSON.stringify(input.asks), input.mockId);
+            if (input.resolvedAt !== undefined) {
+                this.sql.exec("UPDATE mocks SET resolvedAt = ?, updatedAt = ? WHERE id = ?", input.resolvedAt, input.resolvedAt, input.mockId);
+            }
+            for (const { id, version } of input.accept) {
+                this.sql.exec("UPDATE posts SET status = 'accepted', acceptedVersion = ? WHERE id = ? AND mockId = ?", version, id, input.mockId);
             }
             for (const id of input.archive) {
-                this.sql.exec("UPDATE posts SET status = 'archived' WHERE id = ? AND mockId = ?", id, input.mockId);
+                this.sql.exec("UPDATE posts SET status = 'archived', acceptedVersion = NULL WHERE id = ? AND mockId = ?", id, input.mockId);
             }
+            for (const id of input.drop ?? []) {
+                this.sql.exec("UPDATE posts SET status = 'dropped', acceptedVersion = NULL WHERE id = ? AND mockId = ?", id, input.mockId);
+            }
+            this.invalidateAssetRefs();
             return comment;
         });
     }
@@ -865,6 +1012,17 @@ export class SqlStore {
         for (const r of this.sql.exec("SELECT surfaces FROM post_versions").toArray()) {
             collectAssetIds(parseJson(r.surfaces, []), out);
         }
+        // The user's attachments: in a draft, in a sent reply, on an answered ask.
+        for (const r of this.sql.exec("SELECT asks, draft FROM mocks").toArray()) {
+            collectAttachedIds(parseJson(r.draft, null), out);
+            for (const ask of parseJson(r.asks, []))
+                collectAttachedIds(ask, out);
+        }
+        for (const r of this.sql
+            .exec("SELECT payload FROM comments WHERE kind = 'reply' AND payload IS NOT NULL")
+            .toArray()) {
+            collectAttachedIds(parseJson(r.payload, null), out);
+        }
         // An installed icon set is referenced by its project's design, not by a
         // surface; evicting it would blank that project's icons.
         for (const r of this.sql