@sixb/sqlite 0.1.19 → 0.1.21

package/dist/index.js

@@ -28,6 +28,11 @@ import { assertActionRunExecution } from "@sixb/core/internal/action-run-storage
 import { normalizeRecordActionRunInput, resolveActionRunEffects } from "@sixb/core/internal/storage";
 import { ActionRunError } from "@sixb/core/storage";
 
+// src/transactions.ts
+import { Database as SqliteDatabase } from "bun:sqlite";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+
 // src/migrations.ts
 import { Database } from "bun:sqlite";
 import { createHash } from "crypto";
@@ -5142,6 +5147,230 @@ CREATE INDEX idx_action_runs_project_status_started
   ON action_runs(project_id, status, started_at DESC);
 `;
 
+// src/migrations/061-drop-auth-audience.sql
+var _061_drop_auth_audience_default = `-- 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;
+`;
+
+// src/migrations/062-artifacts.sql
+var _062_artifacts_default = `-- 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);
+`;
+
+// src/migrations/063-drop-output-diagnostics.sql
+var _063_drop_output_diagnostics_default = `-- 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 '\\'
+  );
+`;
+
+// src/migrations/064-activity.sql
+var _064_activity_default = `-- 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);
+`;
+
+// src/migrations/065-activity-timeline.sql
+var _065_activity_timeline_default = `-- 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);
+`;
+
+// src/migrations/066-activity-interactions.sql
+var _066_activity_interactions_default = `-- 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);
+`;
+
 // src/migrations.ts
 var MIGRATIONS_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS sixb_migrations (
@@ -5249,7 +5478,13 @@ var sqliteStorageMigrations = defineMigrations({
     sqliteSql("057-reranking-model-kind", _057_reranking_model_kind_default),
     sqliteSql("058-file-download-grants", _058_file_download_grants_default),
     sqliteSql("059-drained-source-versions", _059_drained_source_versions_default),
-    sqliteSql("060-terminal-action-runs", _060_terminal_action_runs_default)
+    sqliteSql("060-terminal-action-runs", _060_terminal_action_runs_default),
+    sqliteSql("061-drop-auth-audience", _061_drop_auth_audience_default),
+    sqliteSql("062-artifacts", _062_artifacts_default),
+    sqliteSql("063-drop-output-diagnostics", _063_drop_output_diagnostics_default),
+    sqliteSql("064-activity", _064_activity_default),
+    sqliteSql("065-activity-timeline", _065_activity_timeline_default),
+    sqliteSql("066-activity-interactions", _066_activity_interactions_default)
   ]
 });
 function sqliteStoragePath(basePath) {
@@ -5263,6 +5498,20 @@ function sqliteSql(id, sqlText) {
 function sqliteStep(id, up, options = {}) {
   return step(id, up, options);
 }
+var freshSchema;
+function freshSqliteDatabase() {
+  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);
+}
 function installFreshSqliteSchema(db) {
   for (const migration of sqliteStorageMigrations.steps) {
     const installed = migration.up(db);
@@ -5480,28 +5729,20 @@ function rollbackQuietly(db) {
 }
 
 // src/transactions.ts
-import { Database as SqliteDatabase } from "bun:sqlite";
-import { mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
 function openSqliteStoreConnection(options = {}) {
   if (options.connection) {
     return {
       db: options.connection.db,
-      ownsConnection: false,
-      installFreshSchema: false
+      ownsConnection: false
     };
   }
   const path = options.path ?? ":memory:";
   if (path !== ":memory:" && !options.readonly)
     mkdirSync2(dirname2(path), { recursive: true });
-  const db = new SqliteDatabase(path, options.readonly ? { readonly: true } : undefined);
+  const db = path === ":memory:" && !options.readonly ? freshSqliteDatabase() : new SqliteDatabase(path, options.readonly ? { readonly: true } : undefined);
   db.run("PRAGMA foreign_keys = ON");
   db.run("PRAGMA busy_timeout = 5000");
-  return {
-    db,
-    ownsConnection: true,
-    installFreshSchema: path === ":memory:" && !options.readonly
-  };
+  return { db, ownsConnection: true };
 }
 function closeSqliteStoreConnection(connection) {
   if (connection.ownsConnection) {
@@ -5582,9 +5823,6 @@ class SqliteActionRunStorage {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
     this.executions = options.executions;
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db);
-    }
   }
   async record(input) {
     const record = normalizeRecordActionRunInput(input);
@@ -5646,6 +5884,23 @@ class SqliteActionRunStorage {
     const row = this.db.query("SELECT * FROM action_runs WHERE project_id = ? AND id = ?").get(params.projectId, params.id);
     return row ? rowToActionRunRecord(row) : null;
   }
+  async getByExecutionIds(params) {
+    const executionIds = [...new Set(params.executionIds)];
+    if (executionIds.length === 0) {
+      return [];
+    }
+    const rows = this.db.query(`
+        SELECT *
+        FROM action_runs
+        WHERE project_id = ?
+          AND execution_id IN (SELECT value FROM json_each(?))
+      `).all(params.projectId, JSON.stringify(executionIds));
+    const byExecution = new Map(rows.map((row) => [row.execution_id, row]));
+    return executionIds.flatMap((executionId) => {
+      const row = byExecution.get(executionId);
+      return row ? [rowToActionRunRecord(row)] : [];
+    });
+  }
   async list(input) {
     if (input.statuses && input.statuses.length === 0 || input.actionIds?.length === 0) {
       return {
@@ -5817,6 +6072,342 @@ function rowToActionSubject(row) {
   };
 }
 
+// src/activity-storage.ts
+import {
+  ACTIVITY_MAX_VISIT_MS,
+  activityActor,
+  activityCalendarDays,
+  parseActivityAttribution,
+  planActivityAppend,
+  serializeActivityAttribution,
+  validateActivityAppend
+} from "@sixb/core/internal/storage";
+var VISIT_COLUMNS = `
+  v.id, v.actor_type, v.user_id, v.grant_id, v.started_at, v.last_seen_at, v.page_views,
+  v.interactions, v.attribution
+`;
+var NO_CURSOR = { at: "9999-12-31T23:59:59.999Z", id: "" };
+
+class SqliteActivityStorage {
+  db;
+  constructor(connection) {
+    this.db = connection.db;
+  }
+  async append(input) {
+    validateActivityAppend(input);
+    return runImmediateTransaction(this.db, () => {
+      const plan = planActivityAppend(input, this.source(input), this.storedEvents(input));
+      if (plan.status !== "append") {
+        return { status: plan.status === "duplicate" ? "accepted" : "throttled", accepted: 0 };
+      }
+      const { state } = plan;
+      const lastSeenAt = iso(state.lastSeenAt);
+      if (plan.newVisit) {
+        this.run(`
+            INSERT INTO activity_visits (
+              project_id, id, actor_type, user_id, grant_id, session_id,
+              started_at, last_seen_at, page_views, interactions, attribution
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `, input.projectId, state.visitId, input.actor.type, input.actor.type === "user" ? input.actor.userId : null, input.actor.type === "share" ? input.actor.grantId : null, input.sessionId, lastSeenAt, lastSeenAt, plan.pageViews.length, plan.interactions.length, plan.newVisit.attribution === null ? null : serializeActivityAttribution(plan.newVisit.attribution));
+      } else {
+        this.run(`
+            UPDATE activity_visits
+            SET
+              last_seen_at = ?,
+              page_views = page_views + ?,
+              interactions = interactions + ?
+            WHERE project_id = ? AND id = ?
+          `, lastSeenAt, plan.pageViews.length, plan.interactions.length, input.projectId, state.visitId);
+      }
+      for (const pageView of plan.pageViews) {
+        this.run(`
+            INSERT INTO activity_page_views (
+              project_id, visit_id, sequence, id, route, received_at, attribution
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+          `, input.projectId, pageView.visitId, pageView.sequence, pageView.id, pageView.route, pageView.receivedAt.toISOString(), serializeActivityAttribution(pageView.attribution));
+      }
+      for (const interaction of plan.interactions) {
+        this.run(`
+            INSERT INTO activity_interactions (
+              project_id, visit_id, sequence, id, name, route, received_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+          `, input.projectId, interaction.visitId, interaction.sequence, interaction.id, interaction.name, interaction.route, interaction.receivedAt.toISOString());
+      }
+      this.run(`
+          INSERT INTO activity_sources (
+            project_id, actor_type, session_id, visit_id, last_seen_at, sequence,
+            window_start, window_count
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT (project_id, actor_type, session_id) DO UPDATE SET
+            visit_id = excluded.visit_id,
+            last_seen_at = excluded.last_seen_at,
+            sequence = excluded.sequence,
+            window_start = excluded.window_start,
+            window_count = excluded.window_count
+        `, input.projectId, input.actor.type, input.sessionId, state.visitId, lastSeenAt, state.sequence, iso(state.windowStart), state.windowCount);
+      return { status: "accepted", accepted: plan.accepted };
+    });
+  }
+  async list(input) {
+    const period = overlapping(input);
+    const before = cursorOf(input.before);
+    const rows = this.all(`
+        SELECT ${VISIT_COLUMNS}
+        FROM activity_visits v
+        WHERE ${period.where}
+          AND (v.last_seen_at < ? OR (v.last_seen_at = ? AND v.id < ?))
+        ORDER BY v.last_seen_at DESC, v.id DESC
+        LIMIT ?
+      `, ...period.params, before.at, before.at, before.id, input.limit + 1);
+    return {
+      visits: rows.slice(0, input.limit).map(visitFromRow),
+      hasMore: rows.length > input.limit
+    };
+  }
+  async users(input) {
+    const period = overlapping(input);
+    const before = cursorOf(input.before);
+    const rows = this.all(`
+        SELECT
+          v.user_id,
+          MAX(v.last_seen_at) AS last_seen_at,
+          COUNT(DISTINCT v.id) AS visits,
+          COUNT(p.id) AS page_views
+        FROM activity_visits v
+        LEFT JOIN activity_page_views p
+          ON p.project_id = v.project_id
+          AND p.visit_id = v.id
+          AND p.received_at >= ?
+          AND p.received_at < ?
+        WHERE ${period.where} AND v.actor_type = 'user'
+        GROUP BY v.user_id
+        HAVING MAX(v.last_seen_at) < ? OR (MAX(v.last_seen_at) = ? AND v.user_id < ?)
+        ORDER BY last_seen_at DESC, v.user_id DESC
+        LIMIT ?
+      `, input.from.toISOString(), input.to.toISOString(), ...period.params, before.at, before.at, before.id, input.limit + 1);
+    return {
+      users: rows.slice(0, input.limit).map((row) => ({
+        userId: row.user_id,
+        lastSeenAt: new Date(row.last_seen_at),
+        visits: Number(row.visits),
+        pageViews: Number(row.page_views)
+      })),
+      hasMore: rows.length > input.limit
+    };
+  }
+  async summarize(input) {
+    const period = overlapping(input);
+    const [row] = this.all(`
+        SELECT
+          COUNT(DISTINCT v.user_id) AS users,
+          COUNT(DISTINCT v.id) AS visits,
+          COUNT(DISTINCT CASE WHEN v.actor_type = 'share' THEN v.id END) AS shared_visits,
+          COUNT(p.id) AS page_views
+        FROM activity_visits v
+        LEFT JOIN activity_page_views p
+          ON p.project_id = v.project_id
+          AND p.visit_id = v.id
+          AND p.received_at >= ?
+          AND p.received_at < ?
+        WHERE ${period.where}
+      `, input.from.toISOString(), input.to.toISOString(), ...period.params);
+    return {
+      users: Number(row?.users ?? 0),
+      visits: Number(row?.visits ?? 0),
+      sharedVisits: Number(row?.shared_visits ?? 0),
+      pageViews: Number(row?.page_views ?? 0)
+    };
+  }
+  async calendar(input) {
+    const period = overlapping(input);
+    const visits = this.all(`
+        SELECT v.started_at, v.last_seen_at
+        FROM activity_visits v
+        WHERE ${period.where}
+      `, ...period.params);
+    const days = this.all(`
+        SELECT substr(p.received_at, 1, 10) AS day, COUNT(*) AS page_views
+        FROM activity_visits v
+        JOIN activity_page_views p ON p.project_id = v.project_id AND p.visit_id = v.id
+        WHERE ${period.where}
+          AND p.received_at >= ?
+          AND p.received_at < ?
+        GROUP BY day
+      `, ...period.params, input.from.toISOString(), input.to.toISOString());
+    return activityCalendarDays(input, visits.map((visit) => ({
+      startedAt: new Date(visit.started_at),
+      lastSeenAt: new Date(visit.last_seen_at)
+    })), new Map(days.map((row) => [row.day, Number(row.page_views)])));
+  }
+  async read(input) {
+    const [visit] = this.all(`
+        SELECT ${VISIT_COLUMNS}, v.session_id
+        FROM activity_visits v
+        WHERE v.project_id = ? AND v.id = ?
+      `, input.projectId, input.id);
+    if (!visit) {
+      return null;
+    }
+    const rows = this.all(`
+        SELECT id, visit_id, sequence, route, NULL AS name, received_at
+        FROM activity_page_views
+        WHERE project_id = ? AND visit_id = ?
+        UNION ALL
+        SELECT id, visit_id, sequence, route, name, received_at
+        FROM activity_interactions
+        WHERE project_id = ? AND visit_id = ?
+        ORDER BY sequence
+        LIMIT ?
+      `, input.projectId, input.id, input.projectId, input.id, input.limit + 1);
+    const pageViews = [];
+    const interactions = [];
+    for (const row of rows.slice(0, input.limit)) {
+      if (row.name === null) {
+        pageViews.push(pageViewFromRow(row));
+      } else {
+        interactions.push({ ...pageViewFromRow(row), name: row.name });
+      }
+    }
+    return {
+      visit: visitFromRow(visit),
+      sessionId: visit.session_id,
+      pageViews,
+      interactions,
+      hasMore: rows.length > input.limit
+    };
+  }
+  async sessionVisits(input) {
+    if (input.sessionIds.length === 0) {
+      return [];
+    }
+    const rows = this.all(`
+        SELECT *
+        FROM (
+          SELECT
+            ${VISIT_COLUMNS},
+            v.session_id,
+            ROW_NUMBER() OVER (
+              PARTITION BY v.session_id ORDER BY v.started_at DESC, v.id DESC
+            ) AS position,
+            COUNT(*) OVER (PARTITION BY v.session_id) AS total
+          FROM activity_visits v
+          WHERE v.project_id = ?
+            AND v.actor_type = 'user'
+            AND v.session_id IN (SELECT value FROM json_each(?))
+            AND v.user_id = ?
+        )
+        WHERE position <= ?
+        ORDER BY session_id, position
+      `, input.projectId, JSON.stringify(input.sessionIds), input.userId, input.limit);
+    const bySession = new Map;
+    for (const row of rows) {
+      const session = bySession.get(row.session_id) ?? { visits: Number(row.total), latest: [] };
+      session.latest.push(visitFromRow(row));
+      bySession.set(row.session_id, session);
+    }
+    return [...bySession].map(([sessionId, session]) => ({ sessionId, ...session }));
+  }
+  source(input) {
+    const [row] = this.all(`
+        SELECT
+          s.visit_id, v.started_at AS visit_started_at, s.last_seen_at, s.sequence,
+          s.window_start, s.window_count
+        FROM activity_sources s
+        LEFT JOIN activity_visits v ON v.project_id = s.project_id AND v.id = s.visit_id
+        WHERE s.project_id = ? AND s.actor_type = ? AND s.session_id = ?
+      `, input.projectId, input.actor.type, input.sessionId);
+    if (!row) {
+      return;
+    }
+    return {
+      visitId: row.visit_id,
+      visitStartedAt: row.visit_started_at === null ? null : Date.parse(row.visit_started_at),
+      lastSeenAt: Date.parse(row.last_seen_at),
+      sequence: Number(row.sequence),
+      windowStart: Date.parse(row.window_start),
+      windowCount: Number(row.window_count)
+    };
+  }
+  storedEvents(input) {
+    const ids = JSON.stringify(input.events.map((event) => event.id));
+    const rows = this.all(`
+        SELECT p.id, p.route, NULL AS name, p.attribution
+        FROM activity_page_views p
+        JOIN activity_visits v ON v.project_id = p.project_id AND v.id = p.visit_id
+        WHERE p.project_id = ?
+          AND p.id IN (SELECT value FROM json_each(?))
+          AND v.actor_type = ?
+          AND v.session_id = ?
+        UNION ALL
+        SELECT i.id, i.route, i.name, NULL AS attribution
+        FROM activity_interactions i
+        JOIN activity_visits v ON v.project_id = i.project_id AND v.id = i.visit_id
+        WHERE i.project_id = ?
+          AND i.id IN (SELECT value FROM json_each(?))
+          AND v.actor_type = ?
+          AND v.session_id = ?
+      `, input.projectId, ids, input.actor.type, input.sessionId, input.projectId, ids, input.actor.type, input.sessionId);
+    return rows.map((row) => {
+      if (row.name !== null) {
+        return { id: row.id, route: row.route, name: row.name };
+      }
+      const attribution = parseActivityAttribution(row.attribution);
+      return { id: row.id, route: row.route, ...attribution ? { attribution } : {} };
+    });
+  }
+  run(sql, ...params) {
+    this.db.query(sql).run(...params);
+  }
+  all(sql, ...params) {
+    return this.db.query(sql).all(...params);
+  }
+}
+function overlapping(input) {
+  const conditions = [
+    "v.project_id = ?",
+    "v.started_at >= ?",
+    "v.started_at < ?",
+    "v.last_seen_at >= ?"
+  ];
+  const params = [
+    input.projectId,
+    new Date(input.from.getTime() - ACTIVITY_MAX_VISIT_MS).toISOString(),
+    input.to.toISOString(),
+    input.from.toISOString()
+  ];
+  if (input.userId !== undefined) {
+    conditions.push("v.user_id = ?");
+    params.push(input.userId);
+  }
+  return { where: conditions.join(" AND "), params };
+}
+function cursorOf(cursor) {
+  return cursor ? { at: cursor.at.toISOString(), id: cursor.id } : NO_CURSOR;
+}
+function visitFromRow(row) {
+  return {
+    id: row.id,
+    actor: activityActor(row.actor_type, row.user_id, row.grant_id),
+    attribution: parseActivityAttribution(row.attribution),
+    startedAt: new Date(row.started_at),
+    lastSeenAt: new Date(row.last_seen_at),
+    pageViews: Number(row.page_views),
+    interactions: Number(row.interactions)
+  };
+}
+function pageViewFromRow(row) {
+  return {
+    id: row.id,
+    visitId: row.visit_id,
+    sequence: Number(row.sequence),
+    route: row.route,
+    receivedAt: new Date(row.received_at)
+  };
+}
+function iso(epochMs) {
+  return new Date(epochMs).toISOString();
+}
+
 // src/agents/checkpoints.ts
 import {
   agentContextCheckpointMatchesCreateInput,
@@ -6599,6 +7190,23 @@ class SqliteAgentThreadStore {
     const row = this.db.query("SELECT * FROM agent_threads WHERE project_id = ? AND id = ?").get(params.projectId, params.id);
     return row ? rowToThreadRecord(row) : null;
   }
+  async getByIds(params) {
+    const ids = [...new Set(params.ids)];
+    if (ids.length === 0) {
+      return [];
+    }
+    const rows = this.db.query(`
+        SELECT *
+        FROM agent_threads
+        WHERE project_id = ?
+          AND id IN (SELECT value FROM json_each(?))
+      `).all(params.projectId, JSON.stringify(ids));
+    const byId = new Map(rows.map((row) => [row.id, row]));
+    return ids.flatMap((id) => {
+      const row = byId.get(id);
+      return row ? [rowToThreadRecord(row)] : [];
+    });
+  }
   async list(input) {
     if (input.statuses !== undefined && input.statuses.length === 0) {
       return { threads: [], hasMore: false, total: 0 };
@@ -6643,9 +7251,6 @@ class SqliteAgentStorage {
   connection;
   constructor(options) {
     this.connection = openSqliteStoreConnection(options);
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.connection.db);
-    }
     this.threads = new SqliteAgentThreadStore(this.connection.db);
     this.runs = new SqliteAgentRunStore(this.connection.db, options.executions);
     this.messages = new SqliteAgentMessageStore(this.connection.db);
@@ -6777,9 +7382,6 @@ class SqliteAiUsageStorage {
   connection;
   constructor(options = {}) {
     this.connection = openSqliteStoreConnection(options);
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.connection.db);
-    }
   }
   async recordModelCall(input) {
     const record = normalizeAiModelCallRecord(input);
@@ -7511,8 +8113,6 @@ class SqliteAiLimitStorage {
   connection;
   constructor(options = {}) {
     this.connection = openSqliteStoreConnection(options);
-    if (this.connection.installFreshSchema)
-      installFreshSqliteSchema(this.connection.db);
   }
   async createPolicy(input) {
     const policy = normalizeCreateAiLimitPolicy(input);
@@ -8045,6 +8645,185 @@ function isConstraintError(error) {
   return error instanceof Error && /constraint/i.test(error.message);
 }
 
+// src/artifact-storage.ts
+import {
+  artifactStorageErrors,
+  parseArtifactFrameGrantRow,
+  parseArtifactRow,
+  parseArtifactVersionRow
+} from "@sixb/core/internal/storage";
+var ARTIFACT_COLUMNS = `
+  project_id AS projectId, id, kind, title,
+  owner_principal_type AS ownerPrincipalType, owner_principal_id AS ownerPrincipalId,
+  latest_version AS latestVersion, created_at AS createdAt, updated_at AS updatedAt
+`;
+var VERSION_COLUMNS = `
+  project_id AS projectId, artifact_id AS artifactId, version, title, entry, files, outline, refs,
+  author_principal_type AS authorPrincipalType, author_principal_id AS authorPrincipalId,
+  origin_thread_id AS originThreadId, origin_run_id AS originRunId, created_at AS createdAt
+`;
+var FRAME_GRANT_COLUMNS = `
+  project_id AS projectId, token_hash AS tokenHash, artifact_id AS artifactId, version, targets,
+  created_at AS createdAt, expires_at AS expiresAt
+`;
+
+class SqliteArtifactStorage {
+  db;
+  constructor(connection) {
+    this.db = connection.db;
+  }
+  async create(input) {
+    return runImmediateTransaction(this.db, () => {
+      const createdAt = input.version.createdAt.toISOString();
+      const artifact = this.db.query(`INSERT INTO artifacts (
+            project_id, id, kind, title, owner_principal_type, owner_principal_id,
+            latest_version, next_version, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, 1, 2, ?, ?)
+          ON CONFLICT (project_id, id) DO NOTHING
+          RETURNING ${ARTIFACT_COLUMNS}`).get(input.projectId, input.id, input.kind, input.version.title, input.owner.type, input.owner.id, createdAt, createdAt);
+      if (!artifact)
+        throw artifactStorageErrors.exists(input.id);
+      return {
+        artifact: parseArtifactRow(artifact),
+        version: this.insertVersion(input.projectId, input.id, 1, input.version)
+      };
+    });
+  }
+  async publish(input) {
+    return runImmediateTransaction(this.db, () => {
+      const current = this.db.query("SELECT kind, next_version AS nextVersion FROM artifacts WHERE project_id = ? AND id = ?").get(input.projectId, input.artifactId);
+      if (!current)
+        throw artifactStorageErrors.notFound(input.artifactId);
+      if (current.kind !== input.kind) {
+        throw artifactStorageErrors.kindMismatch(input.artifactId, current.kind, input.kind);
+      }
+      const version = this.insertVersion(input.projectId, input.artifactId, current.nextVersion, input.version);
+      const artifact = this.db.query(`UPDATE artifacts
+           SET title = ?, latest_version = ?, next_version = ?, updated_at = ?
+           WHERE project_id = ? AND id = ?
+           RETURNING ${ARTIFACT_COLUMNS}`).get(input.version.title, version.version, version.version + 1, input.version.createdAt.toISOString(), input.projectId, input.artifactId);
+      return { artifact: parseArtifactRow(artifact), version };
+    });
+  }
+  async get(input) {
+    const row = this.db.query(`SELECT ${ARTIFACT_COLUMNS} FROM artifacts WHERE project_id = ? AND id = ?`).get(input.projectId, input.id);
+    return row ? parseArtifactRow(row) : null;
+  }
+  async list(input) {
+    const where = ["a.project_id = ?"];
+    const params = [input.projectId];
+    if (input.owner) {
+      where.push("a.owner_principal_type = ? AND a.owner_principal_id = ?");
+      params.push(input.owner.type, input.owner.id);
+    }
+    if (input.originThreadId !== undefined) {
+      where.push(`EXISTS (
+          SELECT 1 FROM artifact_versions v
+          WHERE v.project_id = a.project_id AND v.artifact_id = a.id AND v.origin_thread_id = ?
+        )`);
+      params.push(input.originThreadId);
+    }
+    if (input.kind !== undefined) {
+      where.push("a.kind = ?");
+      params.push(input.kind);
+    }
+    const clause = where.join(" AND ");
+    const { total } = this.db.query(`SELECT COUNT(*) AS total FROM artifacts a WHERE ${clause}`).get(...params);
+    const offset = input.offset ?? 0;
+    const rows = this.db.query(`SELECT ${ARTIFACT_COLUMNS} FROM artifacts a WHERE ${clause}
+         ORDER BY a.updated_at DESC, a.id ASC LIMIT ? OFFSET ?`).all(...params, input.limit ?? -1, offset);
+    return {
+      artifacts: rows.map(parseArtifactRow),
+      hasMore: offset + rows.length < total,
+      total
+    };
+  }
+  async getVersion(input) {
+    const row = this.db.query(`SELECT ${VERSION_COLUMNS} FROM artifact_versions
+         WHERE project_id = ? AND artifact_id = ? AND version = ?`).get(input.projectId, input.artifactId, input.version);
+    return row ? parseArtifactVersionRow(row) : null;
+  }
+  async listVersions(input) {
+    const { total } = this.db.query("SELECT COUNT(*) AS total FROM artifact_versions WHERE project_id = ? AND artifact_id = ?").get(input.projectId, input.artifactId);
+    const offset = input.offset ?? 0;
+    const rows = this.db.query(`SELECT ${VERSION_COLUMNS} FROM artifact_versions
+         WHERE project_id = ? AND artifact_id = ?
+         ORDER BY version DESC LIMIT ? OFFSET ?`).all(input.projectId, input.artifactId, input.limit ?? -1, offset);
+    return {
+      versions: rows.map(parseArtifactVersionRow),
+      hasMore: offset + rows.length < total,
+      total
+    };
+  }
+  async listReferencingVersions(input) {
+    const prefix = `artifact:${input.artifactId}`;
+    const rows = this.db.query(`SELECT ${VERSION_COLUMNS} FROM artifact_versions v
+         WHERE (project_id, artifact_id, version) IN (
+           SELECT project_id, id, latest_version FROM artifacts WHERE project_id = ?
+         ) AND EXISTS (
+           SELECT 1 FROM json_each(v.refs) r
+           WHERE substr(json_extract(r.value, '$.address'), 1, ?) = ?
+             AND substr(json_extract(r.value, '$.address'), ? + 1, 1) IN ('', '@', '/', '#')
+         )
+         ORDER BY artifact_id`).all(input.projectId, prefix.length, prefix, prefix.length);
+    return rows.map(parseArtifactVersionRow);
+  }
+  async createFrameGrant(record) {
+    runImmediateTransaction(this.db, () => {
+      const exists = this.db.query("SELECT 1 FROM artifacts WHERE project_id = ? AND id = ?").get(record.projectId, record.artifactId);
+      if (!exists)
+        throw artifactStorageErrors.notFound(record.artifactId);
+      this.db.query(`INSERT INTO artifact_frame_grants
+             (project_id, token_hash, artifact_id, version, targets, created_at, expires_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`).run(record.projectId, record.tokenHash, record.artifactId, record.version, JSON.stringify(record.targets), record.createdAt.toISOString(), record.expiresAt.toISOString());
+    });
+  }
+  async findFrameGrant(input) {
+    const row = this.db.query(`SELECT ${FRAME_GRANT_COLUMNS} FROM artifact_frame_grants
+         WHERE project_id = ? AND token_hash = ?`).get(input.projectId, input.tokenHash);
+    return row ? parseArtifactFrameGrantRow(row) : null;
+  }
+  async deleteExpiredFrameGrants(input) {
+    return this.db.query(`DELETE FROM artifact_frame_grants WHERE rowid IN (
+           SELECT rowid FROM artifact_frame_grants
+           WHERE project_id = ? AND expires_at < ?
+           ORDER BY expires_at LIMIT ?
+         )`).run(input.projectId, input.expiredBefore.toISOString(), input.limit).changes;
+  }
+  async delete(input) {
+    return this.db.query("DELETE FROM artifacts WHERE project_id = ? AND id = ?").run(input.projectId, input.id).changes > 0;
+  }
+  async deleteVersionsByOrigin(input) {
+    return runImmediateTransaction(this.db, () => {
+      const affected = this.db.query(`SELECT DISTINCT artifact_id AS artifactId FROM artifact_versions
+           WHERE project_id = ? AND origin_run_id = ?`).all(input.projectId, input.runId);
+      const deleted = this.db.query("DELETE FROM artifact_versions WHERE project_id = ? AND origin_run_id = ?").run(input.projectId, input.runId).changes;
+      for (const { artifactId } of affected) {
+        this.repointLatest(input.projectId, artifactId);
+      }
+      return deleted;
+    });
+  }
+  repointLatest(projectId, artifactId) {
+    const latest = this.db.query(`SELECT version, title, created_at AS createdAt FROM artifact_versions
+         WHERE project_id = ? AND artifact_id = ? ORDER BY version DESC LIMIT 1`).get(projectId, artifactId);
+    if (!latest) {
+      this.db.query("DELETE FROM artifacts WHERE project_id = ? AND id = ?").run(projectId, artifactId);
+      return;
+    }
+    this.db.query(`UPDATE artifacts SET title = ?, latest_version = ?, updated_at = ?
+         WHERE project_id = ? AND id = ?`).run(latest.title, latest.version, latest.createdAt, projectId, artifactId);
+  }
+  insertVersion(projectId, artifactId, version, input) {
+    const row = this.db.query(`INSERT INTO artifact_versions (
+          project_id, artifact_id, version, title, entry, files, outline, refs,
+          author_principal_type, author_principal_id, origin_thread_id, origin_run_id, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        RETURNING ${VERSION_COLUMNS}`).get(projectId, artifactId, version, input.title, input.entry, JSON.stringify(input.files), JSON.stringify(input.outline), JSON.stringify(input.references), input.author.type, input.author.id, input.origin?.threadId ?? null, input.origin?.runId ?? null, input.createdAt.toISOString());
+    return parseArtifactVersionRow(row);
+  }
+}
+
 // src/auth-storage/auth-storage.ts
 import { AuthStorageError as AuthStorageError11 } from "@sixb/core/storage";
 
@@ -8106,7 +8885,6 @@ function rowToSessionRecord(row) {
     projectId: row.project_id,
     userId: row.user_id,
     strategyId: row.strategy_id,
-    audience: row.audience,
     tokenHash: row.token_hash,
     createdAt: new Date(row.created_at),
     expiresAt: new Date(row.expires_at),
@@ -8179,7 +8957,6 @@ function rowToMagicLinkRecord(row) {
     id: row.id,
     projectId: row.project_id,
     strategyId: row.strategy_id,
-    audience: row.audience,
     email: row.email,
     tokenHash: row.token_hash,
     returnTo: row.return_to ?? undefined,
@@ -8194,7 +8971,6 @@ function rowToOidcAuthorizationAttemptRecord(row) {
     id: row.id,
     projectId: row.project_id,
     strategyId: row.strategy_id,
-    audience: row.audience,
     stateHash: row.state_hash,
     nonceHash: row.nonce_hash,
     codeVerifier: row.code_verifier,
@@ -8412,7 +9188,6 @@ function consumeOidcAttempt(db, params) {
 }
 function validateCompleteSessionInput(db, projectId, session) {
   const sessionId = assertNonEmpty(session.id, "Session id");
-  assertNonEmpty(session.audience, "Session audience");
   assertNonEmpty(session.tokenHash, "Session token hash");
   assertSessionIdAvailable(db, projectId, sessionId);
 }
@@ -8426,7 +9201,6 @@ function createSession(db, input) {
   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);
   db.query(`
@@ -8435,7 +9209,6 @@ function createSession(db, input) {
       id,
       user_id,
       strategy_id,
-      audience,
       token_hash,
       created_at,
       expires_at,
@@ -8445,8 +9218,8 @@ function createSession(db, input) {
       client_name,
       access_expires_at,
       refresh_token_hash
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(projectId, id, userId, strategyId, audience, tokenHash, toIso(input.createdAt), toIso(input.expiresAt), input.absoluteExpiresAt ? toIso(input.absoluteExpiresAt) : null, input.userAgent ?? null, input.ipAddress ?? null, input.bearer ? assertNonEmpty(input.bearer.clientName, "Session client name") : null, input.bearer ? toIso(input.bearer.accessExpiresAt) : null, input.bearer ? assertNonEmpty(input.bearer.refreshTokenHash, "Refresh token hash") : null);
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(projectId, id, userId, strategyId, tokenHash, toIso(input.createdAt), toIso(input.expiresAt), input.absoluteExpiresAt ? toIso(input.absoluteExpiresAt) : null, input.userAgent ?? null, input.ipAddress ?? null, input.bearer ? assertNonEmpty(input.bearer.clientName, "Session client name") : null, input.bearer ? toIso(input.bearer.accessExpiresAt) : null, input.bearer ? assertNonEmpty(input.bearer.refreshTokenHash, "Refresh token hash") : null);
   const session = getSessionById(db, { projectId, id });
   if (!session) {
     throw new AuthStorageError("missing_session", `[Sixb] Failed to load session '${id}' for project '${projectId}'.`);
@@ -8455,30 +9228,25 @@ function createSession(db, input) {
 }
 function revokeActiveSessionsForUser(db, params) {
   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(`
       SELECT *
       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);
+    `).all(params.projectId, params.userId, revokedAt, revokedAt);
   db.query(`
     UPDATE auth_sessions
     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({
     ...row,
     revoked_at: revokedAt
@@ -9056,7 +9824,6 @@ class SqliteAuthInvitationStore {
 }
 
 // src/auth-storage/magic-links.ts
-import { resolveAuthSessionAudience } from "@sixb/core";
 import { AuthStorageError as AuthStorageError5 } from "@sixb/core/storage";
 class SqliteAuthMagicLinkStore {
   db;
@@ -9068,7 +9835,6 @@ class SqliteAuthMagicLinkStore {
       const id = assertNonEmpty(input.id, "Magic link id");
       const projectId = assertNonEmpty(input.projectId, "Project id");
       const strategyId = assertNonEmpty(input.strategyId, "Strategy id");
-      const audience = resolveAuthSessionAudience(input.audience);
       const email = normalizeEmail(input.email);
       const tokenHash = assertNonEmpty(input.tokenHash, "Magic link token hash");
       if (getMagicLinkRowById(this.db, { projectId, id })) {
@@ -9085,14 +9851,13 @@ class SqliteAuthMagicLinkStore {
               project_id,
               id,
               strategy_id,
-              audience,
               email,
               token_hash,
               return_to,
               created_at,
               expires_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-          `).run(projectId, id, strategyId, audience, email, tokenHash, input.returnTo ?? null, toIso(input.createdAt), toIso(input.expiresAt));
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          `).run(projectId, id, strategyId, email, tokenHash, input.returnTo ?? null, toIso(input.createdAt), toIso(input.expiresAt));
       } catch (error) {
         mapUniqueConstraintError(error, "duplicate_magic_link", `[Sixb] Magic link '${id}' already exists for project '${projectId}'.`);
       }
@@ -9100,7 +9865,6 @@ class SqliteAuthMagicLinkStore {
         id,
         projectId,
         strategyId,
-        audience,
         email,
         tokenHash,
         returnTo: input.returnTo,
@@ -9135,7 +9899,6 @@ class SqliteAuthMagicLinkStore {
 }
 
 // src/auth-storage/oidc-attempts.ts
-import { resolveAuthSessionAudience as resolveAuthSessionAudience2 } from "@sixb/core";
 import { AuthStorageError as AuthStorageError6 } from "@sixb/core/storage";
 class SqliteAuthOidcAuthorizationAttemptStore {
   db;
@@ -9147,7 +9910,6 @@ class SqliteAuthOidcAuthorizationAttemptStore {
       const id = assertNonEmpty(input.id, "OIDC authorization attempt id");
       const projectId = assertNonEmpty(input.projectId, "Project id");
       const strategyId = assertNonEmpty(input.strategyId, "Strategy id");
-      const audience = resolveAuthSessionAudience2(input.audience);
       const stateHash = assertNonEmpty(input.stateHash, "OIDC state hash");
       const nonceHash = assertNonEmpty(input.nonceHash, "OIDC nonce hash");
       const codeVerifier = assertNonEmpty(input.codeVerifier, "OIDC code verifier");
@@ -9160,15 +9922,14 @@ class SqliteAuthOidcAuthorizationAttemptStore {
               project_id,
               id,
               strategy_id,
-              audience,
               state_hash,
               nonce_hash,
               code_verifier,
               return_to,
               created_at,
               expires_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-          `).run(projectId, id, strategyId, audience, stateHash, nonceHash, codeVerifier, input.returnTo ?? null, toIso(input.createdAt), toIso(input.expiresAt));
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `).run(projectId, id, strategyId, stateHash, nonceHash, codeVerifier, input.returnTo ?? null, toIso(input.createdAt), toIso(input.expiresAt));
       } catch (error) {
         mapUniqueConstraintError(error, "duplicate_oidc_attempt", `[Sixb] OIDC authorization attempt '${id}' already exists for project '${projectId}'.`);
       }
@@ -9176,7 +9937,6 @@ class SqliteAuthOidcAuthorizationAttemptStore {
         id,
         projectId,
         strategyId,
-        audience,
         stateHash,
         nonceHash,
         codeVerifier,
@@ -9395,21 +10155,6 @@ class SqliteAuthSessionStore {
   async getById(params) {
     return getSessionById(this.db, params);
   }
-  async getActiveByUserId(params) {
-    const row = this.db.query(`
-        SELECT *
-        FROM auth_sessions
-        WHERE project_id = ?
-          AND user_id = ?
-          AND audience = ?
-          AND revoked_at IS NULL
-          AND expires_at > ?
-          AND (absolute_expires_at IS NULL OR absolute_expires_at > ?)
-        ORDER BY created_at DESC, id DESC
-        LIMIT 1
-      `).get(params.projectId, params.userId, params.audience, toIso(params.now), toIso(params.now));
-    return row ? rowToSessionRecord(row) : null;
-  }
   async listActiveByUserId(params) {
     const rows = this.db.query(`
         SELECT *
@@ -9423,9 +10168,22 @@ class SqliteAuthSessionStore {
       `).all(params.projectId, params.userId, toIso(params.now), toIso(params.now));
     return rows.map(rowToSessionRecord);
   }
+  async listByUserId(params) {
+    const rows = this.db.query(`
+        SELECT *
+        FROM auth_sessions
+        WHERE project_id = ? AND user_id = ? AND created_at <= ?
+        ORDER BY created_at DESC, id DESC
+        LIMIT ? OFFSET ?
+      `).all(params.projectId, params.userId, params.before ? toIso(params.before.createdAt) : "9999-12-31T23:59:59.999Z", params.limit + 1, params.before?.skip ?? 0);
+    return {
+      sessions: rows.slice(0, params.limit).map(rowToSessionRecord),
+      hasMore: rows.length > params.limit
+    };
+  }
   async findValidByTokenHash(params) {
     const row = getSessionRowById(this.db, params);
-    if (!row || row.refresh_token_hash !== null || row.audience !== params.audience || row.token_hash !== params.tokenHash || !isLiveSessionRow(row, params.now)) {
+    if (!row || row.refresh_token_hash !== null || row.token_hash !== params.tokenHash || !isLiveSessionRow(row, params.now)) {
       return null;
     }
     return rowToSessionRecord(row);
@@ -9480,13 +10238,12 @@ class SqliteAuthSessionStore {
               last_seen_at = ?
           WHERE project_id = ?
             AND id = ?
-            AND audience = ?
             AND token_hash = ?
             AND refresh_token_hash IS NULL
             AND revoked_at IS NULL
             AND expires_at > ?
             AND (absolute_expires_at IS NULL OR absolute_expires_at > ?)
-        `).run(expiresAt, expiresAt, now, params.projectId, params.id, params.audience, params.tokenHash, now, now);
+        `).run(expiresAt, expiresAt, now, params.projectId, params.id, params.tokenHash, now, now);
       return result.changes === 0 ? null : getSessionById(this.db, params);
     });
   }
@@ -9679,9 +10436,6 @@ class SqliteAuthStorage {
   constructor(options = {}) {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db);
-    }
     this.users = new SqliteAuthUserStore(this.db);
     this.identities = new SqliteAuthUserIdentityStore(this.db);
     this.serviceAccounts = new SqliteAuthServiceAccountStore(this.db);
@@ -9760,7 +10514,6 @@ class SqliteAuthStorage {
         };
       }
       validateCompleteSessionInput(this.db, projectId, input.session);
-      assertSignInSessionAudience(projectId, input.session.audience, magicLink.audience);
       let newUserId;
       if (shouldCreateUser) {
         newUserId = assertNonEmpty(input.newUserId, "User id");
@@ -9857,7 +10610,6 @@ class SqliteAuthStorage {
         };
       }
       validateCompleteSessionInput(this.db, projectId, input.session);
-      assertSignInSessionAudience(projectId, input.session.audience, attempt.audience);
       let newUserId;
       if (shouldCreateUser) {
         newUserId = assertNonEmpty(input.newUserId, "User id");
@@ -10076,7 +10828,6 @@ class SqliteAuthStorage {
       projectId: input.projectId,
       userId: input.userId,
       strategyId: input.strategyId,
-      audience: input.session.audience,
       tokenHash: input.session.tokenHash,
       createdAt: input.session.createdAt,
       expiresAt: input.session.expiresAt,
@@ -10121,12 +10872,6 @@ class SqliteAuthStorage {
     });
   }
 }
-function assertSignInSessionAudience(projectId, sessionAudience, storedAudience) {
-  if (sessionAudience === storedAudience) {
-    return;
-  }
-  throw new AuthStorageError11("invalid_input", `[Sixb] Sign-in session audience '${sessionAudience}' does not match stored auth audience '${storedAudience}' for project '${projectId}'.`);
-}
 function assertCompletableDeviceAuthorization(authorization, input) {
   if (authorization.deviceCodeHash !== input.deviceCodeHash) {
     throw new AuthStorageError11("invalid_device_authorization", "[Sixb] Invalid device authorization.");
@@ -10194,7 +10939,7 @@ class SqliteConnectorConnectionPersistence {
             callback_binding_hash, reauthorization_id, reauthorization_revision,
             reauthorization_connection_ids, created_at, expires_at
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(record.projectId, record.connectorId, record.id, record.slot, record.initiatedByExecutionId, record.stateHash, record.codeVerifier === undefined ? null : json(record.codeVerifier), record.redirectUri, record.connectionRunId ?? null, record.returnTo ?? null, record.callbackBindingHash ?? null, record.reauthorizationId ?? null, record.reauthorizationRevision ?? null, record.reauthorizationConnectionIds ? json(record.reauthorizationConnectionIds) : null, iso(record.createdAt), iso(record.expiresAt));
+        `).run(record.projectId, record.connectorId, record.id, record.slot, record.initiatedByExecutionId, record.stateHash, record.codeVerifier === undefined ? null : json(record.codeVerifier), record.redirectUri, record.connectionRunId ?? null, record.returnTo ?? null, record.callbackBindingHash ?? null, record.reauthorizationId ?? null, record.reauthorizationRevision ?? null, record.reauthorizationConnectionIds ? json(record.reauthorizationConnectionIds) : null, iso2(record.createdAt), iso2(record.expiresAt));
       return true;
     } catch (error) {
       if (isUniqueConstraintError(error))
@@ -10285,7 +11030,7 @@ class SqliteConnectorConnectionPersistence {
             project_id, connector_id, id, authorization_id, slot, account,
             account_id, status, disconnected_at, created_at, updated_at
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(record.projectId, record.connectorId, record.id, record.authorizationId, record.slot, json(record.account), record.account.id, record.status, optionalIso(record.disconnectedAt), iso(record.createdAt), iso(record.updatedAt));
+        `).run(record.projectId, record.connectorId, record.id, record.authorizationId, record.slot, json(record.account), record.account.id, record.status, optionalIso(record.disconnectedAt), iso2(record.createdAt), iso2(record.updatedAt));
       return true;
     } catch (error) {
       if (isUniqueConstraintError(error))
@@ -10337,7 +11082,7 @@ class SqliteConnectorConnectionPersistence {
         SET authorization_id = ?, slot = ?, account = ?, account_id = ?,
             status = ?, disconnected_at = ?, updated_at = ?
         WHERE project_id = ? AND connector_id = ? AND id = ?
-      `).run(record.authorizationId, record.slot, json(record.account), record.account.id, record.status, optionalIso(record.disconnectedAt), iso(record.updatedAt), record.projectId, record.connectorId, record.id);
+      `).run(record.authorizationId, record.slot, json(record.account), record.account.id, record.status, optionalIso(record.disconnectedAt), iso2(record.updatedAt), record.projectId, record.connectorId, record.id);
     assertChanged(result.changes, "connector connection", record.id);
   }
   insertRun(record) {
@@ -10349,7 +11094,7 @@ class SqliteConnectorConnectionPersistence {
           expires_at, authorization_id, cleanup_authorization_id, connections, error,
           created_at, updated_at, finished_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(record.projectId, record.connectorId, record.id, ...values.slice(0, -2), iso(record.createdAt), ...values.slice(-2));
+      `).run(record.projectId, record.connectorId, record.id, ...values.slice(0, -2), iso2(record.createdAt), ...values.slice(-2));
   }
   insertAuthorizationRow(record) {
     const values = authorizationValues(record);
@@ -10361,7 +11106,7 @@ class SqliteConnectorConnectionPersistence {
           mutation_expected_connection_ids, staged_credentials, staged_credential_expires_at,
           staged_scopes, created_at, updated_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(record.projectId, record.connectorId, record.id, ...values.slice(0, -1), iso(record.createdAt), ...values.slice(-1));
+      `).run(record.projectId, record.connectorId, record.id, ...values.slice(0, -1), iso2(record.createdAt), ...values.slice(-1));
   }
   getById(table, id) {
     if (this.scope.connectorId) {
@@ -10398,13 +11143,13 @@ function authorizationAttemptFromRow(row) {
 function runValues(record) {
   const waitingFor = record.status === "waiting" ? record.waitingFor : null;
   const processingId = record.status === "running" ? record.processingId : null;
-  const callbackStartedAt = record.status === "running" ? iso(record.callbackStartedAt) : null;
-  const expiresAt = record.status === "waiting" || record.status === "running" ? iso(record.expiresAt) : null;
+  const callbackStartedAt = record.status === "running" ? iso2(record.callbackStartedAt) : null;
+  const expiresAt = record.status === "waiting" || record.status === "running" ? iso2(record.expiresAt) : null;
   const authorizationId = "authorizationId" in record ? record.authorizationId ?? null : null;
   const cleanupAuthorizationId = record.status === "succeeded" ? record.cleanupAuthorizationId ?? null : null;
   const connections = record.status === "succeeded" ? json(record.connections) : null;
   const error = record.status === "failed" ? json(record.error) : null;
-  const finishedAt = record.status === "succeeded" || record.status === "failed" || record.status === "cancelled" || record.status === "expired" ? iso(record.finishedAt) : null;
+  const finishedAt = record.status === "succeeded" || record.status === "failed" || record.status === "cancelled" || record.status === "expired" ? iso2(record.finishedAt) : null;
   return [
     record.kind,
     record.slot,
@@ -10418,7 +11163,7 @@ function runValues(record) {
     cleanupAuthorizationId,
     connections,
     error,
-    iso(record.updatedAt),
+    iso2(record.updatedAt),
     finishedAt
   ];
 }
@@ -10521,7 +11266,7 @@ function authorizationValues(record) {
     staged ? json(staged.credentials) : null,
     optionalIso(staged?.credentialExpiresAt),
     staged ? json(staged.scopes) : null,
-    iso(record.updatedAt)
+    iso2(record.updatedAt)
   ];
 }
 function authorizationFromRow(row) {
@@ -10596,7 +11341,7 @@ function json(value) {
 function parseJson(value) {
   return JSON.parse(value);
 }
-function iso(value) {
+function iso2(value) {
   return value.toISOString();
 }
 function optionalIso(value) {
@@ -10618,6 +11363,7 @@ function assertChanged(changes, label, id) {
 
 // src/execution-storage.ts
 import {
+  compareExecutionCreation,
   executionRecordFromStorageRow,
   executionRecordToStorageRow,
   prepareExecutionRecord
@@ -10684,6 +11430,39 @@ class SqliteExecutionStorage {
       `).get(params.projectId, params.id);
     return row ? sqliteExecutionRecord(row) : null;
   }
+  async listBySession(input) {
+    const sessionColumn = input.session.type === "user" ? "authority_session_id" : "authority_delegation_session_id";
+    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);
+    const kept = rows.slice(0, input.limit).map(sqliteExecutionRecord);
+    return {
+      executions: kept.sort(compareExecutionCreation),
+      truncated: rows.length > input.limit
+    };
+  }
 }
 function sqliteExecutionRecord(row) {
   return executionRecordFromStorageRow(toStorageRow(row));
@@ -12785,9 +13564,6 @@ class SqliteObjectStorage {
     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() {
     return SQLITE_OBJECT_QUERY_CAPABILITIES;
@@ -15822,6 +16598,26 @@ class SqliteOntologySourceStorage {
       return row ? sourceRecord(row) : null;
     });
   }
+  async listActive(input) {
+    return this.runRootOperation(() => {
+      assertNonblank(input.projectId, "Source project id");
+      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);
+      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) {
     return this.runRootOperation(() => {
       assertProjectAndSource(input);
@@ -16330,9 +17126,6 @@ class SqlitePipelineRunStorage {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
     this.executions = options.executions;
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db);
-    }
   }
   async queue(input) {
     const queuedAt = input.queuedAt ?? new Date;
@@ -16678,9 +17471,6 @@ class SqliteProjectionRunStorage {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
     this.executions = options.executions;
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db);
-    }
   }
   async queue(input) {
     assertProjectionRunQueueInput(input);
@@ -17124,9 +17914,6 @@ class SqliteRulesStorage {
   constructor(options = {}) {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db);
-    }
   }
   async getActive(params) {
     const row = this.db.query(`
@@ -17372,8 +18159,6 @@ class SqliteShareGrantStorage {
   constructor(options = {}) {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
-    if (this.connection.installFreshSchema)
-      installFreshSqliteSchema(this.db);
   }
   async create(input) {
     const record = normalizeShareGrantCreate(input);
@@ -17397,6 +18182,23 @@ class SqliteShareGrantStorage {
     const normalized = normalizeGetShareGrantByIdInput(input);
     return this.getRow(normalized.projectId, normalized.id);
   }
+  async getByIds(input) {
+    const ids = [...new Set(input.ids)];
+    if (ids.length === 0) {
+      return [];
+    }
+    const rows = this.db.query(`
+        SELECT *
+        FROM share_grants
+        WHERE project_id = ?
+          AND id IN (SELECT value FROM json_each(?))
+      `).all(input.projectId, JSON.stringify(ids));
+    const byId = new Map(rows.map((row) => [row.id, row]));
+    return ids.flatMap((id) => {
+      const row = byId.get(id);
+      return row ? [rowToRecord(row)] : [];
+    });
+  }
   async list(input) {
     const normalized = normalizeListShareGrantsInput(input);
     const where = ["project_id = ?"];
@@ -17518,8 +18320,6 @@ class SqliteShareSessionStorage {
   constructor(options = {}) {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
-    if (this.connection.installFreshSchema)
-      installFreshSqliteSchema(this.db);
   }
   async create(input) {
     const record = normalizeShareSessionCreate(input);
@@ -17622,9 +18422,6 @@ class SqliteSyncRunStorage {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
     this.executions = options.executions;
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db);
-    }
   }
   async queue(input) {
     const queuedAt = input.queuedAt ?? new Date;
@@ -17834,9 +18631,6 @@ class SqliteTimeseriesStorage {
   constructor(options = {}) {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db);
-    }
   }
   async getHistory(params) {
     let query = `
@@ -17963,8 +18757,6 @@ class SqliteWebhookRunStorage {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
     this.executions = options.executions;
-    if (this.connection.installFreshSchema)
-      installFreshSqliteSchema(this.db);
   }
   async start(input) {
     const startedAt = input.startedAt ?? new Date;
@@ -18110,9 +18902,6 @@ class SqliteWorkflowInterventionStorage {
   constructor(options = {}) {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db);
-    }
   }
   async create(input) {
     assertNonNegativeInteger(input.nodeIndex, "nodeIndex");
@@ -18347,9 +19136,6 @@ class SqliteWorkflowRunStorage {
     this.connection = openSqliteStoreConnection(options);
     this.db = this.connection.db;
     this.executions = options.executions;
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db);
-    }
     this.nodes = new SqliteWorkflowNodeRunStorage(this.db);
     this.agentNodes = new SqliteWorkflowAgentNodeRunStorage(this.db, this.executions);
   }
@@ -18499,6 +19285,23 @@ class SqliteWorkflowRunStorage {
     const row = this.db.query("SELECT * FROM workflow_runs WHERE project_id = ? AND id = ?").get(params.projectId, params.id);
     return row ? rowToWorkflowRunRecord(row) : null;
   }
+  async getByExecutionIds(params) {
+    const executionIds = [...new Set(params.executionIds)];
+    if (executionIds.length === 0) {
+      return [];
+    }
+    const rows = this.db.query(`
+        SELECT *
+        FROM workflow_runs
+        WHERE project_id = ?
+          AND execution_id IN (SELECT value FROM json_each(?))
+      `).all(params.projectId, JSON.stringify(executionIds));
+    const byExecution = new Map(rows.map((row) => [row.execution_id, row]));
+    return executionIds.flatMap((executionId) => {
+      const row = byExecution.get(executionId);
+      return row ? [rowToWorkflowRunRecord(row)] : [];
+    });
+  }
   async list(input) {
     if (hasEmptyStatuses(input) || input.workflowIds?.length === 0) {
       return {
@@ -18964,6 +19767,7 @@ class SqliteStorage {
   auth;
   executions;
   agents;
+  artifacts;
   aiUsage;
   aiCosts;
   aiLimits;
@@ -18981,6 +19785,7 @@ class SqliteStorage {
   connectorConnections;
   fileUploadSessions;
   fileDownloadGrants;
+  activity;
   migrators;
   connection;
   readConnection;
@@ -18995,9 +19800,6 @@ class SqliteStorage {
     } else {
       this.readConnection = this.connection;
     }
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.connection.db);
-    }
     const stores = createSqliteStores(this.connection, {
       runOntologyOperation: async (run) => run(),
       transactionContext: null
@@ -19016,6 +19818,7 @@ class SqliteStorage {
     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);
@@ -19033,6 +19836,7 @@ class SqliteStorage {
     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) => stores.connectorConnections.advanceTimeForTesting(durationMs),
@@ -19090,8 +19894,7 @@ class SqliteStorage {
     return {
       ...createSqliteStores({
         db: this.connection.db,
-        ownsConnection: false,
-        installFreshSchema: false
+        ownsConnection: false
       }, {
         runOntologyOperation: async (run) => run(),
         transactionContext
@@ -19146,6 +19949,7 @@ function createSqliteStores(connection, options) {
     auth,
     executions,
     agents: new SqliteAgentStorage({ connection, executions }),
+    artifacts: new SqliteArtifactStorage(connection),
     aiUsage: new SqliteAiUsageStorage({ connection }),
     aiCosts: new SqliteAiCostStorage(connection),
     aiLimits: new SqliteAiLimitStorage({ connection }),
@@ -19162,7 +19966,8 @@ function createSqliteStores(connection, options) {
     shareSessions,
     connectorConnections: new SqliteConnectorConnectionStorage(connection),
     fileUploadSessions: new SqliteFileUploadSessionStorage(connection),
-    fileDownloadGrants: new SqliteFileDownloadGrantStorage(connection)
+    fileDownloadGrants: new SqliteFileDownloadGrantStorage(connection),
+    activity: new SqliteActivityStorage(connection)
   };
 }
 export {
@@ -19170,4 +19975,4 @@ export {
   migrateSqliteStorage
 };
 
-//# debugId=682E7F57F0A7280864756E2164756E21
+//# debugId=B9F8223963B8B3F664756E2164756E21