@jini-ai/server 0.0.0-stage → 0.5.1

package/dist/kernel-base.js

@@ -0,0 +1,125 @@
+/**
+ * @module kernel-base
+ *
+ * The infrastructure every composition owns regardless of which features it activates: the durable
+ * (or in-memory) event log, the run lifecycle, the byte journal, the agent executor, the one shared
+ * `ToolRegistry`/`ToolExecutor` pair, and — for sqlite storage — the raw database connection.
+ *
+ * **The database connection belongs here, not to a feature.** It is borrowed by the readiness probe
+ * (`health`), by the raw db-operations tools (`daemonDb`), and by the durable tool catalog
+ * (`toolCatalog`) — three independently-selectable features. Had any one of them owned it, disabling
+ * that feature would have silently broken the others: turning off `daemonDb` would leave `health`'s
+ * readiness probe with nothing to check, which is a much worse failure than the one it was meant to
+ * simplify, because a readiness probe that stops probing still answers `200`. Ownership by the base,
+ * borrowing by features, is what makes the feature set genuinely independent.
+ */
+import { openSqliteConnection } from '@jini-ai/db/sqlite';
+import { join } from 'node:path';
+import { createToolRegistry } from '@jini-ai/core';
+import { createAgentExecutor, createInMemoryEventLog, createRunByteJournal, createRunLifecycle, createToolExecutor, resumableFromProcessExit, } from '@jini-ai/daemon';
+import { openSqliteEventLog } from '@jini-ai/daemon/store/event-log/sqlite';
+/**
+ * The zero-config retry classifier every composition gets. Delegates entirely to `@jini-ai/daemon`'s
+ * `resumableFromProcessExit` — see that function's own doc for the classification policy.
+ */
+export function classifyRunFailureForRetry(context) {
+    return resumableFromProcessExit({ code: context.code, signal: context.signal }, context.sideEffects === undefined ? {} : { sideEffects: context.sideEffects });
+}
+/**
+ * Opens every kernel-owned resource and rehydrates durable run history.
+ *
+ * @throws If rehydration fails against a corrupt or unreadable durable history. Every handle this
+ * call had already opened is closed before it rethrows, so a failed boot never leaks a sqlite file
+ * handle — the invariant the standalone daemon has always maintained.
+ */
+export async function createJiniKernelBase(options) {
+    const sqliteStorage = options.storage.kind === 'sqlite' ? options.storage : null;
+    const dataDir = sqliteStorage?.dataDir ?? null;
+    const eventsDbPath = dataDir === null ? null : join(dataDir, 'events.db');
+    // One acquisition block, one cleanup path — and **every** acquisition is inside it. Opening even
+    // the first event log outside the block would reintroduce exactly the leak this shape exists to
+    // prevent: `events.db` opens, `journal.db` fails (corrupt file, or a directory sitting where a
+    // database was expected), and the first handle stays open for the lifetime of a process that has
+    // no kernel. The second sqlite connection and the rehydration are grouped here for the same
+    // reason: all four can fail after handles are already open, and two try/catch blocks with
+    // near-identical cleanup is how one of them eventually drifts and starts leaking.
+    const opened = [];
+    const openEventLog = (path) => {
+        let log;
+        if (path === null)
+            log = createInMemoryEventLog({});
+        else {
+            // A non-null path is derived only from sqliteStorage above.
+            log = openSqliteEventLog({ file: path, open: sqliteStorage.open });
+        }
+        opened.push(log);
+        return log;
+    };
+    let sqlite = null;
+    let featureConnection;
+    let eventLog;
+    let journalEventLog;
+    let lifecycle;
+    let journal;
+    try {
+        eventLog = openEventLog(eventsDbPath);
+        // Gap 1's byte journal gets its own store, deliberately separate from `eventLog`: that log
+        // replays every entry it holds to SSE subscribers as a `RunProtocolEvent`, and a journal entry
+        // has no corresponding protocol-event kind.
+        journalEventLog = openEventLog(dataDir === null ? null : join(dataDir, 'journal.db'));
+        if (sqliteStorage && eventsDbPath !== null && dataDir !== null) {
+            // A *second* connection to the same `events.db` the log above owns — safe: both run in WAL
+            // mode, which permits multiple concurrently open handles on one file within a single process.
+            featureConnection = openSqliteConnection({ filePath: eventsDbPath, open({ filePath }, settings) {
+                    featureConnection = sqliteStorage.open(filePath, settings);
+                    return featureConnection;
+                } });
+            sqlite = { connection: featureConnection, eventsDbPath, dataDir };
+        }
+        journal = createRunByteJournal({ eventLog: journalEventLog });
+        lifecycle = createRunLifecycle({ eventLog });
+        await lifecycle.rehydrate({});
+    }
+    catch (error) {
+        // Every acquired handle is attempted even if another closer fails. Preserve the boot error.
+        try {
+            featureConnection?.close();
+        }
+        catch { /* Keep the boot failure. */ }
+        await Promise.allSettled(opened.map((log) => log.close?.({})));
+        throw error;
+    }
+    const agentExecutor = createAgentExecutor({ lifecycle }, {
+        ...options.agentExecutor,
+        journal,
+        classifyFailure: classifyRunFailureForRetry,
+    });
+    const registry = createToolRegistry({});
+    // Created eagerly against the still-empty registry, and that is correct: `ToolExecutor` resolves
+    // a registration at execute time, not at construction, so features composed later can contribute
+    // tools this executor will find. It is what lets a feature's routes take the executor as a
+    // dependency while its own tools register in the same pass.
+    const toolExecutor = createToolExecutor({ registry });
+    let closed = null;
+    return {
+        eventLog,
+        journalEventLog,
+        lifecycle,
+        agentExecutor,
+        registry,
+        toolExecutor,
+        sqlite,
+        close() {
+            closed ??= (async () => {
+                try {
+                    sqlite?.connection.close();
+                }
+                finally {
+                    await Promise.all([eventLog.close?.({}), journalEventLog.close?.({})]);
+                }
+            })();
+            return closed;
+        },
+    };
+}
+//# sourceMappingURL=kernel-base.js.map

