@nessielabs/daemon 0.3.1 → 0.4.0

package/README.md

@@ -28,13 +28,11 @@ nessie-daemon stop
 nessie-daemon status
 ```
 
-The daemon registers selected local resources through sync preflight and pushes local agent traces. It does not pull cloud data.
+The daemon registers selected local resources through sync preflight, pulls this device's cloud sync state, and pushes local agent traces.
 
-Config is stored at `~/.config/nessie-daemon/config.json`; sync state is stored at `~/.local/state/nessie-daemon/state.json`.
+Config is stored at `~/.config/nessie-daemon/config.json`; the local sync graph is stored at `~/.local/state/nessie-daemon/nessie.sqlite`.
 
-Re-running `setup` rewrites the source selection and resets sync cursors, which can trigger a full re-scan and idempotent re-push of local history.
-
-The first implementation uses file `mtime` and `size` cursors. When a JSONL file changes, the daemon reparses that file and relies on stable node IDs for idempotent pushes.
+Re-running `setup` rewrites the source selection. The daemon reparses selected local history, reconciles it into SQLite, and only pushes rows whose local graph state has not been acknowledged by the cloud.
 
 ## systemd
 

package/dist/api/http.js

@@ -23,3 +23,22 @@ export async function postJson(baseUrl, path, body, options = {}) {
     }
     return (text ? JSON.parse(text) : {});
 }
+export async function getJson(baseUrl, path, options = {}) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const url = new URL(path, baseUrl);
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+        if (value !== undefined)
+            url.searchParams.set(key, value);
+    }
+    const response = await fetchImpl(url, {
+        method: "GET",
+        headers: {
+            ...(options.token ? { authorization: `Bearer ${options.token}` } : {}),
+        },
+    });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new ApiError(`HTTP status ${response.status}: ${text || response.statusText}`, response.status, text);
+    }
+    return (text ? JSON.parse(text) : {});
+}

package/dist/cli.js

@@ -1,13 +1,20 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 import { Command } from "commander";
 import { runDaemon } from "./commands/run.js";
 import { runServiceCommand } from "./commands/service.js";
 import { runSetup } from "./commands/setup.js";
+// Read the version from package.json so the reported version can never drift
+// from the published one. ../package.json resolves from both dist/cli.js
+// (installed) and src/cli.ts (tsx dev path), since both sit one level under
+// the package root, and npm always includes package.json in the tarball.
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
 const program = new Command();
 program
     .name("nessie-daemon")
     .description("Headless Nessie ingestion daemon for Linux agent machines.")
-    .version("0.3.1");
+    .version(version);
 program
     .command("setup")
     .description("Authenticate, select local sources, and optionally install the user systemd service.")

package/dist/commands/setup.js

@@ -2,7 +2,7 @@ import { checkbox, confirm } from "@inquirer/prompts";
 import { hostname } from "node:os";
 import { runDeviceAuth } from "../auth/deviceFlow.js";
 import { getDaemonPaths } from "../config/paths.js";
-import { createConfig, createInitialState, writeConfig, writeState } from "../config/store.js";
+import { createConfig, writeConfig } from "../config/store.js";
 import { installUserService } from "../service/systemd.js";
 import { detectSources } from "../sources/detect.js";
 export async function runSetup(options, depsOverride = {}) {
@@ -38,7 +38,6 @@ export async function runSetup(options, depsOverride = {}) {
         selectedSources,
     });
     await deps.writeConfig(config, deps.paths);
-    await deps.writeState(createInitialState(), deps.paths);
     console.log(`Saved config to ${deps.paths.configFile}`);
     if (await confirm({ message: "Install and start the user systemd service?", default: true })) {
         await installUserService(deps.paths);
@@ -59,7 +58,6 @@ async function runAPIKeySetup(input) {
         selectedSources: detectedSources,
     });
     await input.deps.writeConfig(config, input.deps.paths);
-    await input.deps.writeState(createInitialState(), input.deps.paths);
     console.log("Configured Nessie daemon with API key auth.");
     console.log(`Selected ${detectedSources.length} source(s):`);
     for (const source of detectedSources) {
@@ -72,7 +70,6 @@ function resolveSetupDeps(overrides) {
     return {
         detectSources: overrides.detectSources ?? detectSources,
         writeConfig: overrides.writeConfig ?? writeConfig,
-        writeState: overrides.writeState ?? writeState,
         paths: overrides.paths ?? getDaemonPaths(),
     };
 }

package/dist/config/paths.js

@@ -10,7 +10,7 @@ export function getDaemonPaths(env = process.env, home = homedir()) {
         configDir,
         stateDir,
         configFile: join(configDir, "config.json"),
-        stateFile: join(stateDir, "state.json"),
+        databaseFile: join(stateDir, "nessie.sqlite"),
         pidFile: join(stateDir, "daemon.pid"),
         logFile: join(stateDir, "daemon.log"),
         systemdUserDir,

package/dist/config/store.js

@@ -2,7 +2,6 @@ import { randomUUID } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { hostname } from "node:os";
 import { dirname } from "node:path";
-import { PARSER_VERSION } from "../parser/types.js";
 import { getDaemonPaths } from "./paths.js";
 export function createConfig(input) {
     const deviceId = input.deviceId ?? randomUUID();
@@ -19,15 +18,6 @@ export function createConfig(input) {
         })),
     };
 }
-export function createInitialState() {
-    return {
-        files: {},
-        pushedSourceRootIds: [],
-        pushedSessions: {},
-        parserVersion: PARSER_VERSION,
-        lastSyncAt: null,
-    };
-}
 export async function readConfig(paths = getDaemonPaths()) {
     return JSON.parse(await readFile(paths.configFile, "utf8"));
 }
@@ -35,29 +25,3 @@ export async function writeConfig(config, paths = getDaemonPaths()) {
     await mkdir(dirname(paths.configFile), { recursive: true });
     await writeFile(paths.configFile, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
 }
-export async function readState(paths = getDaemonPaths()) {
-    try {
-        const parsed = JSON.parse(await readFile(paths.stateFile, "utf8"));
-        return {
-            files: parsed.files ?? {},
-            pushedSourceRootIds: parsed.pushedSourceRootIds ?? [],
-            pushedSessions: parsed.pushedSessions ?? {},
-            // State written before parser versioning existed predates every
-            // versioned parser change, so it always needs the backfill pass.
-            parserVersion: parsed.parserVersion ?? 0,
-            lastSyncAt: parsed.lastSyncAt ?? null,
-        };
-    }
-    catch (error) {
-        if (isMissingFileError(error))
-            return createInitialState();
-        throw error;
-    }
-}
-export async function writeState(state, paths = getDaemonPaths()) {
-    await mkdir(dirname(paths.stateFile), { recursive: true });
-    await writeFile(paths.stateFile, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
-}
-function isMissingFileError(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}

package/dist/localStore/daemonGraphStore.js

@@ -0,0 +1,494 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import Database from "better-sqlite3";
+import { redactSecrets } from "../redact/secrets.js";
+import { contentHash } from "../sync/hash.js";
+import { splitContent } from "../sync/slices.js";
+import { messageMatches, messageMetadataChanged, messageNodeName, messageTimestamp, } from "./messageComparison.js";
+import { mapEdgePushItem, mapNodePushItem } from "./pushMapping.js";
+import { createDaemonGraphSchema } from "./schema.js";
+import { uuidFromBytes, uuidToBytes } from "./uuid.js";
+const NODE_CANDIDATE_LIMIT = 500;
+export class DaemonGraphStore {
+    db;
+    lastTimestampMs = 0;
+    constructor(db) {
+        this.db = db;
+        createDaemonGraphSchema(db);
+    }
+    close() {
+        this.db.close();
+    }
+    persistSourceSessions(source, sessions, options) {
+        const persist = this.db.transaction(() => {
+            this.ensureIntegrationRoot(source);
+            for (const session of sessions) {
+                this.persistSession(source, session, options);
+            }
+        });
+        persist();
+    }
+    conversationsNeedingFetch(source, conversations, parserVersion) {
+        const kind = source.kind === "codex" ? "codex_chat" : "claude_code_chat";
+        const select = this.db.prepare(`
+      SELECT parserVersion, originalUpdatedAt
+      FROM node
+      WHERE kind = ? AND sourceId = ? AND deletedAt IS NULL
+      ORDER BY createdAt ASC
+      LIMIT 1
+    `);
+        this.ensureIntegrationRoot(source);
+        return conversations.filter((conversation) => {
+            const row = select.get(kind, conversation.sourceId);
+            if (!row)
+                return true;
+            const remoteUpdatedAt = conversation.lastMessageTime ?? conversation.updatedAt;
+            const isUpdated = remoteUpdatedAt
+                ? Date.parse(remoteUpdatedAt) - Date.parse(row.originalUpdatedAt) > 5000
+                : false;
+            if (row.parserVersion !== null && row.parserVersion < parserVersion)
+                return true;
+            return isUpdated;
+        });
+    }
+    pendingPushItems() {
+        const nodes = this.dirtyNodes().map((node) => this.mapNodePushItem(node));
+        const edges = this.dirtyEdges().map((edge) => this.mapEdgePushItem(edge));
+        return { nodes, edges };
+    }
+    nextPushBatch(options) {
+        const nodeRows = this.dirtyNodes(NODE_CANDIDATE_LIMIT);
+        const nodes = [];
+        const pushedNodeVersions = {};
+        let sliceCount = 0;
+        for (const row of nodeRows) {
+            const node = this.mapNodePushItem(row);
+            const nodeSliceCount = node.slices.length;
+            if (nodes.length > 0 && sliceCount + nodeSliceCount > options.targetSliceCount)
+                break;
+            nodes.push(node);
+            pushedNodeVersions[node.node.id] = row.updatedAt;
+            sliceCount += nodeSliceCount;
+        }
+        if (nodes.length > 0)
+            return { nodes, edges: [], pushedNodeVersions, pushedEdgeVersions: {} };
+        const edgeRows = this.dirtyEdges(options.edgeLimit);
+        const pushedEdgeVersions = {};
+        const edges = edgeRows.map((edge) => {
+            const item = this.mapEdgePushItem(edge);
+            pushedEdgeVersions[item.edge.id] = edge.updatedAt;
+            return item;
+        });
+        return edges.length > 0 ? { nodes: [], edges, pushedNodeVersions: {}, pushedEdgeVersions } : null;
+    }
+    applyPushAcknowledgements(batch, response) {
+        const apply = this.db.transaction(() => {
+            const updateNode = this.db.prepare(`
+        UPDATE node SET lastPushedAt = ?, cloudUpdatedAt = ?
+        WHERE id = ?
+      `);
+            for (const ack of response.nodes) {
+                const pushedUpdatedAt = batch.pushedNodeVersions[ack.id];
+                if (!pushedUpdatedAt)
+                    continue;
+                updateNode.run(pushedUpdatedAt, ack.updatedAt, uuidToBytes(ack.id));
+            }
+            const updateEdge = this.db.prepare(`
+        UPDATE node_edge SET lastPushedAt = ?, cloudUpdatedAt = ?
+        WHERE id = ?
+      `);
+            for (const ack of response.edges) {
+                const pushedUpdatedAt = batch.pushedEdgeVersions[ack.id];
+                if (!pushedUpdatedAt)
+                    continue;
+                updateEdge.run(pushedUpdatedAt, ack.updatedAt, uuidToBytes(ack.id));
+            }
+        });
+        apply();
+    }
+    applyCloudPull(response) {
+        const apply = this.db.transaction(() => {
+            let skippedEdges = 0;
+            for (const bundle of response.nodes) {
+                this.applyCloudPullNodeBundle(bundle);
+            }
+            for (const edge of response.edges) {
+                if (!this.applyCloudPullEdge(edge))
+                    skippedEdges += 1;
+            }
+            return { skippedEdges };
+        });
+        return apply();
+    }
+    getAppSetting(key) {
+        const row = this.db.prepare("SELECT value FROM app_setting WHERE key = ?").get(key);
+        return row?.value ?? null;
+    }
+    getSyncCursor(key) {
+        const value = this.getAppSetting(key);
+        if (!value)
+            return null;
+        try {
+            const parsed = JSON.parse(value);
+            return typeof parsed.updatedAt === "string" && typeof parsed.id === "string"
+                ? { updatedAt: parsed.updatedAt, id: parsed.id }
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    setAppSetting(key, value) {
+        this.db.prepare(`
+      INSERT INTO app_setting (key, value) VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `).run(key, value);
+    }
+    setSyncCursor(key, cursor) {
+        this.setAppSetting(key, JSON.stringify(cursor));
+    }
+    ensureIntegrationRoot(source) {
+        const now = this.nextTimestamp();
+        const id = uuidToBytes(source.localId);
+        const existing = this.nodeById(id);
+        const name = redactSecrets(source.displayName);
+        if (!existing) {
+            this.insertNode({
+                id,
+                integrationId: id,
+                sourceId: source.basePath,
+                name,
+                kind: "integration_root",
+                originalCreatedAt: now,
+                originalUpdatedAt: now,
+                now,
+            });
+            return id;
+        }
+        if (existing.integrationId?.equals(id) !== true ||
+            existing.sourceId !== source.basePath ||
+            existing.name !== name ||
+            existing.kind !== "integration_root" ||
+            existing.deletedAt !== null) {
+            this.db.prepare(`
+        UPDATE node
+        SET integrationId = ?, sourceId = ?, name = ?, kind = 'integration_root',
+          updatedAt = ?, originalUpdatedAt = ?, deletedAt = NULL
+        WHERE id = ?
+      `).run(id, source.basePath, name, now, now, id);
+        }
+        return id;
+    }
+    persistSession(source, session, options) {
+        const now = this.nextTimestamp();
+        const transcriptKind = session.sourceKind === "codex" ? "codex_chat" : "claude_code_chat";
+        const messageKind = session.sourceKind === "codex" ? "codex_chat_message" : "claude_code_chat_message";
+        const integrationId = uuidToBytes(source.localId);
+        const repoInfo = session.cwd ? options.resolveRepo?.(session.cwd) ?? null : null;
+        const transcript = this.upsertTranscript({
+            integrationId,
+            sourceId: session.sourceId,
+            name: redactSecrets(session.title),
+            kind: transcriptKind,
+            workspacePath: session.cwd,
+            repoRemoteUrl: repoInfo?.remoteUrl ?? null,
+            repoKey: repoInfo?.repoKey ?? null,
+            parserVersion: options.parserVersion,
+            originalCreatedAt: session.createdAt,
+            originalUpdatedAt: session.updatedAt,
+            now,
+        });
+        this.ensureSourceEdge(integrationId, transcript.id, now);
+        const existingMessages = this.existingMessages(transcript.id);
+        const pushableMessages = session.messages.filter((message) => message.role !== "system");
+        const keptIds = new Set();
+        for (const [index, message] of pushableMessages.entries()) {
+            const existing = existingMessages[index];
+            if (existing && messageMatches(existing, message, messageKind)) {
+                const timestamp = messageTimestamp(message, session);
+                if (messageMetadataChanged(existing.node, message, integrationId, messageKind, timestamp)) {
+                    this.db.prepare(`
+            UPDATE node
+            SET integrationId = ?, name = ?, kind = ?, originalCreatedAt = ?,
+              originalUpdatedAt = ?, updatedAt = ?, deletedAt = NULL
+            WHERE id = ?
+          `).run(integrationId, messageNodeName(message), messageKind, timestamp, timestamp, now, existing.node.id);
+                }
+                this.ensureSourceEdge(integrationId, existing.node.id, now);
+                this.ensureContainsEdge(transcript.id, existing.node.id, index, now);
+                keptIds.add(uuidFromBytes(existing.node.id));
+                continue;
+            }
+            const nodeId = uuidToBytes(randomUUID());
+            const content = redactSecrets(message.content);
+            const timestamp = messageTimestamp(message, session);
+            this.insertNode({
+                id: nodeId,
+                integrationId,
+                sourceId: null,
+                name: messageNodeName(message),
+                kind: messageKind,
+                originalCreatedAt: timestamp,
+                originalUpdatedAt: timestamp,
+                now,
+            });
+            this.db.prepare(`
+        INSERT INTO ai_chat_message (nodeId, role, author, toolCallId, toolName, toolFriendlyName, toolStatus)
+        VALUES (?, ?, NULL, NULL, NULL, NULL, NULL)
+      `).run(nodeId, message.role);
+            this.replaceContentSlices(nodeId, content);
+            this.ensureContainsEdge(transcript.id, nodeId, index, now);
+            this.ensureSourceEdge(integrationId, nodeId, now);
+            keptIds.add(uuidFromBytes(nodeId));
+        }
+        for (const existing of existingMessages) {
+            if (!keptIds.has(uuidFromBytes(existing.node.id)))
+                this.softDeleteNode(existing.node.id, now);
+        }
+    }
+    upsertTranscript(input) {
+        const existing = this.db.prepare(`
+      SELECT * FROM node
+      WHERE kind = ? AND sourceId = ?
+      ORDER BY createdAt ASC
+      LIMIT 1
+    `).get(input.kind, input.sourceId);
+        if (!existing) {
+            const id = uuidToBytes(randomUUID());
+            this.insertNode({ id, ...input });
+            return this.nodeById(id);
+        }
+        if (existing.integrationId?.equals(input.integrationId) !== true ||
+            existing.name !== input.name ||
+            existing.workspacePath !== input.workspacePath ||
+            existing.repoRemoteUrl !== input.repoRemoteUrl ||
+            existing.repoKey !== input.repoKey ||
+            existing.parserVersion !== input.parserVersion ||
+            existing.originalCreatedAt !== input.originalCreatedAt ||
+            existing.originalUpdatedAt !== input.originalUpdatedAt ||
+            existing.deletedAt !== null) {
+            this.db.prepare(`
+        UPDATE node
+        SET integrationId = ?, name = ?, workspacePath = ?, repoRemoteUrl = ?,
+          repoKey = ?, parserVersion = ?, originalCreatedAt = ?, originalUpdatedAt = ?,
+          updatedAt = ?, deletedAt = NULL
+        WHERE id = ?
+      `).run(input.integrationId, input.name, input.workspacePath, input.repoRemoteUrl, input.repoKey, input.parserVersion, input.originalCreatedAt, input.originalUpdatedAt, input.now, existing.id);
+            return this.nodeById(existing.id);
+        }
+        return existing;
+    }
+    insertNode(input) {
+        this.db.prepare(`
+      INSERT INTO node (
+        id, integrationId, sourceId, name, kind, pinned, workspacePath,
+        repoRemoteUrl, repoKey, createdAt, updatedAt, parserVersion,
+        originalCreatedAt, originalUpdatedAt
+      )
+      VALUES (?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(input.id, input.integrationId, input.sourceId, input.name, input.kind, input.workspacePath ?? null, input.repoRemoteUrl ?? null, input.repoKey ?? null, input.now, input.now, input.parserVersion ?? null, input.originalCreatedAt, input.originalUpdatedAt);
+    }
+    ensureContainsEdge(fromNodeId, toNodeId, sortIndex, now) {
+        this.ensureEdge(fromNodeId, toNodeId, "contains", sortIndex, now);
+    }
+    ensureSourceEdge(fromNodeId, toNodeId, now) {
+        this.ensureEdge(fromNodeId, toNodeId, "source_of", 0, now);
+    }
+    ensureEdge(fromNodeId, toNodeId, type, sortIndex, now) {
+        const existing = this.db.prepare(`
+      SELECT * FROM node_edge
+      WHERE fromNodeId = ? AND toNodeId = ? AND type = ?
+      LIMIT 1
+    `).get(fromNodeId, toNodeId, type);
+        if (!existing) {
+            this.db.prepare(`
+        INSERT INTO node_edge (id, fromNodeId, toNodeId, type, sortIndex, createdAt, updatedAt)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(uuidToBytes(randomUUID()), fromNodeId, toNodeId, type, sortIndex, now, now);
+            return;
+        }
+        if (existing.sortIndex !== sortIndex || existing.deletedAt !== null) {
+            this.db.prepare(`
+        UPDATE node_edge
+        SET sortIndex = ?, updatedAt = ?, deletedAt = NULL
+        WHERE id = ?
+      `).run(sortIndex, now, existing.id);
+        }
+    }
+    replaceContentSlices(nodeId, content) {
+        this.db.prepare("DELETE FROM node_content_slice WHERE nodeId = ?").run(nodeId);
+        const insert = this.db.prepare(`
+      INSERT INTO node_content_slice (id, nodeId, "index", content, contentHash)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        for (const [index, piece] of splitContent(content).entries()) {
+            insert.run(uuidToBytes(randomUUID()), nodeId, index, piece, contentHash(piece));
+        }
+    }
+    applyCloudPullNodeBundle(bundle) {
+        const nodeId = uuidToBytes(bundle.node.id);
+        const existing = this.nodeById(nodeId);
+        if (existing?.cloudUpdatedAt === bundle.node.updatedAt)
+            return;
+        const now = this.nextTimestamp();
+        this.db.prepare(`
+      INSERT INTO node (
+        id, integrationId, sourceId, name, kind, emoji, pinned, label, labelSliceCount,
+        workspacePath, repoRemoteUrl, repoKey, createdAt, updatedAt, lastPushedAt,
+        cloudUpdatedAt, parserVersion, deletedAt, originalCreatedAt, originalUpdatedAt
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        integrationId = excluded.integrationId,
+        sourceId = excluded.sourceId,
+        name = excluded.name,
+        kind = excluded.kind,
+        emoji = excluded.emoji,
+        pinned = excluded.pinned,
+        label = excluded.label,
+        labelSliceCount = excluded.labelSliceCount,
+        workspacePath = excluded.workspacePath,
+        repoRemoteUrl = excluded.repoRemoteUrl,
+        repoKey = excluded.repoKey,
+        updatedAt = excluded.updatedAt,
+        lastPushedAt = excluded.lastPushedAt,
+        cloudUpdatedAt = excluded.cloudUpdatedAt,
+        deletedAt = excluded.deletedAt,
+        originalCreatedAt = excluded.originalCreatedAt,
+        originalUpdatedAt = excluded.originalUpdatedAt
+    `).run(nodeId, bundle.node.integrationId ? uuidToBytes(bundle.node.integrationId) : null, bundle.node.sourceId ?? null, bundle.node.name, bundle.node.kind, bundle.node.emoji ?? null, bundle.node.pinned === true ? 1 : 0, bundle.node.label ?? null, bundle.node.labelSliceCount ?? null, bundle.node.workspacePath ?? null, bundle.node.repoRemoteUrl ?? null, bundle.node.repoKey ?? null, existing?.createdAt ?? now, now, now, bundle.node.updatedAt, existing?.parserVersion ?? null, bundle.node.deletedAt ?? null, bundle.node.originalCreatedAt, bundle.node.originalUpdatedAt);
+        this.replacePulledContentSlices(nodeId, bundle.slices);
+        this.replacePulledAiChatMessage(nodeId, bundle.aiChatMessage ?? null);
+    }
+    applyCloudPullEdge(edge) {
+        const id = uuidToBytes(edge.id);
+        const fromNodeId = uuidToBytes(edge.fromNodeId);
+        const toNodeId = uuidToBytes(edge.toNodeId);
+        if (!this.nodeById(fromNodeId) || !this.nodeById(toNodeId))
+            return false;
+        const existing = this.db.prepare("SELECT createdAt, cloudUpdatedAt FROM node_edge WHERE id = ?")
+            .get(id);
+        if (existing?.cloudUpdatedAt === edge.updatedAt)
+            return true;
+        const now = this.nextTimestamp();
+        this.db.prepare(`
+      INSERT INTO node_edge (
+        id, fromNodeId, toNodeId, type, sortIndex, createdAt, updatedAt,
+        lastPushedAt, cloudUpdatedAt, deletedAt
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        fromNodeId = excluded.fromNodeId,
+        toNodeId = excluded.toNodeId,
+        type = excluded.type,
+        sortIndex = excluded.sortIndex,
+        updatedAt = excluded.updatedAt,
+        lastPushedAt = excluded.lastPushedAt,
+        cloudUpdatedAt = excluded.cloudUpdatedAt,
+        deletedAt = excluded.deletedAt
+    `).run(id, fromNodeId, toNodeId, edge.type, edge.sortIndex ?? null, existing?.createdAt ?? now, now, now, edge.updatedAt, edge.deletedAt ?? null);
+        return true;
+    }
+    replacePulledContentSlices(nodeId, slices) {
+        this.db.prepare("DELETE FROM node_content_slice WHERE nodeId = ?").run(nodeId);
+        const insert = this.db.prepare(`
+      INSERT INTO node_content_slice (id, nodeId, "index", content, contentHash)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        for (const slice of slices) {
+            insert.run(uuidToBytes(slice.id), nodeId, slice.index, slice.content, slice.contentHash);
+        }
+    }
+    replacePulledAiChatMessage(nodeId, message) {
+        this.db.prepare("DELETE FROM ai_chat_message WHERE nodeId = ?").run(nodeId);
+        if (!message)
+            return;
+        this.db.prepare(`
+      INSERT INTO ai_chat_message (nodeId, role, author, toolCallId, toolName, toolFriendlyName, toolStatus)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(nodeId, message.role, message.author ?? null, message.toolCallId ?? null, message.toolName ?? null, message.toolFriendlyName ?? null, message.toolStatus ?? null);
+    }
+    softDeleteNode(id, now) {
+        this.db.prepare("UPDATE node SET deletedAt = ?, updatedAt = ? WHERE id = ? AND deletedAt IS NULL")
+            .run(now, now, id);
+        this.db.prepare(`
+      UPDATE node_edge
+      SET deletedAt = ?, updatedAt = ?
+      WHERE (fromNodeId = ? OR toNodeId = ?) AND deletedAt IS NULL
+    `).run(now, now, id, id);
+    }
+    existingMessages(transcriptId) {
+        const rows = this.db.prepare(`
+      SELECT n.*, ai.role, ai.author, ai.toolCallId, ai.toolName, ai.toolStatus
+      FROM node_edge e
+      JOIN node n ON n.id = e.toNodeId
+      LEFT JOIN ai_chat_message ai ON ai.nodeId = n.id
+      WHERE e.fromNodeId = ? AND e.type = 'contains'
+        AND e.deletedAt IS NULL AND n.deletedAt IS NULL
+      ORDER BY e.sortIndex ASC, n.createdAt ASC
+    `).all(transcriptId);
+        return rows.map((row) => ({
+            node: row,
+            role: row.role,
+            author: row.author,
+            toolCallId: row.toolCallId,
+            toolName: row.toolName,
+            toolStatus: row.toolStatus,
+            contentHashes: this.contentHashes(row.id),
+        }));
+    }
+    contentHashes(nodeId) {
+        const rows = this.db.prepare(`
+      SELECT contentHash
+      FROM node_content_slice
+      WHERE nodeId = ?
+      ORDER BY "index" ASC
+    `).all(nodeId);
+        return rows.map((row) => row.contentHash);
+    }
+    dirtyNodes(limit) {
+        return this.db.prepare(`
+      SELECT *
+      FROM node
+      WHERE lastPushedAt IS NULL OR updatedAt > lastPushedAt
+      ORDER BY
+        CASE kind
+          WHEN 'integration_root' THEN 0
+          WHEN 'codex_chat' THEN 1
+          WHEN 'claude_code_chat' THEN 1
+          ELSE 2
+        END ASC,
+        updatedAt ASC,
+        hex(id) ASC
+      ${limit === undefined ? "" : "LIMIT ?"}
+    `).all(...(limit === undefined ? [] : [limit]));
+    }
+    dirtyEdges(limit) {
+        return this.db.prepare(`
+      SELECT *
+      FROM node_edge
+      WHERE lastPushedAt IS NULL OR updatedAt > lastPushedAt
+      ORDER BY updatedAt ASC, hex(id) ASC
+      ${limit === undefined ? "" : "LIMIT ?"}
+    `).all(...(limit === undefined ? [] : [limit]));
+    }
+    mapNodePushItem(row) {
+        return mapNodePushItem(this.db, row);
+    }
+    mapEdgePushItem(row) {
+        return mapEdgePushItem(row);
+    }
+    nodeById(id) {
+        return this.db.prepare("SELECT * FROM node WHERE id = ?").get(id);
+    }
+    nextTimestamp() {
+        const ms = Math.max(Date.now(), this.lastTimestampMs + 1);
+        this.lastTimestampMs = ms;
+        return new Date(ms).toISOString();
+    }
+}
+export function openDaemonGraphStore(databaseFile) {
+    mkdirSync(dirname(databaseFile), { recursive: true });
+    return new DaemonGraphStore(new Database(databaseFile));
+}