deepline 0.3.286 → 0.3.288

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 =

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

@@ -22,6 +22,11 @@ const EVENTS_TABLE = 'runtime_observability.events';
 const RUNTIME_EVENT_LOG_DEDUPE_INDEX = 'runtime_events_log_attempt_digest_idx';
 const RUNTIME_EVENT_LOG_POSITION_INDEX =
   'runtime_events_log_attempt_position_idx';
+const RUNTIME_EVENT_LOG_POSITION_CHANNELS = [
+  'worker',
+  'replay',
+  'envelope',
+] as const;
 const RUNTIME_EVENT_LOG_LEGACY_INDEX =
   'runtime_events_legacy_log_normalize_idx';
 const RUNTIME_EVENT_LOG_BODY_PAGE_INDEX = 'runtime_events_run_log_body_seq_idx';
@@ -51,7 +56,7 @@ const RUNTIME_EVENT_LOG_POSITION_EXPRESSION = `jsonb_set(
 // Migration readiness tracks this projection body independently of scheduler
 // wire and schema versions. Bump when a changed trigger must be reinstalled.
 export const RUNTIME_EVENT_SEARCH_OUTBOX_PROJECTION_MARKER =
-  'runtime-event-search-log-context-v13-index-first-position';
+  'runtime-event-search-log-context-v14-btree-position';
 export const RUNTIME_EVENT_CANONICAL_RETENTION_INDEX_READY_MARKER =
   'runtime-event-canonical-retention-v1';
 export const RUNTIME_EVENTS_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
@@ -1263,10 +1268,7 @@ export async function attachRuntimeEventSearchTriggers(
                   'logPositions', jsonb_build_object(log_channel, log_position));
                 position_alias := jsonb_build_object(
                   'producerAttempt', (item->>'producerAttempt')::integer,
-                  '_runtimeScope:' || ${quoteLiteral(scope)}, true,
-                  '_orgId:' || run_org, true,
-                  '_runId:' || observation.run_id, true)
-                  || jsonb_build_object(log_channel, log_position);
+                  log_channel, log_position);
                 matched_event_id := NULL;
                 position_event_ids := ARRAY[
                   legacy_position_prefix || log_position::text,
@@ -1293,24 +1295,26 @@ export async function attachRuntimeEventSearchTriggers(
                  ORDER BY event.event_id
                  LIMIT 1;
                 IF matched_event_id IS NULL THEN
-                  -- A transport may already be aliased onto an event whose
-                  -- primary key belongs to another channel. Find that alias
-                  -- independently of content so changed bytes still fail the
-                  -- immutable-position check below. Materialize the scoped
-                  -- position lookup before applying run filters: otherwise
-                  -- the planner can choose the run-history index and inspect
-                  -- every old log for each incoming position, even with a
-                  -- custom plan. The indexed document already binds scope,
-                  -- org, run, attempt and channel position; retain the outer
-                  -- identity checks as defense in depth.
+                  -- Pack scope, organization and run into one indexed key.
+                  -- The materialization keeps generic plans from choosing a
+                  -- run-history scan based on the outer identity checks.
                   WITH position_matches AS MATERIALIZED (
+                    ${RUNTIME_EVENT_LOG_POSITION_CHANNELS.map(
+                      (channel) => `
                     SELECT event.event_id, event.source_digest, event.search_doc,
-                           event.runtime_scope, event.org_id, event.run_id, event.log_seq
+                           event.log_seq, event.runtime_scope, event.org_id, event.run_id
                       FROM runtime_observability.events AS event
-                     WHERE event.kind = ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}
+                     WHERE log_channel = '${channel}'
+                       AND ARRAY[event.runtime_scope, event.org_id, event.run_id]
+                         = ARRAY[${quoteLiteral(scope)}, run_org, observation.run_id]
+                       AND event.kind = ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}
                        AND event.search_doc ? 'producerAttempt'
                        AND event.search_doc ? 'logPositions'
