@sixb/sqlite 0.1.19 → 0.1.21

package/src/auth-storage/shared.ts

@@ -1,5 +1,4 @@
 import type { Database } from "bun:sqlite"
-import type { AuthSessionAudience } from "@sixb/core"
 import type {
   CompleteAuthSessionInput,
   CreateAuthSessionInput,
@@ -385,7 +384,6 @@ export function validateCompleteSessionInput(
   session: CompleteAuthSessionInput
 ): void {
   const sessionId = assertNonEmpty(session.id, "Session id")
-  assertNonEmpty(session.audience, "Session audience")
   assertNonEmpty(session.tokenHash, "Session token hash")
   assertSessionIdAvailable(db, projectId, sessionId)
 }
@@ -407,7 +405,6 @@ export function createSession(
   const projectId = assertNonEmpty(input.projectId, "Project id")
   const userId = assertNonEmpty(input.userId, "User id")
   const strategyId = assertNonEmpty(input.strategyId, "Strategy id")
-  const audience = assertNonEmpty(input.audience, "Session audience")
   const tokenHash = assertNonEmpty(input.tokenHash, "Session token hash")
 
   assertSessionIdAvailable(db, projectId, id)
@@ -419,7 +416,6 @@ export function createSession(
       id,
       user_id,
       strategy_id,
-      audience,
       token_hash,
       created_at,
       expires_at,
@@ -429,14 +425,13 @@ export function createSession(
       client_name,
       access_expires_at,
       refresh_token_hash
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `
   ).run(
     projectId,
     id,
     userId,
     strategyId,
-    audience,
     tokenHash,
     toIso(input.createdAt),
     toIso(input.expiresAt),
@@ -463,20 +458,10 @@ export function revokeActiveSessionsForUser(
   params: {
     readonly projectId: string
     readonly userId: string
-    readonly audience?: AuthSessionAudience
     readonly revokedAt: Date
   }
 ): readonly ReturnType<typeof rowToSessionRecord>[] {
   const revokedAt = toIso(params.revokedAt)
-  const audienceCondition = params.audience === undefined ? "" : "AND audience = ?"
-  const selectArgs =
-    params.audience === undefined
-      ? [params.projectId, params.userId, revokedAt, revokedAt]
-      : [params.projectId, params.userId, params.audience, revokedAt, revokedAt]
-  const updateArgs =
-    params.audience === undefined
-      ? [revokedAt, params.projectId, params.userId, revokedAt, revokedAt]
-      : [revokedAt, params.projectId, params.userId, params.audience, revokedAt, revokedAt]
   const rows = db
     .query(
       `
@@ -484,14 +469,13 @@ export function revokeActiveSessionsForUser(
       FROM auth_sessions
       WHERE project_id = ?
         AND user_id = ?
-        ${audienceCondition}
         AND revoked_at IS NULL
         AND expires_at > ?
         AND (absolute_expires_at IS NULL OR absolute_expires_at > ?)
       ORDER BY created_at ASC, id ASC
     `
     )
-    .all(...selectArgs) as SqliteAuthSessionRow[]
+    .all(params.projectId, params.userId, revokedAt, revokedAt) as SqliteAuthSessionRow[]
 
   db.query(
     `
@@ -499,12 +483,11 @@ export function revokeActiveSessionsForUser(
     SET revoked_at = ?
     WHERE project_id = ?
       AND user_id = ?
-      ${audienceCondition}
       AND revoked_at IS NULL
       AND expires_at > ?
       AND (absolute_expires_at IS NULL OR absolute_expires_at > ?)
   `
-  ).run(...updateArgs)
+  ).run(revokedAt, params.projectId, params.userId, revokedAt, revokedAt)
 
   return rows.map((row) =>
     rowToSessionRecord({

package/src/execution-storage.ts

@@ -1,5 +1,6 @@
 import type { Database } from "bun:sqlite"
 import {
+  compareExecutionCreation,
   type ExecutionStorageRow,
   executionRecordFromStorageRow,
   executionRecordToStorageRow,
@@ -9,6 +10,8 @@ import type {
   CreateExecutionInput,
   ExecutionRecord,
   ExecutionStorage,
+  ListSessionExecutionsInput,
+  SessionExecutions,
   ShareSessionStorage,
 } from "@sixb/core/storage"
 import { ExecutionStorageError } from "@sixb/core/storage"
@@ -115,6 +118,59 @@ export class SqliteExecutionStorage implements ExecutionStorage {
 
     return row ? sqliteExecutionRecord(row) : null
   }
+
+  async listBySession(input: ListSessionExecutionsInput): Promise<SessionExecutions> {
+    const sessionColumn =
+      input.session.type === "user" ? "authority_session_id" : "authority_delegation_session_id"
+
+    // The queue is ordered by depth, so the walk takes roots, then their children level by level,
+    // the earliest first, and the limit stops it: a large tree costs no more than the rows
+    // returned. CROSS JOIN keeps the walk driven by the rows found: statistics taken on a small
+    // ledger choose to scan every child.
+    const rows = this.db
+      .query(
+        `
+        WITH RECURSIVE tree AS (
+          SELECT roots.*, 0 AS depth
+          FROM (
+            SELECT *
+            FROM executions
+            WHERE project_id = ?
+              AND ${sessionColumn} = ?
+              AND parent_execution_id IS NULL
+              AND created_at >= ?
+              AND created_at < ?
+            ORDER BY created_at, id
+            LIMIT ?
+          ) roots
+          UNION ALL
+          SELECT child.*, tree.depth + 1
+          FROM tree
+          CROSS JOIN executions child
+            ON child.project_id = tree.project_id
+            AND child.parent_execution_id = tree.id
+          ORDER BY depth, created_at, id
+          LIMIT ?
+        )
+        SELECT * FROM tree
+      `
+      )
+      .all(
+        input.projectId,
+        input.session.id,
+        input.from.toISOString(),
+        input.to.toISOString(),
+        input.limit + 1,
+        input.limit + 1
+      ) as SqliteExecutionRow[]
+
+    // Rows come out in walk order, so the first `limit` are the ones the contract keeps.
+    const kept = rows.slice(0, input.limit).map(sqliteExecutionRecord)
+    return {
+      executions: kept.sort(compareExecutionCreation),
+      truncated: rows.length > input.limit,
+    }
+  }
 }
 
 /** An `executions` row as its record, for any store that reads executions alongside its own rows. */

package/src/index.ts

@@ -32,20 +32,18 @@ import {
   StorageTransactionError,
 } from "@sixb/core/storage"
 import { SqliteActionRunStorage } from "./action-run-storage"
+import { SqliteActivityStorage } from "./activity-storage"
 import { SqliteAgentStorage } from "./agents"
 import { SqliteAiCostStorage } from "./ai-cost-storage"
 import { SqliteAiLimitStorage } from "./ai-limit-storage"
 import { SqliteAiUsageStorage } from "./ai-usage-storage"
+import { SqliteArtifactStorage } from "./artifact-storage"
 import { SqliteAuthStorage } from "./auth-storage"
 import { SqliteConnectorConnectionStorage } from "./connector-connection-storage"
 import { SqliteExecutionStorage } from "./execution-storage"
 import { SqliteFileDownloadGrantStorage } from "./file-download-grant-storage"
 import { SqliteFileUploadSessionStorage } from "./file-upload-session-storage"
-import {
-  createSqliteStorageMigrators,
-  installFreshSqliteSchema,
-  sqliteStoragePath,
-} from "./migrations"
+import { createSqliteStorageMigrators, sqliteStoragePath } from "./migrations"
 import { SqliteObjectStorage } from "./objects"
 import { SqliteOntologyStorage, type SqliteOntologyTransactionContext } from "./ontology-storage"
 import { SqlitePipelineRunStorage } from "./pipeline-run-storage"
@@ -93,6 +91,7 @@ export class SqliteStorage implements MigrationCapableStorage {
   readonly auth: SqliteAuthStorage
   readonly executions: SqliteExecutionStorage
   readonly agents: SqliteAgentStorage
+  readonly artifacts: SqliteArtifactStorage
   readonly aiUsage: AiUsageStorage
   readonly aiCosts: AiCostStorage
   readonly aiLimits: AiLimitStorage
@@ -110,6 +109,7 @@ export class SqliteStorage implements MigrationCapableStorage {
   readonly connectorConnections: SqliteConnectorConnectionStorage
   readonly fileUploadSessions: SqliteFileUploadSessionStorage
   readonly fileDownloadGrants: SqliteFileDownloadGrantStorage
+  readonly activity: SqliteActivityStorage
   readonly migrators: readonly StorageMigrator[]
 
   private readonly connection: SqliteStoreConnection
@@ -127,10 +127,6 @@ export class SqliteStorage implements MigrationCapableStorage {
       this.readConnection = this.connection
     }
 
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.connection.db)
-    }
-
     const stores = createSqliteStores(this.connection, {
       runOntologyOperation: async (run) => run(),
       transactionContext: null,
@@ -161,6 +157,7 @@ export class SqliteStorage implements MigrationCapableStorage {
     this.auth = createAuthOperationScope(stores.auth, scope)
     this.executions = createOperationScopedFacade(stores.executions, scope)
     this.agents = createAgentOperationScope(stores.agents, scope)
+    this.artifacts = createOperationScopedFacade(stores.artifacts, scope)
     this.aiUsage = createOperationScopedFacade(stores.aiUsage, scope)
     this.aiCosts = createOperationScopedFacade(stores.aiCosts, scope)
     this.aiLimits = createOperationScopedFacade(stores.aiLimits, scope)
@@ -178,6 +175,7 @@ export class SqliteStorage implements MigrationCapableStorage {
     this.connectorConnections = createOperationScopedFacade(stores.connectorConnections, scope)
     this.fileUploadSessions = createOperationScopedFacade(stores.fileUploadSessions, scope)
     this.fileDownloadGrants = createOperationScopedFacade(stores.fileDownloadGrants, scope)
+    this.activity = createOperationScopedFacade(stores.activity, scope)
     this.migrators = options.path ? createSqliteStorageMigrators(options.path) : []
     registerSqliteStorageTestingAdapter(this, {
       advanceConnectorConnectionTime: (durationMs) =>
@@ -256,7 +254,6 @@ export class SqliteStorage implements MigrationCapableStorage {
         {
           db: this.connection.db,
           ownsConnection: false,
-          installFreshSchema: false,
         },
         {
           runOntologyOperation: async (run) => run(),
@@ -326,6 +323,7 @@ function createSqliteStores(
     auth,
     executions,
     agents: new SqliteAgentStorage({ connection, executions }),
+    artifacts: new SqliteArtifactStorage(connection),
     aiUsage: new SqliteAiUsageStorage({ connection }),
     aiCosts: new SqliteAiCostStorage(connection),
     aiLimits: new SqliteAiLimitStorage({ connection }),
@@ -343,6 +341,7 @@ function createSqliteStores(
     connectorConnections: new SqliteConnectorConnectionStorage(connection),
     fileUploadSessions: new SqliteFileUploadSessionStorage(connection),
     fileDownloadGrants: new SqliteFileDownloadGrantStorage(connection),
+    activity: new SqliteActivityStorage(connection),
   }
 }
 
@@ -352,6 +351,7 @@ interface SqliteStoreSet {
   readonly auth: SqliteAuthStorage
   readonly executions: SqliteExecutionStorage
   readonly agents: SqliteAgentStorage
+  readonly artifacts: SqliteArtifactStorage
   readonly aiUsage: SqliteAiUsageStorage
   readonly aiCosts: SqliteAiCostStorage
   readonly aiLimits: SqliteAiLimitStorage
@@ -369,6 +369,7 @@ interface SqliteStoreSet {
   readonly connectorConnections: SqliteConnectorConnectionStorage
   readonly fileUploadSessions: SqliteFileUploadSessionStorage
   readonly fileDownloadGrants: SqliteFileDownloadGrantStorage
+  readonly activity: SqliteActivityStorage
 }
 
 export { migrateSqliteStorage } from "./migrations"

package/src/migrations/061-drop-auth-audience.sql

@@ -0,0 +1,16 @@
+-- A project has one browser app, so sessions, magic links and sign-in attempts no longer name the
+-- one they belong to. Atlas's browser sessions end here: their cookie is no longer read. Native
+-- sessions carried Atlas's name only because the column needed a value, so they stay.
+UPDATE auth_sessions
+SET revoked_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE audience = 'atlas'
+  AND refresh_token_hash IS NULL
+  AND revoked_at IS NULL;
+
+DROP INDEX idx_auth_sessions_user_active;
+ALTER TABLE auth_sessions DROP COLUMN audience;
+CREATE INDEX idx_auth_sessions_user_active
+  ON auth_sessions(project_id, user_id, revoked_at, expires_at);
+
+ALTER TABLE auth_magic_links DROP COLUMN audience;
+ALTER TABLE auth_oidc_authorization_attempts DROP COLUMN audience;

package/src/migrations/062-artifacts.sql

@@ -0,0 +1,71 @@
+-- Artifacts: versioned documents, sheets, decks, and files. An artifact's kind never
+-- changes. Versions take `next_version`, which only grows, so a number is never reused after its
+-- version is deleted. Timestamps are ISO-8601 UTC text and compare lexicographically.
+CREATE TABLE artifacts (
+  project_id TEXT NOT NULL CHECK (length(trim(project_id)) > 0),
+  id TEXT NOT NULL CHECK (length(trim(id)) > 0),
+  kind TEXT NOT NULL CHECK (kind IN ('document', 'sheet', 'slides', 'file')),
+  title TEXT NOT NULL CHECK (length(trim(title)) > 0),
+  owner_principal_type TEXT NOT NULL
+    CHECK (owner_principal_type IN ('user', 'serviceAccount', 'system')),
+  owner_principal_id TEXT NOT NULL CHECK (length(owner_principal_id) > 0),
+  latest_version INTEGER NOT NULL CHECK (latest_version > 0),
+  next_version INTEGER NOT NULL CHECK (next_version > latest_version),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, id)
+);
+
+CREATE INDEX idx_artifacts_project_updated ON artifacts (project_id, updated_at DESC, id);
+CREATE INDEX idx_artifacts_owner_updated
+  ON artifacts (project_id, owner_principal_type, owner_principal_id, updated_at DESC, id);
+
+-- `refs`, not `references`: that word is reserved in SQL.
+CREATE TABLE artifact_versions (
+  project_id TEXT NOT NULL,
+  artifact_id TEXT NOT NULL,
+  version INTEGER NOT NULL CHECK (version > 0),
+  title TEXT NOT NULL CHECK (length(trim(title)) > 0),
+  entry TEXT NOT NULL CHECK (length(entry) > 0),
+  files TEXT NOT NULL CHECK (json_type(files) = 'array'),
+  outline TEXT NOT NULL CHECK (json_type(outline) = 'object'),
+  refs TEXT NOT NULL CHECK (json_type(refs) = 'array'),
+  author_principal_type TEXT NOT NULL
+    CHECK (author_principal_type IN ('user', 'serviceAccount', 'system')),
+  author_principal_id TEXT NOT NULL CHECK (length(author_principal_id) > 0),
+  origin_thread_id TEXT,
+  origin_run_id TEXT,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, artifact_id, version),
+  FOREIGN KEY (project_id, artifact_id) REFERENCES artifacts (project_id, id) ON DELETE CASCADE,
+  CHECK ((origin_thread_id IS NULL) = (origin_run_id IS NULL))
+);
+
+CREATE INDEX idx_artifact_versions_origin_run
+  ON artifact_versions (project_id, origin_run_id) WHERE origin_run_id IS NOT NULL;
+CREATE INDEX idx_artifact_versions_origin_thread
+  ON artifact_versions (project_id, origin_thread_id, artifact_id) WHERE origin_thread_id IS NOT NULL;
+
+-- Short-lived links that a sandboxed frame loads a deck's files through. Only the SHA-256 of each
+-- link's token is stored. `targets` is what the frame may show from other artifacts, decided for
+-- its reader when the link was issued: a JSON array of { address, artifactId, version }.
+CREATE TABLE artifact_frame_grants (
+  project_id TEXT NOT NULL,
+  token_hash TEXT NOT NULL CHECK (
+    length(token_hash) = 64
+    AND token_hash = lower(token_hash)
+    AND token_hash NOT GLOB '*[^0-9a-f]*'
+  ),
+  artifact_id TEXT NOT NULL,
+  version INTEGER NOT NULL CHECK (version > 0),
+  targets TEXT NOT NULL CHECK (json_type(targets) = 'array'),
+  created_at TEXT NOT NULL,
+  expires_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, token_hash),
+  FOREIGN KEY (project_id, artifact_id) REFERENCES artifacts (project_id, id) ON DELETE CASCADE,
+  CHECK (expires_at > created_at)
+);
+
+CREATE INDEX idx_artifact_frame_grants_expiry ON artifact_frame_grants (project_id, expires_at);
+-- Deleting an artifact cascades here.
+CREATE INDEX idx_artifact_frame_grants_artifact ON artifact_frame_grants (project_id, artifact_id);

package/src/migrations/063-drop-output-diagnostics.sql

@@ -0,0 +1,19 @@
+-- The Agent delivers files by publishing artifacts, so a run no longer collects an output
+-- directory or reports on it. Stored `output_*` diagnostics go; a run left with none stores none.
+UPDATE agent_runs
+SET diagnostics = (
+  SELECT CASE WHEN count(*) = 0 THEN NULL ELSE json_group_array(json(value)) END
+  FROM (
+    SELECT value
+    FROM json_each(agent_runs.diagnostics)
+    WHERE json_extract(value, '$.code') NOT LIKE 'output\_%' ESCAPE '\'
+    ORDER BY key
+  )
+)
+WHERE diagnostics IS NOT NULL
+  AND json_valid(diagnostics)
+  AND EXISTS (
+    SELECT 1
+    FROM json_each(agent_runs.diagnostics)
+    WHERE json_extract(value, '$.code') LIKE 'output\_%' ESCAPE '\'
+  );

package/src/migrations/064-activity.sql

@@ -0,0 +1,61 @@
+-- App activity: one source per verified session, the visits it opened, and their page views.
+-- Foreground activity moves a visit's `last_seen_at` and stores no row, unless it opens a visit.
+-- A session id names an `auth_sessions` row for a user and a `share_sessions` row for a share; it
+-- is not a secret, and no foreign key holds it, so history outlives its sessions. Timestamps are
+-- ISO-8601 UTC text and compare lexicographically.
+CREATE TABLE activity_sources (
+  project_id TEXT NOT NULL,
+  actor_type TEXT NOT NULL CHECK (actor_type IN ('user', 'share')),
+  session_id TEXT NOT NULL CHECK (length(session_id) > 0),
+  visit_id TEXT NOT NULL,
+  last_seen_at TEXT NOT NULL,
+  sequence INTEGER NOT NULL CHECK (sequence >= 0),
+  window_start TEXT NOT NULL,
+  window_count INTEGER NOT NULL CHECK (window_count >= 0),
+  PRIMARY KEY (project_id, actor_type, session_id)
+);
+
+CREATE TABLE activity_visits (
+  project_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  actor_type TEXT NOT NULL CHECK (actor_type IN ('user', 'share')),
+  user_id TEXT,
+  grant_id TEXT,
+  session_id TEXT NOT NULL CHECK (length(session_id) > 0),
+  started_at TEXT NOT NULL,
+  last_seen_at TEXT NOT NULL CHECK (last_seen_at >= started_at),
+  page_views INTEGER NOT NULL CHECK (page_views >= 0),
+  attribution TEXT CHECK (attribution IS NULL OR json_type(attribution) = 'object'),
+  PRIMARY KEY (project_id, id),
+  CHECK (
+    (actor_type = 'user' AND user_id IS NOT NULL AND grant_id IS NULL)
+    OR (actor_type = 'share' AND user_id IS NULL AND grant_id IS NOT NULL)
+  )
+);
+
+-- A period reads the visits it overlaps. A visit lasts less than a day, so they started in
+-- `[from - 1 day, to)`: both period indexes bound `started_at` on both sides. `last_seen_at` is
+-- left out of every index, so the update each batch makes touches none of them. The user index
+-- also serves deleting one user's history.
+CREATE INDEX idx_activity_visits_started
+  ON activity_visits (project_id, started_at, id);
+CREATE INDEX idx_activity_visits_user
+  ON activity_visits (project_id, user_id, started_at, id);
+-- A session's visits, to join them with the session and the executions it authorized.
+CREATE INDEX idx_activity_visits_session
+  ON activity_visits (project_id, actor_type, session_id);
+
+CREATE TABLE activity_page_views (
+  project_id TEXT NOT NULL,
+  visit_id TEXT NOT NULL,
+  sequence INTEGER NOT NULL CHECK (sequence > 0),
+  id TEXT NOT NULL,
+  route TEXT NOT NULL,
+  received_at TEXT NOT NULL,
+  attribution TEXT CHECK (attribution IS NULL OR json_type(attribution) = 'object'),
+  PRIMARY KEY (project_id, visit_id, sequence),
+  FOREIGN KEY (project_id, visit_id) REFERENCES activity_visits (project_id, id) ON DELETE CASCADE
+);
+
+-- Finds a retried page view by the id its browser chose.
+CREATE INDEX idx_activity_page_views_id ON activity_page_views (project_id, id);

package/src/migrations/065-activity-timeline.sql

@@ -0,0 +1,19 @@
+-- A visit's timeline reads what its session started: the roots it authorized in a window, then
+-- everything they caused. A signed-in session is the credential of its roots, a shared link's
+-- session their delegation; a child names its parent. Agent executions copy their parent's
+-- session: the root indexes hold only executions without a parent, so they never see those, and
+-- end with `id` so the root read's order needs no sort.
+CREATE INDEX idx_executions_session_roots
+  ON executions (project_id, authority_session_id, created_at, id)
+  WHERE authority_session_id IS NOT NULL AND parent_execution_id IS NULL;
+CREATE INDEX idx_executions_delegation_roots
+  ON executions (project_id, authority_delegation_session_id, created_at, id)
+  WHERE authority_delegation_session_id IS NOT NULL AND parent_execution_id IS NULL;
+CREATE INDEX idx_executions_parent
+  ON executions (project_id, parent_execution_id)
+  WHERE parent_execution_id IS NOT NULL;
+
+-- A user's connection history lists all their sessions, revoked and expired ones too, newest
+-- first.
+CREATE INDEX idx_auth_sessions_user_created
+  ON auth_sessions (project_id, user_id, created_at, id);

package/src/migrations/066-activity-interactions.sql

@@ -0,0 +1,20 @@
+-- Interactions an app marks, such as a button: their name and route, never a value. They share
+-- the visit's sequence with its page views, so a visit reads both in the order they happened, and
+-- cascade with the visit, which counts them as it counts its page views.
+ALTER TABLE activity_visits
+  ADD COLUMN interactions INTEGER NOT NULL DEFAULT 0 CHECK (interactions >= 0);
+
+CREATE TABLE activity_interactions (
+  project_id TEXT NOT NULL,
+  visit_id TEXT NOT NULL,
+  sequence INTEGER NOT NULL CHECK (sequence > 0),
+  id TEXT NOT NULL,
+  name TEXT NOT NULL CHECK (length(name) BETWEEN 1 AND 100),
+  route TEXT NOT NULL,
+  received_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, visit_id, sequence),
+  FOREIGN KEY (project_id, visit_id) REFERENCES activity_visits (project_id, id) ON DELETE CASCADE
+);
+
+-- Finds a retried interaction by the id its browser chose.
+CREATE INDEX idx_activity_interactions_id ON activity_interactions (project_id, id);

package/src/migrations.ts

@@ -272,6 +272,12 @@ export const sqliteStorageMigrations = defineMigrations({
     sqliteSql("058-file-download-grants", fileDownloadGrantsSql),
     sqliteSql("059-drained-source-versions", drainedSourceVersionsSql),
     sqliteSql("060-terminal-action-runs", terminalActionRunsSql),
+    sqliteSql("061-drop-auth-audience", dropAuthAudienceSql),
+    sqliteSql("062-artifacts", artifactsSql),
+    sqliteSql("063-drop-output-diagnostics", dropOutputDiagnosticsSql),
+    sqliteSql("064-activity", activitySql),
+    sqliteSql("065-activity-timeline", activityTimelineSql),
+    sqliteSql("066-activity-interactions", activityInteractionsSql),
   ],
 })
 
@@ -297,6 +303,26 @@ export function sqliteStep(
   return step<Database>(id, up, options)
 }
 
+// Replaying every migration costs a few hundred milliseconds, and in-memory databases are made
+// often (each test's storage, for one). The schema is built once per process and each new database
+// starts as a copy of it.
+let freshSchema: Uint8Array | undefined
+
+/** A new in-memory database holding the current schema, as replaying every migration leaves it. */
+export function freshSqliteDatabase(): Database {
+  if (!freshSchema) {
+    const template = new Database(":memory:")
+    try {
+      template.run("PRAGMA foreign_keys = ON")
+      installFreshSqliteSchema(template)
+      freshSchema = template.serialize()
+    } finally {
+      template.close()
+    }
+  }
+  return Database.deserialize(freshSchema)
+}
+
 export function installFreshSqliteSchema(db: Database): void {
   for (const migration of sqliteStorageMigrations.steps) {
     const installed = migration.up(db)
@@ -599,3 +625,13 @@ import drainedSourceVersionsSql from "./migrations/059-drained-source-versions.s
   type: "text",
 }
 import terminalActionRunsSql from "./migrations/060-terminal-action-runs.sql" with { type: "text" }
+import dropAuthAudienceSql from "./migrations/061-drop-auth-audience.sql" with { type: "text" }
+import artifactsSql from "./migrations/062-artifacts.sql" with { type: "text" }
+import dropOutputDiagnosticsSql from "./migrations/063-drop-output-diagnostics.sql" with {
+  type: "text",
+}
+import activitySql from "./migrations/064-activity.sql" with { type: "text" }
+import activityTimelineSql from "./migrations/065-activity-timeline.sql" with { type: "text" }
+import activityInteractionsSql from "./migrations/066-activity-interactions.sql" with {
+  type: "text",
+}

package/src/objects/storage.ts

@@ -22,7 +22,6 @@ import type {
   QueryObjectsInput,
   QueryObjectsResult,
 } from "@sixb/core/storage"
-import { installFreshSqliteSchema } from "../migrations"
 import {
   closeSqliteStoreConnection,
   openSqliteStoreConnection,
@@ -124,10 +123,6 @@ export class SqliteObjectStorage implements ObjectStorage {
     this.connection = openSqliteStoreConnection(options)
     this.db = this.connection.db
     this.reader = new SqliteObjectReader(this.db, DEFAULT_OBJECT_QUERY_SOURCE)
-
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db)
-    }
   }
 
   queryCapabilities(): ObjectQueryCapabilities {

package/src/ontology-storage/sources.ts

@@ -20,6 +20,7 @@ import type {
   AbandonRunSourceMaterializationInput,
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,
+  ActiveOntologySource,
   AdoptedSourceMaterialization,
   AdoptSourceMaterializationInput,
   AssertSourceMaterializationExecutionInput,
@@ -27,6 +28,7 @@ import type {
   CleanupTerminalSourceMaterializationsInput,
   CleanupTerminalSourceMaterializationsResult,
   GetActiveOntologySourceInput,
+  ListActiveOntologySourcesInput,
   MarkSourceMaterializationReadyInput,
   OntologySourceRecord,
   OntologySourceStorage,
@@ -238,6 +240,36 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
     })
   }
 
+  async listActive(
+    input: ListActiveOntologySourcesInput
+  ): Promise<readonly ActiveOntologySource[]> {
+    return this.runRootOperation(() => {
+      assertNonblank(input.projectId, "Source project id")
+
+      // Served by the partial index on active sources.
+      const rows = this.db
+        .query(
+          `
+            SELECT source_id, dataset_id, dataset_version_id, dataset_version_created_at,
+              projection_revision
+            FROM ontology_sources
+            WHERE project_id = ? AND status = 'active'
+          `
+        )
+        .all(input.projectId) as ActiveSourceRow[]
+
+      return rows.map((row) => ({
+        source: { projectionId: row.source_id },
+        datasetVersion: {
+          datasetId: row.dataset_id,
+          versionId: row.dataset_version_id,
+          createdAt: row.dataset_version_created_at,
+        },
+        projectionRevision: row.projection_revision,
+      }))
+    })
+  }
+
   async adopt(
     input: AdoptSourceMaterializationInput
   ): Promise<AdoptedSourceMaterialization | null> {
@@ -626,3 +658,12 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
     return row
   }
 }
+
+type ActiveSourceRow = Pick<
+  SqliteOntologySourceRow,
+  | "source_id"
+  | "dataset_id"
+  | "dataset_version_id"
+  | "dataset_version_created_at"
+  | "projection_revision"
+>

package/src/pipeline-run-storage.ts

@@ -22,7 +22,6 @@ import type {
 } from "@sixb/core/storage"
 import { PIPELINE_RUN_FAILURE_CODES, PipelineRunError } from "@sixb/core/storage"
 import { queryLatestRunsByOwnerId } from "./latest-run-query"
-import { installFreshSqliteSchema } from "./migrations"
 import {
   appendRunListFilters,
   hasEmptyStatuses,
@@ -54,10 +53,6 @@ export class SqlitePipelineRunStorage implements PipelineRunStorage {
     this.connection = openSqliteStoreConnection(options)
     this.db = this.connection.db
     this.executions = options.executions
-
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db)
-    }
   }
 
   async queue(input: QueuePipelineRunInput): Promise<PipelineRunRecord> {

package/src/projection-run-storage.ts

@@ -56,7 +56,6 @@ import type {
 } from "@sixb/core/storage"
 import { PROJECTION_RUN_FAILURE_CODES, ProjectionRunError } from "@sixb/core/storage"
 import { queryLatestRunsByOwnerId } from "./latest-run-query"
-import { installFreshSqliteSchema } from "./migrations"
 import {
   closeSqliteStoreConnection,
   openSqliteStoreConnection,
@@ -82,10 +81,6 @@ export class SqliteProjectionRunStorage implements ProjectionRunStorage {
     this.connection = openSqliteStoreConnection(options)
     this.db = this.connection.db
     this.executions = options.executions
-
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db)
-    }
   }
 
   async queue(input: QueueProjectionRunInput): Promise<ProjectionRunRecord> {