mockpit 1.2.0 → 2.0.0

package/dist/server/sqlStore.js

@@ -1,4 +1,10 @@
-import { collectAssetIds, collectAttachedIds, 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, isMockKind, newId, normalizeSurfaceIds, projectFromCwd, AREA_ORDER_SETTING, reservedAgent, sameScreen, selectEvictions, slugify, stripNul, summarizeProjects, } from "./types.js";
+import { renameSlugRefs } from "./embeds.js";
+import { RULES_SETTING } from "./guidance.js";
+// The settings keyed `<prefix>:<project>`, which a project rename carries.
+const PROJECT_SETTINGS = ["design", AREA_ORDER_SETTING, RULES_SETTING];
+// An optional free-text label: blank means none.
+const label = (v) => stripNul(v ?? "").trim() || null;
 function parseJson(raw, fallback) {
     if (typeof raw !== "string" || !raw)
         return fallback;
@@ -9,12 +15,41 @@ function parseJson(raw, fallback) {
         return fallback;
     }
 }
+// A stored reply in the current names, or null when it already uses them.
+function contractReply(payload) {
+    if (!("mix" in payload) && !("decision" in payload) && !("resolved" in payload))
+        return null;
+    const { mix, decision, resolved, ...rest } = payload;
+    const out = { ...rest };
+    if (mix !== undefined)
+        out.borrowed = mix;
+    const kind = decision?.kind;
+    if (kind === "accept" || kind === "revise") {
+        out.verdict = { ...decision, kind: kind === "accept" ? "use" : "revise" };
+    }
+    if (resolved !== undefined)
+        out.closed = resolved;
+    return out;
+}
+// `surfaces` with every `<mockpit-slot>` tag spelled `<mockpit-embed>`, or null
+// when none has one. Only html is markup; a code or markdown surface may quote
+// the tag as text.
+function slotTagsToEmbed(surfaces) {
+    let changed = false;
+    const out = surfaces.map((s) => {
+        if (s.kind !== "html" || !/<\/?mockpit-slot\b/i.test(s.html))
+            return s;
+        changed = true;
+        return { ...s, html: s.html.replace(/<(\/?)mockpit-slot\b/gi, "<$1mockpit-embed") };
+    });
+    return changed ? out : null;
+}
 const POST_COLUMNS = `
   id TEXT PRIMARY KEY, sessionId TEXT NOT NULL, mockId TEXT NOT NULL, state TEXT,
   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.
@@ -69,9 +104,10 @@ export class SqlStore {
       );
       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 '[]',
+        kind TEXT NOT NULL DEFAULT 'sketch', 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,6 +131,11 @@ 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",
@@ -102,10 +143,84 @@ export class SqlStore {
             key: "TEXT",
             agentActiveAt: "TEXT",
         });
+        // The close column's first name.
+        const mockCols = this.columns("mocks");
+        if (mockCols.has("resolvedAt") && !mockCols.has("closedAt")) {
+            this.sql.exec("ALTER TABLE mocks RENAME COLUMN resolvedAt TO closedAt");
+        }
+        this.addMissing("mocks", {
+            widths: "TEXT NOT NULL DEFAULT '[]'",
+            closedAt: "TEXT",
+            area: "TEXT",
+            source: "TEXT",
+            situations: "TEXT NOT NULL DEFAULT '{}'",
+        });
         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'");
+        }
+        if (this.settingSync("sketchKind") !== "1")
+            this.migrateToSketches();
+        if (this.settingSync("contractTerms") !== "1")
+            this.migrateToContractTerms();
         this.createIndexes();
     }
+    // The agent contract renamed what replies and drafts store (mix → borrowed,
+    // decision → verdict with accept → use, resolved → closed) and retired drop
+    // and the `<mockpit-slot>` embed alias. Stored data is rewritten once, here,
+    // so nothing past the store reads an old name: a dropped variant is archived
+    // (both were hidden from the choice and restorable), a drop verdict loses its
+    // verdict (the variant's archived status says the rest), and every stored
+    // version spells its embeds `<mockpit-embed>` so it still renders them.
+    migrateToContractTerms() {
+        this.sql.exec("UPDATE posts SET status = 'archived', acceptedVersion = NULL WHERE status = 'dropped'");
+        for (const r of this.sql
+            .exec("SELECT seq, payload FROM comments WHERE kind = 'reply' AND payload IS NOT NULL")
+            .toArray()) {
+            const payload = parseJson(r.payload, null);
+            const next = payload && contractReply(payload);
+            if (next) {
+                this.sql.exec("UPDATE comments SET payload = ? WHERE seq = ?", JSON.stringify(next), r.seq);
+            }
+        }
+        for (const r of this.sql
+            .exec("SELECT id, draft FROM mocks WHERE draft IS NOT NULL")
+            .toArray()) {
+            const draft = parseJson(r.draft, null);
+            if (!draft || !("mix" in draft))
+                continue;
+            const { mix, ...rest } = draft;
+            this.sql.exec("UPDATE mocks SET draft = ? WHERE id = ?", JSON.stringify({ ...rest, borrowed: mix ?? {} }), r.id);
+        }
+        for (const r of this.sql
+            .exec("SELECT id, surfaces FROM posts WHERE surfaces LIKE '%mockpit-slot%'")
+            .toArray()) {
+            const surfaces = slotTagsToEmbed(parseJson(r.surfaces, []));
+            if (surfaces) {
+                this.sql.exec("UPDATE posts SET surfaces = ? WHERE id = ?", JSON.stringify(surfaces), r.id);
+            }
+        }
+        for (const r of this.sql
+            .exec("SELECT postId, version, surfaces FROM post_versions WHERE surfaces LIKE '%mockpit-slot%'")
+            .toArray()) {
+            const surfaces = slotTagsToEmbed(parseJson(r.surfaces, []));
+            if (surfaces) {
+                this.sql.exec("UPDATE post_versions SET surfaces = ? WHERE postId = ? AND version = ?", JSON.stringify(surfaces), r.postId, r.version);
+            }
+        }
+        this.sql.exec("INSERT OR REPLACE INTO settings (key, value) VALUES ('contractTerms', '1')");
+    }
     createIndexes() {
         this.sql.exec(`
       CREATE UNIQUE INDEX IF NOT EXISTS mockpit_mocks_slug_idx ON mocks (project, slug);
