deepline 0.3.408 → 0.3.410

package/dist/cli/{play-GNC5CQAS.mjs → play-DE7VH6NU.mjs}

@@ -1,14 +1,14 @@
 import {
   addDescribeOptions,
   recordPlayTermination
-} from "./chunk-OSDXE27V.mjs";
+} from "./chunk-4PG4ARL2.mjs";
 import {
   registerDeprecatedSearchCommand
-} from "./chunk-YMOFWHGO.mjs";
+} from "./chunk-XNZJKRJA.mjs";
 import {
   handleDeploymentGet,
   handleDeploymentsList
-} from "./chunk-URACNNLO.mjs";
+} from "./chunk-MN2OWLFA.mjs";
 import {
   buildPlayDashboardUrl
 } from "./chunk-IHG7UAHD.mjs";
@@ -23,16 +23,17 @@ import {
   listPlayFileExports,
   parsePlaySourceForAnalysis,
   resolveEnabledExecutionProfile
-} from "./chunk-6BJK4EJ3.mjs";
+} from "./chunk-AARWVK4C.mjs";
 import "./chunk-H7HIDGZ7.mjs";
+import "./chunk-FR2ILQ4G.mjs";
 import {
   parseCsvDataInput
-} from "./chunk-HQXL5526.mjs";
+} from "./chunk-NUX2QHNC.mjs";
 import {
   pinLocalPlayImports,
   planLocalPlayExecution
 } from "./chunk-ERFN2QY4.mjs";
-import "./chunk-CLJGSOVM.mjs";
+import "./chunk-ZCALLYF6.mjs";
 import {
   DeeplineClient,
   RUN_EVENT_SEARCH_KIND_VALUES,
@@ -43,12 +44,14 @@ import {
   isTransientPlayRunReadError,
   logLevelReaches,
   logProvenanceReaches,
+  normalizePlayStatus,
   normalizeRunEventOperationRequest,
   parseLogLevel
-} from "./chunk-LOYISF7S.mjs";
-import "./chunk-6IKARAYD.mjs";
+} from "./chunk-4XQLVUC7.mjs";
+import "./chunk-L2VKAASU.mjs";
 import {
   CSV_DATA_INPUT_KEY,
+  CliPlayAdmissionUnsupportedError,
   buildNamedPlayRunRequest,
   decodePlayRunPublicStatus,
   fileInputBindingsFromPlaySchema,
@@ -56,20 +59,26 @@ import {
   setDottedInputValue,
   stageFileInputs,
   stagedFileContentType
-} from "./chunk-JI2B4RZP.mjs";
+} from "./chunk-KCC3FKIW.mjs";
 import {
   CSV_HEADER_MATCHING_NOTE,
   playInputExampleArgs
 } from "./chunk-EIMG75BT.mjs";
 import "./chunk-UBKA33KY.mjs";
 import {
+  checkPlayRunCompatibility,
+  usesInlinePlayAdmission
+} from "./chunk-EQ4Z7RJW.mjs";
+import {
+  isCliTraceEnabled,
   recordCliTrace,
+  resolveCliMaintenancePolicy,
   traceCliSpan
-} from "./chunk-SJVVBWRL.mjs";
+} from "./chunk-ZKYEW55U.mjs";
 import {
   createCliProgress,
   getActiveCliProgress
-} from "./chunk-67RWR34T.mjs";
+} from "./chunk-XIHWSXSV.mjs";
 import {
   argsWantJson,
   csvSafeJsonString,
@@ -84,16 +93,16 @@ import {
   printJsonError,
   renderCommandEnvelopeText,
   shouldEmitJson
-} from "./chunk-4CFULMRB.mjs";
+} from "./chunk-5V5Y37BC.mjs";
 import {
   fetchWithDeploymentProtection
-} from "./chunk-SD7MXAJA.mjs";
-import "./chunk-YHPYUZZX.mjs";
+} from "./chunk-RFB25DSQ.mjs";
+import "./chunk-MAMVGOSC.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import {
   DeeplineError
-} from "./chunk-NXGCO4JB.mjs";
-import "./chunk-WTT6CLED.mjs";
+} from "./chunk-E4IXDAZI.mjs";
+import "./chunk-2YR7BIIC.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import {
   __commonJS,
@@ -7886,7 +7895,7 @@ function parsePlayRunOptions(args, initialInput = null) {
     headers
   };
 }
-function resolvePlayRunCliOptions(target, options, inputArgs = []) {
+function resolvePlayRunCliOptions(target, options, inputArgs = [], maintenancePolicy) {
   const stringOption = (value, flag) => {
     if (value !== void 0 && !value.trim())
       throw new Error(`${flag} requires a non-empty value.`);
@@ -7998,6 +8007,7 @@ function resolvePlayRunCliOptions(target, options, inputArgs = []) {
   );
   return {
     ...base,
+    ...maintenancePolicy ? { maintenancePolicy } : {},
     target: resolvedTarget,
     dryRun,
     input: base.input,
@@ -8036,6 +8046,79 @@ function playAuthoringGraphPath(parent, filePath) {
   ).replaceAll("\\", "/");
 }
 
+// src/plays/check-local-play-graph.ts
+async function checkLocalPlayGraph(input) {
+  const { client, graph } = input;
+  const nodesByPath = new Map(
+    [...graph.nodes.values()].map((node) => [node.filePath, node])
+  );
+  const importedPlaysFor = (node) => {
+    const imported = /* @__PURE__ */ new Set();
+    const collect = (parent) => {
+      for (const dependency of parent.importedPlayDependencies) {
+        if (imported.has(dependency.filePath)) continue;
+        const child = nodesByPath.get(dependency.filePath);
+        if (!child)
+          throw new Error(
+            `Missing bundled Play dependency ${dependency.filePath}.`
+          );
+        imported.add(dependency.filePath);
+        collect(child);
+      }
+    };
+    collect(node);
+    return [...imported].map((filePath) => {
+      const child = nodesByPath.get(filePath);
+      return {
+        playName: child.playName,
+        sourceCode: child.sourceCode,
+        sourcePath: playAuthoringGraphPath(node, child.filePath)
+      };
+    });
+  };
+  const checkNode = (node) => {
+    const name = node.playName ?? (node === graph.root ? input.rootPlayName : null);
+    if (!name)
+      throw new Error(`Bundled Play ${node.filePath} has no declared name.`);
+    const importedPlays = importedPlaysFor(node);
+    const exportName = node === graph.root ? input.exportName : node.artifact.exportName ?? "default";
+    return client.checkPlayArtifact({
+      name,
+      sourceCode: node.sourceCode,
+      sourceFiles: node.sourceFiles,
+      description: node.playDescription ?? void 0,
+      artifact: input.prepareArtifact?.(node.artifact) ?? node.artifact,
+      ...exportName === "default" ? {} : { exportName },
+      ...importedPlays.length ? { importedPlays } : {},
+      ...input.integrationMode ? { integrationMode: input.integrationMode } : {}
+    });
+  };
+  if ([...graph.nodes.values()].some(
+    (node) => (node.artifact.compatibility.authoringContractEdition ?? 1) >= 10
+  )) {
+    const checked = /* @__PURE__ */ new Set();
+    const checkChildren = async (node) => {
+      if (checked.has(node.filePath)) return null;
+      checked.add(node.filePath);
+      for (const dependency of node.importedPlayDependencies) {
+        const child = nodesByPath.get(dependency.filePath);
+        if (!child)
+          throw new Error(
+            `Missing bundled Play dependency ${dependency.filePath}.`
+          );
+        const failure2 = await checkChildren(child);
+        if (failure2) return failure2;
+      }
+      if (node === graph.root) return null;
+      const result = await checkNode(node);
+      return result.valid ? null : { result, failedChild: node };
+    };
+    const failure = await checkChildren(graph.root);
+    if (failure) return failure;
+  }
+  return { result: await checkNode(graph.root) };
+}
+
 // src/cli/renderers/local-play-execution.ts
 function renderLocalPlayExecutionPlan(plan, options = {}) {
   if (options.dryRun) {
@@ -9005,20 +9088,11 @@ function isRetryablePendingStartFailure(status) {
   if (status.runId && status.runId !== "pending") return false;
   return isTransientPlayRunReadError(new Error(playStatusErrorText(status)));
 }
-function pendingStartFailureStatus(input) {
-  const message = input.error instanceof Error ? input.error.message : String(input.error);
-  return {
-    runId: "pending",
-    name: input.playName,
-    playName: input.playName,
-    dashboardUrl: input.dashboardUrl,
-    status: "failed",
-    progress: {
-      status: "failed",
-      logs: [],
-      error: message
-    }
-  };
+function isAmbiguousPlayStartOutcomeError(error) {
+  if (error instanceof DeeplineError && typeof error.statusCode === "number") {
+    return error.statusCode >= 500;
+  }
+  return true;
 }
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set([
   "completed",
@@ -9026,8 +9100,39 @@ var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set([
   "cancelled"
 ]);
 var PLAY_START_TRANSIENT_RETRY_DELAYS_MS = [500, 1500];
+var PLAY_START_STREAM_TERMINAL_WINDOW_MS = 2e3;
 var PLAY_PROGRESS_HEARTBEAT_INTERVAL_MS = 15e3;
 var PLAY_STATUS_HEARTBEAT_INTERVAL_MS = 15e3;
+var RetryablePlayStartAttemptError = class extends Error {
+  constructor(originalError) {
+    super(
+      originalError instanceof Error ? originalError.message : String(originalError)
+    );
+    this.originalError = originalError;
+    this.name = "RetryablePlayStartAttemptError";
+  }
+};
+var PlayStartOutcomeUnknownError = class extends DeeplineError {
+  retryable = false;
+  constructor(playName, cause) {
+    const causeMessage = cause instanceof Error ? cause.message : String(cause);
+    const recoveryCommand = `deepline runs list --play ${shellQuote(playName)} --json`;
+    super(
+      `Play ${playName} may have started, but the CLI did not receive confirmation. Do not run it again until you inspect the original workspace with: ${recoveryCommand}`,
+      cause instanceof DeeplineError ? cause.statusCode : void 0,
+      "PLAY_START_OUTCOME_UNKNOWN",
+      {
+        outcome: "unknown",
+        playName,
+        recoveryCommand,
+        recoveryScope: "same_authenticated_host_and_workspace",
+        causeMessage
+      }
+    );
+    this.name = "PlayStartOutcomeUnknownError";
+    Object.defineProperty(this, "cause", { value: cause, configurable: true });
+  }
+};
 function watchSurfaceReaches(state, provenance, level) {
   const minimumLevel = state.logLevel ?? (state.verbose ? "debug" : "info");
   if (!logLevelReaches(level, minimumLevel)) {
@@ -9593,11 +9698,26 @@ async function waitForPlayCompletionByWatch(input) {
     await input.onRunAdmitted?.(input.workflowId);
   };
   const withDashboardUrl = (status) => input.dashboardUrl ? { ...status, dashboardUrl: input.dashboardUrl } : status;
+  const finishTerminalStatus = async (status) => {
+    if (status.runId === input.workflowId && statusProvesPlayRunExecution(status.status)) {
+      await confirmAdmission();
+    }
+    if (!TERMINAL_PLAY_STATUSES.has(status.status)) return null;
+    const resolved = input.fullJson === void 0 ? status : await resolvePlayRunOutputStatus({
+      client: input.client,
+      status,
+      fullJson: input.fullJson,
+      jsonOutput: input.jsonOutput,
+      fromDurableStatus: true
+    });
+    return withDashboardUrl(resolved);
+  };
   const fetchTerminalStatus = async () => {
     let refreshed;
     try {
       refreshed = await input.client.getPlayStatus(input.workflowId, {
-        billing: false
+        billing: false,
+        ...input.fullJson === void 0 ? {} : { full: input.fullJson }
       });
     } catch (error) {
       if (isTransientPlayRunReadError(error) || isAdmittedRunVisibilityDelay(error)) {
@@ -9605,10 +9725,7 @@ async function waitForPlayCompletionByWatch(input) {
       }
       throw error;
     }
-    if (refreshed.runId === input.workflowId && statusProvesPlayRunExecution(refreshed.status)) {
-      await confirmAdmission();
-    }
-    return TERMINAL_PLAY_STATUSES.has(refreshed.status) ? withDashboardUrl(refreshed) : null;
+    return finishTerminalStatus(refreshed);
   };
   const handleLiveEvent = async (event) => {
     assertPlayWaitNotTimedOut({ ...input, lastPhase });
@@ -9664,7 +9781,7 @@ async function waitForPlayCompletionByWatch(input) {
     }
     const finalStatus = getFinalStatusFromLiveEvent(event);
     if (event.type === "play.run.final_status" && finalStatus) {
-      return withDashboardUrl(finalStatus);
+      return input.fullJson === void 0 ? withDashboardUrl(finalStatus) : fetchTerminalStatus();
     }
     const status = getStatusFromLiveEvent(event);
     if (status && TERMINAL_PLAY_STATUSES.has(status)) {
@@ -9679,7 +9796,37 @@ async function waitForPlayCompletionByWatch(input) {
         let terminalFromWatch = null;
         for await (const event of input.client.watchRunEvents(
           input.workflowId,
-          { signal: controller.signal }
+          {
+            signal: controller.signal,
+            deferLogs: !input.emitLogs,
+            omitTerminalLogs: !input.emitLogs,
+            ...isCliTraceEnabled() ? {
+              onPoll: (observation) => {
+                recordCliTrace({
+                  phase: "play_watch_poll",
+                  workflowId: input.workflowId,
+                  ms: observation.durationMs,
+                  poll: observation.poll,
+                  httpStatus: observation.status,
+                  serverTiming: observation.serverTiming
+                });
+              }
+            } : {},
+            terminalStatus: {
+              full: input.fullJson,
+              billing: false,
+              onStatus: async (status) => {
+                recordCliTrace({
+                  phase: "play_watch_terminal_status",
+                  workflowId: input.workflowId,
+                  full: input.fullJson === true
+                });
+                terminalStatusRead = Promise.resolve(
+                  await finishTerminalStatus(status)
+                );
+              }
+            }
+          }
         )) {
           const terminal3 = await handleLiveEvent(event);
           if (terminal3) terminalFromWatch = terminal3;
@@ -9716,18 +9863,183 @@ async function waitForPlayCompletionByWatch(input) {
     controller.abort();
   }
 }
+async function startAndWaitForPlayCompletion(input) {
+  const startedAt = Date.now();
+  const controller = new AbortController();
+  let timedOut = false;
+  const timeout = input.waitTimeoutMs === null ? null : setTimeout(
+    () => {
+      timedOut = true;
+      controller.abort();
+    },
+    Math.max(1, input.waitTimeoutMs)
+  );
+  let started;
+  let inlineCompatibility = input.cliAdmission === true;
+  const request = input.request;
+  try {
+    try {
+      started = await input.client.startPlayRun(request, {
+        signal: controller.signal,
+        onSubmission: input.onSubmission,
+        ...input.cliAdmission ? { cliAdmission: true } : {}
+      });
+    } catch (error) {
+      if (!(error instanceof CliPlayAdmissionUnsupportedError)) throw error;
+      await checkPlayRunCompatibility(
+        input.client.baseUrl,
+        input.maintenancePolicy
+      );
+      inlineCompatibility = false;
+      controller.signal.throwIfAborted();
+      started = await input.client.startPlayRun(request, {
+        signal: controller.signal,
+        onSubmission: input.onSubmission
+      });
+    }
+  } catch (error) {
+    if (timedOut) {
+      assertPlayWaitNotTimedOut({
+        workflowId: "",
+        startedAt,
+        waitTimeoutMs: input.waitTimeoutMs
+      });
+    }
+    throw error;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+  const workflowId = started.workflowId;
+  if (!workflowId || workflowId === "pending") {
+    throw new DeeplineError(
+      "Play admission returned no run id. Check recent runs before submitting again.",
+      void 0,
+      "PLAY_START_MISSING_RUN_ID"
+    );
+  }
+  await input.onRunStarted?.(workflowId);
+  await input.onRunAdmitted?.(workflowId);
+  const dashboardUrl = started.dashboardUrl ?? buildPlayDashboardUrl(input.client.baseUrl, input.playName);
+  if (!input.jsonOutput) {
+    writeStartedPlayRun({
+      runId: workflowId,
+      playName: input.playName,
+      dashboardUrl,
+      inputFieldCount: Object.keys(input.request.input ?? {}).length,
+      jsonOutput: false,
+      progress: input.progress
+    });
+  }
+  openPlayDashboard(dashboardUrl, input.open ?? false);
+  input.progress.phase("running");
+  recordCliTrace({
+    phase: "cli.play_start_admitted",
+    ms: Date.now() - startedAt,
+    ok: true,
+    playName: input.playName,
+    workflowId,
+    inlineCompatibility
+  });
+  const initialTerminal = readRecord(started.finalStatus);
+  const initialPackage = readRecord(initialTerminal?.package) ?? initialTerminal;
+  const initialRun = readRecord(initialPackage?.run);
+  if (initialTerminal && initialRun?.id === workflowId && initialRun.status === "completed" && (initialTerminal.runId === void 0 || initialTerminal.runId === workflowId) && (initialTerminal.status === void 0 || initialTerminal.status === "completed") && input.fullJson === true && started.finalStatusView === "full") {
+    assertPlayWaitNotTimedOut({
+      workflowId,
+      startedAt,
+      waitTimeoutMs: input.waitTimeoutMs
+    });
+    const initialStatus = normalizePlayStatus(initialTerminal);
+    const status2 = await resolvePlayRunOutputStatus({
+      client: input.client,
+      status: initialStatus,
+      fullJson: true,
+      jsonOutput: input.jsonOutput,
+      fromDurableStatus: true
+    });
+    recordCliTrace({
+      phase: "play_watch_terminal_status",
+      workflowId,
+      full: true,
+      source: status2 === initialStatus ? "start_response" : "durable_repair"
+    });
+    const completedStatus = { ...status2, dashboardUrl };
+    return input.request.revisionId ? { ...completedStatus, revisionId: input.request.revisionId } : completedStatus;
+  }
+  const status = await waitForPlayCompletionByWatch({
+    ...input,
+    workflowId,
+    dashboardUrl,
+    startedAt,
+    onRunAdmitted: void 0,
+    state: {
+      emittedRunnerStarted: false,
+      verbose: input.verboseLogs === true,
+      logLevel: input.logLevel ?? "info",
+      lastProgressSignature: null,
+      lastProgressHeartbeatAt: 0,
+      lastStatusHeartbeatAt: 0
+    }
+  });
+  return input.request.revisionId ? { ...status, revisionId: input.request.revisionId } : status;
+}
 async function startAndWaitForPlayCompletionByStream(input) {
   const prepared = await input.client.preparePlayRunAdmission(input.request, {
+    cliAdmission: input.cliAdmission,
     onSubmission: input.onSubmission
   });
   const pinnedInput = {
     ...input,
     request: prepared.body,
-    startStream: prepared.startStream
+    startStream: prepared.startStream,
+    supportsCallerIntent: prepared.supportsCallerIntent
   };
   const retryDelays = prepared.supportsCallerIntent ? PLAY_START_TRANSIENT_RETRY_DELAYS_MS : [];
   for (let attempt = 0; attempt <= retryDelays.length; attempt += 1) {
-    const status = await startAndWaitForPlayCompletionByStreamOnce(pinnedInput);
+    let status;
+    try {
+      status = await startAndWaitForPlayCompletionByStreamOnce(pinnedInput);
+    } catch (error) {
+      if (error instanceof CliPlayAdmissionUnsupportedError && input.cliAdmission) {
+        await checkPlayRunCompatibility(
+          input.client.baseUrl,
+          input.maintenancePolicy
+        );
+        return startAndWaitForPlayCompletion({
+          ...input,
+          cliAdmission: false,
+          streamTerminalWindowMs: void 0
+        });
+      }
+      if (!(error instanceof RetryablePlayStartAttemptError)) throw error;
+      const retryDelayMs2 = retryDelays[attempt];
+      if (retryDelayMs2 === void 0) {
+        throw new DeeplineError(
+          `Play ${input.playName} did not start after retrying transient start failures.`,
+          void 0,
+          "PLAY_START_RETRY_EXHAUSTED",
+          {
+            causeMessage: error.originalError instanceof Error ? error.originalError.message : String(error.originalError)
+          }
+        );
+      }
+      if (!input.jsonOutput) {
+        input.progress.writeLine(
+          `[play watch] start response was ambiguous; retrying the same caller intent (${error.message})`
+        );
+      }
+      recordCliTrace({
+        phase: "cli.play_start_stream_retry",
+        ms: 0,
+        ok: true,
+        playName: input.playName,
+        attempt: attempt + 1,
+        reason: error.message,
+        recovery: "same_caller_intent"
+      });
+      await sleep(retryDelayMs2);
+      continue;
+    }
     const retryDelayMs = retryDelays[attempt];
     if (retryDelayMs === void 0 || !isRetryablePendingStartFailure(status)) {
       return status;
@@ -9775,10 +10087,26 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
   let eventCount = 0;
   let firstRunIdMs = null;
   let launchConfirmed = false;
+  let terminalWindowExpired = false;
+  let terminalWindowTimer = null;
   const confirmAdmission = async (runId) => {
     if (launchConfirmed || !runId || runId === "pending") return;
     launchConfirmed = true;
     await input.onRunAdmitted?.(runId);
+    recordCliTrace({
+      phase: "cli.play_start_admitted",
+      ms: Date.now() - startedAt,
+      ok: true,
+      playName: input.playName,
+      workflowId: runId,
+      inlineCompatibility: input.cliAdmission === true
+    });
+    if ((input.streamTerminalWindowMs ?? 0) > 0) {
+      terminalWindowTimer = setTimeout(() => {
+        terminalWindowExpired = true;
+        controller.abort();
+      }, input.streamTerminalWindowMs);
+    }
   };
   let lastPhase = null;
   const timeout = input.waitTimeoutMs === null ? null : setTimeout(
@@ -9795,7 +10123,8 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
     let refreshed;
     try {
       refreshed = await input.client.getPlayStatus(lastKnownWorkflowId, {
-        billing: false
+        billing: false,
+        full: input.fullJson
       });
     } catch (error) {
       if (isTransientPlayRunReadError(error)) {
@@ -9918,11 +10247,18 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
             ...launchedRevisionId ? { revisionId: launchedRevisionId } : {}
           };
         }
-        const canonicalTerminal = input.request.profile === "absurd" ? await fetchKnownTerminalStatus() : {
-          ...finalStatus,
-          dashboardUrl,
-          ...launchedRevisionId ? { revisionId: launchedRevisionId } : {}
-        };
+        let fromDurableStatus = false;
+        let canonicalTerminal;
+        if (input.request.profile === "absurd") {
+          canonicalTerminal = await fetchKnownTerminalStatus();
+          fromDurableStatus = canonicalTerminal !== null;
+        } else {
+          canonicalTerminal = {
+            ...finalStatus,
+            dashboardUrl,
+            ...launchedRevisionId ? { revisionId: launchedRevisionId } : {}
+          };
+        }
         if (!canonicalTerminal) {
           recordCliTrace({
             phase: "cli.play_start_stream_stale_terminal_ignored",
@@ -9937,22 +10273,37 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
           });
           continue;
         }
+        const outputTerminal = input.fullJson === true ? await resolvePlayRunOutputStatus({
+          client: input.client,
+          status: canonicalTerminal,
+          fullJson: true,
+          jsonOutput: input.jsonOutput,
+          fromDurableStatus
+        }) : canonicalTerminal;
+        if (input.fullJson === true) {
+          recordCliTrace({
+            phase: "play_watch_terminal_status",
+            workflowId: outputTerminal.runId || lastKnownWorkflowId || void 0,
+            full: true,
+            source: outputTerminal === canonicalTerminal ? fromDurableStatus ? "start_stream_durable" : "start_stream" : "durable_repair"
+          });
+        }
         recordCliTrace({
           phase: "cli.play_start_stream_terminal",
           ms: Date.now() - startedAt,
           ok: true,
           playName: input.playName,
-          workflowId: canonicalTerminal.runId || lastKnownWorkflowId || null,
+          workflowId: outputTerminal.runId || lastKnownWorkflowId || null,
           eventCount,
           firstRunIdMs,
           lastPhase
         });
-        if (statusProvesPlayRunExecution(canonicalTerminal.status)) {
+        if (statusProvesPlayRunExecution(outputTerminal.status)) {
           await confirmAdmission(lastKnownWorkflowId);
         }
-        return canonicalTerminal;
+        return outputTerminal;
       }
-      if (lastKnownWorkflowId && launchConfirmed) {
+      if (lastKnownWorkflowId && launchConfirmed && (!input.streamTerminalWindowMs || terminalWindowExpired)) {
         if (timeout) {
           clearTimeout(timeout);
         }
@@ -9965,7 +10316,8 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
           workflowId: lastKnownWorkflowId,
           eventCount,
           firstRunIdMs,
-          lastPhase
+          lastPhase,
+          handoffReason: terminalWindowExpired ? "terminal_window_elapsed" : "launch_confirmed"
         });
         return waitForPlayCompletionByWatch({
           client: input.client,
@@ -9978,6 +10330,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
           startedAt,
           state,
           progress: input.progress,
+          fullJson: input.fullJson,
           onRunAdmitted: confirmAdmission
         });
       }
@@ -10006,11 +10359,11 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
         lastPhase
       });
     }
-    if (lastKnownWorkflowId && isTransientPlayRunReadError(error)) {
+    if (lastKnownWorkflowId && (terminalWindowExpired || isTransientPlayRunReadError(error))) {
       if (timeout) {
         clearTimeout(timeout);
       }
-      const reason = error instanceof Error ? error.message : String(error);
+      const reason = terminalWindowExpired ? "terminal observation window elapsed" : error instanceof Error ? error.message : String(error);
       if (!input.jsonOutput) {
         process.stderr.write(
           `[play watch] start stream failed after run ${lastKnownWorkflowId}; reconnecting to canonical run stream (${reason})
@@ -10039,10 +10392,11 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
         startedAt,
         state,
         progress: input.progress,
+        fullJson: input.fullJson,
         onRunAdmitted: confirmAdmission
       });
     }
-    if (!lastKnownWorkflowId && isTransientPlayRunReadError(error)) {
+    if (!lastKnownWorkflowId && isAmbiguousPlayStartOutcomeError(error)) {
       recordCliTrace({
         phase: "cli.play_start_stream_transient_failure",
         ms: Date.now() - startedAt,
@@ -10053,17 +10407,17 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
         lastPhase,
         reason: error instanceof Error ? error.message : String(error)
       });
-      return pendingStartFailureStatus({
-        playName: input.playName,
-        dashboardUrl,
-        error
-      });
+      if (input.supportsCallerIntent) {
+        throw new RetryablePlayStartAttemptError(error);
+      }
+      throw new PlayStartOutcomeUnknownError(input.playName, error);
     }
     throw error;
   } finally {
     if (timeout) {
       clearTimeout(timeout);
     }
+    if (terminalWindowTimer) clearTimeout(terminalWindowTimer);
   }
   if (lastKnownWorkflowId) {
     if (!input.jsonOutput) {
@@ -10080,7 +10434,8 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
       eventCount,
       firstRunIdMs,
       lastPhase,
-      reason: "stream ended before terminal event"
+      reason: "stream ended before terminal event",
+      ...terminalWindowExpired ? { handoffReason: "terminal_window_elapsed" } : {}
     });
     return waitForPlayCompletionByWatch({
       client: input.client,
@@ -10093,13 +10448,14 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
       startedAt,
       state,
       progress: input.progress,
+      fullJson: input.fullJson,
       onRunAdmitted: confirmAdmission
     });
   }
   const phaseSuffix = lastPhase && lastPhase.trim() ? ` (last observed phase: ${lastPhase.trim()})` : "";
   const idSuffix = lastKnownWorkflowId ? ` runId=${lastKnownWorkflowId}` : "";
-  throw new DeeplineError(
-    `Play start request ended before terminal status was observed${idSuffix}${phaseSuffix}. If a run id was printed, inspect it with 'deepline runs get <run-id> --full' or continue watching with 'deepline runs watch <run-id>'.`,
+  const endedBeforeConfirmation = new DeeplineError(
+    `Play start request ended before terminal status was observed${idSuffix}${phaseSuffix}.`,
     void 0,
     "PLAY_START_STREAM_ENDED",
     {
@@ -10107,6 +10463,14 @@ async function startAndWaitForPlayCompletionByStreamOnce(input) {
       ...lastPhase ? { phase: lastPhase } : {}
     }
   );
+  if (lastKnownWorkflowId) throw endedBeforeConfirmation;
+  if (input.supportsCallerIntent) {
+    throw new RetryablePlayStartAttemptError(endedBeforeConfirmation);
+  }
+  throw new PlayStartOutcomeUnknownError(
+    input.playName,
+    endedBeforeConfirmation
+  );
 }
 function formatInteger(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toLocaleString("en-US") : String(value ?? "-");
@@ -11861,7 +12225,7 @@ function withRunNavigationLines(lines, status, actionCommands = buildRunNavigati
 function playRunPackageTextLedgerIncomplete(pkg) {
   if (!pkg) return true;
   const steps = readRecordArray(pkg.steps);
-  if (steps.length === 0) return true;
+  if (steps.length === 0) return pkg.stepsExpected !== false;
   for (const step of steps) {
     if (step.kind !== "dataset" || step.status !== "completed") continue;
     const output = readRecord(step.output);
@@ -11876,9 +12240,9 @@ async function resolvePlayRunOutputStatus(input) {
     return input.status;
   }
   const streamedPackage = getPlayRunPackage(input.status);
-  const refreshForFullJson = input.fullJson && streamedPackage !== null;
+  const refreshForFullJson = input.fullJson && !input.fromDurableStatus;
   const streamedTextPackageIncomplete = input.status.status === "completed" && playRunPackageTextLedgerIncomplete(streamedPackage);
-  const refreshFailedTerminal = input.status.status === "failed";
+  const refreshFailedTerminal = input.status.status === "failed" && (!input.fromDurableStatus || readRecord(streamedPackage?.run)?.status !== "failed");
   if (!refreshForFullJson && !streamedTextPackageIncomplete && !refreshFailedTerminal) {
     return input.status;
   }
@@ -13144,45 +13508,61 @@ async function checkOneExportedPlay(input) {
   const authoringErrors = collectPlayGraphAuthoringErrors(graph);
   const client = new DeeplineClient();
   const integrationMode = resolveEvalIntegrationMode();
-  const importedPlays = [...graph.nodes.values()].filter((node) => node.filePath !== graph.root.filePath).map((node) => ({
-    playName: node.playName,
-    sourceCode: node.sourceCode,
-    sourcePath: playAuthoringGraphPath(graph.root, node.filePath)
-  }));
-  const result = await client.checkPlayArtifact({
-    name: playName,
-    sourceCode: graph.root.sourceCode,
-    sourceFiles: graph.root.sourceFiles,
-    description: graph.root.playDescription ?? void 0,
-    artifact: artifactForProductionCompatibilityCheck(graph.root.artifact),
-    ...exportName === PLAY_DEFAULT_EXPORT ? {} : { exportName },
-    ...importedPlays.length > 0 ? { importedPlays } : {},
-    ...integrationMode ? { integrationMode } : {}
+  const checked = await checkLocalPlayGraph({
+    client,
+    graph,
+    rootPlayName: playName,
+    exportName,
+    integrationMode,
+    prepareArtifact: artifactForProductionCompatibilityCheck
   });
-  const valid = result.valid && authoringErrors.length === 0;
+  const importedPlayName = checked.failedChild?.playName;
+  const diagnosticPrefix = importedPlayName ? `Imported Play ${importedPlayName}: ` : "";
+  const valid = checked.result.valid && !checked.failedChild && authoringErrors.length === 0;
+  const errors = [
+    ...authoringErrors,
+    ...checked.result.errors.map((error) => `${diagnosticPrefix}${error}`)
+  ];
   return {
     exportName,
     playName,
-    ...authoringErrors.length > 0 ? { stage: "authoring" } : {},
+    ...authoringErrors.length > 0 || checked.failedChild ? { stage: "authoring" } : {},
     result: {
-      ...result,
+      ...checked.result,
       valid,
-      errors: valid ? result.errors : addPlayCheckRepairHints({
-        errors: [...authoringErrors, ...result.errors],
-        sourceCode: graph.root.sourceCode
+      errors: valid ? checked.result.errors : addPlayCheckRepairHints({
+        errors,
+        sourceCode: checked.failedChild?.sourceCode ?? graph.root.sourceCode
       }),
-      toolGetterHints: result.toolGetterHints ?? await buildToolGetterHints(client, result.staticPipeline)
+      ...checked.failedChild && checked.result.issues ? {
+        issues: checked.result.issues.map((issue) => ({
+          ...issue,
+          message: `${diagnosticPrefix}${issue.message}`
+        }))
+      } : {},
+      toolGetterHints: checked.result.toolGetterHints ?? (checked.failedChild ? [] : await buildToolGetterHints(client, checked.result.staticPipeline))
     }
   };
 }
 function playRunClientOptions(options) {
   return options.headers ? { headers: options.headers } : void 0;
 }
+async function preflightPlayRunTotalBudget(input) {
+  if (input.maxTotalCredits === null) return;
+  await input.client.preparePlayRunAdmission({
+    name: input.playName,
+    maxTotalCredits: input.maxTotalCredits
+  });
+}
 async function handleFileBackedRun(options, hooks) {
   if (options.target.kind !== "file") {
     throw new Error("Expected a file-backed play run target.");
   }
   let client;
+  let cliAdmission = usesInlinePlayAdmission(
+    "plays run",
+    process.argv.slice(2)
+  );
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const absolutePlayPath = resolve5(options.target.path);
   progress.phase("compiling play");
@@ -13220,6 +13600,18 @@ async function handleFileBackedRun(options, hooks) {
       return 0;
     }
     client = new DeeplineClient(playRunClientOptions(options));
+    if (cliAdmission && (graph.root.importedPlayDependencies.length > 0 || inputContainsLocalFilePath(runtimeInput))) {
+      await checkPlayRunCompatibility(
+        client.baseUrl,
+        options.maintenancePolicy
+      );
+      cliAdmission = false;
+    }
+    await preflightPlayRunTotalBudget({
+      client,
+      playName: graph.root.playName ?? extractPlayName(sourceCode, absolutePlayPath),
+      maxTotalCredits: options.maxTotalCredits
+    });
     const canDeferCompilerManifest = graph.root.importedPlayDependencies.length === 0 && !sourceGraphMentionsRunPlay(graph.root) && !inputContainsLocalFilePath(runtimeInput);
     if (canDeferCompilerManifest) {
       recordCliTrace({
@@ -13324,7 +13716,7 @@ async function handleFileBackedRun(options, hooks) {
     const finalStatus = await traceCliSpan(
       "cli.play_start_watch",
       { targetKind: "file", playName },
-      () => startAndWaitForPlayCompletionByStream({
+      () => (options.runIdFile || cliAdmission ? startAndWaitForPlayCompletionByStream : startAndWaitForPlayCompletion)({
         client,
         request: startRequest,
         playName,
@@ -13337,7 +13729,13 @@ async function handleFileBackedRun(options, hooks) {
         progress,
         onRunStarted: hooks?.onRunStarted,
         onSubmission: hooks?.onSubmission,
-        onRunAdmitted: hooks?.onRunAdmitted
+        onRunAdmitted: hooks?.onRunAdmitted,
+        maintenancePolicy: options.maintenancePolicy,
+        ...options.runIdFile ? {} : { fullJson: options.fullJson },
+        ...cliAdmission ? {
+          cliAdmission: true,
+          streamTerminalWindowMs: PLAY_START_STREAM_TERMINAL_WINDOW_MS
+        } : {}
       }).catch(async (error) => {
         throw await normalizePlayStartError(client, error, playName);
       })
@@ -13349,12 +13747,12 @@ async function handleFileBackedRun(options, hooks) {
     }
     const outputStatus = withOrdinaryRunAgainCommand(
       withTerminalPlayIdentity(
-        await resolvePlayRunOutputStatus({
+        options.runIdFile ? await resolvePlayRunOutputStatus({
           client,
           status: finalStatus,
           fullJson: options.fullJson,
           jsonOutput: options.jsonOutput
-        }),
+        }) : finalStatus,
         playName
       ),
       options
@@ -13419,6 +13817,10 @@ async function handleNamedRun(options, hooks) {
     throw new Error("Expected a named play run target.");
   }
   const client = new DeeplineClient(playRunClientOptions(options));
+  let cliAdmission = usesInlinePlayAdmission(
+    "plays run",
+    process.argv.slice(2)
+  );
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const playName = options.target.name;
   const runtimeInput = options.input ? { ...options.input } : {};
@@ -13465,10 +13867,19 @@ async function handleNamedRun(options, hooks) {
       selector: options.revisionSelector
     })
   );
+  await preflightPlayRunTotalBudget({
+    client,
+    playName,
+    maxTotalCredits: options.maxTotalCredits
+  });
   const fileInputBindings = playDetail ? [
     ...fileInputBindingsFromPlaySchema(playDetail.play.inputSchema),
     ...fileInputBindingsFromStaticPipeline(playDetail.play.staticPipeline)
   ] : [];
+  if (cliAdmission && fileInputBindings.length > 0) {
+    await checkPlayRunCompatibility(client.baseUrl, options.maintenancePolicy);
+    cliAdmission = false;
+  }
   const stagedFileInputs = await traceCliSpan(
     "cli.play_stage_inputs",
     {
@@ -13516,7 +13927,7 @@ async function handleNamedRun(options, hooks) {
     const finalStatus = await traceCliSpan(
       "cli.play_start_watch",
       { targetKind: "name", playName },
-      () => startAndWaitForPlayCompletionByStream({
+      () => (options.runIdFile || cliAdmission ? startAndWaitForPlayCompletionByStream : startAndWaitForPlayCompletion)({
         client,
         request: startRequest,
         playName,
@@ -13529,7 +13940,13 @@ async function handleNamedRun(options, hooks) {
         progress,
         onRunStarted: hooks?.onRunStarted,
         onSubmission: hooks?.onSubmission,
-        onRunAdmitted: hooks?.onRunAdmitted
+        onRunAdmitted: hooks?.onRunAdmitted,
+        maintenancePolicy: options.maintenancePolicy,
+        ...options.runIdFile ? {} : { fullJson: options.fullJson },
+        ...cliAdmission ? {
+          cliAdmission: true,
+          streamTerminalWindowMs: PLAY_START_STREAM_TERMINAL_WINDOW_MS
+        } : {}
       }).catch(async (error) => {
         throw await normalizePlayStartError(client, error, playName, {
           suggestMissingPlay: true
@@ -13543,12 +13960,12 @@ async function handleNamedRun(options, hooks) {
     }
     const outputStatus = withOrdinaryRunAgainCommand(
       withTerminalPlayIdentity(
-        await resolvePlayRunOutputStatus({
+        options.runIdFile ? await resolvePlayRunOutputStatus({
           client,
           status: finalStatus,
           fullJson: options.fullJson,
           jsonOutput: options.jsonOutput
-        }),
+        }) : finalStatus,
         playName
       ),
       options,
@@ -14299,7 +14716,7 @@ Active runs: ${next.running}`
     return lines2.join("\n");
   });
   const nextOffset = (page.offset ?? offset ?? 0) + runs.length;
-  const nextPage = page.hasMore && playName ? `deepline runs list --play ${shellQuote(playName)}${statusFilter ? ` --status ${shellQuote(statusFilter)}` : ""} --limit ${page.limit ?? limit ?? 20} --offset ${nextOffset}` : null;
+  const nextPage = page.hasMore && playName ? `deepline runs list --play ${shellQuote(playName)}${nodeId ? ` --node ${shellQuote(nodeId)}` : ""}${statusFilter ? ` --status ${shellQuote(statusFilter)}` : ""} --limit ${page.limit ?? limit ?? 20} --offset ${nextOffset}${argsWantJson(args) ? " --json" : ""}` : null;
   if (page.hasMore) {
     lines.push("List truncated \u2014 more runs match this filter.");
     lines.push(
@@ -15083,6 +15500,7 @@ async function handleRunExport(args) {
   }
   const client = new DeeplineClient();
   let status = await client.getPlayStatus(runId, { full: true });
+  assertRunExportStatusIdentity(status, runId);
   if (wait && !TERMINAL_PLAY_STATUSES.has(status.status)) {
     const progress = createCliProgress(!argsWantJson(args));
     try {
@@ -15103,6 +15521,7 @@ async function handleRunExport(args) {
         progress
       });
       status = await client.getPlayStatus(runId, { full: true });
+      assertRunExportStatusIdentity(status, runId);
       progress.complete();
     } catch (error) {
       progress.fail();
@@ -15198,6 +15617,19 @@ async function handleRunExport(args) {
   });
   return 0;
 }
+function assertRunExportStatusIdentity(status, requestedRunId) {
+  if (status.runId === requestedRunId) return;
+  throw new DeeplineError(
+    `Run status identity did not match requested run ${requestedRunId}; refusing to export rows for ${status.runId || "an unidentified run"}.`,
+    void 0,
+    "RUN_EXPORT_SCOPE_MISMATCH",
+    {
+      requestedRunId,
+      statusRunId: status.runId || null,
+      reason: "status_identity_mismatch"
+    }
+  );
+}
 async function handlePlayGet(args) {
   const target = args[0];
   if (!target) {
@@ -16555,7 +16987,8 @@ JSON field selection:
         resolvePlayRunCliOptions(
           effectiveTarget ?? void 0,
           options,
-          passthroughArgs
+          passthroughArgs,
+          resolveCliMaintenancePolicy(command.optsWithGlobals())
         )
       );
       recordCliTrace({
@@ -16762,7 +17195,7 @@ Examples:
         process.exitCode = await ownView();
         return;
       }
-      const { describeAnything } = await import("./describe-PVWQJ2PB.mjs");
+      const { describeAnything } = await import("./describe-Q23DWJUK.mjs");
       process.exitCode = await describeAnything(
         name,
         {
@@ -17151,12 +17584,13 @@ Examples:
   deepline runs list --play my-play --status failed --compact
   deepline runs list --status running --compact
 `
-  ).option("--play <name>", "Play name to filter runs").option("--status <status>", "Filter by run status").option("--limit <count>", "Maximum runs to return").option("--offset <count>", "Zero-based page offset (requires --play)").option("--compact", "Drop verbose fields from JSON output").option("--json", "Emit JSON output").option(
+  ).option("--play <name>", "Play name to filter runs").option("--node <id>", "Mermaid node id to filter runs").option("--status <status>", "Filter by run status").option("--limit <count>", "Maximum runs to return").option("--offset <count>", "Zero-based page offset (requires --play)").option("--compact", "Drop verbose fields from JSON output").option("--json", "Emit JSON output").option(
     "--timing",
     "Report the inventory request duration and periodic long-read updates to stderr"
   ).action(async (options) => {
     process.exitCode = await handleRunsList([
       ...options.play ? ["--play", options.play] : [],
+      ...options.node ? ["--node", options.node] : [],
       ...options.status ? ["--status", options.status] : [],
       ...options.limit ? ["--limit", options.limit] : [],
       ...options.offset ? ["--offset", options.offset] : [],
@@ -17812,6 +18246,7 @@ export {
   resolveRunStopState,
   selectRunLogTailPage,
   shouldPrintPlayProgressLine,
+  startAndWaitForPlayCompletion,
   startAndWaitForPlayCompletionByStream,
   truncateErrorForDisplay,
   waitForPlayCompletionByWatch,