deepline 0.1.21 → 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.21";
+var SDK_VERSION = "0.1.22";
 var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
@@ -558,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,
@@ -566,23 +566,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);
@@ -591,6 +574,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;
@@ -700,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 = {}) {
@@ -793,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
@@ -1085,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
    *
@@ -1109,35 +1162,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;
@@ -1157,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
@@ -1173,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) {
@@ -1245,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.
@@ -1427,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`
@@ -1447,7 +1486,6 @@ var DeeplineClient = class {
    *     const logs = status.progress?.logs ?? [];
    *     console.log(`[${status.status}] ${logs.length} log lines`);
    *   },
-   *   pollIntervalMs: 1000,
    * });
    *
    * if (result.success) {
@@ -1478,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
@@ -1590,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) };
@@ -1601,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 {
   }
 }
@@ -3862,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,
@@ -4919,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;
   }
@@ -4928,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",
@@ -4999,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;
@@ -5035,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 = {
@@ -5068,6 +5385,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,
@@ -5123,21 +5445,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,
@@ -5145,10 +5467,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,
@@ -5166,13 +5487,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,
@@ -5180,10 +5501,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,
@@ -5204,72 +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, { 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 ?? "-");
 }
@@ -5410,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`
   };
@@ -5526,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,
@@ -5775,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) {
@@ -5787,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`
   ];
@@ -5802,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;
@@ -5812,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];
@@ -5845,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;
       }
@@ -5922,10 +6174,10 @@ function parsePlayRunOptions(args) {
     watch,
     emitLogs,
     jsonOutput,
-    pollIntervalMs,
     waitTimeoutMs,
     force,
-    outPath
+    outPath,
+    noOpen
   };
 }
 function parsePlayCheckOptions(args) {
@@ -6100,6 +6352,7 @@ async function handleFileBackedRun(options) {
         jsonOutput: options.jsonOutput,
         emitLogs: options.emitLogs,
         waitTimeoutMs: options.waitTimeoutMs,
+        noOpen: options.noOpen,
         progress
       })
     );
@@ -6127,14 +6380,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
   });
@@ -6239,6 +6497,7 @@ async function handleNamedRun(options) {
         jsonOutput: options.jsonOutput,
         emitLogs: options.emitLogs,
         waitTimeoutMs: options.waitTimeoutMs,
+        noOpen: options.noOpen,
         progress
       })
     );
@@ -6269,14 +6528,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
   });
@@ -6319,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;
     }
@@ -6404,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);
@@ -6412,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;
 }
@@ -6966,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
@@ -6998,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>",
@@ -7019,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("--");
@@ -7041,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
     ]);
@@ -7150,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) => {