deepline 0.1.57 → 0.1.58

package/dist/cli/index.mjs

@@ -197,10 +197,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.57",
+  version: "0.1.58",
   apiContract: "2026-05-play-tool-describe-starters",
   supportPolicy: {
-    latest: "0.1.57",
+    latest: "0.1.58",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -338,8 +338,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.
@@ -512,7 +512,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
@@ -522,7 +522,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") {
@@ -2258,7 +2258,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) {
@@ -4014,7 +4014,7 @@ import {
   realpathSync,
   writeFileSync as writeFileSync6
 } from "fs";
-import { basename as basename3, dirname as dirname8, join as join6, resolve as resolve9 } from "path";
+import { basename as basename3, dirname as dirname8, join as join6, resolve as resolve10 } from "path";
 
 // src/plays/bundle-play-file.ts
 import { tmpdir as tmpdir2 } from "os";
@@ -4374,6 +4374,9 @@ function localSdkAliasPlugin(adapter, options) {
       buildContext.onResolve({ filter: /^deepline$/ }, () => ({
         path: entryFile
       }));
+      buildContext.onResolve({ filter: /^deepline\/helpers$/ }, () => ({
+        path: join3(adapter.sdkSourceRoot, "helpers.ts")
+      }));
     }
   };
 }
@@ -5550,37 +5553,1474 @@ function warnAboutNonDevelopmentBundling(filePath) {
   console.warn(
     `[deepline] Warning: live play bundling was invoked while NODE_ENV=${nodeEnv} for ${filePath}. This source-first SDK path is intended for local development. For preview/production, run a published or prebuilt play reference instead of bundling source at runtime.`
   );
-  console.warn(
-    '[deepline] Preferred production call pattern: client.play("person-to-email").run(...) or run a previously registered/published org play.'
+  console.warn(
+    '[deepline] Preferred production call pattern: client.play("person-to-email").run(...) or run a previously registered/published org play.'
+  );
+}
+function defaultPlayBundleTarget() {
+  return resolveExecutionProfile(null).artifactKind;
+}
+function createSdkPlayBundlingAdapter() {
+  return {
+    projectRoot: PROJECT_ROOT,
+    nodeModulesDir: resolve8(PROJECT_ROOT, "node_modules"),
+    cacheDir: join5(
+      tmpdir2(),
+      `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION2}`
+    ),
+    sdkSourceRoot: SDK_SOURCE_ROOT,
+    sdkPackageJson: SDK_PACKAGE_JSON,
+    sdkEntryFile: SDK_ENTRY_FILE,
+    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !existsSync5(SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
+    sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
+    workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
+    workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
+    discoverPackagedLocalFiles,
+    warnAboutNonDevelopmentBundling
+  };
+}
+async function bundlePlayFile2(filePath, options = {}) {
+  return bundlePlayFile(filePath, {
+    target: options.target ?? defaultPlayBundleTarget(),
+    exportName: options.exportName,
+    adapter: createSdkPlayBundlingAdapter()
+  });
+}
+
+// src/cli/commands/plays/bootstrap.ts
+import { closeSync, openSync, readSync, statSync } from "fs";
+import { isAbsolute as isAbsolute3, relative as relative2, resolve as resolve9 } from "path";
+import { parse as parseCsvSync } from "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 = resolve9(csvPath);
+  const size = statSync(resolvedPath).size;
+  const fd = openSync(resolvedPath, "r");
+  const byteLength = Math.min(size, CSV_HEADER_SAMPLE_BYTES);
+  const buffer = Buffer.alloc(byteLength);
+  const bytesRead = readSync(fd, buffer, 0, byteLength, 0);
+  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 = parseCsvSync(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 = parseCsvSync(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 = resolve9(csvPath);
+  const relativePath = relative2(playDir, absoluteCsvPath);
+  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute3(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 defaultPlayBundleTarget() {
-  return resolveExecutionProfile(null).artifactKind;
-}
-function createSdkPlayBundlingAdapter() {
+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 {
-    projectRoot: PROJECT_ROOT,
-    nodeModulesDir: resolve8(PROJECT_ROOT, "node_modules"),
-    cacheDir: join5(
-      tmpdir2(),
-      `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION2}`
-    ),
-    sdkSourceRoot: SDK_SOURCE_ROOT,
-    sdkPackageJson: SDK_PACKAGE_JSON,
-    sdkEntryFile: SDK_ENTRY_FILE,
-    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !existsSync5(SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
-    sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
-    workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
-    workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
-    discoverPackagedLocalFiles,
-    warnAboutNonDevelopmentBundling
+    count: await rows.count(),
+    rows,
   };
+});
+
+`;
 }
-async function bundlePlayFile2(filePath, options = {}) {
-  return bundlePlayFile(filePath, {
-    target: options.target ?? defaultPlayBundleTarget(),
-    exportName: options.exportName,
-    adapter: createSdkPlayBundlingAdapter()
+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] : []
+    ]);
   });
 }
 
@@ -6035,9 +7475,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) {
@@ -6058,7 +7498,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({
@@ -6079,10 +7519,10 @@ function formatPlayListReference(play) {
   return play.reference || play.name;
 }
 function defaultMaterializedPlayPath(reference) {
-  return resolve9(defaultStarterPlayPath(reference));
+  return resolve10(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`;
 }
@@ -6138,7 +7578,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));
@@ -6158,7 +7598,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return existsSync6(resolve9(target));
+  return existsSync6(resolve10(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -6179,7 +7619,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.`);
@@ -6187,7 +7627,7 @@ function parsePositiveInteger2(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? readFileSync5(resolve9(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? readFileSync5(resolve10(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.");
@@ -6254,7 +7694,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;
 }
@@ -6288,7 +7729,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 existsSync6(resolve9(value));
+  return existsSync6(resolve10(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -6309,12 +7750,14 @@ 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 = resolve9(value);
+    const absolutePath = resolve10(value);
     return [{ binding, absolutePath, logicalPath: basename3(absolutePath) }];
   });
   if (localFiles.length === 0) {
@@ -6327,10 +7770,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 {
@@ -6350,9 +7801,9 @@ function stageFile(logicalPath, absolutePath) {
 }
 function normalizePlayPath(filePath) {
   try {
-    return realpathSync.native(resolve9(filePath));
+    return realpathSync.native(resolve10(filePath));
   } catch {
-    return resolve9(filePath);
+    return resolve10(filePath);
   }
 }
 function formatBundlingErrors(filePath, errors) {
@@ -6710,7 +8161,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}`;
 }
@@ -7424,7 +8878,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;
 }
@@ -7496,7 +8952,10 @@ function normalizeErrorsForEnvelope(status, error) {
       }
       return {
         ...entry,
-        message: formatInsufficientCreditsMessage({ billing: billing2, error: message2 }),
+        message: formatInsufficientCreditsMessage({
+          billing: billing2,
+          error: message2
+        }),
         billing: stripProviderSpendFromBilling(billing2)
       };
     });