-                       AND (${RUNTIME_EVENT_LOG_POSITION_EXPRESSION.replaceAll('search_doc', 'event.search_doc')}) @> position_alias
+                       AND (event.search_doc->'logPositions') ? '${channel}'
+                       AND event.search_doc->'producerAttempt' = position_alias->'producerAttempt'
+                       AND event.search_doc->'logPositions'->'${channel}' = position_alias->'${channel}'
+                    `,
+                    ).join(' UNION ALL ')}
                   )
                   SELECT event.event_id, event.source_digest, event.search_doc
                     INTO matched_event_id, existing_digest, matched_doc
@@ -2034,8 +2038,27 @@ const RUNTIME_EVENT_LOG_POSITION_INDEX_SPEC: RuntimeEventIndexExpectation = {
       WHERE ${RUNTIME_EVENT_LOG_POSITION_PREDICATE}`,
 };
 
+const RUNTIME_EVENT_LOG_CHANNEL_POSITION_INDEXES: RuntimeEventIndexExpectation[] =
+  RUNTIME_EVENT_LOG_POSITION_CHANNELS.map((channel) => ({
+    name: `runtime_events_log_${channel}_position_idx`,
+    keys: [
+      'ARRAY[runtime_scope, org_id, run_id]',
+      "(search_doc -> 'producerAttempt'::text)",
+      `(search_doc -> 'logPositions'::text) -> '${channel}'::text`,
+    ],
+    predicate: `${RUNTIME_EVENT_LOG_POSITION_PREDICATE}
+      AND (search_doc->'logPositions') ? '${channel}'`,
+    createSql: `CREATE INDEX CONCURRENTLY IF NOT EXISTS runtime_events_log_${channel}_position_idx
+      ON runtime_observability.events
+        ((ARRAY[runtime_scope, org_id, run_id]), (search_doc->'producerAttempt'),
+         (search_doc->'logPositions'->'${channel}'))
+      WHERE ${RUNTIME_EVENT_LOG_POSITION_PREDICATE}
+        AND (search_doc->'logPositions') ? '${channel}'`,
+  }));
+
 const RUNTIME_EVENT_QUERY_INDEXES: RuntimeEventIndexExpectation[] = [
   RUNTIME_EVENT_LOG_POSITION_INDEX_SPEC,
+  ...RUNTIME_EVENT_LOG_CHANNEL_POSITION_INDEXES,
   {
     name: RUNTIME_EVENT_LOG_DEDUPE_INDEX,
     keys: [
@@ -2167,20 +2190,25 @@ async function prepareRuntimeEventQueryIndex(
 export async function hasRuntimeEventLogPositionIndex(
   client: PostgresSchedulerQueryClient,
 ): Promise<boolean> {
-  return hasRuntimeEventQueryIndex(
-    client,
+  for (const expected of [
     RUNTIME_EVENT_LOG_POSITION_INDEX_SPEC,
-  );
+    ...RUNTIME_EVENT_LOG_CHANNEL_POSITION_INDEXES,
+  ]) {
+    if (!(await hasRuntimeEventQueryIndex(client, expected))) return false;
+  }
+  return true;
 }
 
-/** Prepare the existing position index before replacing the projection body. */
+/** Prepare old and new position indexes before replacing the projection body. */
 export async function prepareRuntimeEventLogPositionIndex(
   client: PostgresSchedulerQueryClient,
 ): Promise<void> {
-  await prepareRuntimeEventQueryIndex(
-    client,
+  for (const expected of [
     RUNTIME_EVENT_LOG_POSITION_INDEX_SPEC,
-  );
+    ...RUNTIME_EVENT_LOG_CHANNEL_POSITION_INDEXES,
+  ]) {
+    await prepareRuntimeEventQueryIndex(client, expected);
+  }
 }
 
 /** Build only operator-owned indexes, concurrently and outside a transaction. */

package/dist/bundling-sources/shared_libs/play-runtime/secret-redaction.ts

@@ -188,6 +188,7 @@ export type SecretRedactionContext = {
   /** Redacts only values registered by the secret resolver, preserving safe diagnostics. */
   redactRegisteredSecrets(value: string): string;
   redactString(value: string): string;
+  /** Redacts registered credential values recursively, without guessing from field names or patterns. */
   redactKnownSecrets<T>(value: T): T;
   redact<T>(value: T): T;
 };
@@ -335,7 +336,7 @@ export function createSecretRedactionContext(
   }
 
   function redactKnownSecrets<T>(value: T): T {
-    if (typeof value === 'string') return redactString(value) as T;
+    if (typeof value === 'string') return redactRegisteredSecrets(value) as T;
     if (Array.isArray(value)) {
       return value.map((entry) => redactKnownSecrets(entry)) as T;
     }
@@ -360,3 +361,48 @@ export function createSecretRedactionContext(
     redact,
   };
 }
+
+const REQUEST_CREDENTIAL_HEADER_NAMES = new Set([
+  'authorization',
+  'cookie',
+  'proxy-authorization',
+  'x-api-key',
+  'api-key',
+  'apikey',
+  'x-auth',
+  'auth-token',
+  'access-token',
+  'refresh-token',
+  'session-token',
+  'x-auth-token',
+  'x-access-token',
+  'x-refresh-token',
+  'x-session-token',
+]);
+
+export function createRequestHeaderSecretRedactionContext(
+  headers: Readonly<Record<string, string>>,
+  sensitiveHeaders: readonly string[] = [],
+): SecretRedactionContext {
+  const redactor = createSecretRedactionContext();
+  const declared = new Set(sensitiveHeaders.map((name) => name.toLowerCase()));
+  for (const [name, value] of Object.entries(headers)) {
+    const normalizedName = name.toLowerCase();
+    if (
+      !REQUEST_CREDENTIAL_HEADER_NAMES.has(normalizedName) &&
+      !declared.has(normalizedName)
+    ) {
+      continue;
+    }
+    redactor.register(value);
+    const auth = /^(?:bearer|basic)\s+(.+)$/i.exec(value.trim());
+    if (auth?.[1]) redactor.register(auth[1]);
+    if (normalizedName === 'cookie') {
+      for (const pair of value.split(';')) {
+        const separator = pair.indexOf('=');
+        if (separator > 0) redactor.register(pair.slice(separator + 1).trim());
+      }
+    }
+  }
+  return redactor;
+}

package/dist/bundling-sources/shared_libs/play-runtime/step-progress.ts

@@ -1,4 +1,17 @@
-import type { PlayStaticSubstep } from '../plays/static-pipeline';
+import {
+  getTopLevelPipelineSubsteps,
+  type PlayStaticPipeline,
+  type PlayStaticSubstep,
+} from '../plays/static-pipeline';
+import {
+  docflowOutputRoots,
+  flattenSubsteps,
+  resolveDocflowOwnerDataset,
+} from '../plays/docflow-binding-owner';
+import {
+  normalizePlayConditionCounts,
+  type PlayConditionCounts,
+} from './cell-provenance';
 import {
   normalizePlayDocflowNodeIoState,
   type PlayDocflowNodeIoState,
@@ -32,6 +45,7 @@ export type PlayVisualNodeProgress = {
   completedAt?: number | null;
   artifactTableNamespace?: string | null;
   nodeIo?: PlayDocflowNodeIoState;
+  conditionCounts?: PlayConditionCounts;
 };
 
 export type PlayVisualNodeState = {
@@ -162,6 +176,9 @@ export function normalizePlayVisualNodeProgressMap(
           ? null
           : undefined;
     const nodeIo = normalizePlayDocflowNodeIoState(rawProgress.nodeIo);
+    const conditionCounts = normalizePlayConditionCounts(
+      rawProgress.conditionCounts,
+    );
 
     normalized[nodeId] = {
       ...(completed !== undefined ? { completed } : {}),
@@ -180,11 +197,76 @@ export function normalizePlayVisualNodeProgressMap(
         ? { artifactTableNamespace }
         : {}),
       ...(nodeIo ? { nodeIo } : {}),
+      ...(conditionCounts ? { conditionCounts } : {}),
     };
   }
   return normalized;
 }
 
+/** Join observed predicates to authored decision nodes by their owning column. */
+export function projectDocflowConditionCounts(
+  pipeline: PlayStaticPipeline | null | undefined,
+  sheets: readonly {
+    tableNamespace: string;
+    conditions?: Record<string, PlayConditionCounts>;
+  }[],
+): Record<string, PlayConditionCounts> {
+  if (!pipeline?.docflow) return {};
+  const substeps = getTopLevelPipelineSubsteps(pipeline);
+  const namespaces = flattenSubsteps(substeps)
+    .filter((step) => step.type === 'dataset' || step.type === 'csv')
+    .map((step) =>
+      step.type === 'dataset'
+        ? (step.tableNamespace ?? step.field)
+        : step.field,
+    )
+    .sort((a, b) => b.length - a.length);
+  const decisions = new Set(
+    pipeline.docflow.nodes
+      .filter((node) => node.kind === 'decision' && !node.sketch)
+      .map((node) => node.id),
+  );
+  const result: Record<string, PlayConditionCounts> = {};
+  for (const binding of pipeline.docflow.bindings) {
+    if (!decisions.has(binding.nodeId)) continue;
+    const owner = resolveDocflowOwnerDataset(binding, substeps).substep;
+    if (!owner) continue;
+    const namespace = owner.tableNamespace ?? owner.field;
+    const roots = docflowOutputRoots(binding);
+    // Several output columns can carry different predicates. Do not combine them.
+    if (roots.length !== 1) continue;
+    const root = roots[0]!;
+    const column = owner.sheetContract?.columns.find(
+      (candidate) =>
+        candidate.field === root ||
+        candidate.id === root ||
+        candidate.sqlName === root,
+    );
+    const key = column?.sqlName ?? root;
+    for (const sheet of sheets) {
+      const sheetOwner = namespaces.find(
+        (candidate) =>
+          sheet.tableNamespace === candidate ||
+          sheet.tableNamespace.startsWith(`${candidate}_`),
+      );
+      if (sheetOwner !== namespace) continue;
+      const counts = normalizePlayConditionCounts(
+        sheet.conditions?.[key] ?? sheet.conditions?.[root],
+      );
+      if (!counts) continue;
+      const current = result[`docflow:${binding.nodeId}`] ?? {
+        true: 0,
+        false: 0,
+      };
+      result[`docflow:${binding.nodeId}`] = {
+        true: current.true + counts.true,
+        false: current.false + counts.false,
+      };
+    }
+  }
+  return result;
+}
+
 export function applyVisualNodeProgress(input: {
   nodeStates: readonly PlayVisualNodeState[];
   progressByNode: PlayVisualNodeProgressMap;

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

@@ -1,5 +1,6 @@
 import type { PlayDocflowNodeIoState } from './docflow-node-io';
 import type { PlayMapRowActivitySource } from './run-ledger';
+import type { PlayConditionCounts } from './cell-provenance';
 
 export type PlayStagedFileRef = {
   storageKind: 'r2';
@@ -33,6 +34,7 @@ export type PlayVisualNodeProgress = {
   completedAt?: number;
   artifactTableNamespace?: string | null;
   nodeIo?: PlayDocflowNodeIoState;
+  conditionCounts?: PlayConditionCounts;
 };
 
 export type PlayVisualNodeProgressMap = Record<string, PlayVisualNodeProgress>;