package/dist/lifecycle/boot-lifecycle.d.ts

@@ -0,0 +1,61 @@
+/** Two-stage boot orchestration. Modules clean up their own partially failed stage. */
+export type ModuleLifecycleStatus = {
+    status: 'ready';
+} | {
+    status: 'disabled';
+    reasonCode: string;
+    remediationHint: string;
+} | {
+    status: 'failed';
+    reasonCode: string;
+    remediationHint: string;
+};
+export type BootCriticality = 'critical' | 'optional';
+export interface BootModule {
+    name: string;
+    owner: string;
+    criticality: BootCriticality;
+    /** Acquire reversible resources; do not start external work yet. */
+    prepare(): Promise<void>;
+    start(): Promise<void>;
+    /** Idempotent; never called on the module whose current stage failed. */
+    stop(): Promise<void>;
+}
+export interface BootModuleResult {
+    name: string;
+    owner: string;
+    criticality: BootCriticality;
+    lifecycle: ModuleLifecycleStatus;
+}
+export interface BootResult {
+    ok: boolean;
+    modules: BootModuleResult[];
+}
+export interface ReadinessStore {
+    set(required: {
+        snapshot: BootResult;
+    }): void;
+    get(): BootResult;
+}
+export interface LifecycleReporter {
+    report(required: {
+        result: BootResult;
+    }): void;
+}
+/**
+ * Preserve source rollback semantics: prepare failure unwinds completed preparations;
+ * start failure unwinds completed starts only. Failing modules own their partial cleanup.
+ * Prepared modules not yet started on a start-stage abort remain host-owned.
+
+ * Contract rationale (including readiness ownership):
+ * Ports: `BootModule`, `ReadinessStore`, optional `LifecycleReporter`. `runBootLifecycle({ modules }, { readiness, reporter })` runs all preparations before starts. Optional failures do not set `ok=false`; critical failures stop the stage and unwind completed modules in reverse order. The failing module self-cleans. The existing start-stage rollback stops only modules that completed start, leaving other prepared resources host-owned; this extraction deliberately preserves that source behavior. A ready record for an unwound module retains the original source status.
+ *
+ * `createReadinessStore({}, { initial })` owns defensive snapshot copies per instance. No module-global state or synthetic daemon name. Keep daemon health latching in the host and compose it with this store. Duplicate module names now reject before acquisition; reporter failure is best effort. Lifecycle calls can be concurrent only if callers provide separate modules/stores or coordinate their own boot.
+ */
+export declare function runBootLifecycle(required: {
+    modules: readonly BootModule[];
+}, optional?: {
+    readiness?: ReadinessStore;
+    reporter?: LifecycleReporter;
+}): Promise<BootResult>;
+//# sourceMappingURL=boot-lifecycle.d.ts.map

