deepline 0.1.20 → 0.1.22

package/dist/cli/index.js

@@ -266,7 +266,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
@@ -349,7 +349,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);
@@ -468,6 +468,13 @@ var HttpClient = class {
       headers
     });
   }
+  async postFormData(path, formData, headers) {
+    return this.request(path, {
+      method: "POST",
+      formData,
+      headers
+    });
+  }
   /**
    * Send a DELETE request.
    *
@@ -551,7 +558,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,
@@ -559,22 +566,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;
@@ -685,7 +756,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 = {}) {
@@ -778,7 +849,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
@@ -1027,9 +1098,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;
   }
@@ -1045,9 +1141,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
    *
@@ -1058,41 +1151,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;
@@ -1112,7 +1186,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
@@ -1128,7 +1202,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) {
@@ -1200,32 +1274,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.
@@ -1382,11 +1466,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`
@@ -1402,7 +1486,6 @@ var DeeplineClient = class {
    *     const logs = status.progress?.logs ?? [];
    *     console.log(`[${status.status}] ${logs.length} log lines`);
    *   },
-   *   pollIntervalMs: 1000,
    * });
    *
    * if (result.success) {
@@ -1433,33 +1516,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
@@ -1545,6 +1648,7 @@ var import_node_path2 = require("path");
 var import_node_child_process = require("child_process");
 var import_sync = require("csv-parse/sync");
 var import_sync2 = require("csv-stringify/sync");
+var BROWSER_FOCUS_COOLDOWN_MS = 3e4;
 function getAuthedHttpClient() {
   const config = resolveConfig();
   return { config, http: new HttpClient(config) };
@@ -1556,12 +1660,215 @@ async function writeOutputFile(filename, content) {
   await (0, import_promises.writeFile)(fullPath, content, "utf-8");
   return fullPath;
 }
+function browserFocusStateFile() {
+  const homeDir = process.env.HOME || (0, import_node_os2.homedir)();
+  return (0, import_node_path2.join)(
+    homeDir,
+    ".local",
+    "deepline",
+    "runtime",
+    "state",
+    "browser-focus.json"
+  );
+}
+function claimBrowserFocus(now = Date.now()) {
+  const statePath = browserFocusStateFile();
+  try {
+    (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(statePath), { recursive: true });
+    let lastFocusedAt = 0;
+    if ((0, import_node_fs2.existsSync)(statePath)) {
+      const payload = JSON.parse((0, import_node_fs2.readFileSync)(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;
+    }
+    (0, import_node_fs2.writeFileSync)(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 = (0, import_node_child_process.execFileSync)(
+      "/usr/bin/defaults",
+      [
+        "read",
+        `${(0, import_node_os2.homedir)()}/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 = (0, import_node_child_process.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 {
+    (0, import_node_child_process.execFileSync)("open", [targetUrl], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function openInBrowser(url) {
   try {
-    if (process.platform === "darwin") (0, import_node_child_process.execSync)(`open "${url}"`, { stdio: "ignore" });
-    else if (process.platform === "win32")
-      (0, import_node_child_process.execSync)(`start "" "${url}"`, { stdio: "ignore" });
-    else (0, import_node_child_process.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") {
+      (0, import_node_child_process.execFileSync)("cmd.exe", ["/c", "start", "", targetUrl], {
+        stdio: "ignore"
+      });
+      return;
+    }
+    (0, import_node_child_process.execFileSync)("xdg-open", [targetUrl], { stdio: "ignore" });
   } catch {
   }
 }
@@ -3817,13 +4124,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,
@@ -4362,7 +4662,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("/");
@@ -4601,6 +4971,23 @@ function isLocalFilePathValue(value) {
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
   return (0, import_node_fs6.existsSync)((0, import_node_path8.resolve)(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 = [
     ...new Map(input.bindings.map((binding) => [binding.inputPath, binding])).values()
@@ -4787,7 +5174,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;
   }
@@ -4796,12 +5183,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",
@@ -4867,6 +5248,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;
@@ -4903,6 +5290,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 = {
@@ -4913,6 +5362,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(
     () => {
@@ -4925,13 +5376,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,
@@ -4965,6 +5423,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;
       }
     }
@@ -4977,21 +5445,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,
@@ -5009,13 +5487,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,
@@ -5036,71 +5524,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 ?? "-");
 }
@@ -5241,7 +5664,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`
   };
@@ -5357,10 +5779,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,
@@ -5606,7 +6027,6 @@ function writeStartedPlayRun(input) {
     workflowId: input.runId,
     name: input.playName,
     status: input.status ?? "started",
-    statusUrl: input.statusUrl,
     dashboardUrl: input.dashboardUrl
   };
   if (input.jsonOutput) {
@@ -5618,7 +6038,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`
   ];
@@ -5633,7 +6053,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;
@@ -5643,8 +6063,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];
@@ -5676,15 +6096,16 @@ function parsePlayRunOptions(args) {
       outPath = (0, import_node_path8.resolve)(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;
       }
@@ -5753,10 +6174,10 @@ function parsePlayRunOptions(args) {
     watch,
     emitLogs,
     jsonOutput,
-    pollIntervalMs,
     waitTimeoutMs,
     force,
-    outPath
+    outPath,
+    noOpen
   };
 }
 function parsePlayCheckOptions(args) {
@@ -5844,11 +6265,24 @@ async function handleFileBackedRun(options) {
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const absolutePlayPath = (0, import_node_path8.resolve)(options.target.path);
   progress.phase("compiling play");
-  const sourceCode = (0, import_node_fs6.readFileSync)(absolutePlayPath, "utf-8");
+  const sourceCode = traceCliSync(
+    "cli.play_file_read_source",
+    { targetKind: "file" },
+    () => (0, import_node_fs6.readFileSync)(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();
@@ -5859,36 +6293,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 } : {},
@@ -5897,35 +6342,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
   });
@@ -5951,32 +6418,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 } : {},
@@ -5985,38 +6487,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
   });
@@ -6059,7 +6583,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;
     }
@@ -6144,7 +6668,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);
@@ -6152,20 +6676,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;
 }
@@ -6706,8 +7229,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
@@ -6738,17 +7262,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>",
@@ -6759,7 +7308,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("--");
@@ -6781,9 +7330,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
     ]);
@@ -6890,12 +7439,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) => {
@@ -7876,54 +8424,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")) {
@@ -7934,6 +8434,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({
@@ -7978,11 +8484,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);