@@ -7651,7 +9110,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}`);
   }
@@ -7722,13 +9183,16 @@ function writePlayResult(status, jsonOutput, options) {
   }
   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")}
-` });
+  printCommandEnvelope(
+    {
+      ...payload,
+      render: {
+        sections: [{ title: "run result", lines }]
+      }
+    },
+    { json: jsonOutput, text: `${lines.join("\n")}
+` }
+  );
 }
 async function resolvePlayRunOutputStatus(input) {
   if (!input.fullJson || !getPlayRunPackage(input.status)) {
@@ -7753,7 +9217,7 @@ function sqlStringLiteral(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
 function runExportRetryCommand(runId, outPath, datasetPath) {
-  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote(resolve9(outPath))}`;
+  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote(resolve10(outPath))}`;
 }
 function extractRunPlayName(status) {
   const run = status.run;
@@ -7787,7 +9251,7 @@ function buildCustomerDbQueryPlan(input) {
   return {
     sql,
     json: `${base} --json`,
-    csv: `${base} --format csv --out ${shellSingleQuote(resolve9(input.outPath))}`
+    csv: `${base} --format csv --out ${shellSingleQuote(resolve10(input.outPath))}`
   };
 }
 function exportableSheetRow(row) {
@@ -8087,7 +9551,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") {
@@ -8140,10 +9606,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) {
@@ -8154,11 +9623,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.";
@@ -8181,7 +9653,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]) {
@@ -8211,7 +9683,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)) {
@@ -8245,7 +9717,7 @@ function parsePlayRunOptions(args) {
       if (isFileTarget(arg) || looksLikeFilePath(arg)) {
         filePath = arg;
       } else {
-        playName = parseReferencedPlayTarget(arg).playName;
+        playName = parseReferencedPlayTarget2(arg).playName;
       }
       continue;
     }
@@ -8294,34 +9766,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.");
@@ -8329,14 +9801,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") {
@@ -8348,20 +9820,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);
@@ -8417,11 +9889,11 @@ function printToolGetterHints(hints) {
 async function handlePlayCheck(args) {
   const options = parsePlayCheckOptions(args);
   if (!isFileTarget(options.target)) {
-    const resolved = resolve9(options.target);
+    const resolved = resolve10(options.target);
     console.error(`File not found: ${resolved}`);
     return 1;
   }
-  const absolutePlayPath = resolve9(options.target);
+  const absolutePlayPath = resolve10(options.target);
   const sourceCode = readFileSync5(absolutePlayPath, "utf-8");
   let graph;
   try {
@@ -8449,8 +9921,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)}`);
@@ -8474,8 +9948,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) {
@@ -8497,7 +9973,7 @@ async function handleFileBackedRun(options) {
   }
   const client = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  const absolutePlayPath = resolve9(options.target.path);
+  const absolutePlayPath = resolve10(options.target.path);
   progress.phase("compiling play");
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
@@ -8786,7 +10262,7 @@ async function handlePlayRun(args) {
     if (isFileTarget(options.target.path)) {
       return handleFileBackedRun(options);
     }
-    const resolved = resolve9(options.target.path);
+    const resolved = resolve10(options.target.path);
     console.error(`File not found: ${resolved}`);
     const dir = dirname8(resolved);
     if (existsSync6(dir)) {
@@ -8852,7 +10328,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]) {
@@ -8881,15 +10357,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) {
@@ -8904,7 +10385,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") {
@@ -8931,11 +10414,11 @@ 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 = resolve9(args[++index]);
+      outPath = resolve10(args[++index]);
     }
   }
   const client = new DeeplineClient();
@@ -8943,30 +10426,46 @@ async function handleRunLogs(args) {
   const logs = status.progress?.logs ?? [];
   if (outPath) {
     writeFileSync6(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) });
+    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) {
@@ -8991,10 +10490,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) {
@@ -9012,7 +10514,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 = resolve9(args[++index]);
+      outPath = resolve10(args[++index]);
       continue;
     }
     if (arg === "--dataset" && args[index + 1]) {
@@ -9020,7 +10522,7 @@ async function handleRunExport(args) {
       continue;
     }
     if (arg === "--metadata-out" && args[index + 1]) {
-      metadataOutPath = resolve9(args[++index]);
+      metadataOutPath = resolve10(args[++index]);
     }
   }
   if (!outPath) {
@@ -9107,10 +10609,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 = resolve9(args[++index]);
+      outPath = resolve10(args[++index]);
     }
   }
-  const playName = isFileTarget(target) ? extractPlayName(readFileSync5(resolve9(target), "utf-8"), resolve9(target)) : parseReferencedPlayTarget(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName(readFileSync5(resolve10(target), "utf-8"), resolve10(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({
@@ -9195,7 +10697,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 })}
@@ -9329,7 +10831,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;
 }
@@ -9344,7 +10847,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 {
@@ -9494,7 +11000,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")
     }
@@ -9540,7 +11046,7 @@ async function handlePlayPublish(args) {
     }
     let graph;
     try {
-      graph = await collectBundledPlayGraph(resolve9(playName));
+      graph = await collectBundledPlayGraph(resolve10(playName));
       await compileBundledPlayGraphManifests(client, graph);
       await publishImportedPlayDependencies(client, graph);
     } catch (error) {
@@ -9569,7 +11075,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];
@@ -9609,17 +11115,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)}
@@ -9764,6 +11272,7 @@ Pass-through input flags:
       ...passthroughArgs
     ]);
   });
+  registerPlayBootstrapCommand(play);
   play.command("get <target>").description("Fetch full play details.").addHelpText(
     "after",
     `
@@ -9778,7 +11287,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"] : [],
@@ -9825,7 +11337,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:
@@ -9911,7 +11425,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,
@@ -9956,7 +11472,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:
@@ -10024,7 +11542,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] : [],
@@ -10065,7 +11587,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] : [],
@@ -10293,11 +11818,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: [
@@ -10317,10 +11845,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
       },
