deepline 0.1.85 → 0.1.89

package/dist/cli/index.js

@@ -229,10 +229,10 @@ var import_node_path2 = require("path");
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.85",
+  version: "0.1.89",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.85",
+    latest: "0.1.89",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -246,6 +246,7 @@ var SDK_API_CONTRACT = SDK_RELEASE.apiContract;
 var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
 var COORDINATOR_URL_OVERRIDE_HEADER = "x-deepline-coordinator-url";
 var WORKER_CALLBACK_URL_OVERRIDE_HEADER = "x-deepline-worker-callback-url";
+var SYNTHETIC_RUN_HEADER = "x-deepline-synthetic-run";
 
 // src/http.ts
 var MAX_DIAGNOSTIC_HEADER_LENGTH = 120;
@@ -313,6 +314,10 @@ var HttpClient = class {
     if (workerCallbackUrl?.trim()) {
       headers[WORKER_CALLBACK_URL_OVERRIDE_HEADER] = workerCallbackUrl.trim();
     }
+    const syntheticRun = typeof process !== "undefined" ? process.env?.DEEPLINE_SYNTHETIC_RUN : void 0;
+    if (syntheticRun && syntheticRun.trim() && syntheticRun.trim() !== "0") {
+      headers[SYNTHETIC_RUN_HEADER] = "1";
+    }
     return headers;
   }
   /**
@@ -579,7 +584,7 @@ function decodeSseFrame(frame) {
   return parsed;
 }
 function sleep(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 
 // src/client.ts
@@ -589,7 +594,7 @@ var EXECUTE_RESPONSE_CONTRACT_HEADER = "x-deepline-execute-response-contract";
 var V2_EXECUTE_RESPONSE_CONTRACT = "v2-tool-response";
 var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
 function sleep2(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 function isTransientCompileManifestError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
@@ -603,6 +608,21 @@ function isTransientCompileManifestError(error) {
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function isPrebuiltPlayDescription(play) {
+  return play.origin === "prebuilt" || play.ownerType === "deepline";
+}
+function preferPrebuiltPlayDescriptions(plays) {
+  const prebuilt = [];
+  const owned = [];
+  for (const play of plays) {
+    if (isPrebuiltPlayDescription(play)) {
+      prebuilt.push(play);
+    } else {
+      owned.push(play);
+    }
+  }
+  return [...prebuilt, ...owned];
+}
 function isPlayRunPackage(value) {
   return Boolean(
     value && typeof value === "object" && !Array.isArray(value) && value.kind === "play_run" && value.run && typeof value.run?.id === "string"
@@ -726,8 +746,14 @@ function playRunStatusFromState(state) {
 var DeeplineClient = class {
   http;
   config;
+  /** Canonical run lifecycle namespace backed by `/api/v2/runs`. */
   runs;
   /**
+   * Create a low-level SDK client.
+   *
+   * Most callers can omit options and let the SDK resolve auth/config from
+   * environment variables and CLI-managed credentials.
+   *
    * @param options - Optional overrides for API key, base URL, timeout, and retries.
    * @throws {@link ConfigError} if no API key can be resolved from any source.
    */
@@ -829,12 +855,19 @@ var DeeplineClient = class {
   // ——————————————————————————————————————————————————————————
   // Secrets
   // ——————————————————————————————————————————————————————————
+  /** List secret metadata visible to the current workspace. */
   async listSecrets() {
     const response = await this.http.get(
       "/api/v2/secrets"
     );
     return Array.isArray(response.secrets) ? response.secrets : [];
   }
+  /**
+   * Check whether a named secret exists, is active, and has a stored value.
+   *
+   * @param name - Secret name. It is normalized to uppercase before lookup.
+   * @returns Matching active secret metadata, or `null`.
+   */
   async checkSecret(name) {
     const normalized = name.trim().toUpperCase();
     const secrets = await this.listSecrets();
@@ -947,9 +980,21 @@ var DeeplineClient = class {
       headers
     );
   }
+  /**
+   * Back-compatible alias for {@link executeTool}.
+   *
+   * Retained for callers that still use the older raw naming while the response
+   * envelope remains the same.
+   */
   async executeToolRaw(toolId, input2, options) {
     return this.executeTool(toolId, input2, options);
   }
+  /**
+   * Run a bounded SQL query against the customer data plane.
+   *
+   * Use this from trusted backend or agent contexts only. The API enforces
+   * workspace scoping and row limits.
+   */
   async queryCustomerDb(input2) {
     return this.http.post("/api/v2/db/query", {
       sql: input2.sql,
@@ -1021,6 +1066,17 @@ var DeeplineClient = class {
     );
     return normalizePlayRunStart(response);
   }
+  /**
+   * Start a play run and stream live runtime events from the same request.
+   *
+   * Use this when a caller wants low-level event handling instead of submitting
+   * first and then connecting to `streamPlayRunEvents(runId)`.
+   *
+   * @param request - Play run configuration.
+   * @param options - Optional streaming options.
+   * @param options.signal - Optional abort signal for the streaming request.
+   * @returns Async stream of play-scoped live events.
+   */
   async *startPlayRunStream(request, options) {
     const body = {
       ...request.name ? { name: request.name } : {},
@@ -1073,6 +1129,12 @@ var DeeplineClient = class {
       compilerManifest
     });
   }
+  /**
+   * Register multiple bundled play artifacts in one request.
+   *
+   * Used by packaging and prebuilt publication flows. Each artifact is compiled
+   * first when a compiler manifest is not already supplied.
+   */
   async registerPlayArtifacts(artifacts) {
     const compiledArtifacts = await Promise.all(
       artifacts.map(async (artifact) => ({
@@ -1089,6 +1151,13 @@ var DeeplineClient = class {
       artifacts: compiledArtifacts
     });
   }
+  /**
+   * Compile a bundled play artifact into the server-side compiler manifest.
+   *
+   * The manifest records imports, trigger bindings, static pipeline shape, and
+   * runtime metadata needed before a play artifact can be checked, registered,
+   * or run.
+   */
   async compilePlayManifest(input2) {
     const retryDelays = COMPILE_MANIFEST_RETRY_DELAYS_MS.slice(
       0,
@@ -1117,9 +1186,21 @@ var DeeplineClient = class {
   async checkPlayArtifact(input2) {
     return this.http.post("/api/v2/plays/check", input2);
   }
+  /**
+   * Compile legacy enrich command arguments into a runtime plan.
+   *
+   * This is primarily used by CLI compatibility paths that translate older
+   * enrichment commands onto the play runtime.
+   */
   async compileEnrichPlan(input2) {
     return this.http.post("/api/v2/enrich/compile", input2);
   }
+  /**
+   * Register an already-bundled play artifact and start a run from it.
+   *
+   * This is the low-level file-backed run path used by SDK/CLI packaging
+   * wrappers after local bundling has produced the runtime artifact.
+   */
   async startPlayRunFromBundle(input2) {
     const compilerManifest = input2.compilerManifest ?? await this.compilePlayManifest({
       name: input2.name,
@@ -1277,6 +1358,12 @@ var DeeplineClient = class {
     const response = await this.http.postFormData("/api/v2/plays/files/stage", buildFormData);
     return response.files;
   }
+  /**
+   * Resolve staged play files by content hash without uploading bytes.
+   *
+   * Missing files are returned so callers can upload only the files the server
+   * does not already have.
+   */
   async resolveStagedPlayFiles(files) {
     return this.http.post("/api/v2/plays/files/stage", { files });
   }
@@ -1493,6 +1580,12 @@ var DeeplineClient = class {
       entries
     };
   }
+  /**
+   * Export persisted runtime-sheet rows for a play dataset/table namespace.
+   *
+   * This is the SDK form of exporting `ctx.dataset(...).run()` output for a
+   * specific play and optional run id.
+   */
   async getPlaySheetRows(input2) {
     const params = new URLSearchParams({
       tableNamespace: input2.tableNamespace,
@@ -1521,6 +1614,12 @@ var DeeplineClient = class {
       options?.reason ? { reason: options.reason } : {}
     );
   }
+  /**
+   * List callable plays visible to the workspace.
+   *
+   * Pass `origin: "prebuilt"` for Deepline-managed prebuilts or
+   * `origin: "owned"` for org-owned plays.
+   */
   async listPlays(options) {
     const params = new URLSearchParams();
     if (options?.origin) params.set("origin", options.origin);
@@ -1535,15 +1634,32 @@ var DeeplineClient = class {
     );
     return response.plays ?? [];
   }
+  /**
+   * Search callable plays and return compact play descriptions.
+   *
+   * Prebuilt plays are preferred by default because they have maintained
+   * contracts and stable run behavior.
+   */
   async searchPlays(options) {
     const params = new URLSearchParams();
     params.set("search", options.query.trim());
+    const scope = options.scope ?? "prebuilt";
+    if (scope !== "all") {
+      params.set("origin", scope);
+    }
     const response = await this.http.get(
       `/api/v2/plays?${params.toString()}`
     );
-    return (response.plays ?? []).map(
+    const plays = (response.plays ?? []).map(
       (play) => this.summarizePlayListItem(play, options)
     );
+    if (scope === "prebuilt") {
+      return plays.filter(isPrebuiltPlayDescription);
+    }
+    if (scope === "owned") {
+      return plays.filter((play) => !isPrebuiltPlayDescription(play));
+    }
+    return preferPrebuiltPlayDescriptions(plays);
   }
   /**
    * Get the full definition and state of a named play.
@@ -1566,6 +1682,12 @@ var DeeplineClient = class {
     const encodedName = encodeURIComponent(name);
     return this.http.get(`/api/v2/plays/${encodedName}`);
   }
+  /**
+   * Get a normalized play description suitable for agents and CLIs.
+   *
+   * The description includes runnable examples, input/output summaries, clone
+   * guidance, revision state, and latest run metadata when available.
+   */
   async describePlay(name, options) {
     const detail = await this.getPlay(name);
     return this.summarizePlayDetail(detail, options);
@@ -2420,7 +2542,7 @@ function buildCandidateUrls2(url) {
   }
 }
 function sleep3(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 function printDeeplineLogo() {
   if (process.stdout.isTTY && (process.stdout.columns ?? 80) >= 70) {
@@ -4675,7 +4797,12 @@ function readPackageVersionFromPackageJson(packageJsonPath, packageName) {
   return null;
 }
 function findPackageJsonPathFrom(startDir, packageName) {
-  let current = (0, import_node_path8.resolve)(startDir);
+  if (!(0, import_node_path8.isAbsolute)(startDir)) {
+    throw new Error(
+      `Package resolution requires an absolute start directory, got ${startDir}`
+    );
+  }
+  let current = startDir;
   while (true) {
     const packageJsonPath = (0, import_node_path8.join)(
       current,
@@ -4695,17 +4822,15 @@ function findPackageJsonPathFrom(startDir, packageName) {
 }
 function findPackageJsonPath(packageName, fromFile, adapter) {
   const startDirs = [
-    (0, import_node_path8.dirname)(fromFile),
-    adapter.projectRoot,
-    (0, import_node_path8.dirname)(adapter.sdkPackageJson),
-    process.cwd()
+    (0, import_node_path8.resolve)((0, import_node_path8.dirname)(fromFile)),
+    (0, import_node_path8.resolve)(adapter.projectRoot),
+    (0, import_node_path8.resolve)((0, import_node_path8.dirname)(adapter.sdkPackageJson))
   ];
   const seen = /* @__PURE__ */ new Set();
   for (const startDir of startDirs) {
-    const normalized = (0, import_node_path8.resolve)(startDir);
-    if (seen.has(normalized)) continue;
-    seen.add(normalized);
-    const packageJsonPath = findPackageJsonPathFrom(normalized, packageName);
+    if (seen.has(startDir)) continue;
+    seen.add(startDir);
+    const packageJsonPath = findPackageJsonPathFrom(startDir, packageName);
     if (packageJsonPath) return packageJsonPath;
   }
   const adapterNodeModulesPackageJson = (0, import_node_path8.join)(
@@ -5163,13 +5288,13 @@ async function writeArtifactCache(artifact, adapter) {
     "utf-8"
   );
 }
-function normalizeSourceMapForRuntime(sourceMapText) {
+function normalizeSourceMapForRuntime(sourceMapText, projectRoot) {
   const parsed = JSON.parse(sourceMapText);
   parsed.sources = (parsed.sources ?? []).map((sourcePath) => {
     if (sourcePath.startsWith("data:") || sourcePath.startsWith("node:") || sourcePath.startsWith("/") || /^[a-zA-Z]+:\/\//.test(sourcePath)) {
       return sourcePath;
     }
-    return (0, import_node_path8.resolve)(process.cwd(), sourcePath);
+    return (0, import_node_path8.join)(projectRoot, sourcePath);
   });
   parsed.sourceRoot = void 0;
   return JSON.stringify(parsed);
@@ -5435,7 +5560,10 @@ workers-harness:${harnessFingerprint}`
       };
     }
     const { bundledCode, sourceMapText, outputExtension } = buildOutcome;
-    const normalizedSourceMap = normalizeSourceMapForRuntime(sourceMapText);
+    const normalizedSourceMap = normalizeSourceMapForRuntime(
+      sourceMapText,
+      (0, import_node_path8.resolve)(adapter.projectRoot)
+    );
     const virtualBaseName = exportName === "default" ? (0, import_node_path8.basename)(absolutePath).replace(/\.[^.]+$/, "") : `${(0, import_node_path8.basename)(absolutePath).replace(/\.[^.]+$/, "")}.${exportName}`;
     const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${virtualBaseName}.${outputExtension}`;
     const executableCode = `${bundledCode}
@@ -7836,7 +7964,7 @@ function traceCliSync(phase, fields, run) {
   }
 }
 function sleep4(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 function parseReferencedPlayTarget2(target) {
   const trimmed = target.trim();
@@ -8355,6 +8483,8 @@ var TERMINAL_PLAY_STATUSES2 = /* @__PURE__ */ new Set([
   "cancelled"
 ]);
 var PLAY_START_TRANSIENT_RETRY_DELAYS_MS = [500, 1500];
+var PLAY_PROGRESS_HEARTBEAT_INTERVAL_MS = 15e3;
+var PLAY_STATUS_HEARTBEAT_INTERVAL_MS = 15e3;
 function getEventPayload(event) {
   return event.payload && typeof event.payload === "object" ? event.payload : {};
 }
@@ -8415,6 +8545,7 @@ function extractTableNamespaceFromLiveEvent(event) {
   const payload = getEventPayload(event);
   const candidates = [
     payload.artifactTableNamespace,
+    payload.activeArtifactTableNamespace,
     payload.tableNamespace,
     payload.mapNodeId
   ];
@@ -8493,6 +8624,20 @@ function formatProgressCounts(input2) {
   const failed = typeof input2.failed === "number" && Number.isFinite(input2.failed) && input2.failed > 0 ? `, failed ${formatInteger(input2.failed)}` : "";
   return `${formatInteger(completed)}/${formatInteger(total)} (${percent}%)${failed}`;
 }
+function formatProgressMessageSuffix(input2) {
+  const message = typeof input2.message === "string" ? input2.message.trim() : "";
+  if (!message) {
+    return "";
+  }
+  const completed = typeof input2.completed === "number" && Number.isFinite(input2.completed) ? input2.completed : null;
+  if (/^[\d,]+\s*\/\s*[\d,]+\s+rows processed$/i.test(message)) {
+    return "";
+  }
+  if (completed !== null && completed > 0 && /rows?\s+queued\b/i.test(message)) {
+    return "";
+  }
+  return ` - ${message}`;
+}
 function getProgressLinesFromLiveEvent(event) {
   const payload = getEventPayload(event);
   if (event.type === "play.step.progress") {
@@ -8502,7 +8647,13 @@ function getProgressLinesFromLiveEvent(event) {
       failed: payload.failed
     });
     if (!counts) return [];
-    return [`progress ${formatProgressLabel(payload.stepId)}: ${counts}`];
+    const messageSuffix = formatProgressMessageSuffix({
+      message: payload.message,
+      completed: payload.completed
+    });
+    return [
+      `progress ${formatProgressLabel(payload.stepId)}: ${counts}${messageSuffix}`
+    ];
   }
   if (event.type !== "play.run.snapshot" && event.type !== "play.run.final_status") {
     return [];
@@ -8526,22 +8677,69 @@ function getProgressLinesFromLiveEvent(event) {
     if (!counts) {
       continue;
     }
+    const messageSuffix = formatProgressMessageSuffix({
+      message: progress.message,
+      completed: progress.completed
+    });
     lines.push(
-      `progress ${formatProgressLabel(record.nodeId ?? progress.artifactTableNamespace)}: ${counts}`
+      `progress ${formatProgressLabel(record.nodeId ?? progress.artifactTableNamespace)}: ${counts}${messageSuffix}`
     );
   }
   return lines;
 }
+function shouldPrintPlayProgressLine(input2) {
+  if (!input2.signature) {
+    return false;
+  }
+  return input2.lastProgressSignature !== input2.signature || input2.nowMs - input2.lastProgressHeartbeatAt >= PLAY_PROGRESS_HEARTBEAT_INTERVAL_MS;
+}
 function printPlayProgressLines(input2) {
   for (const line of input2.lines) {
     const signature = line.trim();
-    if (!signature || input2.state.lastProgressSignature === signature) {
+    const now = Date.now();
+    if (!shouldPrintPlayProgressLine({
+      signature,
+      lastProgressSignature: input2.state.lastProgressSignature,
+      lastProgressHeartbeatAt: input2.state.lastProgressHeartbeatAt,
+      nowMs: now
+    })) {
       continue;
     }
     input2.state.lastProgressSignature = signature;
+    input2.state.lastProgressHeartbeatAt = now;
     input2.progress.writeLine(line);
   }
 }
+function getRunningHeartbeatLine(input2) {
+  const status = getStatusFromLiveEvent(input2.event);
+  if (status !== "queued" && status !== "running" && status !== "waiting") {
+    return null;
+  }
+  const tableNamespace = extractTableNamespaceFromLiveEvent(input2.event);
+  const target = tableNamespace ? formatProgressLabel(tableNamespace) : input2.playName;
+  if (status === "queued") {
+    return `queued ${target}: waiting for worker capacity`;
+  }
+  if (status === "waiting") {
+    return `waiting ${target}: waiting on external work`;
+  }
+  return `running ${target}: still processing`;
+}
+function printPlayStatusHeartbeat(input2) {
+  const now = Date.now();
+  if (now - input2.state.lastStatusHeartbeatAt < PLAY_STATUS_HEARTBEAT_INTERVAL_MS) {
+    return;
+  }
+  const line = getRunningHeartbeatLine({
+    event: input2.event,
+    playName: input2.playName
+  });
+  if (!line) {
+    return;
+  }
+  input2.state.lastStatusHeartbeatAt = now;
+  input2.progress.writeLine(line);
+}
 function buildPlayDashboardUrl(baseUrl, playName) {
   const trimmedBase = baseUrl.replace(/\/$/, "");
   const encodedPlayName = encodeURIComponent(playName);
@@ -8624,11 +8822,20 @@ async function waitForPlayCompletionByStream(input2) {
         progress: input2.progress
       });
       if (!input2.jsonOutput) {
+        const progressLines = getProgressLinesFromLiveEvent(event);
         printPlayProgressLines({
-          lines: getProgressLinesFromLiveEvent(event),
+          lines: progressLines,
           state: input2.state,
           progress: input2.progress
         });
+        if (progressLines.length === 0) {
+          printPlayStatusHeartbeat({
+            event,
+            playName: input2.playName,
+            state: input2.state,
+            progress: input2.progress
+          });
+        }
       }
       const finalStatus = getFinalStatusFromLiveEvent(event);
       if (finalStatus) {
@@ -8706,7 +8913,9 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
   const state = {
     lastLogIndex: 0,
     emittedRunnerStarted: false,
-    lastProgressSignature: null
+    lastProgressSignature: null,
+    lastProgressHeartbeatAt: 0,
+    lastStatusHeartbeatAt: 0
   };
   const controller = new AbortController();
   let timedOut = false;
@@ -8747,7 +8956,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
           dashboardUrl,
           noOpen: input2.noOpen
         });
-        input2.progress.phase(`loading play on ${dashboardUrl}`);
+        input2.progress.phase("running");
         emittedDashboardUrl = true;
       }
       assertPlayWaitNotTimedOut({
@@ -8778,11 +8987,20 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
         progress: input2.progress
       });
       if (!input2.jsonOutput) {
+        const progressLines = getProgressLinesFromLiveEvent(event);
         printPlayProgressLines({
-          lines: getProgressLinesFromLiveEvent(event),
+          lines: progressLines,
           state,
           progress: input2.progress
         });
+        if (progressLines.length === 0) {
+          printPlayStatusHeartbeat({
+            event,
+            playName: input2.playName,
+            state,
+            progress: input2.progress
+          });
+        }
       }
       const finalStatus = getFinalStatusFromLiveEvent(event);
       if (finalStatus) {
@@ -9382,6 +9600,17 @@ function getPlayRunPackage(status) {
   const packaged = status.package;
   return isPlayRunPackageValue(packaged) ? packaged : null;
 }
+function withTerminalPlayIdentity(status, playName) {
+  if (!playName.trim() || getPlayRunPackage(status)) {
+    return status;
+  }
+  const record = status;
+  const hasIdentity = typeof record.playName === "string" && record.playName.trim().length > 0 || typeof record.name === "string" && record.name.trim().length > 0 || Boolean(getStringField(record.run, "playName"));
+  if (hasIdentity) {
+    return status;
+  }
+  return { ...status, playName };
+}
 function compactPlayStatus(status) {
   const packaged = getPlayRunPackage(status);
   if (packaged) {
@@ -9558,6 +9787,9 @@ function actionToCommand(action) {
   if (record.kind === "deepline_run_inspect" && typeof record.runId === "string") {
     return `deepline runs get ${record.runId} --json`;
   }
+  if (record.kind === "deepline_run_billing" && typeof record.runId === "string") {
+    return `deepline runs get ${record.runId} --full --json | jq '.billing'`;
+  }
   if (record.kind === "deepline_run_export" && typeof record.runId === "string" && typeof record.datasetPath === "string") {
     return `deepline runs export ${record.runId} --dataset ${shellSingleQuote(
       record.datasetPath
@@ -9590,6 +9822,12 @@ function buildRunPackageTextLines(packaged) {
   if (playName) {
     lines.push(`  play: ${playName}`);
   }
+  const next = packaged.next && typeof packaged.next === "object" && !Array.isArray(packaged.next) ? packaged.next : {};
+  const billingCommand = actionToCommand(next.billing);
+  if (billingCommand) {
+    const costState = status === "completed" || status === "failed" || status === "cancelled" ? "finalizing" : "pending";
+    lines.push(`  cost: ${costState}`);
+  }
   for (const step of readRecordArray(packaged.steps).slice(0, 8)) {
     const id = typeof step.id === "string" ? step.id : "step";
     const kind = typeof step.kind === "string" ? step.kind : "step";
@@ -9606,12 +9844,12 @@ function buildRunPackageTextLines(packaged) {
       );
     }
   }
-  const next = packaged.next && typeof packaged.next === "object" && !Array.isArray(packaged.next) ? packaged.next : {};
   const datasetActions = readFirstDatasetActions(packaged);
   const inspectCommand = actionToCommand(next.inspect);
   const queryCommand = actionToCommand(next.query) ?? actionToCommand(datasetActions.query);
   const exportCommand = actionToCommand(next.export) ?? actionToCommand(datasetActions.exportCsv);
   if (inspectCommand) lines.push(`  inspect: ${inspectCommand}`);
+  if (billingCommand) lines.push(`  billing: ${billingCommand}`);
   if (queryCommand) lines.push(`  query: ${queryCommand}`);
   if (exportCommand) lines.push(`  export CSV: ${exportCommand}`);
   return lines;
@@ -10653,11 +10891,14 @@ async function handleFileBackedRun(options) {
     } else {
       progress.fail();
     }
-    const outputStatus = await resolvePlayRunOutputStatus({
-      client,
-      status: finalStatus,
-      fullJson: options.fullJson
-    });
+    const outputStatus = withTerminalPlayIdentity(
+      await resolvePlayRunOutputStatus({
+        client,
+        status: finalStatus,
+        fullJson: options.fullJson
+      }),
+      playName
+    );
     traceCliSync(
       "cli.play_write_result",
       { targetKind: "file", playName },
@@ -10680,7 +10921,7 @@ async function handleFileBackedRun(options) {
     dashboardUrl: resolvedDashboardUrl,
     noOpen: options.noOpen
   });
-  progress.phase(`loading play on ${resolvedDashboardUrl}`);
+  progress.phase("started run");
   progress.complete();
   writeStartedPlayRun({
     runId: started.workflowId,
@@ -10800,11 +11041,14 @@ async function handleNamedRun(options) {
     } else {
       progress.fail();
     }
-    const outputStatus = await resolvePlayRunOutputStatus({
-      client,
-      status: finalStatus,
-      fullJson: options.fullJson
-    });
+    const outputStatus = withTerminalPlayIdentity(
+      await resolvePlayRunOutputStatus({
+        client,
+        status: finalStatus,
+        fullJson: options.fullJson
+      }),
+      playName
+    );
     traceCliSync(
       "cli.play_write_result",
       { targetKind: "name", playName },
@@ -10827,7 +11071,7 @@ async function handleNamedRun(options) {
     dashboardUrl: resolvedDashboardUrl,
     noOpen: options.noOpen
   });
-  progress.phase(`loading play on ${resolvedDashboardUrl}`);
+  progress.phase("started run");
   progress.complete();
   writeStartedPlayRun({
     runId: started.workflowId,
@@ -11315,16 +11559,19 @@ function parsePlaySearchOptions(args) {
   const query = args[0]?.trim();
   if (!query) {
     throw new Error(
-      "Usage: deepline plays search <query> [--compact] [--json]"
+      "Usage: deepline plays search <query> [--all] [--compact] [--json]"
     );
   }
   return {
     query,
     jsonOutput: argsWantJson(args),
     compact: args.includes("--compact"),
-    prebuiltOnly: args.includes("--prebuilt")
+    scope: args.includes("--all") && !args.includes("--prebuilt") ? "all" : "prebuilt"
   };
 }
+function playSearchDisclaimer(scope) {
+  return scope === "all" ? "Prebuilt-first search: Deepline-managed prebuilts are trusted, robust plays with maintained contracts, so they are listed before plays you created. Use created-play results only when you are specifically looking for one." : "Prebuilt-first search: Deepline-managed prebuilts are trusted, robust plays with maintained contracts. Plays you created are omitted by default; add --all only when you are specifically looking for one.";
+}
 function printPlayDescription(play) {
   const reference = formatPlayListReference(play);
   const labels = [
@@ -11466,19 +11713,26 @@ async function handlePlaySearch(args) {
     return 1;
   }
   const client = new DeeplineClient();
-  const plays = (await client.searchPlays({
+  const plays = await client.searchPlays({
     query: options.query,
-    compact: options.compact
-  })).filter(
-    (play) => options.prebuiltOnly ? play.origin === "prebuilt" || play.ownerType === "deepline" : true
-  );
+    compact: options.compact,
+    scope: options.scope
+  });
+  const disclaimer = playSearchDisclaimer(options.scope);
   if (options.jsonOutput) {
-    const jsonPlays = options.prebuiltOnly ? plays.map((play) => ({
+    const jsonPlays = options.scope === "prebuilt" ? plays.map((play) => ({
       ...play,
       inputSchema: compactPlaySchema(play.inputSchema)
     })) : plays;
     process.stdout.write(
       `${JSON.stringify({
+        disclaimer,
+        search_policy: {
+          default_scope: "prebuilt",
+          included_origins: options.scope === "all" ? ["prebuilt", "owned"] : ["prebuilt"],
+          owned_plays_omitted: options.scope === "prebuilt",
+          include_owned_flag: "--all"
+        },
         plays: jsonPlays,
         total: jsonPlays.length,
         truncated: false
@@ -11487,21 +11741,23 @@ async function handlePlaySearch(args) {
     );
     return 0;
   }
-  const displayPlays = options.prebuiltOnly ? plays.slice(0, 5) : plays;
+  const displayPlays = options.scope === "prebuilt" ? plays.slice(0, 5) : plays;
+  process.stdout.write(`${disclaimer}
+`);
   process.stdout.write(
-    `${plays.length} plays found${options.prebuiltOnly && plays.length > displayPlays.length ? `; showing top ${displayPlays.length}` : ""}:
+    `${plays.length} plays found${options.scope === "prebuilt" && plays.length > displayPlays.length ? `; showing top ${displayPlays.length}` : ""}:
 
 `
   );
   for (const play of displayPlays) {
-    if (options.prebuiltOnly) {
+    if (options.scope === "prebuilt") {
       printCompactPlaySearchResult(play);
     } else {
       printPlayDescription(play);
     }
     console.log("");
   }
-  if (options.prebuiltOnly && plays.length > displayPlays.length) {
+  if (options.scope === "prebuilt" && plays.length > displayPlays.length) {
     console.log("Use --json for the full machine-readable result set.");
   }
   return 0;
@@ -11955,18 +12211,26 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
-  const addPlaySearchCommand = (command) => command.description("Search saved and prebuilt plays.").option("--prebuilt", "Only show Deepline-managed prebuilt plays").addHelpText(
+  const addPlaySearchCommand = (command) => command.description("Search Deepline prebuilt plays by task.").option(
+    "--prebuilt",
+    "Only show Deepline-managed prebuilt plays (default)"
+  ).option(
+    "--all",
+    "Also include plays you created after Deepline-managed prebuilts"
+  ).addHelpText(
     "after",
     `
 Notes:
-  Ranked discovery for workflows. Use describe on a result before running it.
-  Prefer --prebuilt for new GTM tasks so old workspace scratchpads do not
-  outrank Deepline-managed routes unless the user names one explicitly.
+  Ranked discovery for workflows. Search defaults to Deepline-managed prebuilts
+  because they are trusted, robust plays with maintained contracts. Use describe
+  on a result before running it.
+  Add --all only when you are specifically looking for a play you created.
   The grep alias is the same ranked retrieval surface with a more literal name
   for agents that are filtering the play registry.
 
 Examples:
   deepline plays search email
+  deepline plays search email --all
   deepline plays grep "linkedin to email" --compact --json
   deepline plays describe person-linkedin-to-email --json
 `
@@ -11974,6 +12238,7 @@ Examples:
     process.exitCode = await handlePlaySearch([
       query,
       ...options.prebuilt ? ["--prebuilt"] : [],
+      ...options.all ? ["--all"] : [],
       ...options.compact ? ["--compact"] : [],
       ...options.json ? ["--json"] : []
     ]);
@@ -13741,7 +14006,7 @@ async function readHiddenLine(prompt) {
   if (typeof import_node_process.stdin.setRawMode === "function") import_node_process.stdin.setRawMode(true);
   let value = "";
   import_node_process.stdin.resume();
-  return await new Promise((resolve13, reject) => {
+  return await new Promise((resolve14, reject) => {
     let settled = false;
     const cleanup = () => {
       import_node_process.stdin.off("data", onData);
@@ -13756,7 +14021,7 @@ async function readHiddenLine(prompt) {
       settled = true;
       import_node_process.stdout.write("\n");
       cleanup();
-      resolve13(line);
+      resolve14(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -14521,7 +14786,13 @@ Examples:
   ).option(
     "--json [payload]",
     "Emit JSON output. Use `--input` or `--payload` for passing JSON params."
-  ).option("--input <payload>", "Merge a JSON object into the tool params").option("--payload <payload>", "Merge a JSON object into the tool params").option(
+  ).option(
+    "--input <payload>",
+    "Merge a JSON object or @file path into the tool params"
+  ).option(
+    "--payload <payload>",
+    "Merge a JSON object or @file path into the tool params"
+  ).option(
     "--output-format <format>",
     "Output format: auto, csv, csv_file, json, or json_file"
   ).option(
@@ -15092,6 +15363,57 @@ function normalizeOutputFormat(raw) {
       throw new Error(`Invalid value for --output-format: ${raw}`);
   }
 }
+function resolveAtFilePath(rawPath) {
+  const trimmed = rawPath.trim();
+  const resolved = (0, import_node_path15.resolve)(trimmed);
+  if ((0, import_node_fs12.existsSync)(resolved)) return resolved;
+  if (process.platform !== "win32" && trimmed.includes("\\")) {
+    const normalized = (0, import_node_path15.resolve)(trimmed.replace(/\\/g, "/"));
+    if ((0, import_node_fs12.existsSync)(normalized)) return normalized;
+  }
+  return resolved;
+}
+function readJsonArgument(raw, flagName) {
+  if (!raw.startsWith("@")) return raw.replace(/^\uFEFF/, "");
+  const filePath = raw.slice(1).trim();
+  if (!filePath) {
+    throw new Error(`Invalid ${flagName} value: empty @file path.`);
+  }
+  try {
+    return (0, import_node_fs12.readFileSync)(resolveAtFilePath(filePath), "utf8").replace(
+      /^\uFEFF/,
+      ""
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to read ${flagName} file '${filePath}': ${message}`
+    );
+  }
+}
+function invalidJsonError(flagName, message) {
+  const error = new Error(
+    `Invalid JSON in ${flagName}: ${message}`
+  );
+  error.code = "INVALID_JSON";
+  return error;
+}
+function parseJsonObjectArgument(raw, flagName) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readJsonArgument(raw, flagName));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith("Failed to read ") || message.startsWith("Invalid ")) {
+      throw error;
+    }
+    throw invalidJsonError(flagName, message);
+  }
+  if (!isRecord5(parsed)) {
+    throw invalidJsonError(flagName, "expected an object.");
+  }
+  return parsed;
+}
 function parseExecuteOptions(args) {
   const toolId = args[0];
   if (!toolId) {
@@ -15114,12 +15436,15 @@ function parseExecuteOptions(args) {
       const next = args[index + 1];
       outputFormat = "json";
       if (next && !next.startsWith("--")) {
-        Object.assign(params, JSON.parse(args[++index]));
+        Object.assign(
+          params,
+          parseJsonObjectArgument(args[++index], "--json")
+        );
       }
       continue;
     }
     if ((arg === "--input" || arg === "--payload") && args[index + 1]) {
-      Object.assign(params, JSON.parse(args[++index]));
+      Object.assign(params, parseJsonObjectArgument(args[++index], arg));
       continue;
     }
     if (arg === "--output-format" && args[index + 1]) {
@@ -15704,7 +16029,7 @@ function commandCompatibilityHint(currentFamily, commandName, baseUrl) {
     lines.push(
       "",
       "  To stay on the SDK CLI, install the SDK agent skill:",
-      `    ${skillsInstallCommand(baseUrl, "deepline-sdk")}`,
+      `    ${skillsInstallCommand(baseUrl, "deepline-plays")}`,
       "  To use the legacy Python CLI instead:",
       `    ${legacyPythonInstallCommand(baseUrl)}`,
       "  `deepline update` updates this SDK CLI, but it will not switch CLI families."
@@ -15717,7 +16042,7 @@ function commandCompatibilityHint(currentFamily, commandName, baseUrl) {
       "",
       "  To use SDK commands, install the SDK CLI and SDK agent skill:",
       `    ${sdkNpmGlobalInstallCommand()}`,
-      `    ${skillsInstallCommand(baseUrl, "deepline-sdk")}`,
+      `    ${skillsInstallCommand(baseUrl, "deepline-plays")}`,
       "  `deepline update` updates this Python CLI and its skills, but it will not switch CLI families."
     );
     if (compatibility.python_alternative) {
@@ -15738,12 +16063,29 @@ var import_node_fs14 = require("fs");
 var import_node_os10 = require("os");
 var import_node_path17 = require("path");
 var CHECK_TIMEOUT_MS2 = 3e3;
-var SDK_SKILL_NAME = "deepline-sdk";
+var SDK_SKILL_NAME = "deepline-plays";
 var attemptedSync = false;
 function shouldSkipSkillsSync() {
   const value = process.env.DEEPLINE_SKIP_SKILLS_SYNC?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
+function activePluginSkillsDir() {
+  const pluginMode = process.env.DEEPLINE_PLUGIN_MODE?.trim().toLowerCase();
+  if (pluginMode !== "true" && pluginMode !== "1" && pluginMode !== "yes" && pluginMode !== "on") {
+    return "";
+  }
+  const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
+  return dir && (0, import_node_fs14.existsSync)(dir) ? dir : "";
+}
+function readPluginSkillsVersion() {
+  const dir = activePluginSkillsDir();
+  if (!dir) return "";
+  try {
+    return (0, import_node_fs14.readFileSync)((0, import_node_path17.join)(dir, ".version"), "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
 function sdkSkillsVersionPath(baseUrl) {
   const home = process.env.HOME?.trim() || (0, import_node_os10.homedir)();
   return (0, import_node_path17.join)(
@@ -15756,6 +16098,8 @@ function sdkSkillsVersionPath(baseUrl) {
   );
 }
 function readLocalSkillsVersion(baseUrl) {
+  const pluginVersion = readPluginSkillsVersion();
+  if (pluginVersion) return pluginVersion;
   const path = sdkSkillsVersionPath(baseUrl);
   if (!(0, import_node_fs14.existsSync)(path)) return "";
   try {
@@ -15772,7 +16116,8 @@ function writeLocalSkillsVersion(baseUrl, version) {
 }
 function installedSdkSkillHasStalePositionalExecuteExamples() {
   const home = process.env.HOME?.trim() || (0, import_node_os10.homedir)();
-  const roots = [
+  const pluginSkillsDir = activePluginSkillsDir();
+  const roots = pluginSkillsDir ? [(0, import_node_path17.join)(pluginSkillsDir, SDK_SKILL_NAME)] : [
     (0, import_node_path17.join)(home, ".claude", "skills", SDK_SKILL_NAME),
     (0, import_node_path17.join)(home, ".agents", "skills", SDK_SKILL_NAME)
   ];
@@ -15871,7 +16216,7 @@ function resolveSkillsInstallCommands(baseUrl) {
   return [npxInstall];
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve13) => {
+  return new Promise((resolve14) => {
     const child = (0, import_node_child_process2.spawn)(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
@@ -15881,7 +16226,7 @@ function runOneSkillsInstall(install) {
       stderr += chunk.toString("utf-8");
     });
     child.on("error", (error) => {
-      resolve13({
+      resolve14({
         ok: false,
         detail: `failed to start ${install.command}: ${error.message}`,
         manualCommand: install.manualCommand
@@ -15889,11 +16234,11 @@ function runOneSkillsInstall(install) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve13({ ok: true, detail: "", manualCommand: install.manualCommand });
+        resolve14({ ok: true, detail: "", manualCommand: install.manualCommand });
         return;
       }
       const detail = stderr.trim();
-      resolve13({
+      resolve14({
         ok: false,
         detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
         manualCommand: install.manualCommand
@@ -15930,18 +16275,22 @@ function writeSdkSkillsStatusLine(line) {
 async function syncSdkSkillsIfNeeded(baseUrl) {
   if (attemptedSync || shouldSkipSkillsSync()) return;
   attemptedSync = true;
+  const usingPluginSkills = Boolean(activePluginSkillsDir());
   const localVersion = readLocalSkillsVersion(baseUrl);
   const update = await fetchSkillsUpdate(baseUrl, localVersion);
   const hasStaleInstalledSkill = installedSdkSkillHasStalePositionalExecuteExamples();
+  if (usingPluginSkills) {
+    return;
+  }
   if (!update?.needsUpdate && !hasStaleInstalledSkill || !update?.remoteVersion) {
     return;
   }
-  writeSdkSkillsStatusLine("SDK skills changed; syncing deepline-sdk skill...");
+  writeSdkSkillsStatusLine("SDK skills changed; syncing deepline-plays skill...");
   const installed = await runSkillsInstall(baseUrl);
   if (!installed) return;
   if (installedSdkSkillHasStalePositionalExecuteExamples()) {
     process.stderr.write(
-      "SDK skills sync completed, but installed deepline-sdk docs still contain stale positional ctx.tools.execute examples.\n"
+      "SDK skills sync completed, but installed deepline-plays docs still contain stale positional ctx.tools.execute examples.\n"
     );
     return;
   }