deepline 0.3.233 → 0.3.235

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.233',
+  version: '0.3.235',
   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/play-data-plane/sheet-column-storage.ts

@@ -245,8 +245,74 @@ export const RuntimeSheetColumns = {
     // jsonb_populate_record maps JSON null to SQL NULL. A legacy JSONB cell
     // must retain explicit JSON null, distinct from an omitted/SQL NULL cell.
     if (type === 'jsonb') return jsonExpression;
-    // Resolve the actual row type inside PostgreSQL, never from a cached
-    // contract. This also preserves JSON scalar strings for legacy JSONB.
+    // These types come from the locked, live catalog. Extract scalar text
+    // before casting so JSON null becomes SQL NULL and strings stay unquoted.
+    if (type === 'boolean' || type === 'double precision' || type === 'text')
+      return `((${jsonExpression}) #>> '{}')::${type}`;
+    // Preserve PostgreSQL's conversion rules for other pre-existing SQL types.
     return `(jsonb_populate_record(NULL::${tableReference}, jsonb_build_object(${literal(columnName)}, ${jsonExpression}))).${identifier(columnName)}`;
   },
+
+  /** Convert native cells once per input row; retain raw JSONB cell semantics. */
+  jsonRowSql(input: {
+    jsonExpression: string;
+    tableReference: string;
+    columns: readonly PhysicalSheetColumnProjection[];
+    types: RuntimeSheetColumnTypes;
+    alias?: string;
+    // Guard conversion itself when an existing row makes incoming cells inert.
+    when?: string;
+  }): { joinSql: string; valueSql: (columnName: string) => string } {
+    const alias = identifier(input.alias ?? '_typed_cells');
+    const columns = new Map(
+      input.columns.map((column) => [column.sqlName, column]),
+    );
+    const native = input.columns.filter((column) => {
+      const type = input.types.get(column.sqlName);
+      if (!type)
+        throw new Error(`Runtime Sheet column is missing: ${column.sqlName}`);
+      return (
+        type === 'boolean' || type === 'double precision' || type === 'text'
+      );
+    });
+    const nativeNames = new Set(native.map((column) => column.sqlName));
+    // Unmapped keys are ignored by jsonb_to_record. Remap only renamed fields,
+    // overriding any unrelated payload key that happens to use the SQL name.
+    const renamed = native.filter(
+      (column) => column.sqlName !== column.fieldName,
+    );
+    let payload = `(${input.jsonExpression})`;
+    // jsonb_build_object accepts at most 100 arguments (50 key/value pairs).
+    for (let offset = 0; offset < renamed.length; offset += 50) {
+      payload += ` || jsonb_build_object(${renamed
+        .slice(offset, offset + 50)
+        .map(
+          (column) =>
+            `${literal(column.sqlName)}, (${input.jsonExpression}) -> ${literal(column.fieldName)}`,
+        )
+        .join(', ')})`;
+    }
+    if (input.when)
+      payload = `CASE WHEN ${input.when} THEN ${payload} ELSE NULL::jsonb END`;
+    const joinSql =
+      native.length === 0
+        ? ''
+        : `CROSS JOIN LATERAL jsonb_to_record(${payload}) AS ${alias}(${native.map((column) => `${identifier(column.sqlName)} ${input.types.get(column.sqlName)}`).join(', ')})`;
+    return {
+      joinSql,
+      valueSql(columnName: string): string {
+        const column = columns.get(columnName);
+        if (!column)
+          throw new Error(`Runtime Sheet column is missing: ${columnName}`);
+        if (nativeNames.has(columnName))
+          return `${alias}.${identifier(columnName)}`;
+        return RuntimeSheetColumns.jsonValueSql(
+          `(${input.jsonExpression}) -> ${literal(column.fieldName)}`,
+          input.tableReference,
+          columnName,
+          input.types,
+        );
+      },
+    };
+  },
 };

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

@@ -43,6 +43,7 @@ export type PlayRunRecoveryReason =
   | 'modal_runner_start_failed_before_execution'
   | 'daytona_sandbox_transition_pending_before_execution'
   | 'daytona_sandbox_acquisition_unavailable_before_execution'
+  | 'runtime_scheduler_unavailable_before_execution'
   | 'runtime_initialization_transport_before_execution'
   | 'runtime_traffic_hold_before_execution'
   | 'runtime_traffic_throttled_before_execution';
@@ -211,6 +212,27 @@ export function recoveryForRuntimeTrafficPolicy(input: {
   });
 }
 
