@hyperdrive.bot/fleet-server 0.3.164 → 0.3.166

package/dist/server/server/bootstrap.js

@@ -94,6 +94,7 @@ import { scheduleSessionDigestRefresh } from "./agent/session-digest-generator.j
 import { CardMoveLog } from "./agent/card-move-log.js";
 import { BlockerLog } from "./agent/blocker-log.js";
 import { AUTHORSHIP_ENV_FLAG, createAuthorshipLedger } from "./agent/authorship-ledger.js";
+import { openDaemonState } from "./state/daemon-state.js";
 import { AUTHORSHIP_MARKUP_ENV_FLAG, AUTHORSHIP_SPEAKER_ENV, createAuthorshipMarkup, } from "./agent/authorship-markup.js";
 import { JudgeRelayGate } from "./agent/judge-relay-gate.js";
 import { JarvisJudge } from "./agent/jarvis-judge.js";
@@ -691,9 +692,21 @@ export async function createPaseoDaemon(config, rootLogger) {
     if (config.serviceProxy?.standaloneListen) {
         serviceProxyListenTarget = parseListenString(config.serviceProxy.standaloneListen);
     }
-    const agentStorage = new AgentStorage(config.agentStoragePath, logger);
-    const projectRegistry = new FileBackedProjectRegistry(path.join(config.paseoHome, "projects", "projects.json"), logger);
-    workspaceRegistry = new FileBackedWorkspaceRegistry(path.join(config.paseoHome, "projects", "workspaces.json"), logger);
+    // Non-blob daemon state in $PASEO_HOME/state.sqlite (data-layer-rework.md
+    // section 5). Null when node:sqlite is unavailable, the probe fails or
+    // PASEO_STATE_SQLITE=0: every store then stays on its legacy files. The
+    // first boot copies the files in (yielding batches, resumable); files are
+    // never deleted and stay mirrored for one release.
+    const daemonState = await openDaemonState({
+        paseoHome: config.paseoHome,
+        agentStoragePath: config.agentStoragePath,
+        logger,
+        elapsed,
+    });
+    const stateDb = daemonState.stateDb;
+    const agentStorage = new AgentStorage(config.agentStoragePath, logger, daemonState.agentBackend);
+    const projectRegistry = new FileBackedProjectRegistry(path.join(config.paseoHome, "projects", "projects.json"), logger, { stateDb });
+    workspaceRegistry = new FileBackedWorkspaceRegistry(path.join(config.paseoHome, "projects", "workspaces.json"), logger, { stateDb });
     // Story PASEO-CHAT-ACTIONS-V1-story-3.003 — GET /workspace/:id/sessions.
     registerWorkspaceSessionsRoute(app, workspaceRegistry, logger);
     // MARRA CUSTOMIZATION — GET /sessions (global; walks the agent transcript
@@ -707,6 +720,7 @@ export async function createPaseoDaemon(config, rootLogger) {
     const chatService = new FileBackedChatService({
         paseoHome: config.paseoHome,
         logger,
+        stateDb,
     });
     const github = createGitHubService();
     const workspaceGitService = new WorkspaceGitServiceImpl({
@@ -918,6 +932,7 @@ export async function createPaseoDaemon(config, rootLogger) {
         logger,
         agentManager,
         providerSnapshotManager,
+        stateDb,
     });
     await loopService.initialize();
     logger.info({ elapsed: elapsed() }, "Loop service initialized");
@@ -1669,6 +1684,9 @@ export async function createPaseoDaemon(config, rootLogger) {
         if (listenTarget.type === "socket" && existsSync(listenTarget.path)) {
             unlinkSync(listenTarget.path);
         }
+        // Last: every store above may still write on its way down. Close flushes
+        // the batch queue and the legacy file mirror.
+        await daemonState.close();
     };
     return {
         config,
@@ -1681,6 +1699,11 @@ export async function createPaseoDaemon(config, rootLogger) {
         browserToolsBroker,
         start,
         stop,
+        beginStateShutdown: () => {
+            void daemonState.stateDb?.beginShutdown().catch((error) => {
+                logger.warn({ err: error }, "Early state flush on shutdown failed");
+            });
+        },
         getListenTarget: () => boundListenTarget,
     };
 }

package/dist/server/server/chat/chat-service.d.ts

@@ -1,5 +1,25 @@
 import type pino from "pino";
+import { z } from "zod";
+import { type StateDb } from "../state/state-db.js";
 import { type ChatMessage, type ChatRoomDetail } from "@hyperdrive.bot/fleet-protocol/chat/types";
+export declare const ChatStorePayloadSchema: z.ZodObject<{
+    rooms: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        purpose: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        roomId: z.ZodString;
+        authorAgentId: z.ZodString;
+        body: z.ZodString;
+        replyToMessageId: z.ZodNullable<z.ZodString>;
+        mentionAgentIds: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare function parseMentionAgentIds(body: string): string[];
 export declare class ChatServiceError extends Error {
     readonly code: string;
@@ -49,9 +69,11 @@ export declare class FileBackedChatService {
     private readonly messagesByRoomId;
     private persistQueue;
     private readonly waitersByRoomId;
+    private readonly sqlite;
     constructor(options: {
         paseoHome: string;
         logger: pino.Logger;
+        stateDb?: StateDb | null;
     });
     initialize(): Promise<void>;
     createRoom(input: CreateChatRoomInput): Promise<ChatRoomDetail>;

package/dist/server/server/chat/chat-service.js

@@ -3,8 +3,9 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { z } from "zod";
 import { writeJsonFileAtomic } from "../atomic-file.js";
+import { ScopeSync } from "../state/state-db.js";
 import { ChatMessageSchema, ChatRoomDetailSchema, ChatRoomSchema, } from "@hyperdrive.bot/fleet-protocol/chat/types";
-const ChatStorePayloadSchema = z.object({
+export const ChatStorePayloadSchema = z.object({
     rooms: z.array(ChatRoomSchema),
     messages: z.array(ChatMessageSchema),
 });
@@ -36,6 +37,41 @@ export class ChatServiceError extends Error {
         this.code = code;
     }
 }
+/**
+ * Chat in `state.sqlite`: rooms in `chat_rooms`, each message a row in
+ * `chat_messages` scoped by room (indexed by room and order, unbounded). A
+ * persist writes only what changed; chat/rooms.json is mirrored.
+ */
+class SqliteChatStore {
+    constructor(state, filePath) {
+        this.state = state;
+        this.filePath = filePath;
+        this.rooms = new ScopeSync(state.doc("chat_rooms"));
+        this.messages = new ScopeSync(state.doc("chat_messages"));
+    }
+    load() {
+        const roomRows = this.state.doc("chat_rooms").loadAll("");
+        const messageRows = this.state.doc("chat_messages").loadAll();
+        this.rooms.seed(roomRows);
+        this.messages.seed(messageRows);
+        return {
+            rooms: roomRows.map((row) => JSON.parse(row.body)),
+            messages: messageRows.map((row) => JSON.parse(row.body)),
+        };
+    }
+    async save(payload, messagesByRoomId) {
+        await Promise.all([
+            this.rooms.sync("", payload.rooms.map((room) => ({ id: room.id, value: room })), { prune: true }),
+            ...[...messagesByRoomId].map(([roomId, messages]) => this.messages.sync(roomId, messages.map((message) => ({ id: message.id, value: message })), { prune: true })),
+            this.messages.dropScopesExcept(new Set(messagesByRoomId.keys())),
+        ]);
+        const rev = this.state.mirrorRev();
+        this.state.mirror.write(`chat:${this.filePath}`, async () => {
+            await writeJsonFileAtomic(this.filePath, payload);
+            await this.state.manifest.record("chat", this.filePath, rev);
+        });
+    }
+}
 export class FileBackedChatService {
     constructor(options) {
         this.loaded = false;
@@ -44,6 +80,7 @@ export class FileBackedChatService {
         this.persistQueue = Promise.resolve();
         this.waitersByRoomId = new Map();
         this.filePath = path.join(options.paseoHome, "chat", "rooms.json");
+        this.sqlite = options.stateDb ? new SqliteChatStore(options.stateDb, this.filePath) : null;
         this.logger = options.logger.child({ component: "chat-service" });
     }
     async initialize() {
@@ -216,8 +253,10 @@ export class FileBackedChatService {
         this.rooms.clear();
         this.messagesByRoomId.clear();
         try {
-            const raw = await fs.readFile(this.filePath, "utf8");
-            const parsed = ChatStorePayloadSchema.parse(JSON.parse(raw));
+            const raw = this.sqlite
+                ? this.sqlite.load()
+                : JSON.parse(await fs.readFile(this.filePath, "utf8"));
+            const parsed = ChatStorePayloadSchema.parse(raw);
             for (const room of parsed.rooms) {
                 this.rooms.set(room.id, room);
             }
@@ -247,6 +286,10 @@ export class FileBackedChatService {
                 .flat()
                 .sort((left, right) => left.createdAt.localeCompare(right.createdAt)),
         };
+        if (this.sqlite) {
+            await this.sqlite.save(payload, this.messagesByRoomId);
+            return;
+        }
         await writeJsonFileAtomic(this.filePath, payload);
     }
     findRoomByName(name) {

package/dist/server/server/daemon-worker.js

@@ -87,6 +87,7 @@ async function main() {
         const reason = options?.reason ?? `worker_received_${signal}`;
         if (!shutdownPromise) {
             logger.info({ signal, reason, ...getProcessDiagnostics() }, `${signal} received, shutting down gracefully...`);
+            daemon?.beginStateShutdown();
             shutdownPromise = (async () => {
                 const forceExit = setTimeout(() => {
                     logger.warn({ signal, reason, ...getProcessDiagnostics() }, "Forcing shutdown - HTTP server didn't close in time");

package/dist/server/server/fleet/decision-service.d.ts

@@ -1,4 +1,5 @@
 import { type CreateLoopDecisionInput, type LoopDecision, type LoopDecisionResolver } from "@hyperdrive.bot/fleet-protocol/fleet/decisions";
+import { type StateDb } from "../state/state-db.js";
 /**
  * Store + lifecycle for loop decisions.
  *
@@ -13,6 +14,8 @@ import { type CreateLoopDecisionInput, type LoopDecision, type LoopDecisionResol
 export interface DecisionServiceOptions {
     paseoHome: string;
     now?: () => Date;
+    /** Defaults to the daemon's state.sqlite for this home, when one is attached. */
+    stateDb?: StateDb | null;
 }
 export declare class LoopDecisionService {
     private readonly dir;
@@ -24,6 +27,8 @@ export declare class LoopDecisionService {
      * every file, synchronously, on each RPC.
      */
     private cached;
+    private readonly stateDb;
+    private readonly table;
     constructor(options: DecisionServiceOptions);
     private pathFor;
     private writeAtomic;

package/dist/server/server/fleet/decision-service.js

@@ -1,7 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, readdirSync, statSync, writeFileSync, renameSync } from "node:fs";
+import { writeFile, rename, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { assertDecisionIsSound, isDecisionPending, LoopDecisionSchema, sortDecisionsByUrgency, } from "@hyperdrive.bot/fleet-protocol/fleet/decisions";
+import { stateDbFor } from "../state/state-db.js";
 export class LoopDecisionService {
     constructor(options) {
         /**
@@ -13,11 +15,29 @@ export class LoopDecisionService {
         this.cached = null;
         this.dir = join(options.paseoHome, "fleet", "decisions");
         this.now = options.now ?? (() => new Date());
+        this.stateDb = options.stateDb === undefined ? stateDbFor(options.paseoHome) : options.stateDb;
+        this.table = this.stateDb?.doc("fleet_decisions") ?? null;
     }
     pathFor(id) {
         return join(this.dir, `${id}.json`);
     }
     writeAtomic(decision) {
+        if (this.table && this.stateDb) {
+            // Committed with the next batch; a read flushes the batch first. Several
+            // FleetService instances share one home, so reads go to the table rather
+            // than to a per-instance cache.
+            void this.table.put("", decision.id, decision).catch(() => undefined);
+            const target = this.pathFor(decision.id);
+            const stateDb = this.stateDb;
+            stateDb.mirror.write(`decision:${decision.id}`, async () => {
+                const rev = stateDb.mirrorRev();
+                await mkdir(this.dir, { recursive: true });
+                await writeFile(`${target}.tmp`, JSON.stringify(decision, null, 2), "utf8");
+                await rename(`${target}.tmp`, target);
+                await stateDb.manifest.record("fleet_decisions", target, rev);
+            });
+            return;
+        }
         mkdirSync(this.dir, { recursive: true });
         const target = this.pathFor(decision.id);
         const temp = `${target}.tmp`;
@@ -58,6 +78,16 @@ export class LoopDecisionService {
         return decision;
     }
     readAll() {
+        if (this.table) {
+            const decisions = [];
+            for (const row of this.table.loadAll("")) {
+                const parsed = LoopDecisionSchema.safeParse(JSON.parse(row.body));
+                if (parsed.success) {
+                    decisions.push(parsed.data);
+                }
+            }
+            return decisions;
+        }
         let mtimeMs;
         try {
             mtimeMs = statSync(this.dir).mtimeMs;

package/dist/server/server/loop-service.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import type { Logger } from "pino";
+import { type StateDb } from "./state/state-db.js";
 import type { AgentManager } from "./agent/agent-manager.js";
 import type { AgentProvider } from "./agent/agent-sdk-types.js";
 import type { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
@@ -156,6 +157,98 @@ declare const LoopRecordSchema: z.ZodObject<{
     activeWorkerAgentId: z.ZodNullable<z.ZodString>;
     activeVerifierAgentId: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
+export declare const StoredLoopsSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    prompt: z.ZodString;
+    cwd: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodNullable<z.ZodString>;
+    modeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    workerProvider: z.ZodNullable<z.ZodString>;
+    workerModel: z.ZodNullable<z.ZodString>;
+    verifierProvider: z.ZodNullable<z.ZodString>;
+    verifierModel: z.ZodNullable<z.ZodString>;
+    verifierModeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    verifyPrompt: z.ZodNullable<z.ZodString>;
+    verifyChecks: z.ZodArray<z.ZodString>;
+    archive: z.ZodBoolean;
+    sleepMs: z.ZodNumber;
+    maxIterations: z.ZodNullable<z.ZodNumber>;
+    maxTimeMs: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        succeeded: "succeeded";
+        stopped: "stopped";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    startedAt: z.ZodString;
+    completedAt: z.ZodNullable<z.ZodString>;
+    stopRequestedAt: z.ZodNullable<z.ZodString>;
+    iterations: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        workerAgentId: z.ZodNullable<z.ZodString>;
+        workerStartedAt: z.ZodString;
+        workerCompletedAt: z.ZodNullable<z.ZodString>;
+        verifierAgentId: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            running: "running";
+            failed: "failed";
+            succeeded: "succeeded";
+            stopped: "stopped";
+        }>;
+        workerOutcome: z.ZodNullable<z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            canceled: "canceled";
+        }>>;
+        failureReason: z.ZodNullable<z.ZodString>;
+        verifyChecks: z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            exitCode: z.ZodNumber;
+            passed: z.ZodBoolean;
+            stdout: z.ZodString;
+            stderr: z.ZodString;
+            startedAt: z.ZodString;
+            completedAt: z.ZodString;
+        }, z.core.$strip>>;
+        verifyPrompt: z.ZodNullable<z.ZodObject<{
+            passed: z.ZodBoolean;
+            reason: z.ZodString;
+            verifierAgentId: z.ZodNullable<z.ZodString>;
+            startedAt: z.ZodString;
+            completedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    logs: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        timestamp: z.ZodString;
+        iteration: z.ZodNullable<z.ZodNumber>;
+        source: z.ZodEnum<{
+            loop: "loop";
+            worker: "worker";
+            verifier: "verifier";
+            "verify-check": "verify-check";
+        }>;
+        level: z.ZodEnum<{
+            error: "error";
+            info: "info";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    nextLogSeq: z.ZodNumber;
+    activeIteration: z.ZodNullable<z.ZodNumber>;
+    activeWorkerAgentId: z.ZodNullable<z.ZodString>;
+    activeVerifierAgentId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>>;
+/**
+ * Log entries a loop keeps. The oldest are dropped past this, in memory and on
+ * disk; a long-running loop used to grow its log without bound and rewrite all
+ * of it on every persist.
+ */
+export declare const LOOP_LOGS_RETAINED = 5000;
 export type LoopStatus = z.infer<typeof LoopRecordSchema>["status"];
 export type LoopLogEntry = z.infer<typeof LoopLogEntrySchema>;
 export type LoopVerifyCheckResult = z.infer<typeof LoopVerifyCheckResultSchema>;
@@ -204,11 +297,13 @@ export declare class LoopService {
     private readonly loops;
     private persistQueue;
     private readonly running;
+    private readonly sqlite;
     constructor(options: {
         paseoHome: string;
         agentManager: AgentManager;
         logger: Logger;
         providerSnapshotManager: CreateConfigResolver;
+        stateDb?: StateDb | null;
     });
     initialize(): Promise<void>;
     runLoop(input: LoopRunOptions): Promise<LoopRecord>;

package/dist/server/server/loop-service.js

@@ -3,6 +3,7 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { z } from "zod";
 import { writeJsonFileAtomic } from "./atomic-file.js";
+import { ScopeSync } from "./state/state-db.js";
 import { curateAgentActivity } from "./agent/activity-curator.js";
 import { getStructuredAgentResponse } from "./agent/agent-response-loop.js";
 import { execCommand, platformShell } from "../utils/spawn.js";
@@ -81,7 +82,57 @@ const LoopRecordSchema = z.object({
     activeWorkerAgentId: z.string().nullable(),
     activeVerifierAgentId: z.string().nullable(),
 });
-const StoredLoopsSchema = z.array(LoopRecordSchema);
+export const StoredLoopsSchema = z.array(LoopRecordSchema);
+/**
+ * Log entries a loop keeps. The oldest are dropped past this, in memory and on
+ * disk; a long-running loop used to grow its log without bound and rewrite all
+ * of it on every persist.
+ */
+export const LOOP_LOGS_RETAINED = 5000;
+/**
+ * Loops in `state.sqlite`: the loop (iterations included, bounded by
+ * maxIterations) in `loops`, each log entry as a row in `loop_logs`. A persist
+ * writes only the loops and log entries that changed. loops/loops.json is
+ * mirrored.
+ */
+class SqliteLoopStore {
+    constructor(state, storePath) {
+        this.state = state;
+        this.storePath = storePath;
+        this.loopsTable = state.doc("loops");
+        this.loops = new ScopeSync(this.loopsTable);
+        this.logs = new ScopeSync(state.doc("loop_logs"));
+    }
+    load() {
+        const loopRows = this.loopsTable.loadAll("");
+        const logRows = this.state.doc("loop_logs").loadAll();
+        this.loops.seed(loopRows);
+        this.logs.seed(logRows);
+        const logsByLoop = new Map();
+        for (const row of logRows) {
+            const list = logsByLoop.get(row.scope) ?? [];
+            list.push(JSON.parse(row.body));
+            logsByLoop.set(row.scope, list);
+        }
+        return loopRows.map((row) => {
+            const loop = JSON.parse(row.body);
+            loop.logs = logsByLoop.get(row.id) ?? [];
+            return loop;
+        });
+    }
+    async save(records) {
+        await Promise.all([
+            this.loops.sync("", records.map(({ logs: _logs, ...rest }) => ({ id: rest.id, value: rest })), { prune: true }),
+            ...records.map((record) => this.logs.sync(record.id, record.logs.map((entry) => ({ id: String(entry.seq).padStart(10, "0"), value: entry })), { prune: true })),
+            this.logs.dropScopesExcept(new Set(records.map((record) => record.id))),
+        ]);
+        const rev = this.state.mirrorRev();
+        this.state.mirror.write(`loops:${this.storePath}`, async () => {
+            await writeJsonFileAtomic(this.storePath, records);
+            await this.state.manifest.record("loops", this.storePath, rev);
+        });
+    }
+}
 function nowIso() {
     return new Date().toISOString();
 }
@@ -214,6 +265,7 @@ export class LoopService {
         this.persistQueue = Promise.resolve();
         this.running = new Map();
         this.storePath = path.join(options.paseoHome, "loops", "loops.json");
+        this.sqlite = options.stateDb ? new SqliteLoopStore(options.stateDb, this.storePath) : null;
         this.logger = options.logger.child({ module: "loop-service" });
     }
     async initialize() {
@@ -222,8 +274,10 @@ export class LoopService {
         }
         this.loops.clear();
         try {
-            const raw = await fs.readFile(this.storePath, "utf8");
-            const parsed = StoredLoopsSchema.parse(JSON.parse(raw));
+            const raw = this.sqlite
+                ? this.sqlite.load()
+                : JSON.parse(await fs.readFile(this.storePath, "utf8"));
+            const parsed = StoredLoopsSchema.parse(raw);
             for (const record of parsed) {
                 if (record.status === "running") {
                     const recovered = cloneLoop(record);
@@ -737,6 +791,9 @@ export class LoopService {
         });
         loop.nextLogSeq += 1;
         loop.updatedAt = nowIso();
+        if (loop.logs.length > LOOP_LOGS_RETAINED) {
+            loop.logs.splice(0, loop.logs.length - LOOP_LOGS_RETAINED);
+        }
     }
     requireLoop(idOrPrefix) {
         const trimmed = idOrPrefix.trim();
@@ -759,6 +816,10 @@ export class LoopService {
     async persist() {
         const nextPersist = this.persistQueue.then(async () => {
             const records = Array.from(this.loops.values()).sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+            if (this.sqlite) {
+                await this.sqlite.save(records);
+                return;
+            }
             await writeJsonFileAtomic(this.storePath, records);
             return;
         });

package/dist/server/server/migrations/backfill-workspace-id.migration.js

@@ -53,8 +53,9 @@ export async function backfillWorkspaceIdForLegacyAgents(options) {
         if (!workspaceId) {
             continue;
         }
-        await options.agentStorage.upsert({ ...record, workspaceId });
-        migrated += 1;
+        const written = await options.agentStorage.update(record.id, (latest) => latest.workspaceId ? null : { ...latest, workspaceId });
+        if (written)
+            migrated += 1;
     }
     if (migrated > 0) {
         options.logger.info({ migrated }, "Backfilled workspaceId for legacy agent records");

package/dist/server/server/push/token-store.d.ts

@@ -1,4 +1,5 @@
 import type pino from "pino";
+import type { StateDb } from "../state/state-db.js";
 /**
  * Store for Expo push tokens.
  *
@@ -13,7 +14,9 @@ export declare class PushTokenStore {
     private tokens;
     private readonly filePath;
     private sink;
-    constructor(logger: pino.Logger, filePath: string);
+    private readonly stateDb;
+    private readonly table;
+    constructor(logger: pino.Logger, filePath: string, stateDb?: StateDb | null);
     /**
      * Attach an optional sink that gets notified on each successful addToken.
      * Used by bootstrap to bridge legacy WebSocket-registered Expo tokens into
@@ -25,5 +28,6 @@ export declare class PushTokenStore {
     getAllTokens(): string[];
     private loadFromDisk;
     private persist;
+    private writeFile;
 }
 //# sourceMappingURL=token-store.d.ts.map

package/dist/server/server/push/token-store.js

@@ -1,12 +1,19 @@
 import { existsSync, readFileSync } from "node:fs";
 import { ensurePrivateFile, writePrivateFileAtomicSync } from "../private-files.js";
 export class PushTokenStore {
-    constructor(logger, filePath) {
+    constructor(logger, filePath, stateDb = null) {
         this.tokens = new Set();
         this.sink = null;
         this.logger = logger.child({ component: "token-store" });
         this.filePath = filePath;
-        this.loadFromDisk();
+        this.stateDb = stateDb;
+        this.table = stateDb?.doc("push_tokens") ?? null;
+        if (this.table) {
+            this.tokens = new Set(this.table.loadAll("").map((row) => row.id));
+        }
+        else {
+            this.loadFromDisk();
+        }
     }
     /**
      * Attach an optional sink that gets notified on each successful addToken.
@@ -23,7 +30,7 @@ export class PushTokenStore {
         if (this.tokens.has(normalized))
             return;
         this.tokens.add(normalized);
-        this.persist();
+        this.persist(normalized, "add");
         this.logger.debug({ total: this.tokens.size }, "Added token");
         try {
             this.sink?.onTokenAdded?.(normalized);
@@ -38,7 +45,7 @@ export class PushTokenStore {
             return;
         const deleted = this.tokens.delete(normalized);
         if (deleted) {
-            this.persist();
+            this.persist(normalized, "remove");
             this.logger.debug({ total: this.tokens.size }, "Removed token");
         }
     }
@@ -64,7 +71,21 @@ export class PushTokenStore {
             this.logger.warn({ err }, "Failed to load push tokens");
         }
     }
-    persist() {
+    persist(token, change) {
+        if (this.table && this.stateDb) {
+            const write = change === "add" ? this.table.put("", token, { token }) : this.table.remove("", token);
+            write.catch((error) => this.logger.warn({ err: error }, "Failed to persist push tokens"));
+            const stateDb = this.stateDb;
+            stateDb.mirror.write(`push-tokens:${this.filePath}`, async () => {
+                const rev = stateDb.mirrorRev();
+                this.writeFile();
+                await stateDb.manifest.record("push_tokens", this.filePath, rev);
+            });
+            return;
+        }
+        this.writeFile();
+    }
+    writeFile() {
         try {
             const payload = JSON.stringify({ tokens: Array.from(this.tokens) }, null, 2) + "\n";
             writePrivateFileAtomicSync(this.filePath, payload);

package/dist/server/server/schedule/service.js

@@ -5,6 +5,7 @@ import { curateAgentActivity } from "../agent/activity-curator.js";
 import { ensureAgentLoaded } from "../agent/agent-loading.js";
 import { formatSystemNotificationPrompt } from "../agent/agent-prompt.js";
 import { resolveCreateAgentTitles } from "../agent/create-agent-title.js";
+import { stateDbFor } from "../state/state-db.js";
 import { ScheduleStore } from "./store.js";
 import { computeNextRunAt, validateScheduleCadence } from "./cron.js";
 import { buildSourceRunPrompt } from "./source-prompt.js";
@@ -212,7 +213,9 @@ export class ScheduleService {
         this.agentScheduleFacts = null;
         /** Store version the facts above were built from. */
         this.agentScheduleFactsVersion = -1;
-        this.store = new ScheduleStore(join(options.paseoHome, "schedules"));
+        this.store = new ScheduleStore(join(options.paseoHome, "schedules"), {
+            stateDb: stateDbFor(options.paseoHome),
+        });
         this.logger = options.logger.child({ module: "schedule-service" });
         this.agentManager = options.agentManager;
         this.agentStorage = options.agentStorage;

package/dist/server/server/schedule/store.d.ts

@@ -1,4 +1,6 @@
 import { type StoredSchedule } from "@hyperdrive.bot/fleet-protocol/schedule/types";
+import type { Logger } from "pino";
+import { type StateDb } 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
@@ -35,7 +37,12 @@ export declare class ScheduleStore {
     private readonly stamps;
     private validating;
     private revision;
-    constructor(dir: string);
+    /** Set when the daemon runs on state.sqlite; every public method then delegates. */
+    private readonly sqlite;
+    constructor(dir: string, options?: {
+        stateDb?: StateDb | null;
+        logger?: Logger;
+    });
     private filePath;
     private ensureDir;
     private readStamp;
@@ -61,4 +68,17 @@ export declare class ScheduleStore {
      */
     get version(): number;
 }
+/** Upper bound on how stale an in-place edit of a schedule file can go unseen. */
+export declare const EXTERNAL_EDIT_RECHECK_MS = 1000;
+/**
+ * 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 declare function mergeExternalSchedule(daemon: StoredSchedule, file: StoredSchedule): StoredSchedule;
 //# sourceMappingURL=store.d.ts.map