@hyperdrive.bot/fleet-server 0.3.164 → 0.3.166

package/dist/server/server/schedule/store.js

@@ -1,8 +1,9 @@
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { StoredScheduleSchema, } from "@hyperdrive.bot/fleet-protocol/schedule/types";
 import { writeJsonFileAtomic } from "../atomic-file.js";
+import { ScopeSync } from "../state/state-db.js";
 /**
  * How many runs a schedule file keeps. Every run start and finish rewrites the
  * whole file, and the history grew unbounded (5,510 runs, 2.3 MB in one real
@@ -73,12 +74,15 @@ function generateScheduleId() {
  * changes back through `put`.
  */
 export class ScheduleStore {
-    constructor(dir) {
+    constructor(dir, options = {}) {
         this.dir = dir;
         this.cache = new Map();
         this.stamps = new Map();
         this.validating = null;
         this.revision = 0;
+        this.sqlite = options.stateDb
+            ? new SqliteScheduleStore(options.stateDb, dir, options.logger)
+            : null;
     }
     filePath(id) {
         return join(this.dir, `${id}.json`);
@@ -143,10 +147,14 @@ export class ScheduleStore {
         }
     }
     async list() {
+        if (this.sqlite)
+            return this.sqlite.list();
         await this.validate();
         return [...this.cache.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
     }
     async get(id) {
+        if (this.sqlite)
+            return this.sqlite.get(id);
         await this.validate();
         return this.cache.get(id) ?? null;
     }
@@ -186,6 +194,8 @@ export class ScheduleStore {
         return created;
     }
     async put(schedule) {
+        if (this.sqlite)
+            return this.sqlite.put(schedule);
         await this.ensureDir();
         const name = `${schedule.id}.json`;
         const path = this.filePath(schedule.id);
@@ -207,6 +217,8 @@ export class ScheduleStore {
         this.revision += 1;
     }
     async delete(id) {
+        if (this.sqlite)
+            return this.sqlite.delete(id);
         await this.ensureDir();
         await rm(this.filePath(id), { force: true });
         this.cache.delete(id);
@@ -218,8 +230,277 @@ export class ScheduleStore {
      * put, a delete), so a caller can reuse anything it derived from `list()`
      * until the store actually changes.
      */
+    get version() {
+        return this.sqlite ? this.sqlite.version : this.revision;
+    }
+}
+const MANIFEST_STORE = "schedules";
+/** Upper bound on how stale an in-place edit of a schedule file can go unseen. */
+export const EXTERNAL_EDIT_RECHECK_MS = 1000;
+function runProgress(run) {
+    // A finished run beats a running one; between two of the same kind, the later.
+    return (run.status === "running" ? 0 : 1e15) + Date.parse(run.endedAt ?? run.startedAt);
+}
+/**
+ * Merge a schedule file written by someone else into the daemon's copy.
+ *
+ * Top-level fields come from whichever side has the newer `updatedAt`, as one
+ * unit, so a field the newer side cleared is not resurrected by the older one.
+ * Runs merge by id: a run on one side only is kept (the cap drops the oldest
+ * afterwards, so runs the daemon trimmed stay trimmed), and for the same id
+ * the more advanced run wins, so a completion written on either side is never
+ * replaced by the other side's "running" copy.
+ */
+export function mergeExternalSchedule(daemon, file) {
+    const newer = Date.parse(file.updatedAt) >= Date.parse(daemon.updatedAt) ? file : daemon;
+    const byId = new Map();
+    for (const run of [...daemon.runs, ...file.runs]) {
+        const seen = byId.get(run.id);
+        if (!seen || runProgress(run) > runProgress(seen)) {
+            byId.set(run.id, run);
+        }
+    }
+    const runs = [...byId.values()].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+    return { ...newer, runs };
+}
+/**
+ * Schedules in `state.sqlite`, with the same public surface as the file store
+ * (which delegates here when the daemon has a state database). A run start or
+ * finish used to rewrite the whole
+ * file (2.3 MB for the busiest real schedule); here it writes the one run row
+ * that changed. The legacy file is still written, debounced, by the mirror.
+ *
+ * The directory stays an input as well: a file whose content no longer matches
+ * what this daemon last wrote (the legacy manifest) is read back in and merged
+ * (`takeExternalEdits`), and a file someone deleted deletes the schedule. That
+ * keeps the contract that a schedule hand-written into schedules/ is picked up
+ * by a running daemon. The mirror re-checks the file right before overwriting
+ * it, so a hand edit made while a write was pending is merged, not lost.
+ */
+class SqliteScheduleStore {
+    constructor(state, dir, logger) {
+        this.state = state;
+        this.dir = dir;
+        this.logger = logger;
+        this.cache = null;
+        this.loading = null;
+        this.revision = 0;
+        this.dirMtime = null;
+        this.lastFullCheck = 0;
+        this.schedules = state.doc("schedules");
+        this.runs = new ScopeSync(state.doc("schedule_runs"));
+    }
     get version() {
         return this.revision;
     }
+    filePath(id) {
+        return join(this.dir, `${id}.json`);
+    }
+    async load() {
+        if (this.cache) {
+            const cache = this.cache;
+            const edited = await this.takeExternalEdits((id) => cache.get(id) ?? null);
+            for (const schedule of edited) {
+                cache.set(schedule.id, schedule);
+            }
+            if (edited.length > 0) {
+                this.revision += 1;
+            }
+            return cache;
+        }
+        this.loading ?? (this.loading = this.loadAll().finally(() => {
+            this.loading = null;
+        }));
+        return this.loading;
+    }
+    async list() {
+        const cache = await this.load();
+        return [...cache.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    }
+    async get(id) {
+        return (await this.load()).get(id) ?? null;
+    }
+    async loadAll() {
+        await mkdir(this.dir, { recursive: true });
+        const runRows = this.state.doc("schedule_runs").loadAll();
+        this.runs.seed(runRows);
+        const runsBySchedule = new Map();
+        for (const row of runRows) {
+            const list = runsBySchedule.get(row.scope) ?? [];
+            list.push(JSON.parse(row.body));
+            runsBySchedule.set(row.scope, list);
+        }
+        const maxRunRev = new Map();
+        for (const row of runRows) {
+            maxRunRev.set(row.scope, Math.max(maxRunRev.get(row.scope) ?? 0, row.rev));
+        }
+        const loaded = new Map();
+        const behind = [];
+        const entries = this.state.manifest.entries(MANIFEST_STORE);
+        for (const row of this.schedules.loadAll("")) {
+            const schedule = JSON.parse(row.body);
+            schedule.runs = runsBySchedule.get(row.id) ?? [];
+            loaded.set(schedule.id, schedule);
+            // The process died before the mirror caught this schedule's file up.
+            const mirrored = entries.get(this.filePath(row.id))?.rev ?? -1;
+            if (Math.max(row.rev, maxRunRev.get(row.id) ?? 0) > mirrored)
+                behind.push(schedule);
+        }
+        this.cache = loaded;
+        for (const schedule of await this.takeExternalEdits((id) => loaded.get(id) ?? null)) {
+            loaded.set(schedule.id, schedule);
+        }
+        for (const schedule of behind) {
+            if (loaded.get(schedule.id) === schedule)
+                this.mirrorWrite(schedule);
+        }
+        this.revision += 1;
+        return loaded;
+    }
+    async put(input) {
+        const cache = await this.load();
+        const schedule = capScheduleRuns(input);
+        const { runs, ...rest } = schedule;
+        await Promise.all([
+            this.schedules.put("", schedule.id, rest),
+            this.runs.sync(schedule.id, runs.map((run) => ({ id: run.id, value: run })), { prune: true }),
+        ]);
+        cache.set(schedule.id, schedule);
+        this.revision += 1;
+        this.mirrorWrite(schedule);
+    }
+    async delete(id) {
+        const cache = await this.load();
+        await Promise.all([this.schedules.remove("", id), this.runs.dropScope(id)]);
+        cache.delete(id);
+        this.revision += 1;
+        this.state.mirror.write(`schedule:${id}`, async () => {
+            await rm(this.filePath(id), { force: true });
+            await this.state.manifest.forget(this.filePath(id));
+        });
+    }
+    async takeExternalEdits(current) {
+        let dirMtime;
+        try {
+            dirMtime = (await stat(this.dir)).mtimeMs;
+        }
+        catch {
+            return [];
+        }
+        // A new or renamed file bumps the directory mtime and is read at once. An
+        // in-place edit does not, so the per-file stats also run at most once per
+        // EXTERNAL_EDIT_RECHECK_MS; between those a read costs one stat.
+        const now = Date.now();
+        if (dirMtime === this.dirMtime && now - this.lastFullCheck < EXTERNAL_EDIT_RECHECK_MS) {
+            return [];
+        }
+        this.dirMtime = dirMtime;
+        this.lastFullCheck = now;
+        const edited = [];
+        const entries = this.state.manifest.entries(MANIFEST_STORE);
+        const ids = new Set();
+        for (const entry of await readdir(this.dir, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith(".json") || entry.name.startsWith(".")) {
+                continue;
+            }
+            ids.add(entry.name.slice(0, -".json".length));
+        }
+        for (const entryPath of entries.keys()) {
+            ids.add(basename(entryPath, ".json"));
+        }
+        for (const id of ids) {
+            // Our own write in flight: the manifest catches up when it lands.
+            if (this.state.mirror.isRunning(`schedule:${id}`))
+                continue;
+            const path = this.filePath(id);
+            try {
+                const file = await this.state.manifest.classify(path, entries.get(path) ?? null);
+                if (file.status === "deleted") {
+                    // Deleted by someone else: a deletion wins, so an active schedule is
+                    // never brought back.
+                    if (current(id)) {
+                        await Promise.all([this.schedules.remove("", id), this.runs.dropScope(id)]);
+                        this.cache?.delete(id);
+                        this.revision += 1;
+                    }
+                    await this.state.manifest.forget(path);
+                    continue;
+                }
+                if (file.status !== "changed" && file.status !== "created")
+                    continue;
+                const schedule = await this.adoptForeign(id, file.content, current(id));
+                edited.push(schedule);
+            }
+            catch (error) {
+                // A half-written or invalid file is retried when it changes next; a
+                // failed commit is worth knowing about.
+                this.logger?.warn({ err: error, path }, "Failed to read back an externally edited schedule");
+            }
+        }
+        return edited;
+    }
+    /**
+     * Merge a file someone else wrote into the daemon's copy, commit it, record
+     * the file as seen, and queue the merged result back out when it differs.
+     */
+    async adoptForeign(id, content, existing) {
+        const fromFile = StoredScheduleSchema.parse(JSON.parse(content));
+        const schedule = capScheduleRuns(existing ? mergeExternalSchedule(existing, fromFile) : fromFile);
+        const { runs, ...rest } = schedule;
+        await Promise.all([
+            this.schedules.put("", schedule.id, rest),
+            this.runs.sync(schedule.id, runs.map((run) => ({ id: run.id, value: run })), { prune: true }),
+        ]);
+        this.cache?.set(schedule.id, schedule);
+        this.revision += 1;
+        await this.state.manifest.record(MANIFEST_STORE, this.filePath(id), this.state.mirrorRev());
+        if (existing) {
+            // The merge may differ from the file: write the result back out.
+            this.mirrorWrite(schedule);
+        }
+        return schedule;
+    }
+    mirrorWrite(schedule) {
+        const id = schedule.id;
+        this.state.mirror.write(`schedule:${id}`, async () => {
+            const path = this.filePath(id);
+            // Re-check right before overwriting: a hand edit (or delete) made while
+            // this write was pending is merged in first, never replaced.
+            const file = await this.state.manifest.classify(path);
+            let latest = this.cache?.get(id) ?? schedule;
+            if (file.status === "deleted") {
+                if (this.cache?.has(id)) {
+                    await Promise.all([this.schedules.remove("", id), this.runs.dropScope(id)]);
+                    this.cache.delete(id);
+                    this.revision += 1;
+                }
+                await this.state.manifest.forget(path);
+                return;
+            }
+            if (file.status === "changed" || file.status === "created") {
+                try {
+                    const fromFile = StoredScheduleSchema.parse(JSON.parse(file.content));
+                    latest = capScheduleRuns(mergeExternalSchedule(latest, fromFile));
+                    const { runs, ...rest } = latest;
+                    await Promise.all([
+                        this.schedules.put("", id, rest),
+                        this.runs.sync(id, runs.map((run) => ({ id: run.id, value: run })), { prune: true }),
+                    ]);
+                    this.cache?.set(id, latest);
+                    this.revision += 1;
+                }
+                catch (error) {
+                    this.logger?.warn({ err: error, path }, "Schedule file edited by hand is unreadable; overwriting it");
+                }
+            }
+            else if (!this.cache?.has(id)) {
+                return;
+            }
+            const rev = this.state.mirrorRev();
+            await writeJsonFileAtomic(path, latest);
+            await this.state.manifest.record(MANIFEST_STORE, path, rev);
+            this.dirMtime = null;
+        });
+    }
 }
 //# sourceMappingURL=store.js.map

package/dist/server/server/search/indexer.d.ts

@@ -26,6 +26,16 @@ export interface SourceAdapter {
     discover(): Promise<DiscoveredFile[]>;
     /** Parse one raw record into extractable blocks. */
     extract(record: unknown): ExtractedRecord;
+    /**
+     * Whole-document sources not kept in files (paseo agents in state.sqlite):
+     * the document for a discovered entry, with a size and a version that
+     * changes whenever the document does. Null when it is gone.
+     */
+    readDocument?(file: DiscoveredFile): Promise<{
+        size: number;
+        mtimeMs: number;
+        content: string;
+    } | null>;
 }
 export declare function createClaudeAdapter(root?: string): SourceAdapter;
 export declare function createCodexAdapter(root?: string): SourceAdapter;

package/dist/server/server/search/indexer.js

@@ -26,6 +26,8 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { resolvePaseoHome } from "../paseo-home.js";
+import { agentRecordPath } from "../agent/agent-storage.js";
+import { stateDbFor } from "../state/state-db.js";
 import { extractClaudeRecord, extractCodexRecord, extractPaseoAgent, } from "./extract.js";
 // ---------------------------------------------------------------------------
 // Discovery helpers
@@ -133,12 +135,49 @@ export function createPaseoAdapter(root) {
         // adapter indexes title + labels so agents are findable by name, and the
         // record's runtimeInfo.sessionId is what links a hit to real transcript
         // text held by the provider adapters.
+        async readDocument(file) {
+            const stateDb = root === undefined ? stateDbFor(resolvePaseoHome()) : null;
+            if (!stateDb) {
+                const stat = await fs.stat(file.path);
+                return {
+                    size: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                    content: await fs.readFile(file.path, "utf8"),
+                };
+            }
+            const row = stateDb
+                .prepare("SELECT body, rev FROM agents WHERE scope = '' AND id = ? AND deleted_at IS NULL")
+                .get(file.sid);
+            if (!row || typeof row.body !== "string")
+                return null;
+            // rev changes on every write (a title set keeps updatedAt), so it is the version.
+            return { size: row.body.length, mtimeMs: Number(row.rev), content: row.body };
+        },
         extract(record) {
             const { meta, blocks } = extractPaseoAgent(record);
             // The agent record's own cwd is authoritative for a paseo hit.
             return { blocks, timestamp: meta?.updatedAt ?? null, sid: null, cwd: meta?.cwd ?? null };
         },
         async discover() {
+            // With state.sqlite the agent files are only a lagging mirror (and
+            // absent under PASEO_STATE_FILE_MIRROR=0): index the rows. Paths stay the
+            // legacy file paths, so index keys do not change with the backend.
+            const stateDb = root === undefined ? stateDbFor(resolvePaseoHome()) : null;
+            if (stateDb) {
+                stateDb.flushSync();
+                return stateDb
+                    .prepare("SELECT id, json_extract(body, '$.cwd') AS cwd FROM agents WHERE scope = '' AND deleted_at IS NULL")
+                    .all()
+                    .map((row) => ({
+                    path: agentRecordPath(agentsRoot, {
+                        id: String(row.id),
+                        cwd: String(row.cwd ?? ""),
+                    }),
+                    source: "paseo",
+                    sid: String(row.id),
+                    cwd: "",
+                }));
+            }
             const files = await walkFiles(agentsRoot, ".json");
             return files.map((p) => ({
                 path: p,
@@ -288,8 +327,18 @@ function buildChunks(args, consumable, isWholeDoc) {
 async function indexOneFile(args) {
     const { store, adapter, file, result, maxBytes, log } = args;
     let stat;
+    let document = null;
     try {
-        stat = await fs.stat(file.path);
+        if (adapter.readDocument) {
+            const read = await adapter.readDocument(file);
+            if (!read)
+                return;
+            document = read.content;
+            stat = read;
+        }
+        else {
+            stat = await fs.stat(file.path);
+        }
     }
     catch {
         return;
@@ -301,7 +350,7 @@ async function indexOneFile(args) {
     const end = Math.min(stat.size, start + maxBytes);
     let raw;
     try {
-        raw = await readRange(file.path, start, end);
+        raw = document ?? (await readRange(file.path, start, end));
     }
     catch (err) {
         result.errors += 1;

package/dist/server/server/session.js

@@ -6622,21 +6622,20 @@ export class Session {
                         clearedAgentIds.push(agentId);
                         continue;
                     }
-                    const record = await this.agentStorage.get(agentId);
-                    if (!record ||
-                        record.internal ||
-                        record.archivedAt ||
-                        record.requiresAttention !== true) {
+                    // Inside the agent's write queue, so a concurrent title or digest
+                    // write is never dropped by this read-then-write.
+                    const nextRecord = await this.agentStorage.update(agentId, (record) => record.internal || record.archivedAt || record.requiresAttention !== true
+                        ? null
+                        : {
+                            ...record,
+                            updatedAt: new Date().toISOString(),
+                            requiresAttention: false,
+                            attentionReason: null,
+                            attentionTimestamp: null,
+                        });
+                    if (!nextRecord) {
                         continue;
                     }
-                    const nextRecord = {
-                        ...record,
-                        updatedAt: new Date().toISOString(),
-                        requiresAttention: false,
-                        attentionReason: null,
-                        attentionTimestamp: null,
-                    };
-                    await this.agentStorage.upsert(nextRecord);
                     const agent = this.buildStoredAgentPayload(nextRecord);
                     const project = await this.buildProjectPlacementForWorkspace(workspace);
                     this.emit({

package/dist/server/server/state/agent-state.d.ts

@@ -0,0 +1,39 @@
+import type { Logger } from "pino";
+import { type AgentRecordBackend, type StoredAgentRecord } from "../agent/agent-storage.js";
+import type { AgentMirrorCatchUp } from "./legacy-import.js";
+import type { ChangedRow, StateDb } from "./state-db.js";
+/**
+ * Agent records in `state.sqlite`, one row per agent, with a daemon-wide `rev`
+ * and a tombstone on delete. Replaces the boot scan of every agent JSON (14,388
+ * files on the reference host) with one indexed read, and the per-update
+ * rewrite of a whole file with one row in a batched transaction.
+ *
+ * Every write is mirrored to the legacy file, debounced and off the request
+ * path, see `LegacyMirror`, and each file written or removed is recorded in the
+ * legacy manifest with the rev it reflects. Files the boot import found lagging
+ * the database (the process died inside the debounce window) are caught up on
+ * the first load.
+ */
+export declare class SqliteAgentRecordBackend implements AgentRecordBackend {
+    private readonly state;
+    private readonly catchUp;
+    private readonly table;
+    private readonly files;
+    /**
+     * The record the legacy file currently holds, per agent the mirror has
+     * touched. Debounced writes collapse, so the file to replace is the one the
+     * mirror last wrote (or the record loaded at boot), not the previous record in
+     * memory, which may never have reached disk.
+     */
+    private readonly onDisk;
+    /** Rev each running mirror write reflects, by agent id. */
+    private readonly mirrorRevs;
+    constructor(state: StateDb, baseDir: string, logger: Logger, catchUp?: AgentMirrorCatchUp);
+    loadAll(): Promise<StoredAgentRecord[]>;
+    write(record: StoredAgentRecord, previous: StoredAgentRecord | null): Promise<void>;
+    /** `rev` is the row's own rev for exactly this content (re-review R1). */
+    private mirrorWrite;
+    remove(agentId: string, previous: StoredAgentRecord | null): Promise<void>;
+    listChangedSince(rev: number, limit?: number): ChangedRow[];
+}
+//# sourceMappingURL=agent-state.d.ts.map

package/dist/server/server/state/agent-state.js

@@ -0,0 +1,94 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { FileAgentRecordBackend, } from "../agent/agent-storage.js";
+/**
+ * Agent records in `state.sqlite`, one row per agent, with a daemon-wide `rev`
+ * and a tombstone on delete. Replaces the boot scan of every agent JSON (14,388
+ * files on the reference host) with one indexed read, and the per-update
+ * rewrite of a whole file with one row in a batched transaction.
+ *
+ * Every write is mirrored to the legacy file, debounced and off the request
+ * path, see `LegacyMirror`, and each file written or removed is recorded in the
+ * legacy manifest with the rev it reflects. Files the boot import found lagging
+ * the database (the process died inside the debounce window) are caught up on
+ * the first load.
+ */
+export class SqliteAgentRecordBackend {
+    constructor(state, baseDir, logger, catchUp = { rewrite: [], unlink: [] }) {
+        this.state = state;
+        this.catchUp = catchUp;
+        /**
+         * The record the legacy file currently holds, per agent the mirror has
+         * touched. Debounced writes collapse, so the file to replace is the one the
+         * mirror last wrote (or the record loaded at boot), not the previous record in
+         * memory, which may never have reached disk.
+         */
+        this.onDisk = new Map();
+        /** Rev each running mirror write reflects, by agent id. */
+        this.mirrorRevs = new Map();
+        this.table = state.doc("agents", { tombstones: true });
+        this.files = new FileAgentRecordBackend(baseDir, logger, {
+            written: (filePath) => state.manifest.record("agents", filePath, this.mirrorRevs.get(path.basename(filePath, ".json")) ?? 0),
+            removed: (filePath) => state.manifest.forget(filePath),
+        });
+        // Every file the manifest knows, so a cwd move or a delete also cleans up
+        // copies left at older paths.
+        for (const entry of state.manifest.entries("agents").values()) {
+            this.files.indexPath(path.basename(entry.path, ".json"), entry.path);
+        }
+    }
+    async loadAll() {
+        // Bodies were validated when they were written or imported; re-running zod
+        // over 14k records here would cost more than the read it replaces.
+        const rows = this.table.loadAll("");
+        const records = rows.map((row) => JSON.parse(row.body));
+        if (this.state.mirror.enabled) {
+            const byId = new Map(records.map((record) => [record.id, record]));
+            const revs = new Map(rows.map((row) => [row.id, row.rev]));
+            for (const id of this.catchUp.rewrite) {
+                const record = byId.get(id);
+                if (record)
+                    this.mirrorWrite(record, revs.get(id) ?? 0);
+            }
+            for (const filePath of this.catchUp.unlink) {
+                this.state.mirror.write(`agent-file:${filePath}`, async () => {
+                    await fs.rm(filePath, { force: true });
+                    await this.state.manifest.forget(filePath);
+                });
+            }
+        }
+        return records;
+    }
+    async write(record, previous) {
+        const rev = await this.table.putWithRev("", record.id, record);
+        if (!this.onDisk.has(record.id))
+            this.onDisk.set(record.id, previous);
+        this.mirrorWrite(record, rev);
+    }
+    /** `rev` is the row's own rev for exactly this content (re-review R1). */
+    mirrorWrite(record, rev) {
+        this.state.mirror.write(`agent:${record.id}`, async () => {
+            this.mirrorRevs.set(record.id, rev);
+            try {
+                await this.files.write(record, this.onDisk.get(record.id) ?? null);
+            }
+            finally {
+                this.mirrorRevs.delete(record.id);
+            }
+            this.onDisk.set(record.id, record);
+        });
+    }
+    async remove(agentId, previous) {
+        await this.table.remove("", agentId);
+        if (!this.onDisk.has(agentId))
+            this.onDisk.set(agentId, previous);
+        this.state.mirror.write(`agent:${agentId}`, async () => {
+            await this.files.remove(agentId, this.onDisk.get(agentId) ?? null);
+            this.onDisk.delete(agentId);
+        });
+    }
+    listChangedSince(rev, limit) {
+        return this.table.listChangedSince(rev, limit);
+    }
+}
+//# sourceMappingURL=agent-state.js.map

package/dist/server/server/state/daemon-state.d.ts

@@ -0,0 +1,30 @@
+import type { Logger } from "pino";
+import type { AgentRecordBackend } from "../agent/agent-storage.js";
+import { type StateDb } from "./state-db.js";
+/**
+ * Free space the first import needs, as a multiple of the legacy state it
+ * copies: the database itself (about 1x on a real install) plus the WAL, which
+ * grows to about 1.4x while checkpoints are paused during the import.
+ */
+export declare const IMPORT_SPACE_FACTOR = 2.5;
+export interface DaemonState {
+    /** Null when node:sqlite is unavailable, the probe failed, or PASEO_STATE_SQLITE=0. */
+    stateDb: StateDb | null;
+    /** Undefined means AgentStorage keeps its legacy file backend. */
+    agentBackend: AgentRecordBackend | undefined;
+    close(): Promise<void>;
+}
+/**
+ * Open `state.sqlite` for a daemon, copy the legacy stores in (first boot) or
+ * re-sync files an older daemon changed (after a rollback), and attach it for
+ * the stores constructed deeper down. See data-layer-rework.md section 5.
+ */
+export declare function openDaemonState(options: {
+    paseoHome: string;
+    agentStoragePath: string;
+    logger: Logger;
+    elapsed: () => unknown;
+    /** Test seam: free bytes on the PASEO_HOME filesystem. */
+    freeBytes?: () => Promise<number>;
+}): Promise<DaemonState>;
+//# sourceMappingURL=daemon-state.d.ts.map