deepline 0.1.20 → 0.1.22

package/dist/cli/index.mjs

@@ -243,7 +243,7 @@ function saveProjectDeeplineEnvValues(baseUrl, values, startDir = projectEnvStar
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.20";
+var SDK_VERSION = "0.1.22";
 var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
@@ -326,7 +326,7 @@ var HttpClient = class {
           const response = await fetch(candidateUrl, {
             method,
             headers,
-            body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
+            body: options?.formData !== void 0 ? options.formData : options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
             signal: controller.signal
           });
           clearTimeout(timeoutId);
@@ -445,6 +445,13 @@ var HttpClient = class {
       headers
     });
   }
+  async postFormData(path, formData, headers) {
+    return this.request(path, {
+      method: "POST",
+      formData,
+      headers
+    });
+  }
   /**
    * Send a DELETE request.
    *
@@ -528,7 +535,7 @@ function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function normalizePlayStatus(raw) {
-  const status = typeof raw.status === "string" ? raw.status : typeof raw.temporalStatus === "string" ? mapLegacyTemporalStatus(raw.temporalStatus) : "running";
+  const status = typeof raw.status === "string" ? raw.status : "running";
   const runId = typeof raw.runId === "string" ? raw.runId : typeof raw.workflowId === "string" ? raw.workflowId : "";
   return {
     ...raw,
@@ -536,22 +543,86 @@ function normalizePlayStatus(raw) {
     status
   };
 }
-function mapLegacyTemporalStatus(status) {
-  switch (status.trim().toUpperCase()) {
-    case "PENDING":
-      return "queued";
-    case "COMPLETED":
-      return "completed";
-    case "FAILED":
-      return "failed";
-    case "CANCELLED":
-    case "TERMINATED":
-    case "TIMED_OUT":
-      return "cancelled";
-    case "RUNNING":
-    default:
-      return "running";
+function decodeBase64Bytes(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+function readStringArray(value) {
+  return Array.isArray(value) ? value.filter((line) => typeof line === "string") : [];
+}
+function getPlayLiveEventPayload(event) {
+  return event.payload && typeof event.payload === "object" ? event.payload : {};
+}
+function normalizeLiveStatus(value) {
+  if (value === "queued" || value === "running" || value === "waiting" || value === "completed" || value === "failed" || value === "cancelled") {
+    return value;
+  }
+  return null;
+}
+function updatePlayLiveStatusState(state, event) {
+  const payload = getPlayLiveEventPayload(event);
+  if (event.type === "play.run.log") {
+    state.logs.push(...readStringArray(payload.lines));
+    return null;
+  }
+  if (event.type !== "play.run.snapshot" && event.type !== "play.run.status" && event.type !== "play.run.final_status") {
+    return null;
+  }
+  const runId = typeof payload.runId === "string" && payload.runId ? payload.runId : state.runId;
+  const status = normalizeLiveStatus(payload.status) ?? state.status;
+  const logs = readStringArray(payload.logs);
+  if (logs.length > 0 || event.type === "play.run.snapshot") {
+    state.logs = logs;
+  }
+  if ("result" in payload) {
+    state.result = payload.result;
+  }
+  if (typeof payload.error === "string" && payload.error.trim()) {
+    state.error = payload.error;
   }
+  state.runId = runId;
+  state.status = status;
+  const progressRecord = payload.progress && typeof payload.progress === "object" && !Array.isArray(payload.progress) ? payload.progress : {};
+  const next = {
+    ...payload,
+    runId,
+    status,
+    progress: {
+      ...progressRecord,
+      status: typeof progressRecord.status === "string" ? progressRecord.status : status,
+      logs: state.logs,
+      ...state.error ? { error: state.error } : {}
+    },
+    ..."result" in state ? { result: state.result } : {}
+  };
+  state.latest = next;
+  return next;
+}
+function playRunResultFromStatus(status, startedAt, fallbackRunId) {
+  return {
+    success: status.status === "completed",
+    runId: status.runId || fallbackRunId,
+    result: status.result,
+    logs: status.progress?.logs ?? [],
+    durationMs: Date.now() - startedAt,
+    error: status.progress?.error ?? (status.status !== "completed" ? status.status : void 0)
+  };
+}
+function playRunStatusFromState(state) {
+  return {
+    runId: state.runId,
+    status: state.status,
+    progress: {
+      status: state.status,
+      logs: state.logs,
+      ...state.error ? { error: state.error } : {}
+    },
+    ..."result" in state ? { result: state.result } : {}
+  };
 }
 var DeeplineClient = class {
   http;
@@ -662,7 +733,7 @@ var DeeplineClient = class {
   /**
    * Search available tools using Deepline's ranked backend search.
    *
-   * This is the same discovery surface used by the legacy CLI: it ranks across
+   * This is the same discovery surface used by the CLI: it ranks across
    * tool metadata, categories, agent guidance, and input schema fields.
    */
   async searchTools(options = {}) {
@@ -755,7 +826,7 @@ var DeeplineClient = class {
    * `progress.logs`; they are not part of the user output object.
    *
    * @param request - Play run configuration (name, code, input, etc.)
-   * @returns Workflow metadata including the `workflowId` for status polling
+   * @returns Run metadata including the public `workflowId`
    *
    * @example
    * ```typescript
@@ -1004,9 +1075,34 @@ var DeeplineClient = class {
    * ```
    */
   async stagePlayFiles(files) {
-    const response = await this.http.post(
+    const formData = new FormData();
+    formData.set(
+      "metadata",
+      JSON.stringify({
+        files: files.map((file, index) => ({
+          index,
+          logicalPath: file.logicalPath,
+          contentHash: file.contentHash,
+          contentType: file.contentType,
+          bytes: file.bytes
+        }))
+      })
+    );
+    for (const [index, file] of files.entries()) {
+      const bytes = decodeBase64Bytes(file.contentBase64);
+      const body = bytes.buffer.slice(
+        bytes.byteOffset,
+        bytes.byteOffset + bytes.byteLength
+      );
+      formData.set(
+        `file:${index}`,
+        new Blob([body], { type: file.contentType }),
+        file.logicalPath
+      );
+    }
+    const response = await this.http.postFormData(
       "/api/v2/plays/files/stage",
-      { files }
+      formData
     );
     return response.files;
   }
@@ -1022,9 +1118,6 @@ var DeeplineClient = class {
    * Internal/advanced primitive. Public callers should usually prefer
    * {@link runPlay}, {@link PlayJob.get}, or `deepline play run --watch`.
    *
-   * Poll this method until `status` reaches a terminal state:
-   * `'completed'`, `'failed'`, or `'cancelled'`.
-   *
    * @param workflowId - Play-run id from {@link startPlayRun}
    * @returns Current status with progress logs and partial results
    *
@@ -1035,41 +1128,22 @@ var DeeplineClient = class {
    * console.log(`Logs: ${status.progress?.logs.length ?? 0} lines`);
    * ```
    */
-  async getPlayStatus(workflowId) {
-    const response = await this.http.get(
-      `/api/v2/plays/run/${encodeURIComponent(workflowId)}`
-    );
-    return normalizePlayStatus(response);
-  }
-  /**
-   * Get the lightweight tail-polling status for a play execution.
-   *
-   * This is intentionally smaller than {@link getPlayStatus}: it returns the
-   * fields needed for CLI log tailing while the run is in flight, without
-   * forcing the API to rebuild final result views on every poll. Call
-   * {@link getPlayStatus} once after a terminal state for the full result.
-   */
-  async getPlayTailStatus(workflowId, options) {
-    const params = new URLSearchParams({ mode: "tail" });
-    if (typeof options?.afterLogIndex === "number") {
-      params.set("afterLogIndex", String(options.afterLogIndex));
-    }
-    if (typeof options?.waitMs === "number") {
-      params.set("waitMs", String(options.waitMs));
-    }
-    if (options?.terminalOnly) {
-      params.set("terminalOnly", "true");
+  async getPlayStatus(workflowId, options) {
+    const params = new URLSearchParams();
+    if (options?.billing === false) {
+      params.set("billing", "false");
     }
+    const query = params.size > 0 ? `?${params.toString()}` : "";
     const response = await this.http.get(
-      `/api/v2/plays/run/${encodeURIComponent(workflowId)}?${params.toString()}`
+      `/api/v2/plays/run/${encodeURIComponent(workflowId)}${query}`
     );
     return normalizePlayStatus(response);
   }
   /**
    * Stream semantic play-run events using the same SSE feed as the dashboard.
    *
-   * Consumers should still keep a polling fallback: SSE is the fast live-update
-   * transport, while the status endpoints remain the authoritative recovery path.
+   * The server emits a canonical `play.run.snapshot` event first for every
+   * connection, then incremental live events until terminal state or reconnect.
    */
   async *streamPlayRunEvents(workflowId, options) {
     const headers = options?.lastEventId && options.lastEventId.trim() ? { "Last-Event-ID": options.lastEventId.trim() } : void 0;
@@ -1089,7 +1163,7 @@ var DeeplineClient = class {
    *
    * Sends a stop request for the run.
    *
-   * @param workflowId - Temporal workflow ID to cancel
+   * @param workflowId - Public Deepline play-run id to cancel
    *
    * @example
    * ```typescript
@@ -1105,7 +1179,7 @@ var DeeplineClient = class {
   /**
    * Stop a running play execution, including open HITL waits.
    *
-   * @param workflowId - Temporal workflow ID to stop
+   * @param workflowId - Public Deepline play-run id to stop
    * @param options.reason - Optional audit/debug reason
    */
   async stopPlay(workflowId, options) {
@@ -1177,32 +1251,42 @@ var DeeplineClient = class {
     );
     return response.runs ?? [];
   }
-  /**
-   * Fetch the lightweight tail status for a run using the public runs resource model.
-   *
-   * This is the SDK equivalent of:
-   *
-   * ```bash
-   * deepline runs tail <run-id> --json
-   * ```
-   */
+  /** Read the canonical run stream and return the latest run snapshot. */
   async tailRun(runId, options) {
-    const afterLogIndex = typeof options?.afterLogIndex === "number" ? options.afterLogIndex : typeof options?.cursor === "number" ? options.cursor : typeof options?.cursor === "string" && options.cursor.trim() ? Number(options.cursor) : void 0;
-    const params = new URLSearchParams();
-    if (Number.isFinite(afterLogIndex)) {
-      params.set("afterLogIndex", String(Number(afterLogIndex)));
+    const state = {
+      runId,
+      status: "running",
+      logs: [],
+      latest: null
+    };
+    let terminal = false;
+    for await (const event of this.streamPlayRunEvents(runId, {
+      mode: "cli",
+      signal: options?.signal
+    })) {
+      const status = updatePlayLiveStatusState(state, event);
+      if (!status) {
+        continue;
+      }
+      terminal = TERMINAL_PLAY_STATUSES.has(status.status);
+      if (terminal) {
+        break;
+      }
     }
-    if (typeof options?.waitMs === "number") {
-      params.set("waitMs", String(options.waitMs));
+    if (terminal && state.latest) {
+      return await this.getRunStatus(state.latest.runId || runId).catch(
+        () => state.latest ?? playRunStatusFromState(state)
+      );
     }
-    if (options?.terminalOnly) {
-      params.set("terminalOnly", "true");
+    if (state.latest) {
+      return state.latest;
     }
-    const suffix = params.toString() ? `?${params.toString()}` : "";
-    const response = await this.http.get(
-      `/api/v2/runs/${encodeURIComponent(runId)}/tail${suffix}`
+    throw new DeeplineError(
+      `Run stream for ${runId} ended before the initial snapshot.`,
+      void 0,
+      "PLAY_RUN_STREAM_EMPTY",
+      { runId }
     );
-    return normalizePlayStatus(response);
   }
   /**
    * Fetch persisted logs for a run using the public runs resource model.
@@ -1359,11 +1443,11 @@ var DeeplineClient = class {
   // Plays — high-level orchestration
   // ——————————————————————————————————————————————————————————
   /**
-   * Run a play end-to-end: submit, poll until terminal, return result.
+   * Run a play end-to-end: submit, stream until terminal, return result.
    *
    * This is the highest-level play execution method. It submits the play,
-   * polls for status updates, and returns a structured result with logs
-   * and timing. Supports cancellation via `AbortSignal`.
+   * reads the canonical run stream 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`
    * @param csvPath - Input CSV path, or `null`
@@ -1379,7 +1463,6 @@ var DeeplineClient = class {
    *     const logs = status.progress?.logs ?? [];
    *     console.log(`[${status.status}] ${logs.length} log lines`);
    *   },
-   *   pollIntervalMs: 1000,
    * });
    *
    * if (result.success) {
@@ -1410,33 +1493,53 @@ var DeeplineClient = class {
       packagedFiles: options?.packagedFiles,
       force: options?.force
     });
-    const pollInterval = options?.pollIntervalMs ?? 500;
     const start = Date.now();
-    while (true) {
+    const state = {
+      runId: workflowId,
+      status: "running",
+      logs: [],
+      latest: null
+    };
+    if (options?.signal?.aborted) {
+      await this.cancelPlay(workflowId);
+      return {
+        success: false,
+        runId: workflowId,
+        logs: [],
+        durationMs: Date.now() - start,
+        error: "Cancelled by user"
+      };
+    }
+    for await (const event of this.streamPlayRunEvents(workflowId, {
+      mode: "cli",
+      signal: options?.signal
+    })) {
       if (options?.signal?.aborted) {
         await this.cancelPlay(workflowId);
         return {
           success: false,
           runId: workflowId,
-          logs: [],
+          logs: state.logs,
           durationMs: Date.now() - start,
           error: "Cancelled by user"
         };
       }
-      const status = await this.getPlayStatus(workflowId);
+      const status = updatePlayLiveStatusState(state, event);
+      if (!status) {
+        continue;
+      }
       options?.onProgress?.(status);
       if (TERMINAL_PLAY_STATUSES.has(status.status)) {
-        return {
-          success: status.status === "completed",
-          runId: status.runId || workflowId,
-          result: status.result,
-          logs: status.progress?.logs ?? [],
-          durationMs: Date.now() - start,
-          error: status.progress?.error ?? (status.status !== "completed" ? status.status : void 0)
-        };
+        const finalStatus = await this.getPlayStatus(status.runId || workflowId).catch(() => status);
+        return playRunResultFromStatus(finalStatus, start, workflowId);
       }
-      await new Promise((resolve8) => setTimeout(resolve8, pollInterval));
     }
+    throw new DeeplineError(
+      `Run stream for ${workflowId} ended before the run reached a terminal state.`,
+      void 0,
+      "PLAY_RUN_STREAM_ENDED",
+      { runId: workflowId, workflowId }
+    );
   }
   // ——————————————————————————————————————————————————————————
   // Health
@@ -1510,18 +1613,24 @@ async function enforceSdkCompatibility(baseUrl) {
 }
 
 // src/cli/commands/auth.ts
-import { writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
 import { hostname } from "os";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 
 // src/cli/utils.ts
-import { readFileSync as readFileSync2 } from "fs";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
 import { mkdir, writeFile } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join2, resolve as resolve2 } from "path";
-import { execSync } from "child_process";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import { execFileSync, spawnSync } from "child_process";
 import { parse } from "csv-parse/sync";
 import { stringify } from "csv-stringify/sync";
+var BROWSER_FOCUS_COOLDOWN_MS = 3e4;
 function getAuthedHttpClient() {
   const config = resolveConfig();
   return { config, http: new HttpClient(config) };
@@ -1533,12 +1642,215 @@ async function writeOutputFile(filename, content) {
   await writeFile(fullPath, content, "utf-8");
   return fullPath;
 }
+function browserFocusStateFile() {
+  const homeDir = process.env.HOME || homedir2();
+  return join2(
+    homeDir,
+    ".local",
+    "deepline",
+    "runtime",
+    "state",
+    "browser-focus.json"
+  );
+}
+function claimBrowserFocus(now = Date.now()) {
+  const statePath = browserFocusStateFile();
+  try {
+    mkdirSync2(dirname2(statePath), { recursive: true });
+    let lastFocusedAt = 0;
+    if (existsSync2(statePath)) {
+      const payload = JSON.parse(readFileSync2(statePath, "utf-8"));
+      const value = payload.lastFocusedAt ?? payload.last_focused_at;
+      if (typeof value === "number" && Number.isFinite(value)) {
+        lastFocusedAt = value;
+      }
+    }
+    if (lastFocusedAt > now) {
+      lastFocusedAt = 0;
+    }
+    if (now - lastFocusedAt < BROWSER_FOCUS_COOLDOWN_MS) {
+      return false;
+    }
+    writeFileSync2(statePath, JSON.stringify({ lastFocusedAt: now }), "utf-8");
+    return true;
+  } catch {
+    return true;
+  }
+}
+function extractUrlHost(raw) {
+  try {
+    const parsed = new URL(raw.includes("://") ? raw : `https://${raw}`);
+    return parsed.port ? `${parsed.hostname.toLowerCase()}:${parsed.port}` : parsed.hostname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function browserAppNameFromBundleId(bundleId) {
+  const names = {
+    "com.google.chrome": "Google Chrome",
+    "com.google.chrome.canary": "Google Chrome Canary",
+    "com.microsoft.edgemac": "Microsoft Edge",
+    "com.brave.browser": "Brave Browser",
+    "com.operasoftware.opera": "Opera",
+    "com.operasoftware.operagx": "Opera GX",
+    "com.vivaldi.vivaldi": "Vivaldi",
+    "company.thebrowser.browser": "Arc",
+    "com.apple.safari": "Safari"
+  };
+  return names[bundleId.toLowerCase()] ?? "";
+}
+function readDefaultMacBrowserBundleId() {
+  try {
+    const output = execFileSync(
+      "/usr/bin/defaults",
+      [
+        "read",
+        `${homedir2()}/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist`,
+        "LSHandlers"
+      ],
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    );
+    const httpsMatch = output.match(
+      /LSHandlerURLScheme\s*=\s*https;[\s\S]*?LSHandlerRole(?:All|Viewer|Editor)\s*=\s*"([^"]+)"/
+    );
+    const httpMatch = output.match(
+      /LSHandlerURLScheme\s*=\s*http;[\s\S]*?LSHandlerRole(?:All|Viewer|Editor)\s*=\s*"([^"]+)"/
+    );
+    return (httpsMatch?.[1] ?? httpMatch?.[1] ?? "").trim();
+  } catch {
+    return "";
+  }
+}
+function browserStrategyForBundleId(bundleId) {
+  const normalized = bundleId.toLowerCase();
+  if ((/* @__PURE__ */ new Set([
+    "com.google.chrome",
+    "com.google.chrome.canary",
+    "com.microsoft.edgemac",
+    "com.brave.browser",
+    "com.operasoftware.opera",
+    "com.operasoftware.operagx",
+    "com.vivaldi.vivaldi",
+    "company.thebrowser.browser"
+  ])).has(normalized)) {
+    return "chromium";
+  }
+  return normalized === "com.apple.safari" ? "safari" : "fallback";
+}
+function runAppleScript(script, args) {
+  const result = spawnSync("osascript", ["-", ...args], {
+    input: script,
+    encoding: "utf-8",
+    stdio: ["pipe", "ignore", "ignore"],
+    timeout: 5e3
+  });
+  return result.status === 0;
+}
+function retargetChromiumMacos(appName, targetUrl, allowFocus) {
+  const host = extractUrlHost(targetUrl);
+  if (!host) return false;
+  const escapedAppName = appName.replace(/"/g, '\\"');
+  const activateBlock = allowFocus ? "    activate\n" : "";
+  const foundTabBlock = allowFocus ? "          set active tab index of w to i\n          set index of w to 1\n          set URL of t to targetUrl\n" : "          set URL of t to targetUrl\n";
+  const newTabBlock = allowFocus ? "      tell window 1\n        make new tab with properties {URL:targetUrl}\n        set active tab index to (count of tabs)\n        set index to 1\n      end tell\n" : "      tell window 1\n        make new tab with properties {URL:targetUrl}\n      end tell\n";
+  const script = `
+on run argv
+  set targetUrl to item 1 of argv
+  set targetHost to item 2 of argv
+  tell application "${escapedAppName}"
+${activateBlock}    if (count of windows) is 0 then
+      make new window
+    end if
+    set foundTab to false
+    repeat with w in windows
+      set tabCount to count of tabs of w
+      repeat with i from 1 to tabCount
+        set t to tab i of w
+        if (URL of t) contains targetHost then
+${foundTabBlock}          set foundTab to true
+          exit repeat
+        end if
+      end repeat
+      if foundTab then exit repeat
+    end repeat
+    if not foundTab then
+${newTabBlock}    end if
+  end tell
+end run
+`;
+  return runAppleScript(script, [targetUrl, host]);
+}
+function retargetSafariMacos(appName, targetUrl, allowFocus) {
+  const host = extractUrlHost(targetUrl);
+  if (!host) return false;
+  const escapedAppName = appName.replace(/"/g, '\\"');
+  const activateBlock = allowFocus ? "    activate\n" : "";
+  const foundTabBlock = allowFocus ? "          set current tab of w to t\n          set index of w to 1\n          set URL of t to targetUrl\n" : "          set URL of t to targetUrl\n";
+  const newTabBlock = allowFocus ? "      tell window 1\n        set current tab to (make new tab with properties {URL:targetUrl})\n        set index to 1\n      end tell\n" : "      tell window 1\n        make new tab with properties {URL:targetUrl}\n      end tell\n";
+  const script = `
+on run argv
+  set targetUrl to item 1 of argv
+  set targetHost to item 2 of argv
+  tell application "${escapedAppName}"
+${activateBlock}    if (count of windows) is 0 then
+      make new document
+    end if
+    set foundTab to false
+    repeat with w in windows
+      set tabCount to count of tabs of w
+      repeat with i from 1 to tabCount
+        set t to tab i of w
+        if (URL of t) contains targetHost then
+${foundTabBlock}          set foundTab to true
+          exit repeat
+        end if
+      end repeat
+      if foundTab then exit repeat
+    end repeat
+    if not foundTab then
+${newTabBlock}    end if
+  end tell
+end run
+`;
+  return runAppleScript(script, [targetUrl, host]);
+}
+function openUrlMacos(targetUrl, allowFocus) {
+  const defaultBundleId = readDefaultMacBrowserBundleId();
+  const appName = defaultBundleId ? browserAppNameFromBundleId(defaultBundleId) : "";
+  const strategy = browserStrategyForBundleId(defaultBundleId);
+  if (appName && strategy === "chromium" && retargetChromiumMacos(appName, targetUrl, allowFocus)) {
+    return true;
+  }
+  if (appName && strategy === "safari" && retargetSafariMacos(appName, targetUrl, allowFocus)) {
+    return true;
+  }
+  if (!allowFocus) {
+    return false;
+  }
+  try {
+    execFileSync("open", [targetUrl], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function openInBrowser(url) {
   try {
-    if (process.platform === "darwin") execSync(`open "${url}"`, { stdio: "ignore" });
-    else if (process.platform === "win32")
-      execSync(`start "" "${url}"`, { stdio: "ignore" });
-    else execSync(`xdg-open "${url}"`, { stdio: "ignore" });
+    const targetUrl = String(url || "").trim();
+    if (!targetUrl) return;
+    const allowFocus = claimBrowserFocus();
+    if (process.platform === "darwin") {
+      openUrlMacos(targetUrl, allowFocus);
+      return;
+    }
+    if (!allowFocus) return;
+    if (process.platform === "win32") {
+      execFileSync("cmd.exe", ["/c", "start", "", targetUrl], {
+        stdio: "ignore"
+      });
+      return;
+    }
+    execFileSync("xdg-open", [targetUrl], { stdio: "ignore" });
   } catch {
   }
 }
@@ -1622,14 +1934,14 @@ function envFilePath(baseUrl) {
 }
 function saveEnvValues(values, baseUrl) {
   const filePath = envFilePath(baseUrl);
-  const dir = dirname2(filePath);
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = dirname3(filePath);
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
-  const existing = existsSync2(filePath) ? parseEnvFile(filePath) : {};
+  const existing = existsSync3(filePath) ? parseEnvFile(filePath) : {};
   const merged = { ...existing, ...values };
   const lines = Object.entries(merged).filter(([, v]) => v !== "").map(([k, v]) => `${k}=${v}`);
-  writeFileSync2(filePath, lines.join("\n") + "\n", "utf-8");
+  writeFileSync3(filePath, lines.join("\n") + "\n", "utf-8");
   saveProjectDeeplineEnvValues(baseUrl, values);
 }
 async function httpJson(method, url, apiKey, body) {
@@ -2168,7 +2480,7 @@ function registerBillingCommands(program) {
 }
 
 // src/cli/dataset-stats.ts
-import { writeFileSync as writeFileSync3 } from "fs";
+import { writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve3 } from "path";
 var CSV_PROJECTED_FIELDS_KEY = "__deeplineCsvProjectedFields";
 function csvProjectedFields(row) {
@@ -2500,7 +2812,7 @@ function writeCanonicalRowsCsv(rowsInfo, outPath) {
     columns: rowsInfo.columns
   });
   const resolved = resolve3(outPath);
-  writeFileSync3(
+  writeFileSync4(
     resolved,
     csvStringFromRows(sanitized.rows, sanitized.columns),
     "utf-8"
@@ -2793,25 +3105,25 @@ function registerOrgCommands(program) {
 // src/cli/commands/play.ts
 import { createHash as createHash3 } from "crypto";
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   readFileSync as readFileSync3,
   readdirSync,
   realpathSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
-import { basename as basename3, dirname as dirname6, join as join6, resolve as resolve7 } from "path";
+import { basename as basename3, dirname as dirname7, join as join6, resolve as resolve7 } from "path";
 
 // src/plays/bundle-play-file.ts
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname5, join as join5, resolve as resolve6 } from "path";
+import { dirname as dirname6, join as join5, resolve as resolve6 } from "path";
 import { fileURLToPath } from "url";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 
 // ../shared_libs/plays/bundling/index.ts
 import { createHash } from "crypto";
 import { mkdir as mkdir2, readFile, realpath, stat, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir } from "os";
-import { basename, dirname as dirname3, extname, isAbsolute, join as join3, resolve as resolve4 } from "path";
+import { basename, dirname as dirname4, extname, isAbsolute, join as join3, resolve as resolve4 } from "path";
 import { builtinModules, createRequire } from "module";
 import { build } from "esbuild";
 
@@ -2910,7 +3222,7 @@ async function normalizeLocalPath(filePath) {
 function createPlayWorkspace(entryFile) {
   return {
     entryFile,
-    rootDir: dirname3(entryFile)
+    rootDir: dirname4(entryFile)
   };
 }
 function isPathInsideDirectory(filePath, directory) {
@@ -3111,7 +3423,7 @@ function workersNamedPlayEntryAliasPlugin(playFilePath, exportName) {
           contents: `export { ${exportName} as default } from ${JSON.stringify(playFilePath)};
 `,
           loader: "ts",
-          resolveDir: dirname3(playFilePath)
+          resolveDir: dirname4(playFilePath)
         })
       );
     }
@@ -3275,7 +3587,7 @@ function importedPlayProxyPlugin(importedPlayDependencies) {
         return {
           contents: buildImportedPlayProxyModule(dependency.playName),
           loader: "ts",
-          resolveDir: dirname3(args.path)
+          resolveDir: dirname4(args.path)
         };
       });
     }
@@ -3293,7 +3605,7 @@ async function resolveLocalImport(fromFile, specifier) {
   if (specifier.startsWith("file:")) {
     return normalizeLocalPath(new URL(specifier).pathname);
   }
-  const base = isAbsolute(specifier) ? resolve4(specifier) : resolve4(dirname3(fromFile), specifier);
+  const base = isAbsolute(specifier) ? resolve4(specifier) : resolve4(dirname4(fromFile), specifier);
   const candidates = [base];
   const explicitExtension = extname(base).toLowerCase();
   if (!explicitExtension) {
@@ -3543,7 +3855,7 @@ async function runEsbuildForCjsNode(entryFile, importedPlayDependencies, adapter
     ...namedExportShim ? {
       stdin: {
         contents: namedExportShim,
-        resolveDir: dirname3(entryFile),
+        resolveDir: dirname4(entryFile),
         sourcefile: `${basename(entryFile)}.${exportName}.entry.ts`,
         loader: "ts"
       }
@@ -3799,13 +4111,6 @@ var PLAY_DEDUP_BACKENDS = {
 
 // ../shared_libs/play-runtime/profiles.ts
 var PLAY_EXECUTION_PROFILES = {
-  legacy: {
-    id: "legacy",
-    scheduler: PLAY_SCHEDULER_BACKENDS.temporal,
-    runner: PLAY_RUNTIME_BACKENDS.daytona,
-    dedup: PLAY_DEDUP_BACKENDS.inMemory,
-    label: "Daytona + Temporal (production today)"
-  },
   workers_edge: {
     id: "workers_edge",
     scheduler: PLAY_SCHEDULER_BACKENDS.cfWorkflows,
@@ -3840,7 +4145,7 @@ function resolveExecutionProfile(override) {
 // src/plays/local-file-discovery.ts
 import { createHash as createHash2 } from "crypto";
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import { basename as basename2, dirname as dirname4, extname as extname2, isAbsolute as isAbsolute2, join as join4, relative, resolve as resolve5 } from "path";
+import { basename as basename2, dirname as dirname5, extname as extname2, isAbsolute as isAbsolute2, join as join4, relative, resolve as resolve5 } from "path";
 var SOURCE_EXTENSIONS2 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".json"];
 function sha2562(buffer) {
   return createHash2("sha256").update(buffer).digest("hex");
@@ -4041,7 +4346,7 @@ function isPathInsideDirectory2(filePath, directory) {
   return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute2(relativePath);
 }
 async function resolveLocalImport2(fromFile, specifier) {
-  const base = isAbsolute2(specifier) ? resolve5(specifier) : resolve5(dirname4(fromFile), specifier);
+  const base = isAbsolute2(specifier) ? resolve5(specifier) : resolve5(dirname5(fromFile), specifier);
   const candidates = [base];
   const explicitExtension = extname2(base).toLowerCase();
   if (!explicitExtension) {
@@ -4060,7 +4365,7 @@ async function resolveLocalImport2(fromFile, specifier) {
 }
 async function discoverPackagedLocalFiles(entryFile) {
   const absoluteEntryFile = resolve5(entryFile);
-  const packagingRoot = dirname4(absoluteEntryFile);
+  const packagingRoot = dirname5(absoluteEntryFile);
   const files = /* @__PURE__ */ new Map();
   const unresolved = [];
   const visitedFiles = /* @__PURE__ */ new Set();
@@ -4097,7 +4402,7 @@ async function discoverPackagedLocalFiles(entryFile) {
             message: "Could not resolve this ctx.csv(...) path at submit time. Use a string literal, a top-level const string, or pass a runtime input like input.file."
           });
         } else {
-          const absoluteCsvPath = resolve5(dirname4(absolutePath), resolvedPath);
+          const absoluteCsvPath = resolve5(dirname5(absolutePath), resolvedPath);
           if (isAbsolute2(resolvedPath) || !isPathInsideDirectory2(absoluteCsvPath, packagingRoot)) {
             unresolved.push({
               sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
@@ -4136,14 +4441,14 @@ async function discoverPackagedLocalFiles(entryFile) {
 
 // src/plays/bundle-play-file.ts
 var PLAY_BUNDLE_CACHE_VERSION2 = 26;
-var MODULE_DIR = dirname5(fileURLToPath(import.meta.url));
+var MODULE_DIR = dirname6(fileURLToPath(import.meta.url));
 var SDK_PACKAGE_ROOT = resolve6(MODULE_DIR, "..", "..");
 var SOURCE_REPO_ROOT = resolve6(SDK_PACKAGE_ROOT, "..");
-var HAS_SOURCE_BUNDLING_SOURCES = existsSync3(
+var HAS_SOURCE_BUNDLING_SOURCES = existsSync4(
   resolve6(SOURCE_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
 );
 var PACKAGED_REPO_ROOT = resolve6(SDK_PACKAGE_ROOT, "dist", "repo");
-var HAS_PACKAGED_BUNDLING_SOURCES = existsSync3(
+var HAS_PACKAGED_BUNDLING_SOURCES = existsSync4(
   resolve6(PACKAGED_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
 );
 var PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? SOURCE_REPO_ROOT : HAS_PACKAGED_BUNDLING_SOURCES ? PACKAGED_REPO_ROOT : resolve6(SDK_PACKAGE_ROOT, "..");
@@ -4182,7 +4487,7 @@ function createSdkPlayBundlingAdapter() {
     sdkSourceRoot: SDK_SOURCE_ROOT,
     sdkPackageJson: SDK_PACKAGE_JSON,
     sdkEntryFile: SDK_ENTRY_FILE,
-    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !existsSync3(SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
+    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !existsSync4(SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
     sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
     workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
     workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
@@ -4343,7 +4648,77 @@ function createCliProgress(enabled) {
   return progress;
 }
 
+// src/cli/trace.ts
+var cliTraceStartedAt = Date.now();
+function isTruthyEnv(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+function isCliTraceEnabled() {
+  return isTruthyEnv(process.env.DEEPLINE_CLI_TRACE);
+}
+function recordCliTrace(event) {
+  if (!isCliTraceEnabled()) {
+    return;
+  }
+  const now = Date.now();
+  const payload = {
+    ts: now,
+    source: "cli",
+    sinceStartMs: now - cliTraceStartedAt,
+    ...event
+  };
+  process.stderr.write(`[cli-trace] ${JSON.stringify(payload)}
+`);
+}
+async function traceCliSpan(phase, fields, run) {
+  if (!isCliTraceEnabled()) {
+    return run();
+  }
+  const startedAt = Date.now();
+  try {
+    const result = await run();
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: true,
+      ...fields
+    });
+    return result;
+  } catch (error) {
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      ...fields
+    });
+    throw error;
+  }
+}
+
 // src/cli/commands/play.ts
+function traceCliSync(phase, fields, run) {
+  const startedAt = Date.now();
+  try {
+    const result = run();
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: true,
+      ...fields
+    });
+    return result;
+  } catch (error) {
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      ...fields
+    });
+    throw error;
+  }
+}
 function parseReferencedPlayTarget(target) {
   const trimmed = target.trim();
   const slashIndex = trimmed.indexOf("/");
@@ -4398,15 +4773,15 @@ function materializeRemotePlaySource(input) {
     return null;
   }
   const outputPath = input.outPath ?? defaultMaterializedPlayPath(input.playName);
-  if (existsSync4(outputPath)) {
+  if (existsSync5(outputPath)) {
     const existingSource = readFileSync3(outputPath, "utf-8");
     if (existingSource === input.sourceCode) {
       return { path: outputPath, status: "unchanged", created: false };
     }
-    writeFileSync4(outputPath, input.sourceCode, "utf-8");
+    writeFileSync5(outputPath, input.sourceCode, "utf-8");
     return { path: outputPath, status: "updated", created: false };
   }
-  writeFileSync4(outputPath, input.sourceCode, "utf-8");
+  writeFileSync5(outputPath, input.sourceCode, "utf-8");
   return { path: outputPath, status: "created", created: true };
 }
 function formatLoadedPlayMessage(materializedFile) {
@@ -4451,7 +4826,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return existsSync4(resolve7(target));
+  return existsSync5(resolve7(target));
 }
 function looksLikeFilePath(target) {
   if (target.trim().toLowerCase().startsWith("prebuilt/")) {
@@ -4580,7 +4955,24 @@ function applyCsvShortcutInput(input) {
 function isLocalFilePathValue(value) {
   if (typeof value !== "string" || !value.trim()) return false;
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
-  return existsSync4(resolve7(value));
+  return existsSync5(resolve7(value));
+}
+function inputContainsLocalFilePath(value) {
+  if (isLocalFilePathValue(value)) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.some((entry) => inputContainsLocalFilePath(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).some(
+      (entry) => inputContainsLocalFilePath(entry)
+    );
+  }
+  return false;
+}
+function namedRunNeedsPlayDefinition(input) {
+  return input.revisionSelector === "latest" || getDottedInputValue(input.runtimeInput, "csv") != null || inputContainsLocalFilePath(input.runtimeInput);
 }
 async function stageFileInputArgs(input) {
   const uniqueBindings = [
@@ -4768,7 +5160,7 @@ function formatTimestamp(value) {
 function formatRunLine(run) {
   return `${run.workflowId} ${run.status} ${formatTimestamp(run.startTime)}`;
 }
-function isTransientPlayStatusPollError(error) {
+function isTransientPlayStreamError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
     return error.statusCode >= 500 && error.statusCode < 600;
   }
@@ -4777,12 +5169,6 @@ function isTransientPlayStatusPollError(error) {
     text
   );
 }
-function isTerminalPlayStatusPollError(input) {
-  if (input.error instanceof DeeplineError && input.error.statusCode === 404 && input.hasSeenRun) {
-    return true;
-  }
-  return false;
-}
 var TERMINAL_PLAY_STATUSES2 = /* @__PURE__ */ new Set([
   "completed",
   "failed",
@@ -4848,6 +5234,12 @@ function buildPlayDashboardUrl(baseUrl, playName) {
   const encodedPlayName = encodeURIComponent(playName);
   return `${trimmedBase}/dashboard/plays/${encodedPlayName}`;
 }
+function openPlayDashboard(input) {
+  if (input.jsonOutput || input.noOpen || !input.dashboardUrl) {
+    return;
+  }
+  openInBrowser(input.dashboardUrl);
+}
 function getDashboardUrlFromLiveEvent(event) {
   const dashboardUrl = getEventPayload(event).dashboardUrl;
   return typeof dashboardUrl === "string" && dashboardUrl.trim() ? dashboardUrl.trim() : null;
@@ -4884,6 +5276,68 @@ function assertPlayWaitNotTimedOut(input) {
     );
   }
 }
+async function waitForPlayCompletionByStream(input) {
+  const controller = new AbortController();
+  let timedOut = false;
+  let lastPhase = null;
+  const timeout = input.waitTimeoutMs === null ? null : setTimeout(
+    () => {
+      timedOut = true;
+      controller.abort();
+    },
+    Math.max(1, input.waitTimeoutMs - (Date.now() - input.startedAt))
+  );
+  try {
+    for await (const event of input.client.streamPlayRunEvents(
+      input.workflowId,
+      { signal: controller.signal }
+    )) {
+      assertPlayWaitNotTimedOut({ ...input, lastPhase });
+      const phase = describeLiveEventPhase(event);
+      if (phase) {
+        lastPhase = phase;
+        input.progress.phase(phase);
+      }
+      printPlayLogLines({
+        lines: getLogLinesFromLiveEvent(event),
+        status: null,
+        jsonOutput: input.jsonOutput,
+        emitLogs: input.emitLogs,
+        state: input.state,
+        progress: input.progress
+      });
+      const status = getStatusFromLiveEvent(event);
+      if (status && TERMINAL_PLAY_STATUSES2.has(status)) {
+        const finalStatus = await input.client.getPlayStatus(input.workflowId, {
+          billing: false
+        });
+        if (TERMINAL_PLAY_STATUSES2.has(finalStatus.status)) {
+          return finalStatus;
+        }
+      }
+    }
+  } catch (error) {
+    if (timedOut) {
+      assertPlayWaitNotTimedOut({ ...input, lastPhase });
+    }
+    throw error;
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+  const phaseSuffix = lastPhase && lastPhase.trim() ? ` (last observed phase: ${lastPhase.trim()})` : "";
+  throw new DeeplineError(
+    `Play live stream ended before the run reached a terminal state runId=${input.workflowId}${phaseSuffix}.`,
+    void 0,
+    "PLAY_LIVE_STREAM_ENDED",
+    {
+      runId: input.workflowId,
+      workflowId: input.workflowId,
+      ...lastPhase ? { phase: lastPhase } : {}
+    }
+  );
+}
 async function startAndWaitForPlayCompletionByStream(input) {
   const startedAt = Date.now();
   const state = {
@@ -4894,6 +5348,8 @@ async function startAndWaitForPlayCompletionByStream(input) {
   let timedOut = false;
   let emittedDashboardUrl = false;
   let lastKnownWorkflowId = "";
+  let eventCount = 0;
+  let firstRunIdMs = null;
   let lastPhase = null;
   const timeout = input.waitTimeoutMs === null ? null : setTimeout(
     () => {
@@ -4906,13 +5362,20 @@ async function startAndWaitForPlayCompletionByStream(input) {
     for await (const event of input.client.startPlayRunStream(input.request, {
       signal: controller.signal
     })) {
+      eventCount += 1;
       const eventRunId = getEventPayload(event).runId;
       if (typeof eventRunId === "string" && eventRunId && eventRunId !== "pending") {
         lastKnownWorkflowId = eventRunId;
+        firstRunIdMs ??= Date.now() - startedAt;
       }
       const workflowId = lastKnownWorkflowId || "pending";
       if (workflowId !== "pending" && !emittedDashboardUrl) {
         const dashboardUrl = getDashboardUrlFromLiveEvent(event) ?? buildPlayDashboardUrl(input.client.baseUrl, input.playName);
+        openPlayDashboard({
+          dashboardUrl,
+          jsonOutput: input.jsonOutput,
+          noOpen: input.noOpen
+        });
         if (!input.jsonOutput) {
           writeStartedPlayRun({
             runId: workflowId,
@@ -4946,6 +5409,16 @@ async function startAndWaitForPlayCompletionByStream(input) {
       });
       const finalStatus = getFinalStatusFromLiveEvent(event);
       if (finalStatus) {
+        recordCliTrace({
+          phase: "cli.play_start_stream_terminal",
+          ms: Date.now() - startedAt,
+          ok: true,
+          playName: input.playName,
+          workflowId: finalStatus.runId || lastKnownWorkflowId || null,
+          eventCount,
+          firstRunIdMs,
+          lastPhase
+        });
         return finalStatus;
       }
     }
@@ -4958,21 +5431,31 @@ async function startAndWaitForPlayCompletionByStream(input) {
         lastPhase
       });
     }
-    if (lastKnownWorkflowId && isTransientPlayStatusPollError(error)) {
+    if (lastKnownWorkflowId && isTransientPlayStreamError(error)) {
       if (timeout) {
         clearTimeout(timeout);
       }
       const reason = error instanceof Error ? error.message : String(error);
       if (!input.jsonOutput) {
         process.stderr.write(
-          `[play watch] start stream failed after run ${lastKnownWorkflowId}; falling back to polling (${reason})
+          `[play watch] start stream failed after run ${lastKnownWorkflowId}; reconnecting to run stream (${reason})
 `
         );
       }
-      return waitForPlayCompletionByPolling({
+      recordCliTrace({
+        phase: "cli.play_start_stream_reconnect",
+        ms: Date.now() - startedAt,
+        ok: true,
+        playName: input.playName,
+        workflowId: lastKnownWorkflowId,
+        eventCount,
+        firstRunIdMs,
+        lastPhase,
+        reason
+      });
+      return waitForPlayCompletionByStream({
         client: input.client,
         workflowId: lastKnownWorkflowId,
-        pollIntervalMs: 500,
         jsonOutput: input.jsonOutput,
         emitLogs: input.emitLogs,
         waitTimeoutMs: input.waitTimeoutMs,
@@ -4990,13 +5473,23 @@ async function startAndWaitForPlayCompletionByStream(input) {
   if (lastKnownWorkflowId) {
     if (!input.jsonOutput) {
       input.progress.writeLine(
-        `[play watch] start stream ended after run ${lastKnownWorkflowId}; falling back to polling`
+        `[play watch] start stream ended after run ${lastKnownWorkflowId}; reconnecting to run stream`
       );
     }
-    return waitForPlayCompletionByPolling({
+    recordCliTrace({
+      phase: "cli.play_start_stream_reconnect",
+      ms: Date.now() - startedAt,
+      ok: true,
+      playName: input.playName,
+      workflowId: lastKnownWorkflowId,
+      eventCount,
+      firstRunIdMs,
+      lastPhase,
+      reason: "stream ended before terminal event"
+    });
+    return waitForPlayCompletionByStream({
       client: input.client,
       workflowId: lastKnownWorkflowId,
-      pollIntervalMs: 500,
       jsonOutput: input.jsonOutput,
       emitLogs: input.emitLogs,
       waitTimeoutMs: input.waitTimeoutMs,
@@ -5017,71 +5510,6 @@ async function startAndWaitForPlayCompletionByStream(input) {
     }
   );
 }
-async function waitForPlayCompletionByPolling(input) {
-  let lastTransientPollWarningAt = 0;
-  let hasSeenRun = false;
-  while (true) {
-    assertPlayWaitNotTimedOut(input);
-    let status;
-    try {
-      status = await input.client.getPlayTailStatus(input.workflowId, {
-        afterLogIndex: input.state.lastLogIndex,
-        // Keep the server-side tail wait close to the caller's requested poll
-        // cadence. A long wait makes tiny remote runs look slow whenever the
-        // terminal update lands just after the held request starts.
-        waitMs: Math.max(50, Math.min(input.pollIntervalMs, 1e3))
-      });
-    } catch (error) {
-      if (isTerminalPlayStatusPollError({ error, hasSeenRun })) {
-        throw new DeeplineError(
-          `Play run ${input.workflowId} no longer exists on the server (404). The run was deleted or the backend lost it.`,
-          404,
-          "PLAY_RUN_NOT_FOUND"
-        );
-      }
-      if (!isTransientPlayStatusPollError(error)) {
-        throw error;
-      }
-      const now = Date.now();
-      if (now - lastTransientPollWarningAt >= 3e4) {
-        const message = error instanceof Error ? error.message : String(error);
-        input.progress.writeLine(
-          `[play tail] transient status poll failed; retrying: ${message}`
-        );
-        lastTransientPollWarningAt = now;
-      }
-      await new Promise(
-        (resolvePromise) => setTimeout(resolvePromise, input.pollIntervalMs)
-      );
-      continue;
-    }
-    hasSeenRun = true;
-    const logs = status.progress?.logs ?? [];
-    input.progress.phase(status.status);
-    printPlayLogLines({
-      lines: logs.slice(input.state.lastLogIndex),
-      status,
-      jsonOutput: input.jsonOutput,
-      emitLogs: input.emitLogs,
-      state: input.state,
-      progress: input.progress
-    });
-    if (TERMINAL_PLAY_STATUSES2.has(status.status)) {
-      return status.result !== void 0 ? status : await input.client.getPlayStatus(input.workflowId);
-    }
-    const authoritativeStatus = await input.client.getPlayStatus(
-      input.workflowId
-    );
-    if (TERMINAL_PLAY_STATUSES2.has(authoritativeStatus.status)) {
-      return authoritativeStatus;
-    }
-    if ((status.progress?.logs ?? []).length === input.state.lastLogIndex) {
-      await new Promise(
-        (resolvePromise) => setTimeout(resolvePromise, input.pollIntervalMs)
-      );
-    }
-  }
-}
 function formatInteger(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toLocaleString("en-US") : String(value ?? "-");
 }
@@ -5222,7 +5650,6 @@ function buildRunWarnings(status, rowsInfo) {
 function buildRunNextCommands(runId, rowsInfo) {
   const commands = {
     get: `deepline runs get ${runId} --json`,
-    tail: `deepline runs tail ${runId} --json`,
     stop: `deepline runs stop ${runId} --reason "stale lock" --json`,
     logs: `deepline runs logs ${runId} --out run.log --json`
   };
@@ -5338,10 +5765,9 @@ function normalizeErrorsForEnvelope(status, error) {
 }
 function normalizeLogsForEnvelope(status) {
   const logs = Array.isArray(status.progress?.logs) ? status.progress.logs : [];
-  const offset = typeof status.progress?.logOffset === "number" && Number.isFinite(status.progress.logOffset) ? Math.max(0, Math.trunc(status.progress.logOffset)) : 0;
-  const totalCount = offset + logs.length;
+  const totalCount = logs.length;
   const entries = logs.slice(Math.max(0, logs.length - RUN_LOG_PREVIEW_LIMIT));
-  const firstSequence = entries.length === 0 ? null : offset + logs.length - entries.length + 1;
+  const firstSequence = entries.length === 0 ? null : logs.length - entries.length + 1;
   const lastSequence = totalCount === 0 ? null : totalCount;
   return {
     totalCount,
@@ -5587,7 +6013,6 @@ function writeStartedPlayRun(input) {
     workflowId: input.runId,
     name: input.playName,
     status: input.status ?? "started",
-    statusUrl: input.statusUrl,
     dashboardUrl: input.dashboardUrl
   };
   if (input.jsonOutput) {
@@ -5599,7 +6024,7 @@ function writeStartedPlayRun(input) {
     `Started ${input.playName}`,
     `  run id: ${input.runId}`,
     `  get status: deepline runs get ${input.runId} --json`,
-    `  tail logs: deepline runs tail ${input.runId} --json`,
+    `  logs: deepline runs logs ${input.runId} --json`,
     `  stop run: deepline runs stop ${input.runId} --reason "stale lock" --json`,
     `  result JSON: deepline runs get ${input.runId} --json`
   ];
@@ -5614,7 +6039,7 @@ function writeStartedPlayRun(input) {
   console.log(output);
 }
 function parsePlayRunOptions(args) {
-  const usage = "Usage: deepline plays run <play-name> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n       deepline plays run <play-file.ts> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n       deepline plays run --file <play-file.ts> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n       deepline plays run --name <name> [--input '{...}'] [--live|--latest|--revision-id <id>] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--json] [--<input> value]";
+  const usage = "Usage: deepline plays run <play-name> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n       deepline plays run <play-file.ts> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n       deepline plays run --file <play-file.ts> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n       deepline plays run --name <name> [--input '{...}'] [--live|--latest|--revision-id <id>] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--no-open] [--json] [--<input> value]\nRun `deepline plays run --help` for idempotency, tool call id, and ctx.map guidance.";
   let filePath = null;
   let playName = null;
   let input = null;
@@ -5624,8 +6049,8 @@ function parsePlayRunOptions(args) {
   let jsonOutput = watch ? args.includes("--json") : argsWantJson(args);
   const emitLogs = !jsonOutput || args.includes("--logs");
   const force = args.includes("--force");
+  const noOpen = args.includes("--no-open");
   let outPath = null;
-  let pollIntervalMs = 500;
   let waitTimeoutMs = null;
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
@@ -5657,15 +6082,16 @@ function parsePlayRunOptions(args) {
       outPath = resolve7(args[++index]);
       continue;
     }
-    if ((arg === "--poll-interval-ms" || arg === "--interval-ms") && args[index + 1]) {
-      pollIntervalMs = parsePositiveInteger2(args[++index], arg);
-      continue;
+    if (arg === "--poll-interval-ms" || arg === "--interval-ms") {
+      throw new Error(
+        `${arg} was removed. --watch uses the canonical run stream directly.`
+      );
     }
     if ((arg === "--tail-timeout-ms" || arg === "--timeout-ms") && args[index + 1]) {
       waitTimeoutMs = parsePositiveInteger2(args[++index], arg);
       continue;
     }
-    if (arg === "--json" || arg === "--wait" || arg === "--tail" || arg === "--watch" || arg === "--logs" || arg === "--force") {
+    if (arg === "--json" || arg === "--wait" || arg === "--tail" || arg === "--watch" || arg === "--logs" || arg === "--force" || arg === "--no-open") {
       if (arg === "--watch") {
         continue;
       }
@@ -5734,10 +6160,10 @@ function parsePlayRunOptions(args) {
     watch,
     emitLogs,
     jsonOutput,
-    pollIntervalMs,
     waitTimeoutMs,
     force,
-    outPath
+    outPath,
+    noOpen
   };
 }
 function parsePlayCheckOptions(args) {
@@ -5825,11 +6251,24 @@ async function handleFileBackedRun(options) {
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const absolutePlayPath = resolve7(options.target.path);
   progress.phase("compiling play");
-  const sourceCode = readFileSync3(absolutePlayPath, "utf-8");
+  const sourceCode = traceCliSync(
+    "cli.play_file_read_source",
+    { targetKind: "file" },
+    () => readFileSync3(absolutePlayPath, "utf-8")
+  );
+  const runtimeInput = options.input ? { ...options.input } : {};
   let graph;
   try {
-    graph = await collectBundledPlayGraph(absolutePlayPath);
-    await compileBundledPlayGraphManifests(client, graph);
+    graph = await traceCliSpan(
+      "cli.play_file_bundle_graph",
+      { targetKind: "file" },
+      () => collectBundledPlayGraph(absolutePlayPath)
+    );
+    await traceCliSpan(
+      "cli.play_file_compile_manifests",
+      { targetKind: "file" },
+      () => compileBundledPlayGraphManifests(client, graph)
+    );
     progress.phase("compiled play");
   } catch (error) {
     progress.fail();
@@ -5840,36 +6279,47 @@ async function handleFileBackedRun(options) {
   const playName = bundleResult.playName ?? extractPlayName(sourceCode, absolutePlayPath);
   try {
     progress.phase("publishing imported plays");
-    await publishImportedPlayDependencies(client, graph);
+    await traceCliSpan(
+      "cli.play_file_publish_imports",
+      { targetKind: "file" },
+      () => publishImportedPlayDependencies(client, graph)
+    );
   } catch (error) {
     progress.fail();
     console.error(error instanceof Error ? error.message : String(error));
     return 1;
   }
-  const runtimeInput = options.input ? { ...options.input } : {};
   const packagedFileUploads = bundleResult.packagedFiles.map(
     (file) => stageFile(file.logicalPath, file.absolutePath)
   );
+  const compilerManifest = requireCompilerManifest(bundleResult);
   const fileInputBindings = fileInputBindingsFromStaticPipeline(
-    requireCompilerManifest(bundleResult).staticPipeline
+    compilerManifest.staticPipeline
   );
   applyCsvShortcutInput({
     runtimeInput,
     bindings: fileInputBindings,
     fallbackInputPath: "file"
   });
-  const stagedFileInputs = await stageFileInputArgs({
-    client,
-    runtimeInput,
-    bindings: fileInputBindings,
-    progress
-  });
+  const stagedFileInputs = await traceCliSpan(
+    "cli.play_stage_inputs",
+    {
+      targetKind: "file",
+      bindingCount: fileInputBindings.length
+    },
+    () => stageFileInputArgs({
+      client,
+      runtimeInput,
+      bindings: fileInputBindings,
+      progress
+    })
+  );
   const startRequest = {
     name: playName,
     sourceCode: bundleResult.sourceCode,
     sourceFiles: bundleResult.sourceFiles,
     runtimeArtifact: bundleResult.artifact,
-    compilerManifest: requireCompilerManifest(bundleResult),
+    compilerManifest,
     packagedFileUploads,
     ...Object.keys(runtimeInput).length > 0 ? { input: runtimeInput } : {},
     ...stagedFileInputs.inputFile ? { inputFile: stagedFileInputs.inputFile } : {},
@@ -5878,35 +6328,57 @@ async function handleFileBackedRun(options) {
   };
   if (options.watch) {
     progress.phase("starting run");
-    const finalStatus = await startAndWaitForPlayCompletionByStream({
-      client,
-      request: startRequest,
-      playName,
-      jsonOutput: options.jsonOutput,
-      emitLogs: options.emitLogs,
-      waitTimeoutMs: options.waitTimeoutMs,
-      progress
-    });
-    const exportedPath = exportPlayStatusRows(finalStatus, options.outPath);
+    const finalStatus = await traceCliSpan(
+      "cli.play_start_watch",
+      { targetKind: "file", playName },
+      () => startAndWaitForPlayCompletionByStream({
+        client,
+        request: startRequest,
+        playName,
+        jsonOutput: options.jsonOutput,
+        emitLogs: options.emitLogs,
+        waitTimeoutMs: options.waitTimeoutMs,
+        noOpen: options.noOpen,
+        progress
+      })
+    );
+    const exportedPath = traceCliSync(
+      "cli.play_export_rows",
+      { targetKind: "file", playName },
+      () => exportPlayStatusRows(finalStatus, options.outPath)
+    );
     if (finalStatus.status === "completed") {
       progress.complete();
     } else {
       progress.fail();
     }
-    writePlayResult(finalStatus, options.jsonOutput, { exportedPath });
+    traceCliSync(
+      "cli.play_write_result",
+      { targetKind: "file", playName },
+      () => writePlayResult(finalStatus, options.jsonOutput, { exportedPath })
+    );
     return finalStatus.status === "completed" ? 0 : 1;
   }
   progress.phase("starting run");
-  const started = await client.startPlayRun(startRequest);
+  const started = await traceCliSpan(
+    "cli.play_start_unwatched",
+    { targetKind: "file", playName },
+    () => client.startPlayRun(startRequest)
+  );
   const dashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
-  progress.phase(`loading play on ${dashboardUrl}`);
+  const resolvedDashboardUrl = started.dashboardUrl ?? dashboardUrl;
+  openPlayDashboard({
+    dashboardUrl: resolvedDashboardUrl,
+    jsonOutput: options.jsonOutput,
+    noOpen: options.noOpen
+  });
+  progress.phase(`loading play on ${resolvedDashboardUrl}`);
   progress.complete();
   writeStartedPlayRun({
     runId: started.workflowId,
     playName,
     status: started.status,
-    statusUrl: started.statusUrl,
-    dashboardUrl: started.dashboardUrl ?? dashboardUrl,
+    dashboardUrl: resolvedDashboardUrl,
     jsonOutput: options.jsonOutput,
     progress
   });
@@ -5932,32 +6404,67 @@ async function handleNamedRun(options) {
   }
   const client = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  progress.phase("loading play definition");
-  const playDetail = await assertCanonicalNamedPlayReference(client, options.target.name);
-  progress.phase("selecting revision");
-  const selectedRevisionId = await resolveNamedRunRevisionId({
-    client,
-    playName: options.target.name,
-    revisionId: options.revisionId,
-    selector: options.revisionSelector
-  });
+  const playName = options.target.name;
   const runtimeInput = options.input ? { ...options.input } : {};
-  const fileInputBindings = [
+  const needsPlayDefinition = namedRunNeedsPlayDefinition({
+    runtimeInput,
+    revisionSelector: options.revisionSelector
+  });
+  const playDetail = needsPlayDefinition ? await (async () => {
+    progress.phase("loading play definition");
+    return traceCliSpan(
+      "cli.play_load_definition",
+      { targetKind: "name", playName, skipped: false },
+      () => assertCanonicalNamedPlayReference(client, playName)
+    );
+  })() : (recordCliTrace({
+    phase: "cli.play_load_definition",
+    ms: 0,
+    ok: true,
+    targetKind: "name",
+    playName,
+    skipped: true
+  }), null);
+  progress.phase("selecting revision");
+  const selectedRevisionId = await traceCliSpan(
+    "cli.play_select_revision",
+    {
+      targetKind: "name",
+      playName,
+      selector: options.revisionSelector,
+      hasExplicitRevisionId: Boolean(options.revisionId)
+    },
+    () => resolveNamedRunRevisionId({
+      client,
+      playName,
+      revisionId: options.revisionId,
+      selector: options.revisionSelector
+    })
+  );
+  const fileInputBindings = playDetail ? [
     ...fileInputBindingsFromPlaySchema(playDetail.play.inputSchema),
     ...fileInputBindingsFromStaticPipeline(playDetail.play.staticPipeline)
-  ];
+  ] : [];
   applyCsvShortcutInput({
     runtimeInput,
     bindings: fileInputBindings
   });
-  const stagedFileInputs = await stageFileInputArgs({
-    client,
-    runtimeInput,
-    bindings: fileInputBindings,
-    progress
-  });
+  const stagedFileInputs = await traceCliSpan(
+    "cli.play_stage_inputs",
+    {
+      targetKind: "name",
+      playName,
+      bindingCount: fileInputBindings.length
+    },
+    () => stageFileInputArgs({
+      client,
+      runtimeInput,
+      bindings: fileInputBindings,
+      progress
+    })
+  );
   const startRequest = {
-    name: options.target.name,
+    name: playName,
     ...selectedRevisionId ? { revisionId: selectedRevisionId } : {},
     ...Object.keys(runtimeInput).length > 0 ? { input: runtimeInput } : {},
     ...stagedFileInputs.inputFile ? { inputFile: stagedFileInputs.inputFile } : {},
@@ -5966,38 +6473,60 @@ async function handleNamedRun(options) {
   };
   if (options.watch) {
     progress.phase("starting run");
-    const finalStatus = await startAndWaitForPlayCompletionByStream({
-      client,
-      request: startRequest,
-      playName: options.target.name,
-      jsonOutput: options.jsonOutput,
-      emitLogs: options.emitLogs,
-      waitTimeoutMs: options.waitTimeoutMs,
-      progress
-    });
-    const exportedPath = exportPlayStatusRows(finalStatus, options.outPath);
+    const finalStatus = await traceCliSpan(
+      "cli.play_start_watch",
+      { targetKind: "name", playName },
+      () => startAndWaitForPlayCompletionByStream({
+        client,
+        request: startRequest,
+        playName,
+        jsonOutput: options.jsonOutput,
+        emitLogs: options.emitLogs,
+        waitTimeoutMs: options.waitTimeoutMs,
+        noOpen: options.noOpen,
+        progress
+      })
+    );
+    const exportedPath = traceCliSync(
+      "cli.play_export_rows",
+      { targetKind: "name", playName },
+      () => exportPlayStatusRows(finalStatus, options.outPath)
+    );
     if (finalStatus.status === "completed") {
       progress.complete();
     } else {
       progress.fail();
     }
-    writePlayResult(finalStatus, options.jsonOutput, { exportedPath });
+    traceCliSync(
+      "cli.play_write_result",
+      { targetKind: "name", playName },
+      () => writePlayResult(finalStatus, options.jsonOutput, { exportedPath })
+    );
     return finalStatus.status === "completed" ? 0 : 1;
   }
   progress.phase("starting run");
-  const started = await client.startPlayRun(startRequest);
+  const started = await traceCliSpan(
+    "cli.play_start_unwatched",
+    { targetKind: "name", playName },
+    () => client.startPlayRun(startRequest)
+  );
   const dashboardUrl = buildPlayDashboardUrl(
     client.baseUrl,
-    options.target.name
+    playName
   );
-  progress.phase(`loading play on ${dashboardUrl}`);
+  const resolvedDashboardUrl = started.dashboardUrl ?? dashboardUrl;
+  openPlayDashboard({
+    dashboardUrl: resolvedDashboardUrl,
+    jsonOutput: options.jsonOutput,
+    noOpen: options.noOpen
+  });
+  progress.phase(`loading play on ${resolvedDashboardUrl}`);
   progress.complete();
   writeStartedPlayRun({
     runId: started.workflowId,
-    playName: started.name ?? options.target.name,
+    playName: started.name ?? playName,
     status: started.status,
-    statusUrl: started.statusUrl,
-    dashboardUrl: started.dashboardUrl ?? dashboardUrl,
+    dashboardUrl: resolvedDashboardUrl,
     jsonOutput: options.jsonOutput,
     progress
   });
@@ -6011,8 +6540,8 @@ async function handlePlayRun(args) {
     }
     const resolved = resolve7(options.target.path);
     console.error(`File not found: ${resolved}`);
-    const dir = dirname6(resolved);
-    if (existsSync4(dir)) {
+    const dir = dirname7(resolved);
+    if (existsSync5(dir)) {
       const base = basename3(resolved);
       try {
         const siblings = readdirSync(dir).filter(
@@ -6040,7 +6569,7 @@ function parseRunIdPositional(args, usage) {
       }
       continue;
     }
-    if ((arg === "--out" || arg === "--cursor" || arg === "--reason" || arg === "--interval-ms" || arg === "--poll-interval-ms") && args[index + 1]) {
+    if ((arg === "--out" || arg === "--reason") && args[index + 1]) {
       index += 1;
       continue;
     }
@@ -6125,7 +6654,7 @@ async function handleRunsList(args) {
   return 0;
 }
 async function handleRunTail(args) {
-  const usage = "Usage: deepline runs tail <run-id> [--json] [--compact] [--cursor <cursor>]";
+  const usage = "Usage: deepline runs tail <run-id> [--json] [--compact]";
   let runId;
   try {
     runId = parseRunIdPositional(args, usage);
@@ -6133,20 +6662,19 @@ async function handleRunTail(args) {
     console.error(error instanceof Error ? error.message : usage);
     return 1;
   }
-  const client = new DeeplineClient();
-  let afterLogIndex;
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
-    if (arg === "--cursor" && args[index + 1]) {
-      const parsed = Number(args[++index]);
-      if (Number.isInteger(parsed) && parsed >= 0) {
-        afterLogIndex = parsed;
-      }
+    if (arg === "--cursor") {
+      console.error("--cursor was removed. deepline runs tail reads the canonical run stream.");
+      return 1;
+    }
+    if (arg.startsWith("--") && arg !== "--json" && arg !== "--compact") {
+      console.error(`${arg} is not supported by deepline runs tail.`);
+      return 1;
     }
   }
-  const status = await client.runs.tail(runId, {
-    ...afterLogIndex !== void 0 ? { afterLogIndex } : {}
-  });
+  const client = new DeeplineClient();
+  const status = await client.runs.tail(runId);
   writePlayResult(status, argsWantJson(args));
   return status.status === "failed" ? 1 : 0;
 }
@@ -6175,7 +6703,7 @@ async function handleRunLogs(args) {
   const status = await client.runs.get(runId);
   const logs = status.progress?.logs ?? [];
   if (outPath) {
-    writeFileSync4(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    writeFileSync5(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
     if (argsWantJson(args)) {
       process.stdout.write(
         `${JSON.stringify({
@@ -6687,8 +7215,9 @@ function registerPlayCommands(program) {
     "after",
     `
 Concepts:
-  Plays are durable Deepline cloud workflows. Local .play.ts files are bundled locally,
-  then validated and executed in Deepline cloud.
+  Plays are durable cloud workflows.
+  Stable ctx.tools.execute({ id, tool, input }) calls are replay-safe.
+  ctx.map adds row keys and row progress.
 
 Common commands:
   deepline plays search email --json
@@ -6719,17 +7248,42 @@ Examples:
     "after",
     `
 Notes:
-	  Local play files are bundled locally, then validated and executed in Deepline cloud.
-	  Named plays run the stored live cloud revision.
-	  Unknown --foo and --foo.bar flags are treated as play input args.
-	  File-like input args accept local paths; the CLI stages those files before submit.
-	  Run performs server preflight automatically. Use \`deepline plays check <file>\`
-	  to validate without starting a run.
+  Local files are bundled, preflighted, then run in Deepline cloud.
+  Named plays run the live saved revision.
+  Unknown --foo and --foo.bar flags are treated as play input args.
+  File args accept local paths; the CLI stages files before submit.
+  --watch prints logs, previews, stats, and next commands.
+  The play page opens in your browser as soon as the run starts; use --no-open
+  to only print the URL.
+  --force supersedes active runs; it does not bypass completed reuse.
+
+Idempotent execution:
+  Stable tool call ids are the reuse key:
+
+    await ctx.tools.execute({ id: 'company_lookup', tool, input });
+
+  For rows, use ctx.map plus a stable row key:
+
+    const rows = await ctx
+      .map('companies_v1', companies)
+      .step('cto', (row, ctx) => ctx.tools.execute({
+        id: 'find_cto',
+        tool: 'apollo_search_people_with_match',
+        input: { q_organization_domains_list: [row.domain], per_page: 1 },
+      }))
+      .run({ key: 'domain' });
+
+  Reuse needs the same play, tool id, map name, row key, and compatible logic.
+  To refresh, change the id/map key or set staleAfterSeconds:
+
+    .run({ key: 'domain', staleAfterSeconds: 86400 })
 
 Examples:
   deepline plays run my.play.ts --input '{"domain":"stripe.com"}' --watch
   deepline plays run person-linkedin-to-email --input '{"linkedin_url":"..."}' --watch
   deepline plays run enrich.play.ts --csv leads.csv --watch --out leads-enriched.csv
+  deepline plays run cto-search.play.ts --limit 5 --watch
+  deepline runs get <run-id>
 `
   ).option("--file <path>", "Local play file to run").option("--name <name>", "Saved play name to run").option("-i, --input <json>", "Input JSON object or @file path").option("--live", "Run the current live revision explicitly").option("--latest", "Run the newest saved revision, even if it is not live").option(
     "--revision-id <id>",
@@ -6740,7 +7294,7 @@ Examples:
   ).option("--watch", "Stream logs until completion").option(
     "--logs",
     "When output is non-interactive, stream play logs to stderr while waiting"
-  ).option("--poll-interval-ms <ms>", "Polling interval while tailing").option("--tail-timeout-ms <ms>", "Timeout while tailing").option("--force", "Supersede any active runs for this play").option("--json", "Emit JSON output").action(async (target, options, command) => {
+  ).option("--tail-timeout-ms <ms>", "Timeout while watching the run stream").option("--force", "Supersede any active runs for this play").option("--no-open", "Print the play page URL without opening a browser").option("--json", "Emit JSON output").action(async (target, options, command) => {
     const passthroughArgs = [...command.args];
     const explicitTarget = options.file || options.name;
     const targetIsInputFlag = typeof target === "string" && target.startsWith("--");
@@ -6762,9 +7316,9 @@ Examples:
       ...options.out ? ["--out", options.out] : [],
       ...options.watch ? ["--watch"] : [],
       ...options.logs ? ["--logs"] : [],
-      ...options.pollIntervalMs ? ["--poll-interval-ms", options.pollIntervalMs] : [],
       ...options.tailTimeoutMs ? ["--tail-timeout-ms", options.tailTimeoutMs] : [],
       ...options.force ? ["--force"] : [],
+      ...options.open === false ? ["--no-open"] : [],
       ...options.json ? ["--json"] : [],
       ...passthroughArgs
     ]);
@@ -6871,12 +7425,11 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
-  runs.command("tail <runId>").description("Tail or fetch recent live events for a play run.").option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--compact", "Drop verbose fields from JSON output").option("--cursor <cursor>", "Resume after a previously returned event cursor").action(async (runId, options) => {
+  runs.command("tail <runId>").description("Read the canonical live stream for a play run.").option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--compact", "Drop verbose fields from JSON output").action(async (runId, options) => {
     process.exitCode = await handleRunTail([
       runId,
       ...options.json ? ["--json"] : [],
-      ...options.compact ? ["--compact"] : [],
-      ...options.cursor ? ["--cursor", options.cursor] : []
+      ...options.compact ? ["--compact"] : []
     ]);
   });
   runs.command("logs <runId>").description("Fetch persisted logs for a play run.").option("--limit <count>", "Maximum recent log lines to print without --out", "200").option("--out <path>", "Write the full persisted log stream to a file").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
@@ -6905,12 +7458,12 @@ Examples:
 }
 
 // src/cli/commands/tools.ts
-import { chmodSync, mkdtempSync, writeFileSync as writeFileSync6 } from "fs";
+import { chmodSync, mkdtempSync, writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import { join as join8 } from "path";
 
 // src/tool-output.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join7 } from "path";
 function isPlainObject(value) {
@@ -6988,13 +7541,13 @@ function tryConvertToList(payload, options) {
 }
 function ensureOutputDir() {
   const outputDir = join7(homedir3(), ".local", "share", "deepline", "data");
-  mkdirSync3(outputDir, { recursive: true });
+  mkdirSync4(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
   const outputPath = join7(outputDir, `${stem}_${Date.now()}.json`);
-  writeFileSync5(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  writeFileSync6(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem) {
@@ -7022,7 +7575,7 @@ function writeCsvOutputFile(rows, stem) {
   for (const row of rows) {
     lines.push(columns.map((column) => escapeCell(row[column])).join(","));
   }
-  writeFileSync5(outputPath, `${lines.join("\n")}
+  writeFileSync6(outputPath, `${lines.join("\n")}
 `, "utf-8");
   const previewRows = rows.slice(0, 5);
   const previewColumns = columns.slice(0, 5);
@@ -7559,7 +8112,7 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
   };
 });
 `;
-  writeFileSync6(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  writeFileSync7(scriptPath, script, { encoding: "utf-8", mode: 384 });
   return {
     path: scriptPath,
     projectDir,
@@ -7666,10 +8219,10 @@ async function executeTool(args) {
 }
 
 // src/cli/skills-sync.ts
-import { spawn, spawnSync } from "child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync7 } from "fs";
+import { spawn, spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname7, join as join9 } from "path";
+import { dirname as dirname8, join as join9 } from "path";
 var CHECK_TIMEOUT_MS2 = 3e3;
 var SDK_SKILL_NAME = "deepline-sdk";
 var SKILL_AGENTS = ["codex", "claude-code", "cursor"];
@@ -7684,7 +8237,7 @@ function sdkSkillsVersionPath(baseUrl) {
 }
 function readLocalSkillsVersion(baseUrl) {
   const path = sdkSkillsVersionPath(baseUrl);
-  if (!existsSync5(path)) return "";
+  if (!existsSync6(path)) return "";
   try {
     return readFileSync4(path, "utf-8").trim();
   } catch {
@@ -7693,8 +8246,8 @@ function readLocalSkillsVersion(baseUrl) {
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  mkdirSync4(dirname7(path), { recursive: true });
-  writeFileSync7(path, `${version}
+  mkdirSync5(dirname8(path), { recursive: true });
+  writeFileSync8(path, `${version}
 `, "utf-8");
 }
 async function fetchSkillsUpdate(baseUrl, localVersion) {
@@ -7758,7 +8311,7 @@ function buildBunxSkillsInstallArgs(baseUrl) {
   ];
 }
 function hasCommand(command) {
-  const result = spawnSync(command, ["--version"], {
+  const result = spawnSync2(command, ["--version"], {
     stdio: "ignore",
     shell: process.platform === "win32"
   });
@@ -7857,54 +8410,6 @@ async function syncSdkSkillsIfNeeded(baseUrl) {
   writeSdkSkillsStatusLine("SDK skills are up to date.");
 }
 
-// src/cli/trace.ts
-var cliTraceStartedAt = Date.now();
-function isTruthyEnv(value) {
-  return value === "1" || value === "true" || value === "yes";
-}
-function isCliTraceEnabled() {
-  return isTruthyEnv(process.env.DEEPLINE_CLI_TRACE);
-}
-function recordCliTrace(event) {
-  if (!isCliTraceEnabled()) {
-    return;
-  }
-  const now = Date.now();
-  const payload = {
-    ts: now,
-    source: "cli",
-    sinceStartMs: now - cliTraceStartedAt,
-    ...event
-  };
-  process.stderr.write(`[cli-trace] ${JSON.stringify(payload)}
-`);
-}
-async function traceCliSpan(phase, fields, run) {
-  if (!isCliTraceEnabled()) {
-    return run();
-  }
-  const startedAt = Date.now();
-  try {
-    const result = await run();
-    recordCliTrace({
-      phase,
-      ms: Date.now() - startedAt,
-      ok: true,
-      ...fields
-    });
-    return result;
-  } catch (error) {
-    recordCliTrace({
-      phase,
-      ms: Date.now() - startedAt,
-      ok: false,
-      error: error instanceof Error ? error.message : String(error),
-      ...fields
-    });
-    throw error;
-  }
-}
-
 // src/cli/index.ts
 function shouldPrintStartupPhase() {
   if (process.argv.includes("--json")) {
@@ -7915,6 +8420,12 @@ function shouldPrintStartupPhase() {
   const subcommand = args[1];
   return (command === "play" || command === "plays") && subcommand === "run";
 }
+function shouldDeferSkillsSyncForCommand() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const subcommand = args[1];
+  return (command === "play" || command === "plays") && subcommand === "run" && args.includes("--json");
+}
 async function main() {
   const mainStartedAt = Date.now();
   recordCliTrace({
@@ -7959,11 +8470,13 @@ Output:
     if (printStartupPhase) {
       progress?.phase("checking sdk skills");
     }
-    await traceCliSpan(
-      "cli.sdk_skills_sync",
-      { baseUrl },
-      () => syncSdkSkillsIfNeeded(baseUrl)
-    );
+    if (!shouldDeferSkillsSyncForCommand()) {
+      await traceCliSpan(
+        "cli.sdk_skills_sync",
+        { baseUrl },
+        () => syncSdkSkillsIfNeeded(baseUrl)
+      );
+    }
   });
   registerAuthCommands(program);
   registerToolsCommands(program);