Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.
JavaScript aianthropiccross-platformgeminigroqlinuxmacosnvidiaopen-sourceopenaiparakeetspeech-to-texttranscribewhisperwindows
const test = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const os = require("node:os");
const path = require("node:path");
const Module = require("node:module");
let userDataDir = fs.mkdtempSync(path.join(os.tmpdir(), "openwhispr-container-db-"));
const originalLoad = Module._load;
Module._load = function patchedLoad(request, parent, isMain) {
if (request === "electron") {
return {
app: {
getPath: () => userDataDir,
getAppPath: () => process.cwd(),
isReady: () => false,
},
};
}
return originalLoad.call(this, request, parent, isMain);
};
process.env.NODE_ENV = "test";
const DatabaseManager = require("../../src/helpers/database.js");
function isNativeBindingUnavailable(error) {
const message = String(error?.message || error);
return (
message.includes("NODE_MODULE_VERSION") ||
message.includes("Could not locate the bindings file")
);
}
function createDb(t) {
userDataDir = fs.mkdtempSync(path.join(os.tmpdir(), "openwhispr-container-db-"));
try {
const BetterSqlite = require("better-sqlite3");
const probe = new BetterSqlite(path.join(userDataDir, "probe.db"));
probe.close();
fs.rmSync(path.join(userDataDir, "probe.db"), { force: true });
} catch (error) {
if (isNativeBindingUnavailable(error)) {
t.skip("better-sqlite3 native binding is not available for this Node runtime");
return null;
}
throw error;
}
try {
const database = new DatabaseManager();
database.setActiveAccountId("test-account");
return database;
} catch (error) {
if (isNativeBindingUnavailable(error)) {
t.skip("better-sqlite3 native binding is not available for this Node runtime");
return null;
}
throw error;
}
}
let nextTestTeamSpaceId = 0;
function createTestTeamSpace(db, { name, emoji = null } = {}) {
const maxOrder = db.db.prepare("SELECT MAX(sort_order) AS max_order FROM spaces").get();
const result = db.db
.prepare(
"INSERT INTO spaces (client_space_id, kind, name, emoji, sort_order) VALUES (?, 'team', ?, ?, ?)"
)
.run(
`test-container-space-${++nextTestTeamSpaceId}`,
name,
emoji,
(maxOrder?.max_order ?? 0) + 1
);
db.db
.prepare("INSERT INTO space_accounts (space_id, account_id) VALUES (?, ?)")
.run(result.lastInsertRowid, "test-account");
return { success: true, space: db.getSpace(result.lastInsertRowid) };
}
test("container scope migration is idempotent across launches", (t) => {
const db = createDb(t);
if (!db) return;
const columns = db.db.pragma("table_info('agent_conversations')").map((col) => col.name);
assert.ok(columns.includes("space_id"));
assert.ok(columns.includes("folder_id"));
const noteColumns = db.db.pragma("table_info('notes')").map((col) => col.name);
assert.ok(noteColumns.includes("updated_by_user_id"));
assert.ok(
db.db
.prepare(
"SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'optimistic_folder_delete_rows'"
)
.get()
);
db.db.close();
const db2 = new DatabaseManager();
const indexes = db2.db
.prepare(
"SELECT name FROM sqlite_master WHERE type = 'index' AND tbl_name = 'agent_conversations'"
)
.all()
.map((row) => row.name);
assert.ok(indexes.includes("idx_agent_conversations_container"));
assert.ok(
db2.db
.prepare(
"SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'optimistic_folder_delete_rows'"
)
.get()
);
});
test("createAgentConversation stores container scope", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder = db.createFolder("Docs", space.id).folder;
const folderConv = db.createAgentConversation("Docs", null, space.id, folder.id);
assert.equal(folderConv.space_id, space.id);
assert.equal(folderConv.folder_id, folder.id);
const spaceConv = db.createAgentConversation("Eng", null, space.id);
assert.equal(spaceConv.space_id, space.id);
assert.equal(spaceConv.folder_id, null);
const globalConv = db.createAgentConversation("Global");
assert.equal(globalConv.space_id, null);
assert.equal(globalConv.folder_id, null);
assert.equal(globalConv.note_id, null);
});
test("getPendingConversations excludes scopes the cloud contract cannot preserve", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder = db.createFolder("Docs", space.id).folder;
const note = db.saveNote("Note", "body").note;
const global = db.createAgentConversation("Global");
const noteScoped = db.createAgentConversation("Note chat", note.id);
db.createAgentConversation("Space chat", null, space.id);
db.createAgentConversation("Folder chat", null, space.id, folder.id);
assert.deepEqual(
db.getPendingConversations().map((conversation) => conversation.id),
[global.id, noteScoped.id],
"space/folder chats must remain local until the cloud API carries their scope"
);
});
test("getConversationsForContainer separates folder and space-root scopes", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder = db.createFolder("Docs", space.id).folder;
const folderConv = db.createAgentConversation("Folder chat", null, space.id, folder.id);
const spaceConv = db.createAgentConversation("Space chat", null, space.id);
db.createAgentConversation("Global chat");
db.addAgentMessage(folderConv.id, "user", "hello");
const folderList = db.getConversationsForContainer(space.id, folder.id);
assert.equal(folderList.length, 1);
assert.equal(folderList[0].id, folderConv.id);
assert.equal(folderList[0].message_count, 1);
const spaceList = db.getConversationsForContainer(space.id, null);
assert.equal(spaceList.length, 1, "space root must exclude folder-scoped conversations");
assert.equal(spaceList[0].id, spaceConv.id);
assert.equal(spaceList[0].message_count, 0);
});
test("getConversationsForContainer excludes deleted conversations", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const conv = db.createAgentConversation("Doomed", null, space.id);
db.db
.prepare("UPDATE agent_conversations SET deleted_at = datetime('now') WHERE id = ?")
.run(conv.id);
assert.equal(db.getConversationsForContainer(space.id, null).length, 0);
});
test("global conversation lists and search exclude space and folder chats", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder = db.createFolder("Docs", space.id).folder;
const note = db.saveNote("Roadmap source", "body").note;
const global = db.createAgentConversation("Roadmap global");
const archivedGlobal = db.createAgentConversation("Roadmap archived");
const noteScoped = db.createAgentConversation("Roadmap note", note.id);
const spaceScoped = db.createAgentConversation("Roadmap space", null, space.id);
const folderScoped = db.createAgentConversation("Roadmap folder", null, space.id, folder.id);
db.archiveAgentConversation(archivedGlobal.id);
db.addAgentMessage(global.id, "user", "roadmap");
db.addAgentMessage(noteScoped.id, "user", "roadmap");
db.addAgentMessage(spaceScoped.id, "user", "roadmap");
db.addAgentMessage(folderScoped.id, "user", "roadmap");
assert.deepEqual(
new Set(db.getAgentConversations().map((conversation) => conversation.id)),
new Set([global.id, archivedGlobal.id, noteScoped.id])
);
assert.deepEqual(
new Set(db.getAgentConversationsWithPreview().map((conversation) => conversation.id)),
new Set([noteScoped.id, global.id])
);
assert.deepEqual(
db.getAgentConversationsWithPreview(50, 0, true).map((conversation) => conversation.id),
[archivedGlobal.id]
);
assert.deepEqual(
new Set(db.searchAgentConversations("roadmap").map((conversation) => conversation.id)),
new Set([global.id, noteScoped.id])
);
assert.equal(db.getConversationsForContainer(space.id, null)[0].id, spaceScoped.id);
assert.equal(db.getConversationsForContainer(space.id, folder.id)[0].id, folderScoped.id);
});
test("searchNotes filters by folder", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder = db.createFolder("Docs", space.id).folder;
db.saveNote("Roadmap planning", "quarterly roadmap", "personal", null, null, folder.id, space.id);
db.saveNote("Roadmap ideas", "more roadmap", "personal", null, null, null, space.id);
const spaceHits = db.searchNotes("roadmap", 10, space.id);
assert.equal(spaceHits.length, 2);
const folderHits = db.searchNotes("roadmap", 10, space.id, folder.id);
assert.equal(folderHits.length, 1);
assert.equal(folderHits[0].folder_id, folder.id);
});
test("getNotesForSpace includes foldered notes, unlike the root-only getNotes", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder = db.createFolder("Docs", space.id).folder;
const rootNote = db.saveNote("Root", "", "personal", null, null, null, space.id).note;
const folderNote = db.saveNote("Foldered", "", "personal", null, null, folder.id, space.id).note;
db.deleteNote(folderNote.id);
const keptNote = db.saveNote("Kept", "", "personal", null, null, folder.id, space.id).note;
const rootOnly = db.getNotes(null, 50, null, space.id);
assert.deepEqual(
rootOnly.map((n) => n.id),
[rootNote.id]
);
const all = db.getNotesForSpace(space.id);
assert.deepEqual(new Set(all.map((n) => n.id)), new Set([rootNote.id, keptNote.id]));
});
test("getNoteIdsInFolder excludes deleted notes", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder = db.createFolder("Docs", space.id).folder;
const kept = db.saveNote("Kept", "", "personal", null, null, folder.id, space.id).note;
const removed = db.saveNote("Removed", "", "personal", null, null, folder.id, space.id).note;
db.deleteNote(removed.id);
assert.deepEqual(db.getNoteIdsInFolder(folder.id), [kept.id]);
});
test("getNoteIdsInScope validates vector candidates against the current SQLite scope", (t) => {
const db = createDb(t);
if (!db) return;
const eng = createTestTeamSpace(db, { name: "Eng" }).space;
const design = createTestTeamSpace(db, { name: "Design" }).space;
const engFolder = db.createFolder("Docs", eng.id).folder;
const engRoot = db.saveNote("Eng root", "", "personal", null, null, null, eng.id).note;
const engFiled = db.saveNote("Eng filed", "", "personal", null, null, engFolder.id, eng.id).note;
const designRoot = db.saveNote("Design root", "", "personal", null, null, null, design.id).note;
const deleted = db.saveNote("Deleted", "", "personal", null, null, null, eng.id).note;
db.deleteNote(deleted.id);
assert.deepEqual(new Set(db.getNoteIdsInScope(eng.id)), new Set([engRoot.id, engFiled.id]));
assert.deepEqual(db.getNoteIdsInScope(eng.id, engFolder.id), [engFiled.id]);
assert.deepEqual(db.getNoteIdsInScope(design.id, engFolder.id), []);
assert.deepEqual(db.getNoteIdsInScope(design.id), [designRoot.id]);
assert.deepEqual(
db.getNoteIdsInScope(eng.id, null, [engRoot.id, designRoot.id, deleted.id]),
[engRoot.id],
"stale vector candidates are filtered by live local scope"
);
});
test("upsertNoteFromCloud preserves omitted and clears explicit-null updated_by_user_id", (t) => {
const db = createDb(t);
if (!db) return;
const privateId = db.getPrivateSpaceId();
const cloudNote = {
id: "cloud-1",
client_note_id: "client-1",
title: "Synced",
content: "body",
updated_by_user_id: "user-a",
created_at: "2026-07-01 10:00:00",
updated_at: "2026-07-01 10:00:00",
};
const inserted = db.upsertNoteFromCloud(cloudNote, null, privateId);
assert.equal(inserted.updated_by_user_id, "user-a");
const updated = db.upsertNoteFromCloud(
{ ...cloudNote, updated_by_user_id: "user-b", updated_at: "2026-07-02 10:00:00" },
null,
privateId
);
assert.equal(updated.updated_by_user_id, "user-b");
const cloudNoteWithoutUpdater = { ...cloudNote };
delete cloudNoteWithoutUpdater.updated_by_user_id;
// Older API responses that omit the field must keep the last known editor.
const unchanged = db.upsertNoteFromCloud(
{ ...cloudNoteWithoutUpdater, updated_at: "2026-07-03 10:00:00" },
null,
privateId
);
assert.equal(unchanged.updated_by_user_id, "user-b");
// Explicit null clears attribution after the former user is deleted.
const cleared = db.upsertNoteFromCloud(
{ ...cloudNote, updated_by_user_id: null, updated_at: "2026-07-04 10:00:00" },
null,
privateId
);
assert.equal(cleared.updated_by_user_id, null);
});
// Container conversations die with their container (space purge, folder
// delete, revocation): synced rows tombstone so the next push retires the
// cloud copy — a hard local delete would let the next pull resurrect the
// conversation as a global one — while never-synced rows hard-delete
// outright (no server row to retire).
test("purgeSpace retires the space's container conversations", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder = db.createFolder("Docs", space.id).folder;
const syncedConv = db.createAgentConversation("Synced", null, space.id);
db.markConversationSynced(syncedConv.id, "cloud-conv-1");
const localConv = db.createAgentConversation("Local only", null, space.id, folder.id);
db.addAgentMessage(localConv.id, "user", "hello");
const globalConv = db.createAgentConversation("Global");
assert.equal(db.purgeSpace(space.id).success, true);
const tombstoned = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(syncedConv.id);
assert.ok(tombstoned.deleted_at, "synced conversation must tombstone for the delete push");
assert.equal(tombstoned.sync_status, "pending");
assert.equal(
db.db.prepare("SELECT COUNT(*) AS n FROM agent_conversations WHERE id = ?").get(localConv.id).n,
0
);
assert.equal(
db.db
.prepare("SELECT COUNT(*) AS n FROM agent_messages WHERE conversation_id = ?")
.get(localConv.id).n,
0
);
const global = db.db.prepare("SELECT * FROM agent_conversations WHERE id = ?").get(globalConv.id);
assert.equal(global.deleted_at, null, "unscoped conversations are untouched");
});
test("live cloud upserts never rehydrate local conversation tombstones", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Secret" }).space;
const purged = db.createAgentConversation("Purged chat", null, space.id);
db.markConversationSynced(purged.id, "cloud-conv-purged");
db.addAgentMessage(purged.id, "user", "sensitive team content");
assert.equal(db.purgeSpace(space.id).success, true);
assert.equal(db.getAgentMessages(purged.id).length, 0);
const ignored = db.upsertConversationFromCloud(
{
id: "cloud-conv-purged",
client_conversation_id: purged.client_conversation_id,
title: "Newer cloud copy",
updated_at: "2099-01-01T00:00:00.000Z",
},
[{ role: "assistant", content: "must not come back" }]
);
assert.equal(ignored.id, purged.id);
const stillPurged = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(purged.id);
assert.ok(stillPurged.deleted_at);
assert.equal(stillPurged.sync_status, "pending");
assert.equal(stillPurged.title, "Purged chat");
assert.equal(db.getAgentMessages(purged.id).length, 0);
const optimistic = db.createAgentConversation("Recoverable chat");
db.markConversationSynced(optimistic.id, "cloud-conv-optimistic");
db.addAgentMessage(optimistic.id, "user", "original local message");
assert.equal(db.deleteAgentConversation(optimistic.id).success, true);
db.upsertConversationFromCloud(
{
id: "cloud-conv-optimistic",
client_conversation_id: optimistic.client_conversation_id,
title: "Cloud tried to restore this",
updated_at: "2099-01-01T00:00:00.000Z",
},
[{ role: "assistant", content: "replacement cloud message" }]
);
assert.equal(
db.getAgentMessages(optimistic.id)[0].content,
"original local message",
"an optimistic tombstone retains its prior recoverable content without accepting cloud updates"
);
const inFlightCreate = db.createAgentConversation("Delete raced create");
assert.equal(db.deleteAgentConversation(inFlightCreate.id).success, true);
assert.equal(db.markConversationSynced(inFlightCreate.id, "cloud-conv-late-ack").success, true);
const queuedLateAck = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(inFlightCreate.id);
assert.equal(queuedLateAck.cloud_id, "cloud-conv-late-ack");
assert.ok(queuedLateAck.deleted_at);
assert.equal(queuedLateAck.sync_status, "pending");
assert.ok(
db
.getPendingConversationDeletes()
.some((conversation) => conversation.id === inFlightCreate.id),
"a late create acknowledgement becomes a pending cloud delete"
);
// This is the database action used by the cloud-tombstone branch: an
// acknowledged remote delete still removes the local tombstone completely.
assert.equal(db.hardDeleteConversation(purged.id).success, true);
assert.equal(
db.db.prepare("SELECT COUNT(*) AS n FROM agent_conversations WHERE id = ?").get(purged.id).n,
0
);
});
test("purge rejects late writes and conversations for stale parents", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Secret" }).space;
const folder = db.createFolder("Vault", space.id).folder;
const note = db.saveNote("Secret note", "body", "personal", null, null, folder.id).note;
db.markNoteSynced(note.id, "cloud-note-late-write");
const conversation = db.createAgentConversation("Original title", note.id);
db.markConversationSynced(conversation.id, "cloud-conv-late-write");
db.addAgentMessage(conversation.id, "user", "purge this message");
const localConversation = db.createAgentConversation("Local in-flight chat", note.id);
db.addAgentMessage(localConversation.id, "user", "purge local message");
assert.equal(db.purgeSpace(space.id).success, true);
const tombstone = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(conversation.id);
assert.ok(tombstone.deleted_at);
assert.equal(db.getAgentMessages(conversation.id).length, 0);
assert.equal(db.getAgentConversation(localConversation.id), null);
assert.equal(db.addAgentMessage(localConversation.id, "assistant", "late local response"), null);
assert.equal(
db.updateAgentConversationTitle(localConversation.id, "late local title").success,
false
);
assert.equal(db.addAgentMessage(conversation.id, "assistant", "late sensitive response"), null);
assert.equal(db.getAgentMessages(conversation.id).length, 0);
assert.equal(
db.updateAgentConversationTitle(conversation.id, "late sensitive title").success,
false
);
assert.equal(db.archiveAgentConversation(conversation.id).success, false);
assert.equal(db.unarchiveAgentConversation(conversation.id).success, false);
assert.equal(db.updateAgentConversationCloudId(conversation.id, "late-cloud-id").success, false);
assert.equal(db.markConversationSynced(conversation.id, "late-cloud-id").success, true);
const unchanged = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(conversation.id);
assert.equal(unchanged.title, "Original title");
assert.equal(unchanged.cloud_id, "cloud-conv-late-write");
assert.equal(unchanged.sync_status, "pending");
assert.equal(db.createAgentConversation("Late note chat", note.id), null);
assert.equal(db.createAgentConversation("Late space chat", null, space.id), null);
assert.equal(db.createAgentConversation("Late folder chat", null, space.id, folder.id), null);
assert.ok(db.createAgentConversation("Unscoped chat"), "global chats remain valid");
const deletedNote = db.saveNote("Soft-deleted", "body").note;
db.deleteNote(deletedNote.id);
assert.equal(db.createAgentConversation("Deleted note chat", deletedNote.id), null);
const deletedSpace = createTestTeamSpace(db, { name: "Deleted scope" }).space;
db.db.prepare("UPDATE spaces SET deleted_at = datetime('now') WHERE id = ?").run(deletedSpace.id);
assert.equal(db.createAgentConversation("Deleted space chat", null, deletedSpace.id), null);
const liveSpace = createTestTeamSpace(db, { name: "Live scope" }).space;
const deletedFolder = db.createFolder("Deleted folder", liveSpace.id).folder;
db.markFolderSynced(deletedFolder.id, "cloud-folder-deleted-parent");
db.deleteFolder(deletedFolder.id);
assert.equal(
db.createAgentConversation("Deleted folder chat", null, liveSpace.id, deletedFolder.id),
null
);
});
test("destructive note cleanup retires chats while denied-delete cleanup preserves them", (t) => {
const db = createDb(t);
if (!db) return;
const doomed = db.saveNote("Doomed", "body").note;
const syncedChat = db.createAgentConversation("Synced note chat", doomed.id);
db.markConversationSynced(syncedChat.id, "cloud-conv-doomed");
db.addAgentMessage(syncedChat.id, "user", "remove after confirmed delete");
const localChat = db.createAgentConversation("Local note chat", doomed.id);
db.addAgentMessage(localChat.id, "user", "remove local chat");
assert.equal(db.hardDeleteNote(doomed.id).success, true);
const syncedTombstone = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(syncedChat.id);
assert.ok(syncedTombstone.deleted_at);
assert.equal(syncedTombstone.sync_status, "pending");
assert.equal(db.getAgentMessages(syncedChat.id).length, 0);
assert.equal(db.getAgentConversation(localChat.id), null);
assert.deepEqual(db.getConversationsForNote(doomed.id), []);
const recoverable = db.saveNote("Denied delete", "body").note;
db.markNoteSynced(recoverable.id, "cloud-note-recoverable");
const recoverableChat = db.createAgentConversation("Keep on denial", recoverable.id);
db.markConversationSynced(recoverableChat.id, "cloud-conv-recoverable");
db.addAgentMessage(recoverableChat.id, "user", "restore with server note");
assert.equal(db.deleteNote(recoverable.id).success, true);
assert.equal(db.restoreNoteAfterDeniedDelete(recoverable.id).success, true);
const revived = db.getNote(recoverable.id);
assert.equal(revived.id, recoverable.id);
assert.equal(revived.deleted_at, null);
assert.equal(revived.sync_status, "synced");
assert.equal(revived.updated_at, "1970-01-01 00:00:00");
const pulled = db.upsertNoteFromCloud(
{
id: "cloud-note-recoverable",
client_note_id: recoverable.client_note_id,
title: "Authoritative server note",
content: "server body",
created_at: recoverable.created_at,
updated_at: "2026-07-29 12:00:00",
},
null,
db.getPrivateSpaceId()
);
assert.equal(pulled.id, recoverable.id, "snapshot restore keeps the numeric note identity");
assert.equal(pulled.title, "Authoritative server note");
const preserved = db.getAgentConversation(recoverableChat.id);
assert.equal(preserved.note_id, recoverable.id);
assert.equal(preserved.deleted_at, null);
assert.equal(preserved.messages.length, 1);
});
test("denied folder delete restores the same notes, speakers, and conversations in place", (t) => {
let db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder = db.createFolder("Docs", space.id).folder;
db.markFolderSynced(folder.id, "cloud-folder-denied");
const child = db.saveNote("Child", "body", "personal", null, null, folder.id).note;
db.markNoteSynced(child.id, "cloud-note-child");
const localChild = db.saveNote(
"Local draft",
"never uploaded",
"personal",
null,
null,
folder.id
).note;
db.setSpeakerMapping(child.id, "SPEAKER_00", null, "Alice");
db.saveNoteSpeakerEmbeddings(child.id, { SPEAKER_00: Buffer.from([1, 2, 3, 4]) });
const childNoteConv = db.createAgentConversation("Child note chat", child.id);
db.markConversationSynced(childNoteConv.id, "cloud-conv-child");
db.addAgentMessage(childNoteConv.id, "user", "keep while folder delete is pending");
const localNoteConv = db.createAgentConversation("Local note chat", localChild.id);
db.addAgentMessage(localNoteConv.id, "user", "local note chat survives denial");
const localFolderConv = db.createAgentConversation("Folder chat", null, space.id, folder.id);
db.addAgentMessage(localFolderConv.id, "user", "local folder chat survives denial");
const syncedFolderConv = db.createAgentConversation(
"Synced folder chat",
null,
space.id,
folder.id
);
db.markConversationSynced(syncedFolderConv.id, "cloud-conv-1");
db.addAgentMessage(syncedFolderConv.id, "user", "recoverable until delete is accepted");
const alreadyDeleted = db.createAgentConversation("Already deleted", null, space.id, folder.id);
db.markConversationSynced(alreadyDeleted.id, "cloud-conv-already-deleted");
db.addAgentMessage(alreadyDeleted.id, "user", "independent tombstone");
db.deleteAgentConversation(alreadyDeleted.id);
const spaceConv = db.createAgentConversation("Space chat", null, space.id);
assert.equal(db.deleteFolder(folder.id).success, true);
const hiddenFolder = db.db.prepare("SELECT * FROM folders WHERE id = ?").get(folder.id);
assert.ok(hiddenFolder.deleted_at);
assert.equal(hiddenFolder.name, "Docs", "rollback keeps the original folder name in place");
assert.ok(!db.getFolders(space.id).some((candidate) => candidate.id === folder.id));
assert.deepEqual(db.getNotes(null, 100, folder.id), []);
assert.equal(
db.createFolder("Docs", space.id).success,
false,
"a held folder reserves its name so rollback cannot collide"
);
const hiddenChild = db.getNote(child.id);
const hiddenLocalChild = db.getNote(localChild.id);
assert.ok(hiddenChild.deleted_at);
assert.ok(hiddenLocalChild.deleted_at);
assert.equal(hiddenChild.sync_status, "folder_delete_pending");
assert.equal(hiddenLocalChild.sync_status, "folder_delete_pending");
assert.equal(db.getNoteByClientId(child.client_note_id).folder_delete_pending, 1);
assert.equal(hiddenLocalChild.content, "never uploaded");
assert.deepEqual(
db.getSpeakerMappings(child.id).map((row) => row.display_name),
["Alice"]
);
assert.equal(db.getNoteSpeakerEmbeddings(child.id).length, 1);
const childChatTombstone = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(childNoteConv.id);
assert.ok(childChatTombstone.deleted_at, "note-only chat is hidden with the optimistic delete");
assert.equal(childChatTombstone.note_id, child.id);
assert.equal(childChatTombstone.folder_id, null);
assert.equal(childChatTombstone.sync_status, "folder_delete_pending");
assert.equal(
db.getAgentMessages(childNoteConv.id).length,
1,
"synced note-chat content remains recoverable until the folder delete is accepted"
);
assert.deepEqual(db.getConversationsForNote(child.id), []);
assert.ok(db.db.prepare("SELECT id FROM agent_conversations WHERE id = ?").get(localNoteConv.id));
assert.ok(
db.db.prepare("SELECT id FROM agent_conversations WHERE id = ?").get(localFolderConv.id)
);
const optimisticTombstone = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(syncedFolderConv.id);
assert.ok(optimisticTombstone.deleted_at);
assert.equal(optimisticTombstone.sync_status, "folder_delete_pending");
assert.equal(
db.getConversationByClientId(syncedFolderConv.client_conversation_id).folder_delete_pending,
1
);
assert.equal(
db.getAgentMessages(syncedFolderConv.id).length,
1,
"an optimistic folder delete keeps synced messages recoverable until server acceptance"
);
assert.equal(db.getAgentMessages(localNoteConv.id).length, 1);
assert.equal(db.getAgentMessages(localFolderConv.id).length, 1);
// A late async acknowledgement may rewrite sync_status after the hold. The
// durable journal, not that transient status, must still own both queues.
db.db.prepare("UPDATE notes SET sync_status = 'pending' WHERE id = ?").run(child.id);
db.db
.prepare("UPDATE agent_conversations SET sync_status = 'pending' WHERE id = ?")
.run(childNoteConv.id);
assert.ok(
!db
.getPendingConversationDeletes()
.some(
(conversation) =>
conversation.id === childNoteConv.id ||
conversation.id === syncedFolderConv.id ||
conversation.id === localNoteConv.id ||
conversation.id === localFolderConv.id
),
"conversation deletes wait for the folder-delete result"
);
assert.ok(
db
.getPendingConversationDeletes()
.some((conversation) => conversation.id === alreadyDeleted.id),
"a pre-existing conversation tombstone remains independently queued"
);
assert.ok(
!db.getPendingNoteDeletes().some((note) => note.id === child.id),
"held child notes are not individually queued for deletion"
);
assert.equal(db.getConversationsForContainer(space.id, null)[0].id, spaceConv.id);
db.db.close();
db = new DatabaseManager();
db.setActiveAccountId("test-account");
const restored = db.restoreFolderAfterDeniedDelete(folder.id);
assert.equal(restored.success, true);
assert.equal(restored.folder.id, folder.id);
assert.deepEqual(
db
.getNotes(null, 100, folder.id)
.map((note) => note.id)
.sort((a, b) => a - b),
[child.id, localChild.id].sort((a, b) => a - b),
"both cloud-backed and local-only notes become visible with their original ids"
);
assert.equal(db.getNote(child.id).sync_status, "synced");
assert.equal(db.getNote(localChild.id).sync_status, "pending");
assert.equal(db.getNote(localChild.id).content, "never uploaded");
assert.deepEqual(
db.getConversationsForNote(child.id).map((conversation) => conversation.id),
[childNoteConv.id]
);
assert.equal(
db.db.prepare("SELECT sync_status FROM agent_conversations WHERE id = ?").get(childNoteConv.id)
.sync_status,
"synced",
"rollback restores metadata captured before a late acknowledgement"
);
assert.deepEqual(
db.getConversationsForNote(localChild.id).map((conversation) => conversation.id),
[localNoteConv.id]
);
assert.deepEqual(
db
.getConversationsForContainer(space.id, folder.id)
.map((conversation) => conversation.id)
.sort((a, b) => a - b),
[localFolderConv.id, syncedFolderConv.id].sort((a, b) => a - b)
);
assert.equal(db.getAgentConversation(childNoteConv.id).messages.length, 1);
assert.equal(
db.getAgentConversation(localNoteConv.id).messages[0].content,
"local note chat survives denial"
);
assert.equal(
db.getAgentConversation(localFolderConv.id).messages[0].content,
"local folder chat survives denial"
);
assert.deepEqual(
db.getSpeakerMappings(child.id).map((row) => row.display_name),
["Alice"]
);
assert.deepEqual([...db.getNoteSpeakerEmbeddings(child.id)[0].embedding], [1, 2, 3, 4]);
assert.equal(
db.db.prepare("SELECT deleted_at FROM agent_conversations WHERE id = ?").get(alreadyDeleted.id)
.deleted_at !== null,
true,
"rollback does not revive a conversation deleted before the folder action"
);
assert.equal(
db.db.prepare("SELECT sync_status FROM agent_conversations WHERE id = ?").get(alreadyDeleted.id)
.sync_status,
"pending"
);
assert.equal(
db.db
.prepare("SELECT COUNT(*) AS count FROM optimistic_folder_delete_rows WHERE folder_id = ?")
.get(folder.id).count,
0
);
});
test("denied folder delete rollback reports a name clash instead of failing hard", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder = db.createFolder("Docs", space.id).folder;
db.markFolderSynced(folder.id, "cloud-folder-held");
const child = db.saveNote("Child", "body", "personal", null, null, folder.id).note;
assert.equal(db.deleteFolder(folder.id).success, true);
const journalBefore = db.db
.prepare("SELECT COUNT(*) AS count FROM optimistic_folder_delete_rows WHERE folder_id = ?")
.get(folder.id).count;
assert.ok(journalBefore > 0);
// A pull inserts a teammate's live folder reusing the held name (the pull
// path bypasses the local name reservation, and the held row is deleted_at so
// the partial unique index doesn't stop the insert), so the name is no longer
// free when the server later denies the delete.
db.upsertFolderFromCloud(
{
client_folder_id: "cf-remote-docs",
id: "cloud-folder-live",
name: "Docs",
sort_order: 0,
created_at: "2026-07-01T00:00:00.000Z",
updated_at: "2026-07-02T00:00:00.000Z",
},
space.id
);
const restored = db.restoreFolderAfterDeniedDelete(folder.id);
assert.equal(restored.success, false);
assert.equal(
restored.reason,
"name-taken",
"a name clash is a recoverable, surfaced outcome — not a hard error the sync pass rethrows"
);
// The rollback transaction is atomic: a clash restores nothing, so the held
// folder and its journal stay intact for the next pass to retry once the user
// frees the name.
assert.ok(db.db.prepare("SELECT deleted_at FROM folders WHERE id = ?").get(folder.id).deleted_at);
assert.equal(
db.db
.prepare("SELECT COUNT(*) AS count FROM optimistic_folder_delete_rows WHERE folder_id = ?")
.get(folder.id).count,
journalBefore
);
assert.equal(db.getNote(child.id).sync_status, "folder_delete_pending");
});
test("confirmed folder delete scrubs chats and finalizes held rows", (t) => {
const db = createDb(t);
if (!db) return;
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const folder2 = db.createFolder("Specs", space.id).folder;
const childNote = db.saveNote(
"Folder note",
"sensitive body",
"personal",
null,
null,
folder2.id
).note;
const noteConv = db.createAgentConversation("Note-only chat", childNote.id);
db.markConversationSynced(noteConv.id, "cloud-conv-note");
db.addAgentMessage(noteConv.id, "user", "note-scoped sensitive content");
const conv2 = db.createAgentConversation("Specs chat", null, space.id, folder2.id);
db.markConversationSynced(conv2.id, "cloud-conv-2");
db.addAgentMessage(conv2.id, "user", "confirmed delete must scrub this");
db.hardDeleteFolder(folder2.id);
assert.equal(db.getNote(childNote.id), null);
const noteTombstone = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(noteConv.id);
assert.ok(noteTombstone.deleted_at);
assert.equal(noteTombstone.sync_status, "pending");
assert.equal(noteTombstone.folder_id, null, "regression fixture is scoped only by note_id");
assert.equal(db.getAgentMessages(noteConv.id).length, 0);
assert.deepEqual(db.getConversationsForNote(childNote.id), []);
const tombstoned = db.db.prepare("SELECT * FROM agent_conversations WHERE id = ?").get(conv2.id);
assert.ok(tombstoned.deleted_at);
assert.equal(tombstoned.sync_status, "pending");
assert.equal(
db.getAgentMessages(conv2.id).length,
0,
"a confirmed hard delete scrubs synced messages"
);
const folder3 = db.createFolder("Accepted", space.id).folder;
db.markFolderSynced(folder3.id, "cloud-folder-accepted");
const acceptedLocalNote = db.saveNote(
"Accepted local child",
"delete after confirmation",
"personal",
null,
null,
folder3.id
).note;
const acceptedLocalConv = db.createAgentConversation("Accepted local chat", acceptedLocalNote.id);
db.addAgentMessage(acceptedLocalConv.id, "user", "local content is held until confirmation");
const acceptedConv = db.createAgentConversation("Accepted chat", null, space.id, folder3.id);
db.markConversationSynced(acceptedConv.id, "cloud-conv-accepted");
db.addAgentMessage(acceptedConv.id, "user", "scrub after server acceptance");
const acceptedPredeleted = db.createAgentConversation(
"Accepted predeleted",
null,
space.id,
folder3.id
);
db.markConversationSynced(acceptedPredeleted.id, "cloud-conv-predeleted");
db.addAgentMessage(acceptedPredeleted.id, "user", "scrub but keep delete intent");
db.deleteAgentConversation(acceptedPredeleted.id);
assert.equal(db.deleteFolder(folder3.id).success, true);
assert.equal(
db.db.prepare("SELECT sync_status FROM agent_conversations WHERE id = ?").get(acceptedConv.id)
.sync_status,
"folder_delete_pending"
);
assert.equal(db.hardDeleteFolder(folder3.id).success, true);
const acceptedTombstone = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(acceptedConv.id);
assert.equal(acceptedTombstone.sync_status, "pending");
assert.equal(db.getAgentMessages(acceptedConv.id).length, 0);
assert.equal(db.getNote(acceptedLocalNote.id), null);
assert.equal(db.getAgentConversation(acceptedLocalConv.id), null);
const predeletedAfterConfirmation = db.db
.prepare("SELECT * FROM agent_conversations WHERE id = ?")
.get(acceptedPredeleted.id);
assert.ok(predeletedAfterConfirmation.deleted_at);
assert.equal(predeletedAfterConfirmation.sync_status, "pending");
assert.equal(db.getAgentMessages(acceptedPredeleted.id).length, 0);
const acceptedDeleteIds = new Set(
db.getPendingConversationDeletes().map((conversation) => conversation.id)
);
assert.ok(acceptedDeleteIds.has(acceptedConv.id));
assert.ok(acceptedDeleteIds.has(acceptedPredeleted.id));
});
for (const destination of ["personal", "team"]) {
test(`moveFolderToSpace preserves folder chats when moving to ${destination}`, (t) => {
const db = createDb(t);
if (!db) return;
t.after(() => db.db.close());
const source = createTestTeamSpace(db, { name: "Source" }).space;
const destinationId =
destination === "personal"
? db.getPrivateSpaceId()
: createTestTeamSpace(db, { name: "Destination" }).space.id;
const folder = db.createFolder("Moved", source.id).folder;
const chat = db.createAgentConversation("Moved chat", null, source.id, folder.id);
db.addAgentMessage(chat.id, "user", "Keep this history");
const messages = db.getAgentMessages(chat.id);
const stationary = db.createAgentConversation("Source chat", null, source.id);
db.addAgentMessage(stationary.id, "user", "Retire this history");
const privateChat = db.createAgentConversation("Private chat");
const moved = db.moveFolderToSpace(folder.id, destinationId);
assert.equal(moved.success, true);
assert.equal(moved.folder.space_id, destinationId);
assert.equal(db.getAgentConversation(chat.id).space_id, destinationId);
assert.deepEqual(
db.getConversationsForContainer(destinationId, folder.id).map((row) => row.id),
[chat.id]
);
assert.equal(db.purgeSpace(source.id).success, true);
assert.equal(db.getAgentConversation(chat.id).space_id, destinationId);
assert.deepEqual(db.getAgentMessages(chat.id), messages);
assert.deepEqual(
db.getConversationsForContainer(destinationId, folder.id).map((row) => row.id),
[chat.id]
);
assert.equal(db.getAgentConversation(stationary.id), null);
assert.deepEqual(db.getAgentMessages(stationary.id), []);
assert.ok(db.getAgentConversation(privateChat.id));
});
}
test("failed and unchanged folder moves preserve chat ownership and history", (t) => {
const db = createDb(t);
if (!db) return;
t.after(() => db.db.close());
const source = createTestTeamSpace(db, { name: "Source" }).space;
const destination = createTestTeamSpace(db, { name: "Destination" }).space;
const folder = db.createFolder("Docs", source.id).folder;
db.createFolder("Docs", destination.id);
const chat = db.createAgentConversation("Docs chat", null, source.id, folder.id);
db.addAgentMessage(chat.id, "user", "Keep this history");
const before = db.getAgentConversation(chat.id);
const messages = db.getAgentMessages(chat.id);
assert.equal(db.moveFolderToSpace(folder.id, source.id).success, true);
assert.equal(db.moveFolderToSpace(folder.id, destination.id).success, false);
assert.deepEqual(db.getAgentConversation(chat.id), before);
assert.deepEqual(db.getAgentMessages(chat.id), messages);
});
test("relocateRevokedFolder moves or retires the folder's conversations", (t) => {
const db = createDb(t);
if (!db) return;
const privateId = db.getPrivateSpaceId();
const space = createTestTeamSpace(db, { name: "Eng" }).space;
const kept = db.createFolder("Kept", space.id).folder;
const keptConv = db.createAgentConversation("Kept chat", null, space.id, kept.id);
assert.equal(db.relocateRevokedFolder(kept.id, privateId, true).success, true);
const moved = db.db.prepare("SELECT * FROM agent_conversations WHERE id = ?").get(keptConv.id);
assert.equal(moved.space_id, privateId, "chat follows the preserved folder");
assert.equal(moved.deleted_at, null);
const dropped = db.createFolder("Dropped", space.id).folder;
const droppedConv = db.createAgentConversation("Dropped chat", null, space.id, dropped.id);
assert.equal(db.relocateRevokedFolder(dropped.id, privateId, false).success, true);
assert.equal(
db.db.prepare("SELECT COUNT(*) AS n FROM agent_conversations WHERE id = ?").get(droppedConv.id)
.n,
0
);
});