deepline 0.3.237 → 0.3.238

package/dist/cli/index.js

@@ -3454,7 +3454,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.237",
+  version: "0.3.238",
   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
@@ -4103,19 +4103,19 @@ function withErrorCause(error, cause) {
   }
   return error;
 }
-function mapNetworkError(baseUrl, error, targetLabel2) {
+function mapNetworkError(baseUrl, error, targetLabel) {
   const tagged = error;
   const timeoutMs = tagged?.[REQUEST_TIMEOUT_MARKER];
   if (typeof timeoutMs === "number") {
     return {
-      message: `Request to ${targetLabel2} timed out after ${timeoutMs}ms while waiting for a response.`,
+      message: `Request to ${targetLabel} timed out after ${timeoutMs}ms while waiting for a response.`,
       code: "NETWORK_TIMEOUT",
-      details: { timeoutMs, target: targetLabel2 }
+      details: { timeoutMs, target: targetLabel }
     };
   }
   if (tagged?.[REQUEST_ABORT_MARKER]) {
     return {
-      message: `Request to ${targetLabel2} was aborted before it completed.`,
+      message: `Request to ${targetLabel} was aborted before it completed.`,
       code: "NETWORK_ABORTED"
     };
   }
@@ -4878,30 +4878,6 @@ var DEFAULT_PRODUCT_NOTIFICATION_DELIVERY_TIMING = {
   windowMs: 36e5
 };
 
-// src/stream-reconnect.ts
-var STREAM_RECONNECT_BASE_DELAY_MS = 500;
-var STREAM_RECONNECT_MAX_DELAY_MS = 15e3;
-var STREAM_HEALTHY_CONNECTION_MS = 3e4;
-function streamReconnectDelayMs(attempt) {
-  const cappedExponentialMs = Math.min(
-    STREAM_RECONNECT_MAX_DELAY_MS,
-    STREAM_RECONNECT_BASE_DELAY_MS * 2 ** Math.max(0, attempt)
-  );
-  return Math.max(1, Math.floor(Math.random() * (cappedExponentialMs + 1)));
-}
-function isTransientPlayStreamError(error) {
-  if (error instanceof DeeplineError && error.code === "PLAY_STREAM_NETWORK_ABORTED") {
-    return true;
-  }
-  if (error instanceof DeeplineError && typeof error.statusCode === "number") {
-    return error.statusCode >= 500 && error.statusCode < 600;
-  }
-  const text = error instanceof Error ? error.message : String(error);
-  return /auth validation backend timed out|coordinator \/submit(?:\?[^ ]*)? 5\d\d|Worker threw exception|Internal Server Error|Service Unavailable|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
-    text
-  );
-}
-
 // ../play-runtime/live-events.ts
 function resolveTimingWindow(input2) {
   const startedAt = typeof input2.startedAt === "number" && Number.isFinite(input2.startedAt) ? input2.startedAt : null;
@@ -4917,19 +4893,6 @@ function resolveTimingWindow(input2) {
 // ../play-runtime/run-failure.ts
 var PUBLIC_FAILURE_TEXT_BYTE_LIMIT = 64 * 1024;
 
-// ../play-runtime/run-terminal-source.ts
-var PLAY_RUN_LEDGER_EVENT_SOURCES = [
-  "worker",
-  "convex",
-  "coordinator",
-  "system"
-];
-function normalizePlayRunLedgerTerminalSource(value) {
-  return PLAY_RUN_LEDGER_EVENT_SOURCES.includes(
-    value
-  ) ? value : null;
-}
-
 // ../play-runtime/run-log-buffer.ts
 var RUNNER_LOG_MAX_BYTES = 5 * 1024 * 1024;
 var TERMINAL_RESERVE_BYTES = 64 * 1024;
@@ -5100,12 +5063,12 @@ function createSecretRedactionContext(initialValues = []) {
     }
     return output2;
   }
-  function redactString2(value) {
+  function redactString(value) {
     const output2 = redactRegisteredSecrets(value);
     return redactSecretLikeString(output2);
   }
   function redact(value) {
-    if (typeof value === "string") return redactString2(value);
+    if (typeof value === "string") return redactString(value);
     if (Array.isArray(value)) {
       let changed = false;
       const next = new Array(value.length);
@@ -5138,7 +5101,7 @@ function createSecretRedactionContext(initialValues = []) {
     return value;
   }
   function redactKnownSecrets(value) {
-    if (typeof value === "string") return redactString2(value);
+    if (typeof value === "string") return redactString(value);
     if (Array.isArray(value)) {
       return value.map((entry) => redactKnownSecrets(entry));
     }
@@ -5157,7 +5120,7 @@ function createSecretRedactionContext(initialValues = []) {
     containsRegisteredSecret,
     matchesRegisteredSecret,
     redactRegisteredSecrets,
-    redactString: redactString2,
+    redactString,
     redactKnownSecrets,
     redact
   };
@@ -5181,981 +5144,8 @@ var JSON_SIZE_LIMIT_REACHED = Symbol("JSON_SIZE_LIMIT_REACHED");
 var ledgerIngressRedactor = createSecretRedactionContext();
 
 // ../play-runtime/docflow-node-io.ts
-var DOCFLOW_NODE_IO_LIMITS = {
-  maxPaths: 16,
-  maxDepth: 3,
-  maxObjectFields: 12,
-  maxArrayItems: 3,
-  maxStringBytes: 256,
-  maxPhaseBytes: 2e3,
-  maxErrorBytes: 512
-};
 var utf8Encoder = new TextEncoder();
 var PLAY_DATASET_BRAND = Symbol.for("deepline.play.dataset");
-var MAX_CONVEX_PREVIEW_KEY_LENGTH = 1024;
-function ledgerSafeDocflowPreviewKey(key) {
-  const source = key.startsWith("$") ? key.replace(/^\$+/, "") || "output" : key || "output";
-  let encoded = "";
-  for (const character of source) {
-    const code = character.charCodeAt(0);
-    if (code >= 32 && code < 127) {
-      encoded += character;
-      continue;
-    }
-    for (const byte of utf8Encoder.encode(character)) {
-      encoded += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
-    }
-  }
-  if (encoded.length <= MAX_CONVEX_PREVIEW_KEY_LENGTH) return encoded;
-  let hashA = 2166136261;
-  let hashB = 2654435769;
-  for (let index = 0; index < encoded.length; index += 1) {
-    const code = encoded.charCodeAt(index);
-    hashA = Math.imul(hashA ^ code, 16777619);
-    hashB = Math.imul(hashB ^ code, 16777619);
-  }
-  const suffix = `~${(hashA >>> 0).toString(16).padStart(8, "0")}${(hashB >>> 0).toString(16).padStart(8, "0")}`;
-  return `${encoded.slice(0, MAX_CONVEX_PREVIEW_KEY_LENGTH - suffix.length)}${suffix}`;
-}
-function utf8Bytes(value) {
-  return utf8Encoder.encode(value).byteLength;
-}
-function truncateUtf8(value, maxBytes) {
-  if (utf8Bytes(value) <= maxBytes) return value;
-  let output2 = "";
-  for (const character of value) {
-    if (utf8Bytes(`${output2}${character}\u2026`) > maxBytes) break;
-    output2 += character;
-  }
-  return `${output2}\u2026`;
-}
-function redactString(redactor, value, key) {
-  if (!key) return redactor.redactString(value);
-  const wrapped = redactor.redact({ [key]: value });
-  return typeof wrapped[key] === "string" ? wrapped[key] : redactor.redactString(value);
-}
-function safeString(value, redactor, key) {
-  if (typeof value !== "string") return void 0;
-  return truncateUtf8(
-    redactString(redactor, value, key),
-    DOCFLOW_NODE_IO_LIMITS.maxStringBytes
-  );
-}
-function previewValue(value, input2) {
-  if (value === null) return { kind: "null" };
-  if (value === void 0) return { kind: "unavailable", reason: "undefined" };
-  if (typeof value === "string") {
-    return {
-      kind: "scalar",
-      value: safeString(value, input2.redactor, input2.key) ?? ""
-    };
-  }
-  if (typeof value === "number") {
-    return Number.isFinite(value) ? { kind: "scalar", value } : { kind: "unavailable", reason: "unsupported" };
-  }
-  if (typeof value === "boolean") return { kind: "scalar", value };
-  if (typeof value === "bigint") {
-    return { kind: "unavailable", reason: "bigint" };
-  }
-  if (typeof value === "function") {
-    return { kind: "unavailable", reason: "function" };
-  }
-  if (typeof value === "symbol") {
-    return { kind: "unavailable", reason: "symbol" };
-  }
-  if (typeof value !== "object") {
-    return { kind: "unavailable", reason: "unsupported" };
-  }
-  try {
-    const brand = readDataProperty(value, PLAY_DATASET_BRAND);
-    const datasetKind = readDataProperty(value, "datasetKind");
-    const datasetId = readDataProperty(value, "datasetId");
-    const tableNamespace = readDataProperty(value, "tableNamespace");
-    if (brand.ok && brand.value === true && datasetKind.ok && (datasetKind.value === "csv" || datasetKind.value === "map") && datasetId.ok && typeof datasetId.value === "string") {
-      return {
-        kind: "dataset",
-        datasetId: safeString(datasetId.value, input2.redactor, "datasetId") ?? "dataset",
-        datasetKind: datasetKind.value,
-        tableNamespace: tableNamespace.ok && tableNamespace.value === null ? null : tableNamespace.ok ? safeString(
-          tableNamespace.value,
-          input2.redactor,
-          "tableNamespace"
-        ) : void 0
-      };
-    }
-    const kind = readDataProperty(value, "kind");
-    const count = readDataProperty(value, "count");
-    const preview = readDataProperty(value, "preview");
-    if (kind.ok && kind.value === "dataset" && datasetKind.ok && (datasetKind.value === "csv" || datasetKind.value === "map") && datasetId.ok && typeof datasetId.value === "string" && count.ok && typeof count.value === "number" && preview.ok && Array.isArray(preview.value)) {
-      return {
-        kind: "dataset",
-        datasetId: safeString(datasetId.value, input2.redactor, "datasetId") ?? "dataset",
-        datasetKind: datasetKind.value,
-        tableNamespace: tableNamespace.ok && tableNamespace.value === null ? null : tableNamespace.ok ? safeString(
-          tableNamespace.value,
-          input2.redactor,
-          "tableNamespace"
-        ) : void 0,
-        rowCount: Math.max(0, Math.floor(count.value))
-      };
-    }
-  } catch {
-    return { kind: "unavailable", reason: "access_error" };
-  }
-  if (input2.ancestors.has(value)) {
-    return { kind: "unavailable", reason: "cycle" };
-  }
-  if (input2.depth >= DOCFLOW_NODE_IO_LIMITS.maxDepth) {
-    return { kind: "unavailable", reason: "depth" };
-  }
-  input2.ancestors.add(value);
-  try {
-    if (Array.isArray(value)) {
-      const items = [];
-      for (let index = 0; index < Math.min(value.length, DOCFLOW_NODE_IO_LIMITS.maxArrayItems); index += 1) {
-        const descriptor = Object.getOwnPropertyDescriptor(
-          value,
-          String(index)
-        );
-        items.push(
-          descriptor && "value" in descriptor ? previewValue(descriptor.value, {
-            ...input2,
-            depth: input2.depth + 1
-          }) : { kind: "unavailable", reason: "access_error" }
-        );
-      }
-      return {
-        kind: "array",
-        items,
-        totalItems: value.length,
-        ...value.length > items.length ? { truncated: true } : {}
-      };
-    }
-    let descriptors;
-    try {
-      descriptors = Object.getOwnPropertyDescriptors(value);
-    } catch {
-      return { kind: "unavailable", reason: "access_error" };
-    }
-    const entries = Object.entries(descriptors).filter(
-      ([, descriptor]) => descriptor.enumerable
-    );
-    const selected = entries.slice(0, DOCFLOW_NODE_IO_LIMITS.maxObjectFields);
-    const fields2 = {};
-    for (const [key, descriptor] of selected) {
-      const safeKey = truncateUtf8(
-        ledgerSafeDocflowPreviewKey(input2.redactor.redactString(key)),
-        DOCFLOW_NODE_IO_LIMITS.maxStringBytes
-      );
-      fields2[safeKey] = "value" in descriptor ? previewValue(descriptor.value, {
-        ...input2,
-        depth: input2.depth + 1,
-        key
-      }) : { kind: "unavailable", reason: "access_error" };
-    }
-    return {
-      kind: "object",
-      fields: fields2,
-      totalFields: entries.length,
-      ...entries.length > selected.length ? { truncated: true } : {}
-    };
-  } catch {
-    return { kind: "unavailable", reason: "access_error" };
-  } finally {
-    input2.ancestors.delete(value);
-  }
-}
-function readDataProperty(value, property) {
-  if ((typeof value !== "object" || value === null) && typeof value !== "function") {
-    return { ok: false };
-  }
-  try {
-    let owner = value;
-    while (owner) {
-      const descriptor = Object.getOwnPropertyDescriptor(owner, property);
-      if (descriptor) {
-        return "value" in descriptor ? { ok: true, value: descriptor.value } : { ok: false };
-      }
-      owner = Object.getPrototypeOf(owner);
-    }
-  } catch {
-    return { ok: false };
-  }
-  return { ok: false };
-}
-function buildPlayDocflowNodeErrorPreview(error, redactor = createSecretRedactionContext()) {
-  try {
-    const message = error instanceof Error ? error.message : String(error);
-    return truncateUtf8(
-      redactor.redactString(message),
-      DOCFLOW_NODE_IO_LIMITS.maxErrorBytes
-    );
-  } catch {
-    return "Non-Error value thrown (message unavailable)";
-  }
-}
-function isRecord4(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function normalizePreview(value, depth) {
-  if (!isRecord4(value) || typeof value.kind !== "string") return null;
-  if (value.kind === "null") return { kind: "null" };
-  if (value.kind === "scalar") {
-    if (typeof value.value === "string" || typeof value.value === "boolean" || typeof value.value === "number" && Number.isFinite(value.value)) {
-      return previewValue(value.value, {
-        depth: 0,
-        ancestors: /* @__PURE__ */ new WeakSet(),
-        redactor: createSecretRedactionContext()
-      });
-    }
-    return null;
-  }
-  if (value.kind === "unavailable") {
-    const reason = value.reason;
-    return typeof reason === "string" && [
-      "undefined",
-      "function",
-      "symbol",
-      "bigint",
-      "cycle",
-      "depth",
-      "access_error",
-      "limit",
-      "unsupported"
-    ].includes(reason) ? {
-      kind: "unavailable",
-      reason
-    } : null;
-  }
-  if (value.kind === "dataset") {
-    const datasetId = safeString(
-      value.datasetId,
-      createSecretRedactionContext(),
-      "datasetId"
-    );
-    if (!datasetId || value.datasetKind !== "csv" && value.datasetKind !== "map") {
-      return null;
-    }
-    return {
-      kind: "dataset",
-      datasetId,
-      datasetKind: value.datasetKind,
-      ...value.tableNamespace === null ? { tableNamespace: null } : typeof value.tableNamespace === "string" ? {
-        tableNamespace: safeString(
-          value.tableNamespace,
-          createSecretRedactionContext(),
-          "tableNamespace"
-        )
-      } : {},
-      ...typeof value.rowCount === "number" && Number.isFinite(value.rowCount) ? { rowCount: Math.max(0, Math.floor(value.rowCount)) } : {}
-    };
-  }
-  if (depth >= DOCFLOW_NODE_IO_LIMITS.maxDepth) {
-    return { kind: "unavailable", reason: "depth" };
-  }
-  if (value.kind === "array" && Array.isArray(value.items)) {
-    const items = value.items.slice(0, DOCFLOW_NODE_IO_LIMITS.maxArrayItems).map((item) => normalizePreview(item, depth + 1)).filter((item) => item !== null);
-    const totalItems = typeof value.totalItems === "number" && Number.isFinite(value.totalItems) ? Math.max(items.length, Math.floor(value.totalItems)) : items.length;
-    return {
-      kind: "array",
-      items,
-      totalItems,
-      ...value.truncated === true || totalItems > items.length ? { truncated: true } : {}
-    };
-  }
-  if (value.kind === "object" && isRecord4(value.fields)) {
-    const fields2 = {};
-    for (const [key, field] of Object.entries(value.fields).slice(
-      0,
-      DOCFLOW_NODE_IO_LIMITS.maxObjectFields
-    )) {
-      const normalized = normalizePreview(field, depth + 1);
-      if (normalized) fields2[ledgerSafeDocflowPreviewKey(key)] = normalized;
-    }
-    const totalFields = typeof value.totalFields === "number" && Number.isFinite(value.totalFields) ? Math.max(Object.keys(fields2).length, Math.floor(value.totalFields)) : Object.keys(fields2).length;
-    return {
-      kind: "object",
-      fields: fields2,
-      totalFields,
-      ...value.truncated === true || totalFields > Object.keys(fields2).length ? { truncated: true } : {}
-    };
-  }
-  return null;
-}
-function normalizePlayDocflowNodeIoState(value) {
-  if (!isRecord4(value)) return void 0;
-  const attempt = typeof value.attempt === "number" && Number.isFinite(value.attempt) ? Math.max(0, Math.floor(value.attempt)) : 0;
-  const normalizeMap = (raw) => {
-    if (!isRecord4(raw)) return void 0;
-    const output2 = {};
-    for (const [path, preview] of Object.entries(raw).slice(
-      0,
-      DOCFLOW_NODE_IO_LIMITS.maxPaths
-    )) {
-      const normalized = normalizePreview(preview, 0);
-      if (!normalized) continue;
-      const safePath = ledgerSafeDocflowPreviewKey(path);
-      const candidate = { ...output2, [safePath]: normalized };
-      if (utf8Bytes(JSON.stringify(candidate)) > DOCFLOW_NODE_IO_LIMITS.maxPhaseBytes) {
-        break;
-      }
-      output2[safePath] = normalized;
-    }
-    return output2;
-  };
-  const inputs = normalizeMap(value.inputs);
-  const outputs = normalizeMap(value.outputs);
-  const error = typeof value.error === "string" ? buildPlayDocflowNodeErrorPreview(value.error) : value.error === null ? null : void 0;
-  return {
-    attempt,
-    ...typeof value.invocationId === "string" && value.invocationId.trim() ? {
-      invocationId: truncateUtf8(
-        value.invocationId.trim(),
-        DOCFLOW_NODE_IO_LIMITS.maxStringBytes
-      )
-    } : {},
-    ...inputs ? { inputs } : {},
-    ...outputs ? { outputs } : {},
-    ...value.inputsTruncated === true ? { inputsTruncated: true } : {},
-    ...value.outputsTruncated === true ? { outputsTruncated: true } : {},
-    ...error !== void 0 ? { error } : {}
-  };
-}
-
-// ../play-runtime/activity-observation.ts
-function isRecord5(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function isPlayActivityObservation(value) {
-  if (!isRecord5(value) || value.schemaVersion !== void 0 && value.schemaVersion !== 1 || typeof value.activityId !== "string" || !value.activityId.trim() || typeof value.observedAt !== "number" || !Number.isFinite(value.observedAt) || !isRecord5(value.target) || !isRecord5(value.state)) {
-    return false;
-  }
-  const targetKinds = /* @__PURE__ */ new Set([
-    "provider",
-    "dataset",
-    "lease",
-    "runner",
-    "step",
-    "capacity"
-  ]);
-  const stateKinds = /* @__PURE__ */ new Set([
-    "active",
-    "queued",
-    "waiting",
-    "retrying",
-    "scheduled",
-    "completed",
-    "failed"
-  ]);
-  return typeof value.target.kind === "string" && targetKinds.has(value.target.kind) && typeof value.state.kind === "string" && stateKinds.has(value.state.kind);
-}
-function derivePlayActivityVisibility(input2) {
-  const { state } = input2.observation;
-  if (state.kind === "failed") return "action";
-  if (state.kind === "waiting") {
-    return state.reason.kind === "external_event" ? "action" : "headline";
-  }
-  if (state.kind === "queued" || state.kind === "scheduled") return "headline";
-  if (state.kind === "retrying") {
-    if (state.reason === "rate_limit" && input2.observation.target.kind === "capacity") {
-      return "headline";
-    }
-    if (state.retryAt - input2.now <= 3e4) return "hidden";
-    return state.reason === "rate_limit" ? "headline" : "timeline";
-  }
-  if (state.kind === "active") return "headline";
-  return "timeline";
-}
-function targetLabel(target) {
-  switch (target.kind) {
-    case "provider":
-      return target.label ?? `${target.provider} ${target.operation}`;
-    case "dataset":
-      return target.label ?? `dataset ${target.tableNamespace}`;
-    case "lease":
-      return `${target.resourceKind} ${target.resourceLabel}`;
-    case "runner":
-      return target.label ?? `${target.backend} runner`;
-    case "step":
-      return target.label ?? target.stepId;
-    case "capacity":
-      return target.label ?? `${target.pool} capacity`;
-  }
-}
-function summarizePlayActivity(observation) {
-  const label = targetLabel(observation.target);
-  const { state } = observation;
-  switch (state.kind) {
-    case "active": {
-      const progress = state.progress;
-      const counts = typeof progress?.completed === "number" && typeof progress.total === "number" ? ` (${progress.completed}/${progress.total})` : "";
-      return `Active: ${label}${counts}.`;
-    }
-    case "queued":
-      return `Queued: waiting for ${label}.`;
-    case "waiting":
-      if (state.reason.kind === "external_event") {
-        const provider = state.reason.provider ? ` from ${state.reason.provider}` : "";
-        return `Blocked: waiting for an external event${provider}.`;
-      }
-      if (state.reason.kind === "dataset") {
-        return `Blocked: waiting for dataset ${state.reason.tableNamespace} to become ${state.reason.requiredPhase}.`;
-      }
-      if (state.reason.kind === "lease") {
-        return `Contended: waiting for ${state.reason.resourceKind} lease ${state.reason.resourceLabel}.`;
-      }
-      return `Paused: ${label}; the legacy producer did not report a typed reason.`;
-    case "retrying":
-      if (state.reason === "rate_limit") {
-        return `Waiting for ${label} request capacity; the run will retry automatically.`;
-      }
-      return `Delayed: ${label} will retry automatically.`;
-    case "scheduled":
-      return `Scheduled: ${label} will resume automatically.`;
-    case "completed":
-      return `Completed: ${label}.`;
-    case "failed":
-      return `Failed: ${label}.`;
-  }
-}
-function isTerminalActivityState(state) {
-  return state.kind === "completed" || state.kind === "failed";
-}
-function projection(observation, now, classified = true) {
-  return {
-    observation,
-    summary: summarizePlayActivity(observation),
-    visibility: derivePlayActivityVisibility({ observation, now }),
-    classified
-  };
-}
-function projectPlayRunActivity(input2) {
-  const now = input2.now ?? Date.now();
-  const observedAt = input2.updatedAt ?? now;
-  const normalizedStatus = input2.status.trim().toLowerCase();
-  if (normalizedStatus === "completed" || normalizedStatus === "failed" || normalizedStatus === "cancelled" || normalizedStatus === "terminated" || normalizedStatus === "timed_out") {
-    return null;
-  }
-  const latestExplicit = [...input2.explicit ?? []].filter((candidate) => !isTerminalActivityState(candidate.state)).sort((left, right) => right.observedAt - left.observedAt)[0];
-  const explicit = latestExplicit?.target.kind === "capacity" && latestExplicit.target.pool === "provider" && latestExplicit.state.kind === "retrying" && latestExplicit.state.retryAt < now ? null : latestExplicit;
-  if (explicit) return projection(explicit, now);
-  if (input2.waitKind === "detached_runner") {
-    return projection(
-      {
-        activityId: "runner:managed",
-        target: {
-          kind: "runner",
-          backend: input2.runtimeBackend ?? "managed",
-          label: "managed play runner"
-        },
-        state: { kind: "active" },
-        observedAt
-      },
-      now
-    );
-  }
-  if (input2.waitKind === "sleep") {
-    return projection(
-      {
-        activityId: "run:sleep",
-        target: {
-          kind: "step",
-          stepId: input2.activeNodeId ?? "run",
-          label: input2.playName ?? "play"
-        },
-        state: {
-          kind: "scheduled",
-          reason: "sleep",
-          resumeAt: input2.waitUntil ?? observedAt
-        },
-        observedAt
-      },
-      now
-    );
-  }
-  if (input2.waitKind === "integration_event" || input2.waitKind === "integration_event_batch") {
-    return projection(
-      {
-        activityId: `event:${input2.activeNodeId ?? "run"}`,
-        stepId: input2.activeNodeId ?? void 0,
-        target: {
-          kind: "step",
-          stepId: input2.activeNodeId ?? "run",
-          label: input2.playName ?? "play"
-        },
-        state: {
-          kind: "waiting",
-          reason: {
-            kind: "external_event",
-            eventKey: input2.eventKey ?? void 0,
-            deadlineAt: input2.waitUntil ?? void 0
-          }
-        },
-        observedAt
-      },
-      now
-    );
-  }
-  if (normalizedStatus === "waiting") {
-    return projection(
-      {
-        activityId: "run:legacy-wait",
-        target: {
-          kind: "step",
-          stepId: input2.activeNodeId ?? "run",
-          label: input2.playName ?? "play"
-        },
-        state: { kind: "waiting", reason: { kind: "unknown" } },
-        observedAt
-      },
-      now,
-      false
-    );
-  }
-  const pendingDataset = [...input2.datasets ?? []].filter(
-    (dataset) => dataset.phase === "registered" || dataset.complete !== true && dataset.phase !== "failed"
-  ).sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
-  if (pendingDataset) {
-    const activeDatasetStep = input2.nodeStates?.find(
-      (candidate) => candidate.nodeId === input2.activeNodeId && candidate.status === "running" && candidate.artifactTableNamespace === pendingDataset.tableNamespace
-    );
-    const datasetStep = activeDatasetStep ?? input2.nodeStates?.find(
-      (candidate) => candidate.artifactTableNamespace === pendingDataset.tableNamespace
-    );
-    const datasetProgress = datasetStep?.progress ?? null;
-    return projection(
-      {
-        activityId: `dataset:${pendingDataset.datasetId ?? pendingDataset.tableNamespace}`,
-        target: {
-          kind: "dataset",
-          tableNamespace: pendingDataset.tableNamespace,
-          operation: "materializing"
-        },
-        state: {
-          kind: "active",
-          progress: {
-            completed: datasetProgress?.completed ?? pendingDataset.persistedRows,
-            total: datasetProgress?.total ?? (typeof pendingDataset.succeededRows === "number" || typeof pendingDataset.failedRows === "number" ? (pendingDataset.succeededRows ?? 0) + (pendingDataset.failedRows ?? 0) : void 0),
-            failed: datasetProgress?.failed ?? pendingDataset.failedRows
-          }
-        },
-        observedAt: datasetStep?.updatedAt ?? pendingDataset.updatedAt ?? observedAt
-      },
-      now
-    );
-  }
-  const activeStep = input2.nodeStates?.find(
-    (candidate) => candidate.nodeId === input2.activeNodeId
-  ) ?? input2.nodeStates?.find((candidate) => candidate.status === "running") ?? null;
-  if (activeStep) {
-    const toolId = activeStep.nodeId.startsWith("tool:") ? activeStep.nodeId.split(":").at(-1)?.trim() || null : null;
-    const provider = toolId?.split(/[._]/)[0]?.trim() || null;
-    return projection(
-      {
-        activityId: `step:${activeStep.nodeId}`,
-        stepId: activeStep.nodeId,
-        target: toolId && provider ? {
-          kind: "provider",
-          provider,
-          operation: toolId,
-          label: activeStep.label ?? toolId
-        } : {
-          kind: "step",
-          stepId: activeStep.nodeId,
-          label: activeStep.label
-        },
-        state: {
-          kind: "active",
-          progress: activeStep.progress ?? void 0
-        },
-        observedAt: activeStep.updatedAt ?? observedAt
-      },
-      now
-    );
-  }
-  if (normalizedStatus === "queued") {
-    return projection(
-      {
-        activityId: "capacity:worker",
-        target: { kind: "capacity", pool: "worker" },
-        state: { kind: "queued", reason: "capacity" },
-        observedAt
-      },
-      now
-    );
-  }
-  const fallback = {
-    activityId: "run:legacy",
-    target: {
-      kind: "step",
-      stepId: input2.activeNodeId ?? "run",
-      label: input2.playName ?? "play"
-    },
-    state: normalizedStatus === "waiting" ? { kind: "waiting", reason: { kind: "unknown" } } : { kind: "active" },
-    observedAt
-  };
-  return projection(fallback, now, normalizedStatus !== "waiting");
-}
-
-// ../play-runtime/cell-provenance.ts
-function finiteNonNegativeInteger2(value) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    return null;
-  }
-  return Math.trunc(value);
-}
-function nonEmptyString(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed ? trimmed : null;
-}
-function normalizeDatasetBornFrom(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const record3 = value;
-  const table = nonEmptyString(record3.table);
-  const rowCountIn = finiteNonNegativeInteger2(record3.rowCountIn);
-  if (!table || rowCountIn === null) return null;
-  return { table, rowCountIn };
-}
-
-// ../play-runtime/run-ledger.ts
-var LOG_TAIL_LIMIT = 100;
-var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-  "completed",
-  "failed",
-  "cancelled",
-  "terminated",
-  "timed_out"
-]);
-function isRecord6(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function finiteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function nonnegativeSafeInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function isWorkCounterSegmentId(value) {
-  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
-    value
-  );
-}
-function normalizePlayRunLedgerTerminalWorkCounterSegment(value) {
-  if (!isRecord6(value)) return void 0;
-  if (!nonnegativeSafeInteger(value.attempt) || !nonnegativeSafeInteger(value.invocationSeq) || value.invocationSeq === 0 || !isWorkCounterSegmentId(value.segmentId)) {
-    return void 0;
-  }
-  return {
-    attempt: value.attempt,
-    invocationSeq: value.invocationSeq,
-    segmentId: value.segmentId
-  };
-}
-function hasConfirmedPlayRunLedgerWorkCounters(snapshot) {
-  const counters = snapshot.workCounters;
-  const terminal = snapshot.terminalWorkCounterSegment;
-  return Boolean(
-    isTerminalPlayRunLedgerStatus(snapshot.status) && (snapshot.terminalSource === "worker" || snapshot.terminalSource === "system") && counters?.final && counters.completeThroughAttempt && counters.consistent && terminal && counters.attempt === terminal.attempt && counters.invocationSeq === terminal.invocationSeq && counters.segmentId === terminal.segmentId && Number.isSafeInteger(
-      counters.completedLogicalCalls + counters.logicalCalls
-    ) && Number.isSafeInteger(
-      counters.completedProviderRequests + counters.providerRequests
-    ) && Number.isSafeInteger(
-      counters.completedProvider429s + counters.provider429s
-    )
-  );
-}
-function normalizeWorkCounters(value) {
-  if (!isRecord6(value)) return void 0;
-  for (const field of [
-    "attempt",
-    "invocationSeq",
-    "logicalCalls",
-    "providerRequests",
-    "provider429s",
-    "completedLogicalCalls",
-    "completedProviderRequests",
-    "completedProvider429s"
-  ]) {
-    if (!nonnegativeSafeInteger(value[field])) return void 0;
-  }
-  if (value.invocationSeq === 0 || !isWorkCounterSegmentId(value.segmentId) || typeof value.final !== "boolean" || typeof value.completeThroughAttempt !== "boolean" || typeof value.consistent !== "boolean") {
-    return void 0;
-  }
-  return {
-    ...value,
-    attempt: value.attempt,
-    invocationSeq: value.invocationSeq,
-    segmentId: value.segmentId,
-    logicalCalls: value.logicalCalls,
-    providerRequests: value.providerRequests,
-    provider429s: value.provider429s,
-    final: value.final,
-    completedLogicalCalls: value.completedLogicalCalls,
-    completedProviderRequests: value.completedProviderRequests,
-    completedProvider429s: value.completedProvider429s,
-    completeThroughAttempt: value.completeThroughAttempt,
-    consistent: value.consistent
-  };
-}
-function optionalFiniteNumber(value) {
-  const normalized = finiteNumber(value);
-  return normalized === null ? void 0 : normalized;
-}
-function optionalString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function optionalNullableString(value) {
-  if (value === null) return null;
-  return optionalString(value);
-}
-function normalizePlayRunLedgerStatus(value) {
-  const normalized = String(value ?? "").trim().toLowerCase();
-  switch (normalized) {
-    case "queued":
-    case "pending":
-      return "queued";
-    case "running":
-    case "started":
-      return "running";
-    case "waiting":
-      return "waiting";
-    case "completed":
-    case "complete":
-    case "succeeded":
-      return "completed";
-    case "failed":
-    case "error":
-      return "failed";
-    case "cancelled":
-    case "canceled":
-      return "cancelled";
-    case "terminated":
-      return "terminated";
-    case "timed_out":
-    case "timeout":
-      return "timed_out";
-    default:
-      return "unknown";
-  }
-}
-function isTerminalPlayRunLedgerStatus(status) {
-  return TERMINAL_STATUSES.has(status);
-}
-function summarizeRunRowOutcomes(snapshot) {
-  let completedRows = 0;
-  let failedRows = 0;
-  let totalRows = 0;
-  let supersededRows = 0;
-  for (const step of Object.values(snapshot.stepsById)) {
-    const progress = step.progress;
-    if (!progress) continue;
-    completedRows += Math.max(0, finiteNumber(progress.completed) ?? 0);
-    failedRows += Math.max(0, finiteNumber(progress.failed) ?? 0);
-    supersededRows += Math.max(0, finiteNumber(progress.supersededRows) ?? 0);
-    const stepTotal = finiteNumber(progress.total);
-    totalRows += stepTotal !== null && stepTotal >= 0 ? stepTotal : Math.max(0, finiteNumber(progress.completed) ?? 0) + Math.max(0, finiteNumber(progress.failed) ?? 0) + Math.max(0, finiteNumber(progress.supersededRows) ?? 0);
-  }
-  const resultSummary = isRecord6(snapshot.resultSummary) ? snapshot.resultSummary : null;
-  const resultRowOutcomes = isRecord6(resultSummary?.rowOutcomes) ? resultSummary.rowOutcomes : null;
-  const terminalCompletedRows = finiteNumber(resultRowOutcomes?.completedRows);
-  const terminalFailedRows = finiteNumber(resultRowOutcomes?.failedRows);
-  const terminalTotalRows = finiteNumber(resultRowOutcomes?.totalRows);
-  const terminalSupersededRows = finiteNumber(
-    resultRowOutcomes?.supersededRows
-  );
-  const settledCompletedRows = terminalCompletedRows ?? completedRows;
-  const settledFailedRows = terminalFailedRows ?? failedRows;
-  return {
-    completedRows: settledCompletedRows,
-    failedRows: settledFailedRows,
-    totalRows: terminalTotalRows ?? totalRows,
-    hasRowFailures: settledFailedRows > 0,
-    ...(terminalSupersededRows ?? supersededRows) > 0 ? { supersededRows: terminalSupersededRows ?? supersededRows } : {}
-  };
-}
-function createEmptyPlayRunLedgerSnapshot(input2) {
-  const status = normalizePlayRunLedgerStatus(input2.status ?? "unknown");
-  const startedAt = finiteNumber(input2.startedAt) ?? null;
-  const finishedAt = finiteNumber(input2.finishedAt) ?? null;
-  return {
-    runId: input2.runId,
-    playName: input2.playName ?? null,
-    status,
-    waitKind: null,
-    waitUntil: null,
-    error: optionalNullableString(input2.error) ?? null,
-    createdAt: finiteNumber(input2.createdAt) ?? null,
-    startedAt,
-    updatedAt: finiteNumber(input2.updatedAt) ?? finishedAt ?? startedAt ?? finiteNumber(input2.createdAt) ?? null,
-    finishedAt,
-    durationMs: startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : null,
-    orderedStepIds: [],
-    stepsById: {},
-    orderedDatasetIds: [],
-    datasetsById: {},
-    orderedActivityIds: [],
-    activitiesById: {},
-    logTail: [],
-    totalLogCount: 0,
-    logsTruncated: false,
-    activeStepId: null,
-    activeActivityId: null,
-    activeArtifactTableNamespace: null,
-    resultTableNamespace: null
-  };
-}
-function normalizePlayRunLedgerSnapshot(value, fallback) {
-  if (!isRecord6(value)) {
-    return createEmptyPlayRunLedgerSnapshot(fallback);
-  }
-  const orderedStepIds = Array.isArray(value.orderedStepIds) ? value.orderedStepIds.filter(
-    (entry) => typeof entry === "string" && Boolean(entry.trim())
-  ) : [];
-  const rawSteps = isRecord6(value.stepsById) ? value.stepsById : {};
-  const stepsById = {};
-  for (const [stepId, rawStep] of Object.entries(rawSteps)) {
-    if (!stepId.trim() || !isRecord6(rawStep)) continue;
-    const rawStatus = normalizeStepStatus(rawStep.status);
-    if (!rawStatus) continue;
-    const completedAt = finiteNumber(rawStep.completedAt);
-    const status = rawStatus === "running" && completedAt !== null ? "completed" : rawStatus;
-    const rawProgress = isRecord6(rawStep.progress) ? rawStep.progress : null;
-    stepsById[stepId] = {
-      stepId,
-      label: optionalString(rawStep.label),
-      kind: optionalString(rawStep.kind),
-      status,
-      error: optionalNullableString(rawStep.error),
-      artifactTableNamespace: optionalNullableString(
-        rawStep.artifactTableNamespace
-      ),
-      startedAt: finiteNumber(rawStep.startedAt),
-      completedAt,
-      updatedAt: finiteNumber(rawStep.updatedAt),
-      progress: rawProgress ? normalizeStepProgress(rawProgress) : null
-    };
-  }
-  const rawDatasets = isRecord6(value.datasetsById) ? value.datasetsById : {};
-  const datasetsById = {};
-  for (const [datasetId, rawDataset] of Object.entries(rawDatasets)) {
-    if (!datasetId.trim() || !isRecord6(rawDataset)) continue;
-    const phase = rawDataset.phase === "available" || rawDataset.phase === "failed" ? rawDataset.phase : "registered";
-    const datasetBornFrom = normalizeDatasetBornFrom(rawDataset.bornFrom);
-    datasetsById[datasetId] = {
-      datasetId,
-      path: optionalString(rawDataset.path) ?? `datasets.${datasetId}`,
-      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.
-      ...datasetBornFrom ? { bornFrom: datasetBornFrom } : {},
-      updatedAt: finiteNumber(rawDataset.updatedAt) ?? 0
-    };
-  }
-  const rawActivities = isRecord6(value.activitiesById) ? value.activitiesById : {};
-  const activitiesById = {};
-  for (const [activityId, rawActivity] of Object.entries(rawActivities)) {
-    if (activityId.trim() && isPlayActivityObservation(rawActivity) && rawActivity.activityId === activityId) {
-      activitiesById[activityId] = rawActivity;
-    }
-  }
-  const createdAt = finiteNumber(value.createdAt) ?? fallback.createdAt ?? null;
-  const startedAt = finiteNumber(value.startedAt) ?? fallback.startedAt ?? null;
-  const finishedAt = finiteNumber(value.finishedAt) ?? fallback.finishedAt ?? null;
-  const updatedAt = finiteNumber(value.updatedAt) ?? fallback.updatedAt ?? finishedAt ?? startedAt ?? createdAt ?? null;
-  const error = Object.prototype.hasOwnProperty.call(value, "error") ? optionalNullableString(value.error) ?? null : fallback.error ?? null;
-  const rawTail = Array.isArray(value.logTail) ? value.logTail : value.logs;
-  const logTail = Array.isArray(rawTail) ? rawTail.filter((line) => typeof line === "string") : [];
-  const workCounters = normalizeWorkCounters(value.workCounters);
-  const terminalWorkCounterSegment = normalizePlayRunLedgerTerminalWorkCounterSegment(
-    value.terminalWorkCounterSegment
-  );
-  return {
-    runId: optionalString(value.runId) ?? fallback.runId,
-    playName: optionalNullableString(value.playName) ?? fallback.playName ?? null,
-    status: normalizePlayRunLedgerStatus(value.status ?? fallback.status),
-    waitKind: optionalNullableString(value.waitKind),
-    waitUntil: finiteNumber(value.waitUntil),
-    error,
-    createdAt,
-    startedAt,
-    updatedAt,
-    finishedAt,
-    durationMs: startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : finiteNumber(value.durationMs),
-    orderedStepIds: orderedStepIds.filter((stepId) => stepsById[stepId]),
-    stepsById,
-    orderedDatasetIds: (Array.isArray(value.orderedDatasetIds) ? value.orderedDatasetIds : Object.keys(datasetsById)).filter(
-      (datasetId) => typeof datasetId === "string" && Boolean(datasetsById[datasetId])
-    ),
-    datasetsById,
-    orderedActivityIds: (Array.isArray(value.orderedActivityIds) ? value.orderedActivityIds : Object.keys(activitiesById)).filter(
-      (activityId) => typeof activityId === "string" && Boolean(activitiesById[activityId])
-    ),
-    activitiesById,
-    ...workCounters ? { workCounters } : {},
-    ...terminalWorkCounterSegment ? { terminalWorkCounterSegment } : {},
-    logTail: logTail.slice(-LOG_TAIL_LIMIT),
-    // Snapshots persisted before totalLogCount existed only know the retained
-    // tail, so the best lower bound for the cumulative count is the tail size.
-    totalLogCount: Math.max(
-      finiteNumber(value.totalLogCount) ?? logTail.length,
-      logTail.length
-    ),
-    // A persisted snapshot carrying more lines than the tail keeps is
-    // truncated here, whatever the stored flag says. Reporting `false` while
-    // dropping lines is silent loss: a reader would take the tail for the
-    // whole log.
-    logsTruncated: value.logsTruncated === true || logTail.length > LOG_TAIL_LIMIT,
-    activeStepId: optionalNullableString(value.activeStepId),
-    activeActivityId: optionalNullableString(value.activeActivityId),
-    activeArtifactTableNamespace: optionalNullableString(
-      value.activeArtifactTableNamespace
-    ),
-    resultTableNamespace: optionalNullableString(value.resultTableNamespace),
-    resultSummary: value.resultSummary,
-    result: value.result,
-    terminalSource: normalizePlayRunLedgerTerminalSource(value.terminalSource)
-  };
-}
-function normalizeStepStatus(value) {
-  const normalized = String(value ?? "").trim().toLowerCase();
-  if (normalized === "running" || normalized === "completed" || normalized === "failed" || normalized === "skipped") {
-    return normalized;
-  }
-  return null;
-}
-function normalizeStepProgress(value) {
-  return {
-    ...optionalFiniteNumber(value.completed) !== void 0 ? { completed: optionalFiniteNumber(value.completed) } : {},
-    ...optionalFiniteNumber(value.total) !== void 0 ? { total: optionalFiniteNumber(value.total) } : {},
-    ...optionalFiniteNumber(value.failed) !== void 0 ? { failed: optionalFiniteNumber(value.failed) } : {},
-    ...optionalFiniteNumber(value.startedRows) !== void 0 ? { startedRows: optionalFiniteNumber(value.startedRows) } : {},
-    ...optionalFiniteNumber(value.activeRows) !== void 0 ? { activeRows: optionalFiniteNumber(value.activeRows) } : {},
-    ...optionalFiniteNumber(value.waitingRows) !== void 0 ? { waitingRows: optionalFiniteNumber(value.waitingRows) } : {},
-    ...optionalFiniteNumber(value.completedRows) !== void 0 ? { completedRows: optionalFiniteNumber(value.completedRows) } : {},
-    ...optionalFiniteNumber(value.supersededRows) !== void 0 ? { supersededRows: optionalFiniteNumber(value.supersededRows) } : {},
-    ...optionalString(value.message) ? { message: optionalString(value.message) } : {},
-    ...optionalNullableString(value.artifactTableNamespace) !== void 0 ? {
-      artifactTableNamespace: optionalNullableString(
-        value.artifactTableNamespace
-      )
-    } : {},
-    ...finiteNumber(value.startedAt) !== null ? { startedAt: finiteNumber(value.startedAt) } : {},
-    ...finiteNumber(value.completedAt) !== null ? { completedAt: finiteNumber(value.completedAt) } : {},
-    ...finiteNumber(value.updatedAt) !== null ? { updatedAt: finiteNumber(value.updatedAt) } : {},
-    ...normalizePlayDocflowNodeIoState(value.nodeIo) ? { nodeIo: normalizePlayDocflowNodeIoState(value.nodeIo) } : {}
-  };
-}
 
 // ../play-runtime/run-lifecycle-policy.ts
 var TERMINAL_PLAY_RUN_STATUSES = /* @__PURE__ */ new Set([
@@ -6271,9 +5261,6 @@ function readProvenanceTag(line) {
   const provenance = LOG_PROVENANCE_CLASSES.includes(candidate) ? candidate : null;
   return { provenance, line: line.slice(end + 1) };
 }
-function stripProvenanceTag(line) {
-  return readProvenanceTag(line).line;
-}
 function classifyLegacyLogLine(line) {
   const message = stripLeadingTimestamp(line);
   if (/recovered (?:from checkpoint|response from checkpoint)/i.test(message)) {
@@ -6346,143 +5333,9 @@ function stripLeadingTimestamp(line) {
 }
 
 // ../play-runtime/run-snapshot-stream.ts
-function normalizePlayRunLiveStatus(value) {
-  return normalizePlayRunLifecycleStatus(value);
-}
 function isTerminalPlayRunLiveStatus(status) {
   return isTerminalPlayRunLifecycleStatus(status);
 }
-function isRecord7(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function finiteNumber2(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function extractTerminalRunLogTail(result) {
-  if (!isRecord7(result) || !isRecord7(result._metadata)) {
-    return null;
-  }
-  const runLogTail = result._metadata.runLogTail;
-  if (!isRecord7(runLogTail) || !Array.isArray(runLogTail.tail)) {
-    return null;
-  }
-  const logTail = runLogTail.tail.filter(
-    (line) => typeof line === "string" && line.trim().length > 0
-  );
-  if (logTail.length === 0) {
-    return null;
-  }
-  const totalLogCount = Math.max(
-    finiteNumber2(runLogTail.totalLogCount) ?? logTail.length,
-    logTail.length
-  );
-  return {
-    logTail: logTail.slice(-LOG_TAIL_LIMIT),
-    totalLogCount
-  };
-}
-function buildSnapshotFromLedger(snapshot) {
-  const nodeStates = snapshot.orderedStepIds.map((stepId) => snapshot.stepsById[stepId]).filter((step) => Boolean(step)).map((step) => ({
-    nodeId: step.stepId,
-    status: step.status,
-    error: step.error ?? null,
-    artifactTableNamespace: step.artifactTableNamespace ?? null,
-    progress: step.progress ? {
-      completed: step.progress.completed,
-      total: step.progress.total,
-      failed: step.progress.failed,
-      startedRows: step.progress.startedRows,
-      activeRows: step.progress.activeRows,
-      waitingRows: step.progress.waitingRows,
-      completedRows: step.progress.completedRows,
-      supersededRows: step.progress.supersededRows,
-      message: step.progress.message,
-      artifactTableNamespace: step.progress.artifactTableNamespace ?? step.artifactTableNamespace ?? null,
-      startedAt: step.startedAt ?? null,
-      completedAt: step.completedAt ?? null,
-      updatedAt: step.progress.updatedAt ?? step.updatedAt ?? null,
-      nodeIo: step.progress.nodeIo
-    } : null,
-    startedAt: step.startedAt ?? null,
-    completedAt: step.completedAt ?? null,
-    updatedAt: step.updatedAt ?? null,
-    ...step.progress?.nodeIo ? { nodeIo: step.progress.nodeIo } : {}
-  }));
-  const liveStatus = normalizePlayRunLiveStatus(snapshot.status);
-  const terminalRowOutcomes = isTerminalPlayRunLiveStatus(liveStatus) ? summarizeRunRowOutcomes(snapshot) : null;
-  const rowOutcomes = terminalRowOutcomes && (Object.keys(snapshot.stepsById).length > 0 || terminalRowOutcomes.totalRows > 0 || (terminalRowOutcomes.supersededRows ?? 0) > 0) ? terminalRowOutcomes : null;
-  const workCounters = snapshot.workCounters;
-  const calls = workCounters ? {
-    logicalCalls: workCounters.completedLogicalCalls + workCounters.logicalCalls,
-    providerRequests: workCounters.completedProviderRequests + workCounters.providerRequests,
-    provider429s: workCounters.completedProvider429s + workCounters.provider429s,
-    confirmed: isTerminalPlayRunLiveStatus(liveStatus) && hasConfirmedPlayRunLedgerWorkCounters(snapshot)
-  } : null;
-  return {
-    runId: snapshot.runId,
-    status: liveStatus,
-    createdAt: snapshot.createdAt ?? null,
-    startedAt: snapshot.startedAt ?? null,
-    finishedAt: snapshot.finishedAt ?? null,
-    durationMs: snapshot.durationMs ?? null,
-    updatedAt: snapshot.updatedAt ?? snapshot.finishedAt ?? snapshot.startedAt ?? null,
-    // This snapshot is public SDK/API transport. Keep the historical plain
-    // timestamp-prefixed text while provenance remains runtime metadata.
-    logs: snapshot.logTail.map(stripProvenanceTag),
-    totalLogCount: snapshot.totalLogCount,
-    ...snapshot.logsTruncated ? { logsTruncated: true } : {},
-    activeArtifactTableNamespace: snapshot.activeArtifactTableNamespace ?? null,
-    resultTableNamespace: snapshot.resultTableNamespace ?? null,
-    datasets: snapshot.orderedDatasetIds.map((datasetId) => snapshot.datasetsById[datasetId]).filter(
-      (dataset) => Boolean(dataset)
-    ),
-    activities: snapshot.orderedActivityIds.map((activityId) => snapshot.activitiesById[activityId]).filter(
-      (activity) => Boolean(activity)
-    ),
-    activeActivity: snapshot.activeActivityId ? snapshot.activitiesById[snapshot.activeActivityId] ?? null : null,
-    nodeStates,
-    activeNodeId: snapshot.activeStepId ?? null,
-    ...rowOutcomes ? { rowOutcomes } : {},
-    ...calls && Object.values(calls).every(
-      (value) => typeof value === "boolean" || Number.isSafeInteger(value)
-    ) ? { calls } : {}
-  };
-}
-function buildPlayRunStatusSnapshot(input2) {
-  const ledgerSnapshot = normalizePlayRunLedgerSnapshot(input2.run.runSnapshot, {
-    runId: input2.run.workflowId,
-    playName: input2.run.name ?? null,
-    status: input2.run.status,
-    createdAt: input2.run.createdAt ?? null,
-    startedAt: input2.run.startedAt ?? null,
-    updatedAt: input2.run.updatedAt ?? null,
-    finishedAt: input2.run.finishedAt ?? null
-  });
-  const terminalRunLogTail = extractTerminalRunLogTail(input2.run.result);
-  const projectedSnapshot = terminalRunLogTail && terminalRunLogTail.totalLogCount > ledgerSnapshot.totalLogCount ? buildSnapshotFromLedger({
-    ...ledgerSnapshot,
-    logTail: terminalRunLogTail.logTail,
-    totalLogCount: terminalRunLogTail.totalLogCount
-  }) : buildSnapshotFromLedger(ledgerSnapshot);
-  const activity = projectPlayRunActivity({
-    runId: input2.run.workflowId,
-    playName: input2.run.name,
-    status: projectedSnapshot.status,
-    updatedAt: projectedSnapshot.updatedAt,
-    waitKind: input2.run.waitKind ?? input2.run.wait?.kind ?? null,
-    waitUntil: input2.run.waitUntil,
-    eventKey: input2.run.wait?.eventKey ?? null,
-    runtimeBackend: input2.run.runtimeBackend,
-    activeNodeId: input2.run.activeBoundaryId ?? projectedSnapshot.activeNodeId,
-    nodeStates: projectedSnapshot.nodeStates,
-    datasets: projectedSnapshot.datasets,
-    explicit: projectedSnapshot.activities
-  });
-  return {
-    ...projectedSnapshot,
-    activity
-  };
-}
 function makeRunStreamEvent(input2) {
   return {
     ...input2,
@@ -6565,7 +5418,7 @@ function diffLogLines(input2) {
   const missingCount = tailFirstSeq - 1 - input2.lastLogSeq;
   return {
     lines: [
-      `[stream] ${missingCount} log lines not retained in the live window; full logs via runs logs`,
+      `[watch] ${missingCount} log lines not retained in the live window; full logs via runs logs`,
       ...logs
     ],
     lastLogSeq: totalLogCount,
@@ -6711,310 +5564,156 @@ function diffPlayRunStreamEvents(input2) {
   return { events, next };
 }
 
-// src/runs/observe-transport.ts
-var RunObserveTransportUnavailableError = class extends Error {
-  constructor(message, reason) {
-    super(message);
-    this.reason = reason;
-    this.name = "RunObserveTransportUnavailableError";
+// src/stream-reconnect.ts
+function isTransientPlayRunReadError(error) {
+  if (error instanceof DeeplineError && error.code === "PLAY_STREAM_NETWORK_ABORTED") {
+    return true;
   }
-};
-var OBSERVE_BOOTSTRAP_TIMEOUT_MS = 1e4;
-var OBSERVE_RECONNECT_NOTICE_MS = 1e4;
-var OBSERVE_STALE_WARNING_MS = 12e4;
-var OBSERVE_WATCHDOG_TICK_MS = 5e3;
-var GRANT_REFRESH_MARGIN_MS = 5 * 6e4;
-var BACKFILL_PAGE_LIMIT = 1e3;
-var BACKFILL_MAX_PAGES = 30;
-var OBSERVER_SNAPSHOT_QUERY = "runObservers:getPlayRunSnapshotForObserver";
-var OBSERVER_LOG_PAGE_QUERY = "runObservers:getRunLogPageForObserver";
-function errorText(error) {
-  return error instanceof Error ? error.message : String(error);
+  if (error instanceof DeeplineError && typeof error.statusCode === "number") {
+    return error.statusCode >= 500 && error.statusCode < 600;
+  }
+  const text = error instanceof Error ? error.message : String(error);
+  return /auth validation backend timed out|coordinator \/submit(?:\?[^ ]*)? 5\d\d|Worker threw exception|Internal Server Error|Service Unavailable|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
+    text
+  );
 }
-async function mintRunObserveGrant(http, runId) {
-  let response;
-  try {
-    response = await http.post(
-      `/api/v2/runs/${encodeURIComponent(runId)}/observe-grant`,
-      {}
-    );
-  } catch (error) {
-    if (error instanceof DeeplineError) {
-      if (error.statusCode === 401 || error.statusCode === 403) {
-        throw error;
-      }
-      throw new RunObserveTransportUnavailableError(
-        `observe-grant endpoint unavailable (${error.statusCode ?? "network"}): ${error.message}`,
-        "grant_endpoint_unavailable"
-      );
-    }
-    throw new RunObserveTransportUnavailableError(
-      `observe-grant request failed: ${errorText(error)}`,
-      "grant_request_failed"
-    );
+
+// src/runs/watch-polling.ts
+var RUN_WATCH_POLL_INTERVAL_MS = 2e3;
+function waitForNextPoll(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.resolve(false);
   }
-  const grant = response;
-  if (!grant || typeof grant.convexUrl !== "string" || !grant.convexUrl.trim() || typeof grant.token !== "string" || !grant.token.trim() || typeof grant.expiresAt !== "number") {
-    throw new RunObserveTransportUnavailableError(
-      "observe-grant endpoint returned an invalid grant payload.",
-      "grant_payload_invalid"
-    );
+  return new Promise((resolve22) => {
+    const finish = (elapsed) => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      resolve22(elapsed);
+    };
+    const onAbort = () => finish(false);
+    const timeout = setTimeout(() => finish(true), ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function readSnapshotResponse(response, runId) {
+  if (!response || typeof response !== "object" || Array.isArray(response)) {
+    throw new Error("Run watch returned an invalid snapshot response.");
+  }
+  const record3 = response;
+  const snapshot = record3.snapshot;
+  if (record3.runId !== runId || !snapshot || typeof snapshot !== "object" || Array.isArray(snapshot) || snapshot.runId !== runId || typeof snapshot.status !== "string" || !Array.isArray(snapshot.logs) || !snapshot.logs.every(
+    (line) => typeof line === "string"
+  ) || typeof snapshot.totalLogCount !== "number" || !Array.isArray(snapshot.nodeStates)) {
+    throw new Error(`Run watch returned an invalid snapshot for ${runId}.`);
   }
-  return grant;
+  return { runId, snapshot };
 }
-async function backfillLogGap(input2) {
+async function backfillRotatedLogTail(input2) {
+  if (!input2.previous.runSignature) {
+    return input2.snapshot;
+  }
+  const gap = resolvePlayRunLogGap(input2.snapshot, input2.previous.lastLogSeq);
+  if (!gap) {
+    return input2.snapshot;
+  }
   const lines = [];
-  let cursor = input2.lastLogSeq;
-  for (let page = 0; page < BACKFILL_MAX_PAGES; page += 1) {
-    if (cursor >= input2.tailFirstSeq - 1) {
-      break;
-    }
-    let logPage;
-    try {
-      logPage = await input2.queryLogPage(
-        cursor,
-        Math.min(BACKFILL_PAGE_LIMIT, input2.tailFirstSeq - 1 - cursor)
-      );
-    } catch {
-      return null;
-    }
-    const entries = (logPage?.entries ?? []).filter(
-      (entry) => entry.seq > cursor && entry.seq < input2.tailFirstSeq
+  let cursor = input2.previous.lastLogSeq;
+  const targetSeq = gap.tailFirstSeq - 1;
+  while (cursor < targetSeq) {
+    const limit = Math.min(1e3, targetSeq - cursor);
+    const page = await input2.http.get(
+      `/api/v2/runs/${encodeURIComponent(input2.runId)}/logs?afterSeq=${cursor}&limit=${limit}`,
+      { signal: input2.signal }
     );
-    if (entries.length === 0) {
-      break;
+    if (!page || !Array.isArray(page.entries) || page.entries.length === 0) {
+      return input2.snapshot;
     }
-    for (const entry of entries) {
-      if (entry.seq !== cursor + 1) {
-        return null;
+    for (const entry of page.entries) {
+      if (!entry || entry.seq !== cursor + 1 || typeof entry.line !== "string") {
+        return input2.snapshot;
       }
       lines.push(entry.line);
       cursor = entry.seq;
     }
   }
-  if (cursor < input2.tailFirstSeq - 1) {
-    return null;
+  if (cursor !== targetSeq) {
+    return input2.snapshot;
   }
-  return lines;
+  return { ...input2.snapshot, logs: [...lines, ...input2.snapshot.logs] };
 }
-async function* observeRunEvents(options) {
-  const { http, runId } = options;
-  let grant = await mintRunObserveGrant(http, runId);
-  let convexBrowser;
-  let convexServer;
-  try {
-    convexBrowser = await import("convex/browser");
-    convexServer = await import("convex/server");
-  } catch (error) {
-    throw new RunObserveTransportUnavailableError(
-      `convex client module unavailable: ${errorText(error)}`,
-      "convex_module_unavailable"
-    );
-  }
-  let webSocketConstructor;
-  if (typeof WebSocket === "undefined") {
+async function* watchRunEvents(options) {
+  const { http, runId, signal } = options;
+  const path = `/api/v2/runs/${encodeURIComponent(runId)}?watchSnapshot=true`;
+  const streamId = `play-run-watch:${runId}`;
+  const pollIntervalMs = options.pollIntervalMs ?? RUN_WATCH_POLL_INTERVAL_MS;
+  let previous = EMPTY_PLAY_RUN_STREAM_DIFF_STATE;
+  let consecutiveFailures = 0;
+  let outageNoticeSent = false;
+  while (!signal?.aborted) {
+    const pollStartedAt = Date.now();
+    let snapshot;
     try {
-      const wsModuleName = "ws";
-      const ws = await import(wsModuleName);
-      webSocketConstructor = ws.default;
-    } catch (error) {
-      throw new RunObserveTransportUnavailableError(
-        `no WebSocket implementation available: ${errorText(error)}`,
-        "websocket_unavailable"
-      );
-    }
-  }
-  const snapshotQuery = convexServer.makeFunctionReference(
-    OBSERVER_SNAPSHOT_QUERY
-  );
-  const logPageQuery = convexServer.makeFunctionReference(
-    OBSERVER_LOG_PAGE_QUERY
-  );
-  const client2 = new convexBrowser.ConvexClient(grant.convexUrl, {
-    ...webSocketConstructor ? { webSocketConstructor } : {},
-    unsavedChangesWarning: false
-  });
-  const queue = [];
-  let wake = null;
-  const push = (item) => {
-    queue.push(item);
-    wake?.();
-    wake = null;
-  };
-  let lastForcedRefreshAt = 0;
-  client2.setAuth(async ({ forceRefreshToken }) => {
-    const now = Date.now();
-    if (!forceRefreshToken && grant.expiresAt - now > GRANT_REFRESH_MARGIN_MS) {
-      return grant.token;
-    }
-    if (forceRefreshToken && now - lastForcedRefreshAt < 5e3) {
-      push({
-        kind: "error",
-        error: new DeeplineError(
-          `Run observe grant for ${runId} was rejected after a re-mint. The server and Convex deployment disagree on the grant issuer/JWKS.`,
-          401,
-          "RUN_OBSERVE_GRANT_REJECTED"
-        )
+      const response = await http.get(path, { signal });
+      snapshot = await backfillRotatedLogTail({
+        http,
+        runId,
+        snapshot: readSnapshotResponse(response, runId).snapshot,
+        previous,
+        signal
       });
-      return null;
-    }
-    if (forceRefreshToken) {
-      lastForcedRefreshAt = now;
-    }
-    try {
-      grant = await mintRunObserveGrant(http, runId);
-      return grant.token;
     } catch (error) {
-      push({ kind: "error", error });
-      return null;
-    }
-  });
-  const unsubscribe = client2.onUpdate(
-    snapshotQuery,
-    { workflowId: runId },
-    (run) => push({ kind: "run", run: run ?? null }),
-    (error) => push({ kind: "error", error })
-  );
-  let lastUpdateAt = Date.now();
-  let lastStatusTerminal = false;
-  let disconnectedSince = null;
-  let warnedReconnecting = false;
-  let warnedStale = false;
-  const watchdog = setInterval(() => {
-    const now = Date.now();
-    try {
-      const connectionState = client2.connectionState();
-      if (connectionState.isWebSocketConnected) {
-        disconnectedSince = null;
-        warnedReconnecting = false;
-      } else {
-        disconnectedSince ??= now;
-        if (!warnedReconnecting && now - disconnectedSince >= OBSERVE_RECONNECT_NOTICE_MS) {
-          warnedReconnecting = true;
-          options.onNotice?.(
-            `[observe] connection lost; reconnecting to live run ${runId}\u2026`
-          );
-        }
-      }
-    } catch {
-    }
-    if (!lastStatusTerminal && !warnedStale && now - lastUpdateAt >= OBSERVE_STALE_WARNING_MS) {
-      warnedStale = true;
-      options.onNotice?.(
-        `[observe] no live updates for ${Math.round((now - lastUpdateAt) / 1e3)}s; run ${runId} may be stalled (status checks continue)`
-      );
-    }
-  }, OBSERVE_WATCHDOG_TICK_MS);
-  watchdog.unref?.();
-  const abortListener = () => push({
-    kind: "error",
-    error: new DeeplineError(
-      "Run observation aborted.",
-      void 0,
-      "ABORTED"
-    )
-  });
-  options.signal?.addEventListener("abort", abortListener, { once: true });
-  let diffState = EMPTY_PLAY_RUN_STREAM_DIFF_STATE;
-  const streamId = ["observe", runId].join(":");
-  let sawFirstSnapshot = false;
-  try {
-    for (; ; ) {
-      if (queue.length === 0) {
-        const waitForItem = new Promise((resolve22) => {
-          wake = resolve22;
-        });
-        if (!sawFirstSnapshot) {
-          const timedOut = await Promise.race([
-            waitForItem.then(() => false),
-            new Promise(
-              (resolve22) => setTimeout(() => resolve22(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
-            )
-          ]);
-          if (timedOut && queue.length === 0) {
-            throw new RunObserveTransportUnavailableError(
-              `no snapshot from Convex at ${grant.convexUrl} within ${OBSERVE_BOOTSTRAP_TIMEOUT_MS}ms`,
-              "convex_unreachable"
-            );
-          }
-        } else {
-          await waitForItem;
-        }
-        continue;
-      }
-      const item = queue.shift();
-      if (item.kind === "error") {
-        if (options.signal?.aborted) {
-          return;
-        }
-        throw item.error;
+      if (signal?.aborted) {
+        return;
       }
-      sawFirstSnapshot = true;
-      lastUpdateAt = Date.now();
-      warnedStale = false;
-      if (item.run === null) {
-        throw new DeeplineError(
-          `Run ${runId} was not found (or is not visible to this grant).`,
-          404,
-          "RUN_NOT_FOUND"
-        );
+      if (!isTransientPlayRunReadError(error)) {
+        throw error;
       }
-      const snapshot = buildPlayRunStatusSnapshot({ run: item.run });
-      lastStatusTerminal = isTerminalPlayRunLiveStatus(snapshot.status);
-      const gap = resolvePlayRunLogGap(snapshot, diffState.lastLogSeq);
-      if (gap && diffState.lastLogSeq > 0) {
-        const backfilled = await backfillLogGap({
-          queryLogPage: (afterSeq, limit) => client2.query(logPageQuery, {
-            workflowId: runId,
-            afterSeq,
-            limit
-          }),
-          lastLogSeq: diffState.lastLogSeq,
-          tailFirstSeq: gap.tailFirstSeq
+      consecutiveFailures += 1;
+      const reason = error instanceof Error ? error.message : String(error);
+      if (!outageNoticeSent) {
+        options.onRetry?.({
+          attempt: consecutiveFailures,
+          delayMs: pollIntervalMs,
+          reason
         });
-        if (backfilled && backfilled.length > 0) {
-          yield {
-            cursor: String(snapshot.updatedAt ?? Date.now()),
-            streamId,
-            scope: "play",
-            type: "play.run.log",
-            at: (/* @__PURE__ */ new Date()).toISOString(),
-            payload: {
-              runId: snapshot.runId,
-              lines: backfilled,
-              source: "worker",
-              firstSeq: diffState.lastLogSeq + 1,
-              totalLogCount: snapshot.totalLogCount
-            }
-          };
-          diffState = { ...diffState, lastLogSeq: gap.tailFirstSeq - 1 };
-        }
-      }
-      const { events, next } = diffPlayRunStreamEvents({
-        streamId,
-        snapshot,
-        previous: diffState
-      });
-      diffState = next;
-      const ordered = [
-        ...events.filter((event) => event.type === "play.run.snapshot"),
-        ...events.filter((event) => event.type !== "play.run.snapshot")
-      ];
-      for (const event of ordered) {
-        yield event;
+        options.onNotice?.(
+          `[watch] run snapshot request failed; retrying every ${pollIntervalMs / 1e3}s (${reason})`
+        );
+        outageNoticeSent = true;
       }
-      if (lastStatusTerminal) {
+      const remaining2 = Math.max(
+        0,
+        pollIntervalMs - (Date.now() - pollStartedAt)
+      );
+      if (!await waitForNextPoll(remaining2, signal)) {
         return;
       }
+      continue;
     }
-  } finally {
-    clearInterval(watchdog);
-    options.signal?.removeEventListener("abort", abortListener);
-    try {
-      unsubscribe();
-    } catch {
+    if (outageNoticeSent) {
+      options.onNotice?.("[watch] run snapshot polling recovered");
+      outageNoticeSent = false;
+    }
+    consecutiveFailures = 0;
+    const diff = diffPlayRunStreamEvents({
+      streamId,
+      snapshot,
+      previous
+    });
+    previous = diff.next;
+    for (const event of diff.events) {
+      yield event;
+    }
+    if (isTerminalPlayRunLiveStatus(snapshot.status)) {
+      return;
+    }
+    const remaining = Math.max(
+      0,
+      pollIntervalMs - (Date.now() - pollStartedAt)
+    );
+    if (!await waitForNextPoll(remaining, signal)) {
+      return;
     }
-    await client2.close().catch(() => void 0);
   }
 }
 
@@ -7345,7 +6044,7 @@ function requireTargetBillingIdempotencyKey(value) {
   }
   return normalized;
 }
-function isRecord8(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPrebuiltPlayDescription(play) {
@@ -7377,10 +6076,10 @@ function normalizePlayStatus(raw) {
   return {
     ...raw,
     runId,
-    ...isRecord8(legacyOverview) ? {
+    ...isRecord4(legacyOverview) ? {
       overview: legacyOverview
     } : {},
-    ...isRecord8(runStatus) ? { runStatus } : {},
+    ...isRecord4(runStatus) ? { runStatus } : {},
     ...runPackage ? {
       package: runPackage,
       outputs: runPackage.outputs
@@ -7519,7 +6218,7 @@ function updatePlayLiveStatusState(state, event) {
   }
   const runId = typeof payload.runId === "string" && payload.runId ? payload.runId : isPlayRunPackage(payload) ? payload.run.id : state.runId;
   const status = normalizeLiveStatus(payload.status) ?? (isPlayRunPackage(payload) ? normalizeLiveStatus(payload.run.status) : null) ?? state.status;
-  const progressPayload = isRecord8(payload.progress) ? payload.progress : {};
+  const progressPayload = isRecord4(payload.progress) ? payload.progress : {};
   if (event.type === "play.run.final_status" && state.logs.length === 0 && state.lastLogSeq === 0) {
     const payloadLogs = readStringArray(payload.logs);
     const progressLogs = readStringArray(progressPayload.logs);
@@ -7598,6 +6297,7 @@ var DeeplineClient = class _DeeplineClient {
       status: (runId) => this.getRunLifecycleStatus(runId),
       list: (options2) => this.listRuns(options2),
       listPage: (options2) => this.listRunsPage(options2),
+      watch: (runId, options2) => this.watchRunToTerminal(runId, options2),
       tail: (runId, options2) => this.tailRun(runId, options2),
       logs: (runId, options2) => this.getRunLogs(runId, options2),
       input: (runId) => this.getRunInput(runId),
@@ -7720,9 +6420,9 @@ var DeeplineClient = class _DeeplineClient {
     return fields2.length > 0 ? { fields: fields2 } : schema;
   }
   schemaMetadata(schema, key) {
-    if (!isRecord8(schema)) return null;
+    if (!isRecord4(schema)) return null;
     const value = schema[key];
-    return isRecord8(value) ? value : null;
+    return isRecord4(value) ? value : null;
   }
   playRunCommand(play, options) {
     const target = play.reference || play.name;
@@ -7777,7 +6477,7 @@ var DeeplineClient = class _DeeplineClient {
       aliases,
       inputSchema: options?.compact ? this.compactSchema(play.inputSchema) : play.inputSchema ?? null,
       outputSchema: options?.compact ? this.compactSchema(play.outputSchema) : play.outputSchema ?? null,
-      staticPipeline: isRecord8(play.staticPipeline) ? play.staticPipeline : isRecord8(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord8(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
+      staticPipeline: isRecord4(play.staticPipeline) ? play.staticPipeline : isRecord4(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord4(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
       ...csvInput ? { csvInput } : {},
       ...rowOutputSchema ? { rowOutputSchema } : {},
       runCommand: runCommand2,
@@ -8137,15 +6837,17 @@ var DeeplineClient = class _DeeplineClient {
     return normalizePlayRunStart(response);
   }
   /**
-   * Start a play run and stream live runtime events from the same request.
+   * Submit a play run through the legacy event response.
    *
-   * Use this when a caller wants low-level event handling instead of submitting
-   * first and then connecting to `streamPlayRunEvents(runId)`.
+   * This reports admission from the start request; it does not watch an
+   * existing run. Use `startPlayRun()` and `watchRunEvents(runId)` separately.
+   *
+   * @deprecated Use the separate start and watch methods.
    *
    * @param request - Play run configuration.
-   * @param options - Optional streaming options.
-   * @param options.signal - Optional abort signal for the streaming request.
-   * @returns Async stream of play-scoped live events.
+   * @param options - Optional compatibility response options.
+   * @param options.signal - Abort the start response.
+   * @returns Async generator of play-scoped live events.
    */
   async *startPlayRunStream(request, options) {
     const integrationMode = resolvePlayRunIntegrationMode(request);
@@ -8627,11 +7329,23 @@ var DeeplineClient = class _DeeplineClient {
     );
     return normalizePlayStatus(response);
   }
+  /** Poll authenticated run snapshots every two seconds and emit changed events. */
+  async *watchRunEvents(workflowId, options) {
+    for await (const event of watchRunEvents({
+      http: this.http,
+      runId: workflowId,
+      signal: options?.signal,
+      onNotice: options?.onNotice,
+      onRetry: options?.onRetry
+    })) {
+      yield event;
+    }
+  }
   /**
-   * Stream semantic play-run events using the same SSE feed as the dashboard.
+   * Read raw legacy SSE events for callers that explicitly require that
+   * compatibility endpoint. Ordinary run watching uses REST snapshot polling.
    *
-   * The server emits a canonical `play.run.snapshot` event first for every
-   * connection, then incremental live events until terminal state or reconnect.
+   * @deprecated Use `watchRunEvents` for ordinary run watching.
    */
   async *streamPlayRunEvents(workflowId, options) {
     const headers = options?.lastEventId && options.lastEventId.trim() ? { "Last-Event-ID": options.lastEventId.trim() } : void 0;
@@ -8646,6 +7360,68 @@ var DeeplineClient = class _DeeplineClient {
       }
     }
   }
+  /**
+   * Compatibility alias for polling canonical run snapshots and emitting
+   * their changed events.
+   *
+   * @deprecated Use `watchRunEvents`; kept as a source-compatible alias.
+   * The `fallback` option is ignored because watching uses REST polling.
+   */
+  async *observeRunEvents(runId, options) {
+    yield* this.watchRunEvents(runId, {
+      signal: options?.signal,
+      onNotice: options?.onNotice
+    });
+  }
+  /** Poll snapshots to terminal status and return the durable package. */
+  async watchRunToTerminal(runId, options) {
+    const state = {
+      runId,
+      status: "running",
+      logs: [],
+      lastLogSeq: 0,
+      latest: null
+    };
+    let terminalObserved = false;
+    for await (const event of this.watchRunEvents(runId, {
+      signal: options?.signal,
+      onNotice: options?.onNotice,
+      onRetry: options?.onRetry ?? options?.onReconnect
+    })) {
+      options?.onEvent?.(event);
+      const status = updatePlayLiveStatusState(state, event);
+      if (status && TERMINAL_PLAY_STATUSES.has(status.status)) {
+        terminalObserved = true;
+      }
+    }
+    if (options?.signal?.aborted) {
+      throw new DeeplineError("Run watch aborted.", void 0, "ABORTED");
+    }
+    if (terminalObserved) {
+      return await this.getRunStatus(runId);
+    }
+    const refreshed = await this.getRunStatus(runId);
+    if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) return refreshed;
+    throw new DeeplineError(
+      `Run watch for ${runId} ended before a terminal status.`,
+      void 0,
+      "PLAY_WATCH_ENDED"
+    );
+  }
+  /**
+   * Wait for a run and return its terminal status.
+   *
+   * This source-compatible alias uses the same authenticated two-second REST
+   * snapshot polling as `client.runs.watch`.
+   *
+   * @deprecated Use `client.runs.watch`; retained for SDK compatibility.
+   * @param runId - Public Deepline play-run id.
+   * @param options - Optional callbacks and cancellation signal.
+   * @returns The final durable run status.
+   */
+  async tailRun(runId, options) {
+    return this.watchRunToTerminal(runId, options);
+  }
   /**
    * Cancel a running play execution.
    *
@@ -8809,10 +7585,10 @@ var DeeplineClient = class _DeeplineClient {
     const responseRunStatus = isPlayRunPackage(response) ? response.runStatus : isPlayRunPackage(response.package) ? response.package.runStatus : response.runStatus;
     const responseOverview = isPlayRunPackage(response) ? response.overview : isPlayRunPackage(response.package) ? response.package.overview : response.overview;
     const status = normalizePlayStatus(response);
-    if (isRecord8(responseRunStatus)) {
+    if (isRecord4(responseRunStatus)) {
       status.runStatus = responseRunStatus;
     }
-    if (isRecord8(responseOverview)) {
+    if (isRecord4(responseOverview)) {
       status.overview = responseOverview;
     }
     if (options?.failedLogs !== true || status.status !== "failed") {
@@ -8911,222 +7687,6 @@ var DeeplineClient = class _DeeplineClient {
     );
     return { ...response, runs: response.runs ?? [] };
   }
-  /**
-   * Observe one run's live events. Uses the Convex Run Snapshot subscription
-   * transport first (ADR-0008), then falls back to the canonical SSE stream
-   * when the subscription transport or its optional client modules are not
-   * available. Pass `fallback: 'none'` to receive
-   * {@link RunObserveTransportUnavailableError} instead.
-   */
-  async *observeRunEvents(runId, options) {
-    let yieldedObserveEvent = false;
-    try {
-      for await (const event of observeRunEvents({
-        http: this.http,
-        runId,
-        signal: options?.signal,
-        onNotice: options?.onNotice
-      })) {
-        yieldedObserveEvent = true;
-        yield event;
-      }
-    } catch (error) {
-      if (!(error instanceof RunObserveTransportUnavailableError) || yieldedObserveEvent || options?.fallback === "none") {
-        throw error;
-      }
-      options?.onNotice?.(
-        `[observe] live subscription unavailable (${error.reason}); falling back to SSE tail (support window, ADR-0008)`
-      );
-      yield* this.streamPlayRunEventsUntilTerminal(runId, options);
-    }
-  }
-  async *streamPlayRunEventsUntilTerminal(runId, options) {
-    const state = {
-      runId,
-      status: "running",
-      logs: [],
-      lastLogSeq: 0,
-      latest: null
-    };
-    let lastEventId;
-    let reconnectAttempt = 0;
-    for (; ; ) {
-      if (options?.signal?.aborted) {
-        return;
-      }
-      const connectedAt = Date.now();
-      let sawEvent = false;
-      let endedReason = "stream window ended before a terminal event";
-      try {
-        for await (const event of this.streamPlayRunEvents(runId, {
-          mode: "cli",
-          signal: options?.signal,
-          ...lastEventId ? { lastEventId } : {}
-        })) {
-          sawEvent = true;
-          if (event.cursor?.trim()) {
-            lastEventId = event.cursor;
-          }
-          yield event;
-          const status = updatePlayLiveStatusState(state, event);
-          if (status && TERMINAL_PLAY_STATUSES.has(status.status)) {
-            return;
-          }
-        }
-      } catch (error) {
-        if (options?.signal?.aborted) {
-          return;
-        }
-        if (!isTransientPlayStreamError(error)) {
-          throw error;
-        }
-        endedReason = error instanceof Error ? error.message : String(error);
-      }
-      let refreshed = null;
-      try {
-        refreshed = await this.getRunStatus(runId);
-      } catch (error) {
-        if (!isTransientPlayStreamError(error)) {
-          throw error;
-        }
-      }
-      if (refreshed && TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
-        yield {
-          cursor: String(Date.now()),
-          streamId: `sse-fallback:${runId}`,
-          scope: "play",
-          type: "play.run.status",
-          at: (/* @__PURE__ */ new Date()).toISOString(),
-          payload: refreshed
-        };
-        return;
-      }
-      if (sawEvent || Date.now() - connectedAt >= STREAM_HEALTHY_CONNECTION_MS) {
-        reconnectAttempt = 0;
-      }
-      const delayMs = streamReconnectDelayMs(reconnectAttempt);
-      reconnectAttempt += 1;
-      options?.onNotice?.(
-        `[observe] SSE tail window ended before terminal status (${endedReason}); reconnecting to run ${runId}`
-      );
-      await sleep2(delayMs);
-    }
-  }
-  /**
-   * Tail one run through the subscription transport until terminal, then
-   * return one durable REST status read (the final Run Response Package).
-   */
-  async tailRunViaObserveTransport(runId, options) {
-    const state = {
-      runId,
-      status: "running",
-      logs: [],
-      lastLogSeq: 0,
-      latest: null
-    };
-    for await (const event of this.observeRunEvents(runId, {
-      signal: options?.signal,
-      onNotice: options?.onNotice,
-      fallback: "none"
-    })) {
-      options?.onEvent?.(event);
-      const status = updatePlayLiveStatusState(state, event);
-      if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
-        continue;
-      }
-      return await this.getRunStatus(status.runId || runId);
-    }
-    if (options?.signal?.aborted) {
-      throw new DeeplineError("Run observation aborted.", void 0, "ABORTED");
-    }
-    const refreshed = await this.getRunStatus(runId);
-    if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
-      return refreshed;
-    }
-    throw new DeeplineError(
-      `Run observation for ${runId} ended before a terminal status.`,
-      void 0,
-      "PLAY_LIVE_STREAM_ENDED"
-    );
-  }
-  /**
-   * Read the canonical run stream until a terminal run status is observed.
-   *
-   * Tries the Convex Run Snapshot subscription transport first (ADR-0008);
-   * when the server cannot serve it (grant endpoint missing/unconfigured or
-   * Convex unreachable) it falls back — with one `onNotice` message — to the
-   * support-window SSE stream below.
-   *
-   * Server stream windows are finite: they end cleanly at the function
-   * ceiling even while the run keeps executing. A window that ends (cleanly
-   * or via transient network error) without a terminal event triggers one
-   * durable-status re-check followed by a backed-off reconnect, so long runs
-   * tail to completion. Abort via `options.signal` to stop waiting.
-   */
-  async tailRun(runId, options) {
-    try {
-      return await this.tailRunViaObserveTransport(runId, options);
-    } catch (error) {
-      if (!(error instanceof RunObserveTransportUnavailableError)) {
-        throw error;
-      }
-      options?.onNotice?.(
-        `[observe] live subscription unavailable (${error.reason}); falling back to SSE tail (support window, ADR-0008)`
-      );
-    }
-    const state = {
-      runId,
-      status: "running",
-      logs: [],
-      lastLogSeq: 0,
-      latest: null
-    };
-    let reconnectAttempt = 0;
-    for (; ; ) {
-      const connectedAt = Date.now();
-      let sawEvent = false;
-      let terminalRunId = null;
-      let endedReason = "stream window ended before a terminal event";
-      try {
-        for await (const event of this.streamPlayRunEvents(runId, {
-          mode: "cli",
-          signal: options?.signal
-        })) {
-          options?.onEvent?.(event);
-          sawEvent = true;
-          const status = updatePlayLiveStatusState(state, event);
-          if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
-            continue;
-          }
-          terminalRunId = status.runId || runId;
-          break;
-        }
-      } catch (error) {
-        if (options?.signal?.aborted || !isTransientPlayStreamError(error)) {
-          throw error;
-        }
-        endedReason = error instanceof Error ? error.message : String(error);
-      }
-      if (terminalRunId) {
-        return await this.getRunStatus(terminalRunId);
-      }
-      const refreshed = await this.getRunStatus(runId);
-      if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
-        return refreshed;
-      }
-      if (sawEvent || Date.now() - connectedAt >= STREAM_HEALTHY_CONNECTION_MS) {
-        reconnectAttempt = 0;
-      }
-      const delayMs = streamReconnectDelayMs(reconnectAttempt);
-      reconnectAttempt += 1;
-      options?.onReconnect?.({
-        attempt: reconnectAttempt,
-        delayMs,
-        reason: endedReason
-      });
-      await sleep2(delayMs);
-    }
-  }
   /** Get the exact original input retained for a run. This is intentionally separate from status. */
   async getRunInput(runId) {
     return this.http.get(`/api/v2/runs/${encodeURIComponent(runId)}/input`);
@@ -9917,10 +8477,10 @@ var DeeplineClient = class _DeeplineClient {
   // Plays — high-level orchestration
   // ——————————————————————————————————————————————————————————
   /**
-   * Run a play end-to-end: submit, stream until terminal, return result.
+   * Run a play end-to-end: submit, poll progress until terminal, return result.
    *
    * This is the highest-level play execution method. It submits the play,
-   * reads the canonical run stream for status updates, and returns a structured
+   * reads the canonical run snapshot for status updates, and returns a structured
    * result with logs and timing. Supports cancellation via `AbortSignal`.
    *
    * @param code - Source string fallback; pass the bundled artifact in `options.artifact`
@@ -9976,6 +8536,7 @@ var DeeplineClient = class _DeeplineClient {
       lastLogSeq: 0,
       latest: null
     };
+    let terminalObserved = null;
     if (options?.signal?.aborted) {
       await this.cancelPlay(workflowId);
       return {
@@ -9986,8 +8547,7 @@ var DeeplineClient = class _DeeplineClient {
         error: "Cancelled by user"
       };
     }
-    for await (const event of this.streamPlayRunEvents(workflowId, {
-      mode: "cli",
+    for await (const event of this.watchRunEvents(workflowId, {
       signal: options?.signal
     })) {
       if (options?.signal?.aborted) {
@@ -10000,20 +8560,36 @@ var DeeplineClient = class _DeeplineClient {
           error: "Cancelled by user"
         };
       }
+      const previousStatus = state.latest?.status;
       const status = updatePlayLiveStatusState(state, event);
       if (!status) {
         continue;
       }
-      options?.onProgress?.(status);
+      if (event.type !== "play.run.status" || status.status !== previousStatus) {
+        options?.onProgress?.(status);
+      }
       if (TERMINAL_PLAY_STATUSES.has(status.status)) {
-        const finalStatus = await this.getPlayStatus(
-          status.runId || workflowId
-        ).catch(() => status);
-        return playRunResultFromStatus(finalStatus, start, workflowId);
+        terminalObserved = status;
       }
     }
+    if (options?.signal?.aborted) {
+      await this.cancelPlay(workflowId);
+      return {
+        success: false,
+        runId: workflowId,
+        logs: state.logs,
+        durationMs: Date.now() - start,
+        error: "Cancelled by user"
+      };
+    }
+    if (terminalObserved) {
+      const finalStatus = await this.getPlayStatus(
+        terminalObserved.runId || workflowId
+      ).catch(() => terminalObserved);
+      return playRunResultFromStatus(finalStatus, start, workflowId);
+    }
     throw new DeeplineError(
-      `Run stream for ${workflowId} ended before the run reached a terminal state.`,
+      `Run watch for ${workflowId} ended before the run reached a terminal state.`,
       void 0,
       "PLAY_RUN_STREAM_ENDED",
       { runId: workflowId, workflowId }
@@ -14645,24 +13221,24 @@ function sanitizeCsvProjectionInfo(input2) {
   const rows = input2.rows.map(stripCsvProjectionFields);
   return { rows, columns };
 }
-function isRecord9(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSerializedDataset(value) {
-  return isRecord9(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
+  return isRecord5(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
 }
 function isPackagedDatasetOutput(value) {
-  return isRecord9(value) && value.kind === "dataset" && isRecord9(value.preview) && Array.isArray(value.preview.rows);
+  return isRecord5(value) && value.kind === "dataset" && isRecord5(value.preview) && Array.isArray(value.preview.rows);
 }
 function hasCurrentTableExport(value) {
-  if (!isRecord9(value) || !isRecord9(value.actions)) return false;
+  if (!isRecord5(value) || !isRecord5(value.actions)) return false;
   const exportCsv = value.actions.exportCsv;
-  return isRecord9(exportCsv) && isRecord9(exportCsv.scope) && exportCsv.scope.kind === "database" && exportCsv.scope.mutability === "current";
+  return isRecord5(exportCsv) && isRecord5(exportCsv.scope) && exportCsv.scope.kind === "database" && exportCsv.scope.mutability === "current";
 }
 function currentTableQueryCommand(value) {
-  if (!isRecord9(value) || !isRecord9(value.actions)) return void 0;
+  if (!isRecord5(value) || !isRecord5(value.actions)) return void 0;
   const query = value.actions.queryCurrentTable;
-  const command = isRecord9(query) ? query.command : void 0;
+  const command = isRecord5(query) ? query.command : void 0;
   return typeof command === "string" && command.trim() ? command.trim() : void 0;
 }
 function recoveredReturnPaths(value) {
@@ -14681,7 +13257,7 @@ function pathParts(path) {
 function valueAtPath(root, path) {
   let cursor = root;
   for (const part of pathParts(path)) {
-    if (!isRecord9(cursor)) {
+    if (!isRecord5(cursor)) {
       return void 0;
     }
     cursor = cursor[part];
@@ -14689,17 +13265,17 @@ function valueAtPath(root, path) {
   return cursor;
 }
 function totalRowsForDataset(result, datasetPath) {
-  const metadata = isRecord9(result._metadata) ? result._metadata : null;
+  const metadata = isRecord5(result._metadata) ? result._metadata : null;
   const parentPath = datasetPath.split(".").slice(0, -1).join(".");
   const parent = parentPath ? valueAtPath({ result }, parentPath) : result;
-  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord9(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
+  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord5(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
 }
 function rowArray(value) {
   if (!Array.isArray(value)) {
     return null;
   }
   const rows = value.filter(
-    (row) => isRecord9(row)
+    (row) => isRecord5(row)
   );
   return rows.length === value.length ? rows : null;
 }
@@ -14723,7 +13299,7 @@ function inferColumns(rows) {
   return columns;
 }
 function columnsFromDatasetSummary(summary) {
-  if (!isRecord9(summary) || !isRecord9(summary.columnStats)) {
+  if (!isRecord5(summary) || !isRecord5(summary.columnStats)) {
     return [];
   }
   return Object.keys(summary.columnStats).filter((column) => column);
@@ -14780,7 +13356,7 @@ function canonicalRowsInfoFromCandidate(input2) {
           candidate.value.recoveredReturnPaths
         )
       } : {},
-      ...isRecord9(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace" || candidate.value.exportUnavailable.reason === "returned_dataset_not_persisted") ? {
+      ...isRecord5(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace" || candidate.value.exportUnavailable.reason === "returned_dataset_not_persisted") ? {
         exportUnavailableReason: candidate.value.exportUnavailable.reason,
         ...typeof candidate.value.exportUnavailable.message === "string" ? {
           exportUnavailableMessage: candidate.value.exportUnavailable.message
@@ -14828,7 +13404,7 @@ function collectDatasetCandidates(input2) {
     });
     return;
   }
-  if (!isRecord9(input2.value)) {
+  if (!isRecord5(input2.value)) {
     return;
   }
   for (const [key, child] of Object.entries(input2.value)) {
@@ -14845,12 +13421,12 @@ function collectDatasetCandidates(input2) {
   }
 }
 function collectCanonicalRowsInfos(statusOrResult) {
-  const root = isRecord9(statusOrResult) ? statusOrResult : null;
-  const result = isRecord9(root?.result) ? root.result : root;
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
+  const result = isRecord5(root?.result) ? root.result : root;
   if (!result) {
     return [];
   }
-  const metadata = isRecord9(result._metadata) ? result._metadata : null;
+  const metadata = isRecord5(result._metadata) ? result._metadata : null;
   const totalFromMetadata = metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count;
   const candidates = [
     {
@@ -14874,8 +13450,8 @@ function collectCanonicalRowsInfos(statusOrResult) {
       total: totalFromMetadata ?? result.totalRows ?? result.rowCount ?? result.count
     }
   ];
-  if (isRecord9(result.output)) {
-    const outputMetadata = isRecord9(result.output._metadata) ? result.output._metadata : null;
+  if (isRecord5(result.output)) {
+    const outputMetadata = isRecord5(result.output._metadata) ? result.output._metadata : null;
     const outputTotalFromMetadata = outputMetadata?.totalRows ?? outputMetadata?.rowCount ?? outputMetadata?.count;
     candidates.push(
       {
@@ -14902,14 +13478,14 @@ function collectCanonicalRowsInfos(statusOrResult) {
   }
   if (Array.isArray(result.steps)) {
     result.steps.forEach((step, index) => {
-      if (!isRecord9(step) || !isRecord9(step.output)) {
+      if (!isRecord5(step) || !isRecord5(step.output)) {
         return;
       }
       const source = typeof step.output.path === "string" ? step.output.path : typeof step.id === "string" ? `steps.${step.id}.output` : `steps.${index}.output`;
       candidates.push({
         source,
         value: step.output,
-        total: step.output.rowCount ?? (isRecord9(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord9(step.progress) ? step.progress.total : void 0)
+        total: step.output.rowCount ?? (isRecord5(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord5(step.progress) ? step.progress.total : void 0)
       });
     });
   }
@@ -14937,15 +13513,15 @@ function collectCanonicalRowsInfos(statusOrResult) {
   return infos;
 }
 function collectPackagedDatasetCandidates(statusOrResult) {
-  const root = isRecord9(statusOrResult) ? statusOrResult : null;
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
   if (!root) {
     return [];
   }
-  const pkg = isRecord9(root.package) ? root.package : root;
+  const pkg = isRecord5(root.package) ? root.package : root;
   const datasets = Array.isArray(pkg.datasets) ? pkg.datasets : [];
   const candidates = [];
   for (const output2 of datasets) {
-    if (!isRecord9(output2) || !isPackagedDatasetOutput(output2)) {
+    if (!isRecord5(output2) || !isPackagedDatasetOutput(output2)) {
       continue;
     }
     const source = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : null;
@@ -14955,18 +13531,18 @@ function collectPackagedDatasetCandidates(statusOrResult) {
     candidates.push({
       source,
       value: output2,
-      total: output2.rowCount ?? (isRecord9(output2.preview) ? output2.preview.totalRows : void 0)
+      total: output2.rowCount ?? (isRecord5(output2.preview) ? output2.preview.totalRows : void 0)
     });
   }
   return candidates;
 }
 function collectPackagedStepDatasetCandidates(statusOrResult) {
-  const root = isRecord9(statusOrResult) ? statusOrResult : null;
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
   if (!root) return [];
-  const pkg = isRecord9(root.package) ? root.package : root;
+  const pkg = isRecord5(root.package) ? root.package : root;
   const steps = Array.isArray(pkg.steps) ? pkg.steps : [];
   return steps.flatMap((step) => {
-    if (!isRecord9(step) || !isPackagedDatasetOutput(step.output)) return [];
+    if (!isRecord5(step) || !isPackagedDatasetOutput(step.output)) return [];
     const source = typeof step.output.path === "string" && step.output.path.trim() ? step.output.path.trim() : null;
     return source ? [
       {
@@ -14978,8 +13554,8 @@ function collectPackagedStepDatasetCandidates(statusOrResult) {
   });
 }
 function collectSerializedDatasetRowsInfos(statusOrResult) {
-  const root = isRecord9(statusOrResult) ? statusOrResult : null;
-  const result = isRecord9(root?.result) ? root.result : root;
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
+  const result = isRecord5(root?.result) ? root.result : root;
   const candidates = [];
   if (result) {
     collectDatasetCandidates({
@@ -14987,7 +13563,7 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
       path: "result",
       output: candidates
     });
-    if (isRecord9(result.output)) {
+    if (isRecord5(result.output)) {
       collectDatasetCandidates({
         value: result.output,
         path: "result",
@@ -15070,13 +13646,13 @@ function summarizeSampleValue(value, depth = 0) {
   if (typeof parsed === "number" || typeof parsed === "boolean") return parsed;
   if (depth >= 3) {
     if (Array.isArray(parsed)) return [];
-    if (isRecord9(parsed)) return {};
+    if (isRecord5(parsed)) return {};
     return compactScalar(parsed);
   }
   if (Array.isArray(parsed)) {
     return parsed.slice(0, 3).map((item) => summarizeSampleValue(item, depth + 1));
   }
-  if (isRecord9(parsed)) {
+  if (isRecord5(parsed)) {
     const out = {};
     for (const [key, nested] of Object.entries(parsed)) {
       if (["__dl", "meta", "metadata"].includes(key)) {
@@ -15107,7 +13683,7 @@ function compactCell(value) {
     }
     return `[${parsed.length} items]`;
   }
-  if (isRecord9(parsed)) {
+  if (isRecord5(parsed)) {
     for (const key of ["matched_result", "output"]) {
       if (parsed[key] !== null && parsed[key] !== void 0 && parsed[key] !== "") {
         return compactCell(parsed[key]);
@@ -16502,17 +15078,17 @@ function parsePositiveInteger2(value, flagName) {
   }
   return parsed;
 }
-function isRecord10(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringValue(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function extractionEntries(value) {
-  if (Array.isArray(value)) return value.filter(isRecord10);
-  if (!isRecord10(value)) return [];
+  if (Array.isArray(value)) return value.filter(isRecord6);
+  if (!isRecord6(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord10(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord6(entry) ? { name, ...entry } : { name }
   );
 }
 var PlayBootstrapError = class extends Error {
@@ -17073,7 +15649,7 @@ function readCsvSampleRows(sample) {
     relax_column_count: true,
     trim: true
   });
-  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord10) : [];
+  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord6) : [];
 }
 function readSourceCsvColumnSpecs(csvPath) {
   const sample = readCsvSample(csvPath);
@@ -17106,16 +15682,16 @@ function packagedCsvPathForPlay(csvPath) {
   return portablePath.startsWith(".") ? portablePath : `./${portablePath}`;
 }
 function getterNamesFromTool(tool, kind) {
-  const usageGuidance = isRecord10(tool?.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord10(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord10(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const usageGuidance = isRecord6(tool?.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord6(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord6(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
   const key = kind === "list" ? "extractedLists" : "extractedValues";
   const snakeKey = kind === "list" ? "extracted_lists" : "extracted_values";
   return extractionEntries(resultGuidance[key] ?? resultGuidance[snakeKey]).map((entry) => stringValue(entry.name)).filter(Boolean);
 }
 function targetGettersFromTool(tool) {
-  const record3 = isRecord10(tool) ? tool : {};
+  const record3 = isRecord6(tool) ? tool : {};
   const raw = record3.targetGetters ?? record3.target_getters;
-  if (!isRecord10(raw)) return {};
+  if (!isRecord6(raw)) return {};
   const entries = [];
   for (const [target, value] of Object.entries(raw)) {
     const paths = Array.isArray(value) ? value.map((path) => typeof path === "string" ? path.trim() : "").filter(Boolean) : [];
@@ -17136,10 +15712,10 @@ function listRowCandidateKeysFromTool(tool) {
   return [...keys].sort();
 }
 function inputPropertyNames(schema) {
-  if (!isRecord10(schema)) return [];
-  if (isRecord10(schema.properties)) return Object.keys(schema.properties);
+  if (!isRecord6(schema)) return [];
+  if (isRecord6(schema.properties)) return Object.keys(schema.properties);
   if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord10).map((field) => stringValue(field.name)).filter(Boolean);
+    return schema.fields.filter(isRecord6).map((field) => stringValue(field.name)).filter(Boolean);
   }
   return [];
 }
@@ -17153,7 +15729,7 @@ function schemaFieldDetails(schema) {
   return { required, optional };
 }
 function jsonSchemaTypeExpression(schema) {
-  if (!isRecord10(schema)) return "unknown";
+  if (!isRecord6(schema)) return "unknown";
   const type = schema.type;
   if (Array.isArray(type)) {
     return type.map((entry) => jsonSchemaTypeExpression({ ...schema, type: entry })).join(" | ");
@@ -17183,7 +15759,7 @@ function jsonSchemaTypeExpression(schema) {
   }
 }
 function objectPropertySchema(schema, property) {
-  return isRecord10(schema) && isRecord10(schema.properties) ? schema.properties[property] : null;
+  return isRecord6(schema) && isRecord6(schema.properties) ? schema.properties[property] : null;
 }
 function playOutputHasField(schema, field) {
   return objectPropertySchema(schema, field) != null;
@@ -17359,14 +15935,14 @@ ${indent2.slice(2)}}`;
 }
 function requiredPlayInputFields(play) {
   const schema = play?.inputSchema;
-  if (!isRecord10(schema)) return [];
+  if (!isRecord6(schema)) return [];
   if (Array.isArray(schema.required)) {
     return schema.required.filter(
       (value) => typeof value === "string"
     );
   }
   if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord10).filter(
+    return schema.fields.filter(isRecord6).filter(
       (field) => field.required === true && typeof field.name === "string"
     ).map((field) => String(field.name));
   }
@@ -17547,7 +16123,7 @@ function validateBootstrapRoutes(input2) {
   }
 }
 function staticPipelineSubsteps(pipeline) {
-  if (!isRecord10(pipeline)) return [];
+  if (!isRecord6(pipeline)) return [];
   return [
     ...extractionEntries(pipeline.stages),
     ...extractionEntries(pipeline.substeps)
@@ -17555,7 +16131,7 @@ function staticPipelineSubsteps(pipeline) {
 }
 function playUsesMapBackedRuntime(play) {
   const pipeline = play?.staticPipeline;
-  if (!isRecord10(pipeline)) return false;
+  if (!isRecord6(pipeline)) return false;
   if (stringValue(pipeline.tableNamespace)) return true;
   return staticPipelineSubsteps(pipeline).some((substep) => {
     if (stringValue(substep.type) === "map") return true;
@@ -17564,7 +16140,7 @@ function playUsesMapBackedRuntime(play) {
       aliases: [],
       runCommand: "",
       examples: [],
-      staticPipeline: isRecord10(substep.pipeline) ? substep.pipeline : null
+      staticPipeline: isRecord6(substep.pipeline) ? substep.pipeline : null
     });
   });
 }
@@ -22893,35 +21469,35 @@ async function runDeployment(params, hooks) {
       } catch (error) {
         if (revokedFinalStatus(error)) throw error;
         const body = error instanceof DeployApiError ? error.body : null;
-        const errorText2 = body?.error ?? (error instanceof Error ? error.message : String(error));
-        if (/PLAY_DEPLOYMENT_NOT_ACTIVE/.test(errorText2)) {
+        const errorText = body?.error ?? (error instanceof Error ? error.message : String(error));
+        if (/PLAY_DEPLOYMENT_NOT_ACTIVE/.test(errorText)) {
           console.info("[deploy-worker] cancelled at promote", {
             deploymentId: params.deploymentId
           });
           return { finalStatus: "cancelled", outcomes: [] };
         }
-        if (/PLAY_DEPLOYMENT_STALE/.test(errorText2)) {
+        if (/PLAY_DEPLOYMENT_STALE/.test(errorText)) {
           console.info("[deploy-worker] superseded at promote", {
             deploymentId: params.deploymentId
           });
           await setStatus({
             status: "superseded",
-            error: errorText2.slice(0, 2e3),
+            error: errorText.slice(0, 2e3),
             buildSeconds: buildSeconds()
           });
           return { finalStatus: "superseded", outcomes: [] };
         }
         return await failWithCheck({
           title: "Deploy failed during promotion",
-          summary: errorText2,
-          error: errorText2,
+          summary: errorText,
+          error: errorText,
           outcomes: [
             ...outcomes,
             ...(body?.outcomes ?? toPromote).map((entry) => ({
               name: entry.name,
               file: playByName.get(entry.name)?.file ?? entry.name,
               status: "failed",
-              error: ("error" in entry ? entry.error : void 0) ?? errorText2
+              error: ("error" in entry ? entry.error : void 0) ?? errorText
             }))
           ]
         });
@@ -24796,7 +23372,7 @@ function playStatusErrorText(status) {
 function isRetryablePendingStartFailure(status) {
   if (status.status !== "failed") return false;
   if (status.runId && status.runId !== "pending") return false;
-  return isTransientPlayStreamError(new Error(playStatusErrorText(status)));
+  return isTransientPlayRunReadError(new Error(playStatusErrorText(status)));
 }
 function pendingStartFailureStatus(input2) {
   const message = input2.error instanceof Error ? input2.error.message : String(input2.error);
@@ -25331,7 +23907,7 @@ function assertPlayWaitNotTimedOut(input2) {
   if (input2.waitTimeoutMs !== null && Date.now() - input2.startedAt >= input2.waitTimeoutMs) {
     const hasRealRunId = input2.workflowId.length > 0 && input2.workflowId !== "pending";
     const phaseSuffix = input2.lastPhase && input2.lastPhase.trim() ? ` (last observed phase: ${input2.lastPhase.trim()})` : "";
-    const tailHint = hasRealRunId ? ` The CLI stopped waiting; it did not cancel the run. Check its current state with 'deepline runs get ${input2.workflowId} --json', or reattach with 'deepline runs tail ${input2.workflowId} --json'. Do not start another run just to retrieve results.` : ` No run id was received, so acceptance is unknown. Check recent runs with 'deepline runs list --play <play-name> --json' before submitting again.`;
+    const tailHint = hasRealRunId ? ` The CLI stopped waiting; it did not cancel the run. Check its current state with 'deepline runs get ${input2.workflowId} --json', or reattach with 'deepline runs watch ${input2.workflowId} --json'. Do not start another run just to retrieve results.` : ` No run id was received, so acceptance is unknown. Check recent runs with 'deepline runs list --play <play-name> --json' before submitting again.`;
     throw new DeeplineError(
       `Timed out waiting for play ${hasRealRunId ? input2.workflowId : "<no run id>"} after ${Math.ceil(input2.waitTimeoutMs / 1e3)}s${phaseSuffix}.${tailHint}`,
       void 0,
@@ -25344,63 +23920,54 @@ function assertPlayWaitNotTimedOut(input2) {
     );
   }
 }
-var PLAY_DURABLE_STATUS_PROBE_INTERVAL_MS = 15e3;
+var RUN_WATCH_RETRY_INTERVAL_MS = 2e3;
 function isAdmittedRunVisibilityDelay(error) {
   return error instanceof DeeplineError && error.statusCode === 404 && error.message.trim() === "Workflow run not found.";
 }
-async function waitForPlayCompletionByStream(input2) {
+async function waitForPlayCompletionByWatch(input2) {
   let lastPhase = null;
-  let reconnectAttempt = 0;
-  const durableStatusProbeIntervalMs = input2.durableStatusProbeIntervalMs ?? PLAY_DURABLE_STATUS_PROBE_INTERVAL_MS;
-  let nextDurableProbeAt = Date.now() + durableStatusProbeIntervalMs;
-  let durableStatusProbe = null;
   let admissionConfirmed = false;
+  let visibilityNoticeSent = false;
+  let terminalStatusRead = null;
+  const controller = new AbortController();
+  let timedOut = false;
+  const remainingWaitMs = () => input2.waitTimeoutMs === null ? null : input2.waitTimeoutMs - (Date.now() - input2.startedAt);
+  const remaining = remainingWaitMs();
+  const timeout = remaining === null ? null : setTimeout(
+    () => {
+      timedOut = true;
+      controller.abort();
+    },
+    Math.max(1, remaining)
+  );
   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 () => {
-    if (durableStatusProbe) return durableStatusProbe;
-    const probe = (async () => {
-      let refreshed;
-      try {
-        refreshed = await input2.client.getPlayStatus(input2.workflowId, {
-          billing: false
-        });
-      } catch (error) {
-        if (isTransientPlayStreamError(error) || isAdmittedRunVisibilityDelay(error)) {
-          return null;
-        }
-        throw error;
-      }
-      if (refreshed.runId === input2.workflowId && statusProvesPlayRunExecution(refreshed.status)) {
-        await confirmAdmission();
-      }
-      return TERMINAL_PLAY_STATUSES2.has(refreshed.status) ? withDashboardUrl(refreshed) : null;
-    })();
-    durableStatusProbe = probe;
+    let refreshed;
     try {
-      return await probe;
-    } finally {
-      if (durableStatusProbe === probe) durableStatusProbe = null;
+      refreshed = await input2.client.getPlayStatus(input2.workflowId, {
+        billing: false
+      });
+    } catch (error) {
+      if (isTransientPlayRunReadError(error) || isAdmittedRunVisibilityDelay(error)) {
+        return null;
+      }
+      throw error;
     }
+    if (refreshed.runId === input2.workflowId && statusProvesPlayRunExecution(refreshed.status)) {
+      await confirmAdmission();
+    }
+    return TERMINAL_PLAY_STATUSES2.has(refreshed.status) ? withDashboardUrl(refreshed) : null;
   };
-  const handleLiveEvent = async (event, probeDurableStatus) => {
+  const handleLiveEvent = async (event) => {
     assertPlayWaitNotTimedOut({ ...input2, lastPhase });
     if (getRunIdFromLiveEvent(event) === input2.workflowId && (eventConfirmsPlayRunLaunch(event) || eventProvesPlayRunExecution(event))) {
       await confirmAdmission();
     }
-    const now = Date.now();
-    if (now >= nextDurableProbeAt) {
-      nextDurableProbeAt = now + durableStatusProbeIntervalMs;
-      const durableTerminal = await probeDurableStatus();
-      if (durableTerminal) {
-        return durableTerminal;
-      }
-    }
     const phase = describeLiveEventPhase(event);
     if (phase) {
       lastPhase = phase;
@@ -25451,144 +24018,57 @@ async function waitForPlayCompletionByStream(input2) {
       }
     }
     const finalStatus = getFinalStatusFromLiveEvent(event);
-    if (finalStatus) {
+    if (event.type === "play.run.final_status" && finalStatus) {
       return withDashboardUrl(finalStatus);
     }
     const status = getStatusFromLiveEvent(event);
     if (status && TERMINAL_PLAY_STATUSES2.has(status)) {
-      const refreshedStatus = await probeDurableStatus();
-      if (refreshedStatus) return refreshedStatus;
+      terminalStatusRead ??= fetchTerminalStatus();
+      return await terminalStatusRead;
     }
     return null;
   };
-  const streamOneWindow = async () => {
-    const controller = new AbortController();
-    let timedOut = false;
-    let sawEvent = false;
-    let durableTerminal = null;
-    let durableProbeError = null;
-    let durableProbeTimer = null;
-    const remaining = remainingWaitMs();
-    const timeout = remaining === null ? null : setTimeout(
-      () => {
-        timedOut = true;
-        controller.abort();
-      },
-      Math.max(1, remaining)
-    );
-    const scheduleDurableStatusProbe = () => {
-      durableProbeTimer = setTimeout(() => {
-        durableProbeTimer = null;
-        if (controller.signal.aborted) return;
-        nextDurableProbeAt = Date.now() + durableStatusProbeIntervalMs;
-        void fetchTerminalStatus().then((status) => {
-          if (controller.signal.aborted) return;
-          if (status) {
-            durableTerminal = status;
-            controller.abort();
-            return;
-          }
-          scheduleDurableStatusProbe();
-        }).catch((error) => {
-          if (controller.signal.aborted) return;
-          durableProbeError = error;
-          controller.abort();
-        });
-      }, durableStatusProbeIntervalMs);
-    };
-    try {
-      scheduleDurableStatusProbe();
-      for await (const event of input2.client.streamPlayRunEvents(
-        input2.workflowId,
-        { signal: controller.signal }
-      )) {
-        sawEvent = true;
-        if (durableTerminal) {
-          return { kind: "terminal", status: durableTerminal };
+  try {
+    for (; ; ) {
+      try {
+        let terminalFromWatch = null;
+        for await (const event of input2.client.watchRunEvents(
+          input2.workflowId,
+          { signal: controller.signal }
+        )) {
+          const terminal3 = await handleLiveEvent(event);
+          if (terminal3) terminalFromWatch = terminal3;
         }
-        const terminal = await handleLiveEvent(event, fetchTerminalStatus);
-        if (terminal) {
-          return { kind: "terminal", status: terminal };
+        if (terminalFromWatch) return terminalFromWatch;
+      } catch (error) {
+        if (timedOut || controller.signal.aborted) break;
+        if (!isAdmittedRunVisibilityDelay(error)) throw error;
+        if (!visibilityNoticeSent && !input2.jsonOutput) {
+          input2.progress.writeLine(
+            `[play watch] run is accepted and waiting for its snapshot; checking again in ${RUN_WATCH_RETRY_INTERVAL_MS / 1e3}s`
+          );
+          visibilityNoticeSent = true;
         }
       }
-    } catch (error) {
-      if (timedOut) {
-        return { kind: "timed_out", sawEvent };
-      }
-      if (durableTerminal) {
-        return { kind: "terminal", status: durableTerminal };
-      }
-      if (durableProbeError) {
-        throw durableProbeError;
-      }
-      if (!isTransientPlayStreamError(error) && !isAdmittedRunVisibilityDelay(error)) {
-        throw error;
-      }
-      return {
-        kind: "ended",
-        sawEvent,
-        reason: error instanceof Error ? error.message : String(error)
-      };
-    } finally {
-      if (timeout) {
-        clearTimeout(timeout);
-      }
-      if (durableProbeTimer) {
-        clearTimeout(durableProbeTimer);
-      }
-      controller.abort();
-    }
-    if (timedOut) {
-      return { kind: "timed_out", sawEvent };
-    }
-    if (durableTerminal) {
-      return { kind: "terminal", status: durableTerminal };
-    }
-    if (durableProbeError) {
-      throw durableProbeError;
-    }
-    return {
-      kind: "ended",
-      sawEvent,
-      reason: "stream window ended before a terminal event"
-    };
-  };
-  for (; ; ) {
-    const connectedAt = Date.now();
-    const window = await streamOneWindow();
-    if (window.kind === "terminal") {
-      return window.status;
+      const terminal2 = await fetchTerminalStatus();
+      if (terminal2) return terminal2;
+      assertPlayWaitNotTimedOut({ ...input2, lastPhase });
+      const nextWait = remainingWaitMs();
+      await sleep5(
+        nextWait === null ? RUN_WATCH_RETRY_INTERVAL_MS : Math.min(RUN_WATCH_RETRY_INTERVAL_MS, Math.max(1, nextWait))
+      );
     }
     const terminal = await fetchTerminalStatus();
-    if (terminal) {
-      return terminal;
-    }
+    if (terminal) return terminal;
     assertPlayWaitNotTimedOut({ ...input2, lastPhase });
-    if (window.sawEvent || Date.now() - connectedAt >= STREAM_HEALTHY_CONNECTION_MS) {
-      reconnectAttempt = 0;
-    }
-    const delayMs = streamReconnectDelayMs(reconnectAttempt);
-    reconnectAttempt += 1;
-    const reason = window.kind === "ended" ? window.reason : "wait timeout raced the stream";
-    if (!input2.jsonOutput) {
-      input2.progress.writeLine(
-        `[play watch] stream ended without a terminal status; reconnecting to run ${input2.workflowId} (${reason})`
-      );
-    }
-    recordCliTrace({
-      phase: "cli.play_tail_stream_reconnect",
-      ms: Date.now() - input2.startedAt,
-      ok: true,
-      playName: input2.playName,
-      workflowId: input2.workflowId,
-      attempt: reconnectAttempt,
-      delayMs,
-      reason
-    });
-    const remainingBeforeSleep = remainingWaitMs();
-    await sleep5(
-      remainingBeforeSleep === null ? delayMs : Math.min(delayMs, Math.max(1, remainingBeforeSleep))
+    throw new DeeplineError(
+      `Run watch for ${input2.workflowId} ended before a terminal status.`,
+      void 0,
+      "PLAY_WATCH_ENDED"
     );
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    controller.abort();
   }
 }
 async function startAndWaitForPlayCompletionByStream(input2) {
@@ -25665,7 +24145,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
         billing: false
       });
     } catch (error) {
-      if (isTransientPlayStreamError(error)) {
+      if (isTransientPlayRunReadError(error)) {
         return null;
       }
       throw error;
@@ -25836,7 +24316,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
           firstRunIdMs,
           lastPhase
         });
-        return waitForPlayCompletionByStream({
+        return waitForPlayCompletionByWatch({
           client: input2.client,
           playName: input2.playName,
           workflowId: lastKnownWorkflowId,
@@ -25875,7 +24355,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
         lastPhase
       });
     }
-    if (lastKnownWorkflowId && isTransientPlayStreamError(error)) {
+    if (lastKnownWorkflowId && isTransientPlayRunReadError(error)) {
       if (timeout) {
         clearTimeout(timeout);
       }
@@ -25897,7 +24377,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
         lastPhase,
         reason
       });
-      return waitForPlayCompletionByStream({
+      return waitForPlayCompletionByWatch({
         client: input2.client,
         playName: input2.playName,
         workflowId: lastKnownWorkflowId,
@@ -25911,7 +24391,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
         onRunAdmitted: confirmAdmission
       });
     }
-    if (!lastKnownWorkflowId && isTransientPlayStreamError(error)) {
+    if (!lastKnownWorkflowId && isTransientPlayRunReadError(error)) {
       recordCliTrace({
         phase: "cli.play_start_stream_transient_failure",
         ms: Date.now() - startedAt,
@@ -25951,7 +24431,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
       lastPhase,
       reason: "stream ended before terminal event"
     });
-    return waitForPlayCompletionByStream({
+    return waitForPlayCompletionByWatch({
       client: input2.client,
       playName: input2.playName,
       workflowId: lastKnownWorkflowId,
@@ -25968,7 +24448,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
   const phaseSuffix = lastPhase && lastPhase.trim() ? ` (last observed phase: ${lastPhase.trim()})` : "";
   const idSuffix = lastKnownWorkflowId ? ` runId=${lastKnownWorkflowId}` : "";
   throw new DeeplineError(
-    `Play start stream ended before a terminal status was observed${idSuffix}${phaseSuffix}. If a run id was printed, inspect it with 'deepline runs get <run-id> --full --json' or continue watching with 'deepline runs tail <run-id>'.`,
+    `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 --json' or continue watching with 'deepline runs watch <run-id>'.`,
     void 0,
     "PLAY_START_STREAM_ENDED",
     {
@@ -28081,7 +26561,7 @@ function extractPlayValidationErrors(value) {
   if (value instanceof DeeplineError) {
     return extractPlayValidationErrors(value.details);
   }
-  if (!isRecord11(value)) {
+  if (!isRecord7(value)) {
     return [];
   }
   const directErrors = stringArrayField(value, "errors");
@@ -28477,7 +26957,7 @@ function parsePlayRunOptions(args) {
     }
     if (arg === "--poll-interval-ms" || arg === "--interval-ms") {
       throw new Error(
-        `${arg} was removed. --watch uses the canonical run stream directly.`
+        `${arg} was removed. --watch polls the canonical run snapshot.`
       );
     }
     if ((arg === "--tail-timeout-ms" || arg === "--timeout-ms") && args[index + 1]) {
@@ -28745,7 +27225,7 @@ function formatPlayRuntimeLimit(runtimeLimit) {
   if (seconds % 60 === 0) return `${seconds / 60} min`;
   return `${seconds} sec`;
 }
-function isRecord11(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringValue3(value) {
@@ -28755,14 +27235,14 @@ function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
 function extractionEntries2(value) {
-  if (Array.isArray(value)) return value.filter(isRecord11);
-  if (!isRecord11(value)) return [];
+  if (Array.isArray(value)) return value.filter(isRecord7);
+  if (!isRecord7(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord11(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord7(entry) ? { name, ...entry } : { name }
   );
 }
 function firstRawPath(entry) {
-  const details = isRecord11(entry.details) ? entry.details : {};
+  const details = isRecord7(entry.details) ? entry.details : {};
   const paths = [
     ...asArray(details.rawToolOutputPaths),
     ...asArray(details.raw_tool_output_paths),
@@ -28780,12 +27260,12 @@ function checkHintRawPath(value) {
 function collectStaticPipelineToolIds(staticPipeline) {
   const seen = /* @__PURE__ */ new Set();
   const visitPipeline = (pipeline) => {
-    if (!isRecord11(pipeline)) return;
+    if (!isRecord7(pipeline)) return;
     for (const step of [
       ...asArray(pipeline.stages),
       ...asArray(pipeline.substeps)
     ]) {
-      if (!isRecord11(step)) continue;
+      if (!isRecord7(step)) continue;
       if (step.type === "tool") {
         const toolId = stringValue3(step.toolId) || stringValue3(step.tool);
         if (toolId) seen.add(toolId);
@@ -28799,9 +27279,9 @@ function collectStaticPipelineToolIds(staticPipeline) {
   return [...seen].sort();
 }
 function toolGetterHintFromMetadata(toolId, tool) {
-  const usageGuidance = isRecord11(tool.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord11(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord11(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
-  const toolResponse = isRecord11(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord11(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
+  const usageGuidance = isRecord7(tool.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord7(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord7(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const toolResponse = isRecord7(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord7(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
   const lists = extractionEntries2(
     resultGuidance.extractedLists ?? resultGuidance.extracted_lists
   ).map((entry) => ({
@@ -29164,7 +27644,7 @@ function artifactForProductionCompatibilityCheck(artifact) {
       "DEEPLINE_PROD_CHECK_AUTHORING_CONTRACT_EDITION must be a positive integer."
     );
   }
-  const compatibility = isRecord11(artifact.compatibility) ? artifact.compatibility : {};
+  const compatibility = isRecord7(artifact.compatibility) ? artifact.compatibility : {};
   return {
     ...artifact,
     compatibility: {
@@ -30064,7 +28544,7 @@ Active runs: ${next.running}`
   return 0;
 }
 async function handleRunTail(args) {
-  const usage = "Usage: deepline runs tail <run-id> [--json | --jsonl] [--compact] [--log-level debug|info|warn|error]";
+  const usage = "Usage: deepline runs watch <run-id> [--json | --jsonl] [--compact] [--log-level debug|info|warn|error]";
   let runId;
   try {
     runId = parseRunIdPositional(args, usage);
@@ -30079,7 +28559,7 @@ async function handleRunTail(args) {
     const arg = args[index];
     if (arg === "--cursor") {
       console.error(
-        "--cursor was removed. deepline runs tail reads the canonical run stream."
+        "--cursor was removed. deepline runs watch polls the canonical run snapshot."
       );
       return 1;
     }
@@ -30105,7 +28585,7 @@ async function handleRunTail(args) {
       continue;
     }
     if (arg.startsWith("--") && arg !== "--json" && arg !== "--jsonl" && arg !== "--compact") {
-      console.error(`${arg} is not supported by deepline runs tail.`);
+      console.error(`${arg} is not supported by deepline runs watch.`);
       return 1;
     }
   }
@@ -30141,7 +28621,7 @@ async function handleRunTail(args) {
     verbose: debug,
     logLevel
   };
-  const status = await client2.runs.tail(runId, {
+  const status = await client2.runs.watch(runId, {
     onEvent: jsonLines ? (event) => {
       process.stdout.write(
         `${JSON.stringify({
@@ -30187,9 +28667,9 @@ async function handleRunTail(args) {
       }
     } : void 0,
     // Human mode only: in --json mode emit nothing non-protocol.
-    onReconnect: jsonOutput && !debug && !hasExplicitLogLevel ? void 0 : ({ reason }) => {
+    onRetry: jsonOutput && !debug && !hasExplicitLogLevel ? void 0 : ({ reason }) => {
       process.stderr.write(
-        `[runs tail] stream ended without a terminal status; reconnecting to run ${runId} (${reason})
+        `[runs watch] snapshot polling failed; retrying for run ${runId} (${reason})
 `
       );
     }
@@ -31856,7 +30336,10 @@ Examples:
   ).option(
     "--log-level <level>",
     "Minimum live log severity: debug, info (default), warn, or error"
-  ).option("--tail-timeout-ms <ms>", "Timeout while watching the run stream").option("--force", "Start a fresh run graph").option(
+  ).option(
+    "--tail-timeout-ms <ms>",
+    "Timeout while waiting for terminal run status"
+  ).option("--force", "Start a fresh run graph").option(
     "--force-tool-refresh",
     "Refresh completed tool receipts; may repeat billed provider calls"
   ).option(
@@ -32326,13 +30809,13 @@ Concepts:
   stop mutates cloud state by requesting cancellation.
 
 Debug a run:
-  Active:    deepline runs tail <run-id> --log-level debug
+  Active:    deepline runs watch <run-id> --log-level debug
   Historical: deepline runs logs <run-id> --out run.log --log-level debug --json
   Full state: deepline runs get <run-id> --full --json
 
 Examples:
   deepline runs get play/my-play/run/20260501t000000-000 --json
-  deepline runs tail play/my-play/run/20260501t000000-000
+  deepline runs watch play/my-play/run/20260501t000000-000
   deepline runs logs play/my-play/run/20260501t000000-000 --out run.log --log-level debug --json
   deepline runs list --play my-play --status failed --json
   deepline runs list --status running --json
@@ -32466,29 +30949,30 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
-  runs.command("tail <runId>").description("Read the canonical live stream for a play run.").addHelpText(
+  runs.command("watch <runId>").alias("tail").description("Poll the canonical run snapshot until terminal status.").addHelpText(
     "after",
     `
 Notes:
-  Streams live run events until the stream ends. Human output shows info and
-  warning logs as they arrive. Use get for current status and logs for persisted
-  log history. In human output, --compact prints deduplicated
-  step transitions and progress instead of the full event stream. --json emits
-  one terminal package. --jsonl emits canonical live events as JSON Lines and
-  ends with the same compact package shape as runs get --json. --log-level
+  Polls the authenticated run snapshot every two seconds. Human output shows
+  info and warning logs as snapshots change. Use get for current status and
+  logs for persisted log history. In human output, --compact prints
+  deduplicated step transitions and progress. --json emits one terminal
+  package. --jsonl emits canonical watched events as JSON Lines and ends with
+  the same compact package shape as runs get --json. The tail command remains
+  an alias. --log-level
   filters the rendered customer-safe runtime log lines; debug includes runtime
   and receipt diagnostics and writes them to stderr alongside JSON output.
 
 Examples:
-  deepline runs tail play/my-play/run/20260501t000000-000
-  deepline runs tail play/my-play/run/20260501t000000-000 --compact
-  deepline runs tail play/my-play/run/20260501t000000-000 --log-level debug
-  deepline runs tail play/my-play/run/20260501t000000-000 --log-level error
-  deepline runs tail play/my-play/run/20260501t000000-000 --jsonl
+  deepline runs watch play/my-play/run/20260501t000000-000
+  deepline runs watch play/my-play/run/20260501t000000-000 --compact
+  deepline runs watch play/my-play/run/20260501t000000-000 --log-level debug
+  deepline runs watch play/my-play/run/20260501t000000-000 --log-level error
+  deepline runs watch play/my-play/run/20260501t000000-000 --jsonl
 `
   ).option("--json", "Emit one terminal JSON package after the run completes").option(
     "--jsonl",
-    "Stream live events as JSON Lines, then the terminal package"
+    "Emit watched events as JSON Lines, then the terminal package"
   ).option(
     "--compact",
     "Show deduplicated human step transitions and progress"
@@ -34406,7 +32890,7 @@ function isMarkedTestAiInferenceCommand(command) {
   if (normalizeEnrichPlayRef(command.tool) !== "run_javascript") {
     return false;
   }
-  return isRecord12(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
+  return isRecord8(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
 }
 function enrichDebugEnabled(env = process.env) {
   const raw = String(env.DEEPLINE_DEBUG_ENRICH ?? "").trim().toLowerCase();
@@ -34670,7 +33154,7 @@ function rewriteGeneratedPlayRerunForEnrich(status, enrichCommand) {
     if (Array.isArray(value)) {
       return value.map(rewrite);
     }
-    if (!isRecord12(value)) {
+    if (!isRecord8(value)) {
       return value;
     }
     const next = Object.fromEntries(
@@ -34679,7 +33163,7 @@ function rewriteGeneratedPlayRerunForEnrich(status, enrichCommand) {
         key === "rerunCommand" && typeof entry === "string" ? enrichCommand : rewrite(entry)
       ])
     );
-    if (isRecord12(next.next) && typeof next.next.run === "string") {
+    if (isRecord8(next.next) && typeof next.next.run === "string") {
       next.next = { ...next.next, run: enrichCommand };
     }
     return next;
@@ -35161,7 +33645,7 @@ async function resolveWatchedGeneratedPlayStatus(input2) {
   }
   return input2.client.runs.get(runId, { full: true });
 }
-function isRecord12(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 async function captureStdout(run, options = {}) {
@@ -35413,15 +33897,15 @@ function readFirstEnrichDatasetActions(value) {
       return null;
     }
     const record3 = candidate;
-    const actions = isRecord12(record3.actions) ? record3.actions : null;
-    const currentQuery = isRecord12(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
-    const legacyQuery = isRecord12(actions?.query) ? actions.query : null;
+    const actions = isRecord8(record3.actions) ? record3.actions : null;
+    const currentQuery = isRecord8(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
+    const legacyQuery = isRecord8(actions?.query) ? actions.query : null;
     const query = currentQuery?.kind === "deepline_db_query" ? currentQuery : legacyQuery?.kind === "deepline_db_query" ? legacyQuery : null;
     if (query?.kind === "deepline_db_query") {
       return {
         dataset: record3,
         query,
-        ...isRecord12(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
+        ...isRecord8(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
       };
     }
     if (options.allowLegacy && record3.kind === "dataset" && typeof record3.queryDatasetCommand === "string" && record3.queryDatasetCommand.trim()) {
@@ -35474,7 +33958,7 @@ function enrichCustomerDbJson(input2) {
   const dataset = actions.dataset;
   const sql = actionStringField(query, "sql") ?? parseSqlFromDbQueryCommand(actions.queryDatasetCommand);
   const datasetPath = actionStringField(query, "datasetPath") ?? actionStringField(dataset, "path") ?? actionStringField(dataset, "tableNamespace");
-  const api = isRecord12(query.api) ? query.api : null;
+  const api = isRecord8(query.api) ? query.api : null;
   const apiPath = actionStringField(api ?? {}, "path") ?? "/api/v2/db/query";
   const apiMethod = actionStringField(api ?? {}, "method") ?? "POST";
   if (!datasetPath) {
@@ -35543,11 +34027,11 @@ function sqlStringLiteral(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
 function failureAliasFromCellMeta(cellMeta) {
-  if (!isRecord12(cellMeta)) {
+  if (!isRecord8(cellMeta)) {
     return null;
   }
   for (const [alias, meta] of Object.entries(cellMeta)) {
-    if (!isRecord12(meta)) {
+    if (!isRecord8(meta)) {
       continue;
     }
     const failure = failureCellFromMeta(meta, {});
@@ -36041,7 +34525,7 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
   return fallback;
 }
 function failureCellFromMeta(meta, fallback) {
-  if (!isRecord12(meta)) {
+  if (!isRecord8(meta)) {
     return null;
   }
   const status = typeof meta.status === "string" ? meta.status.trim().toLowerCase() : "";
@@ -36061,7 +34545,7 @@ function failureCellFromMeta(meta, fallback) {
   };
 }
 function applyFailureCellMeta(row, cellMeta, fallback) {
-  if (!isRecord12(cellMeta)) {
+  if (!isRecord8(cellMeta)) {
     return;
   }
   for (const [field, meta] of Object.entries(cellMeta)) {
@@ -36289,7 +34773,7 @@ function stableRowSnapshot(value) {
 }
 function cellFailureError(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord12(parsed)) {
+  if (!isRecord8(parsed)) {
     const text = typeof parsed === "string" ? parsed.trim() : "";
     if (/^(?:[A-Za-z0-9_:-]+:\s*)?(?:Error|TypeError|ReferenceError|SyntaxError|RangeError):\s+/.test(
       text
@@ -36297,12 +34781,12 @@ function cellFailureError(value) {
       return { message: text };
     }
   }
-  if (!isRecord12(parsed)) {
+  if (!isRecord8(parsed)) {
     return null;
   }
   const status = typeof parsed.status === "string" ? parsed.status.trim().toLowerCase() : "";
   const directError = typeof parsed.error === "string" ? parsed.error.trim() : typeof parsed.last_error === "string" ? parsed.last_error.trim() : "";
-  const result = isRecord12(parsed.result) ? parsed.result : null;
+  const result = isRecord8(parsed.result) ? parsed.result : null;
   const resultError = typeof result?.error === "string" ? result.error.trim() : typeof result?.message === "string" ? result.message.trim() : "";
   if (!directError && !resultError && status !== "error" && status !== "failed") {
     return null;
@@ -36372,7 +34856,7 @@ function assignFlattenedFailurePath(target, field, value) {
   let cursor = target;
   for (const part of normalized.slice(0, -1)) {
     const existing = cursor[part];
-    if (!isRecord12(existing)) {
+    if (!isRecord8(existing)) {
       const next = {};
       cursor[part] = next;
       cursor = next;
@@ -36536,10 +35020,10 @@ function waterfallExecutionSignal(status, spec) {
   let everyChildStatOnlyConditionSkipped = true;
   const childAliasesWithStats = /* @__PURE__ */ new Set();
   for (const childAlias of childAliases) {
-    for (const stat5 of summaries.map((summary) => summary[childAlias]).filter(isRecord12)) {
+    for (const stat5 of summaries.map((summary) => summary[childAlias]).filter(isRecord8)) {
       sawChildStats = true;
       childAliasesWithStats.add(childAlias);
-      const execution = isRecord12(stat5.execution) ? stat5.execution : null;
+      const execution = isRecord8(stat5.execution) ? stat5.execution : null;
       const executedSummary = parseExecutionSummary(
         execution?.["completed:executed"]
       );
@@ -36569,7 +35053,7 @@ function waterfallExecutionSignal(status, spec) {
 }
 function emptyWaterfallStatsEvidence(status, spec) {
   const summaries = collectColumnStats(status);
-  const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord12);
+  const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord8);
   for (const stat5 of parentStats) {
     const nonEmpty = parseExecutionSummary(stat5.non_empty);
     if (nonEmpty?.total && nonEmpty.count === 0) {
@@ -36583,7 +35067,7 @@ function emptyWaterfallStatsEvidence(status, spec) {
   let selectedRows = 0;
   let sawStatsForEveryChild = true;
   for (const childAlias of childAliases) {
-    const stat5 = summaries.map((summary) => summary[childAlias]).find(isRecord12);
+    const stat5 = summaries.map((summary) => summary[childAlias]).find(isRecord8);
     if (!stat5) {
       sawStatsForEveryChild = false;
       break;
@@ -36592,7 +35076,7 @@ function emptyWaterfallStatsEvidence(status, spec) {
     if ((nonEmpty?.count ?? 0) > 0) {
       return null;
     }
-    const execution = isRecord12(stat5.execution) ? stat5.execution : null;
+    const execution = isRecord8(stat5.execution) ? stat5.execution : null;
     const executed = parseExecutionSummary(execution?.["completed:executed"]);
     const reused = parseExecutionSummary(execution?.["completed:reused"]);
     const skipped = parseExecutionSummary(execution?.["skipped:condition"]);
@@ -36634,11 +35118,11 @@ function collectStatusFailureJobs(input2) {
   const jobs = [];
   aliases.forEach((spec, aliasIndex) => {
     const { alias } = spec;
-    const stat5 = summaries.map((summary) => summary[alias]).find(isRecord12);
+    const stat5 = summaries.map((summary) => summary[alias]).find(isRecord8);
     if (!stat5) {
       return;
     }
-    const execution = isRecord12(stat5.execution) ? stat5.execution : null;
+    const execution = isRecord8(stat5.execution) ? stat5.execution : null;
     const failedCount = Math.min(
       selectedRows,
       Math.max(
@@ -36745,10 +35229,10 @@ function collectColumnStats(status) {
       value.forEach(visit);
       return;
     }
-    if (!isRecord12(value)) {
+    if (!isRecord8(value)) {
       return;
     }
-    if (isRecord12(value.columnStats)) {
+    if (isRecord8(value.columnStats)) {
       summaries.push(value.columnStats);
     }
     Object.values(value).forEach(visit);
@@ -36760,12 +35244,12 @@ function firstAliasExecutionCounts(input2) {
   const aliases = collectConfigScalarAliasOrder(input2.config);
   const summaries = collectColumnStats(input2.status);
   for (const alias of aliases) {
-    const stat5 = summaries.map((summary) => summary[alias]).find(isRecord12);
+    const stat5 = summaries.map((summary) => summary[alias]).find(isRecord8);
     if (!stat5) continue;
     if (input2.forceAliases.has(normalizeAlias2(alias))) {
       return { executed: input2.selectedRows, reused: 0 };
     }
-    const execution = isRecord12(stat5.execution) ? stat5.execution : null;
+    const execution = isRecord8(stat5.execution) ? stat5.execution : null;
     if (!execution) continue;
     return {
       executed: parseExecutionCount(execution["completed:executed"]),
@@ -36792,14 +35276,14 @@ function rewriteEnrichJsonStatus(input2) {
     if (Array.isArray(value)) {
       return value.map(rewrite);
     }
-    if (!isRecord12(value)) {
+    if (!isRecord8(value)) {
       return value;
     }
     const next = {};
     for (const [key, entry] of Object.entries(value)) {
       next[key] = rewrite(entry);
     }
-    if (isRecord12(next.progress)) {
+    if (isRecord8(next.progress)) {
       next.progress = {
         ...next.progress,
         ...selectedRows > 0 ? { total: selectedRows } : {},
@@ -36808,8 +35292,8 @@ function rewriteEnrichJsonStatus(input2) {
         ...failedRows > 0 ? { failed: failedRows, pending: 0 } : {}
       };
     }
-    if (isRecord12(next.summary)) {
-      const rowCounts = isRecord12(next.summary.rowCounts) ? next.summary.rowCounts : null;
+    if (isRecord8(next.summary)) {
+      const rowCounts = isRecord8(next.summary.rowCounts) ? next.summary.rowCounts : null;
       if (failedRows > 0) {
         next.summary = {
           ...next.summary,
@@ -36822,11 +35306,11 @@ function rewriteEnrichJsonStatus(input2) {
         };
       }
     }
-    if (isRecord12(next.columnStats) && selectedRows > 0) {
+    if (isRecord8(next.columnStats) && selectedRows > 0) {
       const columnStats = { ...next.columnStats };
       for (const alias of forcedAliases) {
-        const stat5 = isRecord12(columnStats[alias]) ? columnStats[alias] : null;
-        const execution = isRecord12(stat5?.execution) ? stat5.execution : null;
+        const stat5 = isRecord8(columnStats[alias]) ? columnStats[alias] : null;
+        const execution = isRecord8(stat5?.execution) ? stat5.execution : null;
         if (!stat5 || !execution) continue;
         columnStats[alias] = {
           ...stat5,
@@ -36845,14 +35329,14 @@ function rewriteEnrichJsonStatus(input2) {
     return next;
   };
   const rewritten = rewrite(input2.status);
-  if (failedRows === 0 || !isRecord12(rewritten)) {
+  if (failedRows === 0 || !isRecord8(rewritten)) {
     return rewritten;
   }
   const partialStatus = selectedRows > 0 && failedRows < selectedRows ? "partial_success" : "failed";
   return {
     ...rewritten,
     ...rewritten.status === "completed" || rewritten.status === "failed" ? { status: partialStatus } : {},
-    ...isRecord12(rewritten.run) && (rewritten.run.status === "completed" || rewritten.run.status === "failed") ? { run: { ...rewritten.run, status: partialStatus } } : {}
+    ...isRecord8(rewritten.run) && (rewritten.run.status === "completed" || rewritten.run.status === "failed") ? { run: { ...rewritten.run, status: partialStatus } } : {}
   };
 }
 function summarizeFailedJobError(value) {
@@ -37476,7 +35960,7 @@ function materializeCsvCellValue(value) {
   return value;
 }
 function compactArrayEnvelopeCompleteValue(value) {
-  if (!isRecord12(value) || value.kind !== "array") {
+  if (!isRecord8(value) || value.kind !== "array") {
     return null;
   }
   if (!Array.isArray(value.preview)) {
@@ -37490,7 +35974,7 @@ function compactArrayEnvelopeCompleteValue(value) {
 }
 function disambiguateCompactAiInferencePayload(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord12(parsed) || !cellFailureError(parsed)) {
+  if (!isRecord8(parsed) || !cellFailureError(parsed)) {
     return value;
   }
   return {
@@ -37499,14 +35983,14 @@ function disambiguateCompactAiInferencePayload(value) {
   };
 }
 function compactAiInferenceCellForCsv(value) {
-  if (!isRecord12(value)) {
+  if (!isRecord8(value)) {
     return value;
   }
   const extractedJson = value.extracted_json;
   if (extractedJson !== null && extractedJson !== void 0) {
     return disambiguateCompactAiInferencePayload(extractedJson);
   }
-  const result = isRecord12(value.result) ? value.result : null;
+  const result = isRecord8(value.result) ? value.result : null;
   const object = result?.object;
   if (object !== null && object !== void 0) {
     return disambiguateCompactAiInferencePayload(object);
@@ -37523,12 +36007,12 @@ function compactAiInferenceCellForCsv(value) {
 }
 function materializeEnrichAliasCellForCsv(row, alias, options) {
   const direct = row[alias];
-  if (isRecord12(direct)) {
+  if (isRecord8(direct)) {
     const completeArray = compactArrayEnvelopeCompleteValue(direct);
     if (completeArray) {
       return materializeCsvCellValue(completeArray);
     }
-    if (options?.compactAiCell && direct.status === "completed" && (isRecord12(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
+    if (options?.compactAiCell && direct.status === "completed" && (isRecord8(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
       return materializeCsvCellValue(compactAiInferenceCellForCsv(direct));
     }
     if (Object.prototype.hasOwnProperty.call(direct, "matched_result") || Object.prototype.hasOwnProperty.call(direct, "matchedResult") || Object.prototype.hasOwnProperty.call(direct, "result")) {
@@ -37669,11 +36153,11 @@ function normalizeEnrichRowsForCsvExport(rows, config, options) {
 }
 function legacyMetadataFromRow(row) {
   const direct = parseLegacyMetadataCell(row._metadata);
-  if (direct && isRecord12(direct.columns)) {
+  if (direct && isRecord8(direct.columns)) {
     return direct;
   }
   const relocated = parseLegacyMetadataCell(row.metadata);
-  if (relocated && isRecord12(relocated.columns)) {
+  if (relocated && isRecord8(relocated.columns)) {
     return relocated;
   }
   const flattenedColumns = parseLegacyMetadataCell(row["metadata.columns"]);
@@ -37690,7 +36174,7 @@ function legacyMetadataFromRow(row) {
 }
 function parseLegacyMetadataCell(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (isRecord12(parsed)) {
+  if (isRecord8(parsed)) {
     return parsed;
   }
   if (typeof value !== "string") {
@@ -37707,12 +36191,12 @@ function parseLegacyMetadataCell(value) {
   for (const candidate of candidates) {
     try {
       const decoded = JSON.parse(candidate);
-      if (isRecord12(decoded)) {
+      if (isRecord8(decoded)) {
         return decoded;
       }
       if (typeof decoded === "string") {
         const nested = JSON.parse(decoded);
-        if (isRecord12(nested)) {
+        if (isRecord8(nested)) {
           return nested;
         }
       }
@@ -37722,8 +36206,8 @@ function parseLegacyMetadataCell(value) {
   return null;
 }
 function mergeLegacyMetadataRecords(base, enriched) {
-  const baseColumns = isRecord12(base.columns) ? base.columns : null;
-  const enrichedColumns = isRecord12(enriched.columns) ? enriched.columns : null;
+  const baseColumns = isRecord8(base.columns) ? base.columns : null;
+  const enrichedColumns = isRecord8(enriched.columns) ? enriched.columns : null;
   const merged = {
     ...base,
     ...enriched
@@ -51030,7 +49514,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
 }
 function extractionContractEntries(entries) {
   return entries.flatMap((entry) => {
-    if (!isRecord13(entry)) return [];
+    if (!isRecord9(entry)) return [];
     const name = stringField2(entry, "name");
     const expression = stringField2(entry, "expression");
     return name && expression ? [{ name, expression }] : [];
@@ -51051,7 +49535,7 @@ function printMonitorTypeFilters(tool) {
   }
   console.log("Deploy filters (set in the monitor payload):");
   for (const name of names) {
-    const field = isRecord13(properties[name]) ? properties[name] : {};
+    const field = isRecord9(properties[name]) ? properties[name] : {};
     const star = required.has(name) ? "*" : "";
     const enumVals = arrayField2(field, "enum").filter(
       (v) => typeof v === "string"
@@ -51065,7 +49549,7 @@ function printMonitorTypeFilterExamples(tool) {
   const documentation = recordField2(tool, "documentation");
   const fields2 = recordField2(documentation, "fields");
   const examples = Object.entries(fields2).flatMap(([name, rawField]) => {
-    const grammar = recordField2(isRecord13(rawField) ? rawField : {}, "grammar");
+    const grammar = recordField2(isRecord9(rawField) ? rawField : {}, "grammar");
     const example = stringField2(grammar, "example");
     const values = [
       ...arrayField2(grammar, "examples").filter(
@@ -51084,14 +49568,14 @@ function printMonitorTypeFilterExamples(tool) {
 }
 function printMonitorTypeStreams(tool) {
   const streams = arrayField2(tool, "streams", "output_streams").filter(
-    isRecord13
+    isRecord9
   );
   if (!streams.length) return;
   console.log("");
   console.log("Filter columns (a play's sqlListeners.where, per stream):");
   for (const stream of streams) {
     const name = stringField2(stream, "stream");
-    const cols = arrayField2(stream, "columns").filter(isRecord13).map((col) => stringField2(col, "name")).filter(Boolean);
+    const cols = arrayField2(stream, "columns").filter(isRecord9).map((col) => stringField2(col, "name")).filter(Boolean);
     console.log(`- ${name}: ${cols.join(", ")}`);
   }
 }
@@ -51108,7 +49592,7 @@ function monitorTypePricingLines(tool) {
   }
   const lines = ["Pricing (Deepline credits per accepted event):"];
   for (const key of keys) {
-    const entry = isRecord13(byType[key]) ? byType[key] : {};
+    const entry = isRecord9(byType[key]) ? byType[key] : {};
     const credits = numberField2(entry, "deepline_credits", "deeplineCredits");
     const display = stringField2(entry, "display");
     const shown = display || (credits !== null ? `${formatDecimal(credits)} credits/event` : "see --json");
@@ -51158,8 +49642,8 @@ function printCompactToolContract(tool, requestedToolId) {
     return;
   }
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord13(contract.cost) ? contract.cost : {};
-  const getters = isRecord13(contract.getters) ? contract.getters : {};
+  const cost = isRecord9(contract.cost) ? contract.cost : {};
+  const getters = isRecord9(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const inputFields = recursiveToolInputFieldsForDisplay(
@@ -51176,7 +49660,7 @@ function printCompactToolContract(tool, requestedToolId) {
   printToolOutputArrayShape(contract);
   printToolExecutionHints(contract);
   if (contract.deprecated === true) {
-    const deprecation = isRecord13(contract.deprecation) ? contract.deprecation : {};
+    const deprecation = isRecord9(contract.deprecation) ? contract.deprecation : {};
     const message = stringField2(deprecation, "message");
     const replacementToolId = stringField2(
       deprecation,
@@ -51203,7 +49687,7 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("");
     console.log("Inputs:");
     for (const field of inputFields) {
-      if (!isRecord13(field)) continue;
+      if (!isRecord9(field)) continue;
       const name = stringField2(field, "name");
       if (!name) continue;
       const required = field.required ? "*" : "";
@@ -51223,7 +49707,7 @@ function printCompactToolContract(tool, requestedToolId) {
   }
   console.log("");
   printToolExamplesOnly(tool, requestedToolId, { includeSamples: false });
-  const starterScript = isRecord13(contract.starterScript) ? contract.starterScript : {};
+  const starterScript = isRecord9(contract.starterScript) ? contract.starterScript : {};
   const starterPath = stringField2(starterScript, "path");
   if (starterPath) {
     console.log("");
@@ -51237,14 +49721,14 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("Getters:");
     if (listGetters.length) console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord13(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
     }
     if (valueGetters.length) console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord13(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -51343,10 +49827,10 @@ function printToolExamplesOnly(tool, requestedToolId, options = {}) {
     `  input: ${JSON.stringify(sampleInput || {}, null, 2).replace(/\n/g, "\n  ")},`
   );
   console.log("});");
-  const getters = isRecord13(contract.getters) ? contract.getters : {};
+  const getters = isRecord9(contract.getters) ? contract.getters : {};
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
-  const firstGetter = [...valueGetters, ...listGetters].find(isRecord13);
+  const firstGetter = [...valueGetters, ...listGetters].find(isRecord9);
   if (firstGetter) {
     const name = stringField2(firstGetter, "name") || "value";
     const expression = stringField2(firstGetter, "expression");
@@ -51382,7 +49866,7 @@ function printPlayLikeToolUsage(tool, requestedToolId) {
 }
 function printToolGettersOnly(tool, requestedToolId) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const getters = isRecord13(contract.getters) ? contract.getters : {};
+  const getters = isRecord9(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   console.log(`Getters: ${contract.toolId}`);
@@ -51395,7 +49879,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (listGetters.length) {
     console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord13(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -51404,7 +49888,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (valueGetters.length) {
     console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord13(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -51430,7 +49914,7 @@ function sampleValueForField(field) {
 function samplePayloadForInputFields(fields2) {
   return Object.fromEntries(
     fields2.slice(0, 4).flatMap((field) => {
-      if (!isRecord13(field)) return [];
+      if (!isRecord9(field)) return [];
       const name = stringField2(field, "name");
       if (!name) return [];
       return [[name, sampleValueForField(field)]];
@@ -51560,8 +50044,8 @@ function formatListedToolCost(tool) {
 }
 function toolInputFieldsForDisplay(inputSchema) {
   if (Array.isArray(inputSchema.fields)) {
-    const fields2 = inputSchema.fields.filter(isRecord13);
-    if (!isRecord13(inputSchema.jsonSchema)) return fields2;
+    const fields2 = inputSchema.fields.filter(isRecord9);
+    if (!isRecord9(inputSchema.jsonSchema)) return fields2;
     const jsonSchemaFields = new Map(
       recursiveToolInputFieldsForDisplay({
         jsonSchema: inputSchema.jsonSchema
@@ -51573,26 +50057,26 @@ function toolInputFieldsForDisplay(inputSchema) {
       const jsonSchemaField = typeof field.name === "string" ? jsonSchemaFields.get(field.name) : void 0;
       const minItems = typeof field.minItems === "number" ? field.minItems : jsonSchemaField?.minItems;
       const maxItems = typeof field.maxItems === "number" ? field.maxItems : jsonSchemaField?.maxItems;
-      const items = isRecord13(field.items) ? field.items : jsonSchemaField?.items;
+      const items = isRecord9(field.items) ? field.items : jsonSchemaField?.items;
       return {
         ...field,
-        ...isRecord13(items) ? { items } : {},
+        ...isRecord9(items) ? { items } : {},
         ...typeof minItems === "number" ? { minItems } : {},
         ...typeof maxItems === "number" ? { maxItems } : {}
       };
     });
   }
-  const jsonSchema = isRecord13(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
-  const properties = isRecord13(jsonSchema.properties) ? jsonSchema.properties : {};
+  const jsonSchema = isRecord9(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  const properties = isRecord9(jsonSchema.properties) ? jsonSchema.properties : {};
   const required = Array.isArray(jsonSchema.required) ? new Set(jsonSchema.required.map(String)) : /* @__PURE__ */ new Set();
   return Object.entries(properties).map(([name, value]) => {
-    const property = isRecord13(value) ? value : {};
+    const property = isRecord9(value) ? value : {};
     return {
       name,
       type: typeof property.type === "string" ? property.type : "unknown",
       required: required.has(name),
       description: property.description,
-      ...isRecord13(property.items) ? { items: property.items } : {},
+      ...isRecord9(property.items) ? { items: property.items } : {},
       ...typeof property.minItems === "number" ? { minItems: property.minItems } : {},
       ...typeof property.maxItems === "number" ? { maxItems: property.maxItems } : {},
       ...Object.prototype.hasOwnProperty.call(property, "default") ? { default: property.default } : {}
@@ -51609,7 +50093,7 @@ function toolOutputFieldsForDisplay(outputSchema) {
 }
 function printToolOutputArrayShape(tool) {
   const outputFields = toolOutputFieldsForDisplay(
-    recordField2(isRecord13(tool) ? tool : {}, "outputSchema", "output_schema")
+    recordField2(isRecord9(tool) ? tool : {}, "outputSchema", "output_schema")
   );
   if (outputFields.length === 0) return;
   console.log("  Output array shape (declared schema):");
@@ -51624,10 +50108,10 @@ function printToolOutputArrayShape(tool) {
   }
 }
 function canonicalToolJsonSchema(inputSchema) {
-  return isRecord13(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  return isRecord9(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
 }
 function declaredToolJsonSchema(inputSchema) {
-  if (isRecord13(inputSchema.jsonSchema)) {
+  if (isRecord9(inputSchema.jsonSchema)) {
     return inputSchema.jsonSchema;
   }
   return Array.isArray(inputSchema.fields) ? null : inputSchema;
@@ -51652,7 +50136,7 @@ function publicToolInputSchemaForDescribe(inputSchema) {
   };
   const stripDescriptions = (value) => {
     if (Array.isArray(value)) return value.map(stripDescriptions);
-    if (!isRecord13(value)) return value;
+    if (!isRecord9(value)) return value;
     return Object.fromEntries(
       Object.entries(value).flatMap(([key, nested]) => {
         if (key === "description" && typeof nested === "string" && exposesProviderSpend(nested)) {
@@ -51673,7 +50157,7 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
       for (const item of value) collectSchemaIds(item);
       return;
     }
-    if (!isRecord13(value)) return;
+    if (!isRecord9(value)) return;
     if (typeof value.$id === "string" && value.$id.trim()) {
       schemasById.set(value.$id.trim(), value);
     }
@@ -51686,10 +50170,10 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
     let current = root;
     for (const rawSegment of ref.slice(2).split("/")) {
       const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
-      if (!isRecord13(current)) return schema;
+      if (!isRecord9(current)) return schema;
       current = current[segment];
     }
-    return isRecord13(current) ? current : schema;
+    return isRecord9(current) ? current : schema;
   };
   const addField = (field) => {
     const name = typeof field.name === "string" ? field.name : "";
@@ -51704,7 +50188,7 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
     if (ref && activeRefs.has(ref)) return;
     const schema = resolveRef(unresolvedSchema);
     const nextActiveRefs = ref ? /* @__PURE__ */ new Set([...activeRefs, ref]) : activeRefs;
-    const type = Array.isArray(schema.type) ? schema.type.map(String).join("|") : typeof schema.type === "string" ? schema.type : isRecord13(schema.properties) ? "object" : schema.items ? "array" : "unknown";
+    const type = Array.isArray(schema.type) ? schema.type.map(String).join("|") : typeof schema.type === "string" ? schema.type : isRecord9(schema.properties) ? "object" : schema.items ? "array" : "unknown";
     if (path) {
       addField({
         name: path,
@@ -51712,18 +50196,18 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
         required,
         description: schema.description,
         ...Array.isArray(schema.enum) ? { enum: schema.enum } : {},
-        ...isRecord13(schema.items) ? { items: schema.items } : {},
+        ...isRecord9(schema.items) ? { items: schema.items } : {},
         ...typeof schema.minItems === "number" ? { minItems: schema.minItems } : {},
         ...typeof schema.maxItems === "number" ? { maxItems: schema.maxItems } : {},
         ...Object.prototype.hasOwnProperty.call(schema, "default") ? { default: schema.default } : {}
       });
     }
-    const properties = isRecord13(schema.properties) ? schema.properties : {};
+    const properties = isRecord9(schema.properties) ? schema.properties : {};
     const requiredNames = new Set(
       Array.isArray(schema.required) ? schema.required.map(String) : []
     );
     for (const [name, value] of Object.entries(properties)) {
-      if (!isRecord13(value)) continue;
+      if (!isRecord9(value)) continue;
       visit(
         value,
         path ? `${path}.${name}` : name,
@@ -51731,13 +50215,13 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
         nextActiveRefs
       );
     }
-    if (isRecord13(schema.items)) {
+    if (isRecord9(schema.items)) {
       visit(schema.items, `${path}[]`, false, nextActiveRefs);
     }
     for (const keyword of ["anyOf", "oneOf", "allOf"]) {
       const branches = Array.isArray(schema[keyword]) ? schema[keyword] : [];
       for (const branch of branches) {
-        if (isRecord13(branch)) {
+        if (isRecord9(branch)) {
           visit(branch, path, required, nextActiveRefs);
         }
       }
@@ -51747,21 +50231,21 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
   return fields2.size ? [...fields2.values()] : toolInputFieldsForDisplay(inputSchema);
 }
 function inputFieldJsonForDescribe(field) {
-  const publicItems = isRecord13(field.items) ? publicToolInputSchemaForDescribe({ items: field.items }).items : void 0;
+  const publicItems = isRecord9(field.items) ? publicToolInputSchemaForDescribe({ items: field.items }).items : void 0;
   return {
     name: field.name,
     type: field.type ?? "unknown",
     required: Boolean(field.required),
     ...field.description ? { description: field.description } : {},
-    ...isRecord13(publicItems) ? { items: publicItems } : {},
+    ...isRecord9(publicItems) ? { items: publicItems } : {},
     ...typeof field.minItems === "number" ? { minItems: field.minItems } : {},
     ...typeof field.maxItems === "number" ? { maxItems: field.maxItems } : {},
     ...Object.prototype.hasOwnProperty.call(field, "default") ? { default: field.default } : {}
   };
 }
 function arrayItemBoundsSuffix(field) {
-  const itemSchema = isRecord13(field.items) ? field.items : null;
-  const itemType = itemSchema ? typeof itemSchema.type === "string" ? itemSchema.type : isRecord13(itemSchema.properties) ? "object" : "unknown" : null;
+  const itemSchema = isRecord9(field.items) ? field.items : null;
+  const itemType = itemSchema ? typeof itemSchema.type === "string" ? itemSchema.type : isRecord9(itemSchema.properties) ? "object" : "unknown" : null;
   const itemEnum = Array.isArray(itemSchema?.enum) ? ` enum=${itemSchema.enum.map(String).join("|")}` : "";
   const itemTypeSuffix = itemType && itemType !== "unknown" ? ` items=${itemType}${itemEnum}` : "";
   const minItems = typeof field.minItems === "number" && Number.isFinite(field.minItems) ? field.minItems : null;
@@ -51775,13 +50259,13 @@ function arrayItemBoundsSuffix(field) {
 }
 function printToolExecutionHints(value) {
   const batchCapabilityRecord = recordField2(
-    isRecord13(value) ? value : {},
+    isRecord9(value) ? value : {},
     "batchCapability",
     "batch_capability"
   );
   const batchCapability = Object.keys(batchCapabilityRecord).length > 0 ? batchCapabilityRecord : null;
   const executionMetadata = recordField2(
-    isRecord13(value) ? value : {},
+    isRecord9(value) ? value : {},
     "executionMetadata",
     "execution_metadata"
   );
@@ -51821,7 +50305,7 @@ function printToolExecutionHints(value) {
     executionMetadata,
     "configuredRateLimits",
     "configured_rate_limits"
-  ).filter(isRecord13);
+  ).filter(isRecord9);
   if (configuredRateLimits.length > 0) {
     console.log("");
     console.log(
@@ -51886,17 +50370,17 @@ function printJsonPreview(label, payload) {
 }
 function samplePayload(samples, key) {
   const entry = samples[key];
-  if (!isRecord13(entry)) return void 0;
+  if (!isRecord9(entry)) return void 0;
   return Object.prototype.hasOwnProperty.call(entry, "payload") ? entry.payload : entry;
 }
 function commandEnvelopeFromRawResponse(rawResponse) {
-  return isRecord13(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
+  return isRecord9(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
 }
 function toolExecuteExitCode(envelope) {
   return envelope.status === "failed" || envelope.ok === false ? 1 : 0;
 }
 function extractToolExecutionWarningMessages(rawResponse) {
-  if (!isRecord13(rawResponse)) return [];
+  if (!isRecord9(rawResponse)) return [];
   const candidates = [
     recordField2(recordField2(rawResponse, "toolResponse"), "meta"),
     recordField2(
@@ -51913,7 +50397,7 @@ function extractToolExecutionWarningMessages(rawResponse) {
     for (const warning of warnings) {
       if (typeof warning === "string" && warning.trim()) {
         messages.push(warning.trim());
-      } else if (isRecord13(warning)) {
+      } else if (isRecord9(warning)) {
         const message = stringField2(warning, "message");
         if (message) messages.push(message);
       }
@@ -51922,7 +50406,7 @@ function extractToolExecutionWarningMessages(rawResponse) {
   return [...new Set(messages)];
 }
 function apifySyncRecoveryNext(rawResponse) {
-  if (!isRecord13(rawResponse) || rawResponse.status !== "running") return null;
+  if (!isRecord9(rawResponse) || rawResponse.status !== "running") return null;
   const toolResponse = recordField2(rawResponse, "toolResponse");
   const raw = recordField2(toolResponse, "raw");
   if (raw.state !== "awaiting_apify") return null;
@@ -51945,7 +50429,7 @@ function apifySyncRecoveryNext(rawResponse) {
 }
 function listExtractorPathsFromUsageGuidance(tool) {
   const toolExecutionResult = tool.usageGuidance?.toolExecutionResult;
-  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord13(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
+  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord9(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
   return extractedLists.flatMap((entry) => {
     const paths = entry.details?.candidatePaths ?? entry.details?.rawToolOutputPaths;
     if (!Array.isArray(paths)) return [];
@@ -51961,7 +50445,7 @@ function formatDecimal(value) {
 function formatUsd(value) {
   return `$${formatDecimal(value)}`;
 }
-function isRecord13(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringField2(source, ...keys) {
@@ -51988,7 +50472,7 @@ function arrayField2(source, ...keys) {
 function recordField2(source, ...keys) {
   for (const key of keys) {
     const value = source[key];
-    if (isRecord13(value)) return value;
+    if (isRecord9(value)) return value;
   }
   return {};
 }
@@ -52054,7 +50538,7 @@ function parseJsonObjectArgument(raw, flagName) {
     }
     throw invalidJsonError(flagName, message);
   }
-  if (!isRecord13(parsed)) {
+  if (!isRecord9(parsed)) {
     throw invalidJsonError(flagName, "expected an object.");
   }
   return parsed;
@@ -52256,7 +50740,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     kind: summaryEntries.length > 0 ? "object" : "raw",
     summary: input2.summary
   };
-  const envelopeHasCanonicalOutput = isRecord13(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
+  const envelopeHasCanonicalOutput = isRecord9(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
   const envelopeHasDeclaredOutput = Object.prototype.hasOwnProperty.call(
     envelope,
     "output"
@@ -52283,7 +50767,7 @@ function buildToolExecuteBaseEnvelope(input2) {
   return {
     ...envelope,
     ...input2.idempotencyKey ? { idempotency_key: input2.idempotencyKey } : {},
-    ...isRecord13(input2.rawResponse) && isRecord13(input2.rawResponse.executionRecovery) ? { execution_recovery: input2.rawResponse.executionRecovery } : {},
+    ...isRecord9(input2.rawResponse) && isRecord9(input2.rawResponse.executionRecovery) ? { execution_recovery: input2.rawResponse.executionRecovery } : {},
     ...envelopeHasCanonicalOutput || envelopeHasDeclaredOutput ? { output_preview: outputPreview } : { output: outputPreview },
     ...summaryEntries.length > 0 ? { summary: input2.summary } : {},
     ...warningMessages.length > 0 ? { warnings: warningMessages } : {},
@@ -52342,7 +50826,7 @@ function buildToolExecuteRowArtifactEnvelope(input2) {
   void _render;
   void _next;
   void _local;
-  const billingLookup = isRecord13(input2.baseEnvelope.next) && typeof input2.baseEnvelope.next.billing === "string" ? input2.baseEnvelope.next.billing : null;
+  const billingLookup = isRecord9(input2.baseEnvelope.next) && typeof input2.baseEnvelope.next.billing === "string" ? input2.baseEnvelope.next.billing : null;
   return {
     ...base,
     status: typeof base.status === "string" ? base.status : "completed",
@@ -52518,7 +51002,7 @@ async function executeTool(args) {
         {
           ...baseEnvelope,
           local: {
-            ...isRecord13(baseEnvelope.local) ? baseEnvelope.local : {},
+            ...isRecord9(baseEnvelope.local) ? baseEnvelope.local : {},
             payload_file: jsonPath
           }
         },
@@ -52832,7 +51316,7 @@ var PLAY_EQUIVALENT = {
   schema: "deepline plays describe <name>",
   runs: "deepline runs list --play <name>",
   run: "deepline runs get <run-id>",
-  tail: "deepline runs tail <run-id>",
+  tail: "deepline runs watch <run-id>",
   cancel: "deepline runs stop <run-id>",
   delete: "deepline plays delete <name>"
 };