+/**
+ * Scheduler admission must be durable before a provider create. If that
+ * control-plane read/write is temporarily unavailable, defer through the
+ * recovery ledger instead of turning an unstarted Play into a runner failure.
+ */
+export function recoveryForRuntimeSchedulerAdmissionFailure(
+  error: unknown,
+): PlayRunRecoveryError {
+  return new PlayRunRecoveryError({
+    decision: {
+      stage: 'pre_code',
+      action: 'defer',
+      reason: 'runtime_scheduler_unavailable_before_execution',
+      dependency: 'runtime',
+    },
+    message:
+      'Runtime scheduler admission is temporarily unavailable before customer execution began.',
+    cause: error,
+  });
+}
+
 /**
  * Daytona acknowledged a named sandbox but has not finished creating it.
  * Resume that durable provider operation after a bounded defer; another

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona.ts

@@ -38,7 +38,10 @@ import {
   type OneShotDaytonaSandboxLifecycle,
   validateDaytonaExecutionContext,
 } from './daytona-lifecycle';
-import { recoveryForDaytonaSandboxTransitionPending } from '../../play-run-recovery-policy';
+import {
+  isPlayRunRecoveryError,
+  recoveryForDaytonaSandboxTransitionPending,
+} from '../../play-run-recovery-policy';
 import { stageDaytonaRunnerPayload } from './daytona-payload-transport';
 import {
   DaytonaRunnerInitializationError,
@@ -1819,6 +1822,9 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
       if (error instanceof DaytonaSandboxAcquisitionUnavailableError) {
         throw error;
       }
+      if (isPlayRunRecoveryError(error)) {
+        throw error;
+      }
       emitDaytonaStage(callbacks, config.context, 'execute:error', {
         sandboxId: sandboxCleanup.currentSandbox()?.id ?? null,
         runnerAttempt: Math.max(0, Math.floor(config.context.runAttempt ?? 0)),

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

@@ -3406,16 +3406,20 @@ async function writeRuntimeRows(
             .map((entry) => entry.row);
         },
       });
+      const incomingRow = RuntimeSheetColumns.jsonRowSql({
+        jsonExpression: 'input_rows.payload',
+        tableReference: sheetTable(session),
+        columns: physicalColumnProjections,
+        types: columnTypes,
+        ...(input.mode === 'upsert'
+          ? { when: 'existing_input._key IS NULL' }
+          : {}),
+      });
       const physicalInsertValuesSql =
         physicalColumns.length > 0
           ? `, ${physicalColumnProjections
               .map((column) => {
-                const incoming = RuntimeSheetColumns.jsonValueSql(
-                  `input_rows.payload -> ${quoteLiteral(column.fieldName)}`,
-                  sheetTable(session),
-                  column.sqlName,
-                  columnTypes,
-                );
+                const incoming = incomingRow.valueSql(column.sqlName);
                 return input.mode === 'upsert'
                   ? `CASE WHEN existing_input._key IS NOT NULL THEN existing_input.${quoteIdentifier(column.sqlName)} ELSE ${incoming} END`
                   : incoming;
@@ -3476,6 +3480,7 @@ async function writeRuntimeRows(
                 SELECT input_rows._key, 'pending', $4::text, input_rows._input_index, now()${physicalInsertValuesSql}
                 FROM input_rows
                 LEFT JOIN ${sheetTable(session)} AS existing_input ON existing_input._key = input_rows._key
+                ${incomingRow.joinSql}
                 ON CONFLICT (_key) DO UPDATE SET
                   _status = 'pending',
                   _run_id = EXCLUDED._run_id,
@@ -3487,8 +3492,9 @@ async function writeRuntimeRows(
               ),`
             : `inserted_rows AS (
                 INSERT INTO ${sheetTable(session)} (_key, _status, _run_id, _input_index, _created_at${physicalInsertColumnsSql})
-                SELECT _key, 'pending', $4::text, _input_index, now()${physicalInsertValuesSql}
+                SELECT input_rows._key, 'pending', $4::text, input_rows._input_index, now()${physicalInsertValuesSql}
                 FROM input_rows
+                ${incomingRow.joinSql}
                 RETURNING _key
               ),`;
 
@@ -3645,6 +3651,7 @@ async function prepareRuntimeSheetDatasetRows(
     writeVersion: number;
     physicalInsertColumnsSql: string;
     physicalInsertValuesSql: string;
+    physicalInsertJoinSql: string;
     physicalRefreshSetSql: string;
     physicalUpsertSetSql: string;
     outputPhysicalColumns: PhysicalSheetColumnProjection[];
@@ -3803,6 +3810,7 @@ async function prepareRuntimeSheetDatasetRows(
           SELECT input_rows._key, 'pending', $4::text, input_rows._input_index, $7::text, $8::text, $9::timestamptz, $10::integer, $12::bigint, $4::text, now()${input.physicalInsertValuesSql}
           FROM input_rows
           LEFT JOIN ${sheetTable(session)} AS existing_input ON existing_input._key = input_rows._key
+          ${input.physicalInsertJoinSql}
           ON CONFLICT (_key) DO UPDATE SET
             _status = 'pending',
             _run_id = EXCLUDED._run_id,
@@ -4097,6 +4105,7 @@ async function prepareNetNewRuntimeSheetDatasetRows(
     writeVersion: number;
     physicalInsertColumnsSql: string;
     physicalInsertValuesSql: string;
+    physicalInsertJoinSql: string;
   },
 ): Promise<{
   inserted: number;
@@ -4152,6 +4161,7 @@ async function prepareNetNewRuntimeSheetDatasetRows(
               $7::timestamptz, $8::integer, $9::bigint, $4::text, now()${input.physicalInsertValuesSql}
        FROM input_rows
        LEFT JOIN ${sheetTable(session)} AS existing_input ON existing_input._key = input_rows._key
+       ${input.physicalInsertJoinSql}
        ON CONFLICT (_key) DO NOTHING
        RETURNING _key
        ),
@@ -6772,16 +6782,23 @@ export async function startRuntimeSheetDataset(
           });
         },
       });
+      const incomingRow = RuntimeSheetColumns.jsonRowSql({
+        jsonExpression: 'input_rows.payload',
+        tableReference: sheetTable(session),
+        columns: physicalSheetColumnProjections(input.sheetContract).map(
+          (column) => ({ ...column, fieldName: column.sqlName }),
+        ),
+        types: columnTypes,
+        when:
+          input.mode === 'net_new'
+            ? 'existing_input._key IS NULL'
+            : "existing_input._key IS NULL OR existing_input._status = 'stale'",
+      });
       const physicalInsertValuesSql =
         physicalColumns.length > 0
           ? `, ${physicalColumns
               .map((column) => {
-                const incoming = RuntimeSheetColumns.jsonValueSql(
-                  `input_rows.payload -> ${quoteLiteral(column)}`,
-                  sheetTable(session),
-                  column,
-                  columnTypes,
-                );
+                const incoming = incomingRow.valueSql(column);
                 const preserveExisting =
                   input.mode === 'net_new'
                     ? 'existing_input._key IS NOT NULL'
@@ -6817,6 +6834,7 @@ export async function startRuntimeSheetDataset(
               writeVersion,
               physicalInsertColumnsSql,
               physicalInsertValuesSql,
+              physicalInsertJoinSql: incomingRow.joinSql,
             })
           : await prepareRuntimeSheetDatasetRows(client, session, {
               chunks,
@@ -6830,6 +6848,7 @@ export async function startRuntimeSheetDataset(
               writeVersion,
               physicalInsertColumnsSql,
               physicalInsertValuesSql,
+              physicalInsertJoinSql: incomingRow.joinSql,
               physicalRefreshSetSql:
                 input.force === true ? physicalRefreshSetSql : '',
               physicalUpsertSetSql,
@@ -8095,17 +8114,16 @@ async function insertMissingCompletedMapRowChunks(
         return accepted.rows.map((row) => row.data_patch);
       },
     });
+    const incomingRow = RuntimeSheetColumns.jsonRowSql({
+      jsonExpression: 'missing_rows.data_patch',
+      tableReference: sheetTable(session),
+      columns: input.physicalColumnProjections,
+      types: columnTypes,
+    });
     const physicalInsertValuesSql =
       input.physicalColumnProjections.length > 0
         ? `, ${input.physicalColumnProjections
-            .map((column) =>
-              RuntimeSheetColumns.jsonValueSql(
-                `missing_rows.data_patch -> ${quoteLiteral(column.fieldName)}`,
-                sheetTable(session),
-                column.sqlName,
-                columnTypes,
-              ),
-            )
+            .map((column) => incomingRow.valueSql(column.sqlName))
             .join(', ')}`
         : '';
 
@@ -8123,7 +8141,9 @@ async function insertMissingCompletedMapRowChunks(
          JOIN unnest($4::jsonb[]) WITH ORDINALITY AS cell_meta_values(cell_meta_patch, ord)
            ON cell_meta_values.ord = key_values.ord
        ),
-       missing_rows AS (
+       -- Decode only accepted rows: a rejected replay may contain values
+       -- incompatible with the stored native types.
+       missing_rows AS MATERIALIZED (
          SELECT input_rows.*
            FROM input_rows
           WHERE NOT EXISTS (
@@ -8150,17 +8170,18 @@ async function insertMissingCompletedMapRowChunks(
            _created_at,
            _cell_meta${physicalInsertColumnsSql}
          )
-         SELECT _key,
+         SELECT missing_rows._key,
                 'enriched',
                 $5::text,
-                input_index,
+                missing_rows.input_index,
                 $8::text,
                 $9::text,
                 $10::timestamptz,
                 $11::integer,
                 now(),
-                cell_meta_patch${physicalInsertValuesSql}
+                missing_rows.cell_meta_patch${physicalInsertValuesSql}
            FROM missing_rows
+           ${incomingRow.joinSql}
          ON CONFLICT (_key) DO NOTHING
          RETURNING _key
        ),

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

@@ -50,6 +50,7 @@ import { runtimeLimitExceededCause } from '../run-failure';
 import {
   recoveryForDaytonaSandboxAcquisitionUnavailable,
   recoveryForRuntimeInitializationTransportFailure,
+  recoveryForRuntimeSchedulerAdmissionFailure,
   recoveryForRuntimeTrafficPolicy,
 } from '../play-run-recovery-policy';
 import type { PlayCheckpoint } from '../ctx-types';
@@ -208,9 +209,10 @@ import {
 } from './absurd-worker-required-env';
 import {
   acquirePgNotifyHub,
+  isConnectionCategoryError,
   isRuntimeSchedulerCapacityError,
+  isRuntimeSchedulerQueryCancellationError,
   isRuntimeSchedulerRetryableTransactionError,
-  isConnectionCategoryError,
   parseRuntimeSchedulerCapacityError,
   RuntimeSchedulerCapacityError,
   runtimeSchedulerCapacityRetryAfterMs,
@@ -3490,22 +3492,85 @@ async function executeAssignedAbsurdAttempt(input: {
                     );
                   }
                   const mode = runtimeSandboxCapacityAdmissionMode();
-                  const reserved = await deps.runWithClient((client) =>
-                    reserveRuntimeSandboxOperation(
-                      client,
+                  const reservationInput = {
+                    orgId: launch.orgId,
+                    runId,
+                    provider,
+                    mode,
+                    attempt: generation,
+                    environment: 'production' as const,
+                    resumePendingDaytonaOperation: provider === 'daytona',
+                    operationKey: `sandbox-operation:${runId}:${generation}:${provider}:${providerAttempt ?? 1}`,
+                  };
+                  const reserve = () =>
+                    deps.runWithClient((client) =>
+                      reserveRuntimeSandboxOperation(
+                        client,
+                        reservationInput,
+                        options,
+                      ),
+                    );
+                  const deferForSchedulerFailure = (error: unknown): never => {
+                    console.warn(
+                      '[absurd-runtime.worker] sandbox_capacity_admission_deferred',
                       {
-                        orgId: launch.orgId,
                         runId,
                         provider,
-                        mode,
-                        attempt: generation,
-                        environment: 'production',
-                        resumePendingDaytonaOperation: provider === 'daytona',
-                        operationKey: `sandbox-operation:${runId}:${generation}:${provider}:${providerAttempt ?? 1}`,
+                        providerAttempt: providerAttempt ?? 1,
+                        error:
+                          error instanceof Error
+                            ? error.message
+                            : String(error),
                       },
-                      options,
-                    ),
-                  );
+                    );
+                    throw recoveryForRuntimeSchedulerAdmissionFailure(error);
+                  };
+                  const isRetryableSchedulerFailure = (error: unknown) =>
+                    isRuntimeSchedulerCapacityError(error) ||
+                    isConnectionCategoryError(error) ||
+                    isRuntimeSchedulerRetryableTransactionError(error) ||
+                    isRuntimeSchedulerQueryCancellationError(error);
+                  let reserved: Awaited<ReturnType<typeof reserve>> | null =
+                    null;
+                  try {
+                    reserved = await reserve();
+                  } catch (error) {
+                    if (isRuntimeSchedulerQueryCancellationError(error)) {
+                      // A query timeout has an ambiguous outcome. The stable
+                      // operation key makes this reservation safe to repeat:
+                      // a committed first attempt is read back, and a missing
+                      // one is inserted once.
+                      console.warn(
+                        '[absurd-runtime.worker] sandbox_capacity_admission_retry',
+                        {
+                          runId,
+                          provider,
+                          providerAttempt: providerAttempt ?? 1,
+                          error:
+                            error instanceof Error
+                              ? error.message
+                              : String(error),
+                        },
+                      );
+                      try {
+                        reserved = await reserve();
+                      } catch (retryError) {
+                        if (!isRetryableSchedulerFailure(retryError)) {
+                          throw retryError;
+                        }
+                        deferForSchedulerFailure(retryError);
+                      }
+                    } else if (isRetryableSchedulerFailure(error)) {
+                      deferForSchedulerFailure(error);
+                    } else {
+                      throw error;
+                    }
+                  }
+                  if (reserved === null) {
+                    throw new Error(
+                      'Runtime scheduler sandbox capacity reservation returned no result.',
+                    );
+                  }
                   if (!reserved.granted) {
                     throw new RuntimeSandboxCapacityLimitError({
                       orgId: launch.orgId,

package/dist/cli/index.js

@@ -3454,7 +3454,7 @@ var 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.233",
+  version: "0.3.235",
   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: {
     updatePreferences: 1

package/dist/cli/index.mjs

@@ -3449,7 +3449,7 @@ var 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.233",
+  version: "0.3.235",
   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: {
     updatePreferences: 1

package/dist/index.js

@@ -1267,7 +1267,7 @@ var 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.233",
+  version: "0.3.235",
   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: {
     updatePreferences: 1

package/dist/index.mjs

@@ -1171,7 +1171,7 @@ var 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.233",
+  version: "0.3.235",
   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: {
     updatePreferences: 1

package/dist/release.d.mts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.233";
+    readonly version: "0.3.235";
     readonly 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.";
     readonly packageCapabilities: {
         readonly updatePreferences: 1;

package/dist/release.d.ts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.233";
+    readonly version: "0.3.235";
     readonly 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.";
     readonly packageCapabilities: {
         readonly updatePreferences: 1;

package/dist/release.js

@@ -74,7 +74,7 @@ var 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.233",
+  version: "0.3.235",
   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: {
     updatePreferences: 1

package/dist/release.mjs

@@ -48,7 +48,7 @@ var 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.233",
+  version: "0.3.235",
   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: {
     updatePreferences: 1

package/dist/viewer/viewer.css

@@ -737,7 +737,7 @@ body {
     top: -24px;
     z-index: 20;
     display: grid;
-    grid-template-columns: minmax(180px, 1.2fr) minmax(170px, 1.2fr) repeat(4, minmax(120px, .75fr)) auto auto;
+    grid-template-columns: minmax(180px, 1.2fr) minmax(170px, 1.2fr) repeat(5, minmax(120px, .75fr)) auto auto;
     gap: 8px;
     align-items: end;
     margin: -24px -32px 18px;
@@ -902,6 +902,7 @@ body {
 .expectation-result.pass { color: var(--green); }
 .expectation-result.fail { color: var(--red); }
 .expectation-result.unknown { color: var(--yellow); }
+.grading-detail { margin-top: 3px; color: var(--text-dim); white-space: pre-wrap; }
 .expectation-failure-reason {
     margin-top: 5px;
     color: color-mix(in srgb, var(--red) 80%, var(--text-dim));

package/dist/viewer/viewer.js

@@ -1371,11 +1371,12 @@ let isLive = false;
 let liveIntervalId = null;
 let currentEval = '';
 let currentSelection = 'all';
-let sliceBy = 'run';
+let sliceBy = 'none';
 let runFilter = '';
 let agentFilter = 'all';
 let modelFilter = 'all';
 let skillFilter = 'all';
+let treatmentFilter = 'all';
 let visibleEvalKeys = [];
 let visibleSelectionKeys = [];
 
@@ -1444,6 +1445,7 @@ function attachEvalMetadata() {
             agent: firstPresent([metric && metric.agent], inferAgent(session.label, session.meta)),
             model: firstPresent([metric && metric.model_id, metric && metric.requested_model, metric && metric.model], inferModel(session.label, session.meta)),
             skill: firstPresent([metric && metric.invoke_skill], inferSkill(session)),
+            treatment: firstPresent([metric && metric.variant_id], 'Unrecorded treatment'),
         };
     });
 }
@@ -1457,7 +1459,7 @@ function sessionsForCurrentEval() {
 }
 
 function selectionDimensions() {
-    const dimensions = ['run', 'agent', 'model', 'skill'];
+    const dimensions = ['run', 'agent', 'model', 'skill', 'treatment'];
     return sliceBy === 'none' ? dimensions : dimensions.filter(dimension => dimension !== sliceBy);
 }
 
@@ -1471,6 +1473,7 @@ function selectionLabel(session) {
         agent: value => value,
         model: value => value,
         skill: value => value,
+        treatment: value => value,
     };
     return selectionDimensions().map(dimension => labels[dimension](session.dimensions[dimension])).join(' · ') || 'All transcripts';
 }
@@ -1481,7 +1484,8 @@ function matchesTopFilters(session) {
     if (agentFilter !== 'all' && d.agent !== agentFilter) return false;
     if (modelFilter !== 'all' && d.model !== modelFilter) return false;
     if (skillFilter !== 'all' && d.skill !== skillFilter) return false;
-    return !query || [session.label, d.eval, d.run, d.agent, d.model, d.skill].join(' ').toLowerCase().includes(query);
+    if (treatmentFilter !== 'all' && d.treatment !== treatmentFilter) return false;
+    return !query || [session.label, d.eval, d.run, d.agent, d.model, d.skill, d.treatment].join(' ').toLowerCase().includes(query);
 }
 
 function matchingConfigurations() {
@@ -1525,6 +1529,7 @@ function saveViewerState() {
         agentFilter: agentFilter,
         modelFilter: modelFilter,
         skillFilter: skillFilter,
+        treatmentFilter: treatmentFilter,
     }));
 }
 
@@ -1563,14 +1568,15 @@ function init() {
     currentEval = saved && visibleEvalKeys.includes(saved.currentEval)
         ? saved.currentEval
         : ((SESSIONS[Math.max(0, initialSession)] || {}).dimensions || {}).eval || visibleEvalKeys[0] || '';
-    sliceBy = saved && ['none', 'run', 'agent', 'model', 'skill'].includes(saved.sliceBy)
+    sliceBy = saved && ['none', 'run', 'agent', 'model', 'skill', 'treatment'].includes(saved.sliceBy)
         ? saved.sliceBy
-        : (SESSIONS.length > 1 ? 'run' : 'none');
+        : 'none';
     currentSelection = (saved && (saved.currentSelection || saved.currentRun)) || 'all';
     runFilter = (saved && saved.runFilter) || '';
     agentFilter = (saved && saved.agentFilter) || 'all';
     modelFilter = (saved && saved.modelFilter) || 'all';
     skillFilter = (saved && saved.skillFilter) || 'all';
+    treatmentFilter = (saved && saved.treatmentFilter) || 'all';
 
     if (SESSIONS.length > 1) {
         document.getElementById('sidebar').classList.remove('hidden');
@@ -1720,6 +1726,7 @@ function switchEval(index) {
     agentFilter = 'all';
     modelFilter = 'all';
     skillFilter = 'all';
+    treatmentFilter = 'all';
     renderSidebar();
     renderRunSidebar();
     renderWorkspace();
@@ -1744,7 +1751,7 @@ function switchSession(i) {
 
 function switchToCompare() {
     currentSelection = 'all';
-    sliceBy = 'run';
+    sliceBy = 'none';
     renderRunSidebar();
     renderWorkspace();
 }
@@ -1760,14 +1767,17 @@ function renderWorkspaceControls() {
     const agents = uniqueValues(sessions.map(s => s.dimensions.agent));
     const models = uniqueValues(sessions.map(s => s.dimensions.model));
     const skills = uniqueValues(sessions.map(s => s.dimensions.skill));
+    const treatments = uniqueValues(sessions.map(s => s.dimensions.treatment));
     return `<section class="workspace-controls" aria-label="Transcript filters">
         <div class="workspace-context"><span class="eyebrow">Evaluation</span><strong>${esc(currentEval)}</strong></div>
         <label class="control-field control-search"><span>Filter runs</span><input id="run-filter" value="${esc(runFilter)}" placeholder="model, skill, label…" oninput="runFilter=this.value" onkeydown="if(event.key==='Enter'){applyWorkspaceFilters()}"></label>
         <label class="control-field"><span>Agent</span><select id="agent-filter" onchange="agentFilter=this.value;applyWorkspaceFilters()">${optionList(agents, agentFilter, 'All agents')}</select></label>
         <label class="control-field"><span>Model</span><select id="model-filter" onchange="modelFilter=this.value;applyWorkspaceFilters()">${optionList(models, modelFilter, 'All models')}</select></label>
         <label class="control-field"><span>Skill</span><select id="skill-filter" onchange="skillFilter=this.value;applyWorkspaceFilters()">${optionList(skills, skillFilter, 'All skills')}</select></label>
+        <label class="control-field"><span>Treatment</span><select id="treatment-filter" onchange="treatmentFilter=this.value;applyWorkspaceFilters()">${optionList(treatments, treatmentFilter, 'All treatments')}</select></label>
         <label class="control-field slice-control"><span>Slice by</span><select id="slice-by" onchange="changeSlice(this.value)">
             <option value="none" ${sliceBy === 'none' ? 'selected' : ''}>No slicing</option>
+            <option value="treatment" ${sliceBy === 'treatment' ? 'selected' : ''}>Treatment</option>
             <option value="run" ${sliceBy === 'run' ? 'selected' : ''}>Run number</option>
             <option value="agent" ${sliceBy === 'agent' ? 'selected' : ''}>Agent</option>
             <option value="model" ${sliceBy === 'model' ? 'selected' : ''}>Model</option>
@@ -1790,6 +1800,9 @@ function resetWorkspaceFilters() {
     agentFilter = 'all';
     modelFilter = 'all';
     skillFilter = 'all';
+    treatmentFilter = 'all';
+    sliceBy = 'none';
+    currentSelection = 'all';
     renderRunSidebar();
     renderWorkspace();
 }
@@ -1801,12 +1814,43 @@ function changeSlice(value) {
     renderWorkspace();
 }
 
+function renderSavedGrading(grading) {
+    if (!grading || typeof grading !== 'object') return '';
+    const outcome = grading.result || {};
+    const graders = Array.isArray(grading.graders) ? grading.graders : [];
+    if (!grading.result && !graders.length) return '';
+    // Quality is an outcome, not a pass/fail check. In particular, zero is a
+    // real Low score; missing evidence and judge errors must remain ungraded.
+    const quality = outcome.score != null
+        ? `${outcome.score}/${outcome.max_score ?? 2} (${outcome.grade || 'scored'})`
+        : `Not scored (${outcome.status || 'unknown'})`;
+    const checks = outcome.checks_status || 'unknown';
+    const rows = graders.map(item => {
+        const status = item.status || 'unknown';
+        const result = item.score != null
+            ? `${item.score} (${item.grade || status})`
+            : status;
+        const resultClass = item.type === 'deterministic' && status === 'passed'
+            ? 'pass' : (status === 'failed' || status === 'error' ? 'fail' : (item.score != null ? '' : 'unknown'));
+        const errors = Array.isArray(item.evidence_errors) ? item.evidence_errors : [];
+        const details = [item.reason, item.error_kind, ...errors.map(error => [error.code, error.detail].filter(Boolean).join(': '))].filter(Boolean);
+        const reason = details.length ? `<div class="${status === 'failed' || status === 'error' ? 'expectation-failure-reason' : 'grading-detail'}">${esc(details.join(' · '))}</div>` : '';
+        return `<tr><td>${esc(item.id || 'Unnamed grader')}${reason}</td><td>${esc(item.type || 'unknown')}</td><td><span class="expectation-result ${resultClass}">${esc(result)}</span></td></tr>`;
+    }).join('');
+    return `<div class="expectations-mini${checks === 'failed' || checks === 'error' ? ' has-failures' : ''}">
+        <div class="expectations-mini-heading"><span>Outcome quality</span><strong>${esc(quality)}</strong></div>
+        <div class="expectations-mini-heading"><span>Required checks: ${esc(checks)}</span><span>Grading: ${esc(outcome.status || 'unknown')}</span></div>
+        ${rows ? `<div class="expectations-table-wrap"><table><thead><tr><th>Grader</th><th>Type</th><th>Result</th></tr></thead><tbody>${rows}</tbody></table></div>` : ''}
+    </div>`;
+}
+
 function renderExpectationMiniTable(session) {
     const metric = session.evalMetric;
+    const grading = renderSavedGrading(metric && metric.grading);
     const expectations = metric && Array.isArray(metric.expectations) ? metric.expectations : [];
     const summary = metric && metric.expectation_summary;
     if (!expectations.length) {
-        return `<div class="expectations-empty"><span>Eval results</span><strong>Pending or unavailable</strong></div>`;
+        return grading || `<div class="expectations-empty"><span>Eval results</span><strong>Pending or unavailable</strong></div>`;
     }
     const passed = summary ? summary.passed : expectations.filter(item => String(item.result || '').toUpperCase() === 'PASS').length;
     const total = summary ? summary.total : expectations.length;
@@ -1820,7 +1864,7 @@ function renderExpectationMiniTable(session) {
             : '';
         return `<tr><td>${esc(item.expectation || '—')}${reason}</td><td>${esc(item.category || 'other')}</td><td><span class="expectation-result ${resultClass}">${esc(result)}</span></td></tr>`;
     }).join('');
-    return `<div class="expectations-mini ${statusClass}">
+    return grading + `<div class="expectations-mini ${statusClass}">
         <div class="expectations-mini-heading"><span>Eval results</span><strong>${passed}/${total} passed</strong></div>
         <div class="expectations-table-wrap"><table><thead><tr><th>Expectation</th><th>Category</th><th>Result</th></tr></thead><tbody>${rows}</tbody></table></div>
     </div>`;
@@ -1887,6 +1931,14 @@ function renderFinalArtifacts(session) {
     </section>`;
 }
 
+function renderSourceProvenance(metric) {
+    if (!metric.bundle_digest) return '';
+    const fields = { 'Source run': metric.source_run, 'Bundle': metric.bundle_digest, 'Assignment': metric.assignment_id };
+    return '<details class="lane-prompt"><summary>Source provenance</summary><div class="prompt-text">'
+        + Object.entries(fields).filter(([, value]) => value).map(([key, value]) => esc(key + ': ' + value)).join('<br>')
+        + '</div></details>';
+}
+
 function renderLaneSession(session) {
     const i = session.sourceIndex;
     const d = session.dimensions;
@@ -1900,9 +1952,10 @@ function renderLaneSession(session) {
     let html = `<article class="lane-session">
         <header class="lane-session-header">
             <div class="lane-title-row"><div><span class="run-kicker">Run ${esc(d.run)}</span><h3>${esc(d.agent)} / ${esc(d.model)}</h3></div><button class="download-btn" onclick="downloadJsonl(${i})">JSONL</button></div>
-            <div class="dimension-chips"><span>${esc(d.skill)}</span><span>${formatDuration(session.stats.duration_s)}</span><span>${session.stats.tool_calls} calls</span><span class="${session.stats.tool_errors ? 'chip-error' : ''}">${session.stats.tool_errors} errors${errorRate ? ' · ' + errorRate + '%' : ''}</span>${embeddedFailures ? `<span class="chip-error">${embeddedFailures} embedded failures</span>` : ''}${infraAffected ? `<span class="chip-error">infra affected${infraCodes ? ' · ' + esc(infraCodes) : ''}</span>` : ''}</div>
+            <div class="dimension-chips"><span>${esc(d.treatment)}</span><span>${esc(d.skill)}</span><span>${formatDuration(session.stats.duration_s)}</span><span>${session.stats.tool_calls} calls</span><span class="${session.stats.tool_errors ? 'chip-error' : ''}">${session.stats.tool_errors} errors${errorRate ? ' · ' + errorRate + '%' : ''}</span>${embeddedFailures ? `<span class="chip-error">${embeddedFailures} embedded failures</span>` : ''}${infraAffected ? `<span class="chip-error">infra affected${infraCodes ? ' · ' + esc(infraCodes) : ''}</span>` : ''}</div>
             ${renderExpectationMiniTable(session)}
             ${renderInfraSignals(metric)}
+            ${renderSourceProvenance(metric)}
         </header>`;
     if (!session.transcript_available) {
         html += '<div class="transcript-unavailable">No transcript was retained for this completed eval. Its scored expectations remain included in this comparison.</div>';
@@ -1985,6 +2038,7 @@ function renderSession(i) {
     html += item('Agent', s.dimensions.agent);
     html += item('Model', s.dimensions.model || s.meta.model || '\u2014');
     html += item('Skill', s.dimensions.skill);
+    html += item('Treatment', s.dimensions.treatment);
     html += item('Run', s.dimensions.run);
     html += item('Session', (s.meta.session_id || '\u2014').slice(0, 12));
     if (s.meta.uploaded_by) html += item('Uploaded by', s.meta.uploaded_by);
@@ -2013,6 +2067,7 @@ function renderSession(i) {
     if (s.stats.loop_groups > 0) html += item('Retry Loops', s.stats.loop_groups);
     if (s.stats.error_streak_groups > 0) html += item('Error Streaks', s.stats.error_streak_groups + ' (max ' + s.stats.max_error_streak + ')');
     html += '</div>';
+    html += renderSourceProvenance(metric);
     html += renderExpectationMiniTable(s);
     html += renderInfraSignals(metric);
     if (!s.transcript_available) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.3.233",
+  "version": "0.3.235",
   "description": "GTM data CLI and TypeScript SDK for coding agents",
   "license": "MIT",
   "homepage": "https://code.deepline.com",