@@ -10345,7 +11874,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;
@@ -10364,7 +11897,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(
       {
@@ -10382,10 +11917,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,
@@ -10400,6 +11936,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());
 }
@@ -10472,9 +12021,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"] : []
     ]);
   });
@@ -10492,9 +12045,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,
@@ -10502,7 +12065,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:
@@ -10516,10 +12081,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
     });
@@ -10540,7 +12109,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 Option("--compact", "Compatibility alias for the default compact view").hideHelp()).addOption(new 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 Option(
+      "--compact",
+      "Compatibility alias for the default compact view"
+    ).hideHelp()
+  ).addOption(
+    new 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),
@@ -10582,13 +12164,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]),
@@ -10620,14 +12213,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 = [
@@ -10637,7 +12234,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) {
@@ -10661,8 +12260,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);
@@ -10670,9 +12271,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")
   );
@@ -10725,7 +12332,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 }] : [];
@@ -10733,8 +12340,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 : [];
@@ -10751,18 +12358,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("");
@@ -10774,19 +12383,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";
@@ -10806,14 +12423,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 = {}) {
@@ -10826,16 +12445,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) {
@@ -10845,31 +12469,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";
@@ -10884,7 +12517,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)]];
@@ -10894,12 +12527,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);
@@ -10990,12 +12626,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",
@@ -11010,8 +12647,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}:`);
@@ -11022,15 +12661,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 [];
@@ -11046,7 +12685,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) {
@@ -11073,7 +12712,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 {};
 }
@@ -11096,7 +12735,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";
@@ -11206,7 +12847,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 ? [
     {
@@ -11240,7 +12881,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
@@ -11267,7 +12910,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);
       }
@@ -11303,12 +12948,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
         }
       },
@@ -11318,7 +12966,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,
@@ -11333,7 +12984,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,
@@ -11359,7 +13013,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}`
           ]