package/dist/lifecycle/boot-lifecycle.js

@@ -0,0 +1,74 @@
+async function stopInReverse(modules) {
+    for (const module of [...modules].reverse()) {
+        try {
+            await module.stop();
+        }
+        catch { /* Preserve the original failure and continue cleanup. */ }
+    }
+}
+/**
+ * Preserve source rollback semantics: prepare failure unwinds completed preparations;
+ * start failure unwinds completed starts only. Failing modules own their partial cleanup.
+ * Prepared modules not yet started on a start-stage abort remain host-owned.
+
+ * Contract rationale (including readiness ownership):
+ * Ports: `BootModule`, `ReadinessStore`, optional `LifecycleReporter`. `runBootLifecycle({ modules }, { readiness, reporter })` runs all preparations before starts. Optional failures do not set `ok=false`; critical failures stop the stage and unwind completed modules in reverse order. The failing module self-cleans. The existing start-stage rollback stops only modules that completed start, leaving other prepared resources host-owned; this extraction deliberately preserves that source behavior. A ready record for an unwound module retains the original source status.
+ *
+ * `createReadinessStore({}, { initial })` owns defensive snapshot copies per instance. No module-global state or synthetic daemon name. Keep daemon health latching in the host and compose it with this store. Duplicate module names now reject before acquisition; reporter failure is best effort. Lifecycle calls can be concurrent only if callers provide separate modules/stores or coordinate their own boot.
+ */
+export async function runBootLifecycle(required, optional = {}) {
+    const modules = [...required.modules];
+    if (new Set(modules.map(module => module.name)).size !== modules.length) {
+        throw new Error('boot module names must be unique');
+    }
+    const results = new Map();
+    const prepared = [];
+    const ready = [];
+    let aborted = false;
+    for (const stage of ['prepare', 'start']) {
+        const completed = stage === 'prepare' ? prepared : ready;
+        for (const module of stage === 'prepare' ? modules : prepared) {
+            try {
+                await module[stage]();
+                completed.push(module);
+                if (stage === 'start')
+                    results.set(module.name, {
+                        name: module.name, owner: module.owner, criticality: module.criticality,
+                        lifecycle: { status: 'ready' },
+                    });
+            }
+            catch (error) {
+                results.set(module.name, {
+                    name: module.name, owner: module.owner, criticality: module.criticality,
+                    lifecycle: {
+                        status: 'failed', reasonCode: error instanceof Error ? error.message : String(error),
+                        remediationHint: 'check the boot log for the underlying error and retry after fixing it',
+                    },
+                });
+                if (module.criticality === 'critical') {
+                    await stopInReverse(completed);
+                    aborted = true;
+                    break;
+                }
+            }
+        }
+        if (aborted)
+            break;
+    }
+    const ordered = modules.flatMap(module => {
+        const result = results.get(module.name);
+        return result === undefined ? [] : [result];
+    });
+    const result = {
+        ok: ordered.every(module => module.criticality !== 'critical' || module.lifecycle.status === 'ready'),
+        modules: ordered,
+    };
+    optional.readiness?.set({ snapshot: result });
+    // A reporter must never turn a completed boot into an apparent failure.
+    try {
+        optional.reporter?.report({ result });
+    }
+    catch { /* Best-effort reporting. */ }
+    return result;
+}
+//# sourceMappingURL=boot-lifecycle.js.map

package/dist/lifecycle/index.d.ts

@@ -0,0 +1,3 @@
+export * from './boot-lifecycle.js';
+export * from './readiness-state.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lifecycle/index.js

@@ -0,0 +1,3 @@
+export * from './boot-lifecycle.js';
+export * from './readiness-state.js';
+//# sourceMappingURL=index.js.map

package/dist/lifecycle/readiness-state.d.ts

@@ -0,0 +1,6 @@
+import type { BootResult, ReadinessStore } from './boot-lifecycle.js';
+/** Instance-owned snapshots. Host-specific health records are supplied by the caller. */
+export declare function createReadinessStore(required: Record<string, never>, optional?: {
+    initial?: BootResult;
+}): ReadinessStore;
+//# sourceMappingURL=readiness-state.d.ts.map

package/dist/lifecycle/readiness-state.js

