@jini-ai/daemon 0.3.7 → 0.5.0

package/dist/store/agent-sessions/errors.d.ts

@@ -0,0 +1,8 @@
+/** Stable boundary failure with the original driver failure retained as a cause. */
+export declare class AgentSessionStoreError extends Error {
+    readonly code: 'invalid-input' | 'unavailable';
+    constructor({ code }: {
+        readonly code: 'invalid-input' | 'unavailable';
+    }, options?: ErrorOptions);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/store/agent-sessions/errors.js

@@ -0,0 +1,10 @@
+/** Stable boundary failure with the original driver failure retained as a cause. */
+export class AgentSessionStoreError extends Error {
+    code;
+    constructor({ code }, options = {}) {
+        super(code === 'invalid-input' ? 'invalid agent session kernel' : 'agent session store unavailable', options);
+        this.code = code;
+        this.name = 'AgentSessionStoreError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/store/agent-sessions/index.d.ts

@@ -0,0 +1,12 @@
+/** Neutral session-id port and reference adapter; never imports SQL or a driver. */
+import type { AgentSessionStore } from './ports.js';
+export type { AgentSessionStore } from './ports.js';
+export { AgentSessionStoreError } from './errors.js';
+/**
+ * Private in-memory mapping for opaque (conversation, agent) pairs.
+ * JSON pair encoding prevents delimiter collisions; overwrite/clear affect only that pair.
+ * @returns Independent store with asynchronous get/set/clear contracts.
+ * @complexity Each operation O(k) for encoding k identity characters, plus expected O(1) map access.
+ */
+export declare function createInMemoryAgentSessionStore(_requiredArgs: Record<string, never>): AgentSessionStore;
+//# sourceMappingURL=index.d.ts.map

package/dist/store/agent-sessions/index.js

@@ -0,0 +1,19 @@
+export { AgentSessionStoreError } from './errors.js';
+/**
+ * Private in-memory mapping for opaque (conversation, agent) pairs.
+ * JSON pair encoding prevents delimiter collisions; overwrite/clear affect only that pair.
+ * @returns Independent store with asynchronous get/set/clear contracts.
+ * @complexity Each operation O(k) for encoding k identity characters, plus expected O(1) map access.
+ */
+export function createInMemoryAgentSessionStore(_requiredArgs) {
+    // This reference store owns no conversation foreign key, so test/lazy compositions need only
+    // a map; opening an in-memory SQL database and running DDL would add no invariant to enforce.
+    const sessions = new Map();
+    const key = (conversationId, agentId) => JSON.stringify([conversationId, agentId]);
+    return {
+        async getSessionId({ conversationId, agentId }) { return sessions.get(key(conversationId, agentId)) ?? null; },
+        async setSessionId({ conversationId, agentId, sessionId }) { sessions.set(key(conversationId, agentId), sessionId); },
+        async clearSessionId({ conversationId, agentId }) { sessions.delete(key(conversationId, agentId)); },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/store/agent-sessions/pglite.d.ts

@@ -0,0 +1,12 @@
+import type { Clock } from '@jini-ai/core/primitives';
+import type { StorageKernel } from '@jini-ai/db/kernel';
+import type { AgentSessionStore } from './ports.js';
+import { type AgentSessionDatabase } from './sql.js';
+export type { AgentSessionDatabase } from './sql.js';
+/** Simple session-id mapping over a borrowed, migrated kernel; optional core Clock defaults to wall time. */
+export declare function createPgliteAgentSessionStore<DB extends AgentSessionDatabase>(input: {
+    kernel: StorageKernel<DB>;
+}, options?: {
+    clock?: Clock;
+}): AgentSessionStore;
+//# sourceMappingURL=pglite.d.ts.map

package/dist/store/agent-sessions/pglite.js

@@ -0,0 +1,7 @@
+import { createSqlAgentSessionStore, validateSessionKernel } from './sql.js';
+/** Simple session-id mapping over a borrowed, migrated kernel; optional core Clock defaults to wall time. */
+export function createPgliteAgentSessionStore(input, options = {}) {
+    validateSessionKernel({ kernel: input.kernel, dialect: 'postgres', transports: ['pglite', 'pglite-socket'] });
+    return createSqlAgentSessionStore({ kernel: input.kernel }, options);
+}
+//# sourceMappingURL=pglite.js.map

package/dist/store/agent-sessions/ports.d.ts

@@ -0,0 +1,24 @@
+/** Underlying CLI resume ids; distinct from rich legacy agent_sessions records. */
+export interface AgentSessionStore {
+    /** A missing pair starts a fresh CLI session; do not attempt a resume without an id. */
+    getSessionId(args: {
+        readonly conversationId: string;
+        readonly agentId: string;
+    }): Promise<string | null>;
+    /** Each resumed turn can return a successor id, so overwrite the previous id rather than append. */
+    setSessionId(args: {
+        readonly conversationId: string;
+        readonly agentId: string;
+        readonly sessionId: string;
+    }): Promise<void>;
+    /**
+     * Clear when a resumed run ends without confirming a session id. Retaining a dead id would
+     * make every later turn repeat the same failed resume until someone repairs storage manually.
+     * Clearing an absent pair is a silent no-op, making repeated terminal-event handling safe.
+     */
+    clearSessionId(args: {
+        readonly conversationId: string;
+        readonly agentId: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=ports.d.ts.map

package/dist/store/agent-sessions/ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ports.js.map

package/dist/store/agent-sessions/postgres.d.ts

@@ -0,0 +1,12 @@
+import type { Clock } from '@jini-ai/core/primitives';
+import type { StorageKernel } from '@jini-ai/db/kernel';
+import type { AgentSessionStore } from './ports.js';
+import { type AgentSessionDatabase } from './sql.js';
+export type { AgentSessionDatabase } from './sql.js';
+/** Simple session-id mapping over a borrowed, migrated kernel; optional core Clock defaults to wall time. */
+export declare function createPostgresAgentSessionStore<DB extends AgentSessionDatabase>(input: {
+    kernel: StorageKernel<DB>;
+}, options?: {
+    clock?: Clock;
+}): AgentSessionStore;
+//# sourceMappingURL=postgres.d.ts.map

package/dist/store/agent-sessions/postgres.js

@@ -0,0 +1,7 @@
+import { createSqlAgentSessionStore, validateSessionKernel } from './sql.js';
+/** Simple session-id mapping over a borrowed, migrated kernel; optional core Clock defaults to wall time. */
+export function createPostgresAgentSessionStore(input, options = {}) {
+    validateSessionKernel({ kernel: input.kernel, dialect: 'postgres', transports: ['node-postgres'] });
+    return createSqlAgentSessionStore({ kernel: input.kernel }, options);
+}
+//# sourceMappingURL=postgres.js.map

package/dist/store/agent-sessions/schema.d.ts

@@ -0,0 +1,3 @@
+/** Rich legacy resume-identity table, separate from assistant_agent_sessions. */
+export declare const LEGACY_AGENT_SESSIONS_DDL = "    CREATE TABLE IF NOT EXISTS agent_sessions (\n      conversation_id TEXT NOT NULL,\n      agent_id        TEXT NOT NULL,\n      session_id      TEXT NOT NULL,\n      stable_prompt_hash TEXT,\n      -- Resume identity guard: the session is only safe to resume when the\n      -- conversation has not changed shape under it. model/cwd are the runtime\n      -- identity the upstream session was created with; a change forces a fresh\n      -- session. last_message_id is the assistant message this session produced\n      -- on its last turn -- if it is no longer the latest completed assistant\n      -- turn (another agent ran in between, or it was edited away), the session\n      -- is behind and we reseed the full transcript.\n      model           TEXT,\n      cwd             TEXT,\n      last_message_id TEXT,\n      updated_at      INTEGER NOT NULL,\n      PRIMARY KEY (conversation_id, agent_id),\n      FOREIGN KEY(conversation_id) REFERENCES conversations(id) ON DELETE CASCADE\n    );\n\n";
+//# sourceMappingURL=schema.d.ts.map

package/dist/store/agent-sessions/schema.js

@@ -0,0 +1,23 @@
+/** Rich legacy resume-identity table, separate from assistant_agent_sessions. */
+export const LEGACY_AGENT_SESSIONS_DDL = `    CREATE TABLE IF NOT EXISTS agent_sessions (
+      conversation_id TEXT NOT NULL,
+      agent_id        TEXT NOT NULL,
+      session_id      TEXT NOT NULL,
+      stable_prompt_hash TEXT,
+      -- Resume identity guard: the session is only safe to resume when the
+      -- conversation has not changed shape under it. model/cwd are the runtime
+      -- identity the upstream session was created with; a change forces a fresh
+      -- session. last_message_id is the assistant message this session produced
+      -- on its last turn -- if it is no longer the latest completed assistant
+      -- turn (another agent ran in between, or it was edited away), the session
+      -- is behind and we reseed the full transcript.
+      model           TEXT,
+      cwd             TEXT,
+      last_message_id TEXT,
+      updated_at      INTEGER NOT NULL,
+      PRIMARY KEY (conversation_id, agent_id),
+      FOREIGN KEY(conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+    );
+
+`;
+//# sourceMappingURL=schema.js.map

package/dist/store/agent-sessions/sql.d.ts

@@ -0,0 +1,35 @@
+/** One simple-session query implementation over the host's borrowed, migrated kernel. */
+import { type Clock } from '@jini-ai/core/primitives';
+import type { ColumnType } from 'kysely';
+import type { StorageKernel, StorageDialect, StorageTransport } from '@jini-ai/db/kernel';
+import type { AgentSessionStore } from './ports.js';
+/** Hosts can add tables; the adapter requires only this unchanged mapping table. */
+export interface AgentSessionDatabase {
+    assistant_agent_sessions: {
+        conversation_id: string;
+        agent_id: string;
+        session_id: string;
+        updated_at: number | string | ColumnType<number | string, number, number>;
+    };
+}
+/** Factory validation is pure; PGlite supports embedded and socket transports. */
+export declare function validateSessionKernel<DB>({ kernel, dialect, transports }: {
+    readonly kernel: StorageKernel<DB>;
+    readonly dialect: StorageDialect;
+    readonly transports: readonly StorageTransport[];
+}): void;
+/**
+ * Constructs a three-method mapping with no migration, pragma, open, close, or query at construction.
+ * All queries join the host kernel's existing transaction; concurrent set is one atomic upsert.
+ * @param kernel Borrowed host kernel with assistant_agent_sessions already migrated.
+ * @param optional Core Clock, evaluated once per set; defaults to system wall time.
+ * @returns Session-id port; missing pairs read null and clear is idempotent.
+ * @throws AgentSessionStoreError when a driver/query fails.
+ * @complexity Each operation is one primary-key statement, O(log n) index lookup for n pairs.
+ */
+export declare function createSqlAgentSessionStore<DB extends AgentSessionDatabase>({ kernel }: {
+    readonly kernel: StorageKernel<DB>;
+}, { clock }?: {
+    readonly clock?: Clock;
+}): AgentSessionStore;
+//# sourceMappingURL=sql.d.ts.map

package/dist/store/agent-sessions/sql.js

@@ -0,0 +1,59 @@
+/** One simple-session query implementation over the host's borrowed, migrated kernel. */
+import { createSystemClock } from '@jini-ai/core/primitives';
+import { AgentSessionStoreError } from './errors.js';
+/** Factory validation is pure; PGlite supports embedded and socket transports. */
+export function validateSessionKernel({ kernel, dialect, transports }) {
+    if (!kernel || kernel.dialect !== dialect || !transports.includes(kernel.transport))
+        throw new AgentSessionStoreError({ code: 'invalid-input' });
+}
+/**
+ * The single table-subset projection preserves the original kernel's transaction context.
+ * DB's bound proves the required table; this erasure does not bridge separate Kysely versions.
+ */
+function runSessionQuery(kernel, body) {
+    return kernel.run(db => body(db));
+}
+/** Translate opaque driver failures without losing their cause or mutating host state. */
+async function atSessionBoundary(operation) {
+    try {
+        return await operation();
+    }
+    catch (cause) {
+        throw new AgentSessionStoreError({ code: 'unavailable' }, { cause });
+    }
+}
+/**
+ * Constructs a three-method mapping with no migration, pragma, open, close, or query at construction.
+ * All queries join the host kernel's existing transaction; concurrent set is one atomic upsert.
+ * @param kernel Borrowed host kernel with assistant_agent_sessions already migrated.
+ * @param optional Core Clock, evaluated once per set; defaults to system wall time.
+ * @returns Session-id port; missing pairs read null and clear is idempotent.
+ * @throws AgentSessionStoreError when a driver/query fails.
+ * @complexity Each operation is one primary-key statement, O(log n) index lookup for n pairs.
+ */
+export function createSqlAgentSessionStore({ kernel }, { clock = createSystemClock() } = {}) {
+    return {
+        getSessionId({ conversationId, agentId }) {
+            return atSessionBoundary(async () => {
+                const row = await runSessionQuery(kernel, db => db.selectFrom('assistant_agent_sessions').select('session_id')
+                    .where('conversation_id', '=', conversationId).where('agent_id', '=', agentId).executeTakeFirst());
+                return row?.session_id ?? null;
+            });
+        },
+        setSessionId({ conversationId, agentId, sessionId }) {
+            return atSessionBoundary(async () => {
+                const updatedAt = clock.nowMs();
+                await runSessionQuery(kernel, db => db.insertInto('assistant_agent_sessions')
+                    .values({ conversation_id: conversationId, agent_id: agentId, session_id: sessionId, updated_at: updatedAt })
+                    .onConflict(oc => oc.columns(['conversation_id', 'agent_id']).doUpdateSet({ session_id: sessionId, updated_at: updatedAt })).execute());
+            });
+        },
+        clearSessionId({ conversationId, agentId }) {
+            return atSessionBoundary(async () => {
+                await runSessionQuery(kernel, db => db.deleteFrom('assistant_agent_sessions')
+                    .where('conversation_id', '=', conversationId).where('agent_id', '=', agentId).execute());
+            });
+        },
+    };
+}
+//# sourceMappingURL=sql.js.map

package/dist/store/agent-sessions/sqlite.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @module db/agent-sessions
+ * Owns the per-(conversation, agent) upstream CLI session cache used by the resume identity guard.
+ * Imports only the core/ kernel (types). No other db concern is imported.
+ *
+ * NOTE (neutral port): no OD-specific columns or logic — every field (session id, prompt hash,
+ * model, cwd, last message id) is generic resume-identity bookkeeping already matched 1:1 by the
+ * already-ported `schema/migrate.ts` `agent_sessions` table. Ported verbatim aside from
+ * de-branding the module doc comment.
+ */
+import type { SqliteDb } from '@jini-ai/db/sqlite';
+/**
+ * Returns the stored upstream CLI session id for a (conversation, agent) pair, or null if none exists.
+ * Used as a quick existence check before the full record is needed.
+ * @param db - Open SQLite database handle.
+ * @param conversationId - Conversation scope for the session.
+ * @param agentId - Agent whose session to look up.
+ */
+export declare function getAgentSession({ db, conversationId, agentId }: {
+    readonly db: SqliteDb;
+    readonly conversationId: string;
+    readonly agentId: string;
+}): string | null;
+/**
+ * Creates or replaces the agent session record for a (conversation, agent) pair.
+ * All nullable fields are stored as SQL NULL when omitted, preserving the resume guard's
+ * ability to detect staleness via stablePromptHash and lastMessageId.
+ * @param db - Open SQLite database handle.
+ * @param input - Session fields to persist; conversationId, agentId, and sessionId are required.
+ */
+export declare function upsertAgentSession({ db, input }: {
+    readonly db: SqliteDb;
+    readonly input: {
+        conversationId: string;
+        agentId: string;
+        sessionId: string;
+        stablePromptHash?: string | null;
+        model?: string | null;
+        cwd?: string | null;
+        lastMessageId?: string | null;
+    };
+}): void;
+/**
+ * Fetches the full agent session record for a (conversation, agent) pair, or null if absent.
+ * Callers that need only the session id should use {@link getAgentSession} instead.
+ * @param db - Open SQLite database handle.
+ * @param conversationId - Conversation scope for the session.
+ * @param agentId - Agent whose session to retrieve.
+ */
+export declare function getAgentSessionRecord({ db, conversationId, agentId }: {
+    readonly db: SqliteDb;
+    readonly conversationId: string;
+    readonly agentId: string;
+}): {
+    sessionId: string;
+    stablePromptHash: string | null;
+    model: string | null;
+    cwd: string | null;
+    lastMessageId: string | null;
+} | null;
+/**
+ * Returns the conversation cursor used by the resume identity guard: the id of the most recent
+ * completed (succeeded) assistant message, excluding the current in-flight placeholder.
+ * See the inline comment above for the full invariant and the resumableMessageId exception.
+ * @param db - Open SQLite database handle.
+ * @param conversationId - Conversation to inspect.
+ * @param excludeMessageId - The in-flight run's own placeholder message id to skip.
+ * @param resumableMessageId - Optional id of a transiently-failed session's last message, admitted through the succeeded-only filter.
+ * @returns The matching message id, or null if no prior completed turn exists.
+ */
+export declare function latestCompletedAssistantMessageId({ db, conversationId, excludeMessageId }: {
+    readonly db: SqliteDb;
+    readonly conversationId: string;
+    readonly excludeMessageId: string;
+}, { resumableMessageId }?: {
+    readonly resumableMessageId?: string | null;
+}): string | null;
+/**
+ * Updates the stable prompt hash for an existing agent session without touching other fields.
+ * Called after the resume path confirms the prompt context is still stable, recording the
+ * current hash so future identity checks can compare against it.
+ * @param db - Open SQLite database handle.
+ * @param conversationId - Conversation scope for the session.
+ * @param agentId - Agent whose session to update.
+ * @param stablePromptHash - The new prompt hash to record.
+ */
+export declare function updateAgentSessionStableHash({ db, conversationId, agentId, stablePromptHash }: {
+    readonly db: SqliteDb;
+    readonly conversationId: string;
+    readonly agentId: string;
+    readonly stablePromptHash: string;
+}): void;
+/**
+ * Deletes the agent session record for a (conversation, agent) pair.
+ * Forces the next run to start a fresh upstream CLI session rather than attempting resume.
+ * @param db - Open SQLite database handle.
+ * @param conversationId - Conversation scope for the session.
+ * @param agentId - Agent whose session to clear.
+ */
+export declare function clearAgentSession({ db, conversationId, agentId }: {
+    readonly db: SqliteDb;
+    readonly conversationId: string;
+    readonly agentId: string;
+}): void;
+export { LEGACY_AGENT_SESSIONS_DDL } from './schema.js';
+import type { Clock } from '@jini-ai/core/primitives';
+import type { StorageKernel } from '@jini-ai/db/kernel';
+import type { AgentSessionStore } from './ports.js';
+import { type AgentSessionDatabase } from './sql.js';
+export type { AgentSessionDatabase } from './sql.js';
+/** Simple session-id mapping over a borrowed, migrated kernel; optional core Clock defaults to wall time. */
+export declare function createSqliteAgentSessionStore<DB extends AgentSessionDatabase>(input: {
+    kernel: StorageKernel<DB>;
+}, options?: {
+    clock?: Clock;
+}): AgentSessionStore;
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/store/agent-sessions/sqlite.js

@@ -0,0 +1,128 @@
+/**
+ * Returns the stored upstream CLI session id for a (conversation, agent) pair, or null if none exists.
+ * Used as a quick existence check before the full record is needed.
+ * @param db - Open SQLite database handle.
+ * @param conversationId - Conversation scope for the session.
+ * @param agentId - Agent whose session to look up.
+ */
+export function getAgentSession({ db, conversationId, agentId }) {
+    const row = db
+        .prepare(`SELECT session_id FROM agent_sessions
+        WHERE conversation_id = ? AND agent_id = ?`)
+        .get(conversationId, agentId);
+    return row && typeof row.session_id === 'string' ? row.session_id : null;
+}
+/**
+ * Creates or replaces the agent session record for a (conversation, agent) pair.
+ * All nullable fields are stored as SQL NULL when omitted, preserving the resume guard's
+ * ability to detect staleness via stablePromptHash and lastMessageId.
+ * @param db - Open SQLite database handle.
+ * @param input - Session fields to persist; conversationId, agentId, and sessionId are required.
+ */
+export function upsertAgentSession({ db, input }) {
+    db.prepare(`INSERT INTO agent_sessions
+       (conversation_id, agent_id, session_id, stable_prompt_hash, model, cwd, last_message_id, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(conversation_id, agent_id)
+       DO UPDATE SET session_id = excluded.session_id,
+                     stable_prompt_hash = excluded.stable_prompt_hash,
+                     model = excluded.model,
+                     cwd = excluded.cwd,
+                     last_message_id = excluded.last_message_id,
+                     updated_at = excluded.updated_at`).run(input.conversationId, input.agentId, input.sessionId, input.stablePromptHash ?? null, input.model ?? null, input.cwd ?? null, input.lastMessageId ?? null, Date.now());
+}
+/**
+ * Fetches the full agent session record for a (conversation, agent) pair, or null if absent.
+ * Callers that need only the session id should use {@link getAgentSession} instead.
+ * @param db - Open SQLite database handle.
+ * @param conversationId - Conversation scope for the session.
+ * @param agentId - Agent whose session to retrieve.
+ */
+export function getAgentSessionRecord({ db, conversationId, agentId }) {
+    const row = db
+        .prepare(`SELECT session_id, stable_prompt_hash, model, cwd, last_message_id FROM agent_sessions
+        WHERE conversation_id = ? AND agent_id = ?`)
+        .get(conversationId, agentId);
+    if (!row || typeof row.session_id !== 'string')
+        return null;
+    return {
+        sessionId: row.session_id,
+        stablePromptHash: typeof row.stable_prompt_hash === 'string' ? row.stable_prompt_hash : null,
+        model: typeof row.model === 'string' ? row.model : null,
+        cwd: typeof row.cwd === 'string' ? row.cwd : null,
+        lastMessageId: typeof row.last_message_id === 'string' ? row.last_message_id : null,
+    };
+}
+// Conversation cursor for the resume identity guard: the id of the latest
+// COMPLETED assistant message in the conversation, EXCLUDING the current run's
+// in-flight placeholder (`excludeMessageId`). At resolve time the session is in
+// sync iff this equals the assistant message the session last produced —
+// otherwise another agent completed a turn in between, or the session's own last
+// message was edited/removed, and the session is behind. Returns null when there
+// is no prior completed assistant turn.
+//
+// "Completed" means run_status = 'succeeded' — a run stamps its assistant
+// message with the terminal status on finish, so an intervening agent run that
+// FAILED or was CANCELED leaves a placeholder that produced no completed turn;
+// counting it as advancement would force a needless cold reseed (silently
+// disabling the resume perf path) even though the stored session is still the
+// latest completed turn. In-flight placeholders have a null run_status and are
+// likewise excluded.
+//
+// `resumableMessageId` is the one allowed exception: a resume-on-failure path
+// may persist a session whose own last assistant turn FAILED transiently (the
+// CLI session already committed a tool/artifact block and is resumable). That
+// stored id is admitted through the filter so the session it owns still matches
+// its cursor — while a DIFFERENT later failed/canceled turn (a different id)
+// stays excluded, so genuine advancement by a later succeeded turn is still
+// detected.
+/**
+ * Returns the conversation cursor used by the resume identity guard: the id of the most recent
+ * completed (succeeded) assistant message, excluding the current in-flight placeholder.
+ * See the inline comment above for the full invariant and the resumableMessageId exception.
+ * @param db - Open SQLite database handle.
+ * @param conversationId - Conversation to inspect.
+ * @param excludeMessageId - The in-flight run's own placeholder message id to skip.
+ * @param resumableMessageId - Optional id of a transiently-failed session's last message, admitted through the succeeded-only filter.
+ * @returns The matching message id, or null if no prior completed turn exists.
+ */
+export function latestCompletedAssistantMessageId({ db, conversationId, excludeMessageId }, { resumableMessageId = null } = {}) {
+    const row = db
+        .prepare(`SELECT id FROM messages
+        WHERE conversation_id = ? AND role = 'assistant' AND id != ?
+          AND (run_status = 'succeeded' OR id = ?)
+        ORDER BY position DESC LIMIT 1`)
+        .get(conversationId, excludeMessageId, resumableMessageId);
+    return row && typeof row.id === 'string' ? row.id : null;
+}
+/**
+ * Updates the stable prompt hash for an existing agent session without touching other fields.
+ * Called after the resume path confirms the prompt context is still stable, recording the
+ * current hash so future identity checks can compare against it.
+ * @param db - Open SQLite database handle.
+ * @param conversationId - Conversation scope for the session.
+ * @param agentId - Agent whose session to update.
+ * @param stablePromptHash - The new prompt hash to record.
+ */
+export function updateAgentSessionStableHash({ db, conversationId, agentId, stablePromptHash }) {
+    db.prepare(`UPDATE agent_sessions SET stable_prompt_hash = ?, updated_at = ?
+      WHERE conversation_id = ? AND agent_id = ?`).run(stablePromptHash, Date.now(), conversationId, agentId);
+}
+/**
+ * Deletes the agent session record for a (conversation, agent) pair.
+ * Forces the next run to start a fresh upstream CLI session rather than attempting resume.
+ * @param db - Open SQLite database handle.
+ * @param conversationId - Conversation scope for the session.
+ * @param agentId - Agent whose session to clear.
+ */
+export function clearAgentSession({ db, conversationId, agentId }) {
+    db.prepare(`DELETE FROM agent_sessions WHERE conversation_id = ? AND agent_id = ?`).run(conversationId, agentId);
+}
+export { LEGACY_AGENT_SESSIONS_DDL } from './schema.js';
+import { createSqlAgentSessionStore, validateSessionKernel } from './sql.js';
+/** Simple session-id mapping over a borrowed, migrated kernel; optional core Clock defaults to wall time. */
+export function createSqliteAgentSessionStore(input, options = {}) {
+    validateSessionKernel({ kernel: input.kernel, dialect: 'sqlite', transports: ['better-sqlite3'] });
+    return createSqlAgentSessionStore({ kernel: input.kernel }, options);
+}
+//# sourceMappingURL=sqlite.js.map

package/dist/store/event-log/sqlite.d.ts

@@ -0,0 +1,75 @@
+import { type Clock } from '@jini-ai/core/primitives';
+/**
+ * `createSqliteEventLog` — the durable `EventLog` adapter (extraction-plan §8 task 8,
+ * §2.6: "`@jini-ai/daemon/store/event-log/sqlite` is the default adapter... an adapter conformance suite covers
+ * transactions/ordering/cursor-durability/cancellation/migrations").
+ *
+ * Implements the protocol's two-object `EventLog` call shape, with the same distinguishable `'replay-gap'` result,
+ * same never-reused monotonic per-run cursor allocation, same FIFO eviction at
+ * `maxEntriesPerRun` — see `createInMemoryEventLog` in `@jini-ai/daemon` for the
+ * reference behavior this mirrors. `better-sqlite3` is synchronous; every public
+ * method still returns a `Promise` per extraction-plan §2.6 ("ports are async-only
+ * from day one... a real persistent adapter is a drop-in swap"), and every
+ * multi-statement operation (`append`'s dedupe-check + insert + eviction) runs
+ * inside a `better-sqlite3` transaction for atomicity.
+ *
+ * Three deliberate divergences from the in-memory reference adapter, all scoped to this durable
+ * adapter only: (1) `maxEntriesPerRun` defaults to {@link DEFAULT_MAX_ENTRIES_PER_RUN} (2000)
+ * instead of unbounded — see `SqliteEventLogOptions.maxEntriesPerRun`'s doc; (2) `replay`'s
+ * `afterCursor` is validated up front and throws for anything other than `null` or a
+ * non-negative-safe-integer string, instead of returning a `'invalid-cursor'` result — see
+ * `assertValidReplayCursor`; (3) dedupe evidence is retained only while its entry remains in the
+ * FIFO window. Memory keeps dedupe evidence until drop, including evicted entries. This durable
+ * adapter preserves its existing bounded SQL/schema behavior rather than adding a hidden archive.
+ */
+import { type SqliteDb, type SqliteSyncOpener } from '@jini-ai/db/sqlite';
+import type { EventLog } from '@jini-ai/protocol';
+/**
+ * Default per-run retention cap applied when `SqliteEventLogOptions.maxEntriesPerRun` is
+ * omitted — see that option's doc for why a durable adapter defaults to a bound instead of
+ * mirroring the in-memory reference adapter's unbounded-by-default behavior.
+ */
+export declare const DEFAULT_MAX_ENTRIES_PER_RUN = 2000;
+export interface SqliteEventLogOptions {
+    /**
+     * Maximum entries retained per run before the oldest are evicted. Defaults to
+     * {@link DEFAULT_MAX_ENTRIES_PER_RUN} (2000) when omitted — unlike the in-memory reference
+     * adapter (`@jini-ai/daemon`'s `createInMemoryEventLog`), where an omitted cap means unbounded,
+     * a durable on-disk store defaults to a bounded retention window because unbounded persistent
+     * growth is a real, unattended operational risk (disk exhaustion across long-lived runs) in a
+     * way an in-process, GC'd, process-lifetime-bounded structure is not. Pass an explicit value
+     * (larger, smaller, or `0`) to override the default in either direction — the caller then
+     * owns that tradeoff explicitly. Must be a non-negative safe integer; anything else (negative,
+     * fractional, `NaN`, `Infinity`) throws at construction time.
+     */
+    readonly maxEntriesPerRun?: number;
+    /** Core Clock for durable recordedAt values; omitted clock preserves system wall time. */
+    readonly clock?: Clock;
+}
+/** A `@jini-ai/daemon` `EventLog` backed by a `better-sqlite3` database, plus a `close()` to release the file handle. */
+export interface SqliteEventLog extends EventLog {
+    close(_args: Record<string, never>): Promise<void>;
+}
+/**
+ * Borrows the caller's connection and ensures the dedicated event-log schema idempotently.
+ * Closing this adapter never closes a borrowed handle or changes its pragmas.
+ * Use openSqliteEventLog with an explicit file/opener to acquire an owned connection.
+ * @throws Host SQL/setup failures, or a missing borrowed connection.
+ * @complexity Setup O(1) statements; append costs depend on the retained per-run cap.
+ */
+export declare function createSqliteEventLog(input: {
+    db: SqliteDb;
+}, options?: SqliteEventLogOptions): SqliteEventLog;
+/**
+ * Acquires a connection through the host opener; setup failure closes that connection.
+ * Successful close is idempotent and closes only this owned handle.
+ * @param input File and host-owned opener; no ambient driver is loaded.
+ * @returns Durable event log with an owned closer.
+ * @throws Original acquisition/schema/prepare failure; cleanup never masks it.
+ * @complexity O(1) acquisition calls; subsequent costs are the borrowed adapter's.
+ */
+export declare function openSqliteEventLog(input: {
+    file: string;
+    open: SqliteSyncOpener;
+}, options?: SqliteEventLogOptions): SqliteEventLog;
+//# sourceMappingURL=sqlite.d.ts.map