deepline 0.3.286 → 0.3.287

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

@@ -117,6 +117,8 @@ import type {
   DeeplineAgentModelDescription,
   InferenceQuote,
   ChildRunSummary,
+  SearchOptions,
+  SearchResult,
 } from './types.js';
 import { isStopAllPlayRunsDryRunResult } from './types.js';
 import type { MonitorDefinition } from './monitors.js';
@@ -610,6 +612,29 @@ function chunkRegisterPlayArtifacts<T>(artifacts: T[]): T[][] {
   return chunks;
 }
 
+/** Query parameters shared by every search route. */
+function searchParams(options: ToolSearchOptions): URLSearchParams {
+  const params = new URLSearchParams();
+  params.set('q', options.query?.trim() ?? '');
+  params.set(
+    'include_search_debug',
+    options.includeSearchDebug ? 'true' : 'false',
+  );
+  params.set('search_mode', options.searchMode ?? 'v2');
+  if (options.limit !== undefined) params.set('limit', String(options.limit));
+  if (options.offset !== undefined) {
+    params.set('offset', String(options.offset));
+  }
+  if (options.categories?.trim()) {
+    params.set('categories', options.categories.trim());
+  }
+  if (options.searchTerms?.trim()) {
+    params.set('search_terms', options.searchTerms.trim());
+  }
+  if (options.task?.trim()) params.set('task', options.task.trim());
+  return params;
+}
+
 /** Filters for `client.runs.list(...)`. */
 export type RunsListOptions = {
   play?: string;
@@ -3195,34 +3220,32 @@ export class DeeplineClient {
   async searchTools(
     options: ToolSearchOptions = {},
   ): Promise<ToolSearchResult> {
-    const params = new URLSearchParams();
-    const query = options.query?.trim() ?? '';
-    params.set('q', query);
-    params.set(
-      'include_search_debug',
-      options.includeSearchDebug ? 'true' : 'false',
-    );
-    params.set('search_mode', options.searchMode ?? 'v2');
-    if (options.limit !== undefined) {
-      params.set('limit', String(options.limit));
-    }
-    if (options.offset !== undefined) {
-      params.set('offset', String(options.offset));
-    }
-    if (options.categories?.trim()) {
-      params.set('categories', options.categories.trim());
-    }
-    if (options.searchTerms?.trim()) {
-      params.set('search_terms', options.searchTerms.trim());
-    }
-    if (options.task?.trim()) {
-      params.set('task', options.task.trim());
-    }
     return this.http.get<ToolSearchResult>(
-      `/api/v2/tools/search?${params.toString()}`,
+      `/api/v2/tools/search?${searchParams(options).toString()}`,
     );
   }
 
+  /**
+   * Search everything Deepline can run or deploy in one ranked list: tools,
+   * monitor types, prebuilt plays, and your workspace's own plays.
+   *
+   * @example
+   * ```typescript
+   * const { results } = await client.search({
+   *   query: 'find work email',
+   *   types: ['tools', 'prebuilts'],
+   * });
+   * ```
+   */
+  async search(options: SearchOptions = {}): Promise<SearchResult> {
+    const params = searchParams(options);
+    if (options.types?.length) params.set('types', options.types.join(','));
+    if (options.exclude?.length) {
+      params.set('exclude', options.exclude.join(','));
+    }
+    return this.http.get<SearchResult>(`/api/v2/search?${params.toString()}`);
+  }
+
   /**
    * Get detailed metadata for a single tool.
    *

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

@@ -313,6 +313,10 @@ export type {
   StopPlayRunResult,
   ToolSearchOptions,
   ToolSearchResult,
+  SearchOptions,
+  SearchResult,
+  SearchResultItem,
+  SearchType,
 } from './types.js';
 
 export type {

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.286',
+  version: '0.3.287',
   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: {
@@ -235,6 +235,12 @@ export const SDK_RELEASE = {
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.3.1',
     commandIntroducedIn: [
+      {
+        command: 'search',
+        introducedIn: '0.3.91',
+        reason:
+          'deepline search was added in SDK CLI 0.3.91 as the one search across tools, monitors, and plays. On an older version run deepline tools search or deepline plays search, or update.',
+      },
       {
         command: 'notifications',
         introducedIn: '0.2.40',

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

@@ -488,6 +488,42 @@ export interface ToolSearchOptions {
   includeSearchDebug?: boolean;
 }
 
+/** What a search can be narrowed to. `plays` is `prebuilts` plus `custom`. */
+export type SearchType =
+  | 'tools'
+  | 'plays'
+  | 'monitors'
+  | 'prebuilts'
+  | 'custom';
+
+/** Options for {@link DeeplineClient.search}. */
+export interface SearchOptions extends ToolSearchOptions {
+  /** Kinds of result to search. Omit to search everything. */
+  types?: readonly SearchType[];
+  /** Kinds of result to leave out; the opposite of `types`. */
+  exclude?: readonly SearchType[];
+}
+
+/** One ranked search result; `kind` says which fields accompany it. */
+export interface SearchResultItem {
+  /** Tool id for tools and monitor types, or play reference. */
+  id: string;
+  kind: 'tool' | 'monitor_type' | 'prebuilt_play' | 'custom_play';
+  displayName?: string;
+  description?: string;
+  [field: string]: unknown;
+}
+
+/** Ranked results across tools, monitor types, and plays. */
+export interface SearchResult extends Omit<
+  ToolSearchResult,
+  'tools' | 'omitted_plays_hint' | 'commandTemplates'
+> {
+  results: SearchResultItem[];
+  /** The result kinds this search covered. */
+  kinds: SearchResultItem['kind'][];
+}
+
 /**
  * Ranked tool/provider discovery response.
  *

package/dist/bundling-sources/shared_libs/play-runtime/cell-provenance.ts

@@ -45,6 +45,22 @@ export interface PlayCellDecision {
   reads: PlayCellReadRef[];
 }
 
+/** One persisted outcome per row and predicate, never evaluation attempts. */
+export type PlayConditionCounts = { true: number; false: number };
+
+export function normalizePlayConditionCounts(
+  value: unknown,
+): PlayConditionCounts | undefined {
+  if (!value || typeof value !== 'object') return undefined;
+  const counts = value as PlayConditionCounts;
+  return Number.isSafeInteger(counts.true) &&
+    counts.true >= 0 &&
+    Number.isSafeInteger(counts.false) &&
+    counts.false >= 0
+    ? { true: counts.true, false: counts.false }
+    : undefined;
+}
+
 /** Row-grain birth: the source row the runtime held while building this row. */
 export type PlayRowBornFromRow = { table: string; rowKey: string };
 

package/dist/bundling-sources/shared_libs/play-runtime/live-state-contract.ts

@@ -1,6 +1,7 @@
 import type { PlayRunLifecycleStatus } from './run-lifecycle-policy';
 import type { PlayDocflowNodeIoState } from './docflow-node-io';
 import type { RunStopCause } from './run-execution-state';
+import type { PlayConditionCounts } from './cell-provenance';
 import type {
   PlayActivityObservation,
   PlayRunActivityProjection,
@@ -31,6 +32,7 @@ export type PlayVisualNodeProgressSnapshot = {
   completedAt?: number | null;
   artifactTableNamespace?: string | null;
   nodeIo?: PlayDocflowNodeIoState;
+  conditionCounts?: PlayConditionCounts;
 };
 
 /**

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger.ts

@@ -20,6 +20,8 @@ import {
   mergeDatasetBornFrom,
   normalizeDatasetBornFrom,
   type PlayDatasetBornFrom,
+  normalizePlayConditionCounts,
+  type PlayConditionCounts,
 } from './cell-provenance';
 import { isLedgerTerminalResultRef } from './output-size-limits';
 import type { PlayLogContext } from './log-context';
@@ -98,6 +100,7 @@ export type PlayRunLedgerStepProgress = {
   completedAt?: number | null;
   updatedAt?: number | null;
   nodeIo?: PlayDocflowNodeIoState;
+  conditionCounts?: PlayConditionCounts;
 };
 
 export type PlayRunLedgerStepSnapshot = {
@@ -1400,6 +1403,9 @@ function normalizeStepProgress(
     ...(normalizePlayDocflowNodeIoState(value.nodeIo)
       ? { nodeIo: normalizePlayDocflowNodeIoState(value.nodeIo) }
       : {}),
+    ...(normalizePlayConditionCounts(value.conditionCounts)
+      ? { conditionCounts: normalizePlayConditionCounts(value.conditionCounts) }
+      : {}),
   };
 }
 
@@ -1760,11 +1766,36 @@ export function reducePlayRunLedgerEvent(
   // Detached runners can race their best-effort progress transport against the
   // terminal outbox, and gateway processes can restart or split that traffic.
   // The Play Run Ledger is the durable projection authority, so late
-  // `step.*` facts must be a true no-op here rather than relying on a gateway
-  // process to remember terminal state.
+  // lifecycle facts must be a true no-op here rather than relying on a gateway
+  // process to remember terminal state. Settled condition counts may arrive
+  // after that claim and fill an absent summary without changing lifecycle.
   if (isTerminalPlayRunLedgerStatus(snapshot.status)) {
     if (event.type === RUN_EVENT_KIND.stepProgress) {
-      return refineTerminalSyntheticStepStart(snapshot, event) ?? snapshot;
+      const refined =
+        refineTerminalSyntheticStepStart(snapshot, event) ?? snapshot;
+      const current = refined.stepsById[event.stepId];
+      const conditionCounts = normalizePlayConditionCounts(
+        event.progress.conditionCounts,
+      );
+      // Sheet reconciliation follows the fenced terminal claim. Accept its
+      // first settled predicate pair without reopening lifecycle or timestamps.
+      if (conditionCounts && !current?.progress?.conditionCounts) {
+        return {
+          ...refined,
+          orderedStepIds: appendOrderedStepId(refined, event.stepId),
+          stepsById: {
+            ...refined.stepsById,
+            [event.stepId]: {
+              ...(current ?? {
+                stepId: event.stepId,
+                status: 'completed' as const,
+              }),
+              progress: { ...current?.progress, conditionCounts },
+            },
+          },
+        };
+      }
+      return refined;
     }
     if (isStepLifecycleEvent(event)) return snapshot;
   }
@@ -2300,6 +2331,7 @@ function progressSignature(
     startedAt: progress?.startedAt ?? null,
     completedAt: progress?.completedAt ?? null,
     nodeIo: progress?.nodeIo ?? null,
+    conditionCounts: progress?.conditionCounts ?? null,
   });
 }
 
@@ -2621,6 +2653,9 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
         ? { completedAt: progress.completedAt }
         : {}),
       ...(progress.nodeIo !== undefined ? { nodeIo: progress.nodeIo } : {}),
+      ...(progress.conditionCounts !== undefined
+        ? { conditionCounts: progress.conditionCounts }
+        : {}),
       updatedAt: progress.updatedAt ?? checkpointAt,
     };
     if (

package/dist/bundling-sources/shared_libs/play-runtime/run-observation.ts

@@ -9,6 +9,10 @@ import {
   isTerminalPlayRunLifecycleStatus,
   type PlayRunPublicStatus,
 } from './run-lifecycle-policy';
+import {
+  normalizePlayConditionCounts,
+  type PlayConditionCounts,
+} from './cell-provenance';
 import type { RunStopCause } from './run-execution-state';
 
 /**
@@ -64,6 +68,7 @@ export type RunObservationNode = {
    * Run Snapshot fact `deriveNodeExecutionState` reads. Absent otherwise.
    */
   stoppedBy?: RunStopCause;
+  conditionCounts?: PlayConditionCounts;
 };
 
 export type RunObservation = {
@@ -204,6 +209,13 @@ function projectNode(node: PlayRunStreamNodeState): RunObservationNode {
     total: finite(node.progress?.total),
     settled: nonNegative(node.progress?.completed),
     failed: nonNegative(node.progress?.failed),
+    ...(normalizePlayConditionCounts(node.progress?.conditionCounts)
+      ? {
+          conditionCounts: normalizePlayConditionCounts(
+            node.progress?.conditionCounts,
+          ),
+        }
+      : {}),
     ...(node.stoppedBy ? { stoppedBy: node.stoppedBy } : {}),
   };
 }

package/dist/bundling-sources/shared_libs/play-runtime/run-snapshot-stream.ts

@@ -18,6 +18,7 @@ import {
 } from './run-lifecycle-policy';
 import type { PlayDocflowNodeIoState } from './docflow-node-io';
 import type { RunStopCause } from './run-execution-state';
+import type { PlayConditionCounts } from './cell-provenance';
 import type { PlayVisualNodeUsageSnapshot } from './live-state-contract';
 import {
   projectPlayRunActivity,
@@ -53,6 +54,7 @@ export type PlayRunStreamNodeProgress = {
   completedAt?: number | null;
   artifactTableNamespace?: string | null;
   nodeIo?: PlayDocflowNodeIoState;
+  conditionCounts?: PlayConditionCounts;
 };
 
 export type PlayRunStreamNodeState = {
@@ -250,6 +252,7 @@ function buildSnapshotFromLedger(
             completedAt: step.completedAt ?? null,
             updatedAt: step.progress.updatedAt ?? step.updatedAt ?? null,
             nodeIo: step.progress.nodeIo,
+            conditionCounts: step.progress.conditionCounts,
           }
         : null,
       startedAt: step.startedAt ?? null,

package/dist/bundling-sources/shared_libs/play-runtime/runtime-api.ts

@@ -116,6 +116,7 @@ import {
   resolveMapRowOutcomeKey,
 } from './map-row-outcome';
 import { DEEPLINE_CELL_META_FIELD } from '../plays/cell-staleness';
+import type { PlayConditionCounts } from './cell-provenance';
 import {
   LEGACY_RUNTIME_RECEIPT_WIRE_FORMAT,
   LEGACY_RUNTIME_RECEIPT_WIRE_HEADER,
@@ -9207,6 +9208,7 @@ export type RuntimeSheetRowOutcomeCounts = {
   completed: number;
   failed: number;
   total: number;
+  conditions?: Record<string, PlayConditionCounts>;
 };
 
 /**
@@ -9231,6 +9233,7 @@ export async function countRuntimeSheetRowOutcomes(
     runId: string;
     playName?: string;
     tableNamespace?: string;
+    includeConditions?: boolean;
   },
 ): Promise<RuntimeSheetRowOutcomeCounts> {
   const { rows } = await client.query<{
@@ -9247,13 +9250,51 @@ export async function countRuntimeSheetRowOutcomes(
     [input.runId],
   );
   const row = rows[0];
+  const conditions = input.includeConditions
+    ? await countRuntimeSheetConditionOutcomes(client, input)
+    : undefined;
   return {
     completed: Math.max(0, Number(row?.completed ?? 0) || 0),
     failed: Math.max(0, Number(row?.failed ?? 0) || 0),
     total: Math.max(0, Number(row?.total ?? 0) || 0),
+    ...(conditions ? { conditions } : {}),
   };
 }
 
+/** Aggregate durable witnesses, including false/skipped and true/failed cells. */
+export async function countRuntimeSheetConditionOutcomes(
+  client: {
+    query<Row extends Record<string, unknown> = Record<string, unknown>>(
+      sql: string,
+      params?: unknown[],
+    ): Promise<{ rows: Row[] }>;
+  },
+  input: { schema: string; table: string; runId: string },
+): Promise<Record<string, PlayConditionCounts>> {
+  const { rows } = await client.query<{
+    field: string;
+    true_count: number | string;
+    false_count: number | string;
+  }>(
+    `SELECT cell.key AS field,
+            count(*) FILTER (WHERE cell.value #>> '{decide,branch}' = 'run') AS true_count,
+            count(*) FILTER (WHERE cell.value #>> '{decide,branch}' = 'else') AS false_count
+       FROM ${quoteIdentifier(input.schema)}.${quoteIdentifier(input.table)} AS sheet
+       CROSS JOIN LATERAL jsonb_each(coalesce(sheet._cell_meta, '{}'::jsonb)) AS cell(key, value)
+      WHERE sheet._run_id = $1::text
+        AND cell.value ->> 'runId' = $1::text
+        AND cell.value #>> '{decide,branch}' IN ('run', 'else')
+      GROUP BY cell.key`,
+    [input.runId],
+  );
+  return Object.fromEntries(
+    rows.map((row) => [
+      row.field,
+      { true: Number(row.true_count), false: Number(row.false_count) },
+    ]),
+  );
+}
+
 /**
  * Read the settled row-outcome counts for a dataset's runtime sheet through the
  * run's preloaded DB session. Used by the scheduler worker at terminal finalize
@@ -9265,7 +9306,7 @@ export async function countRuntimeSheetRowOutcomes(
  */
 export async function readRuntimeSheetRowOutcomeCounts(
   context: RuntimeApiContext & { playName: string; runId: string },
-  input: { tableNamespace: string },
+  input: { tableNamespace: string; includeConditions?: boolean },
 ): Promise<RuntimeSheetRowOutcomeCounts> {
   if (context.dbSessionStrategy === 'gateway_only') {
     throw new Error(
@@ -9290,6 +9331,7 @@ export async function readRuntimeSheetRowOutcomeCounts(
       runId: context.runId,
       playName: context.playName,
       tableNamespace: input.tableNamespace,
+      includeConditions: input.includeConditions,
     }),
   );
 }

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

@@ -1947,6 +1947,10 @@ async function readTerminalSheetRowOutcomes(input: {
     completed: number;
     failed: number;
     total: number;
+    conditions?: Record<
+      string,
+      import('../cell-provenance').PlayConditionCounts
+    >;
   }>
 > {
   const sheetNamespaces = [
@@ -1981,11 +1985,26 @@ async function readTerminalSheetRowOutcomes(input: {
     completed: number;
     failed: number;
     total: number;
+    conditions?: Record<
+      string,
+      import('../cell-provenance').PlayConditionCounts
+    >;
   }> = [];
   for (const tableNamespace of sheetNamespaces) {
     try {
       const counts = await readRuntimeSheetRowOutcomeCounts(runtimeContext, {
         tableNamespace,
+        includeConditions: Boolean(
+          (
+            input.launch.contractSnapshot as {
+              staticPipeline?: {
+                docflow?: { nodes?: Array<{ kind: string; sketch?: boolean }> };
+              };
+            } | null
+          )?.staticPipeline?.docflow?.nodes?.some(
+            (node) => node.kind === 'decision' && !node.sketch,
+          ),
+        ),
       });
       outcomes.push({ tableNamespace, ...counts });
     } catch (error) {

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

@@ -43,7 +43,12 @@ import {
   type PlayStaticPipeline,
   type PlayStaticSubstep,
 } from '../../plays/static-pipeline';
-import { getStaticSubstepNodeId } from '../step-progress';
+import {
+  getStaticSubstepNodeId,
+  projectDocflowConditionCounts,
+} from '../step-progress';
+import type { PlayConditionCounts } from '../cell-provenance';
+import { readRuntimeSheetRowOutcomeCounts } from '../runtime-api';
 import { runtimeApiBaseUrlFromLaunch } from './runtime-api-origin';
 
 // Patterns mirrored from runner events — they parse
@@ -232,6 +237,7 @@ export type PostgresSchedulerProgressReporter = {
       completed: number;
       failed: number;
       total: number;
+      conditions?: Record<string, PlayConditionCounts>;
     }>,
   ): void;
   /**
@@ -737,6 +743,9 @@ export function createPostgresSchedulerProgressReporter(input: {
           ? { completedAt: current.completedAt }
           : {}),
         ...(current.nodeIo !== undefined ? { nodeIo: current.nodeIo } : {}),
+        ...(current.conditionCounts !== undefined
+          ? { conditionCounts: current.conditionCounts }
+          : {}),
         ...(patch.completed !== undefined
           ? { completed: patch.completed }
           : {}),
@@ -783,6 +792,9 @@ export function createPostgresSchedulerProgressReporter(input: {
           ? { completedAt: patch.completedAt }
           : {}),
         ...(patch.nodeIo !== undefined ? { nodeIo: patch.nodeIo } : {}),
+        ...(patch.conditionCounts !== undefined
+          ? { conditionCounts: patch.conditionCounts }
+          : {}),
         updatedAt: Date.now(),
       },
     };
@@ -1474,6 +1486,7 @@ export function createPostgresSchedulerProgressReporter(input: {
     completed: number;
     failed: number;
     total: number;
+    conditions?: Record<string, PlayConditionCounts>;
   }> = [];
 
   const applyTerminalSheetOutcomes = (
@@ -1482,6 +1495,7 @@ export function createPostgresSchedulerProgressReporter(input: {
       completed: number;
       failed: number;
       total: number;
+      conditions?: Record<string, PlayConditionCounts>;
     }>,
   ): void => {
     terminalSheetOutcomes = outcomes;
@@ -1491,6 +1505,13 @@ export function createPostgresSchedulerProgressReporter(input: {
   // the two disagree; also the only terminal source when frames are missing
   // (detached push runs) and liveNodeProgress is empty (zero-event runs).
   const reconcileTerminalMapProgressFromSheetOutcomes = (): void => {
+    const conditionCounts = projectDocflowConditionCounts(
+      staticPipelineFromContractSnapshot(launch.contractSnapshot),
+      terminalSheetOutcomes,
+    );
+    for (const [nodeId, counts] of Object.entries(conditionCounts)) {
+      setNodeProgress(nodeId, { conditionCounts: counts });
+    }
     for (const outcome of terminalSheetOutcomes) {
       const tableNamespace = outcome.tableNamespace.trim();
       if (!tableNamespace) continue;
@@ -1650,6 +1671,7 @@ export function buildFailedTerminalSettledProgressEvents(input: {
     tableNamespace: string;
     completed: number;
     failed: number;
+    conditions?: Record<string, PlayConditionCounts>;
   }>;
   occurredAt: number;
 }): PlayRunLedgerEvent[] {
@@ -1680,6 +1702,21 @@ export function buildFailedTerminalSettledProgressEvents(input: {
       },
     });
   }
+  for (const [stepId, conditionCounts] of Object.entries(
+    projectDocflowConditionCounts(
+      staticPipelineFromContractSnapshot(input.launch.contractSnapshot),
+      input.outcomes,
+    ),
+  )) {
+    events.push({
+      type: 'step.progress',
+      runId: input.launch.runId,
+      source: 'worker',
+      occurredAt: input.occurredAt,
+      stepId,
+      progress: { conditionCounts },
+    });
+  }
   return events;
 }
 
@@ -1724,6 +1761,56 @@ export async function collectGatewayRunnerTerminalProgressLedgerEvents(input: {
       captured.update = update;
     },
   });
+  // The gateway can win terminal before the worker reconciles the sheet.
+  // Carry predicate summaries in that same durable terminal outbox prefix.
+  const pipeline = staticPipelineFromContractSnapshot(
+    input.launch.contractSnapshot,
+  );
+  if (
+    pipeline?.docflow?.nodes.some(
+      (node) => node.kind === 'decision' && !node.sketch,
+    )
+  ) {
+    const outcomes = [];
+    const namespaces = new Set(
+      (input.launch.preloadedDbSessions ?? [])
+        .filter((session) => session.logicalTable === 'sheet_rows')
+        .map((session) => session.tableNamespace),
+    );
+    for (const tableNamespace of namespaces) {
+      try {
+        outcomes.push({
+          tableNamespace,
+          ...(await readRuntimeSheetRowOutcomeCounts(
+            {
+              baseUrl: input.launch.baseUrl,
+              executorToken: input.launch.executorToken,
+              orgId: input.launch.orgId,
+              playName: input.launch.playName,
+              runId: input.launch.runId,
+              dbSessionStrategy: 'preloaded',
+              preloadedDbSessions:
+                input.launch.preloadedDbSessions ?? undefined,
+              postgresSessionUnwrapKey:
+                input.launch.preloadedDbSessionUnwrapKey ??
+                input.launch.executorToken,
+            },
+            { tableNamespace, includeConditions: true },
+          )),
+        });
+      } catch (error) {
+        console.warn(
+          '[postgres-scheduler.terminal_condition_reconcile_failed]',
+          {
+            runId: input.launch.runId,
+            tableNamespace,
+            error: error instanceof Error ? error.message : String(error),
+          },
+        );
+      }
+    }
+    reporter.applyTerminalSheetOutcomes(outcomes);
+  }
   for (const event of input.events) reporter.onRunnerEvent(event);
   await reporter.finalize(input.result, {
     status: 'running',

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

@@ -334,7 +334,9 @@ const POSTGRES_SCHEDULER_SCHEMA_INIT_STATEMENT_TIMEOUT_MS = 60_000;
 // index stays operator-prepared concurrently before marked-run admission.
 // v56 adds a release-leading index for fixed-controller runner-terminal
 // recovery, which scans only active runs for each release lane.
-export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 56;
+// v57 refreshes log-position lookups after the operator concurrently prepares
+// channel-specific indexes; outgoing readers retain the existing GIN index.
+export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 57;
 const POSTGRES_SCHEDULER_SCHEMA_MIGRATIONS_TABLE =
   'scheduler_schema_migrations';
 export const POSTGRES_SCHEDULER_OPEN_RECOVERY_INDEX =