@@ -316,7 +431,7 @@ export class SqlStore {
                 draft = {
                     version: 1,
                     answers: {},
-                    mix: {},
+                    borrowed: {},
                     tuned: {},
                     comments: [],
                     updatedAt: c.createdAt,
@@ -332,6 +447,33 @@ export class SqlStore {
         }
         this.sql.exec("DELETE FROM comments WHERE draft = 1");
     }
+    // A mock no one declared used to be a component. Keep that only where it acts
+    // as one, embedded somewhere or a step of a flow; the rest become sketches.
+    migrateToSketches() {
+        const projectOf = new Map();
+        for (const r of this.sql.exec("SELECT id, project FROM mocks").toArray()) {
+            projectOf.set(r.id, r.project);
+        }
+        const used = new Set();
+        for (const r of this.sql.exec("SELECT mockId, slots FROM posts").toArray()) {
+            const project = projectOf.get(r.mockId);
+            for (const e of parseJson(r.slots, []))
+                used.add(`${project}\u0000${e.slug}`);
+        }
+        for (const r of this.sql.exec("SELECT project, steps FROM flows").toArray()) {
+            for (const x of parseJson(r.steps, [])) {
+                used.add(`${r.project}\u0000${x.mock}`);
+            }
+        }
+        for (const r of this.sql
+            .exec("SELECT id, project, slug FROM mocks WHERE kind = 'component'")
+            .toArray()) {
+            if (used.has(`${r.project}\u0000${r.slug}`))
+                continue;
+            this.sql.exec("UPDATE mocks SET kind = 'sketch' WHERE id = ?", r.id);
+        }
+        this.sql.exec("INSERT OR REPLACE INTO settings (key, value) VALUES ('sketchKind', '1')");
+    }
     settingSync(key) {
         const rows = this.sql.exec("SELECT value FROM settings WHERE key = ?", key).toArray();
         return rows.length ? rows[0].value : null;
@@ -392,18 +534,24 @@ export class SqlStore {
             project: r.project,
             slug: r.slug,
             title: r.title,
-            kind: (r.kind === "page" ? "page" : "component"),
+            kind: isMockKind(r.kind) ? r.kind : "sketch",
+            area: r.area ?? null,
+            source: r.source ?? null,
             states: parseJson(r.states, []),
+            situations: parseJson(r.situations, {}),
             asks: parseJson(r.asks, []),
             knobs: parseJson(r.knobs, {}),
+            widths: parseJson(r.widths, []),
             draft: parseJson(r.draft, null),
             sessionId: r.sessionId ?? null,
+            closedAt: r.closedAt ?? 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,
@@ -418,7 +566,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 }),
@@ -581,16 +737,21 @@ export class SqlStore {
             project: stripNul(input.project).trim() || DEFAULT_PROJECT,
             slug: slugify(stripNul(input.slug)),
             title: stripNul(input.title)?.trim() || input.slug,
-            kind: input.kind === "page" ? "page" : "component",
+            kind: isMockKind(input.kind) ? input.kind : "sketch",
+            area: label(input.area),
+            source: label(input.source),
             states: (input.states ?? []).map((s) => stripNul(s)),
+            situations: {},
             asks: [],
             knobs: input.knobs ?? {},
+            widths: input.widths ?? [],
             draft: null,
             sessionId: input.sessionId ?? null,
+            closedAt: 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, area, source, states, asks, knobs, widths, draft, sessionId, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, '[]', ?, ?, NULL, ?, ?, ?)", mock.id, mock.project, mock.slug, mock.title, mock.kind, mock.area, mock.source, JSON.stringify(mock.states), JSON.stringify(mock.knobs), JSON.stringify(mock.widths), mock.sessionId, mock.createdAt, mock.updatedAt);
         return mock;
     }
     async updateMock(id, patch) {
@@ -601,29 +762,172 @@ export class SqlStore {
             ...mock,
             ...(patch.title !== undefined && { title: stripNul(patch.title).trim() || mock.title }),
             ...(patch.kind !== undefined && { kind: patch.kind }),
+            ...(patch.area !== undefined && { area: label(patch.area) }),
+            ...(patch.source !== undefined && { source: label(patch.source) }),
             ...(patch.states !== undefined && { states: patch.states.map((s) => stripNul(s)) }),
+            ...(patch.situations !== undefined && { situations: patch.situations }),
             ...(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.closedAt !== undefined && { closedAt: patch.closedAt }),
             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 = ?, area = ?, source = ?, states = ?, situations = ?, asks = ?, knobs = ?, widths = ?, sessionId = ?, closedAt = ?, updatedAt = ? WHERE id = ?", next.title, next.kind, next.area, next.source, JSON.stringify(next.states), JSON.stringify(next.situations), JSON.stringify(next.asks), JSON.stringify(next.knobs), JSON.stringify(next.widths), next.sessionId, next.closedAt, 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;
     }
+    async renameMock(id, slug) {
+        const to = slugify(stripNul(slug));
+        return this.atomic(() => {
+            const rows = this.sql.exec("SELECT * FROM mocks WHERE id = ?", id).toArray();
+            if (rows.length === 0)
+                return null;
+            const mock = this.rowToMock(rows[0]);
+            const from = mock.slug;
+            if (to === from)
+                return mock;
+            const taken = this.sql
+                .exec("SELECT id FROM mocks WHERE project = ? AND slug = ?", mock.project, to)
+                .toArray();
+            if (taken.length > 0)
+                return null;
+            const updatedAt = new Date().toISOString();
+            this.sql.exec("UPDATE mocks SET slug = ?, updatedAt = ? WHERE id = ?", to, updatedAt, id);
+            // History is rewritten too: embeds resolve by slug at render time, so an
+            // old version left naming the old slug would show its components missing.
+            const rewrite = (raw) => {
+                let changed = false;
+                const next = parseJson(raw, []).map((x) => {
+                    if (x.kind !== "html")
+                        return x;
+                    const html = renameSlugRefs(x.html, from, to);
+                    if (html === x.html)
+                        return x;
+                    changed = true;
+                    return { ...x, html };
+                });
+                return changed ? JSON.stringify(next) : null;
+            };
+            const posts = this.sql
+                .exec("SELECT id, surfaces, slots FROM posts WHERE mockId IN (SELECT id FROM mocks WHERE project = ?)", mock.project)
+                .toArray();
+            for (const r of posts) {
+                const postId = r.id;
+                const surfaces = rewrite(r.surfaces);
+                if (surfaces)
+                    this.sql.exec("UPDATE posts SET surfaces = ? WHERE id = ?", surfaces, postId);
+                const embeds = parseJson(r.slots, []);
+                if (embeds.some((e) => e.slug === from)) {
+                    this.sql.exec("UPDATE posts SET slots = ? WHERE id = ?", JSON.stringify(embeds.map((e) => (e.slug === from ? { ...e, slug: to } : e))), postId);
+                }
+                for (const v of this.sql
+                    .exec("SELECT version, surfaces FROM post_versions WHERE postId = ?", postId)
+                    .toArray()) {
+                    const old = rewrite(v.surfaces);
+                    if (!old)
+                        continue;
+                    this.sql.exec("UPDATE post_versions SET surfaces = ? WHERE postId = ? AND version = ?", old, postId, v.version);
+                }
+            }
+            for (const flow of this.flowsOf(mock.project)) {
+                if (!flow.steps.some((x) => x.mock === from))
+                    continue;
+                this.writeFlow(flow, flow.steps.map((x) => (x.mock === from ? { ...x, mock: to } : x)));
+            }
+            return { ...mock, slug: to, updatedAt };
+        });
+    }
+    async renameProject(from, to) {
+        const target = stripNul(to).trim();
+        return this.atomic(() => {
+            const occupied = this.sql
+                .exec("SELECT COUNT(*) AS n FROM mocks WHERE project = ?", target)
+                .one().n;
+            if (occupied > 0)
+                return false;
+            // A project with no mocks has nothing a leftover flow could walk.
+            this.sql.exec("DELETE FROM flows WHERE project = ?", target);
+            this.sql.exec("UPDATE mocks SET project = ? WHERE project = ?", target, from);
+            this.sql.exec("UPDATE sessions SET project = ? WHERE project = ?", target, from);
+            this.sql.exec("UPDATE flows SET project = ? WHERE project = ?", target, from);
+            for (const prefix of PROJECT_SETTINGS) {
+                const value = this.settingSync(`${prefix}:${from}`);
+                if (value === null)
+                    continue;
+                this.sql.exec("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)", `${prefix}:${target}`, value);
+                this.sql.exec("DELETE FROM settings WHERE key = ?", `${prefix}:${from}`);
+                if (prefix === "design")
+                    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)
@@ -692,12 +996,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);
@@ -719,13 +1025,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();
@@ -733,22 +1043,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,
@@ -772,12 +1083,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) {
@@ -864,12 +1199,17 @@ 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.closedAt !== undefined) {
+                this.sql.exec("UPDATE mocks SET closedAt = ?, updatedAt = ? WHERE id = ?", input.closedAt, input.closedAt, 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);
             }
             this.invalidateAssetRefs();
             return comment;