deepline 0.3.285 → 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.
    *
@@ -3681,8 +3704,7 @@ export class DeeplineClient {
   /**
    * Compile legacy enrich command arguments into a runtime plan.
    *
-   * This is primarily used by CLI compatibility paths that translate older
-   * enrichment commands onto the play runtime.
+   * @deprecated Retained for older clients. Use Plays for new enrichment workflows.
    */
   async compileEnrichPlan(input: {
     plan_args?: string[];

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.285',
+  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/context.ts

@@ -160,6 +160,7 @@ import {
   attachRelayPublishedToolResultReference,
   attachToolResultListDataset,
   createToolExecuteResult,
+  projectNativeBatchToolResponse,
   parseToolExecuteResponse,
   isToolExecuteResult,
   isSerializedToolExecuteResult,
@@ -1449,6 +1450,18 @@ function publicToolResponseEnvelope(value: unknown): {
   };
 }
 
+function nativeBatchResponseMeta(result: unknown): Record<string, unknown> {
+  return {
+    nativeBatchResponseView:
+      result &&
+      typeof result === 'object' &&
+      !Array.isArray(result) &&
+      Object.prototype.hasOwnProperty.call(result, 'data')
+        ? 'data'
+        : 'rawV2',
+  };
+}
+
 /**
  * A batched provider request returns one envelope for several logical source
  * tool calls. Each source call persists only its own item-shaped canonical
@@ -7362,6 +7375,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   private materializeToolExecutionResult(
     result: ToolExecuteResult,
   ): ToolExecuteResult {
+    result = projectNativeBatchToolResponse(
+      result,
+      this.currentRuntimeContract.semantics.tools.nativeBatchResponse,
+    );
     if (
       this.currentToolResponseContract === RAW_V2_TOOL_RESPONSE_CONTRACT ||
       !this.hasPinnedToolResponseContract ||
@@ -16157,6 +16174,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                       toolId,
                       status: aggregate.status,
                       result: item,
+                      meta: nativeBatchResponseMeta(item),
                       toolResponse: publicToolResponseForBatchedItem(
                         aggregate,
                         item,
@@ -16601,6 +16619,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                           request,
                           result: splitResults[index] ?? null,
                           status: batchExecution?.execution.status,
+                          meta: nativeBatchResponseMeta(
+                            splitResults[index] ?? null,
+                          ),
                           toolResponse:
                             batchExecution == null
                               ? undefined

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/play-runs/sandbox-cleanup/job.ts

@@ -57,6 +57,24 @@ export function createSandboxCleanupJob(
           return await scheduleRetry(ports, input, deletion.detail);
         }
 
+        const expectedRoutingDomain =
+          input.resource.routingDomain?.trim() || null;
+        const observedRoutingDomain = deletion.routingDomain?.trim() || null;
+        // Confirmed deletion can establish a missing legacy domain; absence cannot.
+        const confirmedRoutingDomain =
+          deletion.kind === 'deleted'
+            ? expectedRoutingDomain === null ||
+              expectedRoutingDomain === observedRoutingDomain
+            : expectedRoutingDomain !== null &&
+              expectedRoutingDomain === observedRoutingDomain;
+        if (!confirmedRoutingDomain) {
+          return await scheduleRetry(
+            ports,
+            input,
+            `${input.resource.provider} sandbox ${input.resource.sandboxId} cleanup confirmation used the wrong routing domain.`,
+          );
+        }
+
         // A control-plane retry must never keep a provider-confirmed-deleted
         // resource consuming capacity. This precedes cleanup row completion.
         await ports.store.releaseCapacity({ resource: input.resource });

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

@@ -42,6 +42,9 @@ export type PlayRuntimeSemantics = Readonly<{
      */
     runtimeOnly: boolean;
   }>;
+  tools: Readonly<{
+    nativeBatchResponse: 'legacy_envelope' | 'logical_response';
+  }>;
   slackHitl: Readonly<{
     defaultTimeoutMs: number;
   }>;
@@ -60,6 +63,7 @@ function definePlayRuntimeSemantics(
     secrets: Object.freeze({ ...semantics.secrets }),
     fetch: Object.freeze({ ...semantics.fetch }),
     inlineChild: Object.freeze({ ...semantics.inlineChild }),
+    tools: Object.freeze({ ...semantics.tools }),
     slackHitl: Object.freeze({ ...semantics.slackHitl }),
   });
 }
@@ -73,6 +77,7 @@ const LEGACY_SEMANTICS = {
     receiptIdentityEdition: null,
   },
   inlineChild: { runtimeOnly: false },
+  tools: { nativeBatchResponse: 'legacy_envelope' },
 } as const;
 
 const STRICT_SEMANTICS = {
@@ -164,6 +169,17 @@ const PLAY_RUNTIME_SEMANTICS_BY_AUTHORING = {
     inlineChild: { runtimeOnly: true },
     slackHitl: WEEK_LONG_SLACK_HITL_SEMANTICS,
   },
+  9: {
+    ...PLAINTEXT_SECRET_SEMANTICS,
+    fetch: {
+      httpFailure: 'throw_typed_error',
+      persistHttpFailure: false,
+      receiptIdentityEdition: FETCH_RECEIPT_IDENTITIES.typedHttpFailure,
+    },
+    inlineChild: { runtimeOnly: true },
+    tools: { nativeBatchResponse: 'logical_response' },
+    slackHitl: WEEK_LONG_SLACK_HITL_SEMANTICS,
+  },
 } satisfies Record<PlayAuthoringContractEdition, PlayRuntimeSemanticsTemplate>;
 
 const PLAY_RUNTIME_SEMANTICS = Object.fromEntries(

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) {
@@ -4102,6 +4121,15 @@ async function executeAssignedAbsurdAttempt(input: {
                             runnerResource.kind,
                           ),
                           sandboxId: runnerResource.sandboxId,
+                          environment:
+                            runnerResource.runtimeEnvironment ??
+                            runnerResource.daytonaEnvironment ??
+                            'production',
+                          routingDomain:
+                            runnerResource.kind === 'daytona_sandbox'
+                              ? runnerResource.daytonaOrganizationId?.trim() ||
+                                null
+                              : runnerResource.modalAppId?.trim() || null,
                         },
                         options,
                       );