@cloudcli-ai/cloudcli 1.37.2 → 1.37.3

package/server/modules/database/repositories/sessions.db.ts

@@ -13,6 +13,8 @@ type SessionRow = {
   model: string | null;
   /** Reasoning effort this session runs with; NULL until the app records one. */
   effort: string | null;
+  /** The app session this one was branched from; NULL unless it is a fork. */
+  forked_from_session_id: string | null;
   isArchived: number;
   created_at: string;
   updated_at: string;
@@ -24,7 +26,7 @@ type RecentSessionsPage = {
 };
 
 const SESSION_ROW_COLUMNS =
-  'session_id, provider, provider_session_id, project_path, jsonl_path, custom_name, model, effort, isArchived, created_at, updated_at';
+  'session_id, provider, provider_session_id, project_path, jsonl_path, custom_name, model, effort, forked_from_session_id, isArchived, created_at, updated_at';
 
 const SQLITE_UTC_TIMESTAMP_REGEX = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/;
 
@@ -111,7 +113,7 @@ export const sessionsDb = {
            updated_at = COALESCE(?, CURRENT_TIMESTAMP),
            project_path = ?,
            jsonl_path = ?,
-           isArchived = 0,
+           isArchived = CASE WHEN ? IS NULL OR julianday(?) > julianday(updated_at) THEN 0 ELSE isArchived END,
            custom_name = CASE
              WHEN session_id <> provider_session_id AND custom_name IS NOT NULL THEN custom_name
              ELSE COALESCE(?, custom_name)
@@ -122,6 +124,8 @@ export const sessionsDb = {
         updatedAtValue,
         normalizedProjectPath,
         jsonlPath ?? null,
+        updatedAtValue,
+        updatedAtValue,
         customName ?? null,
         existing.session_id
       );
@@ -141,7 +145,7 @@ export const sessionsDb = {
          updated_at = excluded.updated_at,
          project_path = excluded.project_path,
          jsonl_path = excluded.jsonl_path,
-         isArchived = 0,
+         isArchived = CASE WHEN ? IS NULL OR julianday(excluded.updated_at) > julianday(sessions.updated_at) THEN 0 ELSE sessions.isArchived END,
          custom_name = CASE
            WHEN sessions.session_id <> sessions.provider_session_id AND sessions.custom_name IS NOT NULL
              THEN sessions.custom_name
@@ -155,6 +159,7 @@ export const sessionsDb = {
       normalizedProjectPath,
       jsonlPath ?? null,
       createdAtValue,
+      updatedAtValue,
       updatedAtValue
     );
 
@@ -189,6 +194,55 @@ export const sessionsDb = {
     return sessionId;
   },
 
+  /**
+   * Inserts a session that already has its provider artifact on disk.
+   *
+   * Unlike `createAppSession` this writes `provider_session_id` and
+   * `jsonl_path` immediately, because a fork's transcript file exists before
+   * the row does — and the filesystem watcher would otherwise index it as an
+   * unrelated session under its own id.
+   */
+  createForkedSession(input: {
+    sessionId: string;
+    provider: string;
+    projectPath: string;
+    customName: string | null;
+    providerSessionId: string;
+    jsonlPath: string;
+    forkedFromSessionId: string;
+    model: string | null;
+    effort: string | null;
+  }): string {
+    const db = getConnection();
+    const normalizedProjectPath = normalizeProjectPathForProvider(input.provider, input.projectPath);
+
+    projectsDb.createProjectPath(normalizedProjectPath);
+
+    // The watcher may already have created a row for the new transcript. Its
+    // id is the provider-native one, which is what this row claims, so replace
+    // it rather than leaving two sidebar entries for one conversation.
+    db.transaction(() => {
+      db.prepare('DELETE FROM sessions WHERE session_id = ? AND session_id <> ?')
+        .run(input.providerSessionId, input.sessionId);
+      db.prepare(
+        `INSERT INTO sessions (session_id, provider, provider_session_id, custom_name, project_path, jsonl_path, model, effort, forked_from_session_id, isArchived, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`
+      ).run(
+        input.sessionId,
+        input.provider,
+        input.providerSessionId,
+        input.customName,
+        normalizedProjectPath,
+        input.jsonlPath,
+        input.model,
+        input.effort,
+        input.forkedFromSessionId,
+      );
+    })();
+
+    return input.sessionId;
+  },
+
   /**
    * Records the provider-native session id for one app-allocated session.
    *
@@ -235,6 +289,125 @@ export const sessionsDb = {
     merge();
   },
 
+  /**
+   * Moves one session onto a different provider session and transcript.
+   *
+   * Only editing a message on a provider that has to branch to rewind (Codex)
+   * does this — an ordinary run keeps the same provider session for its whole
+   * life. `assignProviderSessionId` cannot be used for it: that one keeps the
+   * existing `jsonl_path` on purpose, so a session repointed with it would
+   * claim the new thread while still reading the old transcript.
+   *
+   * The watcher may already have indexed the new transcript under its own id.
+   * That row is the same conversation this one is about to become, so it is
+   * replaced rather than left behind as a second sidebar entry.
+   */
+  repointSessionToProviderSession(
+    sessionId: string,
+    input: { providerSessionId: string; jsonlPath: string },
+  ): void {
+    const db = getConnection();
+
+    db.transaction(() => {
+      db.prepare('DELETE FROM sessions WHERE session_id = ? AND session_id <> ?')
+        .run(input.providerSessionId, sessionId);
+      db.prepare(
+        `UPDATE sessions SET
+           provider_session_id = ?,
+           jsonl_path = ?,
+           updated_at = CURRENT_TIMESTAMP
+         WHERE session_id = ?`
+      ).run(input.providerSessionId, input.jsonlPath, sessionId);
+    })();
+  },
+
+  /**
+   * Detaches a session from its provider session so the next run starts a new
+   * one.
+   *
+   * Used when an edit replaces the very first prompt: there is no conversation
+   * left to branch from, so the session starts over instead.
+   */
+  detachProviderSession(sessionId: string): void {
+    const db = getConnection();
+    db.prepare(
+      `UPDATE sessions SET
+         provider_session_id = NULL,
+         jsonl_path = NULL,
+         updated_at = CURRENT_TIMESTAMP
+       WHERE session_id = ?`
+    ).run(sessionId);
+  },
+
+  /**
+   * Records that a session has left a provider session behind for good.
+   *
+   * The transcript stays on disk, which is deliberate — the abandoned attempt
+   * is recoverable — but the indexer must not offer it back, and on a session
+   * discovered from disk (whose app id *is* the provider id) rediscovering it
+   * would repoint the row at the conversation the user edited away from.
+   */
+  markProviderSessionSuperseded(input: {
+    providerSessionId: string;
+    provider: string;
+    sessionId: string;
+    jsonlPath: string | null;
+  }): void {
+    const db = getConnection();
+    db.prepare(
+      `INSERT INTO superseded_provider_sessions (provider_session_id, provider, session_id, jsonl_path)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(provider_session_id, provider) DO UPDATE SET
+         session_id = excluded.session_id,
+         jsonl_path = excluded.jsonl_path,
+         created_at = CURRENT_TIMESTAMP`
+    ).run(input.providerSessionId, input.provider, input.sessionId, input.jsonlPath);
+  },
+
+  isProviderSessionSuperseded(providerSessionId: string, provider: string): boolean {
+    const db = getConnection();
+    const row = db
+      .prepare(
+        `SELECT 1 AS found FROM superseded_provider_sessions
+         WHERE provider_session_id = ? AND provider = ?
+         LIMIT 1`
+      )
+      .get(providerSessionId, provider) as { found: number } | undefined;
+
+    return Boolean(row);
+  },
+
+  /**
+   * Transcripts one session has left behind, for the caller that deletes a
+   * conversation from disk.
+   *
+   * A conversation edited more than once has lived in more than one file, and
+   * the session row only ever points at the newest.
+   */
+  getSupersededTranscriptPaths(sessionId: string): string[] {
+    const db = getConnection();
+    const rows = db
+      .prepare(
+        `SELECT jsonl_path FROM superseded_provider_sessions
+         WHERE session_id = ? AND jsonl_path IS NOT NULL`
+      )
+      .all(sessionId) as Array<{ jsonl_path: string }>;
+
+    return rows.map((row) => row.jsonl_path);
+  },
+
+  /**
+   * Forgets what a session left behind, once the session itself is gone.
+   *
+   * Without this the record outlives the row it was written for and keeps the
+   * indexer refusing a transcript that no longer belongs to anything — a
+   * conversation invisible to the app and impossible to delete through it.
+   */
+  clearSupersededProviderSessions(sessionId: string): void {
+    const db = getConnection();
+    db.prepare('DELETE FROM superseded_provider_sessions WHERE session_id = ?').run(sessionId);
+  },
+
   /**
    * Records the model one session runs with.
    *
@@ -521,4 +694,24 @@ export const sessionsDb = {
     const db = getConnection();
     return db.prepare('DELETE FROM sessions WHERE session_id = ?').run(sessionId).changes > 0;
   },
+
+  /**
+   * Lists every indexed session that claims a transcript file on disk.
+   *
+   * Only rows with a `jsonl_path` are returned, which deliberately excludes
+   * app-created sessions still waiting for their first provider write and
+   * OpenCode rows (whose transcripts all live inside one shared sqlite file).
+   * Used by the session synchronizer to find rows whose transcript has been
+   * deleted underneath the index.
+   */
+  getSessionsWithTranscriptPath(): Array<{ session_id: string; jsonl_path: string }> {
+    const db = getConnection();
+    return db
+      .prepare(
+        `SELECT session_id, jsonl_path
+         FROM sessions
+         WHERE jsonl_path IS NOT NULL AND jsonl_path <> ''`
+      )
+      .all() as Array<{ session_id: string; jsonl_path: string }>;
+  },
 };

package/server/modules/database/repositories/user-preferences.db.ts

@@ -0,0 +1,80 @@
+import { getConnection } from '@/modules/database/connection.js';
+
+type PreferenceRow = {
+  preference_key: string;
+  preference_value: string;
+};
+
+/**
+ * Decodes one stored preference, dropping any row whose JSON no longer parses
+ * rather than failing the whole read. A single corrupted value must not cost
+ * the user every other setting they have.
+ */
+function decodePreference(row: PreferenceRow): [string, unknown] | null {
+  try {
+    return [row.preference_key, JSON.parse(row.preference_value) as unknown];
+  } catch {
+    console.warn(`[UserPreferences] Dropping unreadable value for "${row.preference_key}"`);
+    return null;
+  }
+}
+
+export const userPreferencesDb = {
+  /**
+   * Returns every preference the user has ever set, as one object.
+   *
+   * The client fetches this once on start-up, so absent keys simply mean "the
+   * user never changed this" and the client applies its own default.
+   */
+  getPreferences(userId: number): Record<string, unknown> {
+    const db = getConnection();
+    const rows = db
+      .prepare(
+        `SELECT preference_key, preference_value
+         FROM user_preferences
+         WHERE user_id = ?`
+      )
+      .all(userId) as PreferenceRow[];
+
+    const preferences: Record<string, unknown> = {};
+    for (const row of rows) {
+      const decoded = decodePreference(row);
+      if (decoded) {
+        preferences[decoded[0]] = decoded[1];
+      }
+    }
+
+    return preferences;
+  },
+
+  /**
+   * Merge-patches preferences: keys present in `updates` are written, keys
+   * absent are left alone, and a key given as `undefined` is deleted.
+   *
+   * Runs in one transaction so a multi-key save from the settings dialog can
+   * never be observed half-applied.
+   */
+  savePreferences(userId: number, updates: Record<string, unknown>): void {
+    const db = getConnection();
+    const upsert = db.prepare(
+      `INSERT INTO user_preferences (user_id, preference_key, preference_value, updated_at)
+       VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(user_id, preference_key) DO UPDATE SET
+         preference_value = excluded.preference_value,
+         updated_at = CURRENT_TIMESTAMP`
+    );
+    const remove = db.prepare(
+      'DELETE FROM user_preferences WHERE user_id = ? AND preference_key = ?'
+    );
+
+    db.transaction(() => {
+      for (const [key, value] of Object.entries(updates)) {
+        if (value === undefined) {
+          remove.run(userId, key);
+          continue;
+        }
+        upsert.run(userId, key, JSON.stringify(value));
+      }
+    })();
+  },
+};

package/server/modules/database/schema.ts

@@ -96,6 +96,30 @@ CREATE TABLE IF NOT EXISTS projects (
 );
 `;
 
+export const SCHEDULED_MESSAGES_TABLE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS scheduled_messages (
+    id TEXT PRIMARY KEY,
+    user_id INTEGER NOT NULL,
+    session_id TEXT NOT NULL,
+    content TEXT NOT NULL,
+    -- Composer preferences (model, effort, permission mode, attachments) as
+    -- they were when the message was scheduled, so it runs the way the user
+    -- set it up rather than however the session is configured hours later.
+    options TEXT NOT NULL DEFAULT '{}',
+    -- UTC. The client sends an absolute instant so the schedule does not move
+    -- when the user changes time zone between scheduling and firing.
+    scheduled_for DATETIME NOT NULL,
+    -- pending | sent | failed | cancelled
+    status TEXT NOT NULL DEFAULT 'pending',
+    -- Why a failed one failed, shown next to it in the composer.
+    failure_reason TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+);
+`;
+
 export const SESSIONS_TABLE_SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS sessions (
     session_id TEXT NOT NULL,
@@ -114,6 +138,10 @@ CREATE TABLE IF NOT EXISTS sessions (
     -- restores its exact runtime configuration instead of provider defaults.
     model TEXT,
     effort TEXT,
+    -- The app session this one was branched from, NULL for sessions created
+    -- normally. Informational only: a fork is a fully independent provider
+    -- session, and deleting the source does not affect it.
+    forked_from_session_id TEXT,
     isArchived BOOLEAN DEFAULT 0,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
@@ -160,6 +188,68 @@ CREATE TABLE IF NOT EXISTS provider_models (
 );
 `;
 
+/**
+ * Per-user application preferences that used to live in browser localStorage.
+ *
+ * One row per (user, key); `preference_value` is always a JSON document so a
+ * key can hold a scalar (`"dark"`), a flag (`false`) or a whole settings blob
+ * without the schema having to know which. Keeping them server-side is what
+ * makes a preference follow the user from one device to another.
+ */
+export const USER_PREFERENCES_TABLE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS user_preferences (
+    user_id INTEGER NOT NULL,
+    preference_key TEXT NOT NULL,
+    preference_value TEXT NOT NULL,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (user_id, preference_key),
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+`;
+
+/**
+ * Unsent composer text and queued messages, per user and per chat scope.
+ *
+ * `draft_scope` is a session id, or `project:<projectId>` for a chat that has
+ * not been sent yet and therefore has no session. Storing this server-side is
+ * what lets a message typed on a laptop be finished on a phone.
+ */
+export const SESSION_DRAFTS_TABLE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS session_drafts (
+    user_id INTEGER NOT NULL,
+    draft_scope TEXT NOT NULL,
+    draft_text TEXT NOT NULL DEFAULT '',
+    queued_message TEXT,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (user_id, draft_scope),
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+`;
+
+/**
+ * Provider sessions an app session has moved off, and must never move back to.
+ *
+ * Editing a message on a provider that cannot resume a transcript partway
+ * (Codex) is done by branching: the conversation is copied up to the edited
+ * turn and the app session follows the copy. The original transcript is left
+ * on disk untouched — nothing is deleted — but it is no longer the session's,
+ * and the indexer would otherwise rediscover it on its next full scan and hand
+ * the session back to the version the user edited away from.
+ */
+export const SUPERSEDED_PROVIDER_SESSIONS_TABLE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS superseded_provider_sessions (
+    provider_session_id TEXT NOT NULL,
+    provider TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    -- The transcript the session left behind. Recorded because the session row
+    -- stops pointing at it, and "delete this conversation from disk" has to
+    -- reach every file the conversation ever lived in.
+    jsonl_path TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (provider_session_id, provider)
+);
+`;
+
 export const INIT_SCHEMA_SQL = `
 -- Initialize authentication database
 PRAGMA foreign_keys = ON;
@@ -207,4 +297,10 @@ ${APP_CONFIG_TABLE_SCHEMA_SQL}
 ${PROVIDER_MODELS_TABLE_SCHEMA_SQL}
 CREATE INDEX IF NOT EXISTS idx_provider_models_provider_order
 ON provider_models(provider, sort_order, id);
+
+${USER_PREFERENCES_TABLE_SCHEMA_SQL}
+
+${SESSION_DRAFTS_TABLE_SCHEMA_SQL}
+
+${SUPERSEDED_PROVIDER_SESSIONS_TABLE_SCHEMA_SQL}
 `;

package/server/modules/database/tests/sessions.db.integration.test.ts

@@ -72,6 +72,58 @@ test('createSession reactivates archived rows when the session becomes active ag
   });
 });
 
+test("createSession leaves an archived row archived when the transcript has not changed", async () => {
+  await withIsolatedDatabase(() => {
+    const createdAt = "2026-07-18T09:00:00.000Z";
+    const updatedAt = "2026-07-18T10:00:00.000Z";
+    const jsonlPath = "/transcripts/session-untouched.jsonl";
+
+    sessionsDb.createSession("session-untouched", "claude", "/workspace/demo-project", "A Name", createdAt, updatedAt, jsonlPath);
+    sessionsDb.updateSessionIsArchived("session-untouched", true);
+
+    // A full rescan re-indexes every transcript created since the last scan,
+    // changed or not, and hands over the timestamps the file still carries.
+    sessionsDb.createSession("session-untouched", "claude", "/workspace/demo-project", "A Name", createdAt, updatedAt, jsonlPath);
+
+    assert.equal(sessionsDb.getSessionById("session-untouched")?.isArchived, 1);
+    assert.equal(sessionsDb.getArchivedSessions().length, 1);
+    assert.equal(sessionsDb.getAllSessions().length, 0);
+
+    // Actually writing to the session again still brings it back.
+    sessionsDb.createSession("session-untouched", "claude", "/workspace/demo-project", "A Name", createdAt, "2026-07-18T11:00:00.000Z", jsonlPath);
+
+    assert.equal(sessionsDb.getSessionById("session-untouched")?.isArchived, 0);
+  });
+});
+
+test("the upsert path counts an omitted timestamp as activity", async () => {
+  await withIsolatedDatabase(() => {
+    // An app-created row carries no provider id, so indexing it takes the
+    // INSERT ... ON CONFLICT branch rather than the UPDATE above. Its
+    // updated_at is CURRENT_TIMESTAMP, which resolves to whole seconds, so a
+    // call in the same second is not *newer* -- the omitted timestamp itself
+    // has to be what reactivates the row.
+    sessionsDb.createAppSession("session-legacy", "claude", "/workspace/demo-project");
+    sessionsDb.updateSessionIsArchived("session-legacy", true);
+
+    sessionsDb.createSession("session-legacy", "claude", "/workspace/demo-project", "Indexed Name");
+
+    assert.equal(sessionsDb.getSessionById("session-legacy")?.isArchived, 0);
+  });
+});
+
+test("the upsert path leaves an archived row alone for a transcript older than it", async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession("session-stale", "claude", "/workspace/demo-project");
+    sessionsDb.updateSessionIsArchived("session-stale", true);
+
+    sessionsDb.createSession("session-stale", "claude", "/workspace/demo-project", "Indexed Name", "2026-07-18T09:00:00.000Z", "2026-07-18T10:00:00.000Z", "/transcripts/session-stale.jsonl");
+
+    assert.equal(sessionsDb.getSessionById("session-stale")?.isArchived, 1);
+  });
+});
+
+
 test('repository reads normalize SQLite UTC timestamps to ISO strings', async () => {
   await withIsolatedDatabase(() => {
     sessionsDb.createAppSession('session-timezone', 'claude', '/workspace/demo-project');

package/server/modules/database/tests/user-preferences.db.integration.test.ts

@@ -0,0 +1,135 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  closeConnection,
+  getConnection,
+  initializeDatabase,
+  sessionDraftsDb,
+  userPreferencesDb,
+} from '@/modules/database/index.js';
+
+const USER_ID = 1;
+
+async function withDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'user-prefs-db-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await writeFile(databasePath, '');
+  await initializeDatabase();
+
+  // Both tables cascade from users(id), so a row has to exist to write against.
+  getConnection()
+    .prepare('INSERT INTO users (id, username, password_hash) VALUES (?, ?, ?)')
+    .run(USER_ID, 'tester', 'hash');
+
+  try {
+    await runTest();
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+test('preferences round-trip every JSON shape a setting can take', async () => {
+  await withDatabase(() => {
+    userPreferencesDb.savePreferences(USER_ID, {
+      theme: 'dark',
+      tasksEnabled: false,
+      claudePermissions: { allowedTools: ['Read'], skipPermissions: true },
+    });
+
+    assert.deepEqual(userPreferencesDb.getPreferences(USER_ID), {
+      theme: 'dark',
+      tasksEnabled: false,
+      claudePermissions: { allowedTools: ['Read'], skipPermissions: true },
+    });
+  });
+});
+
+test('saving preferences merge-patches instead of replacing the whole set', async () => {
+  await withDatabase(() => {
+    userPreferencesDb.savePreferences(USER_ID, { theme: 'dark', userLanguage: 'de' });
+    userPreferencesDb.savePreferences(USER_ID, { theme: 'light' });
+
+    assert.deepEqual(userPreferencesDb.getPreferences(USER_ID), {
+      theme: 'light',
+      userLanguage: 'de',
+    });
+  });
+});
+
+test('a preference set to undefined is removed', async () => {
+  await withDatabase(() => {
+    userPreferencesDb.savePreferences(USER_ID, { theme: 'dark', userLanguage: 'de' });
+    userPreferencesDb.savePreferences(USER_ID, { userLanguage: undefined });
+
+    assert.deepEqual(userPreferencesDb.getPreferences(USER_ID), { theme: 'dark' });
+  });
+});
+
+test('one unreadable preference value does not cost the user the others', async () => {
+  await withDatabase(() => {
+    userPreferencesDb.savePreferences(USER_ID, { theme: 'dark' });
+    getConnection()
+      .prepare(
+        `INSERT INTO user_preferences (user_id, preference_key, preference_value)
+         VALUES (?, ?, ?)`
+      )
+      .run(USER_ID, 'broken', 'not json');
+
+    assert.deepEqual(userPreferencesDb.getPreferences(USER_ID), { theme: 'dark' });
+  });
+});
+
+test('drafts round-trip text and queued message per scope', async () => {
+  await withDatabase(() => {
+    sessionDraftsDb.saveDraft(USER_ID, 'session-a', { text: 'half typed', queuedMessage: null });
+    sessionDraftsDb.saveDraft(USER_ID, 'project:p1', {
+      text: '',
+      queuedMessage: { content: 'run it' },
+    });
+
+    const drafts = sessionDraftsDb.getDrafts(USER_ID);
+    const byScope = new Map(drafts.map((draft) => [draft.scope, draft]));
+
+    assert.equal(byScope.get('session-a')?.text, 'half typed');
+    assert.equal(byScope.get('session-a')?.queuedMessage, null);
+    assert.equal(byScope.get('project:p1')?.text, '');
+    assert.deepEqual(byScope.get('project:p1')?.queuedMessage, { content: 'run it' });
+  });
+});
+
+test('saving an empty draft deletes the row rather than keeping a blank one', async () => {
+  await withDatabase(() => {
+    sessionDraftsDb.saveDraft(USER_ID, 'session-a', { text: 'typed', queuedMessage: null });
+    sessionDraftsDb.saveDraft(USER_ID, 'session-a', { text: '', queuedMessage: null });
+
+    assert.deepEqual(sessionDraftsDb.getDrafts(USER_ID), []);
+  });
+});
+
+test('deleteDraft removes only the named scope', async () => {
+  await withDatabase(() => {
+    sessionDraftsDb.saveDraft(USER_ID, 'session-a', { text: 'a', queuedMessage: null });
+    sessionDraftsDb.saveDraft(USER_ID, 'session-b', { text: 'b', queuedMessage: null });
+
+    sessionDraftsDb.deleteDraft(USER_ID, 'session-a');
+
+    assert.deepEqual(
+      sessionDraftsDb.getDrafts(USER_ID).map((draft) => draft.scope),
+      ['session-b'],
+    );
+  });
+});

package/server/modules/projects/services/project-delete.service.ts

@@ -43,11 +43,23 @@ async function unlinkJsonlIfExists(filePath: string): Promise<void> {
  */
 export async function deleteSessionJsonlFilesForProjectPath(projectPath: string): Promise<void> {
   const sessions = sessionsDb.getSessionsByProjectPathIncludingArchived(projectPath);
-  const paths = uniqueJsonlPathsFromSessions(sessions);
+  // Including the transcripts a session has left behind: editing a message on
+  // a provider that rewinds by branching moves the session onto a copy, and
+  // the row stops pointing at the file the replaced turns are still in.
+  const paths = uniqueJsonlPathsFromSessions([
+    ...sessions,
+    ...sessions.flatMap((session) => sessionsDb
+      .getSupersededTranscriptPaths(session.session_id)
+      .map((jsonl_path) => ({ jsonl_path }))),
+  ]);
 
   for (const filePath of paths) {
     await unlinkJsonlIfExists(filePath);
   }
+
+  for (const session of sessions) {
+    sessionsDb.clearSupersededProviderSessions(session.session_id);
+  }
 }
 
 /**