@jini-ai/sqlite 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a
+      fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may act only on Your
+      own behalf and on Your sole responsibility, not on behalf of any
+      other Contributor, and only if You agree to indemnify, defend,
+      and hold each Contributor harmless for any liability incurred by,
+      or claims asserted against, such Contributor by reason of your
+      accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Open Design contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/backend-config.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @module backend-config
+ *
+ * Resolves which SQL backend a host daemon should use from environment
+ * variables. v1 ships local SQLite via `better-sqlite3` (see `./event-log.js`);
+ * 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: 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 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(env?: Record<string, string | undefined>): SqliteBackendConfig;
+//# sourceMappingURL=backend-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"backend-config.d.ts","sourceRoot":"","sources":["../src/backend-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEtD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,iBAAiB,CAAC;IACxB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb;;;WAGG;QACH,OAAO,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,aAAa,CAAC;KACjD,CAAC;CACH;AAED,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,mBAAmB,CA+BxG"}

package/dist/backend-config.js

@@ -0,0 +1,57 @@
+/**
+ * @module backend-config
+ *
+ * Resolves which SQL backend a host daemon should use from environment
+ * variables. v1 ships local SQLite via `better-sqlite3` (see `./event-log.js`);
+ * 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 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(env) {
+    const e = 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('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(`unknown JINI_SQLITE_BACKEND value '${kind}'. Accepted: 'sqlite' (default), 'postgres'.`);
+    }
+    return { kind: 'sqlite' };
+}
+//# sourceMappingURL=backend-config.js.map

package/dist/backend-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-config.js","sourceRoot":"","sources":["../src/backend-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAoBH,MAAM,OAAO,wBAAyB,SAAQ,KAAK;IACjD,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,0BAA0B,CAAC,GAAwC;IACjF,MAAM,CAAC,GAAG,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC;IAC7B,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,mBAAmB,IAAI,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACtE,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;QACxB,MAAM,IAAI,GAAG,CAAC,CAAC,YAAY,IAAI,EAAE,CAAC;QAClC,MAAM,OAAO,GAAG,CAAC,CAAC,YAAY,IAAI,MAAM,CAAC;QACzC,MAAM,QAAQ,GAAG,CAAC,CAAC,gBAAgB,IAAI,EAAE,CAAC;QAC1C,MAAM,IAAI,GAAG,CAAC,CAAC,YAAY,IAAI,EAAE,CAAC;QAClC,MAAM,OAAO,GACX,CAAC,CAAC,gBAAgB,KAAK,SAAS,IAAI,CAAC,CAAC,gBAAgB,KAAK,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC;QAC5G,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;YAChC,MAAM,IAAI,wBAAwB,CAChC,sFAAsF;gBACpF,wEAAwE,CAC3E,CAAC;QACJ,CAAC;QACD,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,QAAQ,EAAE;gBACR,IAAI;gBACJ,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,IAAI;gBAC1C,QAAQ;gBACR,IAAI;gBACJ,OAAO;aACR;SACF,CAAC;IACJ,CAAC;IACD,IAAI,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QACrC,MAAM,IAAI,wBAAwB,CAAC,sCAAsC,IAAI,8CAA8C,CAAC,CAAC;IAC/H,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAC5B,CAAC"}

package/dist/db/agent-sessions/agent-sessions.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @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 '../core/index.js';
+/**
+ * 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: SqliteDb, conversationId: string, 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: SqliteDb, 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: SqliteDb, conversationId: string, 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: SqliteDb, conversationId: string, excludeMessageId: string, 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: SqliteDb, conversationId: string, agentId: string, 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: SqliteDb, conversationId: string, agentId: string): void;
+//# sourceMappingURL=agent-sessions.d.ts.map

package/dist/db/agent-sessions/agent-sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-sessions.d.ts","sourceRoot":"","sources":["../../../src/db/agent-sessions/agent-sessions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAS,MAAM,kBAAkB,CAAC;AAExD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,QAAQ,EACZ,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAQf;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,QAAQ,EACZ,KAAK,EAAE;IACL,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,GACA,IAAI,CAsBN;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,QAAQ,EACZ,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,GACd;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B,GAAG,IAAI,CAgBP;AAyBD;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC/C,EAAE,EAAE,QAAQ,EACZ,cAAc,EAAE,MAAM,EACtB,gBAAgB,EAAE,MAAM,EACxB,kBAAkB,GAAE,MAAM,GAAG,IAAW,GACvC,MAAM,GAAG,IAAI,CAUf;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,EAAE,EAAE,QAAQ,EACZ,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,MAAM,GACvB,IAAI,CAKN;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,QAAQ,EACZ,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,GACd,IAAI,CAIN"}

package/dist/db/agent-sessions/agent-sessions.js

@@ -0,0 +1,121 @@
+/**
+ * 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);
+}
+//# sourceMappingURL=agent-sessions.js.map

package/dist/db/agent-sessions/agent-sessions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-sessions.js","sourceRoot":"","sources":["../../../src/db/agent-sessions/agent-sessions.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,6 @@
+/**
+ * @module db/agent-sessions/index
+ * Public barrel for the agent-sessions concern: re-exports the upstream CLI session cache API.
+ */
+export * from './agent-sessions.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/db/agent-sessions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/db/agent-sessions/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,qBAAqB,CAAC"}

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

@@ -0,0 +1,6 @@
+/**
+ * @module db/agent-sessions/index
+ * Public barrel for the agent-sessions concern: re-exports the upstream CLI session cache API.
+ */
+export * from './agent-sessions.js';
+//# sourceMappingURL=index.js.map

package/dist/db/agent-sessions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/db/agent-sessions/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,qBAAqB,CAAC"}

package/dist/db/capabilities/capabilities.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @module db/capabilities/capabilities
+ *
+ * The SQLite-backed half of `ai-control-plane.md`'s proposed `CapabilityCatalog` (§9): durable
+ * storage for a host's registered capability definitions (name/description/schema/risk) plus an
+ * append-only execution audit trail. New, not ported — scoped to what a real caller
+ * (`examples/reference-web`'s chat capabilities, first) needs today rather than the full
+ * FTS5/tag/scope/provider schema that document sketches; add those when a caller actually needs
+ * search-at-scale instead of a small `SELECT *`. Imports only the `core/` kernel.
+ */
+import type { SqliteDb } from '../core/index.js';
+export interface CapabilityDefinitionRecord {
+    readonly id: string;
+    readonly description: string;
+    readonly inputSchema: unknown;
+    readonly risk: string;
+    readonly updatedAt: number;
+}
+export interface CapabilityExecutionRecord {
+    readonly executionId: string;
+    readonly capabilityId: string;
+    readonly input: unknown;
+    readonly status: string;
+    readonly output?: unknown;
+    readonly error?: string;
+    readonly requestedAt: number;
+    readonly completedAt?: number;
+}
+/** Inserts a capability definition, or overwrites the existing row with the same id (a host re-declaring its manifest at every startup, not a versioned upgrade). */
+export declare function upsertCapabilityDefinition(db: SqliteDb, def: Omit<CapabilityDefinitionRecord, 'updatedAt'> & {
+    updatedAt?: number;
+}): void;
+/** Lists every registered capability definition, ordered by id. */
+export declare function listCapabilityDefinitions(db: SqliteDb): CapabilityDefinitionRecord[];
+/** Fetches one capability definition by id, or `null` if it isn't registered. */
+export declare function getCapabilityDefinition(db: SqliteDb, id: string): CapabilityDefinitionRecord | null;
+/** Appends one execution audit row. Insert-only — this is a durable trail, never updated in place. */
+export declare function recordCapabilityExecution(db: SqliteDb, record: CapabilityExecutionRecord): void;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/db/capabilities/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../src/db/capabilities/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAS,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAGxD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAYD,qKAAqK;AACrK,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,CAAC,0BAA0B,EAAE,WAAW,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAiB1I;AAED,mEAAmE;AACnE,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,QAAQ,GAAG,0BAA0B,EAAE,CAOpF;AAED,iFAAiF;AACjF,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,GAAG,0BAA0B,GAAG,IAAI,CAQnG;AAED,sGAAsG;AACtG,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,yBAAyB,GAAG,IAAI,CAe/F"}

package/dist/db/capabilities/capabilities.js

@@ -0,0 +1,54 @@
+import { row, rows } from '../core/index.js';
+function normalizeDefinition(r) {
+    return {
+        id: r.id,
+        description: r.description,
+        inputSchema: JSON.parse(r.inputSchemaJson),
+        risk: r.risk,
+        updatedAt: Number(r.updatedAt),
+    };
+}
+/** Inserts a capability definition, or overwrites the existing row with the same id (a host re-declaring its manifest at every startup, not a versioned upgrade). */
+export function upsertCapabilityDefinition(db, def) {
+    const updatedAt = def.updatedAt ?? Date.now();
+    db.prepare(`INSERT INTO capability_definitions (id, description, input_schema_json, risk, updated_at)
+     VALUES (@id, @description, @inputSchemaJson, @risk, @updatedAt)
+     ON CONFLICT(id) DO UPDATE SET
+       description = excluded.description,
+       input_schema_json = excluded.input_schema_json,
+       risk = excluded.risk,
+       updated_at = excluded.updated_at`).run({
+        id: def.id,
+        description: def.description,
+        inputSchemaJson: JSON.stringify(def.inputSchema),
+        risk: def.risk,
+        updatedAt,
+    });
+}
+/** Lists every registered capability definition, ordered by id. */
+export function listCapabilityDefinitions(db) {
+    return rows(db.prepare(`SELECT id, description, input_schema_json AS inputSchemaJson, risk, updated_at AS updatedAt
+         FROM capability_definitions ORDER BY id`).all()).map(normalizeDefinition);
+}
+/** Fetches one capability definition by id, or `null` if it isn't registered. */
+export function getCapabilityDefinition(db, id) {
+    const r = row(db.prepare(`SELECT id, description, input_schema_json AS inputSchemaJson, risk, updated_at AS updatedAt
+         FROM capability_definitions WHERE id = ?`).get(id));
+    return r ? normalizeDefinition(r) : null;
+}
+/** Appends one execution audit row. Insert-only — this is a durable trail, never updated in place. */
+export function recordCapabilityExecution(db, record) {
+    db.prepare(`INSERT INTO capability_executions
+       (execution_id, capability_id, input_json, status, output_json, error, requested_at, completed_at)
+     VALUES (@executionId, @capabilityId, @inputJson, @status, @outputJson, @error, @requestedAt, @completedAt)`).run({
+        executionId: record.executionId,
+        capabilityId: record.capabilityId,
+        inputJson: JSON.stringify(record.input ?? null),
+        status: record.status,
+        outputJson: record.output === undefined ? null : JSON.stringify(record.output),
+        error: record.error ?? null,
+        requestedAt: record.requestedAt,
+        completedAt: record.completedAt ?? null,
+    });
+}
+//# sourceMappingURL=capabilities.js.map