deepline 0.3.273 → 0.3.275

package/dist/cli/index.mjs

@@ -1953,7 +1953,7 @@ configureProxyFromEnv();
 import { mkdtemp as mkdtemp4, rm as rm4, writeFile as writeFile7 } from "fs/promises";
 import { join as join29 } from "path";
 import { tmpdir as tmpdir7 } from "os";
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 
 // ../plays/trigger-config-route.ts
 function playTriggerConfigPath(playName) {
@@ -1985,18 +1985,18 @@ function playInputExampleArgs(schema) {
   if (!schema) return " --input '@<input.json>'";
   if (schema.$ref || schema.allOf) return " --input '@<input.json>'";
   const csv = schema.csvInput;
-  const csvField = typeof csv?.inputField === "string" ? csv.inputField : null;
+  const csvField2 = typeof csv?.inputField === "string" ? csv.inputField : null;
   const required = Array.isArray(schema.required) ? schema.required : [];
-  const csvOnlyRequired = required.every((key) => key === csvField);
+  const csvOnlyRequired = required.every((key) => key === csvField2);
   const alternatives = schema.oneOf ?? schema.anyOf;
   const hasCsvAlternative = Array.isArray(alternatives) && alternatives.some((branch) => {
     if (!branch || typeof branch !== "object") return false;
     const keys = branch.required;
-    return Array.isArray(keys) && keys.includes(csvField) && keys.every((key) => key === csvField);
+    return Array.isArray(keys) && keys.includes(csvField2) && keys.every((key) => key === csvField2);
   });
-  if (csvField && csvOnlyRequired && (!alternatives || hasCsvAlternative)) {
-    if (csvField === "csv") return " --csv '<contacts.csv>'";
-    const value = JSON.stringify({ [csvField]: "<contacts.csv>" });
+  if (csvField2 && csvOnlyRequired && (!alternatives || hasCsvAlternative)) {
+    if (csvField2 === "csv") return " --csv '<contacts.csv>'";
+    const value = JSON.stringify({ [csvField2]: "<contacts.csv>" });
     return ` --input '${value.replace(/'/g, "'\\''")}'`;
   }
   if (Array.isArray(schema.required) && !required.length && !csv && !alternatives) {
@@ -3507,7 +3507,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.273",
+  version: "0.3.275",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1
@@ -6210,6 +6210,28 @@ async function* watchRunEvents(options) {
   }
 }
 
+// src/runs/log-cursor.ts
+var RUN_LOGS_CURSOR_PREFIX = "before:";
+function encodeRunLogsCursor(beforeSequence) {
+  return `${RUN_LOGS_CURSOR_PREFIX}${beforeSequence}`;
+}
+function isRunLogsCursor(value) {
+  return value.startsWith(RUN_LOGS_CURSOR_PREFIX);
+}
+function parseRunLogsCursor(value) {
+  const raw = isRunLogsCursor(value) ? value.slice(RUN_LOGS_CURSOR_PREFIX.length) : "";
+  const parsed = /^[1-9]\d*$/.test(raw) ? Number(raw) : NaN;
+  if (!Number.isSafeInteger(parsed)) {
+    throw Object.assign(
+      new Error(
+        `Invalid run log cursor ${JSON.stringify(value)}. Pass the nextCursor value from a previous deepline runs logs result.`
+      ),
+      { exitCode: 2 }
+    );
+  }
+  return parsed;
+}
+
 // src/types.ts
 function isStopAllPlayRunsDryRunResult(result) {
   return "dryRun" in result && result.dryRun === true;
@@ -7160,6 +7182,7 @@ var DeeplineClient = class _DeeplineClient {
       status: (runId) => this.getRunLifecycleStatus(runId),
       list: (options2) => this.listRuns(options2),
       listPage: (options2) => this.listRunsPage(options2),
+      history: (options2) => this.getRunsHistory(options2),
       watch: (runId, options2) => this.watchRunToTerminal(runId, options2),
       tail: (runId, options2) => this.tailRun(runId, options2),
       logs: (runId, options2) => this.getRunLogs(runId, options2),
@@ -7290,7 +7313,7 @@ var DeeplineClient = class _DeeplineClient {
   }
   playRunCommand(play) {
     const target = play.reference || play.name;
-    return `deepline plays run ${target}${playInputExampleArgs(play.inputSchema)} --watch`;
+    return `deepline plays run ${target}${playInputExampleArgs(play.inputSchema)}`;
   }
   starterPlayPath(play) {
     const target = play.reference || play.name;
@@ -7851,7 +7874,7 @@ var DeeplineClient = class _DeeplineClient {
    * Convenience wrapper around {@link registerPlayArtifact} plus
    * {@link startPlayRun}. This is the canonical file-backed path used by wrappers.
    * The returned id can be passed to {@link getPlayStatus} to retrieve the same
-   * durable `{ result }` object that the CLI prints after `--watch` completes.
+   * durable `{ result }` object that the CLI prints after `plays run` completes.
    *
    * @param code - Source string fallback; the bundled artifact should be passed in `options.artifact`
    * @param csvPath - Path to input CSV file, or `null`
@@ -7972,7 +7995,7 @@ var DeeplineClient = class _DeeplineClient {
    * Get the current status of a play execution.
    *
    * Internal/advanced primitive. Public callers should usually prefer
-   * {@link runPlay}, {@link PlayJob.get}, or `deepline plays run --watch`.
+   * {@link runPlay}, {@link PlayJob.get}, or `deepline plays run`.
    *
    * @param workflowId - Play-run id from {@link startPlayRun}
    * @returns Current status with progress logs and partial results
@@ -8237,11 +8260,21 @@ var DeeplineClient = class _DeeplineClient {
     if (options?.full === true) {
       params.set("full", "true");
     }
+    if (options?.configuration === true) {
+      params.set("include", "configuration");
+    }
     const query = params.size > 0 ? `?${params.toString()}` : "";
     const response = await this.http.get(
       `/api/v2/runs/${encodeURIComponent(runId)}${query}`,
       { headers: { "x-deepline-run-status": "1" } }
     );
+    if (options?.configuration === true && !Object.hasOwn(response, "contract")) {
+      throw new DeeplineError(
+        "This server does not support recorded configuration reads.",
+        void 0,
+        "RUN_CONFIGURATION_UNAVAILABLE"
+      );
+    }
     const status = normalizePlayStatus(response);
     if (options?.failedLogs !== true || status.status !== "failed") {
       return status;
@@ -8329,6 +8362,33 @@ var DeeplineClient = class _DeeplineClient {
   async listRuns(options) {
     return (await this.listRunsPage(options)).runs;
   }
+  /** The same tenant-scoped run history searched by the dashboard and CLI. */
+  async getRunsHistory(options = {}) {
+    const params = new URLSearchParams();
+    const search = options.search?.trim();
+    if (search && search.length > 200) {
+      throw new Error("Run search must be at most 200 characters.");
+    }
+    if (options.type && options.type !== "all" && !search) {
+      throw new Error("runs.history options.type requires options.search.");
+    }
+    if (search) params.set("search", search);
+    if (search && options.type) params.set("type", options.type);
+    if (options.cursor) params.set("cursor", options.cursor);
+    if (options.orgId) params.set("orgId", options.orgId);
+    if (options.limit !== void 0) {
+      if (!Number.isSafeInteger(options.limit) || options.limit < 1) {
+        throw new Error(
+          "runs.history options.limit must be a positive integer."
+        );
+      }
+      params.set("limit", String(options.limit));
+    }
+    return this.http.get(
+      `/api/v2/dashboard/runs-history?${params.toString()}`,
+      { signal: options.signal }
+    );
+  }
   /** Read one run page without discarding server pagination metadata. */
   async listRunsPage(options) {
     const playName = options.play?.trim();
@@ -8435,6 +8495,13 @@ var DeeplineClient = class _DeeplineClient {
         "INVALID_RUN_LOG_VIEW"
       );
     }
+    if (options?.cursor !== void 0 && options.failed === true) {
+      throw new DeeplineError(
+        "runs.logs cannot combine failed with cursor.",
+        void 0,
+        "INVALID_RUN_LOG_VIEW"
+      );
+    }
     if (options?.failed === true) {
       const requestedLimit = typeof options.limit === "number" && Number.isFinite(options.limit) && options.limit > 0 ? Math.trunc(options.limit) : RUNS_FAILED_LOG_LIMIT;
       const failedLimit = Math.min(RUNS_FAILED_LOG_LIMIT, requestedLimit);
@@ -8460,6 +8527,7 @@ var DeeplineClient = class _DeeplineClient {
         ...page.logsTruncated ? { logsTruncated: true } : {}
       };
     }
+    const beforeSequence = options?.cursor !== void 0 ? parseRunLogsCursor(options.cursor) : null;
     const limit = options?.all ? Number.MAX_SAFE_INTEGER : typeof options?.limit === "number" && Number.isFinite(options.limit) && options.limit > 0 ? Math.trunc(options.limit) : 200;
     const fetchPage = (afterSeq2, pageLimit) => this.http.get(
       `/api/v2/runs/${encodeURIComponent(runId)}/logs?afterSeq=${afterSeq2}&limit=${pageLimit}`,
@@ -8467,24 +8535,33 @@ var DeeplineClient = class _DeeplineClient {
     );
     const probe = await fetchPage(0, 1);
     const lastStoredSeq = probe.lastStoredSeq;
-    let afterSeq = options?.all ? 0 : Math.max(0, lastStoredSeq - limit);
+    const oldestStoredSeq = probe.entries[0]?.seq ?? null;
+    const upperSeq = beforeSequence === null ? Number.POSITIVE_INFINITY : Math.min(beforeSequence - 1, lastStoredSeq);
+    const windowEndSeq = Math.min(upperSeq, lastStoredSeq);
+    let afterSeq = options?.all ? 0 : Math.max(0, windowEndSeq - limit);
     const entries = [];
-    while (entries.length < limit) {
+    while (entries.length < limit && afterSeq < upperSeq) {
       const page = await fetchPage(
         afterSeq,
-        Math.min(RUN_LOGS_PAGE_LIMIT, limit - entries.length)
+        Math.min(
+          RUN_LOGS_PAGE_LIMIT,
+          limit - entries.length,
+          upperSeq - afterSeq
+        )
       );
-      if (page.entries.length === 0) {
+      const inWindow = page.entries.filter((entry) => entry.seq <= upperSeq);
+      if (inWindow.length === 0) {
         break;
       }
-      entries.push(...page.entries);
-      afterSeq = page.entries[page.entries.length - 1].seq;
-      if (!page.hasMore) {
+      entries.push(...inWindow);
+      afterSeq = inWindow[inWindow.length - 1].seq;
+      if (!page.hasMore || inWindow.length < page.entries.length) {
         break;
       }
     }
     const firstSequence = entries.length > 0 ? entries[0].seq : null;
     const lastSequence = entries.length > 0 ? entries[entries.length - 1].seq : null;
+    const olderLinesExist = firstSequence !== null && oldestStoredSeq !== null && firstSequence > oldestStoredSeq;
     return {
       runId: probe.runId,
       totalCount: probe.totalLogCount,
@@ -8492,7 +8569,8 @@ var DeeplineClient = class _DeeplineClient {
       firstSequence,
       lastSequence,
       truncated: entries.length < probe.totalLogCount,
-      hasMore: lastSequence !== null && lastSequence < lastStoredSeq,
+      hasMore: olderLinesExist,
+      nextCursor: olderLinesExist ? encodeRunLogsCursor(firstSequence) : null,
       entries: entries.map((entry) => entry.line),
       view: options?.all ? "all" : "tail",
       ...probe.logsTruncated ? { logsTruncated: true } : {}
@@ -10469,6 +10547,7 @@ var ROOTS = {
   check: "kind target checked scope name exportName valid stage issues inputSchema outputSchema recognized triggers runtimeLimit limits featureFlags sourceHash artifactHash graphHash toolGetterHints exports actions diagnostics reference origin ownerType activeScheduledPlays command_context",
   run: "schemaVersion kind run datasets actions apiVersion dashboardUrl progress rowOutcomes steps errors error warnings result resultState execution command_context diagnostics",
   get: "schemaVersion kind run runStatus steps failures errorDetails rowOutcomes warnings failedLogs datasets result resultState actions diagnostics command_context",
+  config: "runId contract command_context",
   export: "runId datasets csv_path json_path format source rowCount columns notice metadata_path actions command_context"
 };
 function parseJsonFields(args, surface) {
@@ -14911,7 +14990,7 @@ import {
 } from "fs/promises";
 import { homedir as homedir6, tmpdir as tmpdir5 } from "os";
 import { basename as basename4, dirname as dirname11, extname as extname3, join as join15, resolve as resolve14 } from "path";
-import { Option as Option3 } from "commander";
+import { Option as Option4 } from "commander";
 
 // ../plays/settings-contract.ts
 import { z } from "zod";
@@ -15814,12 +15893,12 @@ var SECTIONS = [
     title: "Choose the read",
     paragraphs: [
       "These commands read existing evidence; they do not start a run or execute a provider. Replace <run-id>, <play-name> and other angle-bracket values with identifiers returned by the CLI.",
-      "Text logs: runs logs <run-id> returns the last 200 retained lines by default. --out writes the full retained stream to a local file. --log-level filters text severity; debug includes all retained levels. --failed reads only a terminal-failed run\u2019s last 20 retained lines and reports retention limitations.",
-      "Event search: omit the run ID, or add any of --since, --until, --play, --kind, --where, --payloads, --cursor, --runtime-namespace or --runtime-backend. A supplied run ID then narrows the search. --limit and --json alone do not switch a run\u2019s text logs to event search. Text-only flags --out, --failed, --log-level, --logs and --debug cannot be combined with event search.",
+      "Text logs: runs logs <run-id> returns the last 200 retained lines by default. When older lines exist, hasMore is true and nextCursor continues the next older page with --cursor. --out writes the full retained stream to a local file. --log-level filters text severity; debug includes all retained levels. --failed reads only a terminal-failed run\u2019s last 20 retained lines and reports retention limitations.",
+      "Event search: omit the run ID, or add any of --since, --until, --play, --kind, --where, --payloads, --runtime-namespace or --runtime-backend. A supplied run ID then narrows the search. --cursor continues event search unless it is a returned before:<sequence> text-log cursor. --limit and --json alone do not switch a run\u2019s text logs to event search. Text-only flags --out, --failed and --log-level cannot be combined with event search.",
       "Current status and returned output selectors: runs get <run-id> --json. Live observation: runs watch <run-id>. Dataset rows: runs export <run-id> --dataset <returned-selector> --out rows.csv. A referenced tool response: runs receipt <run-id> --key <returned-receipt-key> --json. Read each command\u2019s --help for its options."
     ],
     commands: [
-      "deepline runs logs <run-id> --json",
+      "deepline runs logs <run-id> --cursor before:1201 --json",
       "deepline runs logs <run-id> --out run.log --json",
       "deepline runs logs --kind run.failed --json",
       "deepline runs logs --kind step.failed --payloads --json",
@@ -15843,13 +15922,24 @@ var SECTIONS = [
       "Identity strings: orgId, runId, playName, runtimeScope. These come from authenticated execution state; filters only narrow your authorized organization/runtime. Preview reads require the existing runtime credential and an authorized --runtime-namespace; --runtime-backend selects daytona or modal.",
       "Event string: kind. Optional strings: source, stepId, stepKind, status, datasetId, phase, provider, operation. Optional positive integer: producerAttempt. These fields exist only when recorded; inspect a returned event before filtering on an optional field.",
       'stepId/stepKind describe recorded step work; datasetId/phase describe dataset lifecycle (registered, available, failed). provider/operation appear on typed provider activity.observed events, not every receipt or provider call. status is the recorded status or activity state when present: run.completed and step.completed do not imply status == "completed". Select lifecycle outcomes with --kind.',
-      "context.<key> matches an authored flat scalar log field: string, number or boolean. Context cannot override event identity. Missing fields do not match. --where supports only $.field == literal predicates joined with &&, at most eight predicates and 512 bytes. No OR, ranges, wildcards, nested payload paths or text search. Time uses --since/--until; level and message are not --where fields."
+      "context.<key> matches an authored flat scalar log field: string, number or boolean. Context cannot override event identity. Missing fields do not match. --where supports only $.field == literal predicates joined with &&, at most eight predicates and 512 bytes. No OR, ranges, wildcards, nested payload paths or text search. Time uses --since/--until; level and message are not --where fields.",
+      'Wrap the entire predicate in single shell quotes so $ and && reach the CLI unchanged. Inside it, strings use double quotes; numbers and booleans are unquoted. Types must match: 2 differs from "2", false differs from "false". Examples use illustrative recorded values; use your own step IDs, dataset IDs, provider/operation names and authored context. The context examples assume ctx.log recorded companyId: "acme_123", attempt: 2 and cached: false.'
     ],
     commands: [
+      "# Failed retained work with its stored error/result",
       `deepline runs logs --kind receipt.failed --where '$.status == "failed"' --payloads --json`,
-      `deepline runs logs <run-id> --where '$.source == "worker" && $.producerAttempt == 1' --json`,
-      `deepline runs logs --kind activity.observed --where '$.provider == "<returned-provider>" && $.operation == "<returned-operation>"' --json`,
-      `deepline runs logs --kind log.appended --where '$.context.<authored-key> == "<recorded-value>"' --json`
+      "# Failure details for one named step",
+      `deepline runs logs --kind step.failed --where '$.stepId == "company-lookup"' --payloads --json`,
+      "# Typed provider observations matching both fields",
+      `deepline runs logs --kind activity.observed --where '$.provider == "apollo" && $.operation == "company_lookup"' --json`,
+      "# Failed lifecycle transitions for one dataset",
+      `deepline runs logs --kind dataset.lifecycle --where '$.datasetId == "companies" && $.phase == "failed"' --payloads --json`,
+      "# Authored string context on log lines",
+      `deepline runs logs --kind log.appended --where '$.context.companyId == "acme_123"' --json`,
+      "# Authored number and boolean context, both required to match",
+      "deepline runs logs --kind log.appended --where '$.context.attempt == 2 && $.context.cached == false' --json",
+      "# Known producer identity within one run",
+      `deepline runs logs <run-id> --where '$.source == "worker" && $.producerAttempt == 1' --json`
     ]
   },
   {
@@ -16741,6 +16831,7 @@ import {
   relative as relative5,
   resolve as resolve13
 } from "path";
+import { Option as Option3 } from "commander";
 
 // src/cli/commands/plays/bootstrap.ts
 import {
@@ -17101,7 +17192,7 @@ Example: deepline plays bootstrap people-email --from csv:data/leads.csv --using
       `Unknown plays bootstrap template: ${rawTemplate}
 Supported templates: ${formatPlayBootstrapTemplates()}|${MONITOR_BOOTSTRAP_TEMPLATE}` + (looksLikePlayReference ? `
 
-"${rawTemplate}" looks like an existing play reference or file, not a bootstrap template. Do not run plays bootstrap on prebuilt/<play-name>. Use "deepline plays run ${rawTemplate} --input '{...}' --watch" to run it directly, "deepline plays describe ${rawTemplate} --json" to inspect its contract, or "deepline plays get ${rawTemplate} --source --out scratchpad.play.ts" to clone/edit it.` : "")
+"${rawTemplate}" looks like an existing play reference or file, not a bootstrap template. Do not run plays bootstrap on prebuilt/<play-name>. Use "deepline plays run ${rawTemplate} --input '{...}'" to run it directly, "deepline plays describe ${rawTemplate} --json" to inspect its contract, or "deepline plays get ${rawTemplate} --source --out scratchpad.play.ts" to clone/edit it.` : "")
     );
   }
   return rawTemplate;
@@ -17870,7 +17961,7 @@ function playUsesMapBackedRuntime(play) {
 }
 function assertComposablePlayRoute(input2) {
   if (!input2.playRef || !playUsesMapBackedRuntime(input2.play)) return;
-  const runCommand2 = input2.play?.runCommand?.trim() || `deepline plays run ${input2.playRef} --input '{...}' --watch`;
+  const runCommand2 = input2.play?.runCommand?.trim() || `deepline plays run ${input2.playRef} --input '{...}'`;
   throw new PlayBootstrapValidationError(
     `Cannot use ${input2.stageLabel} play:${input2.playRef} in plays bootstrap composition: the selected play is dataset-backed/direct-run-only. Child plays that use ctx.dataset() own durable table state and must be run directly, exported, or validated as their own play instead of wrapped with ctx.runPlay. Run it directly first: ${runCommand2}`
   );
@@ -17912,14 +18003,14 @@ function generatePlaySourceRowsBlock(input2) {
     sourcePlay: input2.sourcePlay
   })) {
     const sourcePlay = input2.sourcePlay;
-    const runCommand2 = sourcePlay?.runCommand?.trim() || `deepline plays run ${input2.source.value} --input '{...}' --watch`;
+    const runCommand2 = sourcePlay?.runCommand?.trim() || `deepline plays run ${input2.source.value} --input '{...}'`;
     return `// Source play ${input2.source.value} is dataset-backed/direct-run-only, so this generated play is stage 2.
   // Stage 1:
   //   ${runCommand2}
   // Stage 2:
   //   deepline runs export <stage-1-run-id> --dataset 'result.rows' --out source-export.csv
   // Stage 3:
-  //   deepline plays run <this-file.play.ts> --input '{"sourceCsv":"source-export.csv","limit":${input2.sourcePlay ? "5" : "5"}}' --watch
+  //   deepline plays run <this-file.play.ts> --input '{"sourceCsv":"source-export.csv","limit":${input2.sourcePlay ? "5" : "5"}}'
   const sourceDataset = await ctx.csv<${input2.collectionType}>(input.sourceCsv ?? './source-export.csv');
   const ${input2.collection}: ${input2.collectionType}[] = await sourceDataset.peek(limit);`;
   }
@@ -18399,7 +18490,7 @@ Notes:
 Examples:
   deepline plays bootstrap people-email --from csv:data/leads.csv --using play:prebuilt/name-and-domain-to-email-waterfall --limit 5 --out email-flow.play.ts
   deepline plays check email-flow.play.ts
-  deepline plays run email-flow.play.ts --input '{"limit":5}' --watch
+  deepline plays run email-flow.play.ts --input '{"limit":5}'
 
   deepline plays bootstrap people-email --from provider:dropleads_search_people --using providers:hunter_email_finder,leadmagic_email_finder --limit 5 --out prospecting.play.ts
   deepline plays bootstrap company-people-email --from provider:crustdata_companydb_search --people play:prebuilt/company-to-contact --email play:prebuilt/name-and-domain-to-email-waterfall --limit 5 --out account-contacts.play.ts
@@ -18587,24 +18678,31 @@ includes nextCommand when another page is available.
 
 // src/cli/commands/plays/run-history.ts
 async function handleRunsHistory(options) {
-  const query = new URLSearchParams();
-  if (options.cursor) query.set("cursor", options.cursor);
-  if (options.org) query.set("orgId", options.org);
+  let limit;
+  if (options.type && !["all", "plays", "monitors"].includes(options.type)) {
+    throw new Error("--type must be all, plays or monitors.");
+  }
   if (options.limit !== void 0) {
-    const limit = Number(options.limit);
+    limit = Number(options.limit);
     if (!/^\d+$/.test(options.limit) || !Number.isSafeInteger(limit) || limit < 1) {
       throw new Error("--limit must be a positive integer.");
     }
-    query.set("limit", String(limit));
   }
-  const search = query.toString();
-  const page = await new HttpClient(resolveConfig()).get(
-    `/api/v2/dashboard/runs-history${search ? `?${search}` : ""}`
-  );
+  const page = await new DeeplineClient().runs.history({
+    cursor: options.cursor,
+    orgId: options.org,
+    search: options.search,
+    type: options.type,
+    limit
+  });
   const lines = page.runs.map(
     (run) => `${run.workflowName} \xB7 ${run.status} \xB7 ${run.runId}`
   );
-  if (lines.length === 0) lines.push("No runs found on this page.");
+  if (lines.length === 0) {
+    lines.push(
+      options.search && page.hasMore ? "No matches in this page; continue searching with the next cursor." : "No runs found on this page."
+    );
+  }
   if (page.hasMore) lines.push(`Next cursor: ${page.nextCursor}`);
   printCommandEnvelope(
     { ...page, render: { sections: [{ title: "Run history", lines }] } },
@@ -18616,6 +18714,12 @@ function registerRunHistoryCommand(runs) {
     "--cursor <cursor>",
     "Opaque nextCursor returned by the previous page"
   ).option("--limit <count>", "Maximum runs on this page").option(
+    "--search <text>",
+    "Search Play/workflow names, run IDs and statuses"
+  ).option(
+    "--type <type>",
+    "Search all, plays or monitors (requires --search)"
+  ).option(
     "--org <id>",
     "Workspace ID (must match the authenticated workspace)"
   ).option("--json", "Emit JSON output. Also automatic when stdout is piped").addHelpText(
@@ -24345,6 +24449,63 @@ var SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES ? SDK_ENTRY_FILE : resolv
 import { writeFileSync as writeFileSync9 } from "fs";
 import { resolve as resolve10 } from "path";
 
+// ../plays/table-csv.ts
+var TABLE_EXPORT_ERROR_COLUMN = "_error";
+var UNRECORDED_FAILURE_REASON = "Row failed without a recorded reason.";
+function tableCellText(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean")
+    return String(value);
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "symbol" || typeof value === "function") return "";
+  try {
+    return JSON.stringify(
+      value,
+      (_key, nested) => typeof nested === "bigint" ? nested.toString() : nested
+    ) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+function csvField(value) {
+  const text = tableCellText(value);
+  return /[",\r\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+function csvRecord(values) {
+  return `${values.map(csvField).join(",")}
+`;
+}
+function isFailedRow(row) {
+  return row.status === "failed";
+}
+function tableExportHasFailedRows(rows) {
+  for (const row of rows) if (isFailedRow(row)) return true;
+  return false;
+}
+function tableExportErrorCell(row) {
+  if (!isFailedRow(row)) return "";
+  const reason = typeof row.error === "string" ? row.error.trim() : "";
+  return reason || UNRECORDED_FAILURE_REASON;
+}
+function tableExportColumns(columns, withError) {
+  if (!withError) return [...columns];
+  return [
+    ...columns.filter((column) => column !== TABLE_EXPORT_ERROR_COLUMN),
+    TABLE_EXPORT_ERROR_COLUMN
+  ];
+}
+function tableExportCells(row, columns, withError) {
+  return tableExportColumns(columns, withError).map(
+    (column) => column === TABLE_EXPORT_ERROR_COLUMN && withError ? tableExportErrorCell(row) : Object.hasOwn(row.data, column) ? row.data[column] : void 0
+  );
+}
+function tableCsvText(header, records) {
+  let text = csvRecord(header);
+  for (const record5 of records) text += csvRecord(record5);
+  return text;
+}
+
 // src/cli/run-dataset-order.ts
 function underscoreKeysLast(keys) {
   return [...keys].sort(
@@ -24393,9 +24554,13 @@ var RunDatasetCsv = class _RunDatasetCsv {
   }
   write(outPath) {
     const absolutePath = resolve10(outPath);
+    const { rows, columns } = this.#projection;
     writeFileSync9(
       absolutePath,
-      csvStringFromRows(this.#projection.rows, this.#projection.columns),
+      tableCsvText(
+        columns,
+        rows.map((data) => tableExportCells({ data }, columns, false))
+      ),
       "utf-8"
     );
     return absolutePath;
@@ -28353,7 +28518,7 @@ function buildPlayReferenceNotFoundMessage(input2) {
       lines.push("", `  ${suggestion.reference}`);
       if (input2.command === "run") {
         lines.push(
-          `    deepline plays run ${suggestion.reference} --input '{...}' --watch`
+          `    deepline plays run ${suggestion.reference} --input '{...}'`
         );
       } else if (input2.command === "get") {
         lines.push(`    deepline plays get ${suggestion.reference} --json`);
@@ -31677,7 +31842,9 @@ function buildOrdinaryPlayRunCommand(options, resolvedRevisionId) {
   }
   if (options.open) parts.push("--open");
   if (options.fullJson) parts.push("--full");
-  if (options.jsonOutput && options.emitLogs) parts.push("--logs");
+  if (options.jsonOutput && options.emitLogs) {
+    parts.push("--log-level", "debug");
+  }
   if (options.jsonOutput) parts.push("--json");
   return parts.join(" ");
 }
@@ -31989,7 +32156,20 @@ async function fetchBackingDatasetRows(input2) {
     }
     offset += page.rows.length;
   }
-  const rows = sheetRows.map(exportableSheetRow).filter((row) => Boolean(row));
+  const withError = tableExportHasFailedRows(
+    sheetRows.filter(
+      (row) => Boolean(row) && typeof row === "object" && !Array.isArray(row)
+    )
+  );
+  const rows = sheetRows.map((row) => {
+    const data = exportableSheetRow(row);
+    return data && withError ? {
+      ...data,
+      [TABLE_EXPORT_ERROR_COLUMN]: tableExportErrorCell(
+        row
+      )
+    } : data;
+  }).filter((row) => Boolean(row));
   const hasCompleteSettledPrefix = acceptsSettledRowsAsCompleteExport(input2.status) && settledTotal !== null && // A zero-row run-scoped read is not a settled export when the returned
   // Dataset Handle advertised rows. That shape is the replay/reuse case:
   // the rows belong to another writer (or the projection has not caught up)
@@ -32761,7 +32941,7 @@ function parsePlayRunOptions(args) {
       }
       if (arg === "--tail") {
         throw new Error(
-          "--tail is removed for `plays run`; use `--watch` to stream completion output."
+          "--tail is removed for `plays run`; run waits and streams completion output by default."
         );
       }
       continue;
@@ -33971,9 +34151,12 @@ function renderRunOverviewText(overview, extras = {}) {
 ${renderCommandEnvelopeText({ render: { sections, actions: actions2 } })}`;
 }
 async function handleRunGet(args) {
-  const selection = parseJsonFields(args, "get");
+  const selection = parseJsonFields(
+    args,
+    args.includes("--config") ? "config" : "get"
+  );
   args = selection.args;
-  const usage2 = "Usage: deepline runs get <run-id> [--json] [--full] [--input] [--log-failed]";
+  const usage2 = "Usage: deepline runs get <run-id> [--json] [--full] [--input] [--config] [--log-failed]";
   let runId;
   try {
     runId = parseRunIdPositional(args, usage2);
@@ -33982,6 +34165,25 @@ async function handleRunGet(args) {
     return 1;
   }
   const client2 = new DeeplineClient();
+  if (args.includes("--config")) {
+    if (args.some((arg) => ["--input", "--full", "--log-failed"].includes(arg))) {
+      console.error(
+        "--config cannot be combined with --input, --full or --log-failed."
+      );
+      return 1;
+    }
+    const status2 = await client2.runs.get(runId, { configuration: true });
+    if (!Object.hasOwn(status2, "contract")) {
+      throw new Error(
+        "This server does not support recorded configuration reads."
+      );
+    }
+    printCommandEnvelope(
+      { runId, contract: status2.contract ?? null },
+      { json: true, fields: selection.fields }
+    );
+    return 0;
+  }
   if (args.includes("--input")) {
     const input2 = await client2.getRunInput(runId);
     printCommandEnvelope(input2, { json: true });
@@ -34487,15 +34689,17 @@ async function handleRunLogs(args) {
     "--play",
     "--kind",
     "--where",
-    "--cursor",
     "--payloads",
     "--runtime-namespace",
     "--runtime-backend"
   ]);
-  if (!args[0] || args[0].startsWith("--") || args.some((arg) => searchFlags.has(arg))) {
+  const cursorIndex = args.indexOf("--cursor");
+  const cursorValue = cursorIndex >= 0 ? args[cursorIndex + 1] : void 0;
+  const continuesEventSearch = cursorIndex >= 0 && !(cursorValue && isRunLogsCursor(cursorValue));
+  if (!args[0] || args[0].startsWith("--") || continuesEventSearch || args.some((arg) => searchFlags.has(arg))) {
     return handleRunEventSearch(args);
   }
-  const usage2 = "Usage: deepline runs logs <run-id> [--limit 200] [--failed] [--out run.log] [--log-level debug|info|warn|error] [--json]";
+  const usage2 = "Usage: deepline runs logs <run-id> [--limit 200] [--cursor before:<seq>] [--failed] [--out run.log] [--log-level debug|info|warn|error] [--json]";
   let runId;
   try {
     runId = parseRunIdPositional(args, usage2);
@@ -34505,6 +34709,7 @@ async function handleRunLogs(args) {
   }
   let limit = 200;
   let outPath = null;
+  let cursor;
   let logLevel = "debug";
   let hasExplicitLogLevel = false;
   let usesDebugAlias = false;
@@ -34543,6 +34748,10 @@ async function handleRunLogs(args) {
       outPath = resolve13(args[++index]);
       continue;
     }
+    if (arg === "--cursor" && args[index + 1]) {
+      cursor = args[++index];
+      continue;
+    }
     if (arg.startsWith("--")) {
       console.error(`${arg} is not supported by deepline runs logs.`);
       return 1;
@@ -34561,6 +34770,12 @@ async function handleRunLogs(args) {
     );
     return 1;
   }
+  if (cursor !== void 0 && (failed || outPath)) {
+    console.error(
+      "--cursor pages the bounded log tail; it cannot be combined with --failed or --out."
+    );
+    return 1;
+  }
   const client2 = new DeeplineClient();
   if (outPath) {
     const result2 = await client2.runs.logs(runId, { all: true });
@@ -34594,19 +34809,25 @@ async function handleRunLogs(args) {
     return 0;
   }
   const result = await client2.runs.logs(runId, {
-    ...failed ? { limit, failed: true } : { all: logLevel !== "debug", limit }
-  });
-  const matchingEntries = result.entries.filter(
-    (line) => logLevelReaches(classifyLogLine(line).level, logLevel)
-  );
-  const entries = failed ? matchingEntries : matchingEntries.slice(-limit);
-  const matchingEntriesTruncated = !failed && matchingEntries.length > limit;
+    ...failed ? { limit, failed: true } : { all: logLevel !== "debug", limit },
+    ...cursor !== void 0 ? { cursor } : {}
+  });
+  const page = failed ? {
+    entries: result.entries,
+    firstSequence: result.firstSequence,
+    lastSequence: result.lastSequence,
+    truncated: result.truncated,
+    hasMore: result.hasMore,
+    nextCursor: void 0
+  } : selectRunLogTailPage(result, logLevel, limit);
+  const entries = page.entries;
+  const nextPage = page.nextCursor ? `deepline runs logs ${result.runId} --limit ${limit}${logLevel === "debug" ? "" : ` --log-level ${logLevel}`} --cursor ${page.nextCursor} --json` : null;
   const filteredResult = {
     ...result,
     entries,
     returnedCount: entries.length,
-    truncated: result.truncated || matchingEntriesTruncated,
-    hasMore: result.hasMore || matchingEntriesTruncated,
+    truncated: page.truncated,
+    hasMore: page.hasMore,
     view: failed ? result.view : "tail",
     next: {
       ...result.next ?? {},
@@ -34619,10 +34840,11 @@ async function handleRunLogs(args) {
       runId: result.runId,
       totalCount: result.totalCount,
       returnedCount: entries.length,
-      firstSequence: result.firstSequence,
-      lastSequence: result.lastSequence,
+      firstSequence: page.firstSequence,
+      lastSequence: page.lastSequence,
       truncated: filteredResult.truncated,
       hasMore: filteredResult.hasMore,
+      ...page.nextCursor !== void 0 ? { nextCursor: page.nextCursor } : {},
       logLevel,
       ...result.logsTruncated ? { logsTruncated: true } : {},
       entries,
@@ -34631,6 +34853,7 @@ async function handleRunLogs(args) {
       ...result.warning ? { warning: result.warning } : {},
       next: {
         ...result.next ?? {},
+        ...nextPage ? { page: nextPage } : {},
         export: `deepline runs logs ${result.runId} --out run.log --log-level ${logLevel} --json`
       },
       render: { sections: [{ title: "run logs", lines: entries }] }
@@ -34642,6 +34865,37 @@ async function handleRunLogs(args) {
   );
   return 0;
 }
+function selectRunLogTailPage(result, logLevel, limit) {
+  if (logLevel === "debug") {
+    return {
+      entries: [...result.entries],
+      firstSequence: result.firstSequence,
+      lastSequence: result.lastSequence,
+      truncated: result.truncated,
+      hasMore: result.hasMore,
+      nextCursor: result.nextCursor ?? null
+    };
+  }
+  const first = result.firstSequence;
+  if (result.entries.length > 0 && (first === null || result.lastSequence === null || result.lastSequence - first + 1 !== result.entries.length)) {
+    throw new Error(
+      `Run log window is not contiguous (sequences ${first}..${result.lastSequence} for ${result.entries.length} lines); cannot page by severity.`
+    );
+  }
+  const matching = result.entries.map((line, index) => ({ line, seq: first + index })).filter(
+    (entry) => logLevelReaches(classifyLogLine(entry.line).level, logLevel)
+  );
+  const selected = matching.slice(-limit);
+  const olderMatchesExist = matching.length > selected.length;
+  return {
+    entries: selected.map((entry) => entry.line),
+    firstSequence: selected[0]?.seq ?? null,
+    lastSequence: selected.at(-1)?.seq ?? null,
+    truncated: result.truncated || olderMatchesExist,
+    hasMore: olderMatchesExist,
+    nextCursor: olderMatchesExist ? encodeRunLogsCursor(selected[0].seq) : null
+  };
+}
 async function handleRunEventSearch(args) {
   const usage2 = "Usage: deepline runs logs [run-id] [--since ISO] [--until ISO] [--play name] [--kind kind] [--where jsonpath] [--payloads] [--cursor token] [--limit 100] [--json]";
   const values = {};
@@ -34807,6 +35061,14 @@ function buildRunLogsText(result) {
   }
   return `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`;
 }
+function resolveRunStopState(result) {
+  if (result.state) return result.state;
+  if (result.cancelling === true) return "cancelling";
+  if (result.stopped === false || result.staleSchedulerState === true) {
+    return "failed";
+  }
+  return "stopped";
+}
 async function handleRunStop(args) {
   const usage2 = 'Usage: deepline runs stop <run-id> [--reason "text"] [--json]';
   let runId;
@@ -34825,15 +35087,25 @@ async function handleRunStop(args) {
   }
   const client2 = new DeeplineClient();
   const result = await client2.runs.stop(runId, { reason });
-  if (result.cancelling === true && result.hitlCancellationPending !== true) {
+  const state = resolveRunStopState(result);
+  const hitlCleanupIncomplete = state === "cancelling" && result.hitlCancellationPending === true;
+  if (state === "cancelling" && !hitlCleanupIncomplete) {
+    const {
+      error: _legacyError,
+      staleSchedulerState: _legacyStale,
+      ...cancelling
+    } = result;
     const lines2 = [
-      `Cancellation queued for ${result.runId || runId}; sandbox cleanup is pending`,
+      `Cancelling run ${result.runId || runId}; sandbox cleanup and the final run update are pending.`,
       ...result.hitlCancelledCount > 0 ? [`cancelled HITL waits: ${result.hitlCancelledCount}`] : [],
       `inspect: deepline runs get ${runId} --full --json`
     ];
     printCommandEnvelope(
       {
-        ...result,
+        ...cancelling,
+        state,
+        stopped: false,
+        cancelling: true,
         render: {
           sections: [
             {
@@ -34847,9 +35119,8 @@ async function handleRunStop(args) {
     );
     return 0;
   }
-  const stopNotConfirmed = result.stopped === false || result.staleSchedulerState === true;
-  if (stopNotConfirmed) {
-    const detail = typeof result.error === "string" && result.error.trim() ? result.error.trim() : result.staleSchedulerState === true ? "scheduler state for the run is stale" : "the server did not confirm the stop";
+  if (state === "failed" || hitlCleanupIncomplete) {
+    const detail = typeof result.error === "string" && result.error.trim() ? result.error.trim() : hitlCleanupIncomplete ? "cancellation is queued, but HITL cleanup is still pending" : result.staleSchedulerState === true ? "scheduler state for the run is stale" : "the server did not confirm the stop";
     const lines2 = [
       `Failed to stop run ${runId}: ${detail}.`,
       ...result.hitlCancelledCount > 0 ? [`cancelled HITL waits: ${result.hitlCancelledCount}`] : [],
@@ -35391,7 +35662,7 @@ async function handlePlayList(args) {
         `    cost estimate: ${formatPlayCostEstimate(play.costEstimate)}`
       );
     }
-    lines.push(`    run: deepline plays run ${reference} --watch`);
+    lines.push(`    run: deepline plays run ${reference}`);
   }
   if (page.hasMore) {
     lines.push("List truncated \u2014 more plays are available.");
@@ -36213,7 +36484,6 @@ Run and retrieve results:
   2. Start and follow a new run: deepline plays run workflow.play.ts --csv contacts.csv
      This example requires input.csv. Use the selected Play's actual input fields.
      Run waits and shows progress by default; --no-wait returns immediately.
-     --watch and --wait are redundant compatibility aliases for the default.
   3. Read its overview: deepline runs get <run-id> --json
   4. Export complete rows: deepline runs export <run-id> --dataset <returned-selector> --out results.csv
   If disconnected, attach to the SAME run with deepline runs tail <run-id>.
@@ -36302,8 +36572,7 @@ Notes:
   Named plays run the live saved revision.
   File args accept local paths; the CLI stages files before submit.
   By default, run waits for completion and prints logs, previews, stats, and
-  next commands. --watch and --wait are accepted compatibility aliases for the
-  default behavior. Use --no-wait only when you intentionally want
+   next commands. Use --no-wait only when you intentionally want
   a fire-and-forget run id.
   --run-id-file writes the durable run id to a versioned JSON file as soon as
   the server accepts the run. The destination must not already exist.
@@ -36373,12 +36642,29 @@ Examples:
   ).option(
     "--fixture-behavior <json>",
     "Internal/testing: fixture response behavior JSON object or @file path"
-  ).option("--watch", "Compatibility alias; run waits by default").option("--wait", "Compatibility alias; run waits by default").option("--no-wait", "Start the run and return immediately").option(
+  ).addOption(
+    new Option3(
+      "--watch",
+      "Compatibility alias; run waits by default"
+    ).hideHelp()
+  ).addOption(
+    new Option3(
+      "--wait",
+      "Compatibility alias; run waits by default"
+    ).hideHelp()
+  ).option("--no-wait", "Start the run and return immediately").option(
     "--run-id-file <path>",
     "Atomically write the accepted run id to a new JSON file"
-  ).option("--logs", "Compatibility alias for --log-level debug").option(
-    "--debug [value]",
-    "Compatibility alias for --log-level debug when bare; --debug <value> remains legacy Play input.debug"
+  ).addOption(
+    new Option3(
+      "--logs",
+      "Compatibility alias for --log-level debug"
+    ).hideHelp()
+  ).addOption(
+    new Option3(
+      "--debug [value]",
+      "Compatibility alias for --log-level debug when bare; --debug <value> remains legacy Play input.debug"
+    ).hideHelp()
   ).option(
     "--log-level <level>",
     "Minimum live log severity: debug, info (default), warn, or error"
@@ -36855,15 +37141,15 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
-  const runs = program.command("runs").description("Inspect, tail, stop, and export play runs.").addHelpText(
+  const runs = program.command("runs").description("Inspect, watch, stop, and export play runs.").addHelpText(
     "after",
     `
 Concepts:
   A run is one execution instance of a play. It has status, progress, logs,
   returned result, dataset previews, recovery metadata, and optional dataset export.
   plays run starts NEW work and follows it by default; --no-wait returns immediately.
-  runs tail attaches to EXISTING work and follows progress without starting a run.
-  Use tail after a disconnect or --no-wait; do not launch again to reconnect.
+  runs watch attaches to EXISTING work and follows progress without starting a run.
+  Use watch after a disconnect or --no-wait; do not launch again to reconnect.
   get reads the current overview once. logs fetches persisted log history.
   stop requests cancellation. rerun starts new work and may spend credits.
 
@@ -36877,14 +37163,15 @@ Retrieve results:
   not JSON rows. For a JSON row file, use --format json --out results.json.
 
 Follow existing work:
-  deepline runs tail <run-id>
-  tail --json waits for one terminal JSON document; --jsonl streams live events.
-  There is no runs watch command; tail is the live-follow command.
+  deepline runs watch <run-id>
+  watch --json waits for one terminal JSON document; --jsonl streams live events.
+  runs tail is an alias of runs watch.
 
 More options:
   deepline runs get -h
   deepline runs children -h
   deepline runs tail -h
+  deepline runs watch -h
   deepline runs export -h
   deepline plays -h
 
@@ -36931,6 +37218,7 @@ Notes:
   Run activity and status evidence retain provider cooldown and call progress.
   Use --input only when you intentionally need the original payload; it can
   contain customer data and is never included in ordinary status output.
+  --config reads only the recorded graph and source; it never uses current Play code.
   --json run.status,datasets.name,actions selects fields without flattening.
   Selection changes stdout only, not the server query. Optional missing paths
   are omitted; array positions are preserved. --json diagnostics needs --full.
@@ -36942,6 +37230,7 @@ Examples:
   deepline runs get play/my-play/run/20260501t000000-000 --log-failed --json
   deepline runs get play/my-play/run/20260501t000000-000 --full --json
   deepline runs get play/my-play/run/20260501t000000-000 --input
+  deepline runs get play/my-play/run/20260501t000000-000 --config --json
 `
   ).option(
     "--json [fields]",
@@ -36952,6 +37241,9 @@ Examples:
   ).option(
     "--input",
     "Explicitly print the original retained input JSON (may contain customer data)"
+  ).option(
+    "--config",
+    "Explicitly print the recorded configuration, without full results"
   ).option(
     "--log-failed",
     "Attach a bounded terminal-failure log window for failed runs"
@@ -36961,6 +37253,7 @@ Examples:
       ...jsonFieldArgs(options.json),
       ...options.full ? ["--full"] : [],
       ...options.input ? ["--input"] : [],
+      ...options.config ? ["--config"] : [],
       ...options.logFailed ? ["--log-failed"] : []
     ]);
   });
@@ -37060,9 +37353,8 @@ Notes:
   logs for persisted log history. In human output, --compact prints
   deduplicated step transitions and progress. --json emits one terminal
   package. --jsonl emits canonical watched events as JSON Lines and ends with
-  the same compact package shape as runs get --json. The tail command remains
-  an alias. --log-level
-  filters the rendered customer-safe runtime log lines; debug includes runtime
+  the same compact package shape as runs get --json. --log-level filters the
+  rendered customer-safe runtime log lines; debug includes runtime
   and receipt diagnostics and writes them to stderr alongside JSON output.
 
 Examples:
@@ -37078,7 +37370,17 @@ Examples:
   ).option(
     "--compact",
     "Show deduplicated human step transitions and progress"
-  ).option("--logs", "Compatibility alias for --log-level debug").option("--debug", "Compatibility alias for --log-level debug").option(
+  ).addOption(
+    new Option3(
+      "--logs",
+      "Compatibility alias for --log-level debug"
+    ).hideHelp()
+  ).addOption(
+    new Option3(
+      "--debug",
+      "Compatibility alias for --log-level debug"
+    ).hideHelp()
+  ).option(
     "--log-level <level>",
     "Minimum severity: debug, info (default), warn, or error"
   ).action(async (runId, options) => {
@@ -37100,7 +37402,17 @@ Examples:
   ).option("--out <path>", "Write the full retained log stream to a file").option("--failed", "Show the bounded terminal-failure log window").option(
     "--log-level <level>",
     "Minimum severity: debug (default), info, warn, or error"
-  ).option("--logs", "Compatibility alias for --log-level debug").option("--debug", "Compatibility alias for --log-level debug").option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--since <timestamp>", "Search events since this UTC timestamp").option("--until <timestamp>", "Search events before this UTC timestamp").option("--play <name>", "Filter events by Play name").option(
+  ).addOption(
+    new Option3(
+      "--logs",
+      "Compatibility alias for --log-level debug"
+    ).hideHelp()
+  ).addOption(
+    new Option3(
+      "--debug",
+      "Compatibility alias for --log-level debug"
+    ).hideHelp()
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--since <timestamp>", "Search events since this UTC timestamp").option("--until <timestamp>", "Search events before this UTC timestamp").option("--play <name>", "Filter events by Play name").option(
     "--kind <kind>",
     "Search one exact event kind; complete catalog below"
   ).option(
@@ -37109,7 +37421,10 @@ Examples:
   ).option(
     "--payloads",
     "Search with canonical eventPayload or receipt payload; max 10 events, 16 MiB"
-  ).option("--cursor <token>", "Continue a bounded event search").option(
+  ).option(
+    "--cursor <token>",
+    "Continue paging: older run-log lines (nextCursor) or a bounded event search"
+  ).option(
     "--runtime-namespace <name>",
     "Search an explicitly authorized Preview namespace"
   ).option("--runtime-backend <backend>", "Preview backend: daytona or modal").action(async (runId, options) => {
@@ -37432,11 +37747,11 @@ async function handlePlaySharePublish(args) {
           ok: false,
           code: "NO_SUCCESSFUL_RUN",
           message,
-          next: `deepline plays run ${name} --wait`
+          next: `deepline plays run ${name}`
         });
       } else {
         console.error(message);
-        console.error(`  deepline plays run ${name} --wait`);
+        console.error(`  deepline plays run ${name}`);
       }
       return 7;
     }
@@ -42422,7 +42737,7 @@ function registerEnrichCommand(program) {
     "--open",
     "Open the generated play page in a browser after the run starts."
   ).addOption(
-    new Option3(
+    new Option4(
       "--no-open [legacy-value]",
       "Removed legacy option"
     ).hideHelp()
@@ -42812,7 +43127,7 @@ function registerExecutionsCommands(program) {
 }
 
 // src/cli/commands/feedback.ts
-import { Option as Option4 } from "commander";
+import { Option as Option5 } from "commander";
 import { readFileSync as readFileSync10 } from "fs";
 async function handleFeedback(text, options) {
   const message = resolveFeedbackText(text, options.file);
@@ -42878,7 +43193,7 @@ Notes:
   to submit the report.
 
 Examples:
-  deepline feedback send "plays run failed after upload" --command "deepline plays run my.play.ts --watch" --error-outcome terminal
+  deepline feedback send "plays run failed after upload" --command "deepline plays run my.play.ts" --error-outcome terminal
   deepline feedback send "unexpected billing output" --payload '{"command":"billing usage"}' --json
 `
   );
@@ -42890,10 +43205,10 @@ Examples:
   deepline feedback send --file incident.md --requested --json
   cat incident.md | deepline feedback send --requested --json
   deepline feedback send "tools search returned stale results" --requested --json
-  deepline feedback send "plays run failed after upload" --command "deepline plays run my.play.ts --watch" --error-outcome terminal
+  deepline feedback send "plays run failed after upload" --command "deepline plays run my.play.ts" --error-outcome terminal
 `
   ).argument("[text]", "Feedback text").option("--file <path>", "Read feedback text from a file, or - for stdin").option("--command <command>", "Command that reproduced the issue").option("--payload <payload>", "JSON or plain-text payload for the repro").addOption(
-    new Option4(
+    new Option5(
       "--error-outcome <outcome>",
       "Error impact on the task: terminal or continued"
     ).choices(["terminal", "continued"])
@@ -54198,7 +54513,7 @@ Examples:
 }
 
 // src/cli/commands/tools.ts
-import { Option as Option5 } from "commander";
+import { Option as Option6 } from "commander";
 import {
   chmodSync,
   existsSync as existsSync20,
@@ -55228,7 +55543,7 @@ function isMissingToolMetadataError(error) {
 function playAliasToolErrorMessage(toolId, play) {
   const playName = play.reference ?? play.name;
   return `${toolId} is a play, not a tool.
-Use: deepline plays run ${playName} --input '{...}' --watch
+Use: deepline plays run ${playName} --input '{...}'
 Inspect its schema with: deepline plays describe ${playName} --json`;
 }
 function printPlayAliasToolError(toolId, play) {
@@ -55260,11 +55575,11 @@ function playRunCommandForTool(tool, toolId, input2) {
   const playReference = playReferenceForTool(tool);
   if (!playReference) return playSearchCommandForToolId(toolId);
   const inputArg = input2 === void 0 ? "'{...}'" : `'${JSON.stringify(input2)}'`;
-  return `deepline plays run ${playReference} --input ${inputArg} --watch`;
+  return `deepline plays run ${playReference} --input ${inputArg}`;
 }
 function playLikeToolExecuteErrorMessage(toolId, tool) {
   const playReference = tool ? playReferenceForTool(tool) : null;
-  const nextStep = playReference ? `Use: deepline plays run ${playReference} --input '{...}' --watch` : `Find the maintained workflow with: ${playSearchCommandForToolId(toolId)}`;
+  const nextStep = playReference ? `Use: deepline plays run ${playReference} --input '{...}'` : `Find the maintained workflow with: ${playSearchCommandForToolId(toolId)}`;
   return [
     `${toolId} is a workflow/play entry, not an atomic provider tool.`,
     nextStep,
@@ -55440,12 +55755,12 @@ Examples:
     "--examples-only",
     "Only print runnable examples and sample payloads"
   ).option("--getters-only", "Only print extracted list/value getters").addOption(
-    new Option5(
+    new Option6(
       "--compact",
       "Compatibility alias for the default compact view"
     ).hideHelp()
   ).addOption(
-    new Option5(
+    new Option6(
       "--contract-json",
       "Compatibility alias for compact contract JSON"
     ).hideHelp()
@@ -58460,7 +58775,7 @@ async function main() {
   if (printStartupPhase) {
     progress?.phase("loading deepline cli");
   }
-  const program = new Command6();
+  const program = new Command7();
   program.name("deepline").description(
     "Deepline CLI \u2014 GTM enrichment tools, plays, and runs from your terminal."
   ).version(SDK_VERSION, "-v, --version", "Show version").exitOverride().showHelpAfterError().showSuggestionAfterError(true).addHelpText(