deepline 0.3.334 → 0.3.336

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.334',
+  version: '0.3.336',
   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-runtime/context.ts

@@ -493,6 +493,7 @@ import {
   createRuntimeSheetDatasetPageReader,
   readRuntimeSheetDatasetRowKeys,
   RuntimeSheetAttemptSupersededError,
+  type RuntimeSheetDatasetPageReader,
 } from './runtime-api';
 import { executionGatewayDecodedBodyBytes } from './execution-gateway-response-size';
 import {
@@ -3304,6 +3305,35 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     base64: (value: SecretValue): SecretValue => createBase64SecretValue(value),
   };
 
+  private createRuntimeSheetDatasetPageReader(
+    tableNamespace: string,
+    rowMode?: 'output' | 'all',
+  ): RuntimeSheetDatasetPageReader {
+    if (this.#options.createRuntimeSheetDatasetPageReader) {
+      return this.#options.createRuntimeSheetDatasetPageReader({
+        orgId: this.#options.orgId,
+        executorToken: this.#options.executorToken!,
+        playName: this.#options.playName!,
+        runId: this.#options.runId!,
+        tableNamespace,
+        rowMode,
+      });
+    }
+    return createRuntimeSheetDatasetPageReader({
+      context: {
+        baseUrl: this.#options.baseUrl!,
+        executorToken: this.#options.executorToken!,
+        dbSessionStrategy: this.#options.dbSessionStrategy,
+        playName: this.#options.playName!,
+        userEmail: this.#options.userEmail,
+        runId: this.#options.runId!,
+      },
+      tableNamespace,
+      runId: this.#options.runId!,
+      rowMode,
+    });
+  }
+
   constructor(options: ContextOptions) {
     this.rootRuntimeContract =
       options.artifactRuntimeContract ??
@@ -9017,18 +9047,8 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         at: Date.now(),
       });
 
