deepline 0.3.310 → 0.3.312

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

@@ -1748,7 +1748,13 @@ export function definePlay<TInput, TOutput extends PlayReturnObject>(
       : {
           name: nameOrConfig.id,
           fn: nameOrConfig.run,
-          bindings: nameOrConfig.bindings,
+          bindings:
+            nameOrConfig.displayName !== undefined
+              ? {
+                  ...nameOrConfig.bindings,
+                  displayName: nameOrConfig.displayName,
+                }
+              : nameOrConfig.bindings,
           description: nameOrConfig.description,
           inputSchema: nameOrConfig.input.schema,
           billing: nameOrConfig.billing,

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.310',
+  version: '0.3.312',
   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/ledger-safe-payload.ts

@@ -95,8 +95,12 @@ export function sanitizeLedgerLogLines(value: unknown): string[] {
   return value
     .filter((line): line is string => typeof line === 'string')
     .slice(0, MAX_LEDGER_LOG_LINES_PER_EVENT)
-    .map((line) =>
-      boundRunLogLine(ledgerIngressRedactor.redactString(line.trim())),
-    )
+    .map((line) => sanitizeLedgerLogLine(line))
     .filter(Boolean);
 }
+
+/** Runtime measurement records use the terminal transport's existing byte budget. */
+export function sanitizeLedgerLogLine(line: string, bounded = true): string {
+  const redacted = ledgerIngressRedactor.redactString(line.trim());
+  return bounded ? boundRunLogLine(redacted) : redacted;
+}

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

@@ -4,6 +4,7 @@ import {
   type RunLedgerDispatchLaunch,
 } from './run-ledger-dispatch-authority';
 import { normalizeRunLogIds } from '../run-log-buffer';
+import { sanitizeLedgerLogLine } from '../ledger-safe-payload';
 import {
   retainedPlayPipelineFields,
   hydrateRetainedPlayPipelines,
@@ -10926,7 +10927,9 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
       stringifyPostgresJson(runtimeTiming ?? null),
       stringifyPostgresJson(ledgerTerminalResult ?? null),
       JSON.stringify(terminalLogLines),
-      JSON.stringify(input.terminalProgressEvents ?? []),
+      JSON.stringify(
+        sanitizeTerminalProgressEvents(input.terminalProgressEvents),
+      ),
       postgresSchedulerNotifyChannel('terminal', options),
       JSON.stringify({ runId: input.runId, status: 'completed' }),
       input.leaseToken,
@@ -13305,7 +13308,7 @@ export async function completePostgresSchedulerAttempt(
   );
   const terminalLogEntries = (input.terminalLogLines ?? [])
     .map((line, index) => ({
-      line: line.trim(),
+      line: sanitizeTerminalLogBody(line),
       context: input.terminalLogContexts?.[index] ?? null,
       metadata: input.terminalLogMetadata?.[index] ?? null,
       entryId: terminalLogIds?.[index] ?? null,
@@ -13529,7 +13532,9 @@ export async function completePostgresSchedulerAttempt(
       JSON.stringify(terminalLogContexts),
       stringifyPostgresJson(input.terminalWorkCounterSegment ?? null),
       JSON.stringify(terminalLogMetadata),
-      JSON.stringify(input.terminalProgressEvents ?? []),
+      JSON.stringify(
+        sanitizeTerminalProgressEvents(input.terminalProgressEvents),
+      ),
       stringifyPostgresJson(
         terminalLogIds
           ? terminalLogEntries.map((entry) => entry.entryId)
@@ -13615,7 +13620,7 @@ export async function failPostgresSchedulerAttempt(
   );
   const terminalLogEntries = (input.terminalLogLines ?? [])
     .map((line, index) => ({
-      line: line.trim(),
+      line: sanitizeTerminalLogBody(line),
       context: input.terminalLogContexts?.[index] ?? null,
       metadata: input.terminalLogMetadata?.[index] ?? null,
       entryId: terminalLogIds?.[index] ?? null,
@@ -13901,7 +13906,9 @@ export async function failPostgresSchedulerAttempt(
       stringifyPostgresJson(resultSummary),
       JSON.stringify(terminalLogContexts),
       stringifyPostgresJson(terminalWorkCounterSegment ?? null),
-      stringifyPostgresJson(input.terminalProgressEvents ?? []),
+      stringifyPostgresJson(
+        sanitizeTerminalProgressEvents(input.terminalProgressEvents),
+      ),
       JSON.stringify(terminalLogMetadata),
       stringifyPostgresJson(
         terminalLogIds
@@ -14612,7 +14619,9 @@ function runnerTerminalLogPayload(input: {
     terminalLogContexts: projection.lineContexts,
     terminalLogMetadata: projection.lineMetadata,
     ...(projection.lineIds ? { terminalLogIds: projection.lineIds } : {}),
-    terminalProgressEvents: input.terminalProgressEvents ?? [],
+    terminalProgressEvents: sanitizeTerminalProgressEvents(
+      input.terminalProgressEvents,
+    ),
     // Older runner envelopes conveyed these diagnostics only in tagged log
     // text. Preserve their small structured facts before removing that text.
     recoveredRuntimeDiagnostics:
@@ -14629,6 +14638,41 @@ function runnerTerminalLogPayload(input: {
   };
 }
 
+function sanitizeTerminalProgressEvents(
+  events: readonly unknown[] = [],
+): unknown[] {
+  return events.map((event) => {
+    if (!event || typeof event !== 'object' || Array.isArray(event))
+      return event;
+    const item = event as Record<string, unknown>;
+    if (item.type !== 'log.appended' || !Array.isArray(item.lines))
+      return event;
+    return {
+      ...item,
+      // Keep every position and annotation aligned, including blank lines.
+      // Invalid values still reach the existing SQL validation unchanged.
+      lines: item.lines.map((line) =>
+        typeof line === 'string'
+          ? sanitizeTerminalLogBody(line) || '(blank log line)'
+          : line,
+      ),
+    };
+  });
+}
+
+function sanitizeTerminalLogBody(line: string): string {
+  const body = line.trim();
+  const runtimeDiagnostic =
+    body.startsWith('[runtime.failure_diagnostic] ') ||
+    body.startsWith('[runtime.phase_summary] ') ||
+    body.startsWith('[runtime.logs] ') ||
+    body.startsWith('[runtime.log_transport] ');
+  // These runtime records contain machine-readable JSON, already bounded by
+  // the terminal transport. Keep it parseable while applying the same redaction.
+  // Authored tagged lines retain the ordinary live-ingress line bound.
+  return sanitizeLedgerLogLine(body, !runtimeDiagnostic);
+}
+
 function terminalLogProjectionForOutbox(
   runnerResult: unknown,
   mode: PostgresSchedulerTerminalLogOutbox | undefined,
@@ -14689,7 +14733,9 @@ function terminalLogProjectionForOutbox(
         normalized.startsWith('[runtime.log_transport] ');
       if (!retained) return null;
       return {
-        line: line.trim(),
+        // The live API applies this same canonicalization before indexing.
+        // Replaying an origin ID must carry that exact redacted, bounded body.
+        line: sanitizeTerminalLogBody(line),
         context: normalizePlayLogContext(logContexts?.[index]),
         metadata: normalizePlayLogMetadata(logMetadata?.[index]),
         entryId: logIds?.[index] ?? null,
@@ -18014,6 +18060,8 @@ export async function readPendingPostgresSchedulerOutboxEvents(
     extendOwnedHead?: string;
     /** The dispatcher owns a short, exclusive claim transaction. */
     inTransaction?: boolean;
+    /** The owner rolls back and restarts the whole claim on the old-schema adapter. */
+    restartTransactionOnMissingMarker?: boolean;
   } = {},
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<PostgresSchedulerOutboxEvent[]> {
@@ -18054,6 +18102,11 @@ async function claimPostgresSchedulerOutboxPrefix(
     `${alias}.delivered_at IS NULL${
       acknowledgement ? ` AND NOT (${alias}.event_id = ANY($5::text[]))` : ''
     }`;
+  // The dispatcher already chose this run. Seek its oldest pending fact
+  // before eligibility checks; comparing every candidate with every earlier
+  // fact makes a single run's burst quadratic. Failed/delayed heads must
+  // remain in this seek so they still block their causal successors.
+  const seekRunHead = runId !== null && !input.extendOwnedHead;
   const claim = async (supportsTerminalBatchMarker: boolean) => {
     const urgentLifecyclePendingSql = (alias: string) =>
       input.searchOnly === true
@@ -18091,6 +18144,18 @@ async function claimPostgresSchedulerOutboxPrefix(
           : `waiting_runs AS MATERIALIZED (
         ${runLedgerWaitingRunsSql(options, '$2')}
       ), `
+      }${
+        seekRunHead
+          ? `pending_head AS MATERIALIZED (
+        SELECT pending.event_id
+        FROM ${tableName('outbox', options)} AS pending
+        WHERE pending.run_id = $2
+          AND ${pending('pending')}
+          AND ${searchLaneSql('pending')} = ${input.searchOnly === true ? 'true' : 'false'}
+        ORDER BY ${runLedgerOrderSql('pending')}
+        LIMIT 1
+      ),`
+          : ''
       }${
         input.extendOwnedHead
           ? `owned_run AS MATERIALIZED (
@@ -18106,6 +18171,7 @@ async function claimPostgresSchedulerOutboxPrefix(
         SELECT candidate.event_id, candidate.run_id, candidate.event_type,
                ${supportsTerminalBatchMarker ? 'candidate.delivery_batch_started_at' : 'NULL::timestamptz'} AS delivery_batch_started_at
         FROM ${tableName('outbox', options)} AS candidate
+        ${seekRunHead ? 'JOIN pending_head ON pending_head.event_id = candidate.event_id' : ''}
         ${input.extendOwnedHead ? 'JOIN owned_run ON owned_run.run_id = candidate.run_id' : ''}
         WHERE ${pending('candidate')}
           AND ${searchLaneSql('candidate')} = ${input.searchOnly === true ? 'true' : 'false'}
@@ -18149,13 +18215,17 @@ async function claimPostgresSchedulerOutboxPrefix(
           -- Competing projectors acquire one run through its oldest event.
           -- Locking this head prevents another projector from splitting the
           -- run while still letting it skip to unrelated runs.
-          AND NOT EXISTS (
+          ${
+            seekRunHead
+              ? ''
+              : `AND NOT EXISTS (
             SELECT 1
             FROM ${tableName('outbox', options)} AS predecessor
             WHERE predecessor.run_id = candidate.run_id
               AND ${pending('predecessor')}
               AND ${runLedgerPrecedesSql('predecessor', 'candidate')}
-          )
+          )`
+          }
         -- A new durable admission has no causal dependency on unrelated
         -- terminal facts. Project it first so a lifecycle backlog cannot make
         -- an accepted run invisible; per-run predecessor checks above retain
@@ -18337,7 +18407,9 @@ async function claimPostgresSchedulerOutboxPrefix(
     );
   };
   let result;
-  if (input.inTransaction) await client.query('SAVEPOINT run_ledger_claim');
+  const useSavepoint =
+    input.inTransaction && !input.restartTransactionOnMissingMarker;
+  if (useSavepoint) await client.query('SAVEPOINT run_ledger_claim');
   if (supportsOutboxDeliveryBatchMarker(options)) {
     try {
       result = await claim(true);
@@ -18347,16 +18419,16 @@ async function claimPostgresSchedulerOutboxPrefix(
       // The ACK caller owns the whole short transaction. Roll it back and
       // repeat only this missing-column adapter, avoiding two SAVEPOINT round
       // trips on every successful acknowledgement.
-      if (acknowledgement) throw error;
-      if (input.inTransaction)
+      if (acknowledgement || input.restartTransactionOnMissingMarker)
+        throw error;
+      if (useSavepoint)
         await client.query('ROLLBACK TO SAVEPOINT run_ledger_claim');
       result = await claim(false);
     }
   } else {
     result = await claim(false);
   }
-  if (input.inTransaction)
-    await client.query('RELEASE SAVEPOINT run_ledger_claim');
+  if (useSavepoint) await client.query('RELEASE SAVEPOINT run_ledger_claim');
   const events = result.rows
     .filter((row) => row.row_kind === 'claimed')
     .map((row) => {
@@ -19825,7 +19897,7 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
 }
 
 async function dispatchRunLedgerOutboxBatchWithScope(
-  withClient: RunLedgerOutboxWithClient,
+  acquireClient: RunLedgerOutboxWithClient,
   input: RunLedgerOutboxDispatchInput & { waitForRunLock?: boolean },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
   scope?: RunLedgerOutboxDrainScope,
@@ -19833,6 +19905,25 @@ async function dispatchRunLedgerOutboxBatchWithScope(
   remainingEvents: number | null = null,
 ): Promise<PostgresSchedulerOutboxProjectionResult> {
   const dispatchStartedAtMs = Date.now();
+  // A committed terminal is running-work control traffic. Use the existing
+  // alternating critical admission lane so its short lease operations do not
+  // sit behind a full ordinary-work backlog; capacity is unchanged.
+  const terminalRunId =
+    scope && scope.targetEventId === `run-terminal:${scope.runId}`
+      ? scope.runId
+      : null;
+  const withClient: RunLedgerOutboxWithClient = (operation, trace) =>
+    acquireClient(
+      operation,
+      trace ??
+        (terminalRunId
+          ? {
+              runId: terminalRunId,
+              phase: 'run_ledger_outbox_terminal_delivery',
+              priority: 'critical',
+            }
+          : undefined),
+    );
   const tokenAuthority = input.tokenAuthority ?? 'local_mint';
   const leaseOwner =
     input.leaseOwner?.trim() || `run-ledger-outbox-dispatch:${randomUUID()}`;
@@ -19884,6 +19975,9 @@ async function dispatchRunLedgerOutboxBatchWithScope(
     await client.query('BEGIN');
     try {
       const targetRunId = input.runId?.trim() || null;
+      let lockedRun: {
+        rows: { run_id: string; dispatch_launch_json: unknown }[];
+      } | null = null;
       if (input.waitForRunLock && targetRunId) {
         // A synchronous drain must not mistake a busy run for an empty
         // outbox. In particular, cancellation owns its pending prefix lease,
@@ -19899,8 +19993,14 @@ async function dispatchRunLedgerOutboxBatchWithScope(
             `${RUNTIME_SCHEDULER_CANCEL_STATEMENT_TIMEOUT_MS}ms`,
           ],
         );
-        await client.query(
-          `SELECT run_id FROM ${tableName('runs', options)} WHERE run_id = $1 FOR UPDATE`,
+        lockedRun = await client.query<{
+          run_id: string;
+          dispatch_launch_json: unknown;
+        }>(
+          `SELECT runs.run_id,
+                  ${needsLaunch ? runLedgerDispatchLaunchSql('runs') : 'NULL::jsonb'} AS dispatch_launch_json
+           FROM ${tableName('runs', options)} AS runs
+           WHERE runs.run_id = $1 FOR UPDATE`,
           [targetRunId],
         );
       }
@@ -19909,12 +20009,14 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       // nullable predicate made PostgreSQL materialize every pending run head
       // for each lifecycle transition. Only the two dedicated projectors may
       // perform the global distinct-head scan below.
-      const selected = targetRunId
-        ? await client.query<{
-            run_id: string;
-            dispatch_launch_json: unknown;
-          }>(
-            `
+      const selected =
+        (input.headEventId ? null : lockedRun) ??
+        (targetRunId
+          ? await client.query<{
+              run_id: string;
+              dispatch_launch_json: unknown;
+            }>(
+              `
             WITH head AS MATERIALIZED (
               SELECT pending.run_id,
                      pending.event_id,
@@ -19947,12 +20049,12 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               )
             FOR UPDATE OF runs SKIP LOCKED
           `,
-            [targetRunId, leaseOwner, input.headEventId?.trim() || null],
-          )
-        : await client.query<{
-            run_id: string;
-            dispatch_launch_json: unknown;
-          }>(`
+              [targetRunId, leaseOwner, input.headEventId?.trim() || null],
+            )
+          : await client.query<{
+              run_id: string;
+              dispatch_launch_json: unknown;
+            }>(`
             WITH ${
               input.searchOnly === true
                 ? ''
@@ -20002,7 +20104,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
             }
                      head.created_at, runs.run_id
             FOR UPDATE OF runs SKIP LOCKED LIMIT 1
-          `);
+          `));
       const runId = selected.rows[0]?.run_id;
       const claimed = runId
         ? await readPendingPostgresSchedulerOutboxEvents(
@@ -20013,6 +20115,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               leaseOwner,
               leaseSeconds: input.leaseSeconds ?? 120,
               inTransaction: true,
+              restartTransactionOnMissingMarker: true,
               searchOnly: input.searchOnly,
             },
             options,
@@ -20037,7 +20140,16 @@ async function dispatchRunLedgerOutboxBatchWithScope(
     : null;
   const claimed = preclaimed
     ? { events: preclaimed, launchJson: null }
-    : await withClient(claimEvents);
+    : await withClient(async (client) => {
+        try {
+          return await claimEvents(client);
+        } catch (error) {
+          if (!isMissingOutboxDeliveryBatchMarker(error)) throw error;
+          // claimEvents rolled back. Reacquire the run fence and its fresh
+          // snapshot using only the named missing-column compatibility path.
+          return claimEvents(client);
+        }
+      });
   const { launchJson } = claimed;
   let events = claimed.events;
   if (events.length === 0) {
@@ -20345,7 +20457,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       events.length === 1 &&
       first.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents
     ) {
-      const widened = await withClient(async (client) => {
+      const widen = async (client: PostgresSchedulerQueryClient) => {
         await client.query('BEGIN');
         try {
           await client.query(
@@ -20376,6 +20488,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               allowIngressPrefix: true,
               extendOwnedHead: first.eventId,
               inTransaction: true,
+              restartTransactionOnMissingMarker: true,
             },
             options,
           );
@@ -20385,6 +20498,14 @@ async function dispatchRunLedgerOutboxBatchWithScope(
           await client.query('ROLLBACK');
           throw error;
         }
+      };
+      const widened = await withClient(async (client) => {
+        try {
+          return await widen(client);
+        } catch (error) {
+          if (!isMissingOutboxDeliveryBatchMarker(error)) throw error;
+          return widen(client);
+        }
       });
       if (widened[0]?.eventId !== first.eventId) {
         throw new RunLedgerProjectionLeaseLostError(

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -717,6 +717,7 @@ export type PlayAuthoringAstSqlListenerDeclaration = {
   operations: string[];
 };
 export type PlayAuthoringAstBindings = {
+  displayName?: string;
   webhook?: {
     hmac?: {
       algorithm?: 'sha256';
@@ -745,6 +746,7 @@ export type PlayAuthoringAstBindings = {
  */
 export const PLAY_AUTHORING_BINDING_FIELDS = {
   root: [
+    'displayName',
     'billing',
     'compatibility',
     'cron',
@@ -792,6 +794,7 @@ export type PlayAuthoringCronInput<TInput> = TInput extends readonly unknown[]
 
 /** The one public type for options accepted by definePlay. */
 export type PlayAuthoringBindings<TInput = Record<string, unknown>> = {
+  displayName?: string;
   description?: string;
   compatibility?: {
     toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
@@ -929,6 +932,7 @@ export type PlayAuthoringDefineConfig<
 > = {
   id: string;
   description?: string;
+  displayName?: string;
   input: PlayAuthoringInputContract<TInput>;
   run: (ctx: TContext, input: TInput) => Promise<TOutput>;
   bindings?: PlayAuthoringBindings<TInput>;
@@ -1644,6 +1648,23 @@ const SqlListenerFilterScalarSchema = Type.Union([
 ]);
 
 export const PLAY_AUTHORING_FIELD_REGISTRY = {
+  displayName: {
+    schema: Type.String(),
+    fixtures: {
+      valid: 'Find verified emails',
+      invalid: 42,
+      absent: undefined,
+      unresolved: { expression: 'displayName' },
+      edition1: 'Legacy play',
+    },
+    referenceType: 'string',
+    required: false,
+    resolution: 'static-required',
+    issueCode: 'play_authoring_binding_invalid',
+    description:
+      'Optional human-readable Play name; empty uses the derived identifier.',
+    errorMessage: 'displayName must be a static string.',
+  },
   description: {
     schema: Type.String({ minLength: 1 }),
     fixtures: {
@@ -3198,6 +3219,7 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   '};',
   'export type PlayCronInput<TInput> = TInput extends readonly unknown[] ? never : TInput extends object ? TInput : never;',
   'export type PlayBindings<TInput = Record<string, unknown>> = {',
+  `  displayName?: ${cloudReferenceType('displayName')};`,
   `  description?: ${cloudReferenceType('description')};`,
   `  compatibility?: { toolErrorSchemaVersion?: ${cloudReferenceType('compatibility.toolErrorSchemaVersion')}; toolResponseReceiptRevision?: ${cloudReferenceType('compatibility.toolResponseReceiptRevision')} };`,
   `  inline?: ${cloudReferenceType('inline')};`,
@@ -3276,7 +3298,7 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   "  log(message: string, options?: { level?: 'debug' | 'info' | 'warn' | 'error'; context?: Readonly<Record<string, string | number | boolean>> }): void;",
   `  sleep(ms: ${cloudReferenceType('ctx.sleep.ms')}): Promise<void>;`,
   '}',
-  "export type DefinePlayConfig<TInput, TOutput extends PlayReturnObject> = { id: string; description?: string; input: PlayInputContract<TInput>; run: (ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>; bindings?: PlayBindings<TInput>; billing?: PlayBindings<TInput>['billing']; runtime?: PlayBindings<TInput>['runtime']; compatibility?: PlayBindings<TInput>['compatibility'] };",
+  "export type DefinePlayConfig<TInput, TOutput extends PlayReturnObject> = { id: string; displayName?: string; description?: string; input: PlayInputContract<TInput>; run: (ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>; bindings?: PlayBindings<TInput>; billing?: PlayBindings<TInput>['billing']; runtime?: PlayBindings<TInput>['runtime']; compatibility?: PlayBindings<TInput>['compatibility'] };",
   "export type DefinedPlay<TInput, TOutput extends PlayReturnObject> = ((ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>) & { readonly name: string; readonly __inputType?: TInput; readonly __outputType?: TOutput; readonly bindings?: PlayBindings<TInput>; readonly runtime?: PlayBindings<TInput>['runtime']; readonly compatibility?: PlayBindings<TInput>['compatibility'] };",
   'export type PlayHandlerInput<THandler> = THandler extends (context: DeeplinePlayRuntimeContext, input: infer TInput) => Promise<PlayReturnObject> ? TInput : never;',
   'export type PlayHandlerOutput<THandler> = THandler extends (context: DeeplinePlayRuntimeContext, input: unknown) => Promise<infer TOutput extends PlayReturnObject> ? TOutput : never;',

package/dist/bundling-sources/shared_libs/plays/core.ts

@@ -358,7 +358,13 @@ export function createDefinedPlay<
       : {
           name: nameOrConfig.id,
           fn: nameOrConfig.run,
-          bindings: nameOrConfig.bindings,
+          bindings:
+            nameOrConfig.displayName !== undefined
+              ? {
+                  ...nameOrConfig.bindings,
+                  displayName: nameOrConfig.displayName,
+                }
+              : nameOrConfig.bindings,
           description: nameOrConfig.description,
           inputSchema: nameOrConfig.input.schema,
           billing: nameOrConfig.billing,

package/dist/bundling-sources/shared_libs/plays/settings-contract.ts

@@ -89,6 +89,12 @@ export function publishedPlayPath(path: PlayPath): PlayPath {
   return { root: 'team', folders: path?.folders ?? [] };
 }
 
+export const playDisplayNameSchema = z
+  .string()
+  .trim()
+  .nullable()
+  .transform((value) => value || null);
+
 /** One registry drives validation, defaults, CLI keys/help and settings controls. */
 export const PLAY_SETTING_FIELDS = {
   path: {
@@ -114,10 +120,30 @@ export const PLAY_SETTING_FIELDS = {
       ],
       parse: (value: string) =>
         value === 'null' ? null : parsePlayPath(value),
-      format: formatPlayPath,
+      format: (value: unknown) => formatPlayPath(playPathSchema.parse(value)),
     },
     ui: { control: 'play-location-picker' as const },
   },
+  displayName: {
+    schema: playDisplayNameSchema
+      .default(null)
+      .describe(
+        'Optional human-readable Play name. Null uses the name derived from the identifier.',
+      ),
+    label: 'Display name',
+    description:
+      'Optional name shown in the UI. Leave empty to use the name derived from the Play identifier.',
+    get defaultValue(): string | null {
+      return this.schema.parse(undefined);
+    },
+    cli: {
+      valueSyntax: 'text | null',
+      examples: ['Find verified emails', 'null'],
+      parse: (value: string) => (value === 'null' ? null : value),
+      format: (value: unknown) => playDisplayNameSchema.parse(value) ?? 'null',
+    },
+    ui: { control: 'text' as const },
+  },
 } as const;
 export const playSettingsSchema = z
   .object(
@@ -150,10 +176,10 @@ export const playSettingsPatchSchema = z
     'Supply at least one setting.',
   );
 export type PlaySettings = {
-  [K in keyof typeof PLAY_SETTING_FIELDS]: z.output<
+  [K in Exclude<keyof typeof PLAY_SETTING_FIELDS, 'displayName'>]: z.output<
     (typeof PLAY_SETTING_FIELDS)[K]['schema']
   >;
-};
+} & { displayName?: string | null };
 export type PlaySettingsPatch = z.output<typeof playSettingsPatchSchema>;
 /** Validate registered keys while preserving future keys in stored objects. */
 export function parsePlaySettings(value: unknown): PlaySettings {

package/dist/cli/{auth-CS6NQ737.mjs → auth-ACDTPM3M.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-LUJGLZCJ.mjs";
-import "./chunk-OJWZADOG.mjs";
-import "./chunk-M4KGWEN2.mjs";
+} from "./chunk-6OGNRAS7.mjs";
+import "./chunk-ZH7KTVAB.mjs";
+import "./chunk-WPTUKXIF.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-VN7Y4LVH.mjs";
+import "./chunk-AA66YTS7.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/auth-TFDGA24W.js

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

package/dist/cli/{billing-SDRP5BYV.mjs → billing-FVBBJ77L.mjs}

@@ -1,7 +1,7 @@
 import {
   DeeplineClient,
   iterateCursorPages
-} from "./chunk-NKRSVEP4.mjs";
+} from "./chunk-NWFE4PGX.mjs";
 import "./chunk-CBVIJSHF.mjs";
 import {
   createTimestampedName,
@@ -9,13 +9,13 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-OJWZADOG.mjs";
+} from "./chunk-ZH7KTVAB.mjs";
 import {
   AuthError,
   ConfigError
-} from "./chunk-M4KGWEN2.mjs";
+} from "./chunk-WPTUKXIF.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-VN7Y4LVH.mjs";
+import "./chunk-AA66YTS7.mjs";
 import "./chunk-6IKARAYD.mjs";
 import {
   DeeplineError
@@ -1383,7 +1383,7 @@ Examples:
   deepline billing subscription status --json
 
   # Price a tool before execution; look up its exact charge afterward
-  deepline tools describe <tool-id> --pricing-only
+  deepline describe <tool-id>
   deepline billing usage --request-id <job_id> --json
 
   # Buy credits or a plan