@@ -11382,22 +13038,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) {
@@ -11421,7 +13080,7 @@ async function executeTool(args) {
 // src/cli/commands/update.ts
 import { spawn } from "child_process";
 import { existsSync as existsSync7 } from "fs";
-import { dirname as dirname9, join as join9, resolve as resolve10 } from "path";
+import { dirname as dirname9, join as join9, resolve as resolve11 } from "path";
 function posixShellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -11440,7 +13099,7 @@ function buildSourceUpdateCommand(sourceRoot) {
   return `${cdCommand} && git fetch origin main --tags && git merge --ff-only origin/main`;
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = resolve10(startPath);
+  let current = resolve11(startPath);
   while (true) {
     if (existsSync7(join9(current, "sdk", "package.json")) && existsSync7(join9(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
@@ -11451,7 +13110,7 @@ function findRepoBackedSdkRoot(startPath) {
   }
 }
 function resolveUpdatePlan() {
-  const entrypoint = process.argv[1] ? resolve10(process.argv[1]) : "";
+  const entrypoint = process.argv[1] ? resolve11(process.argv[1]) : "";
   const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname9(entrypoint)) : null;
   if (sourceRoot) {
     return {
@@ -11545,7 +13204,7 @@ Examples:
 
 // src/cli/skills-sync.ts
 import { spawn as spawn2, spawnSync } from "child_process";
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync6, statSync, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync2, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir4 } from "os";
 import { dirname as dirname10, join as join10 } from "path";
 var CHECK_TIMEOUT_MS2 = 3e3;
@@ -11591,7 +13250,7 @@ function installedSdkSkillHasStalePositionalExecuteExamples() {
   const scan = (dir) => {
     for (const entry of readdirSync2(dir)) {
       const path = join10(dir, entry);
-      const stat3 = statSync(path);
+      const stat3 = statSync2(path);
       if (stat3.isDirectory()) {
         if (scan(path)) return true;
         continue;
@@ -11702,7 +13361,7 @@ function resolveSkillsInstallCommands(baseUrl) {
   return [npxInstall];
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const child = spawn2(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
@@ -11712,7 +13371,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
@@ -11720,11 +13379,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