@revealui/harnesses 0.1.6 → 0.1.8

package/dist/content/index.d.ts

@@ -14,8 +14,8 @@ declare const AgentSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     tier: z.ZodDefault<z.ZodEnum<{
-        pro: "pro";
         oss: "oss";
+        pro: "pro";
     }>>;
     isolation: z.ZodDefault<z.ZodEnum<{
         worktree: "worktree";
@@ -31,8 +31,8 @@ declare const CommandSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     tier: z.ZodDefault<z.ZodEnum<{
-        pro: "pro";
         oss: "oss";
+        pro: "pro";
     }>>;
     disableModelInvocation: z.ZodDefault<z.ZodBoolean>;
     argumentHint: z.ZodOptional<z.ZodString>;
@@ -53,8 +53,8 @@ declare const ManifestSchema: z.ZodObject<{
         }>;
         preambleTier: z.ZodDefault<z.ZodNumber>;
         tier: z.ZodDefault<z.ZodEnum<{
-            pro: "pro";
             oss: "oss";
+            pro: "pro";
         }>>;
         tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
         content: z.ZodString;
@@ -64,8 +64,8 @@ declare const ManifestSchema: z.ZodObject<{
         name: z.ZodString;
         description: z.ZodString;
         tier: z.ZodDefault<z.ZodEnum<{
-            pro: "pro";
             oss: "oss";
+            pro: "pro";
         }>>;
         disableModelInvocation: z.ZodDefault<z.ZodBoolean>;
         argumentHint: z.ZodOptional<z.ZodString>;
@@ -76,8 +76,8 @@ declare const ManifestSchema: z.ZodObject<{
         name: z.ZodString;
         description: z.ZodString;
         tier: z.ZodDefault<z.ZodEnum<{
-            pro: "pro";
             oss: "oss";
+            pro: "pro";
         }>>;
         isolation: z.ZodDefault<z.ZodEnum<{
             worktree: "worktree";
@@ -91,8 +91,8 @@ declare const ManifestSchema: z.ZodObject<{
         name: z.ZodString;
         description: z.ZodString;
         tier: z.ZodDefault<z.ZodEnum<{
-            pro: "pro";
             oss: "oss";
+            pro: "pro";
         }>>;
         disableModelInvocation: z.ZodDefault<z.ZodBoolean>;
         skipFrontmatter: z.ZodDefault<z.ZodBoolean>;
@@ -128,8 +128,8 @@ declare const RuleSchema: z.ZodObject<{
     }>;
     preambleTier: z.ZodDefault<z.ZodNumber>;
     tier: z.ZodDefault<z.ZodEnum<{
-        pro: "pro";
         oss: "oss";
+        pro: "pro";
     }>>;
     tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
     content: z.ZodString;
@@ -141,8 +141,8 @@ declare const SkillSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     tier: z.ZodDefault<z.ZodEnum<{
-        pro: "pro";
         oss: "oss";
+        pro: "pro";
     }>>;
     disableModelInvocation: z.ZodDefault<z.ZodBoolean>;
     skipFrontmatter: z.ZodDefault<z.ZodBoolean>;

package/dist/content/index.js

@@ -16,7 +16,7 @@ import {
   registerResolver,
   resolveTemplate,
   validateManifest
-} from "../chunk-XXEKWC6F.js";
+} from "../chunk-PROC6EJC.js";
 import "../chunk-DGUM43GV.js";
 export {
   AgentSchema,

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 import { HarnessAdapter, HarnessCapabilities, HarnessInfo, HarnessCommand, HarnessCommandResult, HarnessEvent, ConfigDiffEntry, ConfigSyncDirection, ConfigSyncResult, HealthCheckResult, HarnessProcessInfo } from './types/index.js';
 export { Agent, Command, ContentGenerator, ContentSummary, DiffEntry, GeneratedFile, Manifest, PreambleTier, ResolverContext, Rule, Skill, ValidationResult, buildManifest, diffContent, generateContent, listContent, validateManifest } from './content/index.js';
+import { DaemonStore } from './storage/index.js';
+export { AgentMessage, AgentSession, AgentTask, DaemonEvent, DaemonStoreConfig, FileReservation, SCHEMA_SQL } from './storage/index.js';
+import { EventEmitter } from 'node:events';
 import { WorkboardManager } from './workboard/index.js';
 export { ConflictResult, SessionType, WorkboardEntry, WorkboardSession, WorkboardState, acquireLock, atomicWriteSync, deriveSessionId, detectSessionType, lockPathFor, releaseLock, withLock, withLockAsync } from './workboard/index.js';
 import 'zod';
@@ -107,6 +110,247 @@ declare class HarnessRegistry {
     disposeAll(): Promise<void>;
 }
 
+interface OllamaStatus {
+    installed: boolean;
+    running: boolean;
+    version: string | null;
+}
+interface OllamaModel {
+    name: string;
+    size: string;
+    modified: string;
+}
+interface ModelPullResult {
+    success: boolean;
+    message: string;
+}
+interface BitNetStatus {
+    installed: boolean;
+    modelPath: string | null;
+}
+interface SnapStatus {
+    installed: boolean;
+    running: boolean;
+    snapName: string;
+    endpoint: string | null;
+    version: string | null;
+}
+interface SnapModel {
+    name: string;
+    description: string;
+    installed: boolean;
+}
+/**
+ * Manages local inference engines (Ollama, Snaps, BitNet) on the daemon host.
+ * Each method mirrors the equivalent Tauri command from `inference.rs`.
+ */
+declare class InferenceService {
+    ollamaStatus(): Promise<OllamaStatus>;
+    ollamaModels(): Promise<OllamaModel[]>;
+    ollamaPull(modelName: string): Promise<ModelPullResult>;
+    ollamaDelete(modelName: string): Promise<void>;
+    ollamaStart(): Promise<void>;
+    ollamaStop(): Promise<void>;
+    bitnetStatus(): Promise<BitNetStatus>;
+    snapList(): Promise<SnapModel[]>;
+    snapStatus(snapName: string): Promise<SnapStatus>;
+    snapInstall(snapName: string): Promise<ModelPullResult>;
+    snapRemove(snapName: string): Promise<void>;
+}
+
+type AgentBackend = 'Snap' | 'BitNet' | 'Ollama';
+interface AgentSessionInfo {
+    id: string;
+    name: string;
+    model: string;
+    backend: AgentBackend;
+    prompt: string;
+    status: 'running' | 'stopped' | 'errored';
+    pid: number | null;
+}
+interface SpawnerConfig {
+    /** Inference snap OpenAI-compatible endpoint (default: http://localhost:9090) */
+    snapEndpoint: string;
+    /** Max concurrent agent sessions (default: 8) */
+    maxSessions: number;
+}
+/**
+ * Manages agent process lifecycle on the daemon host.
+ *
+ * Emits:
+ *   'output' → AgentOutputEvent  (each stdout/stderr line)
+ *   'exit'   → AgentExitEvent    (process termination)
+ */
+declare class SpawnerService extends EventEmitter {
+    private readonly sessions;
+    private readonly config;
+    constructor(overrides?: Partial<SpawnerConfig>);
+    /** Spawn a new agent process. Returns the session ID. */
+    spawn(name: string, backend: AgentBackend, model: string, prompt: string): string;
+    /** Stop a running agent by killing its process. */
+    stop(sessionId: string): void;
+    /** List all agent sessions. */
+    list(): AgentSessionInfo[];
+    /** Remove a stopped/errored session. */
+    remove(sessionId: string): void;
+    /** Kill all running agents (called on daemon shutdown). */
+    stopAll(): void;
+}
+
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/**
+ * JSON-RPC 2.0 server over a Unix domain socket.
+ * Mirrors RpcServer from packages/editors.
+ *
+ * Methods:
+ *   ping                      → { status: 'ok', pid }
+ *   harness.list              → HarnessInfo[]
+ *   harness.execute           → HarnessCommandResult
+ *   harness.info              → HarnessInfo
+ *   harness.listRunning       → HarnessProcessInfo[]
+ *   harness.syncConfig        → ConfigSyncResult
+ *   harness.diffConfig        → ConfigDiffEntry
+ *   harness.health            → HealthCheckResult
+ *   session.register          → AgentSession
+ *   session.update            → AgentSession
+ *   session.end               → { ok: true }
+ *   session.list              → AgentSession[]
+ *   session.history           → AgentSession[]
+ *   mail.send                 → AgentMessage
+ *   mail.broadcast            → { sent: number }
+ *   mail.inbox                → AgentMessage[]
+ *   mail.markRead             → { ok: true }
+ *   files.reserve             → { success, holder? }
+ *   files.check               → FileReservation | null
+ *   files.release             → { released: number }
+ *   files.list                → FileReservation[]
+ *   tasks.create              → AgentTask
+ *   tasks.claim               → { success, owner? }
+ *   tasks.complete            → { ok: boolean }
+ *   tasks.release             → { ok: boolean }
+ *   tasks.list                → AgentTask[]
+ *   events.log                → DaemonEvent
+ *   events.recent             → DaemonEvent[]
+ *   agent.spawn               → { sessionId: string }
+ *   agent.stop                → { ok: true }
+ *   agent.list                → AgentSessionInfo[]
+ *   agent.remove              → { ok: true }
+ *   inference.ollama.status   → OllamaStatus
+ *   inference.ollama.models   → OllamaModel[]
+ *   inference.ollama.pull     → ModelPullResult
+ *   inference.ollama.delete   → { ok: true }
+ *   inference.ollama.start    → { ok: true }
+ *   inference.ollama.stop     → { ok: true }
+ *   inference.bitnet.status   → BitNetStatus
+ *   inference.snap.list       → SnapModel[]
+ *   inference.snap.status     → SnapStatus
+ *   inference.snap.install    → ModelPullResult
+ *   inference.snap.remove     → { ok: true }
+ */
+declare class RpcServer {
+    private readonly registry;
+    private readonly socketPath;
+    private readonly store?;
+    private server;
+    private healthCheckFn;
+    private spawner;
+    private inference;
+    constructor(registry: HarnessRegistry, socketPath: string, store?: DaemonStore | undefined);
+    private handleLine;
+    private dispatch;
+    /** Helper: store not configured error. */
+    private noStore;
+    /** Helper: missing parameter error. */
+    private missingParam;
+    /** Helper: service not configured error. */
+    private noService;
+    /**
+     * Dispatch an HTTP request body (JSON-RPC) and call the reply callback.
+     * Used by HttpGateway to proxy requests without going through a socket.
+     */
+    dispatchHttp(body: string, reply: (response: JsonRpcResponse) => void): void;
+    /** Set the health check function (called by coordinator after construction). */
+    setHealthCheck(fn: () => Promise<unknown>): void;
+    /** Attach the spawner service (called by coordinator after construction). */
+    setSpawner(spawner: SpawnerService): void;
+    /** Attach the inference service (called by coordinator after construction). */
+    setInference(inference: InferenceService): void;
+    /** Get the spawner service (used by HTTP gateway for SSE). */
+    getSpawner(): SpawnerService | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+
+/**
+ * HTTP gateway that exposes the harness daemon over TCP.
+ *
+ * Routes:
+ *   POST /rpc              — JSON-RPC 2.0 proxy (same protocol as Unix socket)
+ *   GET  /api/pair          — Returns pairing status (requires valid token or no token set)
+ *   POST /api/pair          — Submit pairing code to get a session token
+ *   GET  /api/stream/:id     — SSE stream of agent output (real-time)
+ *   GET  /                  — Serves Studio static frontend (index.html)
+ *   GET  /assets/*          — Serves static assets
+ *
+ * Auth:
+ *   All /rpc and /api/* requests (except POST /api/pair) require:
+ *     Authorization: Bearer <session-token>
+ *   The session token is obtained via the pairing flow.
+ */
+interface HttpGatewayConfig {
+    /** TCP port to listen on (default: 7890) */
+    port: number;
+    /** Bind address (default: '0.0.0.0' for Tailscale access) */
+    host: string;
+    /** Path to Studio static build directory (optional — disables static serving if absent) */
+    staticDir?: string;
+    /** Reference to the Unix-socket RPC server for dispatching */
+    rpcDispatch: RpcServer;
+    /** Reference to the spawner service (enables SSE streaming) */
+    spawner?: SpawnerService;
+}
+declare class HttpGateway {
+    private server;
+    private readonly config;
+    /** 6-digit pairing code (regenerated on each start) */
+    private pairingCode;
+    /** Active session tokens (bearer tokens granted after pairing) */
+    private sessionTokens;
+    /** Whether pairing has been completed at least once */
+    private paired;
+    constructor(config: HttpGatewayConfig);
+    /** The current pairing code (display this in Studio/terminal) */
+    getPairingCode(): string;
+    /** Regenerate the pairing code (invalidates previous code) */
+    regeneratePairingCode(): string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    /** Verify the Authorization: Bearer <token> header */
+    private checkAuth;
+    /** POST /api/pair — submit pairing code, receive session token */
+    private handlePair;
+    /** GET /api/pair — check pairing status */
+    private handlePairStatus;
+    /** GET /api/status — daemon status summary */
+    private handleStatus;
+    /** POST /rpc — proxy JSON-RPC to the daemon's dispatch */
+    private handleRpc;
+    /** GET /api/stream[/:sessionId] — SSE for agent output and exit events */
+    private handleStream;
+    /** Serve static files from the Studio build directory */
+    private handleStatic;
+}
+
 interface CoordinatorOptions {
     /** Absolute path to the project root (where .claude/workboard.md lives) */
     projectRoot: string;
@@ -114,6 +358,12 @@ interface CoordinatorOptions {
     socketPath?: string;
     /** Session task description shown in the workboard */
     task?: string;
+    /** Enable HTTP gateway for remote access (default: disabled) */
+    httpPort?: number;
+    /** HTTP gateway bind address (default: '0.0.0.0') */
+    httpHost?: string;
+    /** Path to Studio static build for serving via HTTP gateway */
+    httpStaticDir?: string;
 }
 /**
  * HarnessCoordinator — single entry point for harness-to-harness coordination.
@@ -132,6 +382,10 @@ declare class HarnessCoordinator {
     private readonly options;
     private readonly registry;
     private rpcServer;
+    private httpGateway;
+    private store;
+    private spawner;
+    private inference;
     private sessionId;
     private readonly workboard;
     constructor(options: CoordinatorOptions);
@@ -141,8 +395,12 @@ declare class HarnessCoordinator {
     getRegistry(): HarnessRegistry;
     /** The workboard manager. */
     getWorkboard(): WorkboardManager;
+    /** The daemon persistent store (available after start()). */
+    getStore(): DaemonStore | null;
     /** Register a custom adapter (must be called before start()). */
     registerAdapter(adapter: HarnessAdapter): void;
+    /** The HTTP gateway (available after start() if httpPort was set). */
+    getHttpGateway(): HttpGateway | null;
     /** Run a health check across all registered harnesses and the workboard. */
     healthCheck(): Promise<HealthCheckResult>;
 }
@@ -168,33 +426,6 @@ declare function findAllHarnessProcesses(): Promise<HarnessProcessInfo[]>;
 /** Finds Claude Code Unix socket files (used for IPC). */
 declare function findClaudeCodeSockets(): Promise<string[]>;
 
-/**
- * JSON-RPC 2.0 server over a Unix domain socket.
- * Mirrors RpcServer from packages/editors.
- *
- * Methods:
- *   harness.list              → HarnessInfo[]
- *   harness.execute           → HarnessCommandResult
- *   harness.info              → HarnessInfo
- *   harness.listRunning       → HarnessProcessInfo[]
- *   harness.syncConfig        → ConfigSyncResult
- *   harness.diffConfig        → ConfigDiffEntry
- *   harness.health            → HealthCheckResult
- */
-declare class RpcServer {
-    private readonly registry;
-    private readonly socketPath;
-    private server;
-    private healthCheckFn;
-    constructor(registry: HarnessRegistry, socketPath: string);
-    private handleLine;
-    private dispatch;
-    /** Set the health check function (called by coordinator after construction). */
-    setHealthCheck(fn: () => Promise<unknown>): void;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-}
-
 /**
  * @revealui/harnesses — AI Harness Integration System (Server-side)
  *
@@ -209,4 +440,4 @@ declare class RpcServer {
 /** Check whether the harnesses feature is licensed for this installation. */
 declare function checkHarnessesLicense(): Promise<boolean>;
 
-export { ClaudeCodeAdapter, ConfigDiffEntry, ConfigSyncDirection, ConfigSyncResult, type CoordinatorOptions, CursorAdapter, HarnessAdapter, HarnessCapabilities, HarnessCommand, HarnessCommandResult, HarnessCoordinator, HarnessEvent, HarnessInfo, HarnessProcessInfo, HarnessRegistry, HealthCheckResult, RpcServer, WorkboardManager, autoDetectHarnesses, checkHarnessesLicense, diffAllConfigs, diffConfig, findAllHarnessProcesses, findClaudeCodeSockets, findHarnessProcesses, findProcesses, getConfigurableHarnesses, getLocalConfigPath, getRootConfigPath, syncAllConfigs, syncConfig, validateConfigJson };
+export { ClaudeCodeAdapter, ConfigDiffEntry, ConfigSyncDirection, ConfigSyncResult, type CoordinatorOptions, CursorAdapter, DaemonStore, HarnessAdapter, HarnessCapabilities, HarnessCommand, HarnessCommandResult, HarnessCoordinator, HarnessEvent, HarnessInfo, HarnessProcessInfo, HarnessRegistry, HealthCheckResult, RpcServer, WorkboardManager, autoDetectHarnesses, checkHarnessesLicense, diffAllConfigs, diffConfig, findAllHarnessProcesses, findClaudeCodeSockets, findHarnessProcesses, findProcesses, getConfigurableHarnesses, getLocalConfigPath, getRootConfigPath, syncAllConfigs, syncConfig, validateConfigJson };

package/dist/index.js

@@ -18,14 +18,18 @@ import {
   syncAllConfigs,
   syncConfig,
   validateConfigJson
-} from "./chunk-XLIKSLM3.js";
+} from "./chunk-6E2BKO6U.js";
 import {
   buildManifest,
   diffContent,
   generateContent,
   listContent,
   validateManifest
-} from "./chunk-XXEKWC6F.js";
+} from "./chunk-PROC6EJC.js";
+import {
+  DaemonStore,
+  SCHEMA_SQL
+} from "./chunk-DGQ5OB6L.js";
 import {
   WorkboardManager,
   acquireLock,
@@ -36,14 +40,16 @@ import {
   releaseLock,
   withLock,
   withLockAsync
-} from "./chunk-JG6CAG4A.js";
+} from "./chunk-4F4ANKIZ.js";
 import "./chunk-DGUM43GV.js";
 export {
   ClaudeCodeAdapter,
   CursorAdapter,
+  DaemonStore,
   HarnessCoordinator,
   HarnessRegistry,
   RpcServer,
+  SCHEMA_SQL,
   WorkboardManager,
   acquireLock,
   atomicWriteSync,

package/dist/storage/index.d.ts

@@ -0,0 +1,170 @@
+/**
+ * PGlite schema for the RevDev Harness daemon.
+ *
+ * Five tables provide persistent state for multi-agent coordination:
+ *   - agent_sessions: active and historical agent sessions
+ *   - agent_messages: inter-agent mailbox (point-to-point + broadcast)
+ *   - file_reservations: advisory file locks with CAS semantics
+ *   - tasks: claimable work items with CAS ownership
+ *   - events: append-only event log for audit trail
+ *
+ * Uses raw SQL (no Drizzle ORM) to keep the daemon dependency-free.
+ * PGlite runs in-process — no external database needed.
+ */
+/** SQL statements to initialize the daemon database. */
+declare const SCHEMA_SQL = "\n  CREATE TABLE IF NOT EXISTS agent_sessions (\n    id            TEXT PRIMARY KEY,\n    env           TEXT NOT NULL DEFAULT '',\n    task          TEXT NOT NULL DEFAULT '(starting)',\n    files         TEXT NOT NULL DEFAULT '',\n    pid           INTEGER,\n    started_at    TIMESTAMP NOT NULL DEFAULT NOW(),\n    updated_at    TIMESTAMP NOT NULL DEFAULT NOW(),\n    ended_at      TIMESTAMP,\n    exit_summary  TEXT\n  );\n\n  CREATE TABLE IF NOT EXISTS agent_messages (\n    id            SERIAL PRIMARY KEY,\n    from_agent    TEXT NOT NULL,\n    to_agent      TEXT NOT NULL,\n    subject       TEXT NOT NULL DEFAULT '',\n    body          TEXT NOT NULL DEFAULT '',\n    read          BOOLEAN NOT NULL DEFAULT FALSE,\n    created_at    TIMESTAMP NOT NULL DEFAULT NOW()\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_messages_to_unread\n    ON agent_messages (to_agent, read) WHERE read = FALSE;\n\n  CREATE TABLE IF NOT EXISTS file_reservations (\n    file_path     TEXT PRIMARY KEY,\n    agent_id      TEXT NOT NULL,\n    reserved_at   TIMESTAMP NOT NULL DEFAULT NOW(),\n    expires_at    TIMESTAMP NOT NULL,\n    reason        TEXT NOT NULL DEFAULT ''\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_reservations_agent\n    ON file_reservations (agent_id);\n\n  CREATE TABLE IF NOT EXISTS tasks (\n    id            TEXT PRIMARY KEY,\n    description   TEXT NOT NULL DEFAULT '',\n    status        TEXT NOT NULL DEFAULT 'open',\n    owner         TEXT,\n    claimed_at    TIMESTAMP,\n    completed_at  TIMESTAMP,\n    created_at    TIMESTAMP NOT NULL DEFAULT NOW()\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_tasks_status\n    ON tasks (status);\n\n  CREATE INDEX IF NOT EXISTS idx_tasks_owner\n    ON tasks (owner) WHERE owner IS NOT NULL;\n\n  CREATE TABLE IF NOT EXISTS events (\n    id            SERIAL PRIMARY KEY,\n    agent_id      TEXT NOT NULL,\n    event_type    TEXT NOT NULL,\n    payload       JSONB NOT NULL DEFAULT '{}',\n    created_at    TIMESTAMP NOT NULL DEFAULT NOW()\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_events_agent\n    ON events (agent_id, created_at DESC);\n";
+/** Session row shape. */
+interface AgentSession {
+    id: string;
+    env: string;
+    task: string;
+    files: string;
+    pid: number | null;
+    started_at: string;
+    updated_at: string;
+    ended_at: string | null;
+    exit_summary: string | null;
+}
+/** Message row shape. */
+interface AgentMessage {
+    id: number;
+    from_agent: string;
+    to_agent: string;
+    subject: string;
+    body: string;
+    read: boolean;
+    created_at: string;
+}
+/** File reservation row shape. */
+interface FileReservation {
+    file_path: string;
+    agent_id: string;
+    reserved_at: string;
+    expires_at: string;
+    reason: string;
+}
+/** Task row shape. */
+interface AgentTask {
+    id: string;
+    description: string;
+    status: 'open' | 'claimed' | 'completed';
+    owner: string | null;
+    claimed_at: string | null;
+    completed_at: string | null;
+    created_at: string;
+}
+/** Event row shape. */
+interface DaemonEvent {
+    id: number;
+    agent_id: string;
+    event_type: string;
+    payload: Record<string, unknown>;
+    created_at: string;
+}
+
+/**
+ * DaemonStore — persistent state for the RevDev Harness daemon.
+ *
+ * Backed by PGlite (in-process PostgreSQL). The database file lives at
+ * ~/.local/share/revealui/harness.db and survives daemon restarts.
+ *
+ * All methods are async (PGlite queries return promises).
+ */
+
+/** Configuration for DaemonStore. */
+interface DaemonStoreConfig {
+    /** PGlite data directory (default: ~/.local/share/revealui/harness.db) */
+    dataDir: string;
+}
+declare class DaemonStore {
+    private db;
+    private readonly dataDir;
+    constructor(config: DaemonStoreConfig);
+    /** Initialize PGlite and create tables. */
+    init(): Promise<void>;
+    /** Shut down the database. */
+    close(): Promise<void>;
+    private getDb;
+    /** Register or update an agent session. */
+    registerSession(session: {
+        id: string;
+        env: string;
+        task?: string;
+        pid?: number;
+    }): Promise<AgentSession>;
+    /** Update a session's task and/or files. */
+    updateSession(id: string, updates: {
+        task?: string;
+        files?: string;
+    }): Promise<AgentSession | null>;
+    /** End a session (mark ended_at, record exit summary). */
+    endSession(id: string, exitSummary?: string): Promise<void>;
+    /** Get all active sessions (ended_at IS NULL). */
+    getActiveSessions(): Promise<AgentSession[]>;
+    /** Get session history for an agent (most recent first). */
+    getSessionHistory(agentId: string, limit: number): Promise<AgentSession[]>;
+    /** Send a message from one agent to another. */
+    sendMessage(msg: {
+        fromAgent: string;
+        toAgent: string;
+        subject: string;
+        body?: string;
+    }): Promise<AgentMessage>;
+    /** Broadcast a message to all active agents (except sender). */
+    broadcastMessage(msg: {
+        fromAgent: string;
+        subject: string;
+        body?: string;
+    }): Promise<number>;
+    /** Get unread messages for an agent. */
+    getInbox(agentId: string, unreadOnly: boolean): Promise<AgentMessage[]>;
+    /** Mark messages as read. */
+    markRead(messageIds: number[]): Promise<void>;
+    /** Reserve a file for an agent (CAS: fails if already reserved by another). */
+    reserveFile(reservation: {
+        filePath: string;
+        agentId: string;
+        ttlSeconds: number;
+        reason?: string;
+    }): Promise<{
+        success: boolean;
+        holder?: string;
+    }>;
+    /** Check who holds a file reservation. */
+    checkReservation(filePath: string): Promise<FileReservation | null>;
+    /** Release all reservations held by an agent. */
+    releaseAllReservations(agentId: string): Promise<number>;
+    /** Get all reservations for an agent. */
+    getReservations(agentId: string): Promise<FileReservation[]>;
+    /** Create a new task. */
+    createTask(task: {
+        id: string;
+        description: string;
+    }): Promise<AgentTask>;
+    /** Claim a task atomically (CAS: fails if already claimed by another agent). */
+    claimTask(taskId: string, agentId: string): Promise<{
+        success: boolean;
+        owner?: string;
+    }>;
+    /** Complete a task (only the owner can complete it). */
+    completeTask(taskId: string, agentId: string): Promise<boolean>;
+    /** Release a claimed task back to open (only the owner can release). */
+    releaseTask(taskId: string, agentId: string): Promise<boolean>;
+    /** List tasks, optionally filtered by status and/or owner. */
+    listTasks(filter?: {
+        status?: string;
+        owner?: string;
+    }): Promise<AgentTask[]>;
+    /** Append an event to the audit log. */
+    logEvent(event: {
+        agentId: string;
+        eventType: string;
+        payload?: Record<string, unknown>;
+    }): Promise<DaemonEvent>;
+    /** Get recent events (newest first). */
+    getRecentEvents(limit: number): Promise<DaemonEvent[]>;
+    /** Prune events older than a given number of days. */
+    pruneEvents(olderThanDays: number): Promise<number>;
+}
+
+export { type AgentMessage, type AgentSession, type AgentTask, type DaemonEvent, DaemonStore, type DaemonStoreConfig, type FileReservation, SCHEMA_SQL };

package/dist/storage/index.js

@@ -0,0 +1,10 @@
+import {
+  DaemonStore,
+  SCHEMA_SQL
+} from "../chunk-DGQ5OB6L.js";
+import "../chunk-DGUM43GV.js";
+export {
+  DaemonStore,
+  SCHEMA_SQL
+};
+//# sourceMappingURL=index.js.map

package/dist/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/workboard/index.js

@@ -10,7 +10,7 @@ import {
   unregisterSession,
   withLock,
   withLockAsync
-} from "../chunk-JG6CAG4A.js";
+} from "../chunk-4F4ANKIZ.js";
 import "../chunk-DGUM43GV.js";
 export {
   WorkboardManager,