-      const runtimeBackedMapPageReader = createRuntimeSheetDatasetPageReader({
-        context: {
-          baseUrl: this.#options.baseUrl!,
-          executorToken: this.#options.executorToken!,
-          dbSessionStrategy: this.#options.dbSessionStrategy,
-          playName: this.#options.playName!,
-          userEmail: this.#options.userEmail,
-          runId: this.#options.runId!,
-        },
-        tableNamespace: resolvedTableNamespace,
-        runId: this.#options.runId!,
-      });
+      const runtimeBackedMapPageReader =
+        this.createRuntimeSheetDatasetPageReader(resolvedTableNamespace);
       const readRuntimeBackedMapRows = async (input: {
         limit: number;
         offset: number;
@@ -9758,19 +9778,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       // Output mode selects enriched rows when this replay's earlier
       // invocation also persisted isolated failures.
       const finalizationRowMode = resumedPendingRowsOnly ? 'output' : 'all';
-      const finalizationPageReader = createRuntimeSheetDatasetPageReader({
-        context: {
-          baseUrl: this.#options.baseUrl!,
-          executorToken: this.#options.executorToken!,
-          dbSessionStrategy: this.#options.dbSessionStrategy,
-          playName: this.#options.playName!,
-          userEmail: this.#options.userEmail,
-          runId: this.#options.runId!,
-        },
-        tableNamespace: resolvedTableNamespace,
-        runId: this.#options.runId!,
-        rowMode: finalizationRowMode,
-      });
+      const finalizationPageReader = this.createRuntimeSheetDatasetPageReader(
+        resolvedTableNamespace,
+        finalizationRowMode,
+      );
       results = await reconcileNodeRuntimeMapResultsWithPersistedSheet({
         mapName: normalizedMapNamespace,
         tableNamespace: resolvedTableNamespace,
@@ -9841,18 +9852,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         this.#options.runId,
       );
     const fullPersistedPageReader = runtimeSheetBacked
-      ? createRuntimeSheetDatasetPageReader({
-          context: {
-            baseUrl: this.#options.baseUrl!,
-            executorToken: this.#options.executorToken!,
-            dbSessionStrategy: this.#options.dbSessionStrategy,
-            playName: this.#options.playName!,
-            userEmail: this.#options.userEmail,
-            runId: this.#options.runId!,
-          },
-          tableNamespace: resolvedTableNamespace,
-          runId: this.#options.runId!,
-        })
+      ? this.createRuntimeSheetDatasetPageReader(resolvedTableNamespace)
       : null;
     const materializeFullPersistedMapRows = async (limit?: number) => {
       if (!runtimeSheetBacked) {
@@ -10752,9 +10752,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             return [
               {
                 inputIndex: executionRowIndex(index),
-                data: this.toPersistedOutputRow(
-                  this.toOutputRow(item as Record<string, unknown>),
-                ),
+                // Checkpoint replay must keep the admitted identity even
+                // when restored output columns change the default row hash.
+                data: {
+                  ...this.toPersistedOutputRow(
+                    this.toOutputRow(item as Record<string, unknown>),
+                  ),
+                  ...mapRowOutcomeRuntimeFields({ key: rowKey }),
+                },
                 ...(runtimeOptions?.authoredInputDigests?.[index]
                   ? {
                       authoredInputDigest:
@@ -11155,7 +11160,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               return [
                 {
                   inputIndex: executionRowIndex(index),
-                  data: this.toPersistedOutputRow(baseRow),
+                  // Preserve the admitted key rather than rehashing the
+                  // waiting row after persisted output fields are restored.
+                  data: {
+                    ...this.toPersistedOutputRow(baseRow),
+                    ...mapRowOutcomeRuntimeFields({
+                      key: keyForIndex(index),
+                    }),
+                  },
                   ...(runtimeOptions?.authoredInputDigests?.[index]
                     ? {
                         authoredInputDigest:

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

@@ -12,6 +12,7 @@ import type { PlayDatasetColumnTypes } from '../play-data-plane/contracts';
 import type { PlayStructuredDefinition } from '../plays/definition';
 import type { PlayStaticPipeline } from '../plays/static-pipeline';
 import type { PlayLogContext, PlayLogMetadata } from './log-context';
+import type { RuntimeSheetDatasetPageReader } from './runtime-api';
 import type {
   AsyncPlayRunRef,
   DurableCallStaleAfterSeconds,
@@ -772,6 +773,15 @@ export type IntegrationEventWaitHandler = {
   suspendAfterTimeoutMs?: number;
 };
 
+export type RuntimeSheetDatasetPageReaderScope = {
+  orgId?: string;
+  executorToken: string;
+  playName: string;
+  runId: string;
+  tableNamespace: string;
+  rowMode?: 'output' | 'all';
+};
+
 export interface ContextOptions {
   /**
    * Immutable worker projection resolved once from the admitted Play artifact.
@@ -822,6 +832,10 @@ export interface ContextOptions {
    * execution gateway and must never fall back to minting direct DB sessions.
    */
   dbSessionStrategy?: 'preloaded' | 'gateway_only' | 'trusted_dynamic';
+  /** Runner-owned reader; scoped database authority stays outside authored code. */
+  createRuntimeSheetDatasetPageReader?: (
+    scope: RuntimeSheetDatasetPageReaderScope,
+  ) => RuntimeSheetDatasetPageReader;
   vercelProtectionBypassToken?: string | null;
   /** Optional per-run integration execution mode for provider calls. */
   integrationMode?: 'live' | 'eval_stub' | 'fixture';

package/dist/bundling-sources/shared_libs/play-runtime/internal-bootstrap-token.ts

@@ -112,6 +112,9 @@ const PRODUCT_NOTIFICATION_UNSUBSCRIBE_PURPOSE =
 const MONITOR_FLEET_DISPATCH_AUDIENCE =
   'deepline.monitor_fleet.dispatch' as const;
 const MONITOR_FLEET_DISPATCH_PURPOSE = 'monitor_fleet_dispatch' as const;
+const AUTO_RECHARGE_TRIGGER_AUDIENCE =
+  'deepline.billing.auto_recharge_trigger' as const;
+const AUTO_RECHARGE_TRIGGER_PURPOSE = 'auto_recharge_trigger' as const;
 const INTERNAL_BOOTSTRAP_TOKEN_DERIVATION_LABEL =
   'deepline:internal-bootstrap-token:v1';
 const WORKFLOW_EXECUTOR_KEY_DERIVATION_LABEL =
@@ -245,6 +248,18 @@ export type ProductNotificationUnsubscribeTokenClaims = {
   v: typeof INTERNAL_BOOTSTRAP_TOKEN_VERSION;
 };
 
+/** Capability to ask the recharge controller to evaluate one workspace. */
+export type AutoRechargeTriggerTokenClaims = {
+  aud: typeof AUTO_RECHARGE_TRIGGER_AUDIENCE;
+  exp: number;
+  iat: number;
+  iss: typeof INTERNAL_BOOTSTRAP_TOKEN_ISSUER;
+  org_id: string;
+  purpose: typeof AUTO_RECHARGE_TRIGGER_PURPOSE;
+  sub: 'credit_balance_reaction';
+  v: typeof INTERNAL_BOOTSTRAP_TOKEN_VERSION;
+};
+
 /** Capability scoped to one durable Monitor Fleet control-plane operation. */
 export type MonitorFleetDispatchTokenClaims = {
   aud: typeof MONITOR_FLEET_DISPATCH_AUDIENCE;
@@ -1512,6 +1527,72 @@ export async function verifyProductNotificationUnsubscribeToken(
   return claims as ProductNotificationUnsubscribeTokenClaims;
 }
 
+/**
+ * Mints a short-lived capability for the balance-triggered recharge
+ * evaluation. It carries no amount: the controller decides from saved policy.
+ */
+export async function mintAutoRechargeTriggerToken(input: {
+  orgId: string;
+  nowMs?: number;
+}): Promise<string> {
+  const issuedAt = Math.floor((input.nowMs ?? Date.now()) / 1000);
+  const claims: AutoRechargeTriggerTokenClaims = {
+    v: INTERNAL_BOOTSTRAP_TOKEN_VERSION,
+    iss: INTERNAL_BOOTSTRAP_TOKEN_ISSUER,
+    aud: AUTO_RECHARGE_TRIGGER_AUDIENCE,
+    purpose: AUTO_RECHARGE_TRIGGER_PURPOSE,
+    org_id: input.orgId,
+    sub: 'credit_balance_reaction',
+    iat: issuedAt,
+    exp: issuedAt + INTERNAL_BOOTSTRAP_TOKEN_TTL_SECONDS,
+  };
+  const signingInput = `${encodeJson({ alg: 'HS256', typ: 'JWT' })}.${encodeJson(claims)}`;
+  return `${signingInput}.${await signTokenMaterial(signingInput)}`;
+}
+
+export async function verifyAutoRechargeTriggerToken(
+  token: string,
+  nowMs = Date.now(),
+): Promise<AutoRechargeTriggerTokenClaims> {
+  const segments = token.split('.');
+  if (segments.length !== 3)
+    throw new Error('Invalid automatic recharge trigger token.');
+  const [encodedHeader, encodedClaims, signature] = segments;
+  const header = decodeJson<Record<string, unknown>>(encodedHeader);
+  if (header.alg !== 'HS256' || header.typ !== 'JWT') {
+    throw new Error('Invalid automatic recharge trigger token.');
+  }
+  const expectedSignature = await signTokenMaterial(
+    `${encodedHeader}.${encodedClaims}`,
+  );
+  if (
+    !timingSafeEqual(fromBase64Url(signature), fromBase64Url(expectedSignature))
+  ) {
+    throw new Error('Invalid automatic recharge trigger token.');
+  }
+  const claims = decodeJson<Record<string, unknown>>(encodedClaims);
+  if (
+    claims.v !== INTERNAL_BOOTSTRAP_TOKEN_VERSION ||
+    claims.iss !== INTERNAL_BOOTSTRAP_TOKEN_ISSUER ||
+    claims.aud !== AUTO_RECHARGE_TRIGGER_AUDIENCE ||
+    claims.purpose !== AUTO_RECHARGE_TRIGGER_PURPOSE ||
+    claims.sub !== 'credit_balance_reaction' ||
+    typeof claims.org_id !== 'string' ||
+    !claims.org_id ||
+    typeof claims.iat !== 'number' ||
+    !Number.isFinite(claims.iat) ||
+    typeof claims.exp !== 'number' ||
+    !Number.isFinite(claims.exp)
+  ) {
+    throw new Error('Invalid automatic recharge trigger token.');
+  }
+  const nowSeconds = Math.floor(nowMs / 1000);
+  if (claims.exp <= nowSeconds || claims.iat > nowSeconds + 30) {
+    throw new Error('Automatic recharge trigger token expired.');
+  }
+  return claims as AutoRechargeTriggerTokenClaims;
+}
+
 export async function mintMonitorFleetDispatchToken(input: {
   orgId: string;
   operation: 'dispatch' | 'daily_sync' | 'job_dispatch';

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/index.ts

@@ -87,6 +87,7 @@ import { getPlayRuntimeBatchStrategy } from '../play-runtime-batching-registry';
 import type { ToolResultMetadataInput } from '../tool-result';
 import type {
   ContextOptions,
+  RuntimeSheetDatasetPageReaderScope,
   IntegrationEventWaitBoundary,
   IntegrationEventWaitHandler,
   IntegrationEventWaitRuntimeContext,
@@ -121,6 +122,8 @@ import {
 import {
   resolveRuntimeReferencedPlay,
   createCompleteRuntimeMapRowsOperation,
+  createRuntimeSheetDatasetPageReader,
+  type RuntimeSheetDatasetPageReader,
   readRuntimeSheetDatasetRowKeys,
   readRuntimeSheetDatasetRows,
   releaseRuntimeWorkReceipts,
@@ -1319,6 +1322,48 @@ export function assertPlayRunnerRuntimeSheetPersistenceContext(
   }
 }
 
+/** Keep launch-scoped database authority in the runner that admitted it. */
+export function createPlayRunnerRuntimeSheetDatasetPageReader(input: {
+  context: PlayRunnerExecutionConfig['context'];
+  preloadedDbSessions: PlayRunnerExecutionConfig['context']['preloadedDbSessions'];
+  postgresSessionUnwrapKey: string | null;
+  abortSignal: AbortSignal;
+  scope: RuntimeSheetDatasetPageReaderScope;
+}): RuntimeSheetDatasetPageReader {
+  const { context, scope } = input;
+  assertPlayRunnerRuntimeSheetPersistenceContext(context);
+  const rootRunId = context.runId ?? context.workflowId;
+  if (
+    scope.orgId !== context.orgId ||
+    scope.playName !== context.playName ||
+    scope.runId !== rootRunId ||
+    scope.executorToken !== context.executorToken
+  ) {
+    throw new Error(
+      'Runtime Sheet reader scope does not match the run launch authority.',
+    );
+  }
+  return createRuntimeSheetDatasetPageReader({
+    context: {
+      baseUrl: context.baseUrl,
+      executorToken: scope.executorToken,
+      orgId: scope.orgId,
+      playName: scope.playName,
+      runId: scope.runId,
+      userEmail: context.userEmail,
+      dbSessionStrategy: context.dbSessionStrategy,
+      preloadedDbSessions: input.preloadedDbSessions,
+      postgresSessionUnwrapKey: input.postgresSessionUnwrapKey,
+      vercelProtectionBypassToken: context.vercelProtectionBypassToken,
+      runtimeTestFaultHeader: context.runtimeTestFaultHeader ?? null,
+      abortSignal: input.abortSignal,
+    },
+    tableNamespace: scope.tableNamespace,
+    runId: scope.runId,
+    rowMode: scope.rowMode,
+  });
+}
+
 function collectReturnedDatasets(value: unknown): unknown[] {
   const datasets: unknown[] = [];
   const seen = new Set<unknown>();
@@ -2277,6 +2322,14 @@ async function run(
       }
     },
     dbSessionStrategy: config.context.dbSessionStrategy,
+    createRuntimeSheetDatasetPageReader: (scope) =>
+      createPlayRunnerRuntimeSheetDatasetPageReader({
+        context: config.context,
+        preloadedDbSessions: runtimePreloadedDbSessions,
+        postgresSessionUnwrapKey: runtimePostgresSessionUnwrapKey,
+        abortSignal: persistenceSignal,
+        scope,
+      }),
     fetchImpl: safeNodeStreamingOutboundFetch,
     vercelProtectionBypassToken: config.context.vercelProtectionBypassToken,
     orgId: config.context.orgId,

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

@@ -10593,6 +10593,36 @@ function terminalWorkCounterSegmentFromRunnerResult(
   });
 }
 
+/** Close the admitted invocation in the same durable fact as its terminal. */
+function terminalWorkCounterProgressEventsFromRunnerResult(
+  result: unknown,
+  runId: string,
+  attempt: number,
+  occurredAt: number,
+): PlayRunLedgerEvent[] {
+  if (!result || typeof result !== 'object' || Array.isArray(result)) return [];
+  const envelope = result as { status?: unknown; stats?: unknown };
+  if (envelope.status !== 'completed' && envelope.status !== 'failed')
+    return [];
+  const counters = runtimeWorkCountersFromStats(envelope.stats);
+  const segment = terminalWorkCounterSegmentFromRunnerResult(result, attempt);
+  // Historical or malformed telemetry must stay visibly unconfirmed.
+  if (!counters || counters.provider429s === undefined || !segment) return [];
+  return [
+    {
+      type: 'work.counters',
+      runId,
+      source: 'worker',
+      occurredAt,
+      ...segment,
+      logicalCalls: counters.logicalCalls,
+      providerRequests: counters.providerRequests,
+      provider429s: counters.provider429s,
+      final: true,
+    },
+  ];
+}
+
 /**
  * Reduce an ordinary detached-runner completion at terminal ingress.
  *
@@ -15040,12 +15070,20 @@ export async function executePostgresSchedulerClaim(
         terminalLogLines: terminalLogProjection.lines,
         terminalLogContexts: terminalLogProjection.lineContexts,
         terminalLogMetadata: terminalLogProjection.lineMetadata,
-        terminalProgressEvents: options.terminalProgressEvents,
         terminalLogIds: terminalLogProjection.lineIds,
         terminalWorkCounterSegment: terminalWorkCounterSegmentFromRunnerResult(
           output,
           claim.attempt,
         ),
+        terminalProgressEvents: [
+          ...terminalWorkCounterProgressEventsFromRunnerResult(
+            output,
+            claim.runId,
+            claim.attempt,
+            runnerTerminalReceivedAtMs ?? Date.now(),
+          ),
+          ...(options.terminalProgressEvents ?? []),
+        ],
       },
       options,
     );
@@ -15109,9 +15147,15 @@ export async function executePostgresSchedulerClaim(
         ...(options.preserveRunnerTerminal
           ? { preserveRunnerTerminal: true }
           : {}),
-        ...(options.terminalProgressEvents?.length
-          ? { terminalProgressEvents: options.terminalProgressEvents }
-          : {}),
+        terminalProgressEvents: [
+          ...terminalWorkCounterProgressEventsFromRunnerResult(
+            terminalFailureResult,
+            claim.runId,
+            claim.attempt,
+            runnerTerminalReceivedAtMs ?? Date.now(),
+          ),
+          ...(options.terminalProgressEvents ?? []),
+        ],
       },
       options,
     );

package/dist/cli/auth-6RQLNYNF.js

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkQ2HYQOIDjs = require('./chunk-Q2HYQOID.js');
+require('./chunk-I5XF4PWD.js');
+require('./chunk-ZPLBQ24U.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-KZT7YX7R.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkQ2HYQOIDjs.EXIT_WORKSPACE_MISMATCH; exports.clearPendingClaim = _chunkQ2HYQOIDjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkQ2HYQOIDjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkQ2HYQOIDjs.handleRegister; exports.handleStatus = _chunkQ2HYQOIDjs.handleStatus; exports.handleWait = _chunkQ2HYQOIDjs.handleWait; exports.readPendingAuthClaim = _chunkQ2HYQOIDjs.readPendingAuthClaim; exports.registerAuthCommands = _chunkQ2HYQOIDjs.registerAuthCommands; exports.reportSetupCompleted = _chunkQ2HYQOIDjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkQ2HYQOIDjs.resolvePendingAuthClaimForResume;

package/dist/cli/{auth-PAEBUPRS.mjs → auth-M45QKCUL.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-U724V33M.mjs";
-import "./chunk-A7S4PRK2.mjs";
-import "./chunk-VB7TNIUB.mjs";
+} from "./chunk-4S3G43M3.mjs";
+import "./chunk-TGMDQIYJ.mjs";
+import "./chunk-IU3TFWPR.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-P3ZX3NSE.mjs";
+import "./chunk-B53RXFGP.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/{billing-QGQJUM5G.mjs → billing-E7ADEFLX.mjs}

@@ -2,7 +2,7 @@ import {
   DeeplineClient,
   iterateCursorPages,
   requireBillingIdempotencyKey
-} from "./chunk-TT2CLWMK.mjs";
+} from "./chunk-VOD4V4G4.mjs";
 import "./chunk-CBVIJSHF.mjs";
 import {
   createTimestampedName,
@@ -10,13 +10,13 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-A7S4PRK2.mjs";
+} from "./chunk-TGMDQIYJ.mjs";
 import {
   AuthError,
   ConfigError
-} from "./chunk-VB7TNIUB.mjs";
+} from "./chunk-IU3TFWPR.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-P3ZX3NSE.mjs";
+import "./chunk-B53RXFGP.mjs";
 import "./chunk-6IKARAYD.mjs";
 import {
   DeeplineError