@@ -0,0 +1,15 @@
+function copy(snapshot) {
+    return { ok: snapshot.ok, modules: snapshot.modules.map(module => ({
+            ...module, lifecycle: { ...module.lifecycle },
+        })) };
+}
+/** Instance-owned snapshots. Host-specific health records are supplied by the caller. */
+export function createReadinessStore(required, optional = {}) {
+    void required;
+    let snapshot = copy(optional.initial ?? { ok: true, modules: [] });
+    return {
+        set({ snapshot: next }) { snapshot = copy(next); },
+        get() { return copy(snapshot); },
+    };
+}
+//# sourceMappingURL=readiness-state.js.map

package/dist/storage/backend-config.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @module backend-config
+ *
+ * Resolves which SQL backend a host daemon should use from environment
+ * variables. v1 ships local SQLite via an injected `better-sqlite3` opener (the event-log adapter
+ * now belongs to the daemon's storage subpath);
+ * a `postgres` selection is recorded so a future adapter can read it, but
+ * `resolveSqliteBackendConfig` never opens a connection itself — it only
+ * pins the parameter surface (host/port/database/user/sslMode) so a
+ * follow-up package can land the adapter without re-litigating the env-var
+ * contract.
+ */
+export type SqliteBackendKind = 'sqlite' | 'postgres';
+export interface SqliteBackendConfig {
+    kind: SqliteBackendKind;
+    /** Resolution metadata a future Postgres adapter will read. */
+    postgres?: {
+        host: string;
+        port: number;
+        database: string;
+        user: string;
+        /**
+         * Password / connection string are looked up at runtime from the
+         * caller's own secret manager; this layer never reads them through env.
+         */
+        sslMode?: 'disable' | 'require' | 'verify-full';
+    };
+}
+export declare class SqliteBackendConfigError extends Error {
+    constructor({ message }: {
+        message: string;
+    });
+}
+/**
+ * Reads `JINI_SQLITE_BACKEND` (`'sqlite'` default, or `'postgres'`) and, for
+ * `postgres`, `JINI_PG_HOST`/`JINI_PG_PORT`/`JINI_PG_DATABASE`/`JINI_PG_USER`/
+ * `JINI_PG_SSL_MODE` from the given env map (defaults to `process.env`).
+ *
+ * @param required - No required configuration values; pass an empty argument object.
+ * @param optional.env - Environment map to read from. Defaults to `process.env`.
+ * @returns The resolved backend config.
+ * @throws {SqliteBackendConfigError} When `kind` is unrecognized, or `postgres`
+ *   is selected without the required host/database/user.
+ */
+export declare function resolveSqliteBackendConfig(required: Record<string, never>, optional?: {
+    env?: Record<string, string | undefined>;
+}): SqliteBackendConfig;
+//# sourceMappingURL=backend-config.d.ts.map

package/dist/storage/backend-config.js

@@ -0,0 +1,61 @@
+/**
+ * @module backend-config
+ *
+ * Resolves which SQL backend a host daemon should use from environment
+ * variables. v1 ships local SQLite via an injected `better-sqlite3` opener (the event-log adapter
+ * now belongs to the daemon's storage subpath);
+ * a `postgres` selection is recorded so a future adapter can read it, but
+ * `resolveSqliteBackendConfig` never opens a connection itself — it only
+ * pins the parameter surface (host/port/database/user/sslMode) so a
+ * follow-up package can land the adapter without re-litigating the env-var
+ * contract.
+ */
+export class SqliteBackendConfigError extends Error {
+    constructor({ message }) {
+        super(message);
+        this.name = 'SqliteBackendConfigError';
+    }
+}
+/**
+ * Reads `JINI_SQLITE_BACKEND` (`'sqlite'` default, or `'postgres'`) and, for
+ * `postgres`, `JINI_PG_HOST`/`JINI_PG_PORT`/`JINI_PG_DATABASE`/`JINI_PG_USER`/
+ * `JINI_PG_SSL_MODE` from the given env map (defaults to `process.env`).
+ *
+ * @param required - No required configuration values; pass an empty argument object.
+ * @param optional.env - Environment map to read from. Defaults to `process.env`.
+ * @returns The resolved backend config.
+ * @throws {SqliteBackendConfigError} When `kind` is unrecognized, or `postgres`
+ *   is selected without the required host/database/user.
+ */
+export function resolveSqliteBackendConfig(required, optional = {}) {
+    void required;
+    const e = optional.env ?? process.env;
+    const kind = (e.JINI_SQLITE_BACKEND ?? 'sqlite').trim().toLowerCase();
+    if (kind === 'postgres') {
+        const host = e.JINI_PG_HOST ?? '';
+        const portStr = e.JINI_PG_PORT ?? '5432';
+        const database = e.JINI_PG_DATABASE ?? '';
+        const user = e.JINI_PG_USER ?? '';
+        const sslMode = e.JINI_PG_SSL_MODE === 'disable' || e.JINI_PG_SSL_MODE === 'verify-full' ? e.JINI_PG_SSL_MODE : 'require';
+        if (!host || !database || !user) {
+            throw new SqliteBackendConfigError({ message: 'JINI_SQLITE_BACKEND=postgres requires JINI_PG_HOST, JINI_PG_DATABASE, JINI_PG_USER. ' +
+                    'JINI_PG_PORT defaults to 5432; JINI_PG_SSL_MODE defaults to "require".',
+            });
+        }
+        return {
+            kind: 'postgres',
+            postgres: {
+                host,
+                port: Number.parseInt(portStr, 10) || 5432,
+                database,
+                user,
+                sslMode,
+            },
+        };
+    }
+    if (kind !== 'sqlite' && kind !== '') {
+        throw new SqliteBackendConfigError({ message: `unknown JINI_SQLITE_BACKEND value '${kind}'. Accepted: 'sqlite' (default), 'postgres'.` });
+    }
+    return { kind: 'sqlite' };
+}
+//# sourceMappingURL=backend-config.js.map

package/dist/storage/index.d.ts

@@ -0,0 +1,3 @@
+/** Host backend selection only; never opens a database or imports a driver. */
+export * from './backend-config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.js

@@ -0,0 +1,3 @@
+/** Host backend selection only; never opens a database or imports a driver. */
+export * from './backend-config.js';
+//# sourceMappingURL=index.js.map

package/dist/storage/legacy/sqlite.d.ts

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import { type SqliteDb, type SqliteSyncOpener } from '@jini-ai/db/sqlite';
+/**
+ * Explicit idempotent bootstrap of unchanged legacy tables; no versioned migration ledger.
+ * @param db Borrowed host handle; this operation neither opens nor closes it.
+ * @complexity O(1) schema statements.
+ */
+export declare function migrate({ db }: {
+    db: SqliteDb;
+}): void;
+/**
+ * Opens/caches <dataDir>/app.sqlite using the injected opener, WAL and foreign keys.
+ * A new path closes the previous singleton; setup failure closes only the newly acquired handle.
+ * @throws The original host acquisition/schema failure, or a missing opener.
+ * @complexity O(1) acquisition/bootstrap calls, independent of stored row count.
+ */
+export declare function openDatabase({ projectRoot, open }: {
+    projectRoot: string;
+    open: SqliteSyncOpener;
+}, options?: {
+    dataDir?: string;
+    filesystem?: Pick<typeof fs, 'mkdirSync'>;
+}): SqliteDb;
+/** Close the active owned singleton once; clearing state first permits a clean retry after failure. */
+export declare function closeDatabase(): void;
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/storage/legacy/sqlite.js

@@ -0,0 +1,63 @@
+/** Local app.sqlite singleton policy; the host explicitly supplies its SQLite driver. */
+import path from 'node:path';
+import fs from 'node:fs';
+import { openSqliteConnection } from '@jini-ai/db/sqlite';
+import { LEGACY_CHAT_DDL } from '@jini-ai/chat/store/legacy/sqlite';
+import { LEGACY_AGENT_SESSIONS_DDL } from '@jini-ai/daemon/store/agent-sessions/sqlite';
+import { LEGACY_PROJECTS_DDL } from '../../store/projects/sqlite.js';
+let dbInstance = null;
+let dbFile = null;
+/**
+ * Explicit idempotent bootstrap of unchanged legacy tables; no versioned migration ledger.
+ * @param db Borrowed host handle; this operation neither opens nor closes it.
+ * @complexity O(1) schema statements.
+ */
+// Only generic engine tables belong in this bootstrap; consumer feature tables and migrations
+// stay in host adapters. Every legacy column is declared in the base DDL, so this is not an
+// ALTER TABLE migration path for a consumer's pre-existing product schema.
+// Catalog tables are created only by hosts that actually seed and query them. A parallel execution
+// table would also weaken the existing ToolExecutionAuditRecord (principal, run and phase data);
+// durable audit storage should preserve that record rather than introduce a second audit noun.
+export function migrate({ db }) {
+    db.exec(LEGACY_PROJECTS_DDL + LEGACY_CHAT_DDL + LEGACY_AGENT_SESSIONS_DDL);
+}
+/**
+ * Opens/caches <dataDir>/app.sqlite using the injected opener, WAL and foreign keys.
+ * A new path closes the previous singleton; setup failure closes only the newly acquired handle.
+ * @throws The original host acquisition/schema failure, or a missing opener.
+ * @complexity O(1) acquisition/bootstrap calls, independent of stored row count.
+ */
+export function openDatabase({ projectRoot, open }, options = {}) {
+    // Keep the historical refusal text for JavaScript callers that omit the required port.
+    if (!open)
+        throw new Error('openDatabase: inject options.open');
+    const dir = options.dataDir ? path.resolve(options.dataDir) : path.join(projectRoot, '.jini');
+    const file = path.join(dir, 'app.sqlite');
+    if (dbInstance && dbFile === file)
+        return dbInstance;
+    closeDatabase();
+    (options.filesystem ?? fs).mkdirSync(dir, { recursive: true });
+    let db;
+    try {
+        db = openSqliteConnection({ filePath: file, open({ filePath }, settings) { db = open(filePath, settings); return db; } }, { pragmas: ['journal_mode = WAL', 'foreign_keys = ON'] });
+        migrate({ db });
+        dbInstance = db;
+        dbFile = file;
+        return db;
+    }
+    catch (error) {
+        try {
+            db?.close();
+        }
+        catch { /* Keep the original bootstrap failure. */ }
+        throw error;
+    }
+}
+/** Close the active owned singleton once; clearing state first permits a clean retry after failure. */
+export function closeDatabase() {
+    const db = dbInstance;
+    dbInstance = null;
+    dbFile = null;
+    db?.close();
+}
+//# sourceMappingURL=sqlite.js.map

package/dist/store/projects/sqlite.d.ts

@@ -0,0 +1,161 @@
+/** @module db/projects
+ * CRUD, run-status queries, and awaiting-input detection for the `projects` SQLite table — a
+ * generic workspace/container row-store, not an OD-specific concept. Also queries `messages` and
+ * `conversations` for run-status and input-gate state. Imports only the core/ kernel (SqliteDb,
+ * DbRow); reaches no sibling concern.
+ *
+ * NOTE (neutral port): drops three OD-product columns with no generic engine equivalent —
+ * `skill_id` (OD's agent-skill marketplace selection), `design_system_id` (OD's Design System
+ * feature), and `applied_plugin_snapshot_id` (OD's plugin host). The already-ported
+ * `schema/migrate.ts` projects table was pre-trimmed to match; see that file and `source-map.md`'s
+ * Design Decisions for the same drop list. The kernel-noun exclusion in `extraction-plan.md` §2.1
+ * ("projects... conversations" are not kernel nouns) does not block this module for the same reason
+ * it didn't block `conversations`: `concern-owned storage` is a generic *optional* storage adapter any
+ * consumer may use, not the kernel itself (`@jini-ai/core`/`@jini-ai/daemon` know nothing about this
+ * table) — so "project" here is a de-branded generic workspace/container concept, not OD's model.
+ */
+import type { SqliteDb } from '@jini-ai/db/sqlite';
+import type { DbRow } from '@jini-ai/db/core';
+/**
+ * Returns all projects ordered by most-recently updated first.
+ * @param db - Open SQLite connection.
+ */
+export declare function listProjects({ db }: {
+    db: SqliteDb;
+}): {
+    id: any;
+    name: any;
+    pendingPrompt: any;
+    metadata: any;
+    customInstructions: any;
+    createdAt: number;
+    updatedAt: number;
+}[];
+/**
+ * Returns the most recent run status for each project, keyed by projectId.
+ * Scans messages with a run_status column and collapses to one entry per project,
+ * so callers can render project-level status badges without iterating conversations.
+ * @param db - Open SQLite connection.
+ */
+export declare function listLatestProjectRunStatuses({ db }: {
+    db: SqliteDb;
+}): Map<string, DbRow>;
+/**
+ * Returns the most recent run status for each conversation, keyed by conversationId.
+ * Used to display per-conversation activity state in a project sidebar.
+ * @param db - Open SQLite connection.
+ */
+export declare function listLatestConversationRunStatuses({ db }: {
+    db: SqliteDb;
+}): Map<string, DbRow>;
+/**
+ * Returns the earliest run status for each conversation, keyed by conversationId.
+ * Useful for determining when a conversation's first agent turn began.
+ * @param db - Open SQLite connection.
+ */
+export declare function listFirstConversationRunStatuses({ db }: {
+    db: SqliteDb;
+}): Map<string, DbRow>;
+/**
+ * Returns the most recent run status for each individual run, keyed by runId.
+ * Powers per-run status indicators in a conversation thread.
+ * @param db - Open SQLite connection.
+ */
+export declare function listLatestRunStatuses({ db }: {
+    db: SqliteDb;
+}): Map<string, DbRow>;
+/**
+ * Returns the set of project IDs whose latest form-bearing assistant message contains a
+ * `<question-form>` or `<ask-question>` artifact and has not yet received a user reply.
+ * Form filtering deliberately precedes ranking: a newer plain assistant turn does not consume
+ * an outstanding question. Keep timestamp/position ordering for replies sharing a timestamp.
+ * This is the data source for an "awaiting input" badge on a project list.
+ * @param db - Open SQLite connection.
+ */
+export declare function listProjectsAwaitingInput({ db }: {
+    db: SqliteDb;
+}): Set<any>;
+/**
+ * Returns the set of conversation IDs whose latest form-bearing assistant message contains a
+ * `<question-form>` or `<ask-question>` artifact and has not yet received a user reply.
+ * As in the project query, a newer plain assistant turn leaves an unanswered form outstanding.
+ * @param db - Open SQLite connection.
+ */
+export declare function listConversationsAwaitingInput({ db }: {
+    db: SqliteDb;
+}): Set<any>;
+/**
+ * Fetches a single project by id, or returns null if it does not exist.
+ * @param db - Open SQLite connection.
+ * @param id - Project id.
+ */
+export declare function getProject({ db, id }: {
+    db: SqliteDb;
+    id: string;
+}): {
+    id: any;
+    name: any;
+    pendingPrompt: any;
+    metadata: any;
+    customInstructions: any;
+    createdAt: number;
+    updatedAt: number;
+} | null;
+/**
+ * Inserts a new project row and returns the freshly read, normalized record.
+ * Metadata is serialized to JSON; all nullable fields default to null on omission.
+ * @param db - Open SQLite connection.
+ * @param project - Project fields to insert.
+ */
+export declare function insertProject({ db, project: p }: {
+    db: SqliteDb;
+    project: DbRow;
+}): {
+    id: any;
+    name: any;
+    pendingPrompt: any;
+    metadata: any;
+    customInstructions: any;
+    createdAt: number;
+    updatedAt: number;
+} | null;
+/**
+ * Applies a partial patch to an existing project, preserving all unpatched fields.
+ * Returns null when the project does not exist; otherwise returns the updated record.
+ * updatedAt defaults to Date.now() when the patch omits it.
+ * @param db - Open SQLite connection.
+ * @param id - Project id to update.
+ * @param patch - Fields to overwrite.
+ * @param optional.clock - Host clock port; defaults to Date.now() as before. An explicit updatedAt
+ * wins without reading the clock, so replayed/imported timestamps remain stable.
+ */
+export declare function updateProject({ db, id, patch }: {
+    db: SqliteDb;
+    id: string;
+    patch: DbRow;
+}, optional?: {
+    clock?: {
+        now(): number;
+    };
+}): {
+    id: any;
+    name: any;
+    pendingPrompt: any;
+    metadata: any;
+    customInstructions: any;
+    createdAt: number;
+    updatedAt: number;
+} | null;
+/**
+ * Permanently removes a project row. Cascading deletes for related rows are
+ * handled at the SQLite schema level, not here.
+ * @param db - Open SQLite connection.
+ * @param id - Project id to delete.
+ */
+export declare function deleteProject({ db, id }: {
+    db: SqliteDb;
+    id: string;
+}): void;
+/** Unchanged local host-project schema; no automatic migration at import. */
+export declare const LEGACY_PROJECTS_DDL = "    CREATE TABLE IF NOT EXISTS projects (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL,\n      pending_prompt TEXT,\n      metadata_json TEXT,\n      custom_instructions TEXT,\n      created_at INTEGER NOT NULL,\n      updated_at INTEGER NOT NULL\n    );\n\n";
+//# sourceMappingURL=sqlite.d.ts.map