deepline 0.1.21 → 0.1.23

package/dist/cli/index.mjs

@@ -243,7 +243,7 @@ function saveProjectDeeplineEnvValues(baseUrl, values, startDir = projectEnvStar
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.21";
+var SDK_VERSION = "0.1.23";
 var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
@@ -531,11 +531,24 @@ function sleep(ms) {
 // src/client.ts
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 var INCLUDE_TOOL_METADATA_HEADER = "x-deepline-include-tool-metadata";
+var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
+function sleep2(ms) {
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
+}
+function isTransientCompileManifestError(error) {
+  if (error instanceof DeeplineError && typeof error.statusCode === "number") {
+    return error.statusCode === 408 || error.statusCode === 425 || error.statusCode === 499 || error.statusCode >= 500 && error.statusCode < 600;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return /fetch failed|connection (?:closed|reset|terminated)|socket hang up|econnreset|etimedout|eai_again|abort/i.test(
+    message
+  );
+}
 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,
@@ -543,23 +556,6 @@ 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);
@@ -568,6 +564,79 @@ function decodeBase64Bytes(value) {
   }
   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;
   config;
@@ -677,7 +746,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 = {}) {
@@ -770,7 +839,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
@@ -880,8 +949,22 @@ var DeeplineClient = class {
     });
   }
   async compilePlayManifest(input) {
-    const response = await this.http.post("/api/v2/plays/compile-manifest", input);
-    return response.compilerManifest;
+    const retryDelays = COMPILE_MANIFEST_RETRY_DELAYS_MS.slice(
+      0,
+      Math.max(0, this.config.maxRetries)
+    );
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        const response = await this.http.post("/api/v2/plays/compile-manifest", input);
+        return response.compilerManifest;
+      } catch (error) {
+        const delayMs = retryDelays[attempt];
+        if (delayMs === void 0 || !isTransientCompileManifestError(error)) {
+          throw error;
+        }
+        await sleep2(delayMs);
+      }
+    }
   }
   /**
    * Check a bundled play artifact against the server's current play compiler.
@@ -1062,9 +1145,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
    *
@@ -1086,35 +1166,11 @@ var DeeplineClient = class {
     );
     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");
-    }
-    const response = await this.http.get(
-      `/api/v2/plays/run/${encodeURIComponent(workflowId)}?${params.toString()}`
-    );
-    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;
@@ -1134,7 +1190,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
@@ -1150,7 +1206,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) {
@@ -1222,32 +1278,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.
@@ -1404,11 +1470,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`
@@ -1424,7 +1490,6 @@ var DeeplineClient = class {
    *     const logs = status.progress?.logs ?? [];
    *     console.log(`[${status.status}] ${logs.length} log lines`);
    *   },
-   *   pollIntervalMs: 1000,
    * });
    *
    * if (result.success) {
@@ -1455,33 +1520,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
@@ -1555,18 +1640,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) };
@@ -1578,12 +1669,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 {
   }
 }
@@ -1667,14 +1961,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) {
@@ -1728,7 +2022,7 @@ function buildCandidateUrls2(url) {
     return [url];
   }
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 function printDeeplineLogo() {
@@ -1811,7 +2105,7 @@ async function handleRegister(args) {
       return EXIT_AUTH;
     }
     if (s >= 500 || s === 0 || s === 400) {
-      await sleep2(2e3);
+      await sleep3(2e3);
       continue;
     }
     if (s >= 400) {
@@ -1835,7 +2129,7 @@ async function handleRegister(args) {
       console.log("That approval link expired. Please run: deepline auth register");
       return EXIT_AUTH;
     }
-    await sleep2(2e3);
+    await sleep3(2e3);
   }
 }
 async function handleWait(args) {
@@ -1872,7 +2166,7 @@ async function handleWait(args) {
       return EXIT_AUTH;
     }
     if (status >= 500 || status === 0 || status === 400) {
-      await sleep2(2e3);
+      await sleep3(2e3);
       continue;
     }
     if (status >= 400) {
@@ -1896,7 +2190,7 @@ async function handleWait(args) {
       console.error("That approval link expired. Run: deepline auth register");
       return EXIT_AUTH;
     }
-    await sleep2(2e3);
+    await sleep3(2e3);
   }
   console.error("Still pending. Approve the browser link, then run: deepline auth wait");
   return EXIT_AUTH;
@@ -2213,7 +2507,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) {
@@ -2545,7 +2839,7 @@ function writeCanonicalRowsCsv(rowsInfo, outPath) {
     columns: rowsInfo.columns
   });
   const resolved = resolve3(outPath);
-  writeFileSync3(
+  writeFileSync4(
     resolved,
     csvStringFromRows(sanitized.rows, sanitized.columns),
     "utf-8"
@@ -2838,25 +3132,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";
 
@@ -2955,7 +3249,7 @@ async function normalizeLocalPath(filePath) {
 function createPlayWorkspace(entryFile) {
   return {
     entryFile,
-    rootDir: dirname3(entryFile)
+    rootDir: dirname4(entryFile)
   };
 }
 function isPathInsideDirectory(filePath, directory) {
@@ -3156,7 +3450,7 @@ function workersNamedPlayEntryAliasPlugin(playFilePath, exportName) {
           contents: `export { ${exportName} as default } from ${JSON.stringify(playFilePath)};
 `,
           loader: "ts",
-          resolveDir: dirname3(playFilePath)
+          resolveDir: dirname4(playFilePath)
         })
       );
     }
@@ -3320,7 +3614,7 @@ function importedPlayProxyPlugin(importedPlayDependencies) {
         return {
           contents: buildImportedPlayProxyModule(dependency.playName),
           loader: "ts",
-          resolveDir: dirname3(args.path)
+          resolveDir: dirname4(args.path)
         };
       });
     }
@@ -3338,7 +3632,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) {
@@ -3588,7 +3882,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"
       }
@@ -3844,13 +4138,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,
@@ -3885,7 +4172,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");
@@ -4086,7 +4373,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) {
@@ -4105,7 +4392,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();
@@ -4142,7 +4429,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(),
@@ -4181,14 +4468,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, "..");
@@ -4227,7 +4514,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,
@@ -4513,15 +4800,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) {
@@ -4566,7 +4853,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/")) {
@@ -4695,7 +4982,7 @@ 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)) {
@@ -4900,7 +5187,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;
   }
@@ -4909,12 +5196,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",
@@ -4980,6 +5261,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;
@@ -5016,6 +5303,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 = {
@@ -5049,6 +5398,11 @@ async function startAndWaitForPlayCompletionByStream(input) {
       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,
@@ -5104,21 +5458,21 @@ 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})
 `
         );
       }
       recordCliTrace({
-        phase: "cli.play_start_stream_fallback",
+        phase: "cli.play_start_stream_reconnect",
         ms: Date.now() - startedAt,
-        ok: false,
+        ok: true,
         playName: input.playName,
         workflowId: lastKnownWorkflowId,
         eventCount,
@@ -5126,10 +5480,9 @@ async function startAndWaitForPlayCompletionByStream(input) {
         lastPhase,
         reason
       });
-      return waitForPlayCompletionByPolling({
+      return waitForPlayCompletionByStream({
         client: input.client,
         workflowId: lastKnownWorkflowId,
-        pollIntervalMs: 500,
         jsonOutput: input.jsonOutput,
         emitLogs: input.emitLogs,
         waitTimeoutMs: input.waitTimeoutMs,
@@ -5147,13 +5500,13 @@ 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`
       );
     }
     recordCliTrace({
-      phase: "cli.play_start_stream_fallback",
+      phase: "cli.play_start_stream_reconnect",
       ms: Date.now() - startedAt,
-      ok: false,
+      ok: true,
       playName: input.playName,
       workflowId: lastKnownWorkflowId,
       eventCount,
@@ -5161,10 +5514,9 @@ async function startAndWaitForPlayCompletionByStream(input) {
       lastPhase,
       reason: "stream ended before terminal event"
     });
-    return waitForPlayCompletionByPolling({
+    return waitForPlayCompletionByStream({
       client: input.client,
       workflowId: lastKnownWorkflowId,
-      pollIntervalMs: 500,
       jsonOutput: input.jsonOutput,
       emitLogs: input.emitLogs,
       waitTimeoutMs: input.waitTimeoutMs,
@@ -5185,72 +5537,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, { billing: false });
-    }
-    const authoritativeStatus = await input.client.getPlayStatus(
-      input.workflowId,
-      { billing: false }
-    );
-    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 ?? "-");
 }
@@ -5391,7 +5677,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`
   };
@@ -5507,10 +5792,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,
@@ -5756,7 +6040,6 @@ function writeStartedPlayRun(input) {
     workflowId: input.runId,
     name: input.playName,
     status: input.status ?? "started",
-    statusUrl: input.statusUrl,
     dashboardUrl: input.dashboardUrl
   };
   if (input.jsonOutput) {
@@ -5768,7 +6051,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`
   ];
@@ -5783,7 +6066,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;
@@ -5793,8 +6076,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];
@@ -5826,15 +6109,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;
       }
@@ -5903,10 +6187,10 @@ function parsePlayRunOptions(args) {
     watch,
     emitLogs,
     jsonOutput,
-    pollIntervalMs,
     waitTimeoutMs,
     force,
-    outPath
+    outPath,
+    noOpen
   };
 }
 function parsePlayCheckOptions(args) {
@@ -6081,6 +6365,7 @@ async function handleFileBackedRun(options) {
         jsonOutput: options.jsonOutput,
         emitLogs: options.emitLogs,
         waitTimeoutMs: options.waitTimeoutMs,
+        noOpen: options.noOpen,
         progress
       })
     );
@@ -6108,14 +6393,19 @@ async function handleFileBackedRun(options) {
     () => 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
   });
@@ -6220,6 +6510,7 @@ async function handleNamedRun(options) {
         jsonOutput: options.jsonOutput,
         emitLogs: options.emitLogs,
         waitTimeoutMs: options.waitTimeoutMs,
+        noOpen: options.noOpen,
         progress
       })
     );
@@ -6250,14 +6541,19 @@ async function handleNamedRun(options) {
     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: started.name ?? playName,
     status: started.status,
-    statusUrl: started.statusUrl,
-    dashboardUrl: started.dashboardUrl ?? dashboardUrl,
+    dashboardUrl: resolvedDashboardUrl,
     jsonOutput: options.jsonOutput,
     progress
   });
@@ -6271,8 +6567,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(
@@ -6300,7 +6596,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;
     }
@@ -6385,7 +6681,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);
@@ -6393,20 +6689,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;
 }
@@ -6435,7 +6730,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({
@@ -6947,8 +7242,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
@@ -6979,17 +7275,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>",
@@ -7000,7 +7321,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("--");
@@ -7022,9 +7343,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
     ]);
@@ -7131,12 +7452,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) => {
@@ -7165,12 +7485,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) {
@@ -7248,13 +7568,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) {
@@ -7282,7 +7602,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);
@@ -7819,7 +8139,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,
@@ -7926,10 +8246,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"];
@@ -7944,7 +8264,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 {
@@ -7953,8 +8273,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) {
@@ -8018,7 +8338,7 @@ function buildBunxSkillsInstallArgs(baseUrl) {
   ];
 }
 function hasCommand(command) {
-  const result = spawnSync(command, ["--version"], {
+  const result = spawnSync2(command, ["--version"], {
     stdio: "ignore",
     shell: process.platform === "win32"
   });