deepline 0.1.220 → 0.1.222

package/dist/cli/index.mjs

@@ -610,10 +610,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.220",
+  version: "0.1.222",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.220",
+    latest: "0.1.222",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [
@@ -5341,6 +5341,12 @@ function printCommandEnvelope(envelope, options = {}) {
 }
 
 // src/cli/commands/admin.ts
+function laneStatusLine(input2) {
+  if (input2.lane) {
+    return `status: ${input2.lane.status}${input2.lane.active ? " (active)" : ""}`;
+  }
+  return input2.registration ? `status: ${input2.registration.status}` : "status: (not in registry)";
+}
 function normalizeEnvironment(value) {
   const trimmed = value?.trim().toLowerCase();
   if (!trimmed || trimmed === "production" || trimmed === "prod") {
@@ -5393,7 +5399,7 @@ async function handleLanesShow(releaseId, options) {
             title: `Lane ${releaseId} (${environment}):`,
             lines: [
               `registered: ${payload.registered}`,
-              payload.lane ? `status: ${payload.lane.status}${payload.lane.active ? " (active)" : ""}` : "status: (not in registry)",
+              laneStatusLine(payload),
               `queue: ${payload.retireCheck.queue}`,
               `queued tasks: ${payload.retireCheck.queuedTasks}`,
               `non-terminal runs: ${payload.retireCheck.nonTerminalRuns}`,
@@ -5435,7 +5441,7 @@ async function handleReleasesActivate(releaseId, options) {
     {
       releaseId,
       environment,
-      ...options.schedulerBackend ? { schedulerBackend: options.schedulerBackend } : {}
+      schedulerBackend: options.schedulerBackend ?? "absurd"
     }
   );
   printCommandEnvelope(
@@ -5460,7 +5466,10 @@ function registerAdminCommands(program) {
   lanes.command("show <releaseId>").description("Show one lane and its retire-gate depth.").option("--environment <env>", "production (default) or preview").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleLanesShow);
   lanes.command("retire-check <releaseId>").description("Check whether a lane is safe to retire (queue empty).").option("--environment <env>", "production (default) or preview").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleLanesRetireCheck);
   const releases = admin.command("releases").description("Manage the active runtime release pointer.");
-  releases.command("activate <releaseId>").description("Flip the active runtime release to a prior registered lane.").option("--environment <env>", "production (default) or preview").option("--scheduler-backend <backend>", "absurd or workers_edge").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleReleasesActivate);
+  releases.command("activate <releaseId>").description("Activate a prior registered Absurd release lane.").option("--environment <env>", "production (default) or preview").option(
+    "--scheduler-backend <backend>",
+    "compatibility flag: absurd only; workers_edge is disabled"
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleReleasesActivate);
 }
 
 // src/cli/commands/auth.ts
@@ -14677,6 +14686,73 @@ function parsePlayCheckOptions(args) {
   const jsonOutput = argsWantJson(args);
   return { target, jsonOutput };
 }
+function parsePlayPublishOptions(args) {
+  const target = args[0];
+  if (!target) {
+    throw new Error(
+      "Usage: deepline plays publish <play-file.ts|play-name> [--expected-artifact <hash>] [--dry-run] [--latest|--revision-id <id>] [--json]"
+    );
+  }
+  let revisionId;
+  let useLatest = false;
+  let expectedArtifactHash;
+  let dryRun = false;
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--revision-id") {
+      revisionId = args[++index];
+      if (!revisionId) throw new Error("--revision-id requires a revision id.");
+      continue;
+    }
+    if (arg === "--latest") {
+      useLatest = true;
+      continue;
+    }
+    if (arg === "--expected-artifact") {
+      expectedArtifactHash = args[++index];
+      if (!expectedArtifactHash) {
+        throw new Error("--expected-artifact requires an artifact hash.");
+      }
+      continue;
+    }
+    if (arg.startsWith("--expected-artifact=")) {
+      expectedArtifactHash = arg.slice("--expected-artifact=".length);
+      if (!expectedArtifactHash) {
+        throw new Error("--expected-artifact requires an artifact hash.");
+      }
+      continue;
+    }
+    if (arg === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (arg === "--json") continue;
+    throw new Error(`Unknown plays publish option: ${arg}`);
+  }
+  if (revisionId && useLatest) {
+    throw new Error("Choose only one live target: --latest or --revision-id.");
+  }
+  return {
+    target,
+    revisionId,
+    useLatest,
+    expectedArtifactHash,
+    dryRun,
+    jsonOutput: argsWantJson(args)
+  };
+}
+function formatByteBudget(usedBytes, limitBytes) {
+  return `${usedBytes.toLocaleString()} B / ${limitBytes.toLocaleString()} B`;
+}
+function printPlayCheckLimits(limits) {
+  if (!limits) return;
+  console.log(
+    `  revision storage: ${formatByteBudget(limits.revisionStorage.usedBytes, limits.revisionStorage.limitBytes)}`
+  );
+  console.log(
+    `  bundle: ${formatByteBudget(limits.bundle.usedBytes, limits.bundle.limitBytes)}`
+  );
+}
 function shouldUseLocalOnlyPlayCheck() {
   const value = process.env.DEEPLINE_PLAY_CHECK_LOCAL_ONLY?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
@@ -14989,7 +15065,11 @@ async function handlePlayCheck(args) {
       );
     } else {
       console.log(`\u2713 ${playName} passed local play check`);
+      console.log(`  source: ${graph.root.artifact.sourceHash.slice(0, 12)}`);
       console.log(`  artifact: ${result2.artifactHash.slice(0, 12)}`);
+      console.log(
+        `  publish: deepline plays publish ${shellQuote2(options.target)} --expected-artifact ${result2.artifactHash}`
+      );
       printToolGetterHints(result2.toolGetterHints);
     }
     return 0;
@@ -15031,6 +15111,15 @@ async function handlePlayCheck(args) {
     if (enrichedResult.artifactHash) {
       console.log(`  artifact: ${enrichedResult.artifactHash.slice(0, 12)}`);
     }
+    if (enrichedResult.sourceHash) {
+      console.log(`  source: ${enrichedResult.sourceHash.slice(0, 12)}`);
+    }
+    printPlayCheckLimits(enrichedResult.limits);
+    if (enrichedResult.artifactHash) {
+      console.log(
+        `  publish: deepline plays publish ${shellQuote2(options.target)} --expected-artifact ${enrichedResult.artifactHash}`
+      );
+    }
     printPlayTriggers(enrichedResult.triggers);
     printRecognizedSummary(enrichedResult.recognized);
     printPlayCheckIssues(enrichedResult.issues, (line) => console.log(line));
@@ -16387,28 +16476,15 @@ async function handlePlayDescribe(args) {
   return 0;
 }
 async function handlePlayPublish(args) {
-  const playName = args[0];
-  if (!playName) {
-    console.error(
-      "Usage: deepline plays publish <play-file.ts|play-name> [--latest|--revision-id <id>] [--json]"
-    );
-    return 1;
-  }
-  let revisionId;
-  let useLatest = false;
-  for (let index = 1; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--revision-id" && args[index + 1]) {
-      revisionId = args[++index];
-    }
-    if (arg === "--latest") {
-      useLatest = true;
-    }
-  }
-  if (revisionId && useLatest) {
-    console.error("Choose only one live target: --latest or --revision-id.");
-    return 1;
+  let options;
+  try {
+    options = parsePlayPublishOptions(args);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 2;
   }
+  const { target: playName, useLatest } = options;
+  let revisionId = options.revisionId;
   const client2 = new DeeplineClient();
   if (isFileTarget(playName)) {
     if (revisionId || useLatest) {
@@ -16425,6 +16501,66 @@ async function handlePlayPublish(args) {
         () => collectBundledPlayGraph(resolve8(playName))
       );
       assertBundledPlayGraphDescriptions(graph);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      return 1;
+    }
+    const rootPlayName = graph.root.playName ?? extractPlayName(graph.root.sourceCode, graph.root.filePath);
+    const artifactHash = graph.root.artifact.artifactHash;
+    if (options.expectedArtifactHash && options.expectedArtifactHash !== artifactHash) {
+      const result3 = {
+        ok: false,
+        code: "PLAY_ARTIFACT_HASH_MISMATCH",
+        message: "Refusing to publish: the local file no longer produces the artifact checked earlier.",
+        expectedArtifactHash: options.expectedArtifactHash,
+        currentArtifactHash: artifactHash,
+        next: `deepline plays check ${shellQuote2(playName)}`
+      };
+      if (options.jsonOutput) {
+        process.stdout.write(`${JSON.stringify(result3)}
+`);
+      } else {
+        console.error(result3.message);
+        console.error(`  checked artifact: ${result3.expectedArtifactHash}`);
+        console.error(`  current artifact: ${result3.currentArtifactHash}`);
+        console.error(`  run: ${result3.next}`);
+      }
+      return 7;
+    }
+    const dryRun = {
+      ok: true,
+      dryRun: true,
+      name: rootPlayName,
+      sourcePath: graph.root.filePath,
+      sourceHash: graph.root.artifact.sourceHash,
+      artifactHash,
+      graphHash: graph.root.artifact.graphHash,
+      importedPlayCount: Math.max(0, graph.nodes.size - 1),
+      plannedMutation: "register revision and promote it live",
+      expectedArtifactHash: options.expectedArtifactHash ?? null
+    };
+    if (options.dryRun) {
+      if (options.jsonOutput) {
+        process.stdout.write(`${JSON.stringify(dryRun)}
+`);
+      } else {
+        console.log(`Dry run: ${rootPlayName}`);
+        console.log(`  source: ${dryRun.sourceHash}`);
+        console.log(`  artifact: ${dryRun.artifactHash}`);
+        console.log(`  would: ${dryRun.plannedMutation}`);
+      }
+      return 0;
+    }
+    let previousLive = null;
+    try {
+      previousLive = (await client2.getPlay(rootPlayName)).play.liveRevision ?? null;
+    } catch (error) {
+      if (!(error instanceof DeeplineError) || error.statusCode !== 404) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 5;
+      }
+    }
+    try {
       await traceCliSpan(
         "cli.play_publish_compile_manifests",
         { targetKind: "file", nodeCount: graph.nodes.size },
@@ -16439,13 +16575,12 @@ async function handlePlayPublish(args) {
       console.error(error instanceof Error ? error.message : String(error));
       return 1;
     }
-    const rootPlayName = graph.root.playName ?? extractPlayName(graph.root.sourceCode, graph.root.filePath);
     const published = await traceCliSpan(
       "cli.play_publish_register_root",
       {
         targetKind: "file",
         playName: rootPlayName,
-        artifactHash: graph.root.artifact.artifactHash
+        artifactHash
       },
       () => client2.registerPlayArtifact({
         name: rootPlayName,
@@ -16457,17 +16592,63 @@ async function handlePlayPublish(args) {
         publish: true
       })
     );
-    process.stdout.write(
-      `${JSON.stringify({
-        success: true,
-        name: rootPlayName,
-        liveVersion: published.version ?? null,
-        revisionId: published.revisionId ?? null,
-        triggerMetadata: published.triggerMetadata ?? null,
-        triggerBindings: published.triggerBindings ?? []
-      })}
-`
-    );
+    const result2 = {
+      success: true,
+      name: rootPlayName,
+      sourcePath: graph.root.filePath,
+      sourceHash: graph.root.artifact.sourceHash,
+      artifactHash,
+      liveVersion: published.version ?? null,
+      revisionId: published.revisionId ?? null,
+      previousLiveVersion: previousLive?.version ?? null,
+      previousArtifactHash: previousLive?.artifactHash ?? null,
+      sourceBytes: {
+        before: previousLive?.sourceCode ? Buffer.byteLength(previousLive.sourceCode, "utf8") : null,
+        after: Buffer.byteLength(graph.root.sourceCode, "utf8")
+      },
+      triggerMetadata: published.triggerMetadata ?? null,
+      triggerBindings: published.triggerBindings ?? []
+    };
+    if (options.jsonOutput) {
+      process.stdout.write(`${JSON.stringify(result2)}
+`);
+    } else {
+      console.log(
+        `\u2713 Published ${rootPlayName} as v${result2.liveVersion ?? "?"}`
+      );
+      console.log(`  source: ${result2.sourceHash.slice(0, 12)}`);
+      console.log(`  artifact: ${result2.artifactHash.slice(0, 12)}`);
+      if (result2.previousLiveVersion !== null) {
+        console.log(
+          `  previous live: v${result2.previousLiveVersion} (${result2.previousArtifactHash?.slice(0, 12) ?? "unknown artifact"})`
+        );
+      }
+      if (result2.sourceBytes.before !== null) {
+        console.log(
+          `  source bytes: ${result2.sourceBytes.before.toLocaleString()} \u2192 ${result2.sourceBytes.after.toLocaleString()}`
+        );
+      }
+      console.log(
+        `  revisions: deepline plays versions --name ${rootPlayName}`
+      );
+    }
+    return 0;
+  }
+  if (options.expectedArtifactHash) {
+    console.error("--expected-artifact only applies to a local play file.");
+    return 2;
+  }
+  if (options.dryRun) {
+    const result2 = {
+      ok: true,
+      dryRun: true,
+      name: playName,
+      plannedMutation: "promote a saved revision live",
+      revisionId: revisionId ?? null,
+      latest: useLatest
+    };
+    process.stdout.write(`${JSON.stringify(result2)}
+`);
     return 0;
   }
   const resolvedName = parseReferencedPlayTarget2(playName).playName;
@@ -16831,7 +17012,9 @@ Notes:
   Mutates cloud state. For a saved play, --latest or --revision-id promotes an
   existing saved revision live.
   Local .play.ts publishing bundles the file, validates it, saves a revision,
-  and promotes that revision live.
+  and promotes that revision live. Use --expected-artifact with the hash from
+  plays check to refuse publishing bytes that changed after validation.
+  --dry-run bundles only and prints the exact artifact that would be published.
   Running a local file with plays run does not publish it.
 
 Examples:
@@ -16839,27 +17022,40 @@ Examples:
   deepline plays set-live my-play --revision-id <revision-id> --json
   deepline plays set-live my.play.ts --json
   deepline plays publish my.play.ts --json
+  deepline plays check my.play.ts
+  deepline plays publish my.play.ts --expected-artifact <artifact-hash>
+  deepline plays publish my.play.ts --dry-run --json
 `
   );
   addPublishHelp(
     play.command("publish <target>").description(
       "Promote a saved play revision or publish a local play file."
     )
-  ).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) => {
+  ).option("--latest", "Promote the newest saved revision").option("--revision-id <id>", "Revision to promote").option(
+    "--expected-artifact <hash>",
+    "Require the local file to produce this checked artifact hash"
+  ).option("--dry-run", "Bundle and show the planned publish without mutation").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
     process.exitCode = await handlePlayPublish([
       target,
       ...options.latest ? ["--latest"] : [],
       ...options.revisionId ? ["--revision-id", options.revisionId] : [],
+      ...options.expectedArtifact ? ["--expected-artifact", options.expectedArtifact] : [],
+      ...options.dryRun ? ["--dry-run"] : [],
       ...options.json ? ["--json"] : []
     ]);
   });
   addPublishHelp(
     play.command("set-live <target>").description("Promote a saved revision or publish a local play file.")
-  ).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) => {
+  ).option("--latest", "Promote the newest saved revision").option("--revision-id <id>", "Revision to promote").option(
+    "--expected-artifact <hash>",
+    "Require the local file to produce this checked artifact hash"
+  ).option("--dry-run", "Bundle and show the planned publish without mutation").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
     process.exitCode = await handlePlayPublish([
       target,
       ...options.latest ? ["--latest"] : [],
       ...options.revisionId ? ["--revision-id", options.revisionId] : [],
+      ...options.expectedArtifact ? ["--expected-artifact", options.expectedArtifact] : [],
+      ...options.dryRun ? ["--dry-run"] : [],
       ...options.json ? ["--json"] : []
     ]);
   });

package/dist/index.d.mts

@@ -945,6 +945,27 @@ interface PlayCheckResult {
     summary?: string;
     artifactHash?: string | null;
     graphHash?: string | null;
+    /** SHA-256 of the exact source bytes checked by Deepline. */
+    sourceHash?: string | null;
+    /** Enforceable byte budgets measured during cloud preflight. */
+    limits?: {
+        revisionStorage: {
+            usedBytes: number;
+            limitBytes: number;
+            withinLimit: boolean;
+            breakdown: {
+                sourceCodeBytes: number;
+                staticPipelineBytes: number;
+                bindingsBytes: number;
+                descriptionBytes: number;
+            };
+        };
+        bundle: {
+            usedBytes: number;
+            limitBytes: number;
+            withinLimit: boolean;
+        };
+    };
 }
 /** Severity of a {@link PlayCheckIssue}. `error` fails the check; `warning` does not. */
 type PlayCheckIssueSeverity = 'error' | 'warning';

package/dist/index.d.ts

@@ -945,6 +945,27 @@ interface PlayCheckResult {
     summary?: string;
     artifactHash?: string | null;
     graphHash?: string | null;
+    /** SHA-256 of the exact source bytes checked by Deepline. */
+    sourceHash?: string | null;
+    /** Enforceable byte budgets measured during cloud preflight. */
+    limits?: {
+        revisionStorage: {
+            usedBytes: number;
+            limitBytes: number;
+            withinLimit: boolean;
+            breakdown: {
+                sourceCodeBytes: number;
+                staticPipelineBytes: number;
+                bindingsBytes: number;
+                descriptionBytes: number;
+            };
+        };
+        bundle: {
+            usedBytes: number;
+            limitBytes: number;
+            withinLimit: boolean;
+        };
+    };
 }
 /** Severity of a {@link PlayCheckIssue}. `error` fails the check; `warning` does not. */
 type PlayCheckIssueSeverity = 'error' | 'warning';

package/dist/index.js

@@ -424,10 +424,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.220",
+  version: "0.1.222",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.220",
+    latest: "0.1.222",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [

package/dist/index.mjs

@@ -354,10 +354,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.220",
+  version: "0.1.222",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.220",
+    latest: "0.1.222",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [

package/dist/viewer/viewer.css

@@ -353,6 +353,17 @@ body {
     border: 1px solid var(--red);
     background: rgba(248,81,73,0.06);
 }
+.tool-detail-toggle {
+    margin-top: 8px;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border);
+    border-radius: 4px;
+    color: var(--blue);
+    cursor: pointer;
+    font-size: 12px;
+    padding: 4px 8px;
+}
+.tool-detail-toggle:hover { border-color: var(--blue); }
 
 /* Result card */
 .result-card {

package/dist/viewer/viewer.js

@@ -1334,7 +1334,7 @@ function renderTimeline(timeline) {
                 <div class="tool-detail" id="detail-${i}">
                     <div class="tool-detail-section">
                         <div class="label">Input</div>
-                        <pre>${esc(formatInput(e.tool, e.input))}</pre>
+                        ${formatToolInputHtml(e.tool, e.input, i)}
                     </div>
                     ${e.result_content != null ? `<div class="tool-detail-section">
                         <div class="label">Result</div>
@@ -1347,8 +1347,17 @@ function renderTimeline(timeline) {
     return html;
 }
 
+function isShellCommandTool(tool) {
+    const normalized = String(tool || '').toLowerCase().replace(/[^a-z]/g, '');
+    return ['bash', 'exec', 'execcommand', 'runcommand', 'shell'].includes(normalized);
+}
+
+function shellCommand(input) {
+    return input.command || input.cmd || input.CommandLine || null;
+}
+
 function formatInput(tool, input) {
-    if (tool === 'Bash') return input.command || JSON.stringify(input, null, 2);
+    if (isShellCommandTool(tool)) return shellCommand(input) || JSON.stringify(input, null, 2);
     if (tool === 'Write') {
         let s = 'file: ' + (input.file_path || input.path || '') + '\n\n';
         if (input.content != null) s += '--- content ---\n' + String(input.content);
@@ -1364,6 +1373,39 @@ function formatInput(tool, input) {
     return JSON.stringify(input, null, 2);
 }
 
+function isLongShellCommand(command) {
+    return command.length > 600 || command.split('\n').length > 10;
+}
+
+function shellCommandPreview(command) {
+    const lines = command.split('\n');
+    let preview = lines.slice(0, 10).join('\n');
+    if (preview.length > 600) preview = preview.slice(0, 600);
+    return preview + '\n...[full command hidden]';
+}
+
+function formatToolInputHtml(tool, input, entryIndex) {
+    const formatted = formatInput(tool, input);
+    if (!isShellCommandTool(tool) || !isLongShellCommand(formatted)) {
+        return `<pre>${esc(formatted)}</pre>`;
+    }
+    const previewId = `command-preview-${entryIndex}`;
+    const fullId = `command-full-${entryIndex}`;
+    return `<pre id="${previewId}">${esc(shellCommandPreview(formatted))}</pre>
+        <button class="tool-detail-toggle" onclick="toggleCommandInput('${previewId}', '${fullId}', this)">Show full command</button>
+        <pre id="${fullId}" hidden>${esc(formatted)}</pre>`;
+}
+
+function toggleCommandInput(previewId, fullId, toggle) {
+    const preview = document.getElementById(previewId);
+    const full = document.getElementById(fullId);
+    if (!preview || !full) return;
+    const showFull = full.hidden;
+    full.hidden = !showFull;
+    preview.hidden = showFull;
+    toggle.textContent = showFull ? 'Show less' : 'Show full command';
+}
+
 function toggleReasoning(id, toggle) {
     const el = document.getElementById(id);
     const collapsed = el.classList.toggle('collapsed');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.220",
+  "version": "0.1.222",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {