@arnilo/prism 0.0.96 → 0.1.0

package/dist/testing/agent-event-source-conformance.js

@@ -0,0 +1,54 @@
+// ponytail: runner-free durable-event contract probe for database adapters.
+/** Assert durable append/page/replay ownership and cursor behavior without a database dependency. */
+export async function assertAgentEventSourceConforms(factory) {
+    const source = await factory();
+    const ownership = { tenantId: "tenant-a", accountId: "account-a", userId: "user-a" };
+    const input = { ownership, sessionId: "session-a", runId: "run-a" };
+    const first = event("event-a", "agent_started", input);
+    const second = event("event-b", "turn_started", input, "2026-01-01T00:00:01.000Z");
+    const storedFirst = await source.append(first);
+    const storedSecond = await source.append(second);
+    equal(storedFirst.sequence, 1, "first durable event must receive sequence 1");
+    equal(storedSecond.sequence, 2, "durable sequence must increase per run");
+    equal((await source.append(first)).sequence, 1, "identical duplicate append must be idempotent");
+    await rejects(() => source.append({ ...first, timestamp: "2026-01-01T00:00:02.000Z" }), "changed duplicate append must fail");
+    const page = await source.page({ ...input, limit: 1 });
+    equal(page.items.length, 1, "page limit must be honored");
+    equal(page.items[0].record.id, first.id, "page order must follow sequence");
+    if (!page.nextCursor)
+        throw new Error("truncated page must include a cursor");
+    const secondPage = await source.page({ ...input, after: page.nextCursor, limit: 1 });
+    equal(secondPage.items[0]?.record.id, second.id, "cursor must be exclusive");
+    const iterator = source.subscribe({ ...input, after: secondPage.items[0].cursor })[Symbol.asyncIterator]();
+    const pending = iterator.next();
+    const third = await source.append(event("event-c", "turn_started", input, "2026-01-01T00:00:02.000Z"));
+    equal((await pending).value?.record.id, third.id, "replay/live handoff dropped an event");
+    await iterator.return?.();
+    const terminal = await source.append(event("event-d", "agent_finished", input, "2026-01-01T00:00:03.000Z"));
+    const final = await source.page({ ...input, after: secondPage.items[0].cursor, limit: 10 });
+    equal(final.items.at(-1)?.record.id, terminal.id, "terminal page must include its terminal event");
+    equal(final.terminal, true, "terminal event must close only after prior events are delivered");
+    await rejects(() => source.page({ ...input, ownership: { ...ownership, tenantId: "tenant-b" }, after: page.nextCursor }), "foreign cursor must fail closed");
+    await rejects(() => source.append({ ...event("event-unredacted", "turn_started", input), redacted: false }), "unredacted append must fail");
+    await rejects(() => source.page({ ...input, limit: 0 }), "invalid page limit must fail");
+}
+function event(id, type, input, timestamp = "2026-01-01T00:00:00.000Z") {
+    const event = type === "turn_started"
+        ? { type, sessionId: input.sessionId, runId: input.runId, turn: 1 }
+        : { type, sessionId: input.sessionId, runId: input.runId };
+    return { id, ...input.ownership, sessionId: input.sessionId, runId: input.runId, type, timestamp, event, redacted: true };
+}
+function equal(actual, expected, message) {
+    if (actual !== expected)
+        throw new Error(`${message}; expected ${String(expected)}, received ${String(actual)}`);
+}
+async function rejects(action, message) {
+    try {
+        await action();
+    }
+    catch {
+        return;
+    }
+    throw new Error(message);
+}
+//# sourceMappingURL=agent-event-source-conformance.js.map

package/dist/testing/compaction-conformance.js

@@ -16,7 +16,11 @@ import { createSessionEntry } from "../session-stores.js";
 export async function assertCompactionStrategyConforms(strategy, options = {}) {
     const secrets = options.secrets ?? [];
     const entries = [
-        createSessionEntry({ sessionId: "s", kind: "message", message: { role: "user", content: [{ type: "text", text: `old ${secrets[0] ?? "history"}` }] } }),
+        createSessionEntry({
+            sessionId: "s",
+            kind: "message",
+            message: { role: "user", content: [{ type: "text", text: `old ${secrets[0] ?? "history"}` }] },
+        }),
         createSessionEntry({ sessionId: "s", kind: "message", message: { role: "assistant", content: [{ type: "text", text: "recent" }] } }),
     ];
     const context = {

package/dist/testing/extension-conformance.js

@@ -23,7 +23,12 @@ export async function assertExtensionConforms(extension, options = {}) {
     // provider/tool/skill capabilities until host code resolves and calls them).
     if (options.expectThrow) {
         // A second extension that throws must rethrow under errorPolicy: "throw".
-        const failing = { name: "conformance-failing", setup: () => { throw new Error("conformance setup failed"); } };
+        const failing = {
+            name: "conformance-failing",
+            setup: () => {
+                throw new Error("conformance setup failed");
+            },
+        };
         let threw = false;
         try {
             await kernel.load([failing]);
@@ -37,9 +42,16 @@ export async function assertExtensionConforms(extension, options = {}) {
     }
     if (options.secrets && options.secrets.length > 0) {
         const secret = options.secrets[0];
-        const failing = { name: "conformance-failing", setup: () => { throw new Error(`boom ${secret}`); } };
+        const failing = {
+            name: "conformance-failing",
+            setup: () => {
+                throw new Error(`boom ${secret}`);
+            },
+        };
         const errors = [];
-        kernel.events.on("extension_error", (event) => { errors.push(event.error ?? {}); });
+        kernel.events.on("extension_error", (event) => {
+            errors.push(event.error ?? {});
+        });
         await kernel.load([failing]);
         if (errors.length === 0)
             throw new Error("Failing extension setup did not emit an extension_error event");

package/dist/testing/feedback.d.ts

@@ -1,6 +1,4 @@
 import type { RunFeedbackStore } from "../contracts.js";
-export interface RunFeedbackConformanceFactory {
-    (): RunFeedbackStore | Promise<RunFeedbackStore>;
-}
+export type RunFeedbackConformanceFactory = () => RunFeedbackStore | Promise<RunFeedbackStore>;
 /** Shared minimum behavior for memory and production feedback stores. */
 export declare function runFeedbackConformance(factory: RunFeedbackConformanceFactory): Promise<void>;

package/dist/testing/feedback.js

@@ -31,7 +31,7 @@ export async function runFeedbackConformance(factory) {
     if (await store.delete({ id: "feedback-1", tenantId: "feedback-tenant", userId: "other" })) {
         throw new Error("cross-owner feedback deletion succeeded");
     }
-    if (!await store.delete({ id: "feedback-1", ...owner }))
+    if (!(await store.delete({ id: "feedback-1", ...owner })))
         throw new Error("owned feedback deletion failed");
 }
 //# sourceMappingURL=feedback.js.map

package/dist/testing/persistence-schema.d.ts

@@ -1,7 +1,7 @@
 import type { PersistencePage, SessionEntry, SessionEntryQuery } from "../contracts.js";
 /** Current shared persistence schema version for production database adapters. */
-export declare const PERSISTENCE_SCHEMA_VERSION = 3;
-export type PersistenceTableName = "prism_tenants" | "prism_accounts" | "prism_users" | "prism_agent_definitions" | "prism_sessions" | "prism_branches" | "prism_session_entries" | "prism_session_append_idempotency" | "prism_runs" | "prism_agent_events" | "prism_tool_calls" | "prism_usage" | "prism_run_feedback" | "prism_retention_policies" | "prism_migrations";
+export declare const PERSISTENCE_SCHEMA_VERSION = 7;
+export type PersistenceTableName = "prism_tenants" | "prism_accounts" | "prism_users" | "prism_agent_definitions" | "prism_sessions" | "prism_branches" | "prism_session_entries" | "prism_session_append_idempotency" | "prism_runs" | "prism_agent_events" | "prism_agent_event_streams" | "prism_tool_calls" | "prism_usage" | "prism_run_feedback" | "prism_retention_policies" | "prism_legal_holds" | "prism_tenant_quotas" | "prism_migrations";
 export type PersistenceColumnType = "text" | "integer" | "number" | "boolean" | "json" | "timestamp";
 export interface PersistenceColumnDefinition {
     readonly name: string;

package/dist/testing/persistence-schema.js

@@ -4,7 +4,7 @@ import { createHash } from "node:crypto";
 // this module defines the shared table/index/pagination/migration expectations
 // adapter authors implement and test against before shipping dialect-specific DDL.
 /** Current shared persistence schema version for production database adapters. */
-export const PERSISTENCE_SCHEMA_VERSION = 3;
+export const PERSISTENCE_SCHEMA_VERSION = 7;
 /** Guidance adapters must follow: values are bound parameters, never interpolated. */
 export const PARAMETERIZED_QUERY_GUIDANCE = "Bind every user-supplied value (session ids, idempotency keys, tenant ids, timestamps, JSON payloads) as a query parameter. Quote/validate schema and table identifiers only; never interpolate untrusted strings into SQL text.";
 const TENANT_COLUMNS = [
@@ -177,6 +177,17 @@ export function createPersistenceSchemaModel() {
                 ],
                 foreignKeys: [{ columns: ["session_id"], referencesTable: "prism_sessions", referencesColumns: ["id"] }],
             },
+            {
+                name: "prism_agent_event_streams",
+                primaryKey: ["session_id", "run_id"],
+                columns: [
+                    { name: "session_id", type: "text" },
+                    { name: "run_id", type: "text" },
+                    { name: "next_sequence", type: "integer" },
+                    { name: "updated_at", type: "timestamp" },
+                ],
+                foreignKeys: [{ columns: ["session_id"], referencesTable: "prism_sessions", referencesColumns: ["id"] }],
+            },
             {
                 name: "prism_tool_calls",
                 primaryKey: ["id"],
@@ -258,6 +269,33 @@ export function createPersistenceSchemaModel() {
                     { name: "metadata", type: "json", nullable: true },
                 ],
             },
+            {
+                name: "prism_legal_holds",
+                primaryKey: ["id"],
+                columns: [
+                    { name: "id", type: "text" },
+                    ...TENANT_COLUMNS,
+                    { name: "resource_kind", type: "text" },
+                    { name: "resource_id", type: "text" },
+                    { name: "reason", type: "text" },
+                    { name: "created_at", type: "timestamp" },
+                    { name: "created_by", type: "text", nullable: true },
+                    { name: "metadata", type: "json", nullable: true },
+                ],
+            },
+            {
+                name: "prism_tenant_quotas",
+                primaryKey: ["id"],
+                columns: [
+                    { name: "id", type: "text" },
+                    ...TENANT_COLUMNS,
+                    { name: "resource_kind", type: "text" },
+                    { name: "limit_count", type: "integer" },
+                    { name: "used_count", type: "integer" },
+                    { name: "updated_at", type: "timestamp" },
+                ],
+                uniqueKeys: [["tenant_id", "account_id", "user_id", "resource_kind"]],
+            },
             {
                 name: "prism_migrations",
                 primaryKey: ["id"],
@@ -274,31 +312,167 @@ export function createPersistenceSchemaModel() {
             },
         ],
         indexes: [
-            { name: "prism_sessions_tenant_created_idx", table: "prism_sessions", columns: ["tenant_id", "account_id", "user_id", "created_at"], purpose: "tenant-scoped session listing" },
+            {
+                name: "prism_sessions_tenant_created_idx",
+                table: "prism_sessions",
+                columns: ["tenant_id", "account_id", "user_id", "created_at"],
+                purpose: "tenant-scoped session listing",
+            },
             { name: "prism_sessions_expires_idx", table: "prism_sessions", columns: ["expires_at"], purpose: "retention expiry scans" },
             { name: "prism_branches_session_name_idx", table: "prism_branches", columns: ["session_id", "name"], purpose: "named branch lookup" },
             { name: "prism_branches_leaf_idx", table: "prism_branches", columns: ["leaf_entry_id"], purpose: "leaf-to-branch resolution" },
-            { name: "prism_session_entries_session_parent_idx", table: "prism_session_entries", columns: ["session_id", "parent_id"], purpose: "parent existence checks and child lookups" },
-            { name: "prism_session_entries_session_kind_ts_idx", table: "prism_session_entries", columns: ["session_id", "kind", "timestamp"], purpose: "kind-filtered entry listing" },
-            { name: "prism_session_entries_session_run_ts_idx", table: "prism_session_entries", columns: ["session_id", "run_id", "timestamp"], purpose: "run-scoped entry listing" },
-            { name: "prism_session_entries_session_ts_id_idx", table: "prism_session_entries", columns: ["session_id", "timestamp", "id"], purpose: "cursor pagination without full scans" },
-            { name: "prism_session_entries_session_id_idx", table: "prism_session_entries", columns: ["session_id", "id"], purpose: "append parent validation and recursive branch reads" },
-            { name: "prism_session_append_idempotency_unique", table: "prism_session_append_idempotency", columns: ["session_id", "expected_parent_id", "idempotency_key"], purpose: "append retry deduplication (primary key enforces uniqueness)" },
-            { name: "prism_runs_session_started_idx", table: "prism_runs", columns: ["session_id", "started_at", "id"], purpose: "run history pagination" },
-            { name: "prism_runs_branch_started_idx", table: "prism_runs", columns: ["branch_id", "started_at", "id"], purpose: "branch-scoped runs" },
-            { name: "prism_runs_tenant_idempotency_unique", table: "prism_runs", columns: ["tenant_id", "idempotency_key"], unique: true, purpose: "run-level idempotency deduplication per tenant" },
-            { name: "prism_agent_events_run_sequence_idx", table: "prism_agent_events", columns: ["run_id", "sequence"], purpose: "stable per-run event timeline pagination" },
-            { name: "prism_agent_events_session_ts_id_idx", table: "prism_agent_events", columns: ["session_id", "timestamp", "id"], purpose: "event stream pagination" },
-            { name: "prism_tool_calls_session_name_started_idx", table: "prism_tool_calls", columns: ["session_id", "name", "started_at"], purpose: "tool usage by name" },
-            { name: "prism_tool_calls_run_started_idx", table: "prism_tool_calls", columns: ["run_id", "started_at"], purpose: "run tool-call listing" },
-            { name: "prism_usage_run_recorded_idx", table: "prism_usage", columns: ["run_id", "recorded_at", "id"], purpose: "run usage pagination" },
-            { name: "prism_usage_session_recorded_idx", table: "prism_usage", columns: ["session_id", "recorded_at"], purpose: "usage aggregation" },
-            { name: "prism_usage_session_scope_recorded_idx", table: "prism_usage", columns: ["session_id", "scope", "recorded_at"], purpose: "scope-safe usage aggregation" },
-            { name: "prism_run_feedback_owner_created_idx", table: "prism_run_feedback", columns: ["tenant_id", "account_id", "user_id", "created_at", "id"], purpose: "ownership-scoped feedback pagination" },
-            { name: "prism_run_feedback_run_created_idx", table: "prism_run_feedback", columns: ["run_id", "created_at", "id"], purpose: "run feedback lookup" },
-            { name: "prism_run_feedback_trace_created_idx", table: "prism_run_feedback", columns: ["trace_id", "created_at", "id"], purpose: "trace feedback lookup" },
-            { name: "prism_agent_definitions_name_version_idx", table: "prism_agent_definitions", columns: ["name", "version"], purpose: "definition lookup" },
-            { name: "prism_migrations_name_version_idx", table: "prism_migrations", columns: ["name", "version"], purpose: "applied-migration lookup (table constraint enforces uniqueness)" },
+            {
+                name: "prism_session_entries_session_parent_idx",
+                table: "prism_session_entries",
+                columns: ["session_id", "parent_id"],
+                purpose: "parent existence checks and child lookups",
+            },
+            {
+                name: "prism_session_entries_session_kind_ts_idx",
+                table: "prism_session_entries",
+                columns: ["session_id", "kind", "timestamp"],
+                purpose: "kind-filtered entry listing",
+            },
+            {
+                name: "prism_session_entries_session_run_ts_idx",
+                table: "prism_session_entries",
+                columns: ["session_id", "run_id", "timestamp"],
+                purpose: "run-scoped entry listing",
+            },
+            {
+                name: "prism_session_entries_session_ts_id_idx",
+                table: "prism_session_entries",
+                columns: ["session_id", "timestamp", "id"],
+                purpose: "cursor pagination without full scans",
+            },
+            {
+                name: "prism_session_entries_session_id_idx",
+                table: "prism_session_entries",
+                columns: ["session_id", "id"],
+                purpose: "append parent validation and recursive branch reads",
+            },
+            {
+                name: "prism_session_append_idempotency_unique",
+                table: "prism_session_append_idempotency",
+                columns: ["session_id", "expected_parent_id", "idempotency_key"],
+                purpose: "append retry deduplication (primary key enforces uniqueness)",
+            },
+            {
+                name: "prism_runs_session_started_idx",
+                table: "prism_runs",
+                columns: ["session_id", "started_at", "id"],
+                purpose: "run history pagination",
+            },
+            {
+                name: "prism_runs_branch_started_idx",
+                table: "prism_runs",
+                columns: ["branch_id", "started_at", "id"],
+                purpose: "branch-scoped runs",
+            },
+            {
+                name: "prism_runs_tenant_idempotency_unique",
+                table: "prism_runs",
+                columns: ["tenant_id", "idempotency_key"],
+                unique: true,
+                purpose: "run-level idempotency deduplication per tenant",
+            },
+            {
+                name: "prism_agent_events_run_sequence_idx",
+                table: "prism_agent_events",
+                columns: ["run_id", "sequence"],
+                unique: true,
+                purpose: "stable per-run event timeline pagination",
+            },
+            {
+                name: "prism_agent_events_session_ts_id_idx",
+                table: "prism_agent_events",
+                columns: ["session_id", "timestamp", "id"],
+                purpose: "event stream pagination",
+            },
+            {
+                name: "prism_agent_events_owner_timestamp_sequence_idx",
+                table: "prism_agent_events",
+                columns: ["tenant_id", "account_id", "user_id", "timestamp", "sequence", "id"],
+                purpose: "owned durable event retention cleanup",
+            },
+            {
+                name: "prism_tool_calls_session_name_started_idx",
+                table: "prism_tool_calls",
+                columns: ["session_id", "name", "started_at"],
+                purpose: "tool usage by name",
+            },
+            {
+                name: "prism_tool_calls_run_started_idx",
+                table: "prism_tool_calls",
+                columns: ["run_id", "started_at"],
+                purpose: "run tool-call listing",
+            },
+            {
+                name: "prism_usage_run_recorded_idx",
+                table: "prism_usage",
+                columns: ["run_id", "recorded_at", "id"],
+                purpose: "run usage pagination",
+            },
+            {
+                name: "prism_usage_session_recorded_idx",
+                table: "prism_usage",
+                columns: ["session_id", "recorded_at"],
+                purpose: "usage aggregation",
+            },
+            {
+                name: "prism_usage_session_scope_recorded_idx",
+                table: "prism_usage",
+                columns: ["session_id", "scope", "recorded_at"],
+                purpose: "scope-safe usage aggregation",
+            },
+            {
+                name: "prism_run_feedback_owner_created_idx",
+                table: "prism_run_feedback",
+                columns: ["tenant_id", "account_id", "user_id", "created_at", "id"],
+                purpose: "ownership-scoped feedback pagination",
+            },
+            {
+                name: "prism_run_feedback_run_created_idx",
+                table: "prism_run_feedback",
+                columns: ["run_id", "created_at", "id"],
+                purpose: "run feedback lookup",
+            },
+            {
+                name: "prism_run_feedback_trace_created_idx",
+                table: "prism_run_feedback",
+                columns: ["trace_id", "created_at", "id"],
+                purpose: "trace feedback lookup",
+            },
+            {
+                name: "prism_agent_definitions_name_version_idx",
+                table: "prism_agent_definitions",
+                columns: ["name", "version"],
+                purpose: "definition lookup",
+            },
+            {
+                name: "prism_legal_holds_owner_resource_idx",
+                table: "prism_legal_holds",
+                columns: ["tenant_id", "account_id", "user_id", "resource_kind", "resource_id"],
+                purpose: "hold lookup by owned resource",
+            },
+            {
+                name: "prism_legal_holds_created_id_idx",
+                table: "prism_legal_holds",
+                columns: ["created_at", "id"],
+                purpose: "hold export pagination",
+            },
+            {
+                name: "prism_tenant_quotas_owner_kind_idx",
+                table: "prism_tenant_quotas",
+                columns: ["tenant_id", "account_id", "user_id", "resource_kind"],
+                purpose: "tenant quota lookup",
+            },
+            {
+                name: "prism_migrations_name_version_idx",
+                table: "prism_migrations",
+                columns: ["name", "version"],
+                purpose: "applied-migration lookup (table constraint enforces uniqueness)",
+            },
         ],
     };
 }
@@ -307,15 +481,51 @@ function migrationStep(version, name, description) {
     const content = version === 1
         ? {
             tables: model.tables
-                .filter((table) => table.name !== "prism_run_feedback")
+                .filter((table) => table.name !== "prism_run_feedback" && table.name !== "prism_agent_event_streams")
                 .map((table) => table.name === "prism_usage"
                 ? { ...table, columns: table.columns.filter((column) => !["scope", "turn", "attempt"].includes(column.name)) }
                 : table),
-            indexes: model.indexes.filter((index) => !index.name.startsWith("prism_usage_session_scope_") && !index.name.startsWith("prism_run_feedback_")),
+            indexes: model.indexes
+                .filter((index) => !index.name.startsWith("prism_usage_session_scope_") &&
+                !index.name.startsWith("prism_run_feedback_") &&
+                !index.name.startsWith("prism_agent_event_streams_") &&
+                !index.name.startsWith("prism_agent_events_owner_timestamp_"))
+                .map((index) => index.name === "prism_agent_events_run_sequence_idx"
+                ? (() => {
+                    const { unique: _unique, ...legacy } = index;
+                    return legacy;
+                })()
+                : index),
         }
-        : version === 2
-            ? { table: "prism_usage", columns: ["scope", "turn", "attempt"], indexes: ["prism_usage_session_scope_recorded_idx"] }
-            : { tables: ["prism_run_feedback"], indexes: model.indexes.filter((index) => index.name.startsWith("prism_run_feedback_")).map((index) => index.name) };
+        : version === 7
+            ? { indexes: ["prism_agent_events_owner_timestamp_sequence_idx"] }
+            : version === 6
+                ? {
+                    tables: ["prism_agent_event_streams"],
+                    indexes: ["prism_agent_events_run_sequence_idx"],
+                }
+                : version === 2
+                    ? { table: "prism_usage", columns: ["scope", "turn", "attempt"], indexes: ["prism_usage_session_scope_recorded_idx"] }
+                    : version === 3
+                        ? {
+                            tables: ["prism_run_feedback"],
+                            indexes: model.indexes.filter((index) => index.name.startsWith("prism_run_feedback_")).map((index) => index.name),
+                        }
+                        : version === 4
+                            ? // Adapter-local FTS objects (SQLite FTS5 / Postgres tsvector) map to this canonical name.
+                                { search: ["prism_session_search"], indexes: ["prism_sessions_updated_id_idx"] }
+                            : version === 5
+                                ? {
+                                    tables: ["prism_legal_holds", "prism_tenant_quotas"],
+                                    indexes: [
+                                        "prism_legal_holds_owner_resource_idx",
+                                        "prism_legal_holds_created_id_idx",
+                                        "prism_tenant_quotas_owner_kind_idx",
+                                    ],
+                                }
+                                : (() => {
+                                    throw new Error(`Unknown migration version ${version}`);
+                                })();
     return {
         version,
         name,
@@ -332,6 +542,10 @@ export function createPersistenceMigrationContract() {
             migrationStep(1, "001_init", "Create core session, branch, entry, idempotency, run, ledger, and migration tables."),
             migrationStep(2, "002_usage_scope", "Distinguish provider-turn usage from aggregate run totals."),
             migrationStep(3, "003_run_feedback", "Add immutable ownership-scoped run/trace feedback and evaluation links."),
+            migrationStep(4, "004_session_search", "Add bounded session search indexes and adapter-local FTS objects."),
+            migrationStep(5, "005_lifecycle_hold_quota", "Add legal-hold and tenant-quota tables for retention lifecycle."),
+            migrationStep(6, "006_agent_event_source", "Add transactional per-run event counters and unique durable event sequencing."),
+            migrationStep(7, "007_agent_event_retention_index", "Add an exact-owner durable-event retention cleanup index."),
         ],
         lockGuidance: "Acquire a dialect-specific migration lock before applying steps (PostgreSQL advisory lock; SQLite exclusive transaction). Only one process should migrate at a time.",
         leastPrivilegeGuidance: "Run migrations with a DDL-capable role; use a separate least-privilege runtime role limited to INSERT/SELECT/UPDATE on adapter tables. Never grant migration credentials to the agent runtime.",
@@ -340,13 +554,33 @@ export function createPersistenceMigrationContract() {
 /** Indexed cursor columns adapters must support for paginated reads. */
 export function getPersistencePaginationCursors() {
     return [
-        { table: "prism_session_entries", columns: ["session_id", "timestamp", "id"], supportsOrder: ["asc", "desc"], purpose: "entry listing and branch paging" },
+        {
+            table: "prism_session_entries",
+            columns: ["session_id", "timestamp", "id"],
+            supportsOrder: ["asc", "desc"],
+            purpose: "entry listing and branch paging",
+        },
         { table: "prism_runs", columns: ["session_id", "started_at", "id"], supportsOrder: ["asc", "desc"], purpose: "run history" },
-        { table: "prism_agent_events", columns: ["run_id", "sequence"], supportsOrder: ["asc", "desc"], purpose: "stable per-run event timeline" },
-        { table: "prism_agent_events", columns: ["session_id", "timestamp", "id"], supportsOrder: ["asc", "desc"], purpose: "session event stream" },
+        {
+            table: "prism_agent_events",
+            columns: ["run_id", "sequence"],
+            supportsOrder: ["asc", "desc"],
+            purpose: "stable per-run event timeline",
+        },
+        {
+            table: "prism_agent_events",
+            columns: ["session_id", "timestamp", "id"],
+            supportsOrder: ["asc", "desc"],
+            purpose: "session event stream",
+        },
         { table: "prism_usage", columns: ["run_id", "recorded_at", "id"], supportsOrder: ["asc", "desc"], purpose: "run usage totals" },
         { table: "prism_tool_calls", columns: ["run_id", "started_at"], supportsOrder: ["asc", "desc"], purpose: "run tool-call listing" },
-        { table: "prism_run_feedback", columns: ["tenant_id", "account_id", "user_id", "created_at", "id"], supportsOrder: ["asc", "desc"], purpose: "owned feedback listing" },
+        {
+            table: "prism_run_feedback",
+            columns: ["tenant_id", "account_id", "user_id", "created_at", "id"],
+            supportsOrder: ["asc", "desc"],
+            purpose: "owned feedback listing",
+        },
     ];
 }
 /** Build a tenant-scoped unique key column list for adapter DDL. */
@@ -379,7 +613,13 @@ export function assertPersistenceSchemaModel(model) {
         throw new Error("Runs table must include tenant-scoped tenant_id");
     }
     const indexTables = new Set(model.indexes.map((index) => index.table));
-    for (const requiredIndex of ["prism_session_append_idempotency", "prism_session_entries", "prism_agent_events", "prism_runs", "prism_run_feedback"]) {
+    for (const requiredIndex of [
+        "prism_session_append_idempotency",
+        "prism_session_entries",
+        "prism_agent_events",
+        "prism_runs",
+        "prism_run_feedback",
+    ]) {
         if (!indexTables.has(requiredIndex)) {
             throw new Error(`Persistence schema missing indexes for ${requiredIndex}`);
         }
@@ -423,7 +663,10 @@ function schemaKey(columns) {
     return columns.join("\u0000");
 }
 function normalizedDefault(value) {
-    return value?.trim().toLowerCase().replace(/::[a-z_ ]+$/, "");
+    return value
+        ?.trim()
+        .toLowerCase()
+        .replace(/::[a-z_ ]+$/, "");
 }
 function compatibleColumnType(dialect, actual, expected) {
     const type = actual.trim().toUpperCase();
@@ -488,7 +731,9 @@ export function assertPersistenceSchemaShape(shape, dialect, model = createPersi
         const actual = actualIndexes.get(expected.name);
         if (!actual)
             throw new Error(`Persistence schema missing required index ${expected.name}`);
-        if (actual.table !== expected.table || schemaKey(actual.columns) !== schemaKey(expected.columns) || actual.unique !== (expected.unique === true)) {
+        if (actual.table !== expected.table ||
+            schemaKey(actual.columns) !== schemaKey(expected.columns) ||
+            actual.unique !== (expected.unique === true)) {
             throw new Error(`Persistence schema index ${expected.name} has incompatible definition`);
         }
     }

package/dist/testing/provider-conformance.js

@@ -73,7 +73,7 @@ export function assertProviderOwnedHeadersWin(captured, options) {
             throw new Error(`Caller header overrode provider-owned "${name}": expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
     }
     for (const [name, callerValue] of Object.entries(options.caller)) {
-        if (Object.prototype.hasOwnProperty.call(ownedLower, name.toLowerCase()))
+        if (Object.hasOwn(ownedLower, name.toLowerCase()))
             continue;
         const actual = captured.get(name);
         if (actual !== callerValue)
@@ -90,7 +90,7 @@ export function assertNoSecretLeak(events, secrets) {
     }
 }
 export function assertUsageAccounting(events, expected) {
-    const usage = [...events].reverse().find((event) => event.type === "done" && event.usage || event.type === "usage");
+    const usage = [...events].reverse().find((event) => (event.type === "done" && event.usage) || event.type === "usage");
     const actual = usage?.type === "usage" ? usage.usage : usage?.usage;
     if (!actual)
         throw new Error("Provider stream did not include usage");
@@ -155,6 +155,6 @@ function jsonPrimitives(value) {
     return primitives;
 }
 function textFrom(events) {
-    return events.map((event) => event.type === "content_delta" && event.content.type === "text" ? event.content.text : "").join("");
+    return events.map((event) => (event.type === "content_delta" && event.content.type === "text" ? event.content.text : "")).join("");
 }
 //# sourceMappingURL=provider-conformance.js.map

package/dist/testing/run-ledger-conformance.js

@@ -138,7 +138,7 @@ export async function assertRunLedgerConforms(fixture, options = {}) {
         await fixture.ledger.appendRun(otherRun);
         const runs = await fixture.readRuns();
         const stored = runs.find((row) => row.id === "run-tenant-b");
-        if (!stored || stored.tenantId !== "tenant-b") {
+        if (stored?.tenantId !== "tenant-b") {
             throw new Error("RunLedger must persist tenant_id on records for tenant-scoped isolation");
         }
         const scoped = runs.filter((row) => row.tenantId === tenantId);

package/dist/testing/session-store-conformance.d.ts

@@ -10,6 +10,12 @@ export interface SessionStoreConformanceOptions {
      * when the store does not implement `readBranchPath`.
      */
     readonly exerciseReadBranchPath?: boolean;
+    /**
+     * When true, exercises optional `searchSessions` (empty page, limit cap,
+     * invalid limit/query rejection via `resolveSessionSearchQuery` semantics).
+     * Skipped when the store does not implement `searchSessions`.
+     */
+    readonly exerciseSearchSessions?: boolean;
     /** When true, appends concurrent children of the same parent (fork allowed). */
     readonly exerciseConcurrentParentAppend?: boolean;
     /**