deepline 0.3.297 → 0.3.298

package/dist/bundling-sources/sdk/src/release.ts

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.297',
+  version: '0.3.298',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

package/dist/bundling-sources/shared_libs/monitors/quickstart-prompts.ts

@@ -1,20 +1,35 @@
 export type MonitorQuickstartPrompt = {
+  id: string;
+  title: string;
+  description: string;
   prompt: string;
   icon: 'job-change' | 'new-hires' | 'hiring-signal';
 };
 
+/** Shared by the first-run card, template gallery, and template discovery API. */
 export const MONITOR_QUICKSTART_PROMPTS: MonitorQuickstartPrompt[] = [
   {
+    id: 'new-leadership-hires',
+    title: 'New leadership hires',
+    description:
+      'Watch target accounts for new VP Sales, Marketing, and Revenue hires.',
     prompt:
       '/deepline-gtm Monitor my target accounts for new VP Sales, Marketing, and Revenue hires.',
     icon: 'new-hires',
   },
   {
+    id: 'champion-job-change',
+    title: 'Job changes',
+    description: 'Find when people at your target accounts change jobs.',
     prompt:
       '/deepline-gtm Monitor when people at my target accounts change jobs.',
     icon: 'job-change',
   },
   {
+    id: 'job-post-keywords',
+    title: 'Job openings',
+    description:
+      'Watch target accounts for hiring signals in the roles you sell to.',
     prompt:
       '/deepline-gtm Monitor my target accounts for job openings in the roles I sell to.',
     icon: 'hiring-signal',

package/dist/bundling-sources/shared_libs/monitors/starter-templates.ts

@@ -1,3 +1,5 @@
+import { MONITOR_QUICKSTART_PROMPTS } from './quickstart-prompts';
+
 export type MonitorStarterTemplate = {
   id: string;
   title: string;
@@ -5,101 +7,10 @@ export type MonitorStarterTemplate = {
   prompt: string;
 };
 
-export const MONITOR_STARTER_TEMPLATES: MonitorStarterTemplate[] = [
-  {
-    id: 'job-post-keywords',
-    title: 'Job post keyword monitor',
-    description:
-      'Watch target accounts for hiring signals that imply new budget, new projects, or urgency.',
-    prompt: `Create a Deepline definePlay() workflow for a job post keyword monitor.
-
-Input: a list of target accounts, job title or description keywords, optional regions, and optional owner routing.
-Behavior: check each account for recent open roles that match the keywords, dedupe against prior matches, enrich each match with company context and job URL, and rank the signal by relevance.
-Output: one concise rep-ready message per owner with account name, matched role, why it matters, job URL, and recommended next step. Include Slack Block Kit formatting and an email fallback.
-Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
-  },
-  {
-    id: 'champion-job-change',
-    title: 'Champion job change monitor',
-    description:
-      'Find when a known buyer, user, or champion joins a new account and route a warm-path action.',
-    prompt: `Create a Deepline definePlay() workflow for a champion job change monitor.
-
-Input: known champions or contacts from CRM, their prior companies, owner routing rules, and optional target-account filters.
-Behavior: detect likely role or company changes, validate the new company and title, suppress weak matches, and connect the signal back to the owning rep or CSM.
-Output: one routed message per owner with champion name, old company, new company, new title, relationship context, source URL, and suggested outreach angle. Include Slack Block Kit formatting and an email fallback.
-Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
-  },
-  {
-    id: 'website-page-change',
-    title: 'Website page change monitor',
-    description:
-      'Track pricing, docs, security, integrations, or product pages for GTM-relevant changes.',
-    prompt: `Create a Deepline definePlay() workflow for a website page change monitor.
-
-Input: a list of account URLs, page categories to watch, a minimum change threshold, and owner routing rules.
-Behavior: fetch current page content, compare it with the prior snapshot, classify meaningful GTM changes, ignore noisy cosmetic edits, and store the new snapshot only after a successful run.
-Output: one routed message per owner with account name, changed URL, before/after summary, why the change matters, confidence, and suggested next step. Include Slack Block Kit formatting and an email fallback.
-Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
-  },
-  {
-    id: 'website-visitor-intent',
-    title: 'Website visitor intent monitor',
-    description:
-      'Turn repeat high-value website visits into account-specific follow-up for the right owner.',
-    prompt: `Create a Deepline definePlay() workflow for a website visitor intent monitor.
-
-Input: visitor or account intent events, high-intent page definitions, account matching rules, suppression rules, and owner routing.
-Behavior: group events by account, score intent from page depth and recency, suppress existing active opportunities when configured, and explain why the account is worth actioning.
-Output: one routed message per owner with account name, intent score, pages visited, timing, CRM context, and recommended next step. Include Slack Block Kit formatting and an email fallback.
-Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
-  },
-  {
-    id: 'tech-stack-change',
-    title: 'Tech stack change monitor',
-    description:
-      'Detect install, removal, or competitor stack changes that create a concrete sales motion.',
-    prompt: `Create a Deepline definePlay() workflow for a tech stack change monitor.
-
-Input: target accounts, technologies to watch, competitor or complementary-product tags, owner routing, and optional exclusion rules.
-Behavior: detect meaningful install or removal events, confirm with available evidence, classify the motion as displacement, expansion, integration, or renewal risk, and dedupe prior alerts.
-Output: one routed message per owner with account name, detected technology change, evidence, GTM interpretation, and suggested next step. Include Slack Block Kit formatting and an email fallback.
-Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
-  },
-  {
-    id: 'social-community-mention',
-    title: 'Social and community mention monitor',
-    description:
-      'Catch relevant public mentions, buying questions, complaints, or competitor comparisons.',
-    prompt: `Create a Deepline definePlay() workflow for a social and community mention monitor.
-
-Input: keywords, target accounts or personas, source allowlist, sentiment or category filters, and owner routing rules.
-Behavior: find recent relevant mentions, classify each mention as buying intent, competitor comparison, complaint, hiring, integration request, or general awareness, and suppress duplicates or low-quality chatter.
-Output: one routed message per owner with mention summary, source link, account/person context, signal category, confidence, and suggested next step. Include Slack Block Kit formatting and an email fallback.
-Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
-  },
-  {
-    id: 'competitor-churn',
-    title: 'Competitor complaint monitor',
-    description:
-      'Surface competitor dissatisfaction or sunset risk while the account is likely open to change.',
-    prompt: `Create a Deepline definePlay() workflow for a competitor complaint monitor.
-
-Input: competitor names, complaint or migration keywords, source allowlist, target-account matching rules, and owner routing.
-Behavior: find recent competitor dissatisfaction or sunset-risk mentions, match them to companies where possible, classify the pain, and suppress vague or stale mentions.
-Output: one routed message per owner with account or person, competitor, pain summary, source URL, suggested displacement angle, and confidence. Include Slack Block Kit formatting and an email fallback.
-Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
-  },
-  {
-    id: 'customer-usage-renewal',
-    title: 'Customer usage and renewal monitor',
-    description:
-      'Route expansion, risk, and renewal signals from product behavior to the account team.',
-    prompt: `Create a Deepline definePlay() workflow for a customer usage and renewal monitor.
-
-Input: product usage events, entitlement limits, renewal dates, account health fields, and owner routing.
-Behavior: detect expansion signals, underuse risk, overage pressure, renewal timing, or feature adoption changes; explain the evidence; and suppress noisy repeat alerts.
-Output: one routed message per owner with account name, signal type, usage evidence, renewal context, business impact, and suggested next step. Include Slack Block Kit formatting and an email fallback.
-Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
-  },
-];
+export const MONITOR_STARTER_TEMPLATES: MonitorStarterTemplate[] =
+  MONITOR_QUICKSTART_PROMPTS.map(({ id, title, description, prompt }) => ({
+    id,
+    title,
+    description,
+    prompt,
+  }));

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/postgres-pool.ts

@@ -196,6 +196,8 @@ export const RUNTIME_SCHEDULER_CANCEL_STATEMENT_TIMEOUT_MS = 15_000;
 
 export type RuntimeSchedulerPoolOptions = {
   url: string;
+  /** Background indexing must not occupy the lifecycle checkout budget. */
+  purpose?: 'observability';
   applicationName?: string;
   maxClients?: number;
   /**
@@ -783,7 +785,7 @@ function getPoolEntry(options: RuntimeSchedulerPoolOptions): PoolEntry {
   // The connection lifetime is part of a Pool's semantics. Do not let a
   // serverless short-idle caller accidentally reuse a long-lived worker pool
   // merely because both target the same runtime database.
-  const key = `${connectionString}::${maxClients}::${idleTimeoutMs}::${maxAcquireQueueDepth}::${maxAcquireQueueWaitMs}`;
+  const key = `${connectionString}::${maxClients}::${idleTimeoutMs}::${maxAcquireQueueDepth}::${maxAcquireQueueWaitMs}${options.purpose === 'observability' ? '::observability' : ''}`;
   const existing = registry.get(key);
   if (existing) {
     // Next dev can retain the process-global pool across a module hot reload.

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/postgres.ts

@@ -18023,10 +18023,15 @@ async function claimPostgresSchedulerOutboxPrefix(
       input.searchOnly === true
         ? runLedgerTerminalPendingSql(alias, options)
         : runLedgerUrgentLifecyclePendingSql(alias, options);
+    // Search is locally indexed and acknowledged; it has no remote ingress
+    // receipt to freeze. Preserve causal ordering/due/lease checks, but admit
+    // its full prefix instead of inheriting lifecycle's singleton transport.
     const ingressPrefixSql =
-      supportsTerminalBatchMarker && input.allowIngressPrefix === true
-        ? `(head.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents})`
-        : 'false';
+      input.searchOnly === true
+        ? 'true'
+        : supportsTerminalBatchMarker && input.allowIngressPrefix === true
+          ? `(head.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents})`
+          : 'false';
     return await client.query<{
       row_kind: 'claimed' | 'delivered';
       event_id: string;
@@ -18145,14 +18150,16 @@ async function claimPostgresSchedulerOutboxPrefix(
           -- Admission is causally first and must be projected alone. A later
           -- start/terminal append may not leapfrog a delayed queued row.
           AND (
-            head.event_type NOT IN (${RUN_EVENT_KIND_SQL_LITERAL.runCreated}, ${RUN_EVENT_KIND_SQL_LITERAL.runStarted}, ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents})
+            ${input.searchOnly === true ? 'true' : 'false'}
+            OR head.event_type NOT IN (${RUN_EVENT_KIND_SQL_LITERAL.runCreated}, ${RUN_EVENT_KIND_SQL_LITERAL.runStarted}, ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents})
             OR outbox.event_id = head.event_id
             OR (head.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
                 AND ${ingressPrefixSql})
           )
           -- Only a receiver with the exact-prefix verifier may combine ingress
           -- facts; old launch origins and schemas retain singleton receipts.
-          AND (outbox.event_type <> ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
+          AND (${input.searchOnly === true ? 'true' : 'false'}
+               OR outbox.event_type <> ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
                OR outbox.event_id = head.event_id
                OR ${ingressPrefixSql})
           -- Once any ingress prefix was attempted, its receipt is immutable,
@@ -19456,6 +19463,11 @@ export function postgresSchedulerCancellationOutboxLease(runId: string): {
 }
 
 export type RunLedgerOutboxDispatchInput = {
+  /** Dedicated bounded checkout for indexing; claims/ACKs use withClient. */
+  withObservabilityClient?: <T>(
+    operation: (client: PostgresSchedulerQueryClient) => Promise<T>,
+  ) => Promise<T>;
+
   /** Only the existing background projector claims the independent search prefix. */
   searchOnly?: boolean;
   /** Only the existing background projector indexes deferred raw inputs. */
@@ -19995,63 +20007,98 @@ async function dispatchRunLedgerOutboxBatchWithScope(
           retryingEventIds: released,
         };
       }
-      for (const event of events) {
-        if (
+      const deferredEvents = events.filter(
+        (event) =>
           payloadField(
             event.payload,
             RUNTIME_EVENT_DEFERRED_PROJECTION_FIELD,
-          ) !== true
-        )
-          continue;
-        await withClient(async (client) => {
-          await renewPostgresRunLedgerDelivery(
+          ) === true,
+      );
+      const materialize = async (prefix: typeof deferredEvents) => {
+        await withClient((client) =>
+          renewPostgresRunLedgerDelivery(
             client,
             {
-              eventIds: events.map((row) => row.eventId),
+              eventIds: events.map((event) => event.eventId),
               leaseOwner,
               leaseSeconds: 120,
             },
             options,
-          );
-          // Keep projection below its renewed lease. The final payload update
-          // fences ownership; indexing locks neither outbox nor Run rows.
+          ),
+        );
+        await (input.withObservabilityClient ?? withClient)(async (client) => {
           await client.query('BEGIN');
           try {
-            // Let PostgreSQL cancel before the pool's client-side timeout,
-            // so rollback completes while the checkout is still usable.
             await client.query(
               "SELECT set_config('statement_timeout', $1, true)",
               [
                 `${Math.min(60_000, RUNTIME_RELIABILITY_POLICY.schedulerDatabase.queryTimeoutMs - 1_000)}ms`,
               ],
             );
-            const result = await client.query<{ payload: unknown }>(
-              `SELECT ${quoteIdent(schemaName(options))}.materialize_runtime_outbox_event($1, $2) AS payload`,
-              [event.eventId, leaseOwner],
+            // The recursive dependency evaluates this already-bounded causal
+            // prefix in order, in one database round trip. Its eight-fact
+            // contract is unchanged. The timeout bounds the entire statement
+            // below the lease; the installed function still fences every fact.
+            const result = await client.query<{
+              ordinal: number;
+              payload: unknown;
+            }>(
+              `WITH RECURSIVE projected(ordinal, payload) AS (
+                 SELECT 1, ${quoteIdent(schemaName(options))}.materialize_runtime_outbox_event(($1::text[])[1], $2)
+                 UNION ALL
+                 SELECT prior.ordinal + 1,
+                        ${quoteIdent(schemaName(options))}.materialize_runtime_outbox_event(($1::text[])[prior.ordinal + 1], $2)
+                 FROM projected AS prior
+                 WHERE prior.ordinal < cardinality($1::text[])
+               )
+               SELECT ordinal, payload FROM projected ORDER BY ordinal`,
+              [prefix.map((event) => event.eventId), leaseOwner],
             );
             await client.query('COMMIT');
-            event.payload = result.rows[0]!.payload;
+            for (const row of result.rows)
+              prefix[row.ordinal - 1]!.payload = row.payload;
           } catch (error) {
             await client.query('ROLLBACK');
+            throw error;
+          }
+        });
+      };
+      try {
+        await materialize(deferredEvents);
+      } catch (error) {
+        if (
+          !(
+            error &&
+            typeof error === 'object' &&
+            'code' in error &&
+            error.code === 'P0001'
+          )
+        ) {
+          throw error;
+        }
+        // An invalid immutable fact must quarantine only itself. The aborted
+        // batch wrote nothing; replay its small prefix one fact at a time to
+        // identify that fact and retain the valid indexed predecessors.
+        for (const event of deferredEvents) {
+          try {
+            await materialize([event]);
+          } catch (factError) {
             if (
-              error &&
-              typeof error === 'object' &&
-              'code' in error &&
-              error.code === 'P0001'
+              factError &&
+              typeof factError === 'object' &&
+              'code' in factError &&
+              factError.code === 'P0001'
             ) {
-              // The installed projector's explicit RAISEs reject malformed
-              // or conflicting immutable facts. Retain them in the existing
-              // quarantine instead of retrying the same invalid input forever.
               throw new DeferredRuntimeProjectionInputError(
                 event.eventId,
-                error instanceof Error
-                  ? error.message
+                factError instanceof Error
+                  ? factError.message
                   : 'Invalid runtime event projection input.',
               );
             }
-            throw error;
+            throw factError;
           }
-        });
+        }
       }
     }
     return null;

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/run-ledger-outbox-recovery.ts

@@ -74,6 +74,7 @@ export const RUN_LEDGER_OUTBOX_RECOVERY_MAX_IN_FLIGHT = 32;
 // The higher exported ceiling remains available to isolated recovery callers,
 // but it is not the steady-state production setting.
 const RUN_LEDGER_OUTBOX_RECOVERY_PRODUCTION_IN_FLIGHT = 8;
+const RUN_LEDGER_OUTBOX_RECOVERY_INDEX_IN_FLIGHT = 4;
 // Admissions retain three of four claim opportunities. The fourth selects
 // the oldest eligible causal head across all runs, preventing terminal work
 // from starving behind continuous new admissions. An empty class never costs
@@ -89,6 +90,9 @@ export type RunLedgerOutboxRecoveryDeps = {
   dispatchOnce: (
     headPriority: RunLedgerOutboxHeadPriority,
   ) => Promise<PostgresSchedulerOutboxProjectionResult>;
+  /** Independent index deliveries share this controller and notification source. */
+  dispatchObservabilityOnce?: () => Promise<PostgresSchedulerOutboxProjectionResult>;
+  observabilityParallelism?: number;
   /** Earliest pending retry time or active lease expiry in the durable outbox. */
   readNextDueAt: () => Promise<Date | null>;
   /** A direct LISTEN connection. It is a hint only; a null lease is safe. */
@@ -159,6 +163,22 @@ export function startRunLedgerOutboxRecovery(
         ),
       )
     : 1;
+  if (deps.dispatchObservabilityOnce && parallelism < 2) {
+    throw new Error(
+      'Independent observability delivery requires at least two slots.',
+    );
+  }
+  const observabilityParallelism = deps.dispatchObservabilityOnce
+    ? Math.min(
+        Math.max(1, deps.observabilityParallelism ?? 1),
+        Math.max(1, parallelism - 1),
+      )
+    : 0;
+  const lifecycleParallelism = Math.max(
+    1,
+    parallelism - observabilityParallelism,
+  );
+  let observabilityRequested = false;
   let closed = false;
   let requested = false;
   let failureCount = 0;
@@ -174,22 +194,24 @@ export function startRunLedgerOutboxRecovery(
   let nextDispatchId = 0;
   let lastDispatchSettledAt: number | null = null;
   let admissionTurns = 0;
-  const dispatchOnce =
-    async (): Promise<PostgresSchedulerOutboxProjectionResult> => {
-      const oldestReady =
-        admissionTurns === ADMISSION_TURNS_PER_OLDEST_READY_TURN;
-      admissionTurns = oldestReady ? 0 : admissionTurns + 1;
-      const id = nextDispatchId++;
-      inFlightStartedAt.set(id, now());
-      try {
-        return await deps.dispatchOnce(
-          oldestReady ? 'oldest_ready' : 'admission_first',
-        );
-      } finally {
-        inFlightStartedAt.delete(id);
-        lastDispatchSettledAt = now();
-      }
-    };
+  const dispatchOnce = async (
+    observability = false,
+  ): Promise<PostgresSchedulerOutboxProjectionResult> => {
+    const oldestReady =
+      admissionTurns === ADMISSION_TURNS_PER_OLDEST_READY_TURN;
+    if (!observability) admissionTurns = oldestReady ? 0 : admissionTurns + 1;
+    const id = nextDispatchId++;
+    inFlightStartedAt.set(id, now());
+    try {
+      if (observability) return await deps.dispatchObservabilityOnce!();
+      return await deps.dispatchOnce(
+        oldestReady ? 'oldest_ready' : 'admission_first',
+      );
+    } finally {
+      inFlightStartedAt.delete(id);
+      lastDispatchSettledAt = now();
+    }
+  };
 
   const clearWakeTimer = () => {
     if (!timer) return;
@@ -220,6 +242,7 @@ export function startRunLedgerOutboxRecovery(
   requestDrain = (reason: string) => {
     if (closed) return;
     requested = true;
+    observabilityRequested = !!deps.dispatchObservabilityOnce;
     if (cooldownUntilMs !== null && now() < cooldownUntilMs) return;
     clearWakeTimer();
     if (drainPromise) {
@@ -313,11 +336,13 @@ export function startRunLedgerOutboxRecovery(
   const drain = async (reason: string): Promise<void> => {
     type Delivery = {
       id: symbol;
+      observability: boolean;
       result:
         | PromiseSettledResult<PostgresSchedulerOutboxProjectionResult>
         | { status: 'skipped' };
     };
     const pending = new Set<symbol>();
+    const pendingObservability = new Set<symbol>();
     const deliveries: Delivery[] = [];
     let refill = false;
     let dispatchFailed = false;
@@ -345,15 +370,16 @@ export function startRunLedgerOutboxRecovery(
       completed = attempted = projected = retrying = blocked = 0;
     };
 
-    const launch = () => {
+    const launch = (observability = false) => {
       const id = Symbol();
       pending.add(id);
+      if (observability) pendingObservability.add(id);
       const settle = (result: Delivery['result']) => {
         if (result.status === 'rejected' && !dispatchFailed) {
           dispatchFailed = true;
           scheduleFailureRetry('dispatch', result.reason);
         }
-        deliveries.push({ id, result });
+        deliveries.push({ id, observability, result });
         wakeActiveDrain?.();
       };
       // Subscribe once per delivery. Repeated Promise.race calls would retain
@@ -364,26 +390,54 @@ export function startRunLedgerOutboxRecovery(
           return;
         }
         try {
-          settle({ status: 'fulfilled', value: await dispatchOnce() });
+          settle({
+            status: 'fulfilled',
+            value: await dispatchOnce(observability),
+          });
         } catch (reason) {
           settle({ status: 'rejected', reason });
         }
       });
     };
 
+    const canProbeLifecycle = () =>
+      !closed &&
+      !dispatchFailed &&
+      requested &&
+      pending.size < parallelism &&
+      pending.size - pendingObservability.size < lifecycleParallelism;
+    const canProbeObservability = () =>
+      !closed &&
+      !dispatchFailed &&
+      observabilityRequested &&
+      pending.size < parallelism &&
+      pendingObservability.size < observabilityParallelism;
+
     for (;;) {
       if (!closed && !dispatchFailed) {
         // A wake grants one indexed probe, including when other slots are
         // still delivering. Keep it pending when full so an empty result
         // cannot consume a notification that arrived after its query began.
-        if (requested && pending.size < parallelism) {
+        if (canProbeObservability()) {
+          observabilityRequested = false;
+          while (
+            pendingObservability.size < observabilityParallelism &&
+            pending.size < parallelism
+          )
+            launch(true);
+        }
+        if (canProbeLifecycle()) {
           requested = false;
           launch();
         }
         // Productive completion permits immediate use of every free slot.
         // Empty results grant no refill, so idle work cannot spin on scans.
         if (refill) {
-          while (pending.size < parallelism) launch();
+          while (
+            pending.size < parallelism &&
+            pending.size - pendingObservability.size < lifecycleParallelism
+          )
+            launch();
           refill = false;
         }
       }
@@ -398,10 +452,8 @@ export function startRunLedgerOutboxRecovery(
         wakeActiveDrain = resolve;
         if (
           deliveries.length > 0 ||
-          (requested &&
-            !closed &&
-            !dispatchFailed &&
-            pending.size < parallelism)
+          canProbeLifecycle() ||
+          canProbeObservability()
         )
           resolve();
       });
@@ -409,6 +461,7 @@ export function startRunLedgerOutboxRecovery(
       const delivery = deliveries.shift();
       if (!delivery) continue;
       pending.delete(delivery.id);
+      pendingObservability.delete(delivery.id);
       if (delivery.result.status !== 'fulfilled') {
         // Stop new claims but settle every already-started delivery before
         // cooldown or close can hand ownership to another drain.
@@ -423,7 +476,9 @@ export function startRunLedgerOutboxRecovery(
       if (completed >= parallelism) reportDeliveries();
       // Retryable rows own durable retry clocks. The SQL claim keeps their
       // run ordered while successful slots keep unrelated runs moving.
-      refill = result.attempted > 0;
+      if (delivery.observability) {
+        if (result.attempted > 0) observabilityRequested = true;
+      } else refill = result.attempted > 0;
     }
   };
 
@@ -598,12 +653,37 @@ export function startRunLedgerOutboxRecoveryController(input: {
   onDelivered?: (deliveries: readonly RunLedgerOutboxDeliveredRow[]) => void;
 }): RunLedgerOutboxRecoveryController {
   const schedulerOptions = input.schedulerOptions ?? {};
-  let dispatchOrdinal = 0;
-  let searchInFlight = 0;
-  const maxSearchInFlight = Math.max(
-    1,
-    Math.floor(RUN_LEDGER_OUTBOX_RECOVERY_PRODUCTION_IN_FLIGHT / 2),
-  );
+  const observabilityPoolOptions: RuntimeSchedulerPoolOptions = {
+    ...input.poolOptions,
+    purpose: 'observability',
+    applicationName: 'deepline-runtime-observability',
+    maxClients: RUN_LEDGER_OUTBOX_RECOVERY_INDEX_IN_FLIGHT,
+  };
+  const dispatch = (
+    headPriority: RunLedgerOutboxHeadPriority,
+    searchOnly: boolean,
+  ) =>
+    dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
+      (operation) =>
+        withRuntimeSchedulerClient(
+          searchOnly ? observabilityPoolOptions : input.poolOptions,
+          operation,
+        ),
+      {
+        tokenAuthority: 'gateway',
+        materializeObservability: true,
+        searchOnly,
+        withObservabilityClient: (operation) =>
+          withRuntimeSchedulerClient(observabilityPoolOptions, operation),
+        limit: 8,
+        headPriority,
+        // The lease holder delivers a run's terminal committed during its
+        // append, instead of leaving it for the next wave.
+        continueThroughTerminal: true,
+        ...(input.onDelivered ? { onDelivered: input.onDelivered } : {}),
+      },
+      schedulerOptions,
+    );
   return startRunLedgerOutboxRecovery({
     acquireNotifyHub: () =>
       input.useDirectNotify === false
@@ -614,33 +694,9 @@ export function startRunLedgerOutboxRecoveryController(input: {
               schedulerOptions,
             }),
           ),
-    dispatchOnce: async (headPriority) => {
-      const searchOnly =
-        dispatchOrdinal++ % 2 === 1 && searchInFlight < maxSearchInFlight;
-      if (searchOnly) searchInFlight += 1;
-      try {
-        return await dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
-          (operation) =>
-            withRuntimeSchedulerClient(input.poolOptions, operation),
-          {
-            tokenAuthority: 'gateway',
-            materializeObservability: true,
-            // One durable controller, with half its capacity reserved for
-            // lifecycle delivery even when every search operation is blocked.
-            searchOnly,
-            limit: 8,
-            headPriority,
-            // The lease holder delivers a run's terminal committed during its
-            // append, instead of leaving it for the next wave.
-            continueThroughTerminal: true,
-            ...(input.onDelivered ? { onDelivered: input.onDelivered } : {}),
-          },
-          schedulerOptions,
-        );
-      } finally {
-        if (searchOnly) searchInFlight -= 1;
-      }
-    },
+    dispatchOnce: (headPriority) => dispatch(headPriority, false),
+    dispatchObservabilityOnce: () => dispatch('oldest_ready', true),
+    observabilityParallelism: RUN_LEDGER_OUTBOX_RECOVERY_INDEX_IN_FLIGHT,
     // `dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope` releases each
     // short scheduler checkout before it calls the Vercel gateway. The two
     // replicas therefore drain up to sixteen independent runs concurrently