deepline 0.1.57 → 0.1.59

package/dist/cli/index.js

@@ -25,7 +25,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/cli/index.ts
 var import_promises5 = require("fs/promises");
-var import_node_path15 = require("path");
+var import_node_path16 = require("path");
 var import_node_os9 = require("os");
 var import_commander3 = require("commander");
 
@@ -220,10 +220,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.57",
-  apiContract: "2026-05-play-tool-describe-starters",
+  version: "0.1.59",
+  apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.57",
+    latest: "0.1.59",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -361,8 +361,8 @@ var HttpClient = class {
     if (lastError instanceof DeeplineError) {
       throw lastError;
     }
-    const errorMessage = lastError?.message ? `Unable to connect to ${baseUrl}. ${lastError.message}` : `Unable to connect to ${baseUrl}. Is the computer able to access the url?`;
-    throw new DeeplineError(errorMessage);
+    const errorMessage2 = lastError?.message ? `Unable to connect to ${baseUrl}. ${lastError.message}` : `Unable to connect to ${baseUrl}. Is the computer able to access the url?`;
+    throw new DeeplineError(errorMessage2);
   }
   /**
    * Send a GET request.
@@ -535,7 +535,7 @@ function decodeSseFrame(frame) {
   return parsed;
 }
 function sleep(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 
 // src/client.ts
@@ -545,7 +545,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((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 function isTransientCompileManifestError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
@@ -2276,7 +2276,7 @@ function buildCandidateUrls2(url) {
   }
 }
 function sleep3(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 function printDeeplineLogo() {
   if (process.stdout.isTTY && (process.stdout.columns ?? 80) >= 70) {
@@ -3044,6 +3044,33 @@ Examples:
 // src/cli/dataset-stats.ts
 var import_node_fs4 = require("fs");
 var import_node_path5 = require("path");
+
+// ../shared_libs/plays/dataset-summary.ts
+function datasetSummaryPercentText(numerator, denominator) {
+  return denominator > 0 ? `${numerator}/${denominator} (${Math.round(100 * numerator / denominator)}%)` : "0/0 (0%)";
+}
+function readCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
+}
+function formatDatasetExecutionStats(raw, denominator) {
+  return {
+    queued: datasetSummaryPercentText(readCount(raw.queued), denominator),
+    running: datasetSummaryPercentText(readCount(raw.running), denominator),
+    "completed:executed": datasetSummaryPercentText(
+      readCount(raw.completed),
+      denominator
+    ),
+    "completed:reused": datasetSummaryPercentText(readCount(raw.cached), denominator),
+    "skipped:condition": datasetSummaryPercentText(
+      readCount(raw.skipped),
+      denominator
+    ),
+    "skipped:missed": datasetSummaryPercentText(readCount(raw.missed), denominator),
+    failed: datasetSummaryPercentText(readCount(raw.failed), denominator)
+  };
+}
+
+// src/cli/dataset-stats.ts
 var CSV_PROJECTED_FIELDS_KEY = "__deeplineCsvProjectedFields";
 function csvProjectedFields(row) {
   const serialized = row[CSV_PROJECTED_FIELDS_KEY];
@@ -3124,9 +3151,6 @@ function rowArray(value) {
 function readNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : null;
 }
-function numericStat(value) {
-  return readNumber(value) ?? 0;
-}
 function inferColumns(rows) {
   const columns = [];
   const seen = /* @__PURE__ */ new Set();
@@ -3290,7 +3314,7 @@ function extractCanonicalRowsInfo(statusOrResult) {
   return collectCanonicalRowsInfos(statusOrResult)[0] ?? null;
 }
 function percentText(numerator, denominator) {
-  return denominator > 0 ? `${numerator}/${denominator} (${Math.round(100 * numerator / denominator)}%)` : "0/0 (0%)";
+  return datasetSummaryPercentText(numerator, denominator);
 }
 function isDatasetExecutionStatsInput(value) {
   return isRecord2(value) && isRecord2(value.columnStats) && Object.values(value.columnStats).every(isRecord2);
@@ -3306,17 +3330,6 @@ function extractDatasetExecutionStats(statusOrResult) {
   const nested = isRecord2(statusOrResult.result) ? statusOrResult.result.dataset_execution_stats : null;
   return isDatasetExecutionStatsInput(nested) ? nested : null;
 }
-function formatExecutionStats(raw, denominator) {
-  return {
-    queued: percentText(numericStat(raw.queued), denominator),
-    running: percentText(numericStat(raw.running), denominator),
-    "completed:executed": percentText(numericStat(raw.completed), denominator),
-    "completed:reused": percentText(numericStat(raw.cached), denominator),
-    "skipped:condition": percentText(numericStat(raw.skipped), denominator),
-    "skipped:missed": percentText(numericStat(raw.missed), denominator),
-    failed: percentText(numericStat(raw.failed), denominator)
-  };
-}
 function countPercentText(count, denominator) {
   return denominator > 0 ? `${count} (${Math.round(100 * count / denominator)}%)` : "0 (0%)";
 }
@@ -3439,7 +3452,7 @@ function buildDatasetStats(rows, totalRows = rows.length, columns = inferColumns
     };
     const rawExecutionStats = executionStats?.columnStats[column];
     if (rawExecutionStats) {
-      stat3.execution = formatExecutionStats(rawExecutionStats, totalRows);
+      stat3.execution = formatDatasetExecutionStats(rawExecutionStats, totalRows);
     }
     if (sampleValue !== void 0 && sampleValueType) {
       stat3.sample_value = sampleValue;
@@ -4025,8 +4038,8 @@ Examples:
 
 // src/cli/commands/play.ts
 var import_node_crypto3 = require("crypto");
-var import_node_fs8 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path11 = require("path");
 
 // src/plays/bundle-play-file.ts
 var import_node_os5 = require("os");
@@ -4379,6 +4392,9 @@ function localSdkAliasPlugin(adapter, options) {
       buildContext.onResolve({ filter: /^deepline$/ }, () => ({
         path: entryFile
       }));
+      buildContext.onResolve({ filter: /^deepline\/helpers$/ }, () => ({
+        path: (0, import_node_path7.join)(adapter.sdkSourceRoot, "helpers.ts")
+      }));
     }
   };
 }
@@ -5590,6 +5606,1443 @@ async function bundlePlayFile2(filePath, options = {}) {
   });
 }
 
+// src/cli/commands/plays/bootstrap.ts
+var import_node_fs8 = require("fs");
+var import_node_path10 = require("path");
+var import_sync4 = require("csv-parse/sync");
+
+// ../shared_libs/plays/bootstrap-routes.ts
+var PLAY_BOOTSTRAP_TEMPLATES = [
+  "people-list",
+  "company-list",
+  "people-email",
+  "people-phone",
+  "company-people",
+  "company-people-email",
+  "company-people-phone"
+];
+var PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY = "company_search";
+var PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY = "people_search";
+var PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER = {
+  email_finder: "email_finder",
+  phone_finder: "phone_finder"
+};
+var PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER = {
+  email_finder: "email",
+  phone_finder: "phone"
+};
+function isPlayBootstrapTemplate(value) {
+  return PLAY_BOOTSTRAP_TEMPLATES.includes(value);
+}
+function formatPlayBootstrapTemplates() {
+  return PLAY_BOOTSTRAP_TEMPLATES.join("|");
+}
+
+// src/cli/commands/plays/bootstrap.ts
+function parseReferencedPlayTarget(target) {
+  const trimmed = target.trim();
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
+    return { ownerSlug: null, playName: trimmed, unqualifiedPlayName: trimmed };
+  }
+  return {
+    ownerSlug: trimmed.slice(0, slashIndex),
+    playName: trimmed,
+    unqualifiedPlayName: trimmed.slice(slashIndex + 1)
+  };
+}
+function parsePositiveInteger2(value, flagName) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new PlayBootstrapUsageError(
+      `${flagName} must be a positive integer.`
+    );
+  }
+  return parsed;
+}
+function isRecord3(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function extractionEntries(value) {
+  if (Array.isArray(value)) return value.filter(isRecord3);
+  if (!isRecord3(value)) return [];
+  return Object.entries(value).map(
+    ([name, entry]) => isRecord3(entry) ? { name, ...entry } : { name }
+  );
+}
+var PlayBootstrapError = class extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+  exitCode;
+};
+var PlayBootstrapUsageError = class extends PlayBootstrapError {
+  constructor(message) {
+    super(message, 2);
+  }
+};
+var PlayBootstrapValidationError = class extends PlayBootstrapError {
+  constructor(message) {
+    super(message, 7);
+  }
+};
+var CSV_HEADER_SAMPLE_BYTES = 64 * 1024;
+function parseCsvList(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function parseProviderList(value, flag) {
+  const providers = parseCsvList(value);
+  if (providers.length === 0) {
+    throw new PlayBootstrapUsageError(`${flag} provider list cannot be empty.`);
+  }
+  return providers;
+}
+function parseBootstrapPrefixedRef(value, flag) {
+  const separatorIndex = value.indexOf(":");
+  if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
+    throw new PlayBootstrapUsageError(
+      `${flag} expects a typed resource reference like csv:data/leads.csv, play:prebuilt/name-and-domain-to-email-waterfall, provider:dropleads_search_people, or providers:hunter_email_finder,leadmagic_email_finder.`
+    );
+  }
+  return {
+    prefix: value.slice(0, separatorIndex).trim(),
+    body: value.slice(separatorIndex + 1).trim()
+  };
+}
+function parseBootstrapSourceRef(value, flag = "--from") {
+  const { prefix, body } = parseBootstrapPrefixedRef(value, flag);
+  switch (prefix) {
+    case "csv":
+      return { kind: "csv", value: body };
+    case "play":
+      return { kind: "play", value: parseReferencedPlayTarget(body).playName };
+    case "provider":
+    case "providers":
+      return { kind: "providers", values: parseProviderList(body, flag) };
+  }
+  throw new PlayBootstrapUsageError(
+    `${flag} does not support ${prefix}:. Use csv:, play:, provider:, or providers:.`
+  );
+}
+function parseBootstrapStageRef(value, flag) {
+  const { prefix, body } = parseBootstrapPrefixedRef(value, flag);
+  switch (prefix) {
+    case "play":
+      return { kind: "play", value: parseReferencedPlayTarget(body).playName };
+    case "provider":
+    case "providers":
+      return { kind: "providers", values: parseProviderList(body, flag) };
+  }
+  throw new PlayBootstrapUsageError(
+    `${flag} does not support ${prefix}:. Use play:, provider:, or providers:.`
+  );
+}
+function playBootstrapTemplateConfig(template) {
+  switch (template) {
+    case "company-list":
+      return { sourceEntity: "company", usingStage: null, requiredStages: [] };
+    case "people-list":
+      return { sourceEntity: "people", usingStage: null, requiredStages: [] };
+    case "people-email":
+      return {
+        sourceEntity: "people",
+        usingStage: "email",
+        requiredStages: []
+      };
+    case "people-phone":
+      return {
+        sourceEntity: "people",
+        usingStage: "phone",
+        requiredStages: []
+      };
+    case "company-people":
+      return {
+        sourceEntity: "company",
+        usingStage: "people",
+        requiredStages: []
+      };
+    case "company-people-email":
+      return {
+        sourceEntity: "company",
+        usingStage: null,
+        requiredStages: ["people", "email"]
+      };
+    case "company-people-phone":
+      return {
+        sourceEntity: "company",
+        usingStage: null,
+        requiredStages: ["people", "phone"]
+      };
+  }
+}
+function templateExample(template) {
+  switch (template) {
+    case "people-list":
+      return "deepline plays bootstrap people-list --from provider:dropleads_search_people > people.play.ts";
+    case "company-list":
+      return "deepline plays bootstrap company-list --from provider:apollo_company_search > companies.play.ts";
+    case "people-email":
+      return "deepline plays bootstrap people-email --from csv:data/leads.csv --using play:prebuilt/name-and-domain-to-email-waterfall > email-flow.play.ts";
+    case "people-phone":
+      return "deepline plays bootstrap people-phone --from csv:data/vp_contacts.csv --using play:prebuilt/person-to-phone > phone-flow.play.ts";
+    case "company-people":
+      return "deepline plays bootstrap company-people --from provider:apollo_company_search --using play:prebuilt/company-to-contact > company-people.play.ts";
+    case "company-people-email":
+      return "deepline plays bootstrap company-people-email --from provider:apollo_company_search --people play:prebuilt/company-to-contact --email providers:hunter_email_finder,leadmagic_email_finder > account-emails.play.ts";
+    case "company-people-phone":
+      return "deepline plays bootstrap company-people-phone --from provider:apollo_company_search --people play:prebuilt/company-to-contact --phone providers:ai_ark_mobile_phone_finder > account-phones.play.ts";
+  }
+}
+var PLAY_BOOTSTRAP_STAGE_NAMES = [
+  "people",
+  "email",
+  "phone"
+];
+function playBootstrapUsageLine() {
+  return `Usage: deepline plays bootstrap <${formatPlayBootstrapTemplates()}> --from <csv:PATH|play:REF|provider:ID|providers:ID,ID> [--using <play:REF|providers:ID,ID>] [--people play:REF] [--email <play:REF|providers:ID,ID>] [--phone <play:REF|providers:ID,ID>] [--limit 5] > flow.play.ts`;
+}
+function requireBootstrapTemplate(rawTemplate) {
+  if (!rawTemplate) {
+    throw new PlayBootstrapUsageError(
+      `plays bootstrap needs a route template: ${formatPlayBootstrapTemplates()}.
+Example: deepline plays bootstrap people-email --from csv:data/leads.csv --using play:prebuilt/name-and-domain-to-email-waterfall > email-flow.play.ts`
+    );
+  }
+  if (!isPlayBootstrapTemplate(rawTemplate)) {
+    throw new PlayBootstrapUsageError(
+      `Unknown plays bootstrap template: ${rawTemplate}
+Supported templates: ${formatPlayBootstrapTemplates()}`
+    );
+  }
+  return rawTemplate;
+}
+function nextFlagValue(args, index, flag) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new PlayBootstrapUsageError(`${flag} needs a value.`);
+  }
+  return value;
+}
+function stageFlag(stage) {
+  return `--${stage}`;
+}
+function stageRefHelp(stage) {
+  switch (stage) {
+    case "people":
+      return "play:<people-play>";
+    case "email":
+    case "phone":
+      return "<play:REF|provider:ID|providers:ID,ID>";
+  }
+}
+function getStageRef(options, stage) {
+  switch (stage) {
+    case "people":
+      return options.people;
+    case "email":
+      return options.email;
+    case "phone":
+      return options.phone;
+  }
+}
+function setStageRef(options, stage, ref) {
+  switch (stage) {
+    case "people":
+      options.people = ref;
+      return;
+    case "email":
+      options.email = ref;
+      return;
+    case "phone":
+      options.phone = ref;
+      return;
+  }
+}
+function unsupportedStageMessage(template, stage) {
+  switch (stage) {
+    case "people":
+      return `${template} does not accept --people. Use company-people, company-people-email, or company-people-phone.`;
+    case "email":
+      return `${template} does not accept --email. Use people-email or company-people-email.`;
+    case "phone":
+      return `${template} does not accept --phone. Use people-phone or company-people-phone.`;
+  }
+}
+function requireSource(options) {
+  if (!options.from) {
+    throw new PlayBootstrapUsageError(
+      `${options.template} needs --from.
+Example: ${templateExample(options.template)}`
+    );
+  }
+  return options.from;
+}
+function assertAllowedStageFlags(options, allowedStages) {
+  const allowed = new Set(allowedStages);
+  for (const stage of PLAY_BOOTSTRAP_STAGE_NAMES) {
+    if (!allowed.has(stage) && getStageRef(options, stage)) {
+      throw new PlayBootstrapUsageError(
+        unsupportedStageMessage(options.template, stage)
+      );
+    }
+  }
+}
+function assertRequiredStages(options, stages) {
+  for (const stage of stages) {
+    if (!getStageRef(options, stage)) {
+      throw new PlayBootstrapUsageError(
+        `${options.template} needs ${stageFlag(stage)} ${stageRefHelp(stage)}.
+Example: ${templateExample(options.template)}`
+      );
+    }
+  }
+}
+function normalizeSingleStageRoute(options, stage) {
+  const explicitStage = getStageRef(options, stage);
+  if (options.using && explicitStage) {
+    throw new PlayBootstrapUsageError(
+      `${options.template} received both --using and ${stageFlag(stage)}. Choose one stage binding.`
+    );
+  }
+  const selectedStage = options.using ?? explicitStage;
+  if (!selectedStage) {
+    throw new PlayBootstrapUsageError(
+      `${options.template} needs --using ${stageRefHelp(stage)} or ${stageFlag(stage)} ${stageRefHelp(stage)}.
+Example: ${templateExample(options.template)}`
+    );
+  }
+  setStageRef(options, stage, selectedStage);
+  options.using = selectedStage;
+  assertAllowedStageFlags(options, [stage]);
+}
+function normalizeMultiStageRoute(options, stages) {
+  if (options.using) {
+    throw new PlayBootstrapUsageError(
+      `${options.template} does not accept --using. Use the explicit stage flags shown in: ${templateExample(options.template)}`
+    );
+  }
+  assertRequiredStages(options, stages);
+  assertAllowedStageFlags(options, stages);
+}
+function normalizeTemplateStages(options) {
+  const config = playBootstrapTemplateConfig(options.template);
+  const from = requireSource(options);
+  switch (config.usingStage) {
+    case "people":
+    case "email":
+    case "phone":
+      normalizeSingleStageRoute(options, config.usingStage);
+      break;
+    case null:
+      normalizeMultiStageRoute(options, config.requiredStages);
+      break;
+  }
+  return {
+    ...options,
+    from
+  };
+}
+function parsePlayBootstrapOptions(args) {
+  const [rawTemplate, ...rest] = args;
+  const template = requireBootstrapTemplate(rawTemplate);
+  const options = {
+    template,
+    name: `gtm-${template}`,
+    from: null,
+    using: null,
+    people: null,
+    email: null,
+    phone: null,
+    limit: 5
+  };
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index];
+    const value = () => nextFlagValue(rest, index, arg);
+    switch (arg) {
+      case "--name":
+        options.name = value();
+        index += 1;
+        break;
+      case "--from":
+        options.from = parseBootstrapSourceRef(value(), "--from");
+        index += 1;
+        break;
+      case "--using":
+        options.using = parseBootstrapStageRef(value(), "--using");
+        index += 1;
+        break;
+      case "--people":
+        options.people = parseBootstrapStageRef(value(), "--people");
+        index += 1;
+        break;
+      case "--email":
+        options.email = parseBootstrapStageRef(value(), "--email");
+        index += 1;
+        break;
+      case "--phone":
+        options.phone = parseBootstrapStageRef(value(), "--phone");
+        index += 1;
+        break;
+      case "--limit":
+        options.limit = parsePositiveInteger2(value(), "--limit");
+        index += 1;
+        break;
+      default:
+        throw new PlayBootstrapUsageError(
+          `Unknown plays bootstrap option: ${arg}
+${playBootstrapUsageLine()}`
+        );
+    }
+  }
+  return normalizeTemplateStages(options);
+}
+function jsString(value) {
+  return JSON.stringify(value);
+}
+function inferCsvCellTypeExpression(values) {
+  const nonEmptyValues = values.map((value) => value.trim()).filter((value) => value.length > 0);
+  const hasEmptyValue = values.some((value) => value.trim().length === 0);
+  if (nonEmptyValues.length === 0) return "string";
+  const numericPattern = /^[+-]?(?:(?:\d+\.?\d*)|(?:\.\d+))(?:[eE][+-]?\d+)?$/;
+  const booleanPattern = /^(?:true|false)$/i;
+  let inferred = "string";
+  if (nonEmptyValues.every((value) => numericPattern.test(value))) {
+    inferred = "`${number}`";
+  } else if (nonEmptyValues.every((value) => booleanPattern.test(value))) {
+    const canonicalBooleanValues = nonEmptyValues.every(
+      (value) => value === "true" || value === "false"
+    );
+    inferred = canonicalBooleanValues ? '"false" | "true"' : [...new Set(nonEmptyValues)].sort().map(jsString).join(" | ");
+  }
+  return hasEmptyValue && inferred !== "string" ? `${inferred} | ""` : inferred;
+}
+function inferCsvColumnSpecs(headers, rows) {
+  return headers.map((header) => ({
+    name: header,
+    typeExpression: inferCsvCellTypeExpression(
+      rows.map((row) => String(row[header] ?? ""))
+    )
+  }));
+}
+function readCsvSample(csvPath) {
+  const resolvedPath = (0, import_node_path10.resolve)(csvPath);
+  const size = (0, import_node_fs8.statSync)(resolvedPath).size;
+  const fd = (0, import_node_fs8.openSync)(resolvedPath, "r");
+  const byteLength = Math.min(size, CSV_HEADER_SAMPLE_BYTES);
+  const buffer = Buffer.alloc(byteLength);
+  const bytesRead = (0, import_node_fs8.readSync)(fd, buffer, 0, byteLength, 0);
+  (0, import_node_fs8.closeSync)(fd);
+  if (bytesRead === 0) {
+    throw new PlayBootstrapUsageError(`--from csv:${csvPath} is empty.`);
+  }
+  return {
+    content: buffer.subarray(0, bytesRead).toString("utf8"),
+    truncated: size > bytesRead
+  };
+}
+function completeCsvSample(csvPath, sample) {
+  if (!sample.truncated) return sample.content;
+  const lastLineBreak = Math.max(
+    sample.content.lastIndexOf("\n"),
+    sample.content.lastIndexOf("\r")
+  );
+  if (lastLineBreak < 0) {
+    throw new PlayBootstrapUsageError(
+      `CSV header in ${csvPath} is longer than ${CSV_HEADER_SAMPLE_BYTES} bytes; shorten the header row before bootstrapping.`
+    );
+  }
+  return sample.content.slice(0, lastLineBreak + 1);
+}
+function readCsvHeaderFields(csvPath, sample) {
+  const records = (0, import_sync4.parse)(sample, {
+    bom: true,
+    to_line: 1,
+    relax_column_count: true,
+    skip_empty_lines: false
+  });
+  const firstRecord = Array.isArray(records) ? records[0] : null;
+  const fields = Array.isArray(firstRecord) ? firstRecord.map((field) => String(field ?? "").trim()).filter(Boolean) : [];
+  const uniqueFields = [...new Set(fields)];
+  if (uniqueFields.length === 0) {
+    throw new PlayBootstrapUsageError(
+      `Could not read a header row from --from csv:${csvPath}.`
+    );
+  }
+  return uniqueFields;
+}
+function readCsvSampleRows(sample) {
+  const parsedRows = (0, import_sync4.parse)(sample, {
+    bom: true,
+    columns: true,
+    skip_empty_lines: true,
+    relax_column_count: true,
+    trim: true
+  });
+  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord3) : [];
+}
+function readSourceCsvColumnSpecs(csvPath) {
+  const sample = readCsvSample(csvPath);
+  const completeSample = completeCsvSample(csvPath, sample);
+  return inferCsvColumnSpecs(
+    readCsvHeaderFields(csvPath, sample.content),
+    readCsvSampleRows(completeSample)
+  );
+}
+function renderSourceCsvRowType(columns) {
+  if (columns.length === 0) return "";
+  const properties = columns.map((column) => `  ${jsString(column.name)}: ${column.typeExpression};`).join("\n");
+  return `// CSV cells are strings at runtime. \`${"${number}"}\` means a numeric-looking CSV string; cast before math.
+type SourceCsvRow = {
+${properties}
+};
+
+`;
+}
+function packagedCsvPathForPlay(csvPath) {
+  const playDir = process.cwd();
+  const absoluteCsvPath = (0, import_node_path10.resolve)(csvPath);
+  const relativePath = (0, import_node_path10.relative)(playDir, absoluteCsvPath);
+  if (relativePath === "" || relativePath.startsWith("..") || (0, import_node_path10.isAbsolute)(relativePath)) {
+    throw new PlayBootstrapUsageError(
+      `--from csv:${csvPath} must point to a file inside the directory where you run plays bootstrap. Run bootstrap from the intended play directory, then redirect stdout to a .play.ts file there.`
+    );
+  }
+  const portablePath = relativePath.split("\\").join("/");
+  return portablePath.startsWith(".") ? portablePath : `./${portablePath}`;
+}
+function getterNamesFromTool(tool, kind) {
+  const usageGuidance = isRecord3(tool?.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord3(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord3(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const key = kind === "list" ? "extractedLists" : "extractedValues";
+  const snakeKey = kind === "list" ? "extracted_lists" : "extracted_values";
+  return extractionEntries(resultGuidance[key] ?? resultGuidance[snakeKey]).map((entry) => stringValue(entry.name)).filter(Boolean);
+}
+function targetGettersFromTool(tool) {
+  const record = isRecord3(tool) ? tool : {};
+  const raw = record.targetGetters ?? record.target_getters;
+  if (!isRecord3(raw)) return {};
+  const entries = [];
+  for (const [target, value] of Object.entries(raw)) {
+    const paths = Array.isArray(value) ? value.map((path) => typeof path === "string" ? path.trim() : "").filter(Boolean) : [];
+    if (target.trim() && paths.length > 0) {
+      entries.push([target.trim(), paths]);
+    }
+  }
+  return Object.fromEntries(entries);
+}
+function listRowCandidateKeysFromTool(tool) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const paths of Object.values(targetGettersFromTool(tool))) {
+    for (const path of paths) {
+      const key = path.replace(/\[(?:\*|\d+)\]/g, "").split(/[.[\]]/, 1)[0]?.trim();
+      if (key) keys.add(key);
+    }
+  }
+  return [...keys].sort();
+}
+function inputPropertyNames(schema) {
+  if (!isRecord3(schema)) return [];
+  if (isRecord3(schema.properties)) return Object.keys(schema.properties);
+  if (Array.isArray(schema.fields)) {
+    return schema.fields.filter(isRecord3).map((field) => stringValue(field.name)).filter(Boolean);
+  }
+  return [];
+}
+function schemaFieldDetails(schema) {
+  const required = requiredPlayInputFields({
+    inputSchema: schema
+  });
+  const optional = inputPropertyNames(schema).filter(
+    (field) => !required.includes(field)
+  );
+  return { required, optional };
+}
+function jsonSchemaTypeExpression(schema) {
+  if (!isRecord3(schema)) return "unknown";
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    return type.map((entry) => jsonSchemaTypeExpression({ ...schema, type: entry })).join(" | ");
+  }
+  if (Array.isArray(schema.anyOf)) {
+    return schema.anyOf.map(jsonSchemaTypeExpression).join(" | ");
+  }
+  if (Array.isArray(schema.oneOf)) {
+    return schema.oneOf.map(jsonSchemaTypeExpression).join(" | ");
+  }
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "array":
+      return `Array<${jsonSchemaTypeExpression(schema.items)}>`;
+    case "object":
+      return "Record<string, unknown>";
+    default:
+      return "unknown";
+  }
+}
+function objectPropertySchema(schema, property) {
+  return isRecord3(schema) && isRecord3(schema.properties) ? schema.properties[property] : null;
+}
+function finderResultTypeName(finder) {
+  return finder === "email_finder" ? "EmailFinderPlayResult" : "PhoneFinderPlayResult";
+}
+function renderFinderPlayResultType(input) {
+  if (!input.play) return null;
+  const outputField = PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER[input.finder];
+  const fieldSchema = objectPropertySchema(
+    input.play.outputSchema,
+    outputField
+  );
+  const fieldType = fieldSchema ? jsonSchemaTypeExpression(fieldSchema) : "string | null";
+  return `type ${finderResultTypeName(input.finder)} =
+  | string
+  | null
+  | {
+      ${outputField}?: ${fieldType};
+    };`;
+}
+function generatedFinderPlayResultTypes(input) {
+  return ["email_finder", "phone_finder"].flatMap((finder) => {
+    const stage = finderStage(input.options, finder);
+    if (stage?.kind !== "play") return [];
+    const typeDefinition = renderFinderPlayResultType({
+      finder,
+      play: input.finderPlays[finder]
+    });
+    return typeDefinition ? [typeDefinition] : [];
+  }).join("\n\n");
+}
+function exampleValueComment(field) {
+  if (field === "limit" || field === "numResults" || field === "num_results" || field === "page_size") {
+    return "limit";
+  }
+  if (field === "roles" || field.endsWith("s")) return '["..."]';
+  return '"..."';
+}
+function generateContactInputObjectFromSchema(schema, indent, label, fallbackFields = ["first_name", "last_name", "domain"]) {
+  const details = schemaFieldDetails(schema);
+  const required = details.required.length ? details.required : fallbackFields;
+  const optional = details.optional;
+  const lines = [
+    `${indent}// TODO: map row fields into ${label}.`,
+    ...playInspectionComments(label, indent),
+    `${indent}// Required: ${required.join(", ") || "none declared"}.`
+  ];
+  for (const field of required) {
+    lines.push(`${indent}// ${field}: row["TODO_SOURCE_FIELD"],`);
+  }
+  if (optional.length > 0) {
+    lines.push("");
+    lines.push(`${indent}// optional (delete unused):`);
+    for (const field of optional) {
+      lines.push(`${indent}// ${field}: row["TODO_SOURCE_FIELD"],`);
+    }
+  }
+  return `{
+${lines.join("\n")}
+${indent.slice(2)}}`;
+}
+function generateCompanyInputObjectFromSchema(schema, indent, label, fallbackFields = ["domain", "company_name"]) {
+  const details = schemaFieldDetails(schema);
+  const required = details.required.length ? details.required : fallbackFields;
+  const optional = details.optional;
+  const lines = [
+    `${indent}// TODO: map company fields into ${label}.`,
+    ...playInspectionComments(label, indent),
+    `${indent}// Required: ${required.join(", ") || "none declared"}.`
+  ];
+  for (const field of required) {
+    lines.push(`${indent}// ${field}: company["TODO_SOURCE_FIELD"],`);
+  }
+  if (optional.length > 0) {
+    lines.push("");
+    lines.push(`${indent}// optional (delete unused):`);
+    for (const field of optional) {
+      lines.push(`${indent}// ${field}: company["TODO_SOURCE_FIELD"],`);
+    }
+  }
+  return `{
+${lines.join("\n")}
+${indent.slice(2)}}`;
+}
+function generateSourceProviderInputObject(input) {
+  const { tool, indent, label, entity } = input;
+  const properties = inputPropertyNames(tool?.inputSchema);
+  const details = schemaFieldDetails(tool?.inputSchema);
+  const required = details.required;
+  const includeOptional = properties.length === 0 ? ["query", "title", "domain", "limit"] : properties.filter(
+    (field) => [
+      "query",
+      "q",
+      "search",
+      "title",
+      "role",
+      "persona",
+      "domain",
+      "company_domain",
+      "limit",
+      "numResults",
+      "num_results",
+      "page_size"
+    ].includes(field)
+  );
+  const lines = [
+    `${indent}// TODO: fill ${entity} source inputs for ${label}.`,
+    `${indent}// Inspect: deepline tools describe ${label} --json`
+  ];
+  for (const field of required) {
+    lines.push(`${indent}// ${field}: ${exampleValueComment(field)},`);
+  }
+  const activeTodoField = required.length === 0 ? ["query", "q", "search", "title", "role", "persona"].find(
+    (field) => includeOptional.includes(field)
+  ) ?? "query" : null;
+  if (activeTodoField) {
+    lines.push(
+      `${indent}// ${activeTodoField}: ${exampleValueComment(activeTodoField)},`
+    );
+  }
+  const optionalExamples = includeOptional.filter(
+    (field) => !required.includes(field) && field !== activeTodoField
+  );
+  if (optionalExamples.length > 0) {
+    lines.push("");
+    lines.push(`${indent}// optional - uncomment what this provider supports:`);
+    for (const field of optionalExamples) {
+      if (field === "limit" || field === "numResults" || field === "num_results" || field === "page_size") {
+        lines.push(`${indent}// ${field}: limit,`);
+      } else {
+        lines.push(`${indent}// ${field}: ${exampleValueComment(field)},`);
+      }
+    }
+  }
+  if (!required.some(
+    (field) => ["limit", "numResults", "num_results", "page_size"].includes(field)
+  )) {
+    lines.push(`${indent}limit,`);
+  }
+  return `{
+${lines.join("\n")}
+${indent.slice(2)}}`;
+}
+function generatePlayInputObject(input) {
+  const { schema, indent, label, entity } = input;
+  const details = schemaFieldDetails(schema);
+  const fallback = entity === "company" ? ["domain", "company_name"] : ["first_name", "last_name", "domain"];
+  const required = details.required.length ? details.required : fallback;
+  const lines = [
+    `${indent}// TODO: fill source play inputs for ${label}.`,
+    ...playInspectionComments(label, indent)
+  ];
+  for (const field of required) {
+    lines.push(`${indent}// ${field}: ${exampleValueComment(field)},`);
+  }
+  if (!required.includes("limit")) lines.push(`${indent}limit,`);
+  return `{
+${lines.join("\n")}
+${indent.slice(2)}}`;
+}
+function requiredPlayInputFields(play) {
+  const schema = play?.inputSchema;
+  if (!isRecord3(schema)) return [];
+  if (Array.isArray(schema.required)) {
+    return schema.required.filter(
+      (value) => typeof value === "string"
+    );
+  }
+  if (Array.isArray(schema.fields)) {
+    return schema.fields.filter(isRecord3).filter(
+      (field) => field.required === true && typeof field.name === "string"
+    ).map((field) => String(field.name));
+  }
+  return [];
+}
+function sourceProviders(options) {
+  return options.from.kind === "providers" ? options.from.values : [];
+}
+function sourcePlayRef(options) {
+  return options.from.kind === "play" ? options.from.value : null;
+}
+function stagePlayRef(stage) {
+  return stage?.kind === "play" ? stage.value : null;
+}
+function stageProviders(stage) {
+  return stage?.kind === "providers" ? stage.values : [];
+}
+function finderStage(options, finder) {
+  return finder === "email_finder" ? options.email : options.phone;
+}
+function stepFieldName(finder) {
+  return PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER[finder];
+}
+function finderProviderStepPrefix(finder) {
+  return finder === "email_finder" ? "emailFinder" : "phoneFinder";
+}
+function safeIdentifier(value) {
+  return value.replace(/[^A-Za-z0-9_]+/g, "_");
+}
+function playInspectionComments(playRef, indent) {
+  return [`${indent}// Inspect: deepline plays describe ${playRef} --json`];
+}
+function accessorExpression(base, field) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(field) ? `${base}.${field}` : `${base}[${jsString(field)}]`;
+}
+function needsWhenImport(options) {
+  return stageProviders(options.email).length > 1 || stageProviders(options.phone).length > 1;
+}
+function sourceCollectionTypeName(entity) {
+  return entity === "company" ? "CompanySourceRow" : "ContactSourceRow";
+}
+function renderPartialRowType(input) {
+  if (input.fields.length === 0) {
+    return `type ${input.typeName} = Record<string, unknown>;`;
+  }
+  const properties = input.fields.map((field) => `  ${jsString(field)}?: unknown;`).join("\n");
+  return `type ${input.typeName} = Record<string, unknown> & Partial<{
+  // ${input.comment}
+${properties}
+}>;`;
+}
+function fieldsFromSchemaDetails(input) {
+  return [
+    ...input.details.required.length ? input.details.required : input.fallbackFields,
+    ...input.details.optional
+  ];
+}
+function schemaFieldsForStage(stage, input) {
+  switch (stage?.kind) {
+    case void 0:
+      return [];
+    case "play":
+      return fieldsFromSchemaDetails({
+        details: schemaFieldDetails(input.play?.inputSchema),
+        fallbackFields: input.fallbackFields
+      });
+    case "providers":
+      return input.tools.flatMap(
+        (tool) => fieldsFromSchemaDetails({
+          details: schemaFieldDetails(tool.inputSchema),
+          fallbackFields: input.fallbackFields
+        })
+      );
+  }
+}
+function sourceRowTypeDefinition(input) {
+  switch (input.options.from.kind) {
+    case "csv":
+      return `type ${input.sourceTypeName} = SourceCsvRow;`;
+    case "providers":
+      return renderPartialRowType({
+        typeName: input.sourceTypeName,
+        fields: [
+          ...new Set(input.sourceTools.flatMap(listRowCandidateKeysFromTool))
+        ].sort(),
+        comment: "Candidate source row keys from described list getters; confirm the actual provider keys with source_*.extractedLists.*.keys before mapping."
+      });
+    case "play": {
+      const details = schemaFieldDetails(input.sourcePlay?.outputSchema);
+      return renderPartialRowType({
+        typeName: input.sourceTypeName,
+        fields: [...details.required, ...details.optional].sort(),
+        comment: "Candidate source play output fields; confirm the selected rows field before mapping."
+      });
+    }
+  }
+}
+function contactBridgeRowTypeDefinition(input) {
+  const config = playBootstrapTemplateConfig(input.options.template);
+  if (config.sourceEntity !== "company" || !input.options.people) return null;
+  const emailFields = schemaFieldsForStage(input.options.email, {
+    tools: input.finderTools.email_finder ?? [],
+    play: input.finderPlays.email_finder,
+    fallbackFields: ["first_name", "last_name", "domain"]
+  });
+  const phoneFields = schemaFieldsForStage(input.options.phone, {
+    tools: input.finderTools.phone_finder ?? [],
+    play: input.finderPlays.phone_finder,
+    fallbackFields: ["first_name", "last_name", "domain"]
+  });
+  return renderPartialRowType({
+    typeName: "ContactSourceRow",
+    fields: [
+      .../* @__PURE__ */ new Set([
+        ...inputPropertyNames(input.peoplePlay?.outputSchema),
+        ...emailFields,
+        ...phoneFields
+      ])
+    ].sort(),
+    comment: "Fields the people play or later finder stages may need; the generated code still requires explicit mapping."
+  });
+}
+function generateRowTypeDefinitions(input) {
+  const config = playBootstrapTemplateConfig(input.options.template);
+  const sourceTypeName = sourceCollectionTypeName(config.sourceEntity);
+  const definitions = [
+    sourceRowTypeDefinition({
+      options: input.options,
+      sourceTypeName,
+      sourceTools: input.sourceTools,
+      sourcePlay: input.sourcePlay
+    }),
+    contactBridgeRowTypeDefinition(input)
+  ];
+  return definitions.filter(Boolean).join("\n\n");
+}
+function validateBootstrapRoutes(input) {
+  const config = playBootstrapTemplateConfig(input.options.template);
+  const sourceCategory = config.sourceEntity === "company" ? PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY : PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY;
+  for (const tool of input.sourceTools) {
+    if (!tool.categories.includes(sourceCategory)) {
+      throw new PlayBootstrapValidationError(
+        `Cannot use ${tool.toolId} as a ${config.sourceEntity} source for ${input.options.template}: expected category ${sourceCategory}, got ${tool.categories.join(", ") || "none"}. Run: deepline tools grep ${sourceCategory} --categories ${sourceCategory} --json`
+      );
+    }
+    if (getterNamesFromTool(tool, "list").length === 0) {
+      throw new PlayBootstrapValidationError(
+        `Cannot use ${tool.toolId} as a ${config.sourceEntity} source: it exposes no extracted list getters. Run: deepline tools describe ${tool.toolId} --json`
+      );
+    }
+  }
+  if (input.options.people?.kind === "providers") {
+    throw new PlayBootstrapValidationError(
+      "Company-to-people bootstrap only accepts --people play:<play-ref> for now. Providers are too task-specific; choose or create a people play so the generated file can show the mapping contract."
+    );
+  }
+  for (const finder of ["email_finder", "phone_finder"]) {
+    const requiredCategory = PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER[finder];
+    for (const tool of input.finderTools[finder] ?? []) {
+      if (!tool.categories.includes(requiredCategory)) {
+        throw new PlayBootstrapValidationError(
+          `Cannot use ${tool.toolId} for ${finder}: expected category ${requiredCategory}, got ${tool.categories.join(", ") || "none"}. Run: deepline tools grep ${requiredCategory} --categories ${requiredCategory} --json`
+        );
+      }
+      if (getterNamesFromTool(tool, "value").length === 0) {
+        throw new PlayBootstrapValidationError(
+          `Cannot use ${tool.toolId} as a ${finder}: it exposes no extracted value getters. Run: deepline tools describe ${tool.toolId} --json`
+        );
+      }
+    }
+  }
+}
+function sourceCollectionName(entity) {
+  switch (entity) {
+    case "company":
+      return "companies";
+    case "people":
+      return "contacts";
+  }
+}
+function requiredGetterName(input) {
+  const getter = getterNamesFromTool(input.tool, input.kind)[0];
+  if (!getter) {
+    switch (input.kind) {
+      case "list":
+        throw new PlayBootstrapValidationError(
+          `Cannot use ${input.label} as a source: it exposes no extracted list getters.`
+        );
+      case "value":
+        throw new PlayBootstrapValidationError(
+          `Cannot use ${input.label} as a finder: it exposes no extracted value getters.`
+        );
+    }
+  }
+  return getter;
+}
+function generateCsvSourceRowsBlock(input) {
+  return `const sourceDataset = await ctx.csv<SourceCsvRow>(${jsString(input.packagedSourceCsvPath ?? input.source.value)});
+  const ${input.collection}: ${input.collectionType}[] = await sourceDataset.peek(limit);`;
+}
+function generatePlaySourceRowsBlock(input) {
+  const playInput = generatePlayInputObject({
+    schema: input.sourcePlay?.inputSchema,
+    indent: "    ",
+    label: input.source.value,
+    entity: input.entity
+  });
+  return `const sourceInput = ${playInput};
+  throw new Error(${jsString(`TODO: map sourceInput for ${input.source.value}, choose the play output rows field, then delete this throw.`)});
+  const sourceResult = await ctx.runPlay('source_play', ${jsString(input.source.value)}, sourceInput, {
+    description: ${jsString(`Seed ${input.entity} rows from the selected play.`)},
+  });
+  // TODO: Replace sourceResult.rows with the selected play's actual row output field.
+  const ${input.collection}: ${input.collectionType}[] = (sourceResult.rows ?? []) as ${input.collectionType}[];`;
+}
+function generateProviderSourceBlock(input) {
+  const getter = requiredGetterName({
+    tool: input.tool,
+    kind: "list",
+    label: input.provider
+  });
+  const inputName = `${input.entity}Input_${input.index}`;
+  return `// ${input.entity === "company" ? "Company" : "People"} source provider: ${input.provider}
+  const ${inputName}: Record<string, unknown> = ${generateSourceProviderInputObject(
+    {
+      tool: input.tool,
+      indent: "    ",
+      label: input.provider,
+      entity: input.entity
+    }
+  )};
+  throw new Error(${jsString(`TODO: fill ${inputName} for ${input.provider}, then delete this throw.`)});
+  const source_${input.index} = await ctx.tools.execute({
+    id: ${jsString(`${input.entity}_source_${input.index}`)},
+    tool: ${jsString(input.provider)},
+    input: ${inputName},
+    description: ${jsString(`Seed ${input.entity} rows from ${input.provider}.`)},
+  });
+  // extractedLists.${getter}.get() returns provider-shaped rows. Do not assume canonical fields;
+  // inspect source_${input.index}.extractedLists.${getter}.keys or the provider output schema, then map explicitly below.
+  const sourceRows_${input.index} = ${accessorExpression(`source_${input.index}.extractedLists`, getter)}.get() as ${input.collectionType}[];`;
+}
+function generateProviderSourceRowsBlock(input) {
+  const blocks = input.source.values.map(
+    (provider, index) => generateProviderSourceBlock({
+      provider,
+      index,
+      tool: input.sourceTools[index] ?? null,
+      entity: input.entity,
+      collectionType: input.collectionType
+    })
+  );
+  return `${blocks.join("\n\n  ")}
+  const ${input.collection}: ${input.collectionType}[] = [${input.source.values.map((_, index) => `...sourceRows_${index}`).join(", ")}];`;
+}
+function generateSourceRowsBlock(input) {
+  const config = playBootstrapTemplateConfig(input.options.template);
+  const entity = config.sourceEntity;
+  const collection = sourceCollectionName(entity);
+  const collectionType = sourceCollectionTypeName(entity);
+  switch (input.options.from.kind) {
+    case "csv":
+      return generateCsvSourceRowsBlock({
+        source: input.options.from,
+        collection,
+        collectionType,
+        packagedSourceCsvPath: input.packagedSourceCsvPath
+      });
+    case "play":
+      return generatePlaySourceRowsBlock({
+        source: input.options.from,
+        sourcePlay: input.sourcePlay,
+        entity,
+        collection,
+        collectionType
+      });
+    case "providers":
+      return generateProviderSourceRowsBlock({
+        source: input.options.from,
+        sourceTools: input.sourceTools,
+        entity,
+        collection,
+        collectionType
+      });
+  }
+}
+function generateSourceSeedBlock(input) {
+  const sourceRows = generateSourceRowsBlock(input);
+  const peoplePlayRef = stagePlayRef(input.options.people);
+  if (!peoplePlayRef) return sourceRows;
+  const peopleInput = generateCompanyInputObjectFromSchema(
+    input.peoplePlay?.inputSchema,
+    "      ",
+    peoplePlayRef,
+    ["domain", "company_name"]
+  );
+  return `${sourceRows}
+  const contacts: ContactSourceRow[] = [];
+  for (const [index, company] of companies.slice(0, limit).entries()) {
+    const peopleInput = ${peopleInput};
+    throw new Error(${jsString(`TODO: map company fields into peopleInput for ${peoplePlayRef}, choose the play output rows field, then delete this throw.`)});
+    const peopleResult = await ctx.runPlay(
+      \`people_play_\${index}\`,
+      ${jsString(peoplePlayRef)},
+      peopleInput,
+      {
+        description: 'Map one company row into people/contact rows with the selected play.',
+      },
+    );
+    // TODO: Replace peopleResult.rows with the selected play's actual contact rows field.
+    contacts.push(...((peopleResult.rows ?? []) as ContactSourceRow[]));
+  }`;
+}
+function finderProviderStepName(input) {
+  return `${input.aggregateStepName}${input.index}_${safeIdentifier(input.provider)}`;
+}
+function finderValueGetter(input) {
+  const getters = getterNamesFromTool(input.tool, "value");
+  const getter = getters.find((name) => name === input.outputField) ?? requiredGetterName({
+    tool: input.tool,
+    kind: "value",
+    label: input.provider
+  });
+  return getter;
+}
+function optionalFinderValueExpression(candidateExpression, outputField) {
+  const valueExpression = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(outputField) ? `${candidateExpression}?.${outputField}` : `${candidateExpression}?.[${jsString(outputField)}]`;
+  return `${valueExpression}?.trim()`;
+}
+function generateFinderPlayStep(input) {
+  const outputField = PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER[input.finder];
+  const resultTypeName = finderResultTypeName(input.finder);
+  const payload = generateContactInputObjectFromSchema(
+    input.play?.inputSchema,
+    "        ",
+    input.stage.value
+  );
+  return `.step(${jsString(outputField)}, async (row, rowCtx) => {
+      const ${input.aggregateStepName}Input = ${payload};
+      throw new Error(${jsString(`TODO: map ${input.aggregateStepName}Input for ${input.stage.value}, then delete this throw.`)});
+      const ${input.aggregateStepName}Result = await rowCtx.runPlay<${resultTypeName}>(
+        ${jsString(`${input.aggregateStepName}Play`)},
+        ${jsString(input.stage.value)},
+        ${input.aggregateStepName}Input,
+        {
+          description: ${jsString(`Run ${input.finder} play.`)},
+        },
+      );
+      return typeof ${input.aggregateStepName}Result === 'string'
+        ? ${input.aggregateStepName}Result.trim() || null
+        : ${input.aggregateStepName}Result?.${outputField} ?? null;
+    })`;
+}
+function generateFinderProviderResolver(input) {
+  const payload = generateContactInputObjectFromSchema(
+    input.tool?.inputSchema,
+    "        ",
+    input.provider
+  );
+  const getter = finderValueGetter({
+    tool: input.tool,
+    provider: input.provider,
+    outputField: input.outputField
+  });
+  return `async (row, rowCtx) => {
+      const providerInput = ${payload};
+      throw new Error(${jsString(`TODO: map providerInput for ${input.provider}, then delete this throw.`)});
+      const result = await rowCtx.tools.execute({
+        id: ${jsString(`${input.aggregateStepName}_${input.providerIndex}`)},
+        tool: ${jsString(input.provider)},
+        input: providerInput,
+        description: ${jsString(`Try ${input.provider} as a ${input.finder}.`)},
+      });
+      return {
+        ${input.outputField}: (${accessorExpression("result.extractedValues", getter)}.get() as string | null) ?? null,
+        result,
+      };
+    }`;
+}
+function generateFinderProviderStep(input) {
+  const stepName = input.stepNames[input.index];
+  switch (input.index) {
+    case 0:
+      return `.step(${jsString(stepName)}, ${input.resolver})`;
+    default: {
+      const priorCandidates = input.stepNames.slice(0, input.index).map((name) => `row.${name}`).join(", ");
+      return `.step(
+      ${jsString(stepName)},
+      when(
+        (row) => ![${priorCandidates}].some((candidate) => ${optionalFinderValueExpression("candidate", input.outputField)}),
+        ${input.resolver},
+      ),
+    )`;
+    }
+  }
+}
+function generateFinderProviderWaterfall(input) {
+  const legPrefix = finderProviderStepPrefix(input.finder);
+  const stepNames = input.stage.values.map(
+    (provider, index) => finderProviderStepName({
+      aggregateStepName: legPrefix,
+      provider,
+      index
+    })
+  );
+  const providerSteps = input.stage.values.map(
+    (provider, index) => generateFinderProviderStep({
+      index,
+      stepNames,
+      outputField: input.outputField,
+      resolver: generateFinderProviderResolver({
+        finder: input.finder,
+        provider,
+        providerIndex: index,
+        tool: input.tools[index] ?? null,
+        aggregateStepName: input.aggregateStepName,
+        outputField: input.outputField
+      })
+    })
+  );
+  const candidateNames = stepNames.map((name) => `row.${name}`).join(", ");
+  return `// ${input.aggregateStepName} provider waterfall. Each provider leg is active once its TODO throw is removed;
+    // delete or comment out legs you do not want before running. Later legs are gated with when(...).
+    ${providerSteps.join("\n    ")}
+    .step(${jsString(input.aggregateStepName)}, (row) => {
+      const candidates = [${candidateNames}];
+      const match = candidates.find((candidate) => ${optionalFinderValueExpression("candidate", input.outputField)});
+      return ${optionalFinderValueExpression("match", input.outputField)} ?? null;
+    })`;
+}
+function generateFinderStageSteps(input) {
+  const outputField = PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER[input.finder];
+  const aggregateStepName = stepFieldName(input.finder);
+  switch (input.stage.kind) {
+    case "play":
+      return generateFinderPlayStep({
+        finder: input.finder,
+        stage: input.stage,
+        play: input.finderPlays[input.finder],
+        aggregateStepName
+      });
+    case "providers":
+      return generateFinderProviderWaterfall({
+        finder: input.finder,
+        stage: input.stage,
+        tools: input.finderTools[input.finder] ?? [],
+        aggregateStepName,
+        outputField
+      });
+  }
+}
+function generateFinderSteps(input) {
+  return ["email_finder", "phone_finder"].flatMap((finder) => {
+    const stage = finderStage(input.options, finder);
+    return stage ? [
+      generateFinderStageSteps({
+        ...input,
+        finder,
+        stage
+      })
+    ] : [];
+  }).join("\n    ");
+}
+function generateBootstrapPlaySource(input) {
+  const config = playBootstrapTemplateConfig(input.options.template);
+  const sourceSeedBlock = generateSourceSeedBlock(input);
+  const finderSteps = generateFinderSteps(input);
+  const hasPeople = config.sourceEntity === "people" || Boolean(input.options.people);
+  const sourceCollection = hasPeople ? "contacts" : "companies";
+  const mapSteps = finderSteps ? `
+    ${finderSteps}` : "";
+  const sourceCsvRowType = input.options.from.kind === "csv" ? renderSourceCsvRowType(input.sourceCsvColumns) : "";
+  const rowTypeDefinitions = generateRowTypeDefinitions(input);
+  const finderPlayResultTypes = generatedFinderPlayResultTypes(input);
+  const typeDefinitions = [
+    sourceCsvRowType.trimEnd(),
+    rowTypeDefinitions,
+    finderPlayResultTypes
+  ].filter((definition) => definition.trim().length > 0).join("\n\n");
+  const importNames = needsWhenImport(input.options) ? "definePlay, when" : "definePlay";
+  return `import { ${importNames} } from 'deepline';
+
+${typeDefinitions}
+
+type Input = {
+  limit?: number;
+};
+
+export default definePlay(${jsString(input.options.name)}, async (ctx, input: Input = {}) => {
+  const limit = Math.max(1, Math.min(Number(input.limit ?? ${input.options.limit}), ${input.options.limit}));
+  ${sourceSeedBlock}
+
+  const rowsToProcess = ${sourceCollection}.slice(0, limit);
+  if (rowsToProcess.length === 0) {
+    throw new Error('plays bootstrap found 0 source rows. Check the source provider/play/CSV output.');
+  }
+
+  const rows = await ctx
+    .map('bootstrap_rows', rowsToProcess)${mapSteps}
+    .run({
+      key: (_row, index) => index,
+      description: ${jsString(`Bootstrap ${input.options.template}: seed source rows, run requested stages, then return the mapped rows.`)},
+    });
+
+  return {
+    count: await rows.count(),
+    rows,
+  };
+});
+
+`;
+}
+async function describePlayMaybe(client, playRef) {
+  return playRef ? client.describePlay(playRef, { compact: true }) : null;
+}
+function loadTools(client, providers) {
+  return Promise.all(providers.map((provider) => client.getTool(provider)));
+}
+async function loadBootstrapContracts(client, options) {
+  const [
+    sourceTools,
+    sourcePlay,
+    peoplePlay,
+    emailPlay,
+    phonePlay,
+    emailTools,
+    phoneTools
+  ] = await Promise.all([
+    loadTools(client, sourceProviders(options)),
+    describePlayMaybe(client, sourcePlayRef(options)),
+    describePlayMaybe(client, stagePlayRef(options.people)),
+    describePlayMaybe(client, stagePlayRef(options.email)),
+    describePlayMaybe(client, stagePlayRef(options.phone)),
+    loadTools(client, stageProviders(options.email)),
+    loadTools(client, stageProviders(options.phone))
+  ]);
+  const contracts = {
+    sourceTools,
+    sourcePlay,
+    peoplePlay,
+    finderTools: {
+      email_finder: emailTools,
+      phone_finder: phoneTools
+    },
+    finderPlays: {
+      email_finder: emailPlay,
+      phone_finder: phonePlay
+    }
+  };
+  validateBootstrapRoutes({
+    options,
+    sourceTools: contracts.sourceTools,
+    peoplePlay: contracts.peoplePlay,
+    finderTools: contracts.finderTools,
+    finderPlays: contracts.finderPlays
+  });
+  return contracts;
+}
+function loadCsvContext(source) {
+  switch (source.kind) {
+    case "csv":
+      return {
+        packagedSourceCsvPath: packagedCsvPathForPlay(source.value),
+        sourceCsvColumns: readSourceCsvColumnSpecs(source.value)
+      };
+    case "play":
+    case "providers":
+      return {
+        packagedSourceCsvPath: null,
+        sourceCsvColumns: []
+      };
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function renderPlayBootstrapError(error) {
+  console.error(errorMessage(error));
+  return error instanceof PlayBootstrapError ? error.exitCode : 1;
+}
+async function runPlayBootstrap(args) {
+  const options = parsePlayBootstrapOptions(args);
+  const client = new DeeplineClient();
+  const contracts = await loadBootstrapContracts(client, options);
+  const csvContext = loadCsvContext(options.from);
+  const source = generateBootstrapPlaySource({
+    options,
+    ...contracts,
+    ...csvContext
+  });
+  process.stdout.write(source);
+  return 0;
+}
+async function handlePlayBootstrap(args) {
+  return runPlayBootstrap(args).catch(renderPlayBootstrapError);
+}
+function registerPlayBootstrapCommand(play) {
+  play.command("bootstrap <template>").description("Print a scratchpad play for a GTM route template.").addHelpText(
+    "after",
+    `
+Notes:
+  Cloud-validated play generator for agents. Pick the JTBD as the positional
+  template, bind resources with typed refs, redirect stdout to a .play.ts file,
+  then edit the generated TODO mapping comments. Multiple finder providers are
+  generated as a waterfall in the order you pass them.
+
+  This command requires auth because provider/play contracts are fetched from
+  Deepline. It prints TypeScript source only and does not run paid tools; the
+  generated play may spend credits later when you run it.
+
+  stdout is the generated .play.ts source. Errors and diagnostics go to stderr.
+  There is no JSON mode and no --out; use shell redirection:
+    deepline plays bootstrap ... > scratchpad.play.ts
+
+  Templates:
+    people-list             start from people/contact rows
+    company-list            start from company/account rows
+    people-email            people/contact rows -> email finder
+    people-phone            people/contact rows -> phone finder
+    company-people          company/account rows -> people play
+    company-people-email    company/account rows -> people play -> email finder
+    company-people-phone    company/account rows -> people play -> phone finder
+
+  Resource refs:
+    csv:./contacts.csv
+    play:prebuilt/name-and-domain-to-email-waterfall
+    provider:dropleads_search_people
+    providers:hunter_email_finder,leadmagic_email_finder
+
+  Validation:
+    source providers must match the route entity: company_search or people_search
+    source providers must expose list getters
+    company -> people uses a play only; provider bridge is generated later when a play exists
+    email/phone finder providers must match their category and expose value getters
+    finder plays/providers must match the route; generated code leaves input mapping explicit
+    business-specific provider inputs and company -> people persona fields are TODOs in code
+    csv: paths are resolved from the directory where you run bootstrap; redirect the play file there too
+
+  Exit codes:
+    0 success
+    2 usage/local input error
+    7 route validation failed
+
+Examples:
+  deepline plays bootstrap people-email --from csv:data/leads.csv --using play:prebuilt/name-and-domain-to-email-waterfall --limit 5 > email-flow.play.ts
+  deepline plays check email-flow.play.ts
+  deepline plays run email-flow.play.ts --input '{"limit":5}' --watch
+
+  deepline plays bootstrap people-email --from provider:dropleads_search_people --using providers:hunter_email_finder,leadmagic_email_finder --limit 5 > prospecting.play.ts
+  deepline plays bootstrap company-people-email --from provider:apollo_company_search --people play:prebuilt/company-to-contact --email play:prebuilt/name-and-domain-to-email-waterfall --limit 5 > account-contacts.play.ts
+  deepline plays bootstrap company-list --from provider:apollo_company_search --limit 5 > companies.play.ts
+`
+  ).option("--name <name>", "Generated play name").option(
+    "--from <ref>",
+    "Route source: csv:PATH, play:REF, provider:ID, or providers:ID,ID"
+  ).option(
+    "--using <ref>",
+    "Single-stage route shorthand for people-email, people-phone, or company-people"
+  ).option(
+    "--people <ref>",
+    "Company-to-people stage for company-people-email/phone; use play:REF"
+  ).option(
+    "--email <ref>",
+    "Email finder stage: play:REF, provider:ID, or providers:ID,ID"
+  ).option(
+    "--phone <ref>",
+    "Phone finder stage: play:REF, provider:ID, or providers:ID,ID"
+  ).option("--limit <n>", "Maximum rows to fan out in the generated play").action(async (template, options) => {
+    process.exitCode = await handlePlayBootstrap([
+      template,
+      ...options.name ? ["--name", options.name] : [],
+      ...options.from ? ["--from", options.from] : [],
+      ...options.using ? ["--using", options.using] : [],
+      ...options.people ? ["--people", options.people] : [],
+      ...options.email ? ["--email", options.email] : [],
+      ...options.phone ? ["--phone", options.phone] : [],
+      ...options.limit ? ["--limit", options.limit] : []
+    ]);
+  });
+}
+
 // src/cli/progress.ts
 var import_node_worker_threads = require("worker_threads");
 var CliProgress = class {
@@ -6041,9 +7494,9 @@ function traceCliSync(phase, fields, run) {
   }
 }
 function sleep4(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
-function parseReferencedPlayTarget(target) {
+function parseReferencedPlayTarget2(target) {
   const trimmed = target.trim();
   const slashIndex = trimmed.indexOf("/");
   if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
@@ -6064,7 +7517,7 @@ function buildBarePrebuiltReferenceError(input) {
   );
 }
 async function assertCanonicalNamedPlayReference(client, target) {
-  const parsed = parseReferencedPlayTarget(target);
+  const parsed = parseReferencedPlayTarget2(target);
   const detail = await client.getPlay(parsed.playName);
   if (detail.play.ownerType === "deepline" && !isPrebuiltReferenceTarget(target)) {
     throw buildBarePrebuiltReferenceError({
@@ -6085,10 +7538,10 @@ function formatPlayListReference(play) {
   return play.reference || play.name;
 }
 function defaultMaterializedPlayPath(reference) {
-  return (0, import_node_path10.resolve)(defaultStarterPlayPath(reference));
+  return (0, import_node_path11.resolve)(defaultStarterPlayPath(reference));
 }
 function defaultStarterPlayPath(reference) {
-  const playName = parseReferencedPlayTarget(reference).unqualifiedPlayName;
+  const playName = parseReferencedPlayTarget2(reference).unqualifiedPlayName;
   const safeName = playName.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   return `./${safeName || "play"}.play.ts`;
 }
@@ -6111,15 +7564,15 @@ function materializeRemotePlaySource(input) {
     return null;
   }
   const outputPath = input.outPath ?? defaultMaterializedPlayPath(input.playName);
-  if ((0, import_node_fs8.existsSync)(outputPath)) {
-    const existingSource = (0, import_node_fs8.readFileSync)(outputPath, "utf-8");
+  if ((0, import_node_fs9.existsSync)(outputPath)) {
+    const existingSource = (0, import_node_fs9.readFileSync)(outputPath, "utf-8");
     if (existingSource === input.sourceCode) {
       return { path: outputPath, status: "unchanged", created: false };
     }
-    (0, import_node_fs8.writeFileSync)(outputPath, input.sourceCode, "utf-8");
+    (0, import_node_fs9.writeFileSync)(outputPath, input.sourceCode, "utf-8");
     return { path: outputPath, status: "updated", created: false };
   }
-  (0, import_node_fs8.writeFileSync)(outputPath, input.sourceCode, "utf-8");
+  (0, import_node_fs9.writeFileSync)(outputPath, input.sourceCode, "utf-8");
   return { path: outputPath, status: "created", created: true };
 }
 function formatLoadedPlayMessage(materializedFile) {
@@ -6144,7 +7597,7 @@ To make your own version:
   );
 }
 async function ensureEditableRemotePlay(client, target) {
-  const parsed = parseReferencedPlayTarget(target);
+  const parsed = parseReferencedPlayTarget2(target);
   const detail = await client.getPlay(parsed.playName);
   if (detail.play.ownerType === "deepline") {
     throw buildReadonlyPrebuiltPlayError(formatPlayReference(detail.play));
@@ -6164,7 +7617,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return (0, import_node_fs8.existsSync)((0, import_node_path10.resolve)(target));
+  return (0, import_node_fs9.existsSync)((0, import_node_path11.resolve)(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -6185,7 +7638,7 @@ function looksLikeFilePath(target) {
   }
   return target.includes("\\") || /\.(ts|js|mjs|play\.ts)$/.test(target);
 }
-function parsePositiveInteger2(value, flagName) {
+function parsePositiveInteger3(value, flagName) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     throw new Error(`${flagName} must be a positive integer.`);
@@ -6193,7 +7646,7 @@ function parsePositiveInteger2(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? (0, import_node_fs8.readFileSync)((0, import_node_path10.resolve)(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? (0, import_node_fs9.readFileSync)((0, import_node_path11.resolve)(raw.slice(1)), "utf-8") : raw;
   const parsed = JSON.parse(source);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("--input must be a JSON object.");
@@ -6260,7 +7713,8 @@ function setDottedInputValue(input, path, value) {
   cursor[parts[parts.length - 1]] = value;
 }
 function schemaMetadata(schema, key) {
-  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return null;
+  if (!schema || typeof schema !== "object" || Array.isArray(schema))
+    return null;
   const value = schema[key];
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -6294,7 +7748,7 @@ function fileInputBindingsFromStaticPipeline(staticPipeline) {
 function isLocalFilePathValue(value) {
   if (typeof value !== "string" || !value.trim()) return false;
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
-  return (0, import_node_fs8.existsSync)((0, import_node_path10.resolve)(value));
+  return (0, import_node_fs9.existsSync)((0, import_node_path11.resolve)(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -6315,13 +7769,15 @@ function namedRunNeedsPlayDefinition(input) {
 }
 async function stageFileInputArgs(input) {
   const uniqueBindings = [
-    ...new Map(input.bindings.map((binding) => [binding.inputPath, binding])).values()
+    ...new Map(
+      input.bindings.map((binding) => [binding.inputPath, binding])
+    ).values()
   ];
   const localFiles = uniqueBindings.flatMap((binding) => {
     const value = getDottedInputValue(input.runtimeInput, binding.inputPath);
     if (!isLocalFilePathValue(value)) return [];
-    const absolutePath = (0, import_node_path10.resolve)(value);
-    return [{ binding, absolutePath, logicalPath: (0, import_node_path10.basename)(absolutePath) }];
+    const absolutePath = (0, import_node_path11.resolve)(value);
+    return [{ binding, absolutePath, logicalPath: (0, import_node_path11.basename)(absolutePath) }];
   });
   if (localFiles.length === 0) {
     return { inputFile: null, packagedFiles: [] };
@@ -6333,10 +7789,18 @@ async function stageFileInputArgs(input) {
     localFiles.map((file) => stageFile(file.logicalPath, file.absolutePath))
   );
   for (const [index, file] of localFiles.entries()) {
-    setDottedInputValue(input.runtimeInput, file.binding.inputPath, file.logicalPath);
+    setDottedInputValue(
+      input.runtimeInput,
+      file.binding.inputPath,
+      file.logicalPath
+    );
     const stagedFile = staged[index];
     if (stagedFile && stagedFile.logicalPath !== file.logicalPath) {
-      setDottedInputValue(input.runtimeInput, file.binding.inputPath, stagedFile.logicalPath);
+      setDottedInputValue(
+        input.runtimeInput,
+        file.binding.inputPath,
+        stagedFile.logicalPath
+      );
     }
   }
   return {
@@ -6345,7 +7809,7 @@ async function stageFileInputArgs(input) {
   };
 }
 function stageFile(logicalPath, absolutePath) {
-  const buffer = (0, import_node_fs8.readFileSync)(absolutePath);
+  const buffer = (0, import_node_fs9.readFileSync)(absolutePath);
   return {
     logicalPath,
     contentBase64: buffer.toString("base64"),
@@ -6356,9 +7820,9 @@ function stageFile(logicalPath, absolutePath) {
 }
 function normalizePlayPath(filePath) {
   try {
-    return import_node_fs8.realpathSync.native((0, import_node_path10.resolve)(filePath));
+    return import_node_fs9.realpathSync.native((0, import_node_path11.resolve)(filePath));
   } catch {
-    return (0, import_node_path10.resolve)(filePath);
+    return (0, import_node_path11.resolve)(filePath);
   }
 }
 function formatBundlingErrors(filePath, errors) {
@@ -6716,7 +8180,10 @@ function formatProgressCounts(input) {
   if (completed === null || total === null || total <= 0) {
     return null;
   }
-  const percent = Math.max(0, Math.min(100, Math.round(completed / total * 100)));
+  const percent = Math.max(
+    0,
+    Math.min(100, Math.round(completed / total * 100))
+  );
   const failed = typeof input.failed === "number" && Number.isFinite(input.failed) && input.failed > 0 ? `, failed ${formatInteger(input.failed)}` : "";
   return `${formatInteger(completed)}/${formatInteger(total)} (${percent}%)${failed}`;
 }
@@ -7223,7 +8690,7 @@ function isDatasetHandle(value) {
     value && typeof value === "object" && !Array.isArray(value) && value.kind === "dataset"
   );
 }
-function collectDatasetHandleLines(value, path = "result") {
+function collectDatasetHandleLines(value, path = "result", datasetStats) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return [];
   }
@@ -7234,6 +8701,9 @@ function collectDatasetHandleLines(value, path = "result") {
     const lines2 = [
       `  dataset ${typeof record.path === "string" ? record.path : path}: rows=${count === null ? "-" : formatInteger(count)} preview=${formatInteger(preview.length)}`
     ];
+    if (datasetStats && (datasetStats.source === path || datasetStats.source === record.path)) {
+      lines2.push(...formatDatasetStatsLines(datasetStats.stats, "    "));
+    }
     if (typeof record.queryDatasetCommand === "string") {
       lines2.push(`  query dataset: ${record.queryDatasetCommand}`);
     }
@@ -7247,7 +8717,9 @@ function collectDatasetHandleLines(value, path = "result") {
     if (key === "preview" || key === "access") {
       continue;
     }
-    lines.push(...collectDatasetHandleLines(child, `${path}.${key}`));
+    lines.push(
+      ...collectDatasetHandleLines(child, `${path}.${key}`, datasetStats)
+    );
   }
   return lines;
 }
@@ -7430,7 +8902,9 @@ function buildInsufficientCreditsSummaryLines(input) {
   const runId = input.status.runId?.trim();
   if (runId) {
     lines.push(`  inspect: deepline runs get ${runId} --json`);
-    lines.push(`  export partial: deepline runs export ${runId} --out output.csv`);
+    lines.push(
+      `  export partial: deepline runs export ${runId} --out output.csv`
+    );
   }
   return lines;
 }
@@ -7502,7 +8976,10 @@ function normalizeErrorsForEnvelope(status, error) {
       }
       return {
         ...entry,
-        message: formatInsufficientCreditsMessage({ billing: billing2, error: message2 }),
+        message: formatInsufficientCreditsMessage({
+          billing: billing2,
+          error: message2
+        }),
         billing: stripProviderSpendFromBilling(billing2)
       };
     });
@@ -7601,13 +9078,26 @@ function compactPlayStatus(status) {
   };
 }
 function enrichPlayStatusWithDatasetStats(status) {
-  const rowsInfo = extractCanonicalRowsInfo(status);
-  if (!rowsInfo?.complete) {
+  const datasetStats = datasetStatsForStatus(status);
+  if (!datasetStats) {
     return status;
   }
   return {
     ...status,
-    dataset_stats: buildDatasetStats(
+    result: attachDatasetStatsToResult(
+      status.result,
+      datasetStats
+    )
+  };
+}
+function datasetStatsForStatus(status) {
+  const rowsInfo = extractCanonicalRowsInfo(status);
+  if (!rowsInfo?.complete) {
+    return null;
+  }
+  return {
+    source: rowsInfo.source,
+    stats: buildDatasetStats(
       rowsInfo.rows,
       rowsInfo.totalRows,
       rowsInfo.columns,
@@ -7615,6 +9105,52 @@ function enrichPlayStatusWithDatasetStats(status) {
     )
   };
 }
+function attachDatasetStatsToResult(result, datasetStats) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) {
+    return result;
+  }
+  const sourcePath = datasetStats.source?.replace(/^result\.?/, "") ?? "";
+  const attach = (value, path) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return value;
+    }
+    const record = value;
+    const isMatchingDataset = record.kind === "dataset" && (path === sourcePath || `result.${path}` === datasetStats.source);
+    const next = { ...record };
+    if (isMatchingDataset) {
+      next.summary = datasetStats.stats;
+      return next;
+    }
+    for (const [key, child] of Object.entries(record)) {
+      if (key === "preview" || key === "access") continue;
+      const childPath = path ? `${path}.${key}` : key;
+      const attached = attach(child, childPath);
+      if (attached !== child) {
+        next[key] = attached;
+      }
+    }
+    return next;
+  };
+  return attach(result, "");
+}
+function formatDatasetStatsLines(datasetStats, indent = "  ") {
+  if (!datasetStats) {
+    return [];
+  }
+  const lines = [`${indent}summary:`];
+  for (const [column, stat3] of Object.entries(datasetStats.columnStats).slice(
+    0,
+    12
+  )) {
+    const topValues = stat3.top_values ? `, top_values=${Object.entries(stat3.top_values).slice(0, 3).map(([value, count]) => `${value}=${count}`).join(", ")}` : "";
+    const sample = stat3.sample_value !== void 0 ? `, sample_value=${JSON.stringify(stat3.sample_value)}` : "";
+    const execution = stat3.execution ? `, execution=${Object.entries(stat3.execution).map(([bucket, count]) => `${bucket}=${count}`).join(", ")}` : "";
+    lines.push(
+      `${indent}  ${column}: non_empty=${stat3.non_empty}, unique=${stat3.unique}${topValues}${sample}${execution}`
+    );
+  }
+  return lines;
+}
 function readRunPackageRun(packaged) {
   return packaged.run && typeof packaged.run === "object" && !Array.isArray(packaged.run) ? packaged.run : {};
 }
@@ -7623,6 +9159,60 @@ function readRecordArray(value) {
     (item) => item !== null && typeof item === "object" && !Array.isArray(item)
   ) : [];
 }
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function formatSummaryScalar(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? formatInteger(Math.trunc(value)) : null;
+  }
+  if (typeof value === "string" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null) {
+    return "null";
+  }
+  return null;
+}
+function formatSummaryScalarParts(record, skipKeys = /* @__PURE__ */ new Set()) {
+  const parts = [];
+  for (const [key, value] of Object.entries(record)) {
+    if (skipKeys.has(key)) {
+      continue;
+    }
+    const formatted = formatSummaryScalar(value);
+    if (formatted !== null) {
+      parts.push(`${key}=${formatted}`);
+    }
+  }
+  return parts;
+}
+function formatPackageDatasetSummaryLines(summary, indent = "    ") {
+  const record = readRecord(summary);
+  const columnStats = readRecord(record?.columnStats);
+  if (!record || !columnStats) {
+    return [];
+  }
+  const lines = [];
+  const parts = formatSummaryScalarParts(record, /* @__PURE__ */ new Set(["columnStats"]));
+  if (parts.length > 0) {
+    lines.push(`${indent}summary: ${parts.join(" ")}`);
+  }
+  for (const [column, rawColumnSummary] of Object.entries(columnStats)) {
+    const columnSummary = readRecord(rawColumnSummary);
+    if (!columnSummary) continue;
+    const execution = readRecord(columnSummary.execution);
+    const executionText = execution ? Object.entries(execution).map(([bucket, value]) => `${bucket}=${String(value)}`).join(", ") : "";
+    const columnParts = [
+      ...formatSummaryScalarParts(columnSummary, /* @__PURE__ */ new Set(["execution"])),
+      executionText ? `execution=${executionText}` : null
+    ].filter(Boolean);
+    if (columnParts.length > 0) {
+      lines.push(`${indent}  ${column}: ${columnParts.join(" ")}`);
+    }
+  }
+  return lines;
+}
 function actionToCommand(action) {
   if (!action || typeof action !== "object" || Array.isArray(action)) {
     return null;
@@ -7657,7 +9247,9 @@ function buildRunPackageTextLines(packaged) {
   const runId = typeof run.id === "string" ? run.id : "unknown";
   const status = typeof run.status === "string" ? run.status : "unknown";
   const playName = typeof run.playName === "string" ? run.playName : null;
-  const lines = [`${status === "completed" ? "\u2713" : status === "failed" ? "\u2717" : "\u2022"} ${status}  ${runId}`];
+  const lines = [
+    `${status === "completed" ? "\u2713" : status === "failed" ? "\u2717" : "\u2022"} ${status}  ${runId}`
+  ];
   if (playName) {
     lines.push(`  play: ${playName}`);
   }
@@ -7669,8 +9261,11 @@ function buildRunPackageTextLines(packaged) {
     const rowCount = output && typeof output.rowCount === "number" ? ` rows=${formatInteger(output.rowCount)}` : "";
     const preview = output?.preview && typeof output.preview === "object" && !Array.isArray(output.preview) ? output.preview : null;
     const previewRows = Array.isArray(preview?.rows) ? preview.rows.length : null;
-    const previewLabel = previewRows !== null ? ` preview=${previewRows}${preview?.truncated ? " truncated" : ""}` : "";
-    lines.push(`  ${kind} ${id}: ${stepStatus}${rowCount}${previewLabel}`);
+    lines.push(`  ${kind} ${id}: ${stepStatus}${rowCount}`);
+    lines.push(...formatPackageDatasetSummaryLines(output?.summary));
+    if (previewRows !== null) {
+      lines.push(`    preview=${previewRows}${preview?.truncated ? " truncated" : ""}`);
+    }
   }
   const next = packaged.next && typeof packaged.next === "object" && !Array.isArray(packaged.next) ? packaged.next : {};
   const datasetActions = readFirstDatasetActions(packaged);
@@ -7684,8 +9279,13 @@ function buildRunPackageTextLines(packaged) {
 }
 function writePlayResult(status, jsonOutput, options) {
   const packaged = getPlayRunPackage(status);
+  const datasetStats = datasetStatsForStatus(status);
   if (jsonOutput) {
-    const payload2 = options?.fullJson ? status : compactPlayStatus(status);
+    const compact2 = compactPlayStatus(status);
+    const payload2 = options?.fullJson ? enrichPlayStatusWithDatasetStats(status) : datasetStats ? {
+      ...compact2,
+      result: attachDatasetStatsToResult(compact2.result, datasetStats)
+    } : compact2;
     printCommandEnvelope(payload2, { json: true });
     return;
   }
@@ -7721,35 +9321,42 @@ function writePlayResult(status, jsonOutput, options) {
   const renderedServerView = renderServerResultView(status.resultView);
   if (result) {
     lines.push(...formatReturnValue(result));
-    lines.push(...collectDatasetHandleLines(result));
+    lines.push(...collectDatasetHandleLines(result, "result", datasetStats));
   }
   if (renderedServerView.lines.length > 0) {
     lines.push(...renderedServerView.lines);
   }
   lines.push(...renderedServerView.actions);
-  const payload = options?.fullJson ? enrichPlayStatusWithDatasetStats(status) : compactPlayStatus(status);
-  printCommandEnvelope({
-    ...payload,
-    render: {
-      sections: [{ title: "run result", lines }]
-    }
-  }, { json: jsonOutput, text: `${lines.join("\n")}
-` });
+  const compact = compactPlayStatus(status);
+  const payload = options?.fullJson ? enrichPlayStatusWithDatasetStats(status) : datasetStats ? {
+    ...compact,
+    result: attachDatasetStatsToResult(compact.result, datasetStats)
+  } : compact;
+  printCommandEnvelope(
+    {
+      ...payload,
+      render: {
+        sections: [{ title: "run result", lines }]
+      }
+    },
+    { json: jsonOutput, text: `${lines.join("\n")}
+` }
+  );
 }
 async function resolvePlayRunOutputStatus(input) {
-  if (!input.fullJson || !getPlayRunPackage(input.status)) {
+  if (!getPlayRunPackage(input.status)) {
     return input.status;
   }
   const runId = input.status.runId;
   if (!runId) {
     return input.status;
   }
-  const fullStatus = await input.client.getPlayStatus(runId, {
+  const refreshedStatus = await input.client.getPlayStatus(runId, {
     billing: false,
-    full: true
+    full: input.fullJson
   });
   const dashboardUrl = input.status.dashboardUrl;
-  return typeof dashboardUrl === "string" ? { ...fullStatus, dashboardUrl } : fullStatus;
+  return typeof dashboardUrl === "string" ? { ...refreshedStatus, dashboardUrl } : refreshedStatus;
 }
 var RUN_EXPORT_PAGE_SIZE = 5e3;
 function shellSingleQuote(value) {
@@ -7759,7 +9366,7 @@ function sqlStringLiteral(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
 function runExportRetryCommand(runId, outPath, datasetPath) {
-  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote((0, import_node_path10.resolve)(outPath))}`;
+  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote((0, import_node_path11.resolve)(outPath))}`;
 }
 function extractRunPlayName(status) {
   const run = status.run;
@@ -7793,7 +9400,7 @@ function buildCustomerDbQueryPlan(input) {
   return {
     sql,
     json: `${base} --json`,
-    csv: `${base} --format csv --out ${shellSingleQuote((0, import_node_path10.resolve)(input.outPath))}`
+    csv: `${base} --format csv --out ${shellSingleQuote((0, import_node_path11.resolve)(input.outPath))}`
   };
 }
 function exportableSheetRow(row) {
@@ -8093,7 +9700,9 @@ function renderServerResultView(value) {
           (field) => typeof field === "string"
         ) : [];
         if (rawResultFields.length > 0) {
-          lines.push(`      tool-result columns: ${rawResultFields.join(", ")}`);
+          lines.push(
+            `      tool-result columns: ${rawResultFields.join(", ")}`
+          );
         }
       }
       if (typeof table.slowExportAsCsvCommand === "string") {
@@ -8146,10 +9755,13 @@ function writeStartedPlayRun(input) {
     `  stop run: deepline runs stop ${input.runId} --reason "stale lock" --json`
   ];
   if (input.jsonOutput) {
-    printCommandEnvelope({
-      ...payload,
-      render: { sections: [{ title: "play run", lines }] }
-    }, { json: true });
+    printCommandEnvelope(
+      {
+        ...payload,
+        render: { sections: [{ title: "play run", lines }] }
+      },
+      { json: true }
+    );
     return;
   }
   if (input.dashboardUrl) {
@@ -8160,11 +9772,14 @@ function writeStartedPlayRun(input) {
     input.progress.writeLine(output, process.stdout);
     return;
   }
-  printCommandEnvelope({
-    ...payload,
-    render: { sections: [{ title: "play run", lines }] }
-  }, { json: false, text: `${output}
-` });
+  printCommandEnvelope(
+    {
+      ...payload,
+      render: { sections: [{ title: "play run", lines }] }
+    },
+    { json: false, text: `${output}
+` }
+  );
 }
 function parsePlayRunOptions(args) {
   const usage = "Usage: deepline plays run <play-name> [--input '{...}'] [--no-wait] [--tail-timeout-ms 30000] [--force] [--full] [--<input> value]\n       deepline plays run <play-file.ts> [--input '{...}'] [--no-wait] [--tail-timeout-ms 30000] [--force] [--full] [--<input> value]\n       deepline plays run --file <play-file.ts> [--input '{...}'] [--no-wait] [--tail-timeout-ms 30000] [--force] [--full] [--<input> value]\n       deepline plays run --name <name> [--input '{...}'] [--live|--latest|--revision-id <id>] [--no-wait] [--tail-timeout-ms 30000] [--force] [--no-open] [--json] [--full] [--<input> value]\n       Unknown --<input> value flags, such as --limit 5, are passed into play input.\nRun `deepline plays run --help` for idempotency, tool call id, and ctx.map guidance.";
@@ -8187,7 +9802,7 @@ function parsePlayRunOptions(args) {
       continue;
     }
     if (arg === "--name" && args[index + 1]) {
-      playName = parseReferencedPlayTarget(args[++index]).playName;
+      playName = parseReferencedPlayTarget2(args[++index]).playName;
       continue;
     }
     if ((arg === "--input" || arg === "-i") && args[index + 1]) {
@@ -8217,7 +9832,7 @@ function parsePlayRunOptions(args) {
       );
     }
     if ((arg === "--tail-timeout-ms" || arg === "--timeout-ms") && args[index + 1]) {
-      waitTimeoutMs = parsePositiveInteger2(args[++index], arg);
+      waitTimeoutMs = parsePositiveInteger3(args[++index], arg);
       continue;
     }
     if (PLAY_RUN_RESERVED_BOOLEAN_FLAGS.has(arg)) {
@@ -8251,7 +9866,7 @@ function parsePlayRunOptions(args) {
       if (isFileTarget(arg) || looksLikeFilePath(arg)) {
         filePath = arg;
       } else {
-        playName = parseReferencedPlayTarget(arg).playName;
+        playName = parseReferencedPlayTarget2(arg).playName;
       }
       continue;
     }
@@ -8300,34 +9915,34 @@ function shouldUseLocalOnlyPlayCheck() {
   const value = process.env.DEEPLINE_PLAY_CHECK_LOCAL_ONLY?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function stringValue(value) {
+function stringValue2(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
-function extractionEntries(value) {
-  if (Array.isArray(value)) return value.filter(isRecord3);
-  if (!isRecord3(value)) return [];
+function extractionEntries2(value) {
+  if (Array.isArray(value)) return value.filter(isRecord4);
+  if (!isRecord4(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord3(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord4(entry) ? { name, ...entry } : { name }
   );
 }
 function firstRawPath(entry) {
-  const details = isRecord3(entry.details) ? entry.details : {};
+  const details = isRecord4(entry.details) ? entry.details : {};
   const paths = [
     ...asArray(details.rawToolOutputPaths),
     ...asArray(details.raw_tool_output_paths),
     ...asArray(details.candidatePaths),
     ...asArray(details.candidate_paths)
-  ].map(stringValue).filter(Boolean);
+  ].map(stringValue2).filter(Boolean);
   return paths[0];
 }
 function checkHintExpression(value) {
-  return stringValue(value).replace(/^toolExecutionResult\./, "result.");
+  return stringValue2(value).replace(/^toolExecutionResult\./, "result.");
 }
 function checkHintRawPath(value) {
   return value?.replace(/^toolResponse\./, "result.toolResponse.");
@@ -8335,14 +9950,14 @@ function checkHintRawPath(value) {
 function collectStaticPipelineToolIds(staticPipeline) {
   const seen = /* @__PURE__ */ new Set();
   const visitPipeline = (pipeline) => {
-    if (!isRecord3(pipeline)) return;
+    if (!isRecord4(pipeline)) return;
     for (const step of [
       ...asArray(pipeline.stages),
       ...asArray(pipeline.substeps)
     ]) {
-      if (!isRecord3(step)) continue;
+      if (!isRecord4(step)) continue;
       if (step.type === "tool") {
-        const toolId = stringValue(step.toolId) || stringValue(step.tool);
+        const toolId = stringValue2(step.toolId) || stringValue2(step.tool);
         if (toolId) seen.add(toolId);
       }
       if (step.type === "play_call") {
@@ -8354,20 +9969,20 @@ function collectStaticPipelineToolIds(staticPipeline) {
   return [...seen].sort();
 }
 function toolGetterHintFromMetadata(toolId, tool) {
-  const usageGuidance = isRecord3(tool.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord3(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord3(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
-  const toolResponse = isRecord3(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord3(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
-  const lists = extractionEntries(
+  const usageGuidance = isRecord4(tool.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord4(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord4(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const toolResponse = isRecord4(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord4(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
+  const lists = extractionEntries2(
     resultGuidance.extractedLists ?? resultGuidance.extracted_lists
   ).map((entry) => ({
-    name: stringValue(entry.name),
+    name: stringValue2(entry.name),
     expression: checkHintExpression(entry.expression),
     raw: checkHintRawPath(firstRawPath(entry))
   })).filter((entry) => entry.name && entry.expression);
-  const values = extractionEntries(
+  const values = extractionEntries2(
     resultGuidance.extractedValues ?? resultGuidance.extracted_values
   ).map((entry) => ({
-    name: stringValue(entry.name),
+    name: stringValue2(entry.name),
     expression: checkHintExpression(entry.expression),
     raw: checkHintRawPath(firstRawPath(entry))
   })).filter((entry) => entry.name && entry.expression);
@@ -8423,12 +10038,12 @@ function printToolGetterHints(hints) {
 async function handlePlayCheck(args) {
   const options = parsePlayCheckOptions(args);
   if (!isFileTarget(options.target)) {
-    const resolved = (0, import_node_path10.resolve)(options.target);
+    const resolved = (0, import_node_path11.resolve)(options.target);
     console.error(`File not found: ${resolved}`);
     return 1;
   }
-  const absolutePlayPath = (0, import_node_path10.resolve)(options.target);
-  const sourceCode = (0, import_node_fs8.readFileSync)(absolutePlayPath, "utf-8");
+  const absolutePlayPath = (0, import_node_path11.resolve)(options.target);
+  const sourceCode = (0, import_node_fs9.readFileSync)(absolutePlayPath, "utf-8");
   let graph;
   try {
     graph = await collectBundledPlayGraph(absolutePlayPath);
@@ -8455,8 +10070,10 @@ async function handlePlayCheck(args) {
       graphHash: graph.root.artifact.graphHash
     };
     if (options.jsonOutput) {
-      process.stdout.write(`${JSON.stringify({ name: playName, ...result2 })}
-`);
+      process.stdout.write(
+        `${JSON.stringify({ name: playName, ...result2 })}
+`
+      );
     } else {
       console.log(`\u2713 ${playName} passed local play check`);
       console.log(`  artifact: ${result2.artifactHash.slice(0, 12)}`);
@@ -8480,8 +10097,10 @@ async function handlePlayCheck(args) {
     toolGetterHints: result.toolGetterHints ?? await buildToolGetterHints(client, result.staticPipeline)
   };
   if (options.jsonOutput) {
-    process.stdout.write(`${JSON.stringify({ name: playName, ...enrichedResult })}
-`);
+    process.stdout.write(
+      `${JSON.stringify({ name: playName, ...enrichedResult })}
+`
+    );
   } else if (enrichedResult.valid) {
     console.log(`\u2713 ${playName} passed cloud play check`);
     if (enrichedResult.artifactHash) {
@@ -8503,12 +10122,12 @@ async function handleFileBackedRun(options) {
   }
   const client = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  const absolutePlayPath = (0, import_node_path10.resolve)(options.target.path);
+  const absolutePlayPath = (0, import_node_path11.resolve)(options.target.path);
   progress.phase("compiling play");
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
     { targetKind: "file" },
-    () => (0, import_node_fs8.readFileSync)(absolutePlayPath, "utf-8")
+    () => (0, import_node_fs9.readFileSync)(absolutePlayPath, "utf-8")
   );
   const runtimeInput = options.input ? { ...options.input } : {};
   let graph;
@@ -8792,19 +10411,19 @@ async function handlePlayRun(args) {
     if (isFileTarget(options.target.path)) {
       return handleFileBackedRun(options);
     }
-    const resolved = (0, import_node_path10.resolve)(options.target.path);
+    const resolved = (0, import_node_path11.resolve)(options.target.path);
     console.error(`File not found: ${resolved}`);
-    const dir = (0, import_node_path10.dirname)(resolved);
-    if ((0, import_node_fs8.existsSync)(dir)) {
-      const base = (0, import_node_path10.basename)(resolved);
+    const dir = (0, import_node_path11.dirname)(resolved);
+    if ((0, import_node_fs9.existsSync)(dir)) {
+      const base = (0, import_node_path11.basename)(resolved);
       try {
-        const siblings = (0, import_node_fs8.readdirSync)(dir).filter(
+        const siblings = (0, import_node_fs9.readdirSync)(dir).filter(
           (f) => f.includes(base.replace(/\.(play\.)?ts$/, "")) || f.endsWith(".play.ts")
         );
         if (siblings.length > 0) {
           console.error(`Did you mean one of these?`);
           for (const s of siblings.slice(0, 5)) {
-            console.error(`  ${(0, import_node_path10.join)(dir, s)}`);
+            console.error(`  ${(0, import_node_path11.join)(dir, s)}`);
           }
         }
       } catch {
@@ -8858,7 +10477,7 @@ async function handleRunsList(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if ((arg === "--play" || arg === "--name") && args[index + 1]) {
-      playName = parseReferencedPlayTarget(args[++index]).playName;
+      playName = parseReferencedPlayTarget2(args[++index]).playName;
       continue;
     }
     if (arg === "--status" && args[index + 1]) {
@@ -8887,15 +10506,20 @@ async function handleRunsList(args) {
     executionTime: run.executionTime,
     playName: run.memo?.playName ?? playName
   }));
-  const lines = runs.length === 0 ? [`No runs found for ${playName}.`] : runs.map((run) => `${run.runId} ${run.status} ${formatTimestamp(run.startedAt)}`);
-  printCommandEnvelope({
-    runs,
-    count: runs.length,
-    next: {
-      get: runs[0]?.runId ? `deepline runs get ${runs[0].runId} --json` : null
+  const lines = runs.length === 0 ? [`No runs found for ${playName}.`] : runs.map(
+    (run) => `${run.runId} ${run.status} ${formatTimestamp(run.startedAt)}`
+  );
+  printCommandEnvelope(
+    {
+      runs,
+      count: runs.length,
+      next: {
+        get: runs[0]?.runId ? `deepline runs get ${runs[0].runId} --json` : null
+      },
+      render: { sections: [{ title: "runs", lines }] }
     },
-    render: { sections: [{ title: "runs", lines }] }
-  }, { json: argsWantJson(args) });
+    { json: argsWantJson(args) }
+  );
   return 0;
 }
 async function handleRunTail(args) {
@@ -8910,7 +10534,9 @@ async function handleRunTail(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--cursor") {
-      console.error("--cursor was removed. deepline runs tail reads the canonical run stream.");
+      console.error(
+        "--cursor was removed. deepline runs tail reads the canonical run stream."
+      );
       return 1;
     }
     if (arg.startsWith("--") && arg !== "--json" && arg !== "--compact") {
@@ -8937,42 +10563,58 @@ async function handleRunLogs(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--limit" && args[index + 1]) {
-      limit = parsePositiveInteger2(args[++index], "--limit");
+      limit = parsePositiveInteger3(args[++index], "--limit");
       continue;
     }
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path10.resolve)(args[++index]);
+      outPath = (0, import_node_path11.resolve)(args[++index]);
     }
   }
   const client = new DeeplineClient();
   const status = await client.runs.get(runId);
   const logs = status.progress?.logs ?? [];
   if (outPath) {
-    (0, import_node_fs8.writeFileSync)(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
-    printCommandEnvelope({
-      runId: status.runId,
-      log_path: outPath,
-      lineCount: logs.length,
-      local: { log_path: outPath },
-      render: { sections: [{ title: "run logs", lines: [`Wrote ${logs.length} log lines to ${outPath}`] }] }
-    }, { json: argsWantJson(args) });
+    (0, import_node_fs9.writeFileSync)(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    printCommandEnvelope(
+      {
+        runId: status.runId,
+        log_path: outPath,
+        lineCount: logs.length,
+        local: { log_path: outPath },
+        render: {
+          sections: [
+            {
+              title: "run logs",
+              lines: [`Wrote ${logs.length} log lines to ${outPath}`]
+            }
+          ]
+        }
+      },
+      { json: argsWantJson(args) }
+    );
     return 0;
   }
   const entries = logs.slice(Math.max(0, logs.length - limit));
-  printCommandEnvelope({
-    runId: status.runId,
-    totalCount: logs.length,
-    returnedCount: entries.length,
-    firstSequence: logs.length === 0 ? null : logs.length - entries.length + 1,
-    lastSequence: logs.length === 0 ? null : logs.length,
-    truncated: logs.length > entries.length,
-    hasMore: logs.length > entries.length,
-    entries,
-    next: {
-      export: `deepline runs logs ${status.runId} --out run.log --json`
+  printCommandEnvelope(
+    {
+      runId: status.runId,
+      totalCount: logs.length,
+      returnedCount: entries.length,
+      firstSequence: logs.length === 0 ? null : logs.length - entries.length + 1,
+      lastSequence: logs.length === 0 ? null : logs.length,
+      truncated: logs.length > entries.length,
+      hasMore: logs.length > entries.length,
+      entries,
+      next: {
+        export: `deepline runs logs ${status.runId} --out run.log --json`
+      },
+      render: { sections: [{ title: "run logs", lines: entries }] }
     },
-    render: { sections: [{ title: "run logs", lines: entries }] }
-  }, { json: argsWantJson(args), text: `${entries.join("\n")}${entries.length > 0 ? "\n" : ""}` });
+    {
+      json: argsWantJson(args),
+      text: `${entries.join("\n")}${entries.length > 0 ? "\n" : ""}`
+    }
+  );
   return 0;
 }
 async function handleRunStop(args) {
@@ -8997,10 +10639,13 @@ async function handleRunStop(args) {
     `Stopped ${result.runId}`,
     ...result.hitlCancelledCount > 0 ? [`cancelled HITL waits: ${result.hitlCancelledCount}`] : []
   ];
-  printCommandEnvelope({
-    ...result,
-    render: { sections: [{ title: "run stop", lines }] }
-  }, { json: argsWantJson(args) });
+  printCommandEnvelope(
+    {
+      ...result,
+      render: { sections: [{ title: "run stop", lines }] }
+    },
+    { json: argsWantJson(args) }
+  );
   return 0;
 }
 async function handleRunExport(args) {
@@ -9018,7 +10663,7 @@ async function handleRunExport(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path10.resolve)(args[++index]);
+      outPath = (0, import_node_path11.resolve)(args[++index]);
       continue;
     }
     if (arg === "--dataset" && args[index + 1]) {
@@ -9026,7 +10671,7 @@ async function handleRunExport(args) {
       continue;
     }
     if (arg === "--metadata-out" && args[index + 1]) {
-      metadataOutPath = (0, import_node_path10.resolve)(args[++index]);
+      metadataOutPath = (0, import_node_path11.resolve)(args[++index]);
     }
   }
   if (!outPath) {
@@ -9083,7 +10728,7 @@ async function handleRunExport(args) {
     }
   };
   if (metadataOutPath) {
-    (0, import_node_fs8.writeFileSync)(
+    (0, import_node_fs9.writeFileSync)(
       metadataOutPath,
       `${JSON.stringify(payload, null, 2)}
 `,
@@ -9113,10 +10758,10 @@ async function handlePlayGet(args) {
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path10.resolve)(args[++index]);
+      outPath = (0, import_node_path11.resolve)(args[++index]);
     }
   }
-  const playName = isFileTarget(target) ? extractPlayName((0, import_node_fs8.readFileSync)((0, import_node_path10.resolve)(target), "utf-8"), (0, import_node_path10.resolve)(target)) : parseReferencedPlayTarget(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName((0, import_node_fs9.readFileSync)((0, import_node_path11.resolve)(target), "utf-8"), (0, import_node_path11.resolve)(target)) : parseReferencedPlayTarget2(target).playName;
   const detail = isFileTarget(target) ? await client.getPlay(playName) : await assertCanonicalNamedPlayReference(client, target);
   const resolvedSource = detail.play.workingRevision?.sourceCode ?? detail.play.liveRevision?.sourceCode ?? detail.play.currentRevision?.sourceCode ?? detail.play.sourceCode ?? "";
   const materializedFile = outPath ? materializeRemotePlaySource({
@@ -9201,7 +10846,7 @@ async function handlePlayVersions(args) {
   const jsonOutput = argsWantJson(args);
   await assertCanonicalNamedPlayReference(client, playName);
   const versions = await client.listPlayVersions(
-    parseReferencedPlayTarget(playName).playName
+    parseReferencedPlayTarget2(playName).playName
   );
   if (jsonOutput) {
     process.stdout.write(`${JSON.stringify({ versions })}
@@ -9219,20 +10864,8 @@ async function handlePlayVersions(args) {
 }
 async function handlePlayList(args) {
   const jsonOutput = argsWantJson(args);
-  const originArgIndex = args.findIndex((arg) => arg === "--origin");
-  const rawOrigin = originArgIndex >= 0 ? args[originArgIndex + 1] : void 0;
-  if (rawOrigin && rawOrigin !== "prebuilt" && rawOrigin !== "owned") {
-    throw new Error(`Invalid value for --origin: ${rawOrigin}`);
-  }
-  const origin = rawOrigin;
   const client = new DeeplineClient();
-  const plays = (await client.listPlays({
-    ...origin ? { origin } : {}
-  })).filter((play) => {
-    if (!origin) return true;
-    const isPrebuilt = play.origin === "prebuilt" || play.ownerType === "deepline";
-    return origin === "prebuilt" ? isPrebuilt : !isPrebuilt;
-  });
+  const plays = await client.listPlays();
   if (jsonOutput) {
     process.stdout.write(`${JSON.stringify(plays)}
 `);
@@ -9335,7 +10968,8 @@ function compactPlaySchema(schema) {
   return fields.length > 0 ? { fields } : schema;
 }
 function playSchemaMetadata(schema, key) {
-  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return null;
+  if (!schema || typeof schema !== "object" || Array.isArray(schema))
+    return null;
   const value = schema[key];
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -9350,7 +10984,10 @@ function playRunCommand(play, options) {
 function summarizePlayListItemForCli(play, options) {
   const aliases = play.aliases?.length ? play.aliases : [play.name];
   const csvInput = playSchemaMetadata(play.inputSchema, "csvInput");
-  const rowOutputSchema = playSchemaMetadata(play.outputSchema, "rowOutputSchema");
+  const rowOutputSchema = playSchemaMetadata(
+    play.outputSchema,
+    "rowOutputSchema"
+  );
   const runCommand2 = playRunCommand(play, { csvInput });
   const cloneEditStarter = buildCloneEditStarter(play);
   return {
@@ -9500,7 +11137,7 @@ async function handlePlayDescribe(args) {
   const client = new DeeplineClient();
   await assertCanonicalNamedPlayReference(client, playName);
   const play = await client.describePlay(
-    parseReferencedPlayTarget(playName).playName,
+    parseReferencedPlayTarget2(playName).playName,
     {
       compact: args.includes("--compact")
     }
@@ -9546,7 +11183,7 @@ async function handlePlayPublish(args) {
     }
     let graph;
     try {
-      graph = await collectBundledPlayGraph((0, import_node_path10.resolve)(playName));
+      graph = await collectBundledPlayGraph((0, import_node_path11.resolve)(playName));
       await compileBundledPlayGraphManifests(client, graph);
       await publishImportedPlayDependencies(client, graph);
     } catch (error) {
@@ -9575,7 +11212,7 @@ async function handlePlayPublish(args) {
     );
     return 0;
   }
-  const resolvedName = parseReferencedPlayTarget(playName).playName;
+  const resolvedName = parseReferencedPlayTarget2(playName).playName;
   if (useLatest) {
     const versions = await client.listPlayVersions(resolvedName);
     const latest = versions[0];
@@ -9615,17 +11252,19 @@ async function handlePlayDelete(args) {
   const client = new DeeplineClient();
   let detail;
   try {
-    detail = await client.getPlay(parseReferencedPlayTarget(playName).playName);
+    detail = await client.getPlay(parseReferencedPlayTarget2(playName).playName);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     return 1;
   }
   if (detail.play.ownerType === "deepline" || detail.play.origin === "prebuilt") {
-    console.error(`Cannot delete prebuilt play: ${formatPlayReference(detail.play)}`);
+    console.error(
+      `Cannot delete prebuilt play: ${formatPlayReference(detail.play)}`
+    );
     return 1;
   }
   const result = await client.deletePlay(
-    parseReferencedPlayTarget(formatPlayReference(detail.play)).playName
+    parseReferencedPlayTarget2(formatPlayReference(detail.play)).playName
   );
   if (argsWantJson(args)) {
     process.stdout.write(`${JSON.stringify(result)}
@@ -9770,6 +11409,7 @@ Pass-through input flags:
       ...passthroughArgs
     ]);
   });
+  registerPlayBootstrapCommand(play);
   play.command("get <target>").description("Fetch full play details.").addHelpText(
     "after",
     `
@@ -9784,7 +11424,10 @@ Examples:
   deepline plays get prebuilt/name-and-domain-to-email-waterfall-batch --source > email-waterfall.play.ts
   deepline plays get prebuilt/name-and-domain-to-email-waterfall-batch --source --out ./email-waterfall.play.ts
 `
-  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--source", "Print raw source code; combine with --out to write a file").option("--out <path>", "Write source to a specific path").action(async (target, options) => {
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option(
+    "--source",
+    "Print raw source code; combine with --out to write a file"
+  ).option("--out <path>", "Write source to a specific path").action(async (target, options) => {
     process.exitCode = await handlePlayGet([
       target,
       ...options.json ? ["--json"] : [],
@@ -9801,12 +11444,10 @@ Notes:
 
 Examples:
   deepline plays list
-  deepline plays list --origin prebuilt --json
   deepline plays search email --json
 `
-  ).option("--origin <origin>", "Filter to prebuilt or owned plays").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (options) => {
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (options) => {
     process.exitCode = await handlePlayList([
-      ...options.origin ? ["--origin", options.origin] : [],
       ...options.json ? ["--json"] : []
     ]);
   });
@@ -9831,7 +11472,9 @@ Examples:
     ]);
   });
   addPlaySearchCommand(play.command("search <query>"));
-  play.command("grep <query>").description("Literal grep over play names, aliases, schemas, and descriptions.").addHelpText(
+  play.command("grep <query>").description(
+    "Literal grep over play names, aliases, schemas, and descriptions."
+  ).addHelpText(
     "after",
     `
 Notes:
@@ -9917,7 +11560,9 @@ Examples:
     ]);
   });
   addPublishHelp(
-    play.command("set-live <target>").description("Promote a local file or saved revision as the live play revision.")
+    play.command("set-live <target>").description(
+      "Promote a local file or saved revision as the live play revision."
+    )
   ).option("--latest", "Promote the newest saved revision").option("--revision-id <id>", "Revision to promote").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
     process.exitCode = await handlePlayPublish([
       target,
@@ -9962,7 +11607,9 @@ Examples:
   deepline runs export play/my-play/run/20260501t000000-000 --out output.csv
 `
   );
-  runs.command("get <runId>").description("Get status, progress, result, errors, and recovery metadata for a play run.").addHelpText(
+  runs.command("get <runId>").description(
+    "Get status, progress, result, errors, and recovery metadata for a play run."
+  ).addHelpText(
     "after",
     `
 Notes:
@@ -10030,7 +11677,11 @@ Examples:
   deepline runs logs play/my-play/run/20260501t000000-000 --limit 500
   deepline runs logs play/my-play/run/20260501t000000-000 --out run.log --json
 `
-  ).option("--limit <count>", "Maximum recent log lines to print without --out", "200").option("--out <path>", "Write the full persisted log stream to a file").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
+  ).option(
+    "--limit <count>",
+    "Maximum recent log lines to print without --out",
+    "200"
+  ).option("--out <path>", "Write the full persisted log stream to a file").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
     process.exitCode = await handleRunLogs([
       runId,
       ...options.limit ? ["--limit", options.limit] : [],
@@ -10071,7 +11722,10 @@ Examples:
   deepline runs export play/my-play/run/20260501t000000-000 --out output.csv --metadata-out output.meta.json
   deepline runs export play/my-play/run/20260501t000000-000 --out output.csv --json
 `
-  ).requiredOption("--out <path>", "Output CSV path").option("--dataset <path>", "Returned dataset handle path, such as result.rows").option("--metadata-out <path>", "Write export metadata JSON to a file").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
+  ).requiredOption("--out <path>", "Output CSV path").option(
+    "--dataset <path>",
+    "Returned dataset handle path, such as result.rows"
+  ).option("--metadata-out <path>", "Write export metadata JSON to a file").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
     process.exitCode = await handleRunExport([
       runId,
       ...options.dataset ? ["--dataset", options.dataset] : [],
@@ -10085,14 +11739,14 @@ Examples:
 
 // src/cli/commands/tools.ts
 var import_commander2 = require("commander");
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_os7 = require("os");
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 
 // src/tool-output.ts
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_node_os6 = require("os");
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -10182,19 +11836,19 @@ function tryConvertToList(payload, options) {
   return null;
 }
 function ensureOutputDir() {
-  const outputDir = (0, import_node_path11.join)((0, import_node_os6.homedir)(), ".local", "share", "deepline", "data");
-  (0, import_node_fs9.mkdirSync)(outputDir, { recursive: true });
+  const outputDir = (0, import_node_path12.join)((0, import_node_os6.homedir)(), ".local", "share", "deepline", "data");
+  (0, import_node_fs10.mkdirSync)(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = (0, import_node_path11.join)(outputDir, `${stem}_${Date.now()}.json`);
-  (0, import_node_fs9.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  const outputPath = (0, import_node_path12.join)(outputDir, `${stem}_${Date.now()}.json`);
+  (0, import_node_fs10.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = (0, import_node_path11.join)(outputDir, `${stem}_${Date.now()}.csv`);
+  const outputPath = (0, import_node_path12.join)(outputDir, `${stem}_${Date.now()}.csv`);
   const seen = /* @__PURE__ */ new Set();
   const columns = [];
   for (const row of rows) {
@@ -10217,7 +11871,7 @@ function writeCsvOutputFile(rows, stem) {
   for (const row of rows) {
     lines.push(columns.map((column) => escapeCell(row[column])).join(","));
   }
-  (0, import_node_fs9.writeFileSync)(outputPath, `${lines.join("\n")}
+  (0, import_node_fs10.writeFileSync)(outputPath, `${lines.join("\n")}
 `, "utf-8");
   const previewRows = rows.slice(0, 5);
   const previewColumns = columns.slice(0, 5);
@@ -10299,11 +11953,14 @@ async function listTools(args) {
   const client = new DeeplineClient();
   const categoryArgIndex = args.findIndex((arg) => arg === "--categories");
   const categoryFilter = categoryArgIndex >= 0 ? args[categoryArgIndex + 1] : "";
+  const compact = args.includes("--compact");
   const requestedCategories = categoryFilter ? categoryFilter.split(",").map((item) => item.trim()).filter(Boolean) : [];
   const items = (await client.listTools({
     ...categoryFilter ? { categories: categoryFilter } : {}
   })).map(toListedTool).filter(
-    (item) => requestedCategories.length === 0 || requestedCategories.some((category) => item.categories.includes(category))
+    (item) => requestedCategories.length === 0 || requestedCategories.some(
+      (category) => item.categories.includes(category)
+    )
   );
   const render = {
     sections: [
@@ -10323,10 +11980,11 @@ async function listTools(args) {
       }
     ]
   };
+  const outputItems = compact ? items.map(compactTool) : items;
   printCommandEnvelope(
     {
-      tools: items,
-      count: items.length,
+      tools: outputItems,
+      count: outputItems.length,
       filters: {
         categories: requestedCategories
       },
@@ -10351,7 +12009,11 @@ async function searchTools(queryInput, options = {}) {
     searchMode: options.searchMode,
     includeSearchDebug: options.includeSearchDebug
   });
-  printCommandEnvelope(result, {
+  const payload = options.compact && Array.isArray(result.tools) ? {
+    ...result,
+    tools: result.tools.map(compactTool)
+  } : result;
+  printCommandEnvelope(payload, {
     json: options.json || shouldEmitJson()
   });
   return 0;
@@ -10370,7 +12032,9 @@ async function grepTools(queryInput, options = {}) {
     grepMode: mode,
     ...options.categories ? { categories: options.categories } : {}
   })).map(toListedTool).filter(
-    (item) => requestedCategories.length === 0 || requestedCategories.some((category) => item.categories.includes(category))
+    (item) => requestedCategories.length === 0 || requestedCategories.some(
+      (category) => item.categories.includes(category)
+    )
   ).filter(
     (item) => matchesGrepQuery(
       {
@@ -10388,10 +12052,11 @@ async function grepTools(queryInput, options = {}) {
       mode
     )
   );
+  const outputTools = options.compact ? tools.map(compactTool) : tools;
   printCommandEnvelope(
     {
-      tools,
-      count: tools.length,
+      tools: outputTools,
+      count: outputTools.length,
       query,
       grep: {
         mode,
@@ -10406,6 +12071,19 @@ async function grepTools(queryInput, options = {}) {
   );
   return 0;
 }
+function compactTool(tool) {
+  const listed = toListedTool(tool);
+  return {
+    id: listed.id,
+    toolId: listed.toolId,
+    provider: listed.provider,
+    displayName: listed.displayName,
+    description: listed.description,
+    categories: listed.categories,
+    type: listed.type,
+    executeCommand: listed.executeCommand
+  };
+}
 function playIdentifiers(play) {
   return [play.name, play.reference, ...play.aliases ?? []].filter((value) => Boolean(value?.trim())).map((value) => value.trim());
 }
@@ -10478,9 +12156,13 @@ Examples:
   deepline tools list --categories email_finder --json
   deepline tools search email --json
 `
-  ).option("--categories <categories>", "Comma-separated categories to filter inventory").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (options) => {
+  ).option(
+    "--categories <categories>",
+    "Comma-separated categories to filter inventory"
+  ).option("--compact", "Drop verbose fields from JSON output").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (options) => {
     process.exitCode = await listTools([
       ...options.categories ? ["--categories", options.categories] : [],
+      ...options.compact ? ["--compact"] : [],
       ...options.json ? ["--json"] : []
     ]);
   });
@@ -10498,9 +12180,19 @@ Examples:
   deepline tools grep "company enrichment" --categories enrichment --json
   deepline tools search verifier --search-mode v2 --json
 `
-  ).option("--categories <categories>", "Comma-separated categories to filter ranked search").option("--search_terms <terms>", "Structured search terms for ranked search").option("--search-terms <terms>", "Structured search terms for ranked search").option("--search-mode <mode>", "Ranked search mode: v1 or v2").option("--include-search-debug", "Include ranked search debug metadata").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (query, options) => {
+  ).option(
+    "--categories <categories>",
+    "Comma-separated categories to filter ranked search"
+  ).option(
+    "--search_terms <terms>",
+    "Structured search terms for ranked search"
+  ).option(
+    "--search-terms <terms>",
+    "Structured search terms for ranked search"
+  ).option("--search-mode <mode>", "Ranked search mode: v1 or v2").option("--include-search-debug", "Include ranked search debug metadata").option("--compact", "Drop verbose fields from JSON output").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (query, options) => {
     process.exitCode = await searchTools(query, {
       json: options.json,
+      compact: options.compact,
       categories: options.categories,
       searchTerms: options.searchTerms ?? options.search_terms,
       searchMode: options.searchMode === "v1" || options.searchMode === "v2" ? options.searchMode : void 0,
@@ -10508,7 +12200,9 @@ Examples:
     });
   });
   addToolSearchCommand(tools.command("search <query>"));
-  tools.command("grep <query>").description("Literal grep over tool ids, descriptions, categories, and input fields.").addHelpText(
+  tools.command("grep <query>").description(
+    "Literal grep over tool ids, descriptions, categories, and input fields."
+  ).addHelpText(
     "after",
     `
 Notes:
@@ -10522,10 +12216,14 @@ Examples:
   deepline tools grep "phone validate" --mode all --json
   deepline tools grep hunter --mode phrase --json
 `
-  ).option("--categories <categories>", "Comma-separated categories to filter inventory").option("--mode <mode>", "Grep matching mode: all, any, or phrase").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (query, options) => {
+  ).option(
+    "--categories <categories>",
+    "Comma-separated categories to filter inventory"
+  ).option("--mode <mode>", "Grep matching mode: all, any, or phrase").option("--compact", "Drop verbose fields from JSON output").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (query, options) => {
     const mode = options.mode === "any" || options.mode === "phrase" ? options.mode : "all";
     process.exitCode = await grepTools(query, {
       json: options.json,
+      compact: options.compact,
       categories: options.categories,
       mode
     });
@@ -10546,7 +12244,20 @@ Examples:
   deepline tools describe hunter_email_verifier --json
   deepline tools execute hunter_email_verifier --input '{"email":"a@b.com"}'
 `
-  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--pricing-only", "Only print pricing and billing semantics").option("--schema-only", "Only print input schema fields").option("--examples-only", "Only print runnable examples and sample payloads").option("--getters-only", "Only print extracted list/value getters").addOption(new import_commander2.Option("--compact", "Compatibility alias for the default compact view").hideHelp()).addOption(new import_commander2.Option("--contract-json", "Compatibility alias for compact contract JSON").hideHelp()).action(async (toolId, options) => {
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--pricing-only", "Only print pricing and billing semantics").option("--schema-only", "Only print input schema fields").option(
+    "--examples-only",
+    "Only print runnable examples and sample payloads"
+  ).option("--getters-only", "Only print extracted list/value getters").addOption(
+    new import_commander2.Option(
+      "--compact",
+      "Compatibility alias for the default compact view"
+    ).hideHelp()
+  ).addOption(
+    new import_commander2.Option(
+      "--contract-json",
+      "Compatibility alias for compact contract JSON"
+    ).hideHelp()
+  ).action(async (toolId, options) => {
     process.exitCode = await getTool(toolId, {
       json: Boolean(options.json),
       compact: Boolean(options.compact),
@@ -10588,13 +12299,24 @@ Examples:
   deepline tools execute hunter_email_verifier -p email=a@b.com
   deepline tools execute test_rate_limit --input '{"key":"smoke"}' --json | jq '.status'
 `
-  ).option("-p, --param <key=value>", "Pass one parameter. Repeat for multiple values.", (value, acc) => {
-    acc.push(value);
-    return acc;
-  }, []).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(
+    "-p, --param <key=value>",
+    "Pass one parameter. Repeat for multiple values.",
+    (value, acc) => {
+      acc.push(value);
+      return acc;
+    },
+    []
+  ).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(
     "--output-format <format>",
     "Output format: auto, csv, csv_file, json, or json_file"
-  ).option("--no-preview", "Only print the extracted output path when applicable").action(async (toolId, options) => {
+  ).option(
+    "--no-preview",
+    "Only print the extracted output path when applicable"
+  ).action(async (toolId, options) => {
     const args = [
       toolId,
       ...options.param.flatMap((value) => ["--param", value]),
@@ -10626,14 +12348,18 @@ async function getTool(toolId, options = {}) {
     throw error;
   }
   if (options.contractJson) {
-    process.stdout.write(`${JSON.stringify(toolContractJsonForDescribe(tool, toolId))}
-`);
+    process.stdout.write(
+      `${JSON.stringify(toolContractJsonForDescribe(tool, toolId))}
+`
+    );
     return 0;
   }
   const emitJson = options.json === true;
   if (emitJson) {
-    process.stdout.write(`${JSON.stringify(toolMetadataJsonForDescribe(tool, toolId))}
-`);
+    process.stdout.write(
+      `${JSON.stringify(toolMetadataJsonForDescribe(tool, toolId))}
+`
+    );
     return 0;
   }
   const onlyModes = [
@@ -10643,7 +12369,9 @@ async function getTool(toolId, options = {}) {
     options.gettersOnly
   ].filter(Boolean).length;
   if (onlyModes > 1) {
-    console.error("Use only one of --pricing-only, --schema-only, --examples-only, or --getters-only.");
+    console.error(
+      "Use only one of --pricing-only, --schema-only, --examples-only, or --getters-only."
+    );
     return 2;
   }
   if (options.pricingOnly) {
@@ -10667,8 +12395,10 @@ async function getTool(toolId, options = {}) {
     return 0;
   }
   if (shouldEmitJson()) {
-    process.stdout.write(`${JSON.stringify(toolMetadataJsonForDescribe(tool, toolId))}
-`);
+    process.stdout.write(
+      `${JSON.stringify(toolMetadataJsonForDescribe(tool, toolId))}
+`
+    );
     return 0;
   }
   printCompactToolContract(tool, toolId);
@@ -10676,9 +12406,15 @@ async function getTool(toolId, options = {}) {
 }
 function toolContractJsonForDescribe(tool, requestedToolId) {
   const toolId = String(tool.toolId || requestedToolId);
-  const inputFields = toolInputFieldsForDisplay(recordField(tool, "inputSchema", "input_schema"));
+  const inputFields = toolInputFieldsForDisplay(
+    recordField(tool, "inputSchema", "input_schema")
+  );
   const usageGuidance = recordField(tool, "usageGuidance", "usage_guidance");
-  const toolExecutionResult = recordField(usageGuidance, "toolExecutionResult", "tool_execution_result");
+  const toolExecutionResult = recordField(
+    usageGuidance,
+    "toolExecutionResult",
+    "tool_execution_result"
+  );
   const extractedLists = extractionContractEntries(
     arrayField(toolExecutionResult, "extractedLists", "extracted_lists")
   );
@@ -10731,7 +12467,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
 }
 function extractionContractEntries(entries) {
   return entries.flatMap((entry) => {
-    if (!isRecord4(entry)) return [];
+    if (!isRecord5(entry)) return [];
     const name = stringField(entry, "name");
     const expression = stringField(entry, "expression");
     return name && expression ? [{ name, expression }] : [];
@@ -10739,8 +12475,8 @@ function extractionContractEntries(entries) {
 }
 function printCompactToolContract(tool, requestedToolId) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord4(contract.cost) ? contract.cost : {};
-  const getters = isRecord4(contract.getters) ? contract.getters : {};
+  const cost = isRecord5(contract.cost) ? contract.cost : {};
+  const getters = isRecord5(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const inputFields = Array.isArray(contract.inputFields) ? contract.inputFields : [];
@@ -10757,18 +12493,20 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("");
     console.log("Inputs:");
     for (const field of inputFields) {
-      if (!isRecord4(field)) continue;
+      if (!isRecord5(field)) continue;
       const name = stringField(field, "name");
       if (!name) continue;
       const required = field.required ? "*" : "";
       const type = stringField(field, "type") || "unknown";
       const description = stringField(field, "description");
-      console.log(`- ${name}${required}: ${type}${description ? ` - ${description}` : ""}`);
+      console.log(
+        `- ${name}${required}: ${type}${description ? ` - ${description}` : ""}`
+      );
     }
   }
   console.log("");
   printToolExamplesOnly(tool, requestedToolId, { includeSamples: false });
-  const starterScript = isRecord4(contract.starterScript) ? contract.starterScript : {};
+  const starterScript = isRecord5(contract.starterScript) ? contract.starterScript : {};
   const starterPath = stringField(starterScript, "path");
   if (starterPath) {
     console.log("");
@@ -10780,19 +12518,27 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("Getters:");
     if (listGetters.length) console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord4(entry)) console.log(`- ${stringField(entry, "name")}: ${playResultExpression(entry)}`);
+      if (isRecord5(entry))
+        console.log(
+          `- ${stringField(entry, "name")}: ${playResultExpression(entry)}`
+        );
     }
     if (valueGetters.length) console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord4(entry)) console.log(`- ${stringField(entry, "name")}: ${playResultExpression(entry)}`);
+      if (isRecord5(entry))
+        console.log(
+          `- ${stringField(entry, "name")}: ${playResultExpression(entry)}`
+        );
     }
   }
   console.log("");
-  console.log(`More: deepline tools describe ${contract.toolId} --pricing-only | --schema-only | --examples-only | --getters-only | --json`);
+  console.log(
+    `More: deepline tools describe ${contract.toolId} --pricing-only | --schema-only | --examples-only | --getters-only | --json`
+  );
 }
 function printToolPricingOnly(tool, requestedToolId, options = {}) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord4(contract.cost) ? contract.cost : {};
+  const cost = isRecord5(contract.cost) ? contract.cost : {};
   const pricingModel = stringField(cost, "pricingModel") || "unknown";
   const billingMode = stringField(cost, "billingMode") || "unknown";
   const unit = pricingModel === "per_page" ? "page" : pricingModel === "per_result" ? "result" : pricingModel === "fixed" ? "call" : pricingModel.replace(/^per_/, "") || "unit";
@@ -10812,14 +12558,16 @@ function printToolSchemaOnly(tool, requestedToolId) {
   }
   console.log("Inputs:");
   for (const field of inputFields) {
-    if (!isRecord4(field)) continue;
+    if (!isRecord5(field)) continue;
     const name = stringField(field, "name");
     if (!name) continue;
     const required = field.required ? "*" : "";
     const type = stringField(field, "type") || "unknown";
     const description = stringField(field, "description");
     const defaultSuffix = Object.prototype.hasOwnProperty.call(field, "default") ? ` default=${JSON.stringify(field.default)}` : "";
-    console.log(`- ${name}${required}: ${type}${defaultSuffix}${description ? ` - ${description}` : ""}`);
+    console.log(
+      `- ${name}${required}: ${type}${defaultSuffix}${description ? ` - ${description}` : ""}`
+    );
   }
 }
 function printToolExamplesOnly(tool, requestedToolId, options = {}) {
@@ -10832,16 +12580,21 @@ function printToolExamplesOnly(tool, requestedToolId, options = {}) {
   console.log("const result = await ctx.tools.execute({");
   console.log(`  id: '${stableStepIdForTool(toolId)}',`);
   console.log(`  tool: '${toolId}',`);
-  console.log(`  input: ${JSON.stringify(sampleInput || {}, null, 2).replace(/\n/g, "\n  ")},`);
+  console.log(
+    `  input: ${JSON.stringify(sampleInput || {}, null, 2).replace(/\n/g, "\n  ")},`
+  );
   console.log("});");
-  const getters = isRecord4(contract.getters) ? contract.getters : {};
+  const getters = isRecord5(contract.getters) ? contract.getters : {};
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
-  const firstGetter = [...valueGetters, ...listGetters].find(isRecord4);
+  const firstGetter = [...valueGetters, ...listGetters].find(isRecord5);
   if (firstGetter) {
     const name = stringField(firstGetter, "name") || "value";
     const expression = stringField(firstGetter, "expression");
-    if (expression) console.log(`const ${safeIdentifier(name)} = ${expression.replace(/^toolExecutionResult\./, "result.")};`);
+    if (expression)
+      console.log(
+        `const ${safeIdentifier2(name)} = ${expression.replace(/^toolExecutionResult\./, "result.")};`
+      );
   }
   console.log("```");
   if (options.includeSamples !== false) {
@@ -10851,31 +12604,40 @@ function printToolExamplesOnly(tool, requestedToolId, options = {}) {
 }
 function printToolGettersOnly(tool, requestedToolId) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const getters = isRecord4(contract.getters) ? contract.getters : {};
+  const getters = isRecord5(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   console.log(`Getters: ${contract.toolId}`);
   if (!listGetters.length && !valueGetters.length) {
-    console.log("No generated getters declared. Use --json only if you need raw metadata.");
+    console.log(
+      "No generated getters declared. Use --json only if you need raw metadata."
+    );
     return;
   }
   if (listGetters.length) {
     console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord4(entry)) console.log(`- ${stringField(entry, "name")}: ${playResultExpression(entry)}`);
+      if (isRecord5(entry))
+        console.log(
+          `- ${stringField(entry, "name")}: ${playResultExpression(entry)}`
+        );
     }
   }
   if (valueGetters.length) {
     console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord4(entry)) console.log(`- ${stringField(entry, "name")}: ${playResultExpression(entry)}`);
+      if (isRecord5(entry))
+        console.log(
+          `- ${stringField(entry, "name")}: ${playResultExpression(entry)}`
+        );
     }
   }
 }
 function sampleValueForField(field) {
   const name = stringField(field, "name").toLowerCase();
   const type = stringField(field, "type").toLowerCase();
-  if (Object.prototype.hasOwnProperty.call(field, "default")) return field.default;
+  if (Object.prototype.hasOwnProperty.call(field, "default"))
+    return field.default;
   if (name.includes("email")) return "ada@example.com";
   if (name.includes("domain") || name.includes("website")) return "example.com";
   if (name.includes("first")) return "Ada";
@@ -10890,7 +12652,7 @@ function sampleValueForField(field) {
 function samplePayloadForInputFields(fields) {
   return Object.fromEntries(
     fields.slice(0, 4).flatMap((field) => {
-      if (!isRecord4(field)) return [];
+      if (!isRecord5(field)) return [];
       const name = stringField(field, "name");
       if (!name) return [];
       return [[name, sampleValueForField(field)]];
@@ -10900,12 +12662,15 @@ function samplePayloadForInputFields(fields) {
 function stableStepIdForTool(toolId) {
   return toolId.replace(/^[a-z0-9]+_/, "").replace(/[^a-z0-9_]+/gi, "_") || "tool_call";
 }
-function safeIdentifier(name) {
+function safeIdentifier2(name) {
   const cleaned = name.replace(/[^a-zA-Z0-9_$]+/g, "_").replace(/^[^a-zA-Z_$]+/, "");
   return cleaned || "value";
 }
 function playResultExpression(entry) {
-  return stringField(entry, "expression").replace(/^toolExecutionResult\./, "result.");
+  return stringField(entry, "expression").replace(
+    /^toolExecutionResult\./,
+    "result."
+  );
 }
 function toolMetadataJsonForDescribe(tool, requestedToolId) {
   const toolId = String(tool.toolId || requestedToolId);
@@ -10996,12 +12761,13 @@ function formatListedToolCost(tool) {
   return displayText ? `Cost: ${displayText}` : "";
 }
 function toolInputFieldsForDisplay(inputSchema) {
-  if (Array.isArray(inputSchema.fields)) return inputSchema.fields.filter(isRecord4);
-  const jsonSchema = isRecord4(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
-  const properties = isRecord4(jsonSchema.properties) ? jsonSchema.properties : {};
+  if (Array.isArray(inputSchema.fields))
+    return inputSchema.fields.filter(isRecord5);
+  const jsonSchema = isRecord5(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  const properties = isRecord5(jsonSchema.properties) ? jsonSchema.properties : {};
   const required = Array.isArray(jsonSchema.required) ? new Set(jsonSchema.required.map(String)) : /* @__PURE__ */ new Set();
   return Object.entries(properties).map(([name, value]) => {
-    const property = isRecord4(value) ? value : {};
+    const property = isRecord5(value) ? value : {};
     return {
       name,
       type: typeof property.type === "string" ? property.type : "unknown",
@@ -11016,8 +12782,10 @@ function printSamples(samples) {
   const responsePayload = samplePayload(samples, "response");
   if (requestPayload === void 0 && responsePayload === void 0) return;
   console.log("  Samples:");
-  if (requestPayload !== void 0) printJsonPreview("Example payload", requestPayload);
-  if (responsePayload !== void 0) printJsonPreview("Example response", responsePayload);
+  if (requestPayload !== void 0)
+    printJsonPreview("Example payload", requestPayload);
+  if (responsePayload !== void 0)
+    printJsonPreview("Example response", responsePayload);
 }
 function printJsonPreview(label, payload) {
   console.log(`  ${label}:`);
@@ -11028,15 +12796,15 @@ function printJsonPreview(label, payload) {
 }
 function samplePayload(samples, key) {
   const entry = samples[key];
-  if (!isRecord4(entry)) return void 0;
+  if (!isRecord5(entry)) return void 0;
   return Object.prototype.hasOwnProperty.call(entry, "payload") ? entry.payload : entry;
 }
 function commandEnvelopeFromRawResponse(rawResponse) {
-  return isRecord4(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
+  return isRecord5(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
 }
 function listExtractorPathsFromUsageGuidance(tool) {
   const toolExecutionResult = tool.usageGuidance?.toolExecutionResult;
-  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord4(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
+  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord5(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
   return extractedLists.flatMap((entry) => {
     const paths = entry.details?.candidatePaths ?? entry.details?.rawToolOutputPaths;
     if (!Array.isArray(paths)) return [];
@@ -11052,7 +12820,7 @@ function formatDecimal(value) {
 function formatUsd(value) {
   return `$${formatDecimal(value)}`;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringField(source, ...keys) {
@@ -11079,7 +12847,7 @@ function arrayField(source, ...keys) {
 function recordField(source, ...keys) {
   for (const key of keys) {
     const value = source[key];
-    if (isRecord4(value)) return value;
+    if (isRecord5(value)) return value;
   }
   return {};
 }
@@ -11102,7 +12870,9 @@ function normalizeOutputFormat(raw) {
 function parseExecuteOptions(args) {
   const toolId = args[0];
   if (!toolId) {
-    throw new Error(`Usage: deepline tools execute <toolId> [--param key=value ...] [--input '{"k":"v"}'] [--output-format auto|csv|csv_file|json|json_file] [--no-preview]`);
+    throw new Error(
+      `Usage: deepline tools execute <toolId> [--param key=value ...] [--input '{"k":"v"}'] [--output-format auto|csv|csv_file|json|json_file] [--no-preview]`
+    );
   }
   const params = {};
   let outputFormat = "auto";
@@ -11151,9 +12921,9 @@ function powerShellQuote(value) {
 function seedToolListScript(input) {
   const stem = safeFileStem(input.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = (0, import_node_fs10.mkdtempSync)((0, import_node_path12.join)((0, import_node_os7.tmpdir)(), "deepline-workflow-seed-"));
-  (0, import_node_fs10.chmodSync)(scriptDir, 448);
-  const scriptPath = (0, import_node_path12.join)(scriptDir, fileName);
+  const scriptDir = (0, import_node_fs11.mkdtempSync)((0, import_node_path13.join)((0, import_node_os7.tmpdir)(), "deepline-workflow-seed-"));
+  (0, import_node_fs11.chmodSync)(scriptDir, 448);
+  const scriptPath = (0, import_node_path13.join)(scriptDir, fileName);
   const projectDir = `deepline/projects/${stem}-workflow`;
   const playName = `${stem}-workflow`;
   const sampleRows = input.rows.length > 0 ? `${JSON.stringify(input.rows.slice(0, 2)).replace(/\]$/, "")}, ...]` : "[]";
@@ -11189,7 +12959,7 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
   };
 });
 `;
-  (0, import_node_fs10.writeFileSync)(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  (0, import_node_fs11.writeFileSync)(scriptPath, script, { encoding: "utf-8", mode: 384 });
   return {
     path: scriptPath,
     sourceCode: script,
@@ -11212,7 +12982,7 @@ function buildToolExecuteBaseEnvelope(input) {
     kind: summaryEntries.length > 0 ? "object" : "raw",
     summary: input.summary
   };
-  const envelopeHasCanonicalOutput = isRecord4(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
+  const envelopeHasCanonicalOutput = isRecord5(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
   const inspectCommand = `deepline tools execute ${input.toolId} --input ${shellQuote(JSON.stringify(input.params))} --json`;
   const actions = input.listConversion ? [
     {
@@ -11246,7 +13016,9 @@ function buildToolExecuteBaseEnvelope(input) {
       ] : [
         {
           title: "result",
-          lines: summaryEntries.length > 0 ? summaryEntries.map(([key, value]) => `${key}=${String(value)}`) : [JSON.stringify(input.rawResponse, null, 2)]
+          lines: summaryEntries.length > 0 ? summaryEntries.map(
+            ([key, value]) => `${key}=${String(value)}`
+          ) : [JSON.stringify(input.rawResponse, null, 2)]
         }
       ],
       actions
@@ -11273,7 +13045,9 @@ async function executeTool(args) {
     const play = await findPlayForToolId(client, parsed.toolId);
     if (play) {
       if (argsWantJson(args)) {
-        printJsonError(new Error(playAliasToolErrorMessage(parsed.toolId, play)));
+        printJsonError(
+          new Error(playAliasToolErrorMessage(parsed.toolId, play))
+        );
       } else {
         printPlayAliasToolError(parsed.toolId, play);
       }
@@ -11309,12 +13083,15 @@ async function executeTool(args) {
     return 0;
   }
   if (parsed.outputFormat === "json_file") {
-    const jsonPath = writeJsonOutputFile(rawResponse, `payload_${parsed.toolId}`);
+    const jsonPath = writeJsonOutputFile(
+      rawResponse,
+      `payload_${parsed.toolId}`
+    );
     printCommandEnvelope(
       {
         ...baseEnvelope,
         local: {
-          ...isRecord4(baseEnvelope.local) ? baseEnvelope.local : {},
+          ...isRecord5(baseEnvelope.local) ? baseEnvelope.local : {},
           payload_file: jsonPath
         }
       },
@@ -11324,7 +13101,10 @@ async function executeTool(args) {
   }
   if (!listConversion) {
     if (parsed.outputFormat === "csv" || parsed.outputFormat === "csv_file") {
-      const jsonPath = writeJsonOutputFile(rawResponse, `payload_${parsed.toolId}`);
+      const jsonPath = writeJsonOutputFile(
+        rawResponse,
+        `payload_${parsed.toolId}`
+      );
       printCommandEnvelope(
         {
           ...baseEnvelope,
@@ -11339,7 +13119,10 @@ async function executeTool(args) {
     printCommandEnvelope(baseEnvelope, { json: false });
     return 0;
   }
-  const csv = writeCsvOutputFile(listConversion.rows, `${parsed.toolId}_output`);
+  const csv = writeCsvOutputFile(
+    listConversion.rows,
+    `${parsed.toolId}_output`
+  );
   const seededScript = seedToolListScript({
     toolId: parsed.toolId,
     payload: parsed.params,
@@ -11365,7 +13148,9 @@ async function executeTool(args) {
           title: `${csv.path} (${csv.rowCount} rows)`,
           lines: [
             ...csv.columns.length > 0 ? [`columns: ${JSON.stringify(csv.columns)}`] : [],
-            ...Object.keys(summary).length > 0 ? [`summary: ${Object.entries(summary).map(([key, value]) => `${key}=${String(value)}`).join(", ")}`] : [],
+            ...Object.keys(summary).length > 0 ? [
+              `summary: ${Object.entries(summary).map(([key, value]) => `${key}=${String(value)}`).join(", ")}`
+            ] : [],
             `preview: ${JSON.stringify(csv.preview)}`,
             `starter script: ${seededScript.path}`
           ]
@@ -11388,22 +13173,25 @@ async function executeTool(args) {
     }
   };
   if (parsed.outputFormat === "csv_file") {
-    printCommandEnvelope({
-      ...materializedEnvelope,
-      extracted_csv: csv.path,
-      extracted_csv_rows: csv.rowCount,
-      extracted_csv_columns: csv.columns,
-      preview: csv.preview,
-      list_strategy: listConversion.strategy,
-      list_source_path: listConversion.sourcePath,
-      starter_script: seededScript.path,
-      project_dir: seededScript.projectDir,
-      copy_to_project: {
-        macos_linux: seededScript.macCopyCommand,
-        windows_powershell: seededScript.windowsCopyCommand
+    printCommandEnvelope(
+      {
+        ...materializedEnvelope,
+        extracted_csv: csv.path,
+        extracted_csv_rows: csv.rowCount,
+        extracted_csv_columns: csv.columns,
+        preview: csv.preview,
+        list_strategy: listConversion.strategy,
+        list_source_path: listConversion.sourcePath,
+        starter_script: seededScript.path,
+        project_dir: seededScript.projectDir,
+        copy_to_project: {
+          macos_linux: seededScript.macCopyCommand,
+          windows_powershell: seededScript.windowsCopyCommand
+        },
+        summary
       },
-      summary
-    }, { json: true });
+      { json: true }
+    );
     return 0;
   }
   if (parsed.noPreview) {
@@ -11426,8 +13214,8 @@ async function executeTool(args) {
 
 // src/cli/commands/update.ts
 var import_node_child_process = require("child_process");
-var import_node_fs11 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path14 = require("path");
 function posixShellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -11446,19 +13234,19 @@ function buildSourceUpdateCommand(sourceRoot) {
   return `${cdCommand} && git fetch origin main --tags && git merge --ff-only origin/main`;
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = (0, import_node_path13.resolve)(startPath);
+  let current = (0, import_node_path14.resolve)(startPath);
   while (true) {
-    if ((0, import_node_fs11.existsSync)((0, import_node_path13.join)(current, "sdk", "package.json")) && (0, import_node_fs11.existsSync)((0, import_node_path13.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if ((0, import_node_fs12.existsSync)((0, import_node_path14.join)(current, "sdk", "package.json")) && (0, import_node_fs12.existsSync)((0, import_node_path14.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = (0, import_node_path13.dirname)(current);
+    const parent = (0, import_node_path14.dirname)(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolveUpdatePlan() {
-  const entrypoint = process.argv[1] ? (0, import_node_path13.resolve)(process.argv[1]) : "";
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path13.dirname)(entrypoint)) : null;
+  const entrypoint = process.argv[1] ? (0, import_node_path14.resolve)(process.argv[1]) : "";
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path14.dirname)(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -11551,9 +13339,9 @@ Examples:
 
 // src/cli/skills-sync.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs12 = require("fs");
+var import_node_fs13 = require("fs");
 var import_node_os8 = require("os");
-var import_node_path14 = require("path");
+var import_node_path15 = require("path");
 var CHECK_TIMEOUT_MS2 = 3e3;
 var SDK_SKILL_NAME = "deepline-sdk";
 var SKILL_AGENTS = ["codex", "claude-code", "cursor"];
@@ -11564,28 +13352,28 @@ function shouldSkipSkillsSync() {
 }
 function sdkSkillsVersionPath(baseUrl) {
   const home = process.env.HOME?.trim() || (0, import_node_os8.homedir)();
-  return (0, import_node_path14.join)(home, ".local", "deepline", baseUrlSlug(baseUrl), "sdk-skills", ".version");
+  return (0, import_node_path15.join)(home, ".local", "deepline", baseUrlSlug(baseUrl), "sdk-skills", ".version");
 }
 function readLocalSkillsVersion(baseUrl) {
   const path = sdkSkillsVersionPath(baseUrl);
-  if (!(0, import_node_fs12.existsSync)(path)) return "";
+  if (!(0, import_node_fs13.existsSync)(path)) return "";
   try {
-    return (0, import_node_fs12.readFileSync)(path, "utf-8").trim();
+    return (0, import_node_fs13.readFileSync)(path, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  (0, import_node_fs12.mkdirSync)((0, import_node_path14.dirname)(path), { recursive: true });
-  (0, import_node_fs12.writeFileSync)(path, `${version}
+  (0, import_node_fs13.mkdirSync)((0, import_node_path15.dirname)(path), { recursive: true });
+  (0, import_node_fs13.writeFileSync)(path, `${version}
 `, "utf-8");
 }
 function installedSdkSkillHasStalePositionalExecuteExamples() {
   const home = process.env.HOME?.trim() || (0, import_node_os8.homedir)();
   const roots = [
-    (0, import_node_path14.join)(home, ".claude", "skills", SDK_SKILL_NAME),
-    (0, import_node_path14.join)(home, ".agents", "skills", SDK_SKILL_NAME)
+    (0, import_node_path15.join)(home, ".claude", "skills", SDK_SKILL_NAME),
+    (0, import_node_path15.join)(home, ".agents", "skills", SDK_SKILL_NAME)
   ];
   const staleMarkers = [
     "ctx.tools.execute(key",
@@ -11595,22 +13383,22 @@ function installedSdkSkillHasStalePositionalExecuteExamples() {
     'rowCtx.tools.execute("'
   ];
   const scan = (dir) => {
-    for (const entry of (0, import_node_fs12.readdirSync)(dir)) {
-      const path = (0, import_node_path14.join)(dir, entry);
-      const stat3 = (0, import_node_fs12.statSync)(path);
+    for (const entry of (0, import_node_fs13.readdirSync)(dir)) {
+      const path = (0, import_node_path15.join)(dir, entry);
+      const stat3 = (0, import_node_fs13.statSync)(path);
       if (stat3.isDirectory()) {
         if (scan(path)) return true;
         continue;
       }
       if (!entry.endsWith(".md")) continue;
-      const text = (0, import_node_fs12.readFileSync)(path, "utf-8");
+      const text = (0, import_node_fs13.readFileSync)(path, "utf-8");
       if (staleMarkers.some((marker) => text.includes(marker))) return true;
     }
     return false;
   };
   for (const root of roots) {
     try {
-      if ((0, import_node_fs12.existsSync)(root) && scan(root)) return true;
+      if ((0, import_node_fs13.existsSync)(root) && scan(root)) return true;
     } catch {
       continue;
     }
@@ -11708,7 +13496,7 @@ function resolveSkillsInstallCommands(baseUrl) {
   return [npxInstall];
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const child = (0, import_node_child_process2.spawn)(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
@@ -11718,7 +13506,7 @@ function runOneSkillsInstall(install) {
       stderr += chunk.toString("utf-8");
     });
     child.on("error", (error) => {
-      resolve11({
+      resolve12({
         ok: false,
         detail: `failed to start ${install.command}: ${error.message}`,
         manualCommand: install.manualCommand
@@ -11726,11 +13514,11 @@ function runOneSkillsInstall(install) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve11({ ok: true, detail: "", manualCommand: install.manualCommand });
+        resolve12({ ok: true, detail: "", manualCommand: install.manualCommand });
         return;
       }
       const detail = stderr.trim();
-      resolve11({
+      resolve12({
         ok: false,
         detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
         manualCommand: install.manualCommand
@@ -11806,8 +13594,8 @@ function shouldDeferSkillsSyncForCommand() {
   return (command === "play" || command === "plays") && subcommand === "run" && args.includes("--json");
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await (0, import_promises5.mkdtemp)((0, import_node_path15.join)((0, import_node_os9.tmpdir)(), "deepline-health-play-"));
-  const file = (0, import_node_path15.join)(dir, "health-check.play.ts");
+  const dir = await (0, import_promises5.mkdtemp)((0, import_node_path16.join)((0, import_node_os9.tmpdir)(), "deepline-health-play-"));
+  const file = (0, import_node_path16.join)(dir, "health-check.play.ts");
   try {
     await (0, import_promises5.writeFile)(
       file,
@@ -12015,6 +13803,6 @@ Examples:
     }
     process.exitCode = 1;
   }
-  process.exit(process.exitCode ?? 0);
+  process.exitCode = process.exitCode ?? 0;
 }
 main();