deepline 0.1.101 → 0.1.103

package/dist/cli/index.mjs

@@ -2,7 +2,7 @@
 
 // src/cli/index.ts
 import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile6 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 import { Command as Command3 } from "commander";
 
@@ -210,10 +210,15 @@ var SDK_RELEASE = {
   // 0.1.98 ships the duplicate-browser-tab fix (default-browser detection).
   // 0.1.99 ships prebuilt job-change source-column preservation and validation fixes.
   // 0.1.101 ships retryable play artifact publish failures and CI retry hardening.
-  version: "0.1.101",
+  // 0.1.102 ships the job-change ledger fixes: recovered-dataset export on
+  // failed runs, persisted/succeeded/failed row counts, strict local CSV
+  // preflight (existence, data rows, quotes, duplicate headers), HTML error
+  // scrubbing, and word-boundary watch truncation.
+  // 0.1.103 ships the refined SDK CLI command surface.
+  version: "0.1.103",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.101",
+    latest: "0.1.103",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -364,6 +369,22 @@ var HttpClient = class {
             parsed = body;
           }
           if (!response.ok) {
+            const htmlError = detectHtmlErrorBody(
+              body,
+              response.headers.get("content-type")
+            );
+            if (htmlError) {
+              throw new DeeplineError(
+                htmlError.message(response.status),
+                response.status,
+                "API_ERROR",
+                {
+                  htmlErrorPage: true,
+                  ...htmlError.title ? { title: htmlError.title } : {},
+                  ...htmlError.workerThrewException ? { workerThrewException: true } : {}
+                }
+              );
+            }
             const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
             const msg = typeof errorValue === "string" ? errorValue : errorValue && typeof errorValue === "object" && "message" in errorValue && typeof errorValue.message === "string" ? errorValue.message : typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string" ? parsed.message : `HTTP ${response.status}`;
             throw new DeeplineError(msg, response.status, "API_ERROR", {
@@ -424,6 +445,22 @@ var HttpClient = class {
         }
         if (!response.ok) {
           const body = await response.text();
+          const htmlError = detectHtmlErrorBody(
+            body,
+            response.headers.get("content-type")
+          );
+          if (htmlError) {
+            throw new DeeplineError(
+              htmlError.message(response.status),
+              response.status,
+              "API_ERROR",
+              {
+                htmlErrorPage: true,
+                ...htmlError.title ? { title: htmlError.title } : {},
+                ...htmlError.workerThrewException ? { workerThrewException: true } : {}
+              }
+            );
+          }
           const parsed = parseResponseBody(body);
           throw new DeeplineError(
             apiErrorMessage(parsed, response.status),
@@ -489,6 +526,31 @@ function parseResponseBody(body) {
     return body;
   }
 }
+function detectHtmlErrorBody(body, contentType) {
+  const trimmed = body.trim();
+  const lower = trimmed.toLowerCase();
+  const isHtml = (contentType ?? "").toLowerCase().includes("text/html") || lower.startsWith("<!doctype") || lower.startsWith("<html");
+  if (!isHtml) {
+    return null;
+  }
+  const titleMatch = trimmed.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = titleMatch?.[1]?.replace(/\s+/g, " ").trim() || void 0;
+  const workerThrewException = /worker threw exception/i.test(trimmed);
+  return {
+    title,
+    workerThrewException,
+    message: (status) => {
+      const segments = [`HTTP ${status}`];
+      if (workerThrewException) {
+        segments.push("Worker threw exception");
+      }
+      if (title) {
+        segments.push(title);
+      }
+      return `${segments.join(": ")} (Cloudflare HTML error page suppressed)`;
+    }
+  };
+}
 function apiErrorMessage(parsed, status) {
   const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
   if (typeof errorValue === "string") {
@@ -565,7 +627,7 @@ function decodeSseFrame(frame) {
   return parsed;
 }
 function sleep(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 
 // src/stream-reconnect.ts
@@ -584,7 +646,7 @@ function isTransientPlayStreamError(error) {
     return error.statusCode >= 500 && error.statusCode < 600;
   }
   const text = error instanceof Error ? error.message : String(error);
-  return /auth validation backend timed out|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
+  return /auth validation backend timed out|coordinator \/submit(?:\?[^ ]*)? 5\d\d|Worker threw exception|Internal Server Error|Service Unavailable|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
     text
   );
 }
@@ -816,6 +878,10 @@ function buildSnapshotFromLedger(snapshot) {
   return {
     runId: snapshot.runId,
     status: normalizePlayRunLiveStatus(snapshot.status),
+    createdAt: snapshot.createdAt ?? null,
+    startedAt: snapshot.startedAt ?? null,
+    finishedAt: snapshot.finishedAt ?? null,
+    durationMs: snapshot.durationMs ?? null,
     updatedAt: snapshot.updatedAt ?? snapshot.finishedAt ?? snapshot.startedAt ?? null,
     logs: snapshot.logTail,
     totalLogCount: snapshot.totalLogCount,
@@ -1272,14 +1338,14 @@ async function* observeRunEvents(options) {
   try {
     for (; ; ) {
       if (queue.length === 0) {
-        const waitForItem = new Promise((resolve15) => {
-          wake = resolve15;
+        const waitForItem = new Promise((resolve16) => {
+          wake = resolve16;
         });
         if (!sawFirstSnapshot) {
           const timedOut = await Promise.race([
             waitForItem.then(() => false),
             new Promise(
-              (resolve15) => setTimeout(() => resolve15(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
+              (resolve16) => setTimeout(() => resolve16(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
             )
           ]);
           if (timedOut && queue.length === 0) {
@@ -1376,7 +1442,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((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 function isTransientCompileManifestError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
@@ -1818,7 +1884,7 @@ var DeeplineClient = class {
    * or {@link runPlay}.
    *
    * Supported invocation surfaces intentionally share this same run contract:
-   * `deepline play run`, repo scripts such as `bun run deepline -- play run`,
+   * `deepline plays run`, repo scripts such as `bun run deepline -- plays run`,
    * SDK context calls like `Deepline.connect().play(name).run()`, and direct
    * `POST /api/v2/plays/run` calls all return a workflow/run id. The completed
    * output is always retrievable from `getPlayStatus(runId).result` (or from
@@ -1987,7 +2053,7 @@ var DeeplineClient = class {
    *
    * Unlike {@link registerPlayArtifact}, this does not store the artifact,
    * publish a revision, or start a run. It is the authoritative cloud validation
-   * path used by `deepline play check`.
+   * path used by `deepline plays check`.
    */
   async checkPlayArtifact(input2) {
     return this.http.post("/api/v2/plays/check", input2);
@@ -2180,7 +2246,7 @@ var DeeplineClient = class {
    * Get the current status of a play execution.
    *
    * Internal/advanced primitive. Public callers should usually prefer
-   * {@link runPlay}, {@link PlayJob.get}, or `deepline play run --watch`.
+   * {@link runPlay}, {@link PlayJob.get}, or `deepline plays run --watch`.
    *
    * @param workflowId - Play-run id from {@link startPlayRun}
    * @returns Current status with progress logs and partial results
@@ -3035,9 +3101,9 @@ async function writeOutputFile(filename, content) {
   return fullPath;
 }
 function browserOpenStateFile() {
-  const homeDir = process.env.HOME || homedir3();
+  const homeDir2 = process.env.HOME || homedir3();
   return join3(
-    homeDir,
+    homeDir2,
     ".local",
     "deepline",
     "runtime",
@@ -3511,8 +3577,8 @@ function printCommandEnvelope(envelope, options = {}) {
 
 // src/cli/commands/auth.ts
 var EXIT_OK = 0;
-var EXIT_AUTH = 1;
-var EXIT_SERVER = 2;
+var EXIT_AUTH = 3;
+var EXIT_SERVER = 5;
 function envFilePath(baseUrl) {
   return hostEnvFilePath(baseUrl);
 }
@@ -3604,7 +3670,7 @@ function buildCandidateUrls2(url) {
   }
 }
 function sleep4(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 function printDeeplineLogo() {
   if (process.stdout.isTTY && (process.stdout.columns ?? 80) >= 70) {
@@ -3867,7 +3933,7 @@ async function handleStatus(args) {
         ...hostStatusPayload ?? { host: baseUrl },
         status: "not connected",
         connected: false,
-        next: "deepline auth register",
+        next: "deepline auth register --no-wait && deepline auth wait",
         render: {
           sections: [
             {
@@ -3875,7 +3941,10 @@ async function handleStatus(args) {
               lines: [...hostLines, "Status: not connected"]
             }
           ],
-          actions: [{ label: "Run", command: "deepline auth register" }]
+          actions: [
+            { label: "Register", command: "deepline auth register --no-wait" },
+            { label: "Wait", command: "deepline auth wait" }
+          ]
         }
       },
       { json: jsonOutput }
@@ -3897,7 +3966,7 @@ async function handleStatus(args) {
         ...hostStatusPayload ?? { host: baseUrl },
         status: "unauthorized",
         connected: false,
-        next: "deepline auth register",
+        next: "deepline auth register --no-wait && deepline auth wait",
         render: {
           sections: [
             {
@@ -3905,7 +3974,10 @@ async function handleStatus(args) {
               lines: [...hostLines, "Status: unauthorized"]
             }
           ],
-          actions: [{ label: "Run", command: "deepline auth register" }]
+          actions: [
+            { label: "Register", command: "deepline auth register --no-wait" },
+            { label: "Wait", command: "deepline auth wait" }
+          ]
         }
       },
       { json: jsonOutput }
@@ -4538,14 +4610,25 @@ import { writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve4 } from "path";
 
 // ../shared_libs/plays/dataset-summary.ts
+function formatDatasetRowCountsLine(counts) {
+  const { persisted, succeeded, failed } = counts;
+  if (succeeded === persisted && failed === 0) {
+    return `${persisted} persisted`;
+  }
+  return `${persisted} persisted (${succeeded} succeeded, ${failed} failed)`;
+}
 function datasetSummaryPercentText(numerator, denominator) {
   return denominator > 0 ? `${numerator}/${denominator} (${Math.round(100 * numerator / denominator)}%)` : "0/0 (0%)";
 }
 function readCount(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
 }
-function formatDatasetExecutionStats(raw, denominator) {
-  return {
+function executionAttemptTotal(raw) {
+  return readCount(raw.queued) + readCount(raw.running) + readCount(raw.completed) + readCount(raw.cached) + readCount(raw.skipped) + readCount(raw.missed) + readCount(raw.failed);
+}
+function formatDatasetExecutionStats(raw, _persistedRowTotal) {
+  const denominator = executionAttemptTotal(raw);
+  const stats = {
     queued: datasetSummaryPercentText(readCount(raw.queued), denominator),
     running: datasetSummaryPercentText(readCount(raw.running), denominator),
     "completed:executed": datasetSummaryPercentText(
@@ -4566,6 +4649,17 @@ function formatDatasetExecutionStats(raw, denominator) {
     ),
     failed: datasetSummaryPercentText(readCount(raw.failed), denominator)
   };
+  if (Object.values(stats).some((text) => {
+    const match = /\((\d+)%\)/.exec(text);
+    return match ? Number(match[1]) > 100 : false;
+  })) {
+    throw new Error(
+      `formatDatasetExecutionStats produced a >100% execution stat; column counts are corrupt: ${JSON.stringify(
+        raw
+      )}`
+    );
+  }
+  return stats;
 }
 
 // src/cli/dataset-stats.ts
@@ -4715,7 +4809,8 @@ function canonicalRowsInfoFromCandidate(input2) {
       complete: rows2.length === totalRows2,
       source: candidate.source,
       datasetId: typeof candidate.value.datasetId === "string" ? candidate.value.datasetId : null,
-      tableNamespace: typeof candidate.value.tableNamespace === "string" ? candidate.value.tableNamespace : null
+      tableNamespace: typeof candidate.value.tableNamespace === "string" ? candidate.value.tableNamespace : null,
+      ...candidate.value.recovered === true ? { recovered: true } : {}
     };
   }
   if (candidate.serializedOnly) {
@@ -4865,18 +4960,46 @@ function collectCanonicalRowsInfos(statusOrResult) {
   }
   return infos;
 }
-function collectSerializedDatasetRowsInfos(statusOrResult) {
+function collectPackagedStepDatasetCandidates(statusOrResult) {
   const root = isRecord3(statusOrResult) ? statusOrResult : null;
-  const result = isRecord3(root?.result) ? root.result : root;
-  if (!result) {
+  if (!root) {
     return [];
   }
+  const pkg = isRecord3(root.package) ? root.package : root;
+  const steps = Array.isArray(pkg.steps) ? pkg.steps : [];
   const candidates = [];
-  collectDatasetCandidates({
-    value: result,
-    path: "result",
-    output: candidates
-  });
+  for (const step of steps) {
+    if (!isRecord3(step) || !isRecord3(step.output)) {
+      continue;
+    }
+    const output2 = step.output;
+    if (!isPackagedDatasetOutput(output2)) {
+      continue;
+    }
+    const source = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : typeof step.id === "string" ? step.id : null;
+    if (!source) {
+      continue;
+    }
+    candidates.push({
+      source,
+      value: output2,
+      total: output2.rowCount ?? (isRecord3(output2.preview) ? output2.preview.totalRows : void 0) ?? (isRecord3(step.progress) ? step.progress.total : void 0)
+    });
+  }
+  return candidates;
+}
+function collectSerializedDatasetRowsInfos(statusOrResult) {
+  const root = isRecord3(statusOrResult) ? statusOrResult : null;
+  const result = isRecord3(root?.result) ? root.result : root;
+  const candidates = [];
+  if (result) {
+    collectDatasetCandidates({
+      value: result,
+      path: "result",
+      output: candidates
+    });
+  }
+  candidates.push(...collectPackagedStepDatasetCandidates(statusOrResult));
   const seen = /* @__PURE__ */ new Set();
   const infos = [];
   for (const candidate of candidates) {
@@ -5500,7 +5623,7 @@ async function handleDbQuery(args) {
   return 0;
 }
 function registerDbCommands(program) {
-  const db = program.command("db").alias("customer-db").description("Query the tenant customer database.").addHelpText(
+  const db = program.command("db").description("Query the tenant customer database.").addHelpText(
     "after",
     `
 Notes:
@@ -5521,7 +5644,7 @@ Examples:
   deepline db query --sql "select domain, name from companies limit 20" --format markdown
 `
   );
-  db.command("query").alias("psql").description("Run SQL against the tenant customer database.").addHelpText(
+  db.command("query").description("Run SQL against the tenant customer database.").addHelpText(
     "after",
     `
 Notes:
@@ -5537,7 +5660,7 @@ Examples:
   deepline db query --sql "select * from companies limit 20"
   deepline db query --sql "select domain, name from companies limit 20" --json
   deepline db query --sql "create table if not exists storage.agent_notes (id text primary key, note text not null)"
-  deepline db psql --sql "select count(*) from contacts" --json
+  deepline db query --sql "select count(*) from contacts" --json
   deepline db query --sql "select * from contacts limit 20" --format csv --out contacts.csv
   deepline db query --sql "select domain, name from companies limit 20" --format markdown
 `
@@ -5575,9 +5698,11 @@ import {
   readFileSync as readFileSync6,
   readdirSync,
   realpathSync,
+  statSync as statSync2,
   writeFileSync as writeFileSync7
 } from "fs";
 import { basename as basename3, dirname as dirname8, join as join7, resolve as resolve10 } from "path";
+import { parse as parseCsvSync2 } from "csv-parse/sync";
 
 // src/plays/bundle-play-file.ts
 import { tmpdir as tmpdir2 } from "os";
@@ -9120,7 +9245,7 @@ function traceCliSync(phase, fields, run) {
   }
 }
 function sleep5(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 function parseReferencedPlayTarget2(target) {
   const trimmed = target.trim();
@@ -9390,6 +9515,177 @@ function inputContainsLocalFilePath(value) {
   }
   return false;
 }
+function isUrlValue(value) {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim());
+}
+function looksLikeStagedFileRef(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  return typeof record.contentHash === "string" || typeof record.contentBase64 === "string" || typeof record.logicalPath === "string" && typeof record.bytes === "number";
+}
+var CSV_DATA_INPUT_KEY = "csv";
+function collectLocalFileInputRefs(value, inputPath, key, out) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed || isUrlValue(trimmed)) {
+      return;
+    }
+    const keyIsCsvData = key === CSV_DATA_INPUT_KEY;
+    const endsWithCsv = /\.csv$/i.test(trimmed);
+    const looksLikeFile = /\.[a-z0-9]{1,8}$/i.test(trimmed);
+    if (keyIsCsvData) {
+      out.push({ inputPath, value: trimmed, isCsvData: true });
+    } else if (endsWithCsv || looksLikeFile && existsSync7(resolve10(trimmed))) {
+      out.push({ inputPath, value: trimmed, isCsvData: false });
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach(
+      (entry, index) => collectLocalFileInputRefs(entry, `${inputPath}[${index}]`, key, out)
+    );
+    return;
+  }
+  if (looksLikeStagedFileRef(value)) {
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [childKey, child] of Object.entries(value)) {
+      collectLocalFileInputRefs(
+        child,
+        inputPath ? `${inputPath}.${childKey}` : childKey,
+        childKey,
+        out
+      );
+    }
+  }
+}
+function preflightLocalFileInputs(runtimeInput) {
+  if (CSV_DATA_INPUT_KEY in runtimeInput) {
+    const csvValue = runtimeInput[CSV_DATA_INPUT_KEY];
+    if (typeof csvValue === "string" && csvValue.trim().length === 0) {
+      throw new DeeplineError(
+        `Input ${CSV_DATA_INPUT_KEY} is an empty string. Provide a path to a CSV file (or a CSV URL). No run was created.`,
+        void 0,
+        "PLAY_INPUT_FILE_PREFLIGHT",
+        { inputPath: CSV_DATA_INPUT_KEY, reason: "csv_empty_string" }
+      );
+    }
+  }
+  const refs = [];
+  for (const [key, value] of Object.entries(runtimeInput)) {
+    collectLocalFileInputRefs(value, key, key, refs);
+  }
+  for (const ref of refs) {
+    const absolutePath = resolve10(ref.value);
+    if (!existsSync7(absolutePath)) {
+      throw new DeeplineError(
+        `Input ${ref.inputPath} references a local file that does not exist: ${ref.value} (resolved to ${absolutePath}). No run was created.`,
+        void 0,
+        "PLAY_INPUT_FILE_PREFLIGHT",
+        { inputPath: ref.inputPath, path: ref.value, resolved: absolutePath }
+      );
+    }
+    let stat4;
+    try {
+      stat4 = statSync2(absolutePath);
+    } catch (error) {
+      throw new DeeplineError(
+        `Input ${ref.inputPath} references a local file that is not readable: ${ref.value} (${error instanceof Error ? error.message : String(error)}). No run was created.`,
+        void 0,
+        "PLAY_INPUT_FILE_PREFLIGHT",
+        { inputPath: ref.inputPath, path: ref.value }
+      );
+    }
+    if (!stat4.isFile()) {
+      throw new DeeplineError(
+        `Input ${ref.inputPath} references ${ref.value}, which is not a file. No run was created.`,
+        void 0,
+        "PLAY_INPUT_FILE_PREFLIGHT",
+        { inputPath: ref.inputPath, path: ref.value }
+      );
+    }
+    if (!ref.isCsvData) {
+      continue;
+    }
+    preflightCsvDataInput(ref, absolutePath);
+  }
+}
+function preflightCsvDataInput(ref, absolutePath) {
+  let content;
+  try {
+    content = readFileSync6(absolutePath, "utf-8");
+  } catch (error) {
+    throw new DeeplineError(
+      `Input ${ref.inputPath} CSV ${ref.value} is not readable: ${error instanceof Error ? error.message : String(error)}. No run was created.`,
+      void 0,
+      "PLAY_INPUT_FILE_PREFLIGHT",
+      { inputPath: ref.inputPath, path: ref.value }
+    );
+  }
+  let records;
+  try {
+    records = parseCsvSync2(content, {
+      bom: true,
+      columns: false,
+      skip_empty_lines: true,
+      relax_column_count: true,
+      // STRICT RFC quoting: an unclosed quote or ragged quoting is a hard
+      // error rather than being swallowed into one giant field.
+      relax_quotes: false,
+      trim: true
+    });
+  } catch (error) {
+    throw new DeeplineError(
+      `Input ${ref.inputPath} could not be parsed as CSV (${ref.value}): ${error instanceof Error ? error.message : String(error)}. This usually means an unclosed quote or ragged quoting. No run was created.`,
+      void 0,
+      "PLAY_INPUT_FILE_PREFLIGHT",
+      { inputPath: ref.inputPath, path: ref.value }
+    );
+  }
+  if (records.length === 0) {
+    throw new DeeplineError(
+      `${ref.value} has a header row but no data rows. No run was created.`,
+      void 0,
+      "PLAY_INPUT_FILE_PREFLIGHT",
+      { inputPath: ref.inputPath, path: ref.value }
+    );
+  }
+  const header = records[0];
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < header.length; i++) {
+    const raw = header[i] ?? "";
+    const name = raw.trim();
+    if (name.length === 0) continue;
+    const prior = seen.get(name);
+    if (prior) {
+      throw new DeeplineError(
+        `Input ${ref.inputPath} (${ref.value}) has a duplicate CSV header "${name}" (columns ${prior.index + 1} and ${i + 1}). The second column would silently overwrite the first. Rename one of them. No run was created.`,
+        void 0,
+        "PLAY_INPUT_FILE_PREFLIGHT",
+        {
+          inputPath: ref.inputPath,
+          path: ref.value,
+          duplicateHeader: name,
+          columns: [prior.index + 1, i + 1],
+          rawSpellings: [prior.raw, raw]
+        }
+      );
+    }
+    seen.set(name, { index: i, raw });
+  }
+  const dataRowCount = records.length - 1;
+  if (dataRowCount < 1) {
+    throw new DeeplineError(
+      `${ref.value} has a header row but no data rows. No run was created.`,
+      void 0,
+      "PLAY_INPUT_FILE_PREFLIGHT",
+      { inputPath: ref.inputPath, path: ref.value }
+    );
+  }
+}
 function namedRunNeedsPlayDefinition(input2) {
   return input2.revisionSelector === "latest" || inputContainsLocalFilePath(input2.runtimeInput);
 }
@@ -9624,6 +9920,21 @@ function isRetryablePendingStartFailure(status) {
   if (status.runId && status.runId !== "pending") return false;
   return isTransientPlayStreamError(new Error(playStatusErrorText(status)));
 }
+function pendingStartFailureStatus(input2) {
+  const message = input2.error instanceof Error ? input2.error.message : String(input2.error);
+  return {
+    runId: "pending",
+    name: input2.playName,
+    playName: input2.playName,
+    dashboardUrl: input2.dashboardUrl,
+    status: "failed",
+    progress: {
+      status: "failed",
+      logs: [],
+      error: message
+    }
+  };
+}
 var TERMINAL_PLAY_STATUSES2 = /* @__PURE__ */ new Set([
   "completed",
   "failed",
@@ -10403,6 +10714,23 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
         progress: input2.progress
       });
     }
+    if (!lastKnownWorkflowId && isTransientPlayStreamError(error)) {
+      recordCliTrace({
+        phase: "cli.play_start_stream_transient_failure",
+        ms: Date.now() - startedAt,
+        ok: false,
+        playName: input2.playName,
+        eventCount,
+        firstRunIdMs,
+        lastPhase,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+      return pendingStartFailureStatus({
+        playName: input2.playName,
+        dashboardUrl,
+        error
+      });
+    }
     throw error;
   } finally {
     if (timeout) {
@@ -10454,6 +10782,28 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
 function formatInteger(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toLocaleString("en-US") : String(value ?? "-");
 }
+var RUN_ERROR_DISPLAY_MAX_CHARS = 2e3;
+function truncateErrorForDisplay(message, runId, maxChars = RUN_ERROR_DISPLAY_MAX_CHARS) {
+  const compact = message.replace(/\s+/g, " ").trim();
+  if (compact.length <= maxChars) {
+    return compact;
+  }
+  const slice = compact.slice(0, maxChars);
+  const lastSpace = slice.lastIndexOf(" ");
+  const wordBoundary = lastSpace > 0 ? slice.slice(0, lastSpace) : slice;
+  const fullErrorHint = runId ? ` (full error: deepline runs get ${runId} --full)` : " (full error: deepline runs get <runId> --full)";
+  return `${wordBoundary}\u2026${fullErrorHint}`;
+}
+function clampJsonPreviewText(json, maxChars) {
+  if (json.length <= maxChars) {
+    return json;
+  }
+  const slice = json.slice(0, maxChars);
+  const lastNewline = slice.lastIndexOf("\n");
+  const head = lastNewline > 0 ? slice.slice(0, lastNewline) : slice;
+  return `${head}
+... truncated; use --json for full output`;
+}
 var BULKY_RETURN_KEYS = /* @__PURE__ */ new Set([
   "contract",
   "staticPipeline",
@@ -10538,8 +10888,7 @@ function formatJsonPreview(value) {
     return [];
   }
   const MAX_CHARS = 4e3;
-  const truncated = json.length > MAX_CHARS ? `${json.slice(0, MAX_CHARS)}
-... truncated; use --json for full output` : json;
+  const truncated = clampJsonPreviewText(json, MAX_CHARS);
   return truncated.split("\n").map((line) => `    ${line}`);
 }
 function formatReturnValue(result) {
@@ -11070,6 +11419,9 @@ function readRecordArray(value) {
 function readRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
+function readNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : null;
+}
 function formatSummaryScalar(value) {
   if (typeof value === "number") {
     return Number.isFinite(value) ? formatInteger(Math.trunc(value)) : null;
@@ -11102,7 +11454,25 @@ function formatPackageDatasetSummaryLines(summary, indent2 = "    ") {
     return [];
   }
   const lines = [];
-  const parts = formatSummaryScalarParts(record, /* @__PURE__ */ new Set(["columnStats"]));
+  const rowCounts = readRecord(record.rowCounts);
+  if (rowCounts) {
+    const persisted = readNonNegativeInteger(rowCounts.persisted);
+    const succeeded = readNonNegativeInteger(rowCounts.succeeded);
+    const failed = readNonNegativeInteger(rowCounts.failed);
+    if (persisted !== null) {
+      lines.push(
+        `${indent2}rows: ${formatDatasetRowCountsLine({
+          persisted,
+          succeeded: succeeded ?? persisted,
+          failed: failed ?? 0
+        })}`
+      );
+    }
+  }
+  const parts = formatSummaryScalarParts(
+    record,
+    /* @__PURE__ */ new Set(["columnStats", "rowCounts"])
+  );
   if (parts.length > 0) {
     lines.push(`${indent2}summary: ${parts.join(" ")}`);
   }
@@ -11163,7 +11533,7 @@ function buildRunPackageTextLines(packaged) {
   ];
   const runError = typeof run.error === "string" && run.error.trim() ? run.error.trim() : null;
   if (runError && (status === "failed" || status === "cancelled")) {
-    lines.push(`  error: ${runError.slice(0, 200)}`);
+    lines.push(`  error: ${truncateErrorForDisplay(runError, runId)}`);
   }
   for (const step of readRecordArray(packaged.steps)) {
     const output2 = step.output && typeof step.output === "object" && !Array.isArray(step.output) ? step.output : null;
@@ -11248,7 +11618,7 @@ function writePlayResult(status, jsonOutput, options) {
       lines.push(...buildInsufficientCreditsSummaryLines({ status, billing }));
     }
     const displayError = formatPlayErrorForDisplay(status, progressError) ?? progressError;
-    lines.push(`  error: ${displayError.slice(0, 200)}`);
+    lines.push(`  error: ${truncateErrorForDisplay(displayError, runId)}`);
   }
   const renderedServerView = renderServerResultView(status.resultView);
   if (result) {
@@ -11419,12 +11789,51 @@ async function fetchBackingDatasetRows(input2) {
     source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
   };
 }
+function resolveDatasetByName(available, datasetPath) {
+  const target = datasetPath.trim();
+  const exact = available.find((info) => info.source === target);
+  if (exact) {
+    return exact;
+  }
+  const byNamespace = available.find(
+    (info) => info.tableNamespace && info.tableNamespace === target
+  );
+  if (byNamespace) {
+    return byNamespace;
+  }
+  const trailing = target.split(".").filter(Boolean).at(-1);
+  if (!trailing) {
+    return null;
+  }
+  const byTrailing = available.find(
+    (info) => info.tableNamespace === trailing || typeof info.source === "string" && info.source.split(".").filter(Boolean).at(-1) === trailing
+  );
+  if (byTrailing) {
+    return byTrailing;
+  }
+  if (target.split(".").filter(Boolean)[0] === "result") {
+    const recovered = available.filter((info) => info.recovered);
+    if (recovered.length === 1) {
+      return recovered[0];
+    }
+    if (recovered.length > 1) {
+      const names = recovered.map((info) => info.tableNamespace ?? info.source).filter((name) => typeof name === "string");
+      throw new DeeplineError(
+        `Run returned multiple recovered datasets; '${target}' is ambiguous. Choose one with --dataset <path>: ${names.join(", ")}.`,
+        void 0,
+        "RUN_EXPORT_DATASET_AMBIGUOUS",
+        { dataset: target, available: names }
+      );
+    }
+  }
+  return null;
+}
 async function exportPlayStatusRows(client2, status, outPath, options = {}) {
   if (!outPath) {
     return null;
   }
   const availableRows = collectSerializedDatasetRowsInfos(status);
-  const rowsInfo = options.datasetPath ? availableRows.find((info) => info.source === options.datasetPath) ?? null : availableRows.length === 1 ? availableRows[0] : null;
+  const rowsInfo = options.datasetPath ? resolveDatasetByName(availableRows, options.datasetPath) ?? null : availableRows.length === 1 ? availableRows[0] : null;
   if (!rowsInfo && options.datasetPath) {
     const available = availableRows.map((info) => info.source).filter((source) => typeof source === "string");
     throw new DeeplineError(
@@ -11904,7 +12313,7 @@ function parsePlayRunOptions(args) {
 function parsePlayCheckOptions(args) {
   const target = args[0];
   if (!target) {
-    throw new Error("Usage: deepline play check <play-file.ts> [--json]");
+    throw new Error("Usage: deepline plays check <play-file.ts> [--json]");
   }
   const jsonOutput = argsWantJson(args);
   return { target, jsonOutput };
@@ -12170,6 +12579,12 @@ async function handleFileBackedRun(options) {
     () => readFileSync6(absolutePlayPath, "utf-8")
   );
   const runtimeInput = options.input ? { ...options.input } : {};
+  try {
+    preflightLocalFileInputs(runtimeInput);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
   let graph;
   try {
     graph = await traceCliSpan(
@@ -12327,6 +12742,12 @@ async function handleNamedRun(options) {
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const playName = options.target.name;
   const runtimeInput = options.input ? { ...options.input } : {};
+  try {
+    preflightLocalFileInputs(runtimeInput);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
   const needsPlayDefinition = namedRunNeedsPlayDefinition({
     runtimeInput,
     revisionSelector: options.revisionSelector
@@ -12822,7 +13243,9 @@ async function handleRunExport(args) {
 async function handlePlayGet(args) {
   const target = args[0];
   if (!target) {
-    console.error("Usage: deepline play get <play-file.ts|play-name> [--json]");
+    console.error(
+      "Usage: deepline plays get <play-file.ts|play-name> [--json]"
+    );
     return 1;
   }
   if (looksLikeRunId(target)) {
@@ -12920,7 +13343,7 @@ async function handlePlayVersions(args) {
   const nameIndex = args.indexOf("--name");
   const playName = nameIndex >= 0 ? args[nameIndex + 1] : void 0;
   if (!playName) {
-    console.error("Usage: deepline play versions --name <name> [--json]");
+    console.error("Usage: deepline plays versions --name <name> [--json]");
     return 1;
   }
   const client2 = new DeeplineClient();
@@ -13300,7 +13723,7 @@ async function handlePlayPublish(args) {
   const playName = args[0];
   if (!playName) {
     console.error(
-      "Usage: deepline play publish <play-file.ts|play-name> [--latest|--revision-id <id>] [--json]"
+      "Usage: deepline plays publish <play-file.ts|play-name> [--latest|--revision-id <id>] [--json]"
     );
     return 1;
   }
@@ -13444,7 +13867,7 @@ async function handlePlayDelete(args) {
   return result.deleted ? 0 : 1;
 }
 function registerPlayCommands(program) {
-  const play = program.command("plays").alias("play").description("Search, validate, run, and manage cloud plays.").addHelpText(
+  const play = program.command("plays").description("Search, validate, run, and manage cloud plays.").addHelpText(
     "after",
     `
 Concepts:
@@ -15951,7 +16374,7 @@ async function runGeneratedEnrichPlay(runArgs, options = {}) {
       });
     } catch (error) {
       if (attempt === 0 && isPlayStartStreamEndedError(error)) {
-        await new Promise((resolve15) => setTimeout(resolve15, 250));
+        await new Promise((resolve16) => setTimeout(resolve16, 250));
         continue;
       }
       throw error;
@@ -16751,19 +17174,16 @@ Notes:
   Use --command and --payload to attach a reproducible command shape.
 
 Examples:
-  deepline feedback "plays run failed after upload" --command "deepline plays run my.play.ts --watch"
-  deepline feedback "unexpected billing output" --payload '{"command":"billing usage"}' --json
+  deepline feedback send "plays run failed after upload" --command "deepline plays run my.play.ts --watch"
+  deepline feedback send "unexpected billing output" --payload '{"command":"billing usage"}' --json
 `
   );
-  feedback.argument("<text>", "Feedback text").option("--command <command>", "Command that reproduced the issue").option("--payload <payload>", "JSON or plain-text payload for the repro").option("--json", "Emit JSON output").action(handleFeedback);
-  program.command("provide-feedback").description("Legacy alias for `deepline feedback`.").addHelpText(
+  feedback.command("send").description("Send CLI feedback to Deepline.").addHelpText(
     "after",
     `
-Notes:
-  Compatibility alias. Prefer deepline feedback in new scripts and docs.
-
 Examples:
-  deepline feedback "tools search returned stale results" --json
+  deepline feedback send "tools search returned stale results" --json
+  deepline feedback send "plays run failed after upload" --command "deepline plays run my.play.ts --watch"
 `
   ).argument("<text>", "Feedback text").option("--command <command>", "Command that reproduced the issue").option("--payload <payload>", "JSON or plain-text payload for the repro").option("--json", "Emit JSON output").action(handleFeedback);
 }
@@ -16884,8 +17304,44 @@ async function handleOrgSwitch(selection, options) {
     { json: options.json }
   );
 }
+async function handleOrgCreate(name, options) {
+  const config = resolveConfig();
+  const http = new HttpClient(config);
+  const created = await http.post("/api/v2/auth/cli/org-create", {
+    api_key: config.apiKey,
+    name
+  });
+  saveHostEnvValues(config.baseUrl, {
+    DEEPLINE_API_KEY: created.api_key,
+    DEEPLINE_ACTIVE_ORG_ID: created.org_id,
+    DEEPLINE_ACTIVE_ORG_NAME: created.org_name
+  });
+  const { api_key: _apiKey, ...publicCreated } = created;
+  printCommandEnvelope(
+    {
+      ok: true,
+      ...publicCreated,
+      api_key_saved: true,
+      switched: true,
+      host_env_path: hostEnvFilePath(config.baseUrl),
+      render: {
+        sections: [
+          {
+            title: "org create",
+            lines: [
+              `Created organization: ${created.org_name}.`,
+              `Switched to ${created.org_name}.`,
+              `Saved host auth in ${hostEnvFilePath(config.baseUrl)}`
+            ]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
 function registerOrgCommands(program) {
-  const org = program.command("org").description("List and switch organizations.").addHelpText(
+  const org = program.command("org").description("List, create, and switch organizations.").addHelpText(
     "after",
     `
 Notes:
@@ -16894,6 +17350,7 @@ Notes:
 
 Examples:
   deepline org list --json
+  deepline org create Acme --json
   deepline org switch 2
   deepline org switch --org-id org_123 --json
 `
@@ -16909,6 +17366,19 @@ Examples:
   deepline org list --json
 `
   ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleOrgList);
+  org.command("create <name>").description("Create a new organization and switch this CLI to it.").addHelpText(
+    "after",
+    `
+Notes:
+  Mutates workspace state. The new organization is created for the current
+  authenticated user, then the returned API key is saved for this host so later
+  CLI commands target the new organization.
+
+Examples:
+  deepline org create Acme
+  deepline org create "Acme Sales" --json
+`
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleOrgCreate);
   org.command("switch [selection]").description(
     "Switch to another organization and save the new API key in the host auth file."
   ).addHelpText(
@@ -16953,7 +17423,7 @@ async function readHiddenLine(prompt) {
   if (typeof input.setRawMode === "function") input.setRawMode(true);
   let value = "";
   input.resume();
-  return await new Promise((resolve15, reject) => {
+  return await new Promise((resolve16, reject) => {
     let settled = false;
     const cleanup = () => {
       input.off("data", onData);
@@ -16968,7 +17438,7 @@ async function readHiddenLine(prompt) {
       settled = true;
       output.write("\n");
       cleanup();
-      resolve15(line);
+      resolve16(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -17138,22 +17608,566 @@ Examples:
   );
 }
 
+// src/cli/commands/sessions.ts
+import {
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync7,
+  statSync as statSync3,
+  writeFileSync as writeFileSync8
+} from "fs";
+import { homedir as homedir5, platform } from "os";
+import { basename as basename4, dirname as dirname9, join as join9, resolve as resolve12 } from "path";
+import { gzipSync } from "zlib";
+import { randomUUID } from "crypto";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var MAX_SESSION_UPLOAD_BYTES = 35e5;
+var MAX_DIRECT_SESSION_DECODED_BYTES = 50 * 1024 * 1024;
+var CHUNK_SIZE_BYTES = 25e5;
+var MAX_EVENT_STRING_CHARS = 8e3;
+var MAX_EVENT_LIST_ITEMS = 40;
+var MAX_EVENT_OBJECT_KEYS = 80;
+var TRUNCATION_MARKER = "...[truncated]";
+var NOISE_EVENT_TYPES = /* @__PURE__ */ new Set(["progress", "file-history-snapshot"]);
+function homeDir() {
+  return process.env.HOME?.trim() || homedir5();
+}
+function detectShellContext() {
+  const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
+  return {
+    shell: shellPath ? basename4(shellPath).replace(/\.exe$/i, "") : "unknown",
+    shell_path: shellPath || null,
+    os: platform(),
+    cwd: process.cwd()
+  };
+}
+function claudeProjectsRoot() {
+  return join9(homeDir(), ".claude", "projects");
+}
+function listClaudeSessionFiles() {
+  const root = claudeProjectsRoot();
+  if (!existsSync8(root)) return [];
+  const projectDirs = readDirectoryNames(root);
+  const files = [];
+  for (const projectDir of projectDirs) {
+    const fullProjectDir = join9(root, projectDir);
+    for (const fileName of readDirectoryNames(fullProjectDir)) {
+      if (fileName.endsWith(".jsonl")) {
+        files.push(join9(fullProjectDir, fileName));
+      }
+    }
+  }
+  return files;
+}
+function readDirectoryNames(dir) {
+  try {
+    return readdirSync2(dir);
+  } catch {
+    return [];
+  }
+}
+function newestClaudeSessionFile() {
+  let newest = null;
+  for (const filePath of listClaudeSessionFiles()) {
+    try {
+      const stat4 = statSync3(filePath);
+      if (!newest || stat4.mtimeMs > newest.mtimeMs) {
+        newest = { filePath, mtimeMs: stat4.mtimeMs };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return newest?.filePath ?? null;
+}
+function sessionIdFromFilePath(filePath) {
+  return basename4(filePath, ".jsonl");
+}
+function findSessionFile(sessionId) {
+  if (!UUID_RE.test(sessionId)) {
+    throw new Error(
+      "Invalid session ID format. Expected a UUID such as 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca."
+    );
+  }
+  for (const filePath of listClaudeSessionFiles()) {
+    if (sessionIdFromFilePath(filePath) === sessionId) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function resolveSessionTargets(input2) {
+  const targets = [];
+  if (input2.currentSession) {
+    const currentFile = newestClaudeSessionFile();
+    if (!currentFile) {
+      throw new Error("No session files found in ~/.claude/projects/*/.");
+    }
+    const sessionId = sessionIdFromFilePath(currentFile);
+    targets.push({
+      sessionId,
+      label: `session-${sessionId}`,
+      filePath: currentFile
+    });
+  }
+  for (const [index, sessionId] of (input2.sessionIds ?? []).entries()) {
+    const filePath = findSessionFile(sessionId);
+    if (!filePath) {
+      throw new Error(
+        `Session file not found: ~/.claude/projects/*/${sessionId}.jsonl`
+      );
+    }
+    targets.push({
+      sessionId,
+      label: input2.labels?.[index] ?? `session-${sessionId}`,
+      filePath
+    });
+  }
+  if (targets.length === 0) {
+    throw new Error("One of --session-id or --current-session is required.");
+  }
+  return targets;
+}
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function normalizedJsonLines(raw) {
+  return raw.toString("utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function stripNoiseEvents(raw) {
+  const lines = [];
+  for (const line of normalizedJsonLines(raw)) {
+    const parsed = parseJsonLine(line);
+    if (parsed && typeof parsed === "object" && NOISE_EVENT_TYPES.has(String(parsed.type ?? ""))) {
+      continue;
+    }
+    lines.push(line);
+  }
+  return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+}
+function messageContentKey(value) {
+  const message = value.message;
+  if (!message || typeof message !== "object") return null;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  return content.map((block) => {
+    if (!block || typeof block !== "object") return String(block);
+    const record = block;
+    const type = String(record.type ?? "");
+    if (type === "tool_use") {
+      return `tool_use:${String(record.name ?? "")}:${String(record.id ?? "")}`;
+    }
+    if (type === "tool_result") {
+      return `tool_result:${String(record.tool_use_id ?? "")}`;
+    }
+    return String(record.text ?? type);
+  }).join("\n");
+}
+function dedupConsecutiveEvents(raw) {
+  const rawLines = normalizedJsonLines(raw);
+  const parsedEvents = rawLines.map(parseJsonLine);
+  const output2 = [];
+  let index = 0;
+  while (index < parsedEvents.length) {
+    const event = parsedEvents[index];
+    if (!event || typeof event !== "object") {
+      output2.push(rawLines[index] ?? "");
+      index += 1;
+      continue;
+    }
+    const record = event;
+    const eventType = String(record.type ?? "");
+    const eventKey = messageContentKey(record);
+    if (!["user", "assistant"].includes(eventType) || !eventKey) {
+      output2.push(rawLines[index] ?? "");
+      index += 1;
+      continue;
+    }
+    let runCount = 1;
+    let cursor = index + 1;
+    while (cursor < parsedEvents.length) {
+      const next = parsedEvents[cursor];
+      if (!next || typeof next !== "object") break;
+      const nextRecord = next;
+      if (String(nextRecord.type ?? "") !== eventType || messageContentKey(nextRecord) !== eventKey) {
+        break;
+      }
+      runCount += 1;
+      cursor += 1;
+    }
+    if (runCount > 1) {
+      record._repeat_count = runCount;
+      record._repeat_summary = `${runCount} consecutive identical ${eventType} messages collapsed`;
+      output2.push(JSON.stringify(record));
+      index = cursor;
+      continue;
+    }
+    output2.push(rawLines[index] ?? "");
+    index += 1;
+  }
+  return Buffer.from(output2.length > 0 ? `${output2.join("\n")}
+` : "", "utf8");
+}
+function compactEventValue(value) {
+  if (typeof value === "string") {
+    if (value.length <= MAX_EVENT_STRING_CHARS) return value;
+    return `${value.slice(0, MAX_EVENT_STRING_CHARS - TRUNCATION_MARKER.length)}${TRUNCATION_MARKER}`;
+  }
+  if (Array.isArray(value)) {
+    const compacted = value.slice(0, MAX_EVENT_LIST_ITEMS).map(compactEventValue);
+    if (value.length > MAX_EVENT_LIST_ITEMS) {
+      compacted.push(
+        `${TRUNCATION_MARKER} ${value.length - MAX_EVENT_LIST_ITEMS} more item(s)`
+      );
+    }
+    return compacted;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    const compacted = {};
+    for (const [key, item] of entries.slice(0, MAX_EVENT_OBJECT_KEYS)) {
+      compacted[key] = compactEventValue(item);
+    }
+    if (entries.length > MAX_EVENT_OBJECT_KEYS) {
+      compacted._truncated_keys = entries.length - MAX_EVENT_OBJECT_KEYS;
+    }
+    return compacted;
+  }
+  return value;
+}
+function selectiveCompactToolResults(raw) {
+  const lines = [];
+  for (const line of normalizedJsonLines(raw)) {
+    const parsed = parseJsonLine(line);
+    if (!parsed || typeof parsed !== "object") {
+      lines.push(line);
+      continue;
+    }
+    const record = parsed;
+    if (record.type === "user") {
+      const message = record.message;
+      const content = message && typeof message === "object" ? message.content : null;
+      if (Array.isArray(content)) {
+        message.content = content.map(
+          (block) => block && typeof block === "object" && block.type === "tool_result" ? compactEventValue(block) : block
+        );
+      }
+    }
+    lines.push(JSON.stringify(record));
+  }
+  return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+}
+function prepareSessionBuffer(raw) {
+  return selectiveCompactToolResults(
+    dedupConsecutiveEvents(stripNoiseEvents(raw))
+  );
+}
+function buildSessionUploadContent(raw) {
+  const prepared = prepareSessionBuffer(raw);
+  const encoded = gzipSync(prepared).toString("base64");
+  if (encoded.length <= MAX_SESSION_UPLOAD_BYTES && prepared.length <= MAX_DIRECT_SESSION_DECODED_BYTES) {
+    return { encodedContent: encoded, needsChunking: false };
+  }
+  return { encodedContent: encoded, needsChunking: true };
+}
+async function uploadPayload(path, payload) {
+  const { http } = getAuthedHttpClient();
+  return await http.post(path, payload);
+}
+async function uploadChunkedSessions(sessions, options) {
+  const uploadId = randomUUID();
+  for (const session of sessions) {
+    const bytes = Buffer.from(session.encodedContent, "base64");
+    const chunks = [];
+    for (let offset = 0; offset < bytes.length; offset += CHUNK_SIZE_BYTES) {
+      chunks.push(bytes.subarray(offset, offset + CHUNK_SIZE_BYTES));
+    }
+    process.stderr.write(
+      `Uploading ${session.label} in ${chunks.length} chunk(s)...
+`
+    );
+    for (const [index, chunk] of chunks.entries()) {
+      await uploadPayload("/api/v2/cli/send-session/chunk", {
+        upload_id: uploadId,
+        session_id: session.sessionId,
+        index,
+        total_chunks: chunks.length,
+        data: chunk.toString("base64")
+      });
+    }
+  }
+  const response = await uploadPayload("/api/v2/cli/send-session/finalize", {
+    upload_id: uploadId,
+    session_ids: sessions.map((session) => session.sessionId),
+    labels: sessions.map((session) => session.label),
+    environments: sessions.map(() => detectShellContext())
+  });
+  printCommandEnvelope(
+    {
+      ...response,
+      ok: true,
+      uploaded: sessions.length,
+      render: {
+        sections: [
+          {
+            title: "sessions send",
+            lines: ["Session uploaded to #internal-reports (chunked)."]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+async function handleSessionsSend(options) {
+  if (options.file) {
+    const filePath = resolve12(options.file);
+    if (!existsSync8(filePath)) {
+      throw new Error(`File not found: ${options.file}`);
+    }
+    const response2 = await uploadPayload("/api/v2/cli/send-session", {
+      file: readFileSync7(filePath).toString("base64"),
+      filename: basename4(filePath)
+    });
+    printCommandEnvelope(
+      {
+        ...response2,
+        ok: true,
+        filename: basename4(filePath),
+        render: {
+          sections: [
+            {
+              title: "sessions send",
+              lines: [
+                `File '${basename4(filePath)}' uploaded to #internal-reports.`
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+    return;
+  }
+  const targets = resolveSessionTargets({
+    sessionIds: options.sessionId,
+    labels: options.label,
+    currentSession: options.currentSession
+  });
+  const built = targets.map((target) => {
+    const upload = buildSessionUploadContent(readFileSync7(target.filePath));
+    return { ...target, ...upload };
+  });
+  if (built.some((session) => session.needsChunking)) {
+    await uploadChunkedSessions(built, options);
+    return;
+  }
+  const response = built.length === 1 && !options.label?.length ? await uploadPayload("/api/v2/cli/send-session", {
+    session_id: built[0]?.sessionId,
+    content: built[0]?.encodedContent,
+    environment: detectShellContext()
+  }) : await uploadPayload("/api/v2/cli/send-session", {
+    sessions: built.map((session) => ({
+      session_id: session.sessionId,
+      content: session.encodedContent,
+      label: session.label,
+      environment: detectShellContext()
+    })),
+    environment: detectShellContext()
+  });
+  printCommandEnvelope(
+    {
+      ...response,
+      ok: true,
+      uploaded: built.length,
+      render: {
+        sections: [
+          {
+            title: "sessions send",
+            lines: ["Session uploaded to #internal-reports."]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+function fallbackViewerAssets() {
+  return {
+    css: [
+      "body{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;margin:0;padding:16px;background:#fafafa;color:#111}",
+      ".section{background:#fff;border:1px solid #ddd;border-radius:8px;padding:12px;margin-bottom:12px}",
+      ".section h2{margin:0 0 8px 0;font-size:14px}",
+      "pre{margin:0;white-space:pre-wrap;word-break:break-word;background:#f6f8fa;border:1px solid #e3e5e8;border-radius:6px;padding:10px}"
+    ].join(""),
+    js: [
+      "(() => {",
+      'const root=document.getElementById("main-content");',
+      'const raw=document.getElementById("raw-sessions");',
+      "if(!root||!raw)return;",
+      'let sessions=[];try{sessions=JSON.parse(raw.textContent||"[]")}catch{}',
+      'root.innerHTML="";',
+      "for(const session of sessions){",
+      'const section=document.createElement("section");section.className="section";',
+      'const title=document.createElement("h2");title.textContent=String(session.label||"session");',
+      'const pre=document.createElement("pre");',
+      'pre.textContent=(Array.isArray(session.events)?session.events:[]).map((event)=>JSON.stringify(event)).join("\\n");',
+      "section.append(title,pre);root.appendChild(section);",
+      "}",
+      "})();"
+    ].join("")
+  };
+}
+function parsePreparedEvents(buffer) {
+  return normalizedJsonLines(buffer).map((line) => {
+    const parsed = parseJsonLine(line);
+    return parsed ?? line;
+  });
+}
+async function handleSessionsRender(options) {
+  const targets = resolveSessionTargets({
+    sessionIds: options.sessionId,
+    labels: options.label,
+    currentSession: options.currentSession
+  });
+  let outputPath = options.output ? resolve12(options.output) : "";
+  if (!outputPath) {
+    const outputDir = join9(process.cwd(), "deepline", "data");
+    mkdirSync4(outputDir, { recursive: true });
+    outputPath = join9(
+      outputDir,
+      targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
+    );
+  } else {
+    mkdirSync4(dirname9(outputPath), { recursive: true });
+  }
+  const sessions = targets.map((target) => ({
+    label: target.label,
+    events: parsePreparedEvents(
+      prepareSessionBuffer(readFileSync7(target.filePath))
+    )
+  }));
+  const { css, js } = fallbackViewerAssets();
+  const refreshMeta = options.autoRefresh ? `<meta http-equiv="refresh" content="${Number.parseInt(options.autoRefresh, 10)}">` : "";
+  const rawJson = JSON.stringify(sessions).replace(/<\//g, "<\\/");
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+${refreshMeta}
+<title>Session Viewer</title>
+<style>${css}</style>
+</head>
+<body>
+<div class="layout">
+  <div class="main" id="main-content"></div>
+</div>
+<script type="application/json" id="raw-sessions">${rawJson}</script>
+<script>${js}</script>
+</body>
+</html>`;
+  writeFileSync8(outputPath, html, "utf8");
+  printCommandEnvelope(
+    {
+      ok: true,
+      file: outputPath,
+      session_count: targets.length,
+      render: {
+        sections: [
+          {
+            title: "sessions render",
+            lines: [`Rendered session viewer: ${outputPath}`]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+function collectOption(value, previous) {
+  previous.push(value);
+  return previous;
+}
+function registerSessionsCommands(program) {
+  const sessions = program.command("sessions").description("Upload and render local agent session transcripts.").addHelpText(
+    "after",
+    `
+Notes:
+  Session commands operate on local Claude session JSONL files under
+  ~/.claude/projects. send uploads a compacted transcript or file to Deepline.
+  render writes a local HTML viewer.
+
+Examples:
+  deepline sessions send --current-session --json
+  deepline sessions send --session-id 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca
+  deepline sessions render --current-session --output session.html
+`
+  );
+  sessions.command("send").description("Upload session transcript(s) or a local file to Deepline.").addHelpText(
+    "after",
+    `
+Examples:
+  deepline sessions send --current-session --json
+  deepline sessions send --session-id 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca --label "pilot run"
+  deepline sessions send --file ./debug.log --json
+`
+  ).option(
+    "--session-id <uuid>",
+    "Claude session UUID. Repeat for multiple sessions.",
+    collectOption,
+    []
+  ).option(
+    "--label <label>",
+    "Label for the preceding session id",
+    collectOption,
+    []
+  ).option("--current-session", "Use the newest local Claude session JSONL").option("--file <path>", "Upload a raw local file instead of a session").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleSessionsSend);
+  sessions.command("render").description("Render local session transcript(s) to an HTML viewer.").addHelpText(
+    "after",
+    `
+Examples:
+  deepline sessions render --current-session
+  deepline sessions render --session-id 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca --output session.html
+  deepline sessions render --current-session --auto-refresh 5 --json
+`
+  ).option(
+    "--session-id <uuid>",
+    "Claude session UUID. Repeat for multiple sessions.",
+    collectOption,
+    []
+  ).option(
+    "--label <label>",
+    "Label for the preceding session id",
+    collectOption,
+    []
+  ).option("--current-session", "Use the newest local Claude session JSONL").option("--auto-refresh <seconds>", "Add a browser auto-refresh interval").option("-o, --output <path>", "Output HTML path").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleSessionsRender);
+}
+
 // src/cli/commands/tools.ts
 import { Option } from "commander";
 import {
   chmodSync,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdtempSync,
-  readFileSync as readFileSync7,
-  writeFileSync as writeFileSync9
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync10
 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join10, resolve as resolve12 } from "path";
+import { join as join11, resolve as resolve13 } from "path";
 
 // src/tool-output.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join9 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join10 } from "path";
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -17249,19 +18263,19 @@ function tryConvertToList(payload, options) {
   return null;
 }
 function ensureOutputDir() {
-  const outputDir = join9(homedir5(), ".local", "share", "deepline", "data");
-  mkdirSync4(outputDir, { recursive: true });
+  const outputDir = join10(homedir6(), ".local", "share", "deepline", "data");
+  mkdirSync5(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = join9(outputDir, `${stem}_${Date.now()}.json`);
-  writeFileSync8(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  const outputPath = join10(outputDir, `${stem}_${Date.now()}.json`);
+  writeFileSync9(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = join9(outputDir, `${stem}_${Date.now()}.csv`);
+  const outputPath = join10(outputDir, `${stem}_${Date.now()}.csv`);
   const seen = /* @__PURE__ */ new Set();
   const columns = [];
   for (const row of rows) {
@@ -17284,7 +18298,7 @@ function writeCsvOutputFile(rows, stem) {
   for (const row of rows) {
     lines.push(columns.map((column) => escapeCell(row[column])).join(","));
   }
-  writeFileSync8(outputPath, `${lines.join("\n")}
+  writeFileSync9(outputPath, `${lines.join("\n")}
 `, "utf-8");
   const previewRows = rows.slice(0, 5);
   const previewColumns = columns.slice(0, 5);
@@ -17570,7 +18584,7 @@ Common commands:
 
 Output:
   Use describe for tool contracts.
-  Use execute to run a tool. run is accepted as a compatibility alias.
+  Use execute to run a tool.
 `
   );
   tools.command("list").description("List available tools.").addHelpText(
@@ -17663,7 +18677,7 @@ Examples:
 Notes:
   Shows the compact agent contract by default: what the tool does, cost,
   required inputs, play getters, and a runnable ctx.tools.execute snippet.
-  Use --json for the full metadata/debug payload.
+  get is accepted as a compatibility alias for describe.
 
 Examples:
   deepline tools describe hunter_email_verifier
@@ -17697,29 +18711,13 @@ Examples:
       gettersOnly: Boolean(options.gettersOnly)
     });
   });
-  addToolMetadataCommand(tools.command("describe <toolId>"));
-  tools.command("get <toolId>").description("Deprecated. Use tools describe.").addHelpText(
-    "after",
-    `
-Examples:
-  deepline tools describe hunter_email_verifier --json
-`
-  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (toolId, options) => {
-    const message = `tools get has been removed from the V2 SDK CLI. Use: deepline tools describe ${toolId} --json`;
-    if (options.json || shouldEmitJson()) {
-      printJsonError({ message, code: "TOOLS_GET_REMOVED" });
-    } else {
-      console.error(message);
-    }
-    process.exitCode = 2;
-  });
-  tools.command("execute <toolId>").alias("run").description("Execute a tool by id.").addHelpText(
+  addToolMetadataCommand(tools.command("describe <toolId>").alias("get"));
+  tools.command("execute <toolId>").description("Execute a tool by id.").addHelpText(
     "after",
     `
 Notes:
   Use tools for one atomic provider/API operation. Use plays for composed workflows,
   waterfalls, row maps, checkpoints, and retries.
-  execute is the canonical execution verb. run is a compatibility alias.
   Calling a provider-backed tool can spend Deepline credits. Use --json for the
   stable result payload plus output preview and debugging helpers.
 
@@ -17767,7 +18765,7 @@ Examples:
 }
 async function getTool(toolId, options = {}) {
   if (!toolId) {
-    console.error("Usage: deepline tools get <toolId> [--json]");
+    console.error("Usage: deepline tools describe <toolId> [--json]");
     return 1;
   }
   const client2 = new DeeplineClient();
@@ -18318,11 +19316,11 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = resolve12(trimmed);
-  if (existsSync8(resolved)) return resolved;
+  const resolved = resolve13(trimmed);
+  if (existsSync9(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = resolve12(trimmed.replace(/\\/g, "/"));
-    if (existsSync8(normalized)) return normalized;
+    const normalized = resolve13(trimmed.replace(/\\/g, "/"));
+    if (existsSync9(normalized)) return normalized;
   }
   return resolved;
 }
@@ -18333,7 +19331,7 @@ function readJsonArgument(raw, flagName) {
     throw new Error(`Invalid ${flagName} value: empty @file path.`);
   }
   try {
-    return readFileSync7(resolveAtFilePath(filePath), "utf8").replace(
+    return readFileSync8(resolveAtFilePath(filePath), "utf8").replace(
       /^\uFEFF/,
       ""
     );
@@ -18424,9 +19422,9 @@ function powerShellQuote(value) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = mkdtempSync(join10(tmpdir4(), "deepline-workflow-seed-"));
+  const scriptDir = mkdtempSync(join11(tmpdir4(), "deepline-workflow-seed-"));
   chmodSync(scriptDir, 448);
-  const scriptPath = join10(scriptDir, fileName);
+  const scriptPath = join11(scriptDir, fileName);
   const projectDir = `deepline/projects/${stem}-workflow`;
   const playName = `${stem}-workflow`;
   const sampleRows = input2.rows.length > 0 ? `${JSON.stringify(input2.rows.slice(0, 2)).replace(/\]$/, "")}, ...]` : "[]";
@@ -18462,7 +19460,7 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
   };
 });
 `;
-  writeFileSync9(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  writeFileSync10(scriptPath, script, { encoding: "utf-8", mode: 384 });
   return {
     path: scriptPath,
     sourceCode: script,
@@ -18717,7 +19715,7 @@ async function executeTool(args) {
 
 // src/cli/commands/workflow.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname9, join as join11, resolve as resolve13 } from "path";
+import { dirname as dirname10, join as join12, resolve as resolve14 } from "path";
 
 // src/cli/workflow-to-play.ts
 import { createHash as createHash4 } from "crypto";
@@ -18924,7 +19922,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await readFile4(resolve13(file), "utf8");
+    const raw = await readFile4(resolve14(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -18958,8 +19956,8 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = join11(resolve13(outDir), `${compiled.playName}.play.ts`);
-    await mkdir5(dirname9(file), { recursive: true });
+    const file = join12(resolve14(outDir), `${compiled.playName}.play.ts`);
+    await mkdir5(dirname10(file), { recursive: true });
     await writeFile5(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
@@ -19206,8 +20204,8 @@ Notes:
 
 // src/cli/commands/update.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync9 } from "fs";
-import { dirname as dirname10, join as join12, resolve as resolve14 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { dirname as dirname11, join as join13, resolve as resolve15 } from "path";
 function posixShellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -19226,19 +20224,19 @@ function buildSourceUpdateCommand(sourceRoot) {
   return `${cdCommand} && git fetch origin main --tags && git merge --ff-only origin/main`;
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = resolve14(startPath);
+  let current = resolve15(startPath);
   while (true) {
-    if (existsSync9(join12(current, "sdk", "package.json")) && existsSync9(join12(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if (existsSync10(join13(current, "sdk", "package.json")) && existsSync10(join13(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = dirname10(current);
+    const parent = dirname11(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolveUpdatePlan() {
-  const entrypoint = process.argv[1] ? resolve14(process.argv[1]) : "";
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname10(entrypoint)) : null;
+  const entrypoint = process.argv[1] ? resolve15(process.argv[1]) : "";
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname11(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -19313,7 +20311,7 @@ async function handleUpdate(options) {
   return runCommand(plan.command, plan.args);
 }
 function registerUpdateCommand(program) {
-  program.command("update").alias("upgrade").description("Update the Deepline SDK/CLI.").addHelpText(
+  program.command("update").description("Update the Deepline SDK/CLI.").addHelpText(
     "after",
     `
 Notes:
@@ -19341,7 +20339,7 @@ var command_compatibility_default = {
   session: {
     family: "python",
     label: "a legacy Python CLI session/playground command",
-    sdk_alternative: "Use SDK play run output and run commands such as `deepline plays run ...`."
+    sdk_alternative: "Use `deepline sessions send ...` or `deepline sessions render ...` for transcript workflows."
   },
   workflows: {
     family: "python",
@@ -19361,15 +20359,14 @@ var command_compatibility_default = {
     label: "an SDK CLI play command",
     python_alternative: "Use `deepline workflows ...` only for legacy workflows."
   },
-  play: {
-    family: "sdk",
-    label: "an SDK CLI play command",
-    python_alternative: "Use `deepline workflows ...` only for legacy workflows."
-  },
   runs: {
     family: "sdk",
     label: "an SDK CLI run inspection command"
   },
+  sessions: {
+    family: "sdk",
+    label: "an SDK CLI session transcript command"
+  },
   health: {
     family: "sdk",
     label: "an SDK CLI health command"
@@ -19502,15 +20499,15 @@ function unknownCommandNameFromMessage(message) {
 // src/cli/skills-sync.ts
 import { spawn as spawn2, spawnSync } from "child_process";
 import {
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync8,
-  statSync as statSync2,
-  writeFileSync as writeFileSync10
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync9,
+  statSync as statSync4,
+  writeFileSync as writeFileSync11
 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname11, join as join13 } from "path";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname12, join as join14 } from "path";
 var CHECK_TIMEOUT_MS2 = 3e3;
 var SDK_SKILL_NAME = "deepline-plays";
 var attemptedSync = false;
@@ -19524,20 +20521,20 @@ function activePluginSkillsDir() {
     return "";
   }
   const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
-  return dir && existsSync10(dir) ? dir : "";
+  return dir && existsSync11(dir) ? dir : "";
 }
 function readPluginSkillsVersion() {
   const dir = activePluginSkillsDir();
   if (!dir) return "";
   try {
-    return readFileSync8(join13(dir, ".version"), "utf-8").trim();
+    return readFileSync9(join14(dir, ".version"), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function sdkSkillsVersionPath(baseUrl) {
-  const home = process.env.HOME?.trim() || homedir6();
-  return join13(
+  const home = process.env.HOME?.trim() || homedir7();
+  return join14(
     home,
     ".local",
     "deepline",
@@ -19550,25 +20547,25 @@ function readLocalSkillsVersion(baseUrl) {
   const pluginVersion = readPluginSkillsVersion();
   if (pluginVersion) return pluginVersion;
   const path = sdkSkillsVersionPath(baseUrl);
-  if (!existsSync10(path)) return "";
+  if (!existsSync11(path)) return "";
   try {
-    return readFileSync8(path, "utf-8").trim();
+    return readFileSync9(path, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  mkdirSync5(dirname11(path), { recursive: true });
-  writeFileSync10(path, `${version}
+  mkdirSync6(dirname12(path), { recursive: true });
+  writeFileSync11(path, `${version}
 `, "utf-8");
 }
 function installedSdkSkillHasStalePositionalExecuteExamples() {
-  const home = process.env.HOME?.trim() || homedir6();
+  const home = process.env.HOME?.trim() || homedir7();
   const pluginSkillsDir = activePluginSkillsDir();
-  const roots = pluginSkillsDir ? [join13(pluginSkillsDir, SDK_SKILL_NAME)] : [
-    join13(home, ".claude", "skills", SDK_SKILL_NAME),
-    join13(home, ".agents", "skills", SDK_SKILL_NAME)
+  const roots = pluginSkillsDir ? [join14(pluginSkillsDir, SDK_SKILL_NAME)] : [
+    join14(home, ".claude", "skills", SDK_SKILL_NAME),
+    join14(home, ".agents", "skills", SDK_SKILL_NAME)
   ];
   const staleMarkers = [
     "ctx.tools.execute(key",
@@ -19578,22 +20575,22 @@ function installedSdkSkillHasStalePositionalExecuteExamples() {
     'rowCtx.tools.execute("'
   ];
   const scan = (dir) => {
-    for (const entry of readdirSync2(dir)) {
-      const path = join13(dir, entry);
-      const stat4 = statSync2(path);
+    for (const entry of readdirSync3(dir)) {
+      const path = join14(dir, entry);
+      const stat4 = statSync4(path);
       if (stat4.isDirectory()) {
         if (scan(path)) return true;
         continue;
       }
       if (!entry.endsWith(".md")) continue;
-      const text = readFileSync8(path, "utf-8");
+      const text = readFileSync9(path, "utf-8");
       if (staleMarkers.some((marker) => text.includes(marker))) return true;
     }
     return false;
   };
   for (const root of roots) {
     try {
-      if (existsSync10(root) && scan(root)) return true;
+      if (existsSync11(root) && scan(root)) return true;
     } catch {
       continue;
     }
@@ -19665,7 +20662,7 @@ function resolveSkillsInstallCommands(baseUrl) {
   return [npxInstall];
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     const child = spawn2(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
@@ -19675,7 +20672,7 @@ function runOneSkillsInstall(install) {
       stderr += chunk.toString("utf-8");
     });
     child.on("error", (error) => {
-      resolve15({
+      resolve16({
         ok: false,
         detail: `failed to start ${install.command}: ${error.message}`,
         manualCommand: install.manualCommand
@@ -19683,11 +20680,11 @@ function runOneSkillsInstall(install) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve15({ ok: true, detail: "", manualCommand: install.manualCommand });
+        resolve16({ ok: true, detail: "", manualCommand: install.manualCommand });
         return;
       }
       const detail = stderr.trim();
-      resolve15({
+      resolve16({
         ok: false,
         detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
         manualCommand: install.manualCommand
@@ -19775,8 +20772,8 @@ function shouldDeferSkillsSyncForCommand() {
   return (command === "play" || command === "plays") && subcommand === "run" && args.includes("--json");
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await mkdtemp2(join14(tmpdir5(), "deepline-health-play-"));
-  const file = join14(dir, "health-check.play.ts");
+  const dir = await mkdtemp2(join15(tmpdir5(), "deepline-health-play-"));
+  const file = join15(dir, "health-check.play.ts");
   try {
     await writeFile6(
       file,
@@ -19964,6 +20961,7 @@ Common commands:
   deepline preflight
   deepline health
   deepline auth status --json
+  deepline sessions send --current-session --json
   deepline plays search email --json
   deepline plays describe person-linkedin-to-email --json
   deepline plays run my.play.ts --input '{"domain":"stripe.com"}'
@@ -20016,6 +21014,7 @@ Exit codes:
   registerAuthCommands(program);
   registerToolsCommands(program);
   registerPlayCommands(program);
+  registerSessionsCommands(program);
   registerWorkflowCommands(program);
   registerSecretsCommands(program);
   registerBillingCommands(program);