@sixb/sqlite 0.1.21 → 0.1.22

package/src/migrations/078-subagent-threads.sql

@@ -0,0 +1,241 @@
+-- A sub-agent works in a thread of its own: its task and its work are that thread's messages, and
+-- each of its runs has the thread and a trigger message, as a turn does. The thread's parent is the
+-- conversation, which every read of it goes through, and its spawning turn and key name it.
+--
+-- SQLite adds neither a foreign key nor a check with ALTER TABLE: both tables are rebuilt, as 033
+-- rebuilt `agent_runs`. Their references use the final names.
+
+-- The children admitted before this have no thread. Each gets one named as a new child's is, with
+-- its task as the only message: what it answered stays in its parent's `wait_agent` output.
+CREATE TEMP TABLE legacy_subagent_threads AS
+SELECT
+  child.project_id,
+  child.id AS run_id,
+  'agt_thr_child_' || CASE
+    WHEN substr(child.id, 1, 14) = 'agt_run_child_' THEN substr(child.id, 15)
+    ELSE child.id
+  END AS thread_id,
+  'agt_msg_child_' || CASE
+    WHEN substr(child.id, 1, 14) = 'agt_run_child_' THEN substr(child.id, 15)
+    ELSE child.id
+  END AS message_id
+FROM agent_runs AS child
+WHERE child.kind = 'subagent' AND child.thread_id IS NULL;
+
+CREATE TABLE agent_threads_v2 (
+  project_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  kind TEXT NOT NULL DEFAULT 'conversation' CHECK (kind IN ('conversation', 'subagent')),
+  parent_thread_id TEXT,
+  parent_run_id TEXT,
+  spawn_key TEXT,
+  owner_principal_type TEXT NOT NULL,
+  owner_principal_id TEXT NOT NULL,
+  title TEXT,
+  status TEXT NOT NULL CHECK (status IN ('active', 'archived')),
+  active_run_id TEXT,
+  last_message_at TEXT,
+  message_count INTEGER NOT NULL DEFAULT 0 CHECK (message_count >= 0),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  sandbox_params TEXT CHECK (
+    sandbox_params IS NULL
+    OR (json_valid(sandbox_params) AND json_type(sandbox_params) = 'object')
+  ),
+  sandbox_state TEXT CHECK (
+    sandbox_state IS NULL
+    OR (json_valid(sandbox_state) AND json_type(sandbox_state) = 'object')
+  ),
+  PRIMARY KEY (project_id, id),
+  UNIQUE (project_id, parent_run_id, spawn_key),
+  -- A conversation's sub-agent threads go with it.
+  FOREIGN KEY (project_id, parent_thread_id)
+    REFERENCES agent_threads (project_id, id)
+    ON DELETE CASCADE,
+  FOREIGN KEY (project_id, parent_run_id)
+    REFERENCES agent_runs (project_id, id)
+    ON DELETE RESTRICT,
+  CHECK (
+    (
+      kind = 'conversation'
+      AND parent_thread_id IS NULL
+      AND parent_run_id IS NULL
+      AND spawn_key IS NULL
+    )
+    OR
+    (
+      kind = 'subagent'
+      AND parent_thread_id IS NOT NULL
+      AND parent_run_id IS NOT NULL
+      AND spawn_key IS NOT NULL
+      AND sandbox_params IS NULL
+    )
+  )
+);
+
+INSERT INTO agent_threads_v2 (
+  project_id, id, owner_principal_type, owner_principal_id, title, status, active_run_id,
+  last_message_at, message_count, created_at, updated_at, sandbox_params, sandbox_state
+)
+SELECT
+  project_id, id, owner_principal_type, owner_principal_id, title, status, active_run_id,
+  last_message_at, message_count, created_at, updated_at, sandbox_params, sandbox_state
+FROM agent_threads;
+
+INSERT INTO agent_threads_v2 (
+  project_id, id, kind, parent_thread_id, parent_run_id, spawn_key, owner_principal_type,
+  owner_principal_id, status, active_run_id, last_message_at, message_count, created_at,
+  updated_at
+)
+SELECT
+  child.project_id,
+  legacy.thread_id,
+  'subagent',
+  parent.thread_id,
+  child.parent_run_id,
+  child.spawn_key,
+  conversation.owner_principal_type,
+  conversation.owner_principal_id,
+  'active',
+  CASE WHEN child.status IN ('queued', 'running') THEN child.id END,
+  child.created_at,
+  1,
+  child.created_at,
+  COALESCE(child.completed_at, child.created_at)
+FROM legacy_subagent_threads AS legacy
+JOIN agent_runs AS child ON child.project_id = legacy.project_id AND child.id = legacy.run_id
+JOIN agent_runs AS parent
+  ON parent.project_id = child.project_id AND parent.id = child.parent_run_id
+JOIN agent_threads AS conversation
+  ON conversation.project_id = parent.project_id AND conversation.id = parent.thread_id;
+
+DROP TABLE agent_threads;
+ALTER TABLE agent_threads_v2 RENAME TO agent_threads;
+
+-- Lists read conversations only, so a conversation's children never weigh on them.
+CREATE INDEX idx_agent_threads_project_activity
+  ON agent_threads(project_id, COALESCE(last_message_at, created_at) DESC)
+  WHERE kind = 'conversation';
+CREATE INDEX idx_agent_threads_project_status_activity
+  ON agent_threads(project_id, status, COALESCE(last_message_at, created_at) DESC)
+  WHERE kind = 'conversation';
+CREATE INDEX idx_agent_threads_project_owner_activity
+  ON agent_threads(
+    project_id,
+    owner_principal_type,
+    owner_principal_id,
+    COALESCE(last_message_at, created_at) DESC
+  )
+  WHERE kind = 'conversation';
+
+-- A conversation's children, in the order they were spawned. Only a child has a parent, so the
+-- index holds children only, and a read by `parent_thread_id` can use it.
+CREATE INDEX idx_agent_threads_children
+  ON agent_threads(project_id, parent_thread_id, created_at, id)
+  WHERE parent_thread_id IS NOT NULL;
+
+INSERT INTO agent_messages (
+  project_id, id, thread_id, run_id, role, seq, parts, content_version, created_at
+)
+SELECT
+  child.project_id,
+  legacy.message_id,
+  legacy.thread_id,
+  child.id,
+  'user',
+  1,
+  json_array(json_object('type', 'text', 'text', json_extract(child.spec, '$.task'))),
+  2,
+  child.created_at
+FROM legacy_subagent_threads AS legacy
+JOIN agent_runs AS child ON child.project_id = legacy.project_id AND child.id = legacy.run_id;
+
+CREATE TABLE agent_runs_v6 (
+  project_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  execution_id TEXT NOT NULL,
+  kind TEXT NOT NULL DEFAULT 'conversation' CHECK (kind IN ('conversation', 'subagent')),
+  thread_id TEXT,
+  trigger_message_id TEXT,
+  parent_run_id TEXT,
+  spawn_key TEXT,
+  spec TEXT CHECK (spec IS NULL OR json_valid(spec)),
+  result TEXT CHECK (result IS NULL OR json_valid(result)),
+  status TEXT NOT NULL CHECK (
+    status IN ('queued', 'running', 'succeeded', 'failed', 'cancelled')
+  ),
+  model_id TEXT,
+  finish_reason TEXT,
+  error TEXT CHECK (error IS NULL OR json_valid(error)),
+  diagnostics TEXT,
+  attempt INTEGER NOT NULL DEFAULT 0 CHECK (attempt >= 0),
+  execution_token TEXT,
+  execution_queue_lease_expires_at TEXT,
+  created_at TEXT NOT NULL,
+  started_at TEXT,
+  completed_at TEXT,
+  PRIMARY KEY (project_id, id),
+  UNIQUE (project_id, execution_id),
+  UNIQUE (project_id, parent_run_id, spawn_key),
+  FOREIGN KEY (project_id, execution_id)
+    REFERENCES executions (project_id, id)
+    ON DELETE RESTRICT,
+  FOREIGN KEY (project_id, parent_run_id)
+    REFERENCES agent_runs (project_id, id)
+    ON DELETE RESTRICT,
+  CHECK ((execution_token IS NULL) = (execution_queue_lease_expires_at IS NULL)),
+  CHECK (
+    (
+      kind = 'conversation'
+      AND thread_id IS NOT NULL
+      AND trigger_message_id IS NOT NULL
+      AND parent_run_id IS NULL
+      AND spawn_key IS NULL
+      AND result IS NULL
+    )
+    OR
+    (
+      kind = 'subagent'
+      AND thread_id IS NOT NULL
+      AND trigger_message_id IS NOT NULL
+      AND parent_run_id IS NOT NULL
+      AND spawn_key IS NOT NULL
+      AND spec IS NOT NULL
+    )
+  ),
+  CHECK (kind <> 'subagent' OR status <> 'succeeded' OR result IS NOT NULL)
+);
+
+INSERT INTO agent_runs_v6 (
+  project_id, id, execution_id, kind, thread_id, trigger_message_id, parent_run_id, spawn_key,
+  spec, result, status, model_id, finish_reason, error, diagnostics, attempt, execution_token,
+  execution_queue_lease_expires_at, created_at, started_at, completed_at
+)
+SELECT
+  run.project_id, run.id, run.execution_id, run.kind,
+  COALESCE(run.thread_id, legacy.thread_id),
+  COALESCE(run.trigger_message_id, legacy.message_id),
+  run.parent_run_id, run.spawn_key, run.spec, run.result, run.status, run.model_id,
+  run.finish_reason, run.error, run.diagnostics, run.attempt, run.execution_token,
+  run.execution_queue_lease_expires_at, run.created_at, run.started_at, run.completed_at
+FROM agent_runs AS run
+LEFT JOIN legacy_subagent_threads AS legacy
+  ON legacy.project_id = run.project_id AND legacy.run_id = run.id;
+
+DROP TABLE agent_runs;
+ALTER TABLE agent_runs_v6 RENAME TO agent_runs;
+
+CREATE INDEX idx_agent_runs_project_thread_started
+  ON agent_runs (project_id, thread_id, COALESCE(started_at, created_at) DESC, id DESC);
+CREATE INDEX idx_agent_runs_project_status_created
+  ON agent_runs (project_id, status, created_at, id);
+CREATE INDEX idx_agent_runs_project_parent_started
+  ON agent_runs (
+    project_id,
+    parent_run_id,
+    status,
+    COALESCE(started_at, created_at) DESC,
+    id DESC
+  );
+
+DROP TABLE legacy_subagent_threads;

package/src/migrations/079-subagent-questions.sql

@@ -0,0 +1,6 @@
+-- A child that pauses on its question waits for a later turn of its parent's conversation to
+-- answer it. Each turn reads which of the conversation's children wait so: few do, so a partial
+-- index keeps that read small however many children the conversation had.
+CREATE INDEX idx_agent_runs_paused_on_question
+  ON agent_runs (project_id, parent_run_id)
+  WHERE kind = 'subagent' AND finish_reason = 'awaiting_answer';

package/src/migrations.ts

@@ -278,6 +278,39 @@ export const sqliteStorageMigrations = defineMigrations({
     sqliteSql("064-activity", activitySql),
     sqliteSql("065-activity-timeline", activityTimelineSql),
     sqliteSql("066-activity-interactions", activityInteractionsSql),
+    sqliteSql("067-artifact-kinds", artifactKindsSql),
+    sqliteSql("068-artifact-state", artifactStateSql),
+    sqliteSql("069-agent-thread-participants", agentThreadParticipantsSql),
+    sqliteSql("070-forked-context-checkpoints", forkedContextCheckpointsSql),
+    sqliteSql("071-unique-values", uniqueValuesSql),
+    sqliteSql("072-generated-media-usage", generatedMediaUsageSql),
+    sqliteSql("073-model-call-files", modelCallFilesSql),
+    sqliteSql("074-agent-memory", agentMemorySql),
+    sqliteSql("075-artifact-threads", artifactThreadsSql),
+    sqliteSql("076-agent-approvals", agentApprovalsSql),
+    sqliteSql("077-agent-approval-resume", agentApprovalResumeSql),
+    sqliteStep(
+      "078-subagent-threads",
+      (db) => {
+        // Bun runs a script past a statement that fails and reports only the last one's error, so
+        // a refused copy would go unnoticed and the rebuild would drop the rows: count around it.
+        const before = subagentThreadCounts(db)
+        db.run(subagentThreadsSql)
+        const after = subagentThreadCounts(db)
+        if (
+          after.runs !== before.runs ||
+          after.threads !== before.threads + before.threadless ||
+          after.messages !== before.messages + before.threadless ||
+          after.threadless !== 0
+        ) {
+          throw new Error(
+            "[SixbSqliteStorage] Agent runs, threads or messages were lost while giving sub-agents their threads."
+          )
+        }
+      },
+      { checksum: checksum(subagentThreadsSql) }
+    ),
+    sqliteSql("079-subagent-questions", subagentQuestionsSql),
   ],
 })
 
@@ -323,7 +356,7 @@ export function freshSqliteDatabase(): Database {
   return Database.deserialize(freshSchema)
 }
 
-export function installFreshSqliteSchema(db: Database): void {
+function installFreshSqliteSchema(db: Database): void {
   for (const migration of sqliteStorageMigrations.steps) {
     const installed = migration.up(db)
     if (installed instanceof Promise) {
@@ -468,6 +501,26 @@ function sourceStorageCounts(db: Database): {
     .get() as { readonly versions: number; readonly roots: number; readonly rows: number }
 }
 
+function subagentThreadCounts(db: Database): {
+  readonly runs: number
+  readonly threads: number
+  readonly messages: number
+  /** Child runs without a thread. */
+  readonly threadless: number
+} {
+  return db
+    .query(`SELECT (SELECT count(*) FROM agent_runs) AS runs,
+      (SELECT count(*) FROM agent_threads) AS threads,
+      (SELECT count(*) FROM agent_messages) AS messages,
+      (SELECT count(*) FROM agent_runs WHERE kind = 'subagent' AND thread_id IS NULL) AS threadless`)
+    .get() as {
+    readonly runs: number
+    readonly threads: number
+    readonly messages: number
+    readonly threadless: number
+  }
+}
+
 /**
  * Stored events that would not rebuild exactly from their commit and execution. Who asked and what
  * wrote are derived from the execution exactly as 047 derived the commit's copies; both sides were
@@ -635,3 +688,24 @@ import activityTimelineSql from "./migrations/065-activity-timeline.sql" with {
 import activityInteractionsSql from "./migrations/066-activity-interactions.sql" with {
   type: "text",
 }
+import artifactKindsSql from "./migrations/067-artifact-kinds.sql" with { type: "text" }
+import artifactStateSql from "./migrations/068-artifact-state.sql" with { type: "text" }
+import agentThreadParticipantsSql from "./migrations/069-agent-thread-participants.sql" with {
+  type: "text",
+}
+import forkedContextCheckpointsSql from "./migrations/070-forked-context-checkpoints.sql" with {
+  type: "text",
+}
+import uniqueValuesSql from "./migrations/071-unique-values.sql" with { type: "text" }
+import generatedMediaUsageSql from "./migrations/072-generated-media-usage.sql" with {
+  type: "text",
+}
+import modelCallFilesSql from "./migrations/073-model-call-files.sql" with { type: "text" }
+import agentMemorySql from "./migrations/074-agent-memory.sql" with { type: "text" }
+import artifactThreadsSql from "./migrations/075-artifact-threads.sql" with { type: "text" }
+import agentApprovalsSql from "./migrations/076-agent-approvals.sql" with { type: "text" }
+import agentApprovalResumeSql from "./migrations/077-agent-approval-resume.sql" with {
+  type: "text",
+}
+import subagentThreadsSql from "./migrations/078-subagent-threads.sql" with { type: "text" }
+import subagentQuestionsSql from "./migrations/079-subagent-questions.sql" with { type: "text" }

package/src/objects/README.md

@@ -4,6 +4,13 @@
 paths. The selected reader holds its traversal-budget probe and terminal statements on one WAL
 snapshot. SQL must filter by those relations before ranking or limiting results.
 
+A conditional scope needs no traversal: `_sixb_scope_objects` keeps an object of a conditioned type
+while its condition matches, and `_sixb_scope_links` a link while each conditioned endpoint is such an
+object. Both are `NOT MATERIALIZED`, so statements keep their index seeks and `LIMIT`. A statement
+that reads one type (`start`, `list` of one type, `getByPrimaryId`) reads the stored table with that
+type's own condition instead: the disjunction over every conditioned type would keep unconditioned
+types off covering indexes and the condition out of reach of an index.
+
 SQLite flattens CTEs. Expose identity columns from the grant/visible relation and put authorized
 parents before indexed lookups with `CROSS JOIN`; exposing stored identities can cause a full
 grant scan per traversed edge. The query-plan regression test checks those lookups.

package/src/objects/conditional-reader.ts

@@ -0,0 +1,27 @@
+import type { Database } from "bun:sqlite"
+import type {
+  CompiledConditionalObjectReadScope,
+  ObjectQueryCapabilities,
+  ObjectReadStorage,
+} from "@sixb/core/storage"
+import { compileSqliteConditionalObjectReadSource } from "./read-scope"
+import { createSqliteScopedReader } from "./scoped-reader"
+
+/** Read objects and links through relations that apply the scope's conditions as they are read. */
+export function createSqliteConditionalReader(
+  db: Database,
+  params: {
+    projectId: string
+    scope: CompiledConditionalObjectReadScope
+  },
+  queryCapabilities: () => ObjectQueryCapabilities
+): ObjectReadStorage {
+  return createSqliteScopedReader(
+    db,
+    {
+      projectId: params.projectId,
+      source: compileSqliteConditionalObjectReadSource(params.projectId, params.scope),
+    },
+    queryCapabilities
+  )
+}

package/src/objects/query-compiler.ts

@@ -118,6 +118,12 @@ export interface SqliteObjectQuerySource {
   readonly objectsTable: string
   readonly linksTable: string
   readonly objectPropertyPermissionsTable?: string
+  /**
+   * Where to read one concrete type's objects, when the source can say it more precisely than
+   * `objectsTable`: a table and that type's own filter over its `properties`. A statement that
+   * reads a single type then holds the filter as a top-level condition, which an index can serve.
+   */
+  objectsOfType?(objectTypeId: string): SqliteTypedObjects
   /** Wrap a terminal SELECT without its own WITH clause; the selected source owns the only WITH. */
   wrapStatement(
     sql: string,
@@ -129,6 +135,26 @@ export interface SqliteObjectQuerySource {
   wrapQuery(query: CompiledObjectQuery): CompiledObjectQuery
 }
 
+export interface SqliteTypedObjects {
+  readonly table: string
+  readonly filter?: { readonly sql: string; readonly args: readonly SqliteValue[] }
+}
+
+/** The table and `AND ...` filter a statement reads one type's objects with. */
+export function sqliteObjectsOfType(
+  source: SqliteObjectQuerySource,
+  objectTypeId: string
+): { table: string; filter: string; args: readonly SqliteValue[] } {
+  const typed = source.objectsOfType?.(objectTypeId)
+  if (!typed) return { table: source.objectsTable, filter: "", args: [] }
+
+  return {
+    table: typed.table,
+    filter: typed.filter ? `AND (${typed.filter.sql})` : "",
+    args: typed.filter?.args ?? [],
+  }
+}
+
 export const DEFAULT_OBJECT_QUERY_SOURCE: SqliteObjectQuerySource = {
   objectsTable: "objects",
   linksTable: "links",
@@ -298,19 +324,20 @@ function compileStart(
   }
 
   const order = compileOrder(identityOrderFields())
+  const objects = sqliteObjectsOfType(ctx.source, query.objectTypeId)
   const sql = `
     SELECT *, properties AS _cursor_properties
-    FROM ${ctx.source.objectsTable}
-    WHERE project_id = ? AND object_type_id = ?
+    FROM ${objects.table}
+    WHERE project_id = ? AND object_type_id = ? ${objects.filter}
     ORDER BY ${order.sql}
   `
-  const args = [projectId, query.objectTypeId, ...order.args]
+  const args = [projectId, query.objectTypeId, ...objects.args, ...order.args]
 
   return {
     sql,
     args,
-    totalSql: `SELECT COUNT(*) as total FROM ${ctx.source.objectsTable} WHERE project_id = ? AND object_type_id = ?`,
-    totalArgs: [projectId, query.objectTypeId],
+    totalSql: `SELECT COUNT(*) as total FROM ${objects.table} WHERE project_id = ? AND object_type_id = ? ${objects.filter}`,
+    totalArgs: [projectId, query.objectTypeId, ...objects.args],
     order,
     hasMore: () => false,
     trimRows: identityRows,
@@ -974,7 +1001,8 @@ export function sqliteJsonEachValue(alias: string): string {
   END`
 }
 
-function compilePredicate(predicate: ObjectQueryPredicate): CompiledPredicate {
+/** Compile a predicate over the unqualified `properties` column of the relation it filters. */
+export function compilePredicate(predicate: ObjectQueryPredicate): CompiledPredicate {
   if (
     "scalarKind" in predicate &&
     predicate.scalarKind === "decimal" &&
@@ -1004,6 +1032,8 @@ function compilePredicate(predicate: ObjectQueryPredicate): CompiledPredicate {
       const item = compilePredicate(predicate.item)
       return negatePredicate(item)
     }
+    case "constant":
+      return { sql: predicate.value ? "1" : "0", args: [] }
     case "eq":
       return predicate.scalarKind === "userRef"
         ? compileUserRefInPredicate(predicate.propertyId, [predicate.value])

package/src/objects/read-scope.ts

@@ -1,6 +1,10 @@
-import type { CompiledSelectedObjectReadScope } from "@sixb/core/storage"
+import type {
+  CompiledConditionalObjectReadScope,
+  CompiledSelectedObjectReadScope,
+} from "@sixb/core/storage"
 import {
   type CompiledObjectQuery,
+  compilePredicate,
   type SqliteObjectQuerySource,
   type SqliteValue,
   sqliteJsonEachValue,
@@ -35,16 +39,75 @@ export function compileSqliteSelectedObjectReadSource(
     objects: scope.objects,
     steps: scope.steps,
   })
-  const compiled = compileSelectedReadScopeCte(scopeJson, projectId)
+  const source = scopedQuerySource(compileSelectedReadScopeCte(scopeJson, projectId))
+
+  return Object.freeze({
+    ...source,
+    objectPropertyPermissionsTable: "_sixb_scope_object_permissions",
+    traversalProbe: source.wrapStatement(
+      `
+        SELECT COUNT(*) AS total
+        FROM (
+          SELECT 1 AS traversal_fact
+          FROM _sixb_scope_root_facts
+
+          UNION ALL
+
+          SELECT 1 AS traversal_fact
+          FROM _sixb_scope_reached_links
+
+          LIMIT ?
+        ) AS bounded_traversal_facts
+      `,
+      [BigInt(maxTraversalFacts) + 1n]
+    ),
+  })
+}
+
+/**
+ * Prepare a conditional scope as SQLite relations that filter stored rows as they are read.
+ *
+ * Both relations are NOT MATERIALIZED, so SQLite flattens them into each statement: its filters,
+ * index seeks and LIMIT reach the stored tables, and the conditions become one more filter. An
+ * object of a conditioned type is visible while its condition matches; a link while each of its
+ * conditioned endpoints is a visible object.
+ */
+export function compileSqliteConditionalObjectReadSource(
+  projectId: string,
+  scope: CompiledConditionalObjectReadScope
+): SqliteObjectQuerySource {
+  const filters = new Map(
+    scope.conditions.map((condition) => [
+      condition.objectTypeId,
+      compilePredicate(condition.predicate),
+    ])
+  )
+
+  return Object.freeze({
+    ...scopedQuerySource(compileConditionalReadScopeCte(projectId, filters)),
+    // One type's visible objects are the stored ones its own condition matches.
+    objectsOfType: (objectTypeId: string) => {
+      const filter = filters.get(objectTypeId)
+      return filter ? { table: "objects", filter } : { table: "objects" }
+    },
+  })
+}
+
+interface CompiledReadScopeCte {
+  readonly sql: string
+  readonly args: readonly SqliteValue[]
+}
+
+/** Prefix every statement of a query with the scope's relations, ahead of its own arguments. */
+function scopedQuerySource(compiled: CompiledReadScopeCte): SqliteObjectQuerySource {
   const wrapStatement = (sql: string, args: readonly SqliteValue[] = []) => ({
     sql: `${compiled.sql}\n${sql}`,
     args: [...compiled.args, ...args],
   })
 
-  return Object.freeze({
+  return {
     objectsTable: "_sixb_scope_objects",
     linksTable: "_sixb_scope_links",
-    objectPropertyPermissionsTable: "_sixb_scope_object_permissions",
     wrapStatement,
     wrapQuery: (query: CompiledObjectQuery): CompiledObjectQuery => ({
       ...query,
@@ -63,29 +126,83 @@ export function compileSqliteSelectedObjectReadSource(
           }
         : {}),
     }),
-    traversalProbe: wrapStatement(
-      `
-        SELECT COUNT(*) AS total
-        FROM (
-          SELECT 1 AS traversal_fact
-          FROM _sixb_scope_root_facts
-
-          UNION ALL
+  }
+}
 
-          SELECT 1 AS traversal_fact
-          FROM _sixb_scope_reached_links
+/** Conditions keyed by their concrete type, each compiled over that type's `properties`. */
+type ConditionFilters = ReadonlyMap<
+  string,
+  { readonly sql: string; readonly args: readonly SqliteValue[] }
+>
 
-          LIMIT ?
-        ) AS bounded_traversal_facts
+function compileConditionalReadScopeCte(
+  projectId: string,
+  filters: ConditionFilters
+): CompiledReadScopeCte {
+  if (filters.size === 0) {
+    return {
+      sql: `
+        WITH
+        _sixb_scope_objects AS NOT MATERIALIZED (
+          SELECT * FROM objects WHERE project_id = ?
+        ),
+        _sixb_scope_links AS NOT MATERIALIZED (
+          SELECT * FROM links WHERE project_id = ?
+        )
       `,
-      [BigInt(maxTraversalFacts) + 1n]
-    ),
-  })
-}
+      args: [projectId, projectId],
+    }
+  }
 
-interface CompiledReadScopeCte {
-  readonly sql: string
-  readonly args: readonly SqliteValue[]
+  const conditionedTypeArgs = [...filters.keys()]
+  const conditionedTypes = conditionedTypeArgs.map(() => "?").join(", ")
+
+  const matches: string[] = []
+  const matchArgs: SqliteValue[] = []
+  for (const [objectTypeId, filter] of filters) {
+    matches.push(`(object_type_id = ? AND ${filter.sql})`)
+    matchArgs.push(objectTypeId, ...filter.args)
+  }
+
+  const visibleEndpoint = (end: "source" | "target") => `
+    (
+      stored.${end}_type_id NOT IN (${conditionedTypes})
+      OR EXISTS (
+        SELECT 1
+        FROM _sixb_scope_objects AS endpoint
+        WHERE endpoint.project_id = stored.project_id
+          AND endpoint.object_type_id = stored.${end}_type_id
+          AND endpoint.primary_id = stored.${end}_id
+      )
+    )
+  `
+
+  return {
+    sql: `
+      WITH
+      _sixb_scope_objects AS NOT MATERIALIZED (
+        SELECT *
+        FROM objects
+        WHERE project_id = ?
+          AND (object_type_id NOT IN (${conditionedTypes}) OR ${matches.join(" OR ")})
+      ),
+      _sixb_scope_links AS NOT MATERIALIZED (
+        SELECT stored.*
+        FROM links AS stored
+        WHERE stored.project_id = ?
+          AND ${visibleEndpoint("source")}
+          AND ${visibleEndpoint("target")}
+      )
+    `,
+    args: [
+      projectId,
+      ...conditionedTypeArgs,
+      ...matchArgs,
+      projectId,
+      ...conditionedTypeArgs,
+      ...conditionedTypeArgs,
+    ],
+  }
 }
 
 function compileSelectedReadScopeCte(scopeJson: string, projectId: string): CompiledReadScopeCte {