deepline 0.3.200 → 0.3.202

package/dist/cli/index.mjs

@@ -3046,7 +3046,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.200",
+  version: "0.3.202",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1
@@ -3637,6 +3637,11 @@ var MAX_DIAGNOSTIC_HEADER_LENGTH = 120;
 var COWORK_NETWORK_HINT = "Claude Cowork appears to be running Deepline in a network-restricted sandbox. In Claude Desktop, open Settings > Capabilities, turn on Allow network egress, and set Domain allowlist to All domains for the Cowork session.";
 var REQUEST_TIMEOUT_MARKER = Symbol("deeplineRequestTimeout");
 var REQUEST_ABORT_MARKER = Symbol("deeplineRequestAbort");
+function requestCancelledError(signal) {
+  const error = withErrorCause(new Error("Request aborted"), signal.reason);
+  error[REQUEST_ABORT_MARKER] = true;
+  return error;
+}
 function normalizeRequestAbortError(error, input2) {
   const normalized = error instanceof Error ? error : new Error(String(error));
   const tagged = normalized;
@@ -3815,14 +3820,27 @@ var HttpClient = class {
     const candidateUrls = options?.exactUrlOnly ? [url] : buildCandidateUrls(url);
     let retryAfterDelayMs = null;
     const maxRetries = options?.maxRetries ?? this.config.maxRetries;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    requestAttempts: for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (options?.signal?.aborted) {
+        lastError = requestCancelledError(options.signal);
+        break;
+      }
       if (attempt > 0) {
         const backoffMs = Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
         const delayMs = retryAfterDelayMs === null ? backoffMs : Math.max(backoffMs, retryAfterDelayMs);
         retryAfterDelayMs = null;
-        await sleep(delayMs);
+        try {
+          await sleep(delayMs, options?.signal);
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          break;
+        }
       }
       for (const candidateUrl of candidateUrls) {
+        if (options?.signal?.aborted) {
+          lastError = requestCancelledError(options.signal);
+          break requestAttempts;
+        }
         const controller = new AbortController();
         const timeoutMs = options?.timeout ?? this.config.timeout;
         let requestTimedOut = false;
@@ -3830,6 +3848,10 @@ var HttpClient = class {
           requestTimedOut = true;
           controller.abort();
         }, timeoutMs);
+        const abortRequest = () => controller.abort();
+        options?.signal?.addEventListener("abort", abortRequest, {
+          once: true
+        });
         try {
           const response = await fetch(candidateUrl, {
             method,
@@ -3842,8 +3864,8 @@ var HttpClient = class {
             clearTimeout(timeoutId);
             return null;
           }
-          clearTimeout(timeoutId);
           const body = await response.text();
+          clearTimeout(timeoutId);
           const parsed = parseResponseBody(body);
           const structuredToolError = options?.toolId && !response.ok ? deserializeToolExecutionFailure(
             apiErrorMessage(parsed, response.status),
@@ -3938,6 +3960,10 @@ var HttpClient = class {
           return parsed;
         } catch (error) {
           clearTimeout(timeoutId);
+          if (options?.signal?.aborted) {
+            lastError = requestCancelledError(options.signal);
+            break requestAttempts;
+          }
           if (error instanceof AuthError || error instanceof DeeplineError) {
             throw error;
           }
@@ -3949,6 +3975,9 @@ var HttpClient = class {
             timeoutMs,
             timedOut: requestTimedOut
           });
+        } finally {
+          clearTimeout(timeoutId);
+          options?.signal?.removeEventListener("abort", abortRequest);
         }
       }
       if (attempt < maxRetries) continue;
@@ -4277,8 +4306,23 @@ function decodeSseFrame(frame) {
   }
   return parsed;
 }
-function sleep(ms) {
-  return new Promise((resolve22) => setTimeout(resolve22, ms));
+function sleep(ms, signal) {
+  return new Promise((resolve22, reject) => {
+    if (signal?.aborted) {
+      reject(requestCancelledError(signal));
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve22();
+    }, ms);
+    const abort = () => {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", abort);
+      reject(requestCancelledError(signal));
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+  });
 }
 function withCoworkNetworkHint(message) {
   if (!isCoworkLikeSandbox2() || message.includes(COWORK_NETWORK_HINT)) {
@@ -5465,9 +5509,13 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       tableNamespace: optionalString(rawDataset.tableNamespace) ?? datasetId,
       phase,
       persistedRows: Math.max(0, finiteNumber(rawDataset.persistedRows) ?? 0),
+      persistedRowsObserved: rawDataset.persistedRowsObserved === true,
       succeededRows: Math.max(0, finiteNumber(rawDataset.succeededRows) ?? 0),
+      succeededRowsObserved: rawDataset.succeededRowsObserved === true,
       failedRows: Math.max(0, finiteNumber(rawDataset.failedRows) ?? 0),
+      failedRowsObserved: rawDataset.failedRowsObserved === true,
       complete: rawDataset.complete === true,
+      completeObserved: rawDataset.completeObserved === true,
       // ADR 0019 birth survives the snapshot round trip. A partial record is
       // dropped rather than half-admitted, so a dataset either states where its
       // rows came from or says nothing.
@@ -7207,6 +7255,7 @@ var DeeplineClient = class _DeeplineClient {
     this.http = new HttpClient(this.config);
     this.runs = {
       get: (runId, options2) => this.getRunStatus(runId, options2),
+      status: (runId) => this.getRunLifecycleStatus(runId),
       list: (options2) => this.listRuns(options2),
       listPage: (options2) => this.listRunsPage(options2),
       tail: (runId, options2) => this.tailRun(runId, options2),
@@ -8619,6 +8668,13 @@ var DeeplineClient = class _DeeplineClient {
       }
     };
   }
+  /** Read only the bounded scalar projection; does not hydrate the run package. */
+  async getRunLifecycleStatus(runId) {
+    const response = await this.http.get(
+      `/api/v2/runs/${encodeURIComponent(runId)}/status`
+    );
+    return response;
+  }
   /**
    * List play runs using the public runs resource model.
    *
@@ -9012,7 +9068,8 @@ var DeeplineClient = class _DeeplineClient {
       params.set("rowMode", "all");
     }
     const result = await this.http.get(
-      `/api/v2/plays/${encodeURIComponent(input2.playName)}/sheet?${params.toString()}`
+      `/api/v2/plays/${encodeURIComponent(input2.playName)}/sheet?${params.toString()}`,
+      { signal: input2.signal }
     );
     const requestedRunId = input2.runId?.trim() || "";
     if (requestedRunId) {
@@ -15808,7 +15865,7 @@ import {
   mkdtemp as mkdtemp3,
   readFile as readFile4,
   realpath as realpath4,
-  rename,
+  rename as rename2,
   rm as rm3,
   stat as stat4,
   writeFile as writeFile4
@@ -15833,6 +15890,7 @@ import {
   link,
   open,
   readFile as readFileAsync,
+  rename,
   unlink
 } from "fs/promises";
 import {
@@ -20734,6 +20792,12 @@ var FIXTURE_BEHAVIOR_REPLAY_VERSION = 3;
 var MAX_FIXTURE_RESPONSE_DELAY_SAMPLES = 256;
 var MAX_FIXTURE_RESPONSE_DELAY_MS = 8 * 6e4;
 var MAX_FIXTURE_RESPONSE_ERROR_MESSAGE_LENGTH = 500;
+var MAX_FIXTURE_RETRY_AFTER_MS = 60 * 6e4;
+var FIXTURE_RATE_WINDOWS = [
+  { field: "requestsPerSecond", name: "rps", windowMs: 1e3 },
+  { field: "requestsPerMinute", name: "rpm", windowMs: 6e4 },
+  { field: "requestsPerHour", name: "rph", windowMs: 36e5 }
+];
 function validateFixtureBehavior(value) {
   if (value === void 0 || value === null) {
     return { ok: true, behavior: null };
@@ -20745,6 +20809,8 @@ function validateFixtureBehavior(value) {
   const supportedKeys = record3.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record3.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? /* @__PURE__ */ new Set([
     "version",
     "responseSamples",
+    "transient429",
+    "sharedRateLimit",
     ...record3.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? ["replayBundle"] : []
   ]) : /* @__PURE__ */ new Set(["version", "responseDelaySamplesMs"]);
   const unknownKeys = Object.keys(record3).filter(
@@ -20841,7 +20907,7 @@ function validateFixtureBehavior(value) {
         }
         const error = sample.httpError;
         const errorUnknownKeys = Object.keys(error).filter(
-          (key) => key !== "status" && key !== "message"
+          (key) => key !== "status" && key !== "message" && key !== "retryAfterMs" && key !== "retryAfterFormat" && key !== "failuresBeforeSuccess"
         );
         if (errorUnknownKeys.length > 0) {
           return {
@@ -20861,7 +20927,33 @@ function validateFixtureBehavior(value) {
             error: `fixtureBehavior.responseSamples[${index}].httpError.message must contain 1-${MAX_FIXTURE_RESPONSE_ERROR_MESSAGE_LENGTH} characters.`
           };
         }
-        httpError = { status: error.status, message: error.message.trim() };
+        if (error.retryAfterMs !== void 0 && (error.status !== 429 || typeof error.retryAfterMs !== "number" || !Number.isSafeInteger(error.retryAfterMs) || error.retryAfterMs < 1 || error.retryAfterMs > MAX_FIXTURE_RETRY_AFTER_MS)) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].httpError.retryAfterMs requires status 429 and an integer from 1 through ${MAX_FIXTURE_RETRY_AFTER_MS}.`
+          };
+        }
+        if (error.retryAfterFormat !== void 0 && (error.status !== 429 || error.retryAfterFormat !== "delta_seconds" && error.retryAfterFormat !== "http_date")) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].httpError.retryAfterFormat requires status 429 and delta_seconds or http_date.`
+          };
+        }
+        if (error.failuresBeforeSuccess !== void 0 && (error.status !== 429 || typeof error.failuresBeforeSuccess !== "number" || !Number.isSafeInteger(error.failuresBeforeSuccess) || error.failuresBeforeSuccess < 1 || error.failuresBeforeSuccess > 20)) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].httpError.failuresBeforeSuccess requires status 429 and an integer from 1 through 20.`
+          };
+        }
+        httpError = {
+          status: error.status,
+          message: error.message.trim(),
+          ...error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {},
+          ...error.retryAfterFormat !== void 0 ? {
+            retryAfterFormat: error.retryAfterFormat
+          } : {},
+          ...error.failuresBeforeSuccess !== void 0 ? { failuresBeforeSuccess: error.failuresBeforeSuccess } : {}
+        };
       }
       samples2.push({
         delayMs: sample.delayMs,
@@ -20869,6 +20961,106 @@ function validateFixtureBehavior(value) {
         ...httpError ? { httpError } : {}
       });
     }
+    let sharedRateLimit;
+    if (record3.sharedRateLimit !== void 0) {
+      const plan = record3.sharedRateLimit;
+      if (!plan || typeof plan !== "object" || Array.isArray(plan)) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.sharedRateLimit must be an object."
+        };
+      }
+      const planRecord = plan;
+      const entries = Object.entries(planRecord);
+      const boundaryAfterMs = planRecord.requestsPerHourBoundaryAfterMs;
+      const quotaEntries = entries.filter(
+        ([name]) => name !== "requestsPerHourBoundaryAfterMs"
+      );
+      if (quotaEntries.length === 0 || quotaEntries.some(
+        ([name, limit]) => !FIXTURE_RATE_WINDOWS.some((window) => window.field === name) || typeof limit !== "number" || !Number.isSafeInteger(limit) || limit < 1
+      )) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.sharedRateLimit requires positive integer requestsPerSecond, requestsPerMinute, or requestsPerHour quotas."
+        };
+      }
+      if (boundaryAfterMs !== void 0 && (planRecord.requestsPerHour === void 0 || typeof boundaryAfterMs !== "number" || !Number.isSafeInteger(boundaryAfterMs) || boundaryAfterMs < 1e3 || boundaryAfterMs > 3e5)) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.sharedRateLimit.requestsPerHourBoundaryAfterMs requires requestsPerHour and an integer from 1000 through 300000."
+        };
+      }
+      sharedRateLimit = Object.fromEntries(entries);
+    }
+    let transient429;
+    if (record3.transient429 !== void 0) {
+      const selected = record3.transient429;
+      if (!selected || typeof selected !== "object" || Array.isArray(selected)) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.transient429 must be an object."
+        };
+      }
+      const fault = selected;
+      const unknownFaultKeys = Object.keys(fault).filter(
+        (key) => key !== "everyNthCall" && key !== "retryAfterMs" && key !== "failuresBeforeSuccess" && key !== "when"
+      );
+      if (unknownFaultKeys.length > 0) {
+        return {
+          ok: false,
+          error: `Unsupported fixtureBehavior.transient429 field "${unknownFaultKeys[0]}".`
+        };
+      }
+      for (const [name, value2, max] of [
+        ["everyNthCall", fault.everyNthCall, 1e4],
+        ["retryAfterMs", fault.retryAfterMs, MAX_FIXTURE_RETRY_AFTER_MS],
+        ["failuresBeforeSuccess", fault.failuresBeforeSuccess, 20]
+      ]) {
+        if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < 1 || value2 > max) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.transient429.${name} must be an integer from 1 through ${max}.`
+          };
+        }
+      }
+      let when;
+      if (fault.when !== void 0) {
+        if (!fault.when || typeof fault.when !== "object" || Array.isArray(fault.when)) {
+          return {
+            ok: false,
+            error: "fixtureBehavior.transient429.when must be an object."
+          };
+        }
+        const condition = fault.when;
+        const unknownConditionKeys = Object.keys(condition).filter(
+          (key) => key !== "provider" && key !== "operation"
+        );
+        if (unknownConditionKeys.length > 0) {
+          return {
+            ok: false,
+            error: `Unsupported fixtureBehavior.transient429.when field "${unknownConditionKeys[0]}".`
+          };
+        }
+        const provider = normalizeFixtureScopeValue(condition.provider, 100);
+        const operation = normalizeFixtureScopeValue(condition.operation, 200);
+        if (provider.error || operation.error || !provider.value && !operation.value) {
+          return {
+            ok: false,
+            error: "fixtureBehavior.transient429.when must select a valid provider or operation."
+          };
+        }
+        when = {
+          ...provider.value ? { provider: provider.value } : {},
+          ...operation.value ? { operation: operation.value } : {}
+        };
+      }
+      transient429 = {
+        everyNthCall: fault.everyNthCall,
+        retryAfterMs: fault.retryAfterMs,
+        failuresBeforeSuccess: fault.failuresBeforeSuccess,
+        ...when ? { when } : {}
+      };
+    }
     let replayBundle;
     if (record3.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
       if (!record3.replayBundle || typeof record3.replayBundle !== "object" || Array.isArray(record3.replayBundle)) {
@@ -20931,6 +21123,8 @@ function validateFixtureBehavior(value) {
         behavior: {
           version: FIXTURE_BEHAVIOR_REPLAY_VERSION,
           responseSamples: samples2,
+          ...transient429 ? { transient429 } : {},
+          ...sharedRateLimit ? { sharedRateLimit } : {},
           replayBundle
         }
       };
@@ -20939,7 +21133,9 @@ function validateFixtureBehavior(value) {
       ok: true,
       behavior: {
         version: FIXTURE_BEHAVIOR_RESPONSE_VERSION,
-        responseSamples: samples2
+        responseSamples: samples2,
+        ...transient429 ? { transient429 } : {},
+        ...sharedRateLimit ? { sharedRateLimit } : {}
       }
     };
   }
@@ -22823,43 +23019,52 @@ async function readRunIdFile(destination) {
   }
   return parsed;
 }
-async function writePlayRunIdFile(destination, runId) {
+async function writePlayRunIdFile(destination, runId, options = {}) {
   const existing = await readRunIdFile(destination);
   if (existing) {
-    if (existing.runId === runId) return;
-    throw new Error(
-      `--run-id-file destination already records run ${existing.runId}; refusing to replace it with ${runId}: ${destination}`
-    );
+    if (existing.runId !== runId) {
+      throw new Error(
+        `--run-id-file destination already records run ${existing.runId}; refusing to replace it with ${runId}: ${destination}`
+      );
+    }
+    if (!options.launchConfirmed || existing.launchConfirmed) return;
   }
   const tempPath = runIdFileTempPath(destination);
   let handle = null;
   try {
     handle = await open(tempPath, "wx", 384);
     await handle.writeFile(
-      `${JSON.stringify({ version: 1, runId })}
+      `${JSON.stringify({ version: 1, runId, ...options })}
 `,
       "utf8"
     );
     await handle.sync();
     await handle.close();
     handle = null;
-    try {
-      await link(tempPath, destination);
-      if (process.platform !== "win32") {
-        const directory = await open(dirname10(destination), "r");
-        try {
-          await directory.sync();
-        } finally {
-          await directory.close();
+    if (existing) {
+      await rename(tempPath, destination);
+    } else {
+      try {
+        await link(tempPath, destination);
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        const raced = await readRunIdFile(destination);
+        if (raced?.runId !== runId) {
+          throw new Error(
+            `--run-id-file destination already records run ${raced?.runId ?? "<invalid>"}; refusing to replace it with ${runId}: ${destination}`
+          );
         }
+        if (!options.launchConfirmed || raced.launchConfirmed) return;
+        await rename(tempPath, destination);
+      }
+    }
+    if (process.platform !== "win32") {
+      const directory = await open(dirname10(destination), "r");
+      try {
+        await directory.sync();
+      } finally {
+        await directory.close();
       }
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-      const raced = await readRunIdFile(destination);
-      if (raced?.runId === runId) return;
-      throw new Error(
-        `--run-id-file destination already records run ${raced?.runId ?? "<invalid>"}; refusing to replace it with ${runId}: ${destination}`
-      );
     }
   } finally {
     await handle?.close();
@@ -23916,6 +24121,16 @@ function getRunIdFromLiveEvent(event) {
 function eventConfirmsPlayRunLaunch(event) {
   return event.type === "play.run.status" && getEventPayload(event).launchConfirmed === true;
 }
+function statusProvesPlayRunExecution(status) {
+  return status === "waiting" || status === "completed";
+}
+function eventProvesPlayRunExecution(event) {
+  if (statusProvesPlayRunExecution(getStatusFromLiveEvent(event))) return true;
+  const payload = getEventPayload(event);
+  return Boolean(getStringField(payload, "stepId")) && (event.type === "play.step.progress" || event.type === "play.step.status" && ["running", "completed", "failed", "skipped"].includes(
+    getStringField(payload, "status") ?? ""
+  ));
+}
 function getStatusFromLiveEvent(event) {
   if (event.type !== "play.run.status" && event.type !== "play.run.snapshot" && event.type !== "play.run.final_status") {
     return null;
@@ -24392,6 +24607,12 @@ async function waitForPlayCompletionByStream(input2) {
   const durableStatusProbeIntervalMs = input2.durableStatusProbeIntervalMs ?? PLAY_DURABLE_STATUS_PROBE_INTERVAL_MS;
   let nextDurableProbeAt = Date.now() + durableStatusProbeIntervalMs;
   let durableStatusProbe = null;
+  let admissionConfirmed = false;
+  const confirmAdmission = async () => {
+    if (admissionConfirmed) return;
+    admissionConfirmed = true;
+    await input2.onRunAdmitted?.(input2.workflowId);
+  };
   const withDashboardUrl = (status) => input2.dashboardUrl ? { ...status, dashboardUrl: input2.dashboardUrl } : status;
   const remainingWaitMs = () => input2.waitTimeoutMs === null ? null : input2.waitTimeoutMs - (Date.now() - input2.startedAt);
   const fetchTerminalStatus = async () => {
@@ -24408,6 +24629,9 @@ async function waitForPlayCompletionByStream(input2) {
         }
         throw error;
       }
+      if (refreshed.runId === input2.workflowId && statusProvesPlayRunExecution(refreshed.status)) {
+        await confirmAdmission();
+      }
       return TERMINAL_PLAY_STATUSES2.has(refreshed.status) ? withDashboardUrl(refreshed) : null;
     })();
     durableStatusProbe = probe;
@@ -24419,6 +24643,9 @@ async function waitForPlayCompletionByStream(input2) {
   };
   const handleLiveEvent = async (event, probeDurableStatus) => {
     assertPlayWaitNotTimedOut({ ...input2, lastPhase });
+    if (getRunIdFromLiveEvent(event) === input2.workflowId && (eventConfirmsPlayRunLaunch(event) || eventProvesPlayRunExecution(event))) {
+      await confirmAdmission();
+    }
     const now = Date.now();
     if (now >= nextDurableProbeAt) {
       nextDurableProbeAt = now + durableStatusProbeIntervalMs;
@@ -24668,6 +24895,11 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
   let eventCount = 0;
   let firstRunIdMs = null;
   let launchConfirmed = false;
+  const confirmAdmission = async (runId) => {
+    if (launchConfirmed || !runId || runId === "pending") return;
+    launchConfirmed = true;
+    await input2.onRunAdmitted?.(runId);
+  };
   let lastPhase = null;
   const timeout = input2.waitTimeoutMs === null ? null : setTimeout(
     () => {
@@ -24691,6 +24923,9 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
       }
       throw error;
     }
+    if (refreshed.runId === lastKnownWorkflowId && statusProvesPlayRunExecution(refreshed.status)) {
+      await confirmAdmission(lastKnownWorkflowId);
+    }
     return TERMINAL_PLAY_STATUSES2.has(refreshed.status) ? {
       ...refreshed,
       dashboardUrl,
@@ -24718,8 +24953,8 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
           await input2.onRunStarted?.(eventRunId);
         }
       }
-      if (eventConfirmsPlayRunLaunch(event) && eventRunId === lastKnownWorkflowId) {
-        launchConfirmed = true;
+      if (!launchConfirmed && eventConfirmsPlayRunLaunch(event) && eventRunId === lastKnownWorkflowId) {
+        await confirmAdmission(lastKnownWorkflowId);
       }
       const workflowId = lastKnownWorkflowId || "pending";
       if (workflowId !== "pending" && !emittedDashboardUrl) {
@@ -24834,6 +25069,9 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
           firstRunIdMs,
           lastPhase
         });
+        if (statusProvesPlayRunExecution(canonicalTerminal.status)) {
+          await confirmAdmission(lastKnownWorkflowId);
+        }
         return canonicalTerminal;
       }
       if (lastKnownWorkflowId && launchConfirmed) {
@@ -24861,7 +25099,8 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
           waitTimeoutMs: input2.waitTimeoutMs,
           startedAt,
           state,
-          progress: input2.progress
+          progress: input2.progress,
+          onRunAdmitted: confirmAdmission
         });
       }
     }
@@ -24921,7 +25160,8 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
         waitTimeoutMs: input2.waitTimeoutMs,
         startedAt,
         state,
-        progress: input2.progress
+        progress: input2.progress,
+        onRunAdmitted: confirmAdmission
       });
     }
     if (!lastKnownWorkflowId && isTransientPlayStreamError(error)) {
@@ -24974,7 +25214,8 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
       waitTimeoutMs: input2.waitTimeoutMs,
       startedAt,
       state,
-      progress: input2.progress
+      progress: input2.progress,
+      onRunAdmitted: confirmAdmission
     });
   }
   const phaseSuffix = lastPhase && lastPhase.trim() ? ` (last observed phase: ${lastPhase.trim()})` : "";
@@ -25917,8 +26158,15 @@ function formatPackageDatasetActionLines(packaged, options) {
     const isReturned = datasetId && returned.datasetIds.has(datasetId) || returned.paths.has(path);
     const category = isReturned ? "returned" : dataset.recovered === true ? "recovered" : "persisted";
     const rowCount = typeof dataset.rowCount === "number" && Number.isFinite(dataset.rowCount) ? Math.max(0, Math.trunc(dataset.rowCount)) : null;
+    const lifecycle = readRecord(dataset.lifecycle);
+    const countUnconfirmed = lifecycle?.complete === false;
+    const persistedLowerBound = typeof lifecycle?.persistedRowsAtLeast === "number" && Number.isFinite(lifecycle.persistedRowsAtLeast) ? Math.max(0, Math.trunc(lifecycle.persistedRowsAtLeast)) : 0;
     const actions = readRecord(dataset.actions) ?? {};
-    if (includeSummary) {
+    if (countUnconfirmed) {
+      lines.push(
+        `  dataset ${path}: row count unconfirmed (at least ${formatInteger(persistedLowerBound)} persisted); export this run to inspect saved rows`
+      );
+    } else if (includeSummary) {
       if (category === "recovered" && Object.keys(actions).length === 0) {
         lines.push(
           `  dataset ${path}: available, ${rowCount === null ? "persisted" : formatInteger(rowCount)} rows persisted; re-running reuses completed work`
@@ -28266,7 +28514,8 @@ async function handleFileBackedRun(options, hooks) {
         waitTimeoutMs: options.waitTimeoutMs,
         open: options.open,
         progress,
-        onRunStarted: hooks?.onRunStarted
+        onRunStarted: hooks?.onRunStarted,
+        onRunAdmitted: hooks?.onRunAdmitted
       }).catch(async (error) => {
         throw await normalizePlayStartError(client2, error, playName);
       })
@@ -28307,6 +28556,7 @@ async function handleFileBackedRun(options, hooks) {
     })
   );
   await hooks?.onRunStarted?.(started.workflowId);
+  await hooks?.onRunAdmitted?.(started.workflowId);
   const resolvedDashboardUrl = buildPlayDashboardUrl(client2.baseUrl, playName);
   openPlayDashboard(resolvedDashboardUrl, options.open);
   progress.phase("started run");
@@ -28449,7 +28699,8 @@ async function handleNamedRun(options, hooks) {
         waitTimeoutMs: options.waitTimeoutMs,
         open: options.open,
         progress,
-        onRunStarted: hooks?.onRunStarted
+        onRunStarted: hooks?.onRunStarted,
+        onRunAdmitted: hooks?.onRunAdmitted
       }).catch(async (error) => {
         throw await normalizePlayStartError(client2, error, playName, {
           suggestMissingPlay: true
@@ -28495,6 +28746,7 @@ async function handleNamedRun(options, hooks) {
     })
   );
   await hooks?.onRunStarted?.(started.workflowId);
+  await hooks?.onRunAdmitted?.(started.workflowId);
   const resolvedDashboardUrl = buildPlayDashboardUrl(client2.baseUrl, playName);
   openPlayDashboard(resolvedDashboardUrl, options.open);
   progress.phase("started run");
@@ -28532,6 +28784,19 @@ async function handlePlayRun(args, hooks) {
         );
       }
       await hooks?.onRunStarted?.(runId);
+    },
+    onRunAdmitted: async (runId) => {
+      try {
+        await writePlayRunIdFile(options.runIdFile, runId, {
+          launchConfirmed: true
+        });
+      } catch (error) {
+        throw new Error(
+          `Run ${runId} was admitted, but its confirmation could not be persisted to ${options.runIdFile}: ${error instanceof Error ? error.message : String(error)}. Inspect it with 'deepline runs get ${runId} --json'; do not submit a replacement run.`,
+          { cause: error }
+        );
+      }
+      await hooks?.onRunAdmitted?.(runId);
     }
   } : hooks;
   if (options.target.kind === "file") {
@@ -28604,6 +28869,36 @@ async function handleRunGet(args) {
   });
   return 0;
 }
+async function handleRunLifecycleStatus(args) {
+  const usage = "Usage: deepline runs status <run-id> [--json]";
+  let runId;
+  try {
+    runId = parseRunIdPositional(args, usage);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : usage);
+    return 1;
+  }
+  const status = await new DeeplineClient().runs.status(runId);
+  if (argsWantJson(args)) {
+    printCommandEnvelope(status, { json: true });
+    return 0;
+  }
+  if (!status.available) {
+    console.log(`Scalar lifecycle status is not available for run ${runId}.`);
+    return 0;
+  }
+  const formatCount = (count) => count.value === null ? "unknown" : `${count.value}${count.confirmed ? "" : " (unconfirmed)"}`;
+  console.log(`${status.lifecycle.status} \xB7 ${runId}`);
+  console.log(
+    `Map-step work (summed, not unique rows): completed ${formatCount(status.mapStepWork.completed)} / ${formatCount(status.mapStepWork.total)}, failed ${formatCount(status.mapStepWork.failed)}`
+  );
+  if (status.lifecycle.status === "waiting") {
+    console.log(
+      status.wait.confirmed && status.wait.kind ? `Waiting: ${status.wait.kind}` : "Waiting reason: unknown"
+    );
+  }
+  return 0;
+}
 async function handleRunsRerun(args) {
   const usage = "Usage: deepline runs rerun <run-id> [--idempotency-key <key>] [--json]";
   let runId;
@@ -29076,6 +29371,30 @@ async function handleRunStop(args) {
   }
   const client2 = new DeeplineClient();
   const result = await client2.runs.stop(runId, { reason });
+  if (result.cancelling === true) {
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [
+            {
+              title: "run stop",
+              lines: [
+                `Cancellation queued for ${result.runId || runId}; sandbox cleanup is pending`,
+                ...result.hitlCancelledCount > 0 ? [`cancelled HITL waits: ${result.hitlCancelledCount}`] : [],
+                ...result.hitlCancellationPending === true ? [
+                  "warning: HITL cancellation or same-card Slack refresh is still pending"
+                ] : [],
+                `inspect: deepline runs get ${runId} --full --json`
+              ]
+            }
+          ]
+        }
+      },
+      { json: argsWantJson(args) }
+    );
+    return 0;
+  }
   const stopNotConfirmed = result.stopped === false || result.staleSchedulerState === true;
   if (stopNotConfirmed) {
     const detail = typeof result.error === "string" && result.error.trim() ? result.error.trim() : result.staleSchedulerState === true ? "scheduler state for the run is stale" : "the server did not confirm the stop";
@@ -29190,6 +29509,7 @@ async function handleRunStopAll(args) {
   const result = await client2.runs.stopAll({ reason });
   const lines = [
     `Stopped ${result.stopped} active run${result.stopped === 1 ? "" : "s"}`,
+    ...result.cancelling ? [`cancellation queued: ${result.cancelling}`] : [],
     ...result.partial ? ["partial: active runs may remain; rerun stop-all"] : [],
     ...result.failed > 0 ? [`failed stops: ${result.failed}`] : [],
     ...result.skipped > 0 ? [`skipped: ${result.skipped}`] : []
@@ -30979,6 +31299,12 @@ Examples:
   deepline runs export play/my-play/run/20260501t000000-000 --out output.csv
 `
   );
+  runs.command("status <runId>").description("Read bounded lifecycle and confirmed work counts for a run.").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
+    process.exitCode = await handleRunLifecycleStatus([
+      runId,
+      ...options.json ? ["--json"] : []
+    ]);
+  });
   runs.command("get <runId>").description(
     "Get status, progress, result, errors, and recovery metadata for a play run."
   ).addHelpText(
@@ -36596,7 +36922,7 @@ function registerEnrichCommand(program) {
         return exportResult;
       }
       const committedTempDir = inPlaceTempDir;
-      await rename(inPlaceTempOutputPath, inPlaceCommitOutputPath);
+      await rename2(inPlaceTempOutputPath, inPlaceCommitOutputPath);
       inPlaceTempDir = null;
       inPlaceTempOutputPath = null;
       outputPath = inPlaceFinalOutputPath;