deepline 0.3.149 → 0.3.151

package/dist/cli/index.js

@@ -3068,7 +3068,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.149",
+  version: "0.3.151",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1
@@ -3827,6 +3827,11 @@ var HttpClient = class {
             body: options?.formData !== void 0 ? typeof options.formData === "function" ? options.formData() : options.formData : options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
             signal: controller.signal
           });
+          options?.onResponse?.(response);
+          if (response.status === 404 && options?.allowNotFound) {
+            clearTimeout(timeoutId);
+            return null;
+          }
           clearTimeout(timeoutId);
           const body = await response.text();
           const parsed = parseResponseBody(body);
@@ -3966,7 +3971,8 @@ var HttpClient = class {
             retryAfterMs: null,
             networkKind: code === "NETWORK_TIMEOUT" ? "timeout" : code === "NETWORK_ABORTED" ? "unknown" : "unavailable",
             networkScope: "client_to_deepline",
-            details: mappedNetworkError.details
+            details: mappedNetworkError.details,
+            publicDetails: options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : null
           }
         ),
         lastError
@@ -6570,6 +6576,56 @@ var MONITOR_NON_RETRYABLE_MUTATION_OPTIONS = {
   exactUrlOnly: true
 };
 var RAW_V2_EXECUTE_RESPONSE_CONTRACT = RAW_V2_TOOL_RESPONSE_CONTRACT;
+var DEFAULT_EXECUTION_RECOVERY_TIMEOUT_MS = 15 * 60 * 1e3;
+function validateExecutionIdempotencyKey(key) {
+  if (typeof key !== "string" || key.length < 1 || key.length > 200 || !/^[A-Za-z0-9._:-]+$/.test(key)) {
+    throw new DeeplineError(
+      "Execution idempotency keys must be 1\u2013200 ASCII letters, digits, dots, underscores, colons, or hyphens.",
+      void 0,
+      "IDEMPOTENCY_KEY_INVALID"
+    );
+  }
+}
+function isExecutionInProgressResponse(value) {
+  return typeof value === "object" && value !== null && typeof value.executionRecovery === "object" && value.executionRecovery.state === "running";
+}
+function getExecutionRecoveryState(value) {
+  if (typeof value !== "object" || value === null || typeof value.executionRecovery !== "object") {
+    return null;
+  }
+  const state = value.executionRecovery.state;
+  return state === "running" || state === "completed" || state === "outcome_unknown" ? state : null;
+}
+function isRecoverableExecutionAttemptError(error) {
+  if (error instanceof ToolExecutionError) {
+    return error.code === "EXECUTION_IN_PROGRESS" || error.origin === "deepline" && error.category === "network" && error.networkScope === "client_to_deepline";
+  }
+  return error instanceof DeeplineError && (error.code === "EXECUTION_IN_PROGRESS" || error.code?.startsWith("NETWORK_") === true && error.statusCode === void 0);
+}
+function isRecoverableExecutionLookupError(error) {
+  if (isRecoverableExecutionAttemptError(error)) return true;
+  return error instanceof DeeplineError && (error.statusCode === 429 || error.statusCode !== void 0 && error.statusCode >= 500);
+}
+function timeoutWithinRecoveryBudget(requestTimeoutMs, defaultRequestTimeoutMs, remainingMs) {
+  return Math.min(requestTimeoutMs ?? defaultRequestTimeoutMs, remainingMs);
+}
+function executionRecoveryError(input2) {
+  return new ToolExecutionError(input2.message, {
+    toolId: input2.toolId,
+    provider: null,
+    operation: input2.toolId,
+    code: input2.code,
+    origin: "deepline",
+    category: input2.code === "EXECUTION_OUTCOME_UNKNOWN" ? "unknown" : "conflict",
+    retryable: input2.code !== "EXECUTION_OUTCOME_UNKNOWN",
+    statusCode: null,
+    requestId: null,
+    retryAfterMs: null,
+    networkKind: null,
+    networkScope: null,
+    publicDetails: { idempotencyKey: input2.idempotencyKey }
+  });
+}
 var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
 var REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
 var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT = 3;
@@ -7483,29 +7539,183 @@ var DeeplineClient = class _DeeplineClient {
    * Deepline execution envelope.
    */
   async executeTool(toolId, input2, options) {
+    const inputSnapshot = JSON.parse(JSON.stringify(input2));
+    const metadataSnapshot = options?.metadata ? JSON.parse(JSON.stringify(options.metadata)) : void 0;
+    const idempotencyKey = options?.idempotencyKey ?? (options?.recover ? crypto.randomUUID() : void 0);
+    if (idempotencyKey !== void 0) {
+      validateExecutionIdempotencyKey(idempotencyKey);
+      if (options?.recoveryTimeoutMs !== void 0 && (!Number.isFinite(options.recoveryTimeoutMs) || options.recoveryTimeoutMs < 0)) {
+        throw new DeeplineError(
+          "recoveryTimeoutMs must be a finite, non-negative number.",
+          void 0,
+          "IDEMPOTENCY_KEY_INVALID"
+        );
+      }
+      await options?.onExecution?.({ idempotencyKey });
+      const timeoutMs2 = options?.timeout ?? resolveToolExecuteTimeoutMs(toolId, inputSnapshot);
+      await this.lookupExecutionByKey(idempotencyKey, timeoutMs2);
+    }
+    const timeoutMs = options?.timeout ?? resolveToolExecuteTimeoutMs(toolId, inputSnapshot);
     const headers = {
       [EXECUTE_RESPONSE_CONTRACT_HEADER]: RAW_V2_EXECUTE_RESPONSE_CONTRACT,
       [TOOL_EXECUTION_ERROR_SCHEMA_HEADER]: String(
         TOOL_EXECUTION_ERROR_SCHEMA_VERSION
       ),
       ...options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : {},
-      [EXECUTE_RESPONSE_INTENT_HEADER]: options?.responseIntent ?? "raw"
+      [EXECUTE_RESPONSE_INTENT_HEADER]: options?.responseIntent ?? "raw",
+      ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}
     };
-    const response = await this.http.post(
+    const request = (requestTimeoutMs) => this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
       {
-        payload: input2,
-        ...options?.metadata ? { metadata: options.metadata } : {}
+        payload: inputSnapshot,
+        ...metadataSnapshot ? { metadata: metadataSnapshot } : {}
       },
       headers,
       {
-        timeout: options?.timeout ?? resolveToolExecuteTimeoutMs(toolId, input2),
-        maxRetries: options?.maxRetries ?? 0,
+        timeout: requestTimeoutMs,
+        maxRetries: idempotencyKey ? 0 : options?.maxRetries ?? 0,
+        exactUrlOnly: true,
+        toolId,
+        idempotencyKey
+      }
+    );
+    let response;
+    let recoveryDeadline = null;
+    const recoveryTimeoutMs = options?.recoveryTimeoutMs ?? DEFAULT_EXECUTION_RECOVERY_TIMEOUT_MS;
+    let retryDelayMs = 1e3;
+    const recoveryTimeoutError = () => executionRecoveryError({
+      toolId,
+      idempotencyKey,
+      code: "EXECUTION_RECOVERY_TIMEOUT",
+      message: `Execution recovery for ${idempotencyKey} did not finish before the recovery timeout. Inspect client.executions.getByKey() and resume with the same idempotency key.`
+    });
+    const waitForRecoveryRetry = async (deadline) => {
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) throw recoveryTimeoutError();
+      await new Promise(
+        (resolve22) => setTimeout(resolve22, Math.min(retryDelayMs, remainingMs))
+      );
+      retryDelayMs = Math.min(retryDelayMs * 2, 5e3);
+    };
+    const lookupDuringRecovery = async () => {
+      while (true) {
+        const remainingMs = recoveryDeadline - Date.now();
+        if (remainingMs <= 0) throw recoveryTimeoutError();
+        try {
+          return await this.lookupExecutionByKey(
+            idempotencyKey,
+            timeoutWithinRecoveryBudget(
+              timeoutMs,
+              this.config.timeout,
+              remainingMs
+            )
+          );
+        } catch (error) {
+          if (!isRecoverableExecutionLookupError(error)) throw error;
+          await waitForRecoveryRetry(recoveryDeadline);
+        }
+      }
+    };
+    while (true) {
+      const remainingMs = recoveryDeadline === null ? null : recoveryDeadline - Date.now();
+      if (remainingMs !== null && remainingMs <= 0) {
+        throw recoveryTimeoutError();
+      }
+      try {
+        response = await request(
+          remainingMs === null ? timeoutMs : timeoutWithinRecoveryBudget(
+            timeoutMs,
+            this.config.timeout,
+            remainingMs
+          )
+        );
+        if (getExecutionRecoveryState(response) === "outcome_unknown") {
+          if (!idempotencyKey) break;
+          throw executionRecoveryError({
+            toolId,
+            idempotencyKey,
+            code: "EXECUTION_OUTCOME_UNKNOWN",
+            message: `The outcome of execution ${idempotencyKey} is unknown. Do not retry with a new key; inspect client.executions.getByKey().`
+          });
+        }
+        if (!idempotencyKey || !isExecutionInProgressResponse(response)) {
+          break;
+        }
+        if (recoveryDeadline === null) {
+          recoveryDeadline = Date.now() + recoveryTimeoutMs;
+        }
+      } catch (error) {
+        if (idempotencyKey && error instanceof DeeplineError && error.code === "EXECUTION_OUTCOME_UNKNOWN") {
+          throw executionRecoveryError({
+            toolId,
+            idempotencyKey,
+            code: "EXECUTION_OUTCOME_UNKNOWN",
+            message: error.message
+          });
+        }
+        if (!idempotencyKey || !isRecoverableExecutionAttemptError(error)) {
+          throw error;
+        }
+        if (recoveryDeadline === null) {
+          recoveryDeadline = Date.now() + recoveryTimeoutMs;
+        }
+      }
+      await waitForRecoveryRetry(recoveryDeadline);
+      const recovered = await lookupDuringRecovery();
+      if (getExecutionRecoveryState(recovered) === "outcome_unknown") {
+        throw executionRecoveryError({
+          toolId,
+          idempotencyKey,
+          code: "EXECUTION_OUTCOME_UNKNOWN",
+          message: `The outcome of execution ${idempotencyKey} is unknown. Do not retry with a new key; inspect client.executions.getByKey().`
+        });
+      }
+    }
+    const materialized = materializeToolExecutionResponse(response);
+    return idempotencyKey ? { ...materialized, idempotencyKey } : materialized;
+  }
+  /** Read the durable state of a keyed tool execution. */
+  async getExecutionByKey(idempotencyKey) {
+    validateExecutionIdempotencyKey(idempotencyKey);
+    const result = await this.lookupExecutionByKey(idempotencyKey);
+    if (!result) {
+      throw new DeeplineError(
+        `No execution exists for idempotency key ${idempotencyKey}.`,
+        404,
+        "EXECUTION_NOT_FOUND"
+      );
+    }
+    return result;
+  }
+  async lookupExecutionByKey(idempotencyKey, timeoutMs) {
+    validateExecutionIdempotencyKey(idempotencyKey);
+    let supported = false;
+    const result = await this.http.get(
+      `/api/v2/executions/by-key/${encodeURIComponent(idempotencyKey)}`,
+      {
         exactUrlOnly: true,
-        toolId
+        maxRetries: 0,
+        timeout: timeoutMs,
+        idempotencyKey,
+        allowNotFound: true,
+        onResponse: (response) => {
+          supported = response.headers.get("X-Deepline-Idempotency-Supported") === "true";
+        }
       }
     );
-    return materializeToolExecutionResponse(response);
+    if (!supported) {
+      throw new DeeplineError(
+        "This Deepline server does not support recoverable tool executions; no tool was dispatched.",
+        422,
+        "IDEMPOTENCY_NOT_SUPPORTED"
+      );
+    }
+    return result;
+  }
+  /** Public recovery namespace. */
+  get executions() {
+    return { getByKey: (key) => this.getExecutionByKey(key) };
   }
   /**
    * Back-compatible alias for {@link executeTool}.
@@ -11132,6 +11342,15 @@ function errorToJsonPayload(error) {
   if (typeof maybeRecord?.status === "number") {
     details.status = maybeRecord.status;
   }
+  if (typeof maybeRecord?.requestId === "string" || maybeRecord?.requestId === null) {
+    details.requestId = maybeRecord.requestId;
+  }
+  if (typeof maybeRecord?.retryable === "boolean") {
+    details.retryable = maybeRecord.retryable;
+  }
+  if (maybeRecord?.publicDetails && typeof maybeRecord.publicDetails === "object" && !Array.isArray(maybeRecord.publicDetails)) {
+    details.publicDetails = maybeRecord.publicDetails;
+  }
   if (maybeRecord?.details && typeof maybeRecord.details === "object" && !Array.isArray(maybeRecord.details)) {
     details.details = maybeRecord.details;
   }
@@ -36047,6 +36266,17 @@ function registerEnrichCommand(program) {
   });
 }
 
+// src/cli/commands/executions.ts
+function registerExecutionsCommands(program) {
+  const executions = program.command("executions").description("Inspect and recover keyed tool executions.");
+  executions.command("get").description("Retrieve a tool execution by its idempotency key.").requiredOption("--idempotency-key <key>", "Stable execution recovery key").option("--json", "Emit the stable JSON response").action(async (options) => {
+    const result = await new DeeplineClient().executions.getByKey(
+      options.idempotencyKey
+    );
+    printCommandEnvelope(result, { json: true });
+  });
+}
+
 // src/cli/commands/feedback.ts
 var import_commander3 = require("commander");
 var import_node_fs13 = require("fs");
@@ -46928,6 +47158,25 @@ Examples:
 
 // src/cli/commands/tools.ts
 var import_commander4 = require("commander");
+var import_node_crypto12 = require("crypto");
+
+// ../plays/row-identity.ts
+function stableValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => stableValue(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, stableValue(entry)])
+    );
+  }
+  return value;
+}
+function stableStringify(value) {
+  return JSON.stringify(stableValue(value));
+}
+
+// src/cli/commands/tools.ts
 var import_node_fs26 = require("fs");
 var import_node_os18 = require("os");
 var import_node_path30 = require("path");
@@ -48058,6 +48307,15 @@ Examples:
   ).option("-o, --out <path>", "Write row-shaped tool output to this CSV path").option(
     "--no-preview",
     "Only print the extracted output path when applicable"
+  ).option(
+    "--idempotency-key <key>",
+    "Stable key for retrying or recovering this tool execution"
+  ).option(
+    "--recover",
+    "Generate or reuse a saved idempotency key for safe recovery"
+  ).option(
+    "--recovery-timeout-ms <milliseconds>",
+    "Maximum wait for a keyed execution to finish (default: 900000)"
   ).action(async (toolId, options) => {
     const args = [
       toolId,
@@ -48069,7 +48327,10 @@ Examples:
       ...options.timeout ? ["--timeout", options.timeout] : [],
       ...options.outputFormat ? ["--output-format", options.outputFormat] : [],
       ...options.out ? ["--out", options.out] : [],
-      ...options.preview === false ? ["--no-preview"] : []
+      ...options.preview === false ? ["--no-preview"] : [],
+      ...options.idempotencyKey ? ["--idempotency-key", options.idempotencyKey] : [],
+      ...options.recover ? ["--recover"] : [],
+      ...options.recoveryTimeoutMs ? ["--recovery-timeout-ms", options.recoveryTimeoutMs] : []
     ];
     process.exitCode = await executeTool(args);
   });
@@ -49306,7 +49567,7 @@ function parseExecuteOptions(args) {
   const toolId = args[0];
   if (!toolId) {
     throw new Error(
-      `Usage: deepline tools execute <toolId> [--param key=value ...] [--input '{"k":"v"}'] [--timeout <duration>] [--out rows.csv] [--output-format auto|csv|csv_file|json|json_file] [--no-preview]`
+      `Usage: deepline tools execute <toolId> [--param key=value ...] [--input '{"k":"v"}'] [--timeout <duration>] [--recover | --idempotency-key <key>] [--recovery-timeout-ms <ms>] [--out rows.csv] [--output-format auto|csv|csv_file|json|json_file] [--no-preview]`
     );
   }
   const params = {};
@@ -49314,6 +49575,9 @@ function parseExecuteOptions(args) {
   let noPreview = false;
   let outPath = null;
   let timeoutMs;
+  let idempotencyKey;
+  let recover = false;
+  let recoveryTimeoutMs;
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index];
     if ((arg === "--param" || arg === "-p") && args[index + 1]) {
@@ -49349,13 +49613,39 @@ function parseExecuteOptions(args) {
       noPreview = true;
       continue;
     }
+    if (arg === "--idempotency-key" && args[index + 1]) {
+      idempotencyKey = args[++index];
+      continue;
+    }
+    if (arg === "--recover") {
+      recover = true;
+      continue;
+    }
+    if (arg === "--recovery-timeout-ms" && args[index + 1]) {
+      const parsed = Number(args[++index]);
+      if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new Error("--recovery-timeout-ms must be a non-negative number.");
+      }
+      recoveryTimeoutMs = parsed;
+      continue;
+    }
     if ((arg === "--out" || arg === "-o") && args[index + 1]) {
       outPath = (0, import_node_path30.resolve)(args[++index]);
       continue;
     }
     throw new Error(`Unknown option: ${arg}`);
   }
-  return { toolId, params, outputFormat, noPreview, outPath, timeoutMs };
+  return {
+    toolId,
+    params,
+    outputFormat,
+    noPreview,
+    outPath,
+    timeoutMs,
+    idempotencyKey,
+    recover,
+    recoveryTimeoutMs
+  };
 }
 function parseToolExecuteTimeout(raw) {
   const match = /^(\d+)(ms|s|m|h)?$/i.exec(raw.trim());
@@ -49375,6 +49665,65 @@ function parseToolExecuteTimeout(raw) {
   }
   return timeoutMs;
 }
+function pendingToolExecutionPath(input2) {
+  const config = resolveConfig();
+  const fingerprint = (0, import_node_crypto12.createHash)("sha256").update(config.baseUrl).update("\0").update((0, import_node_crypto12.createHash)("sha256").update(config.apiKey).digest("hex")).update("\0").update(input2.toolId).update("\0").update(stableStringify(input2.params)).update("\0").update(input2.responseIntent).digest("hex");
+  return (0, import_node_path30.join)(
+    sdkCliStateDirPath(resolveConfig().baseUrl),
+    `pending-tool-execution-${fingerprint}.json`
+  );
+}
+function loadOrCreatePendingToolExecution(path) {
+  (0, import_node_fs26.mkdirSync)((0, import_node_path30.dirname)(path), { recursive: true });
+  if ((0, import_node_fs26.existsSync)(path)) {
+    return readPendingToolExecution(path);
+  }
+  const idempotencyKey = (0, import_node_crypto12.randomUUID)();
+  const temporaryPath = `${path}.${process.pid}.${(0, import_node_crypto12.randomUUID)()}.tmp`;
+  try {
+    (0, import_node_fs26.writeFileSync)(temporaryPath, `${JSON.stringify({ idempotencyKey })}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    (0, import_node_fs26.linkSync)(temporaryPath, path);
+    return idempotencyKey;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    return readPendingToolExecution(path);
+  } finally {
+    if ((0, import_node_fs26.existsSync)(temporaryPath)) (0, import_node_fs26.unlinkSync)(temporaryPath);
+  }
+}
+function readPendingToolExecution(path) {
+  const saved = JSON.parse((0, import_node_fs26.readFileSync)(path, "utf8"));
+  if (typeof saved.idempotencyKey !== "string") {
+    throw new Error(
+      `Cannot resume the saved tool execution at ${path}: invalid recovery key.`
+    );
+  }
+  return saved.idempotencyKey;
+}
+async function completePendingToolExecution(path) {
+  if (!path || !(0, import_node_fs26.existsSync)(path)) return;
+  await new Promise((resolve22, reject) => {
+    const onError = (error) => {
+      process.stdout.off("error", onError);
+      reject(error);
+    };
+    process.stdout.once("error", onError);
+    process.stdout.write("", (error) => {
+      process.stdout.off("error", onError);
+      if (error) {
+        reject(error);
+      } else {
+        resolve22();
+      }
+    });
+  });
+  if ((0, import_node_fs26.existsSync)(path)) (0, import_node_fs26.unlinkSync)(path);
+}
 function safeFileStem(value) {
   return value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "tool";
 }
@@ -49492,6 +49841,8 @@ function buildToolExecuteBaseEnvelope(input2) {
   ] : [];
   return {
     ...envelope,
+    ...input2.idempotencyKey ? { idempotency_key: input2.idempotencyKey } : {},
+    ...isRecord12(input2.rawResponse) && isRecord12(input2.rawResponse.executionRecovery) ? { execution_recovery: input2.rawResponse.executionRecovery } : {},
     ...envelopeHasCanonicalOutput || envelopeHasDeclaredOutput ? { output_preview: outputPreview } : { output: outputPreview },
     ...summaryEntries.length > 0 ? { summary: input2.summary } : {},
     ...warningMessages.length > 0 ? { warnings: warningMessages } : {},
@@ -49675,10 +50026,25 @@ async function executeTool(args) {
     }
     return 2;
   }
+  let idempotencyKey = parsed.idempotencyKey;
+  let pendingRecoveryPath = null;
+  const responseIntent = parsed.outPath || parsed.outputFormat === "csv" || parsed.outputFormat === "csv_file" ? "row_artifact" : "raw";
+  if (parsed.recover && !idempotencyKey) {
+    pendingRecoveryPath = pendingToolExecutionPath({
+      toolId: parsed.toolId,
+      params: parsed.params,
+      responseIntent
+    });
+    idempotencyKey = loadOrCreatePendingToolExecution(pendingRecoveryPath);
+  }
+  if (idempotencyKey) {
+    console.error(`Tool execution recovery key: ${idempotencyKey}`);
+  }
   const rawResponse = await client2.executeTool(parsed.toolId, parsed.params, {
     ...parsed.timeoutMs !== void 0 ? { timeout: parsed.timeoutMs } : {},
-    responseIntent: parsed.outPath || parsed.outputFormat === "csv" || parsed.outputFormat === "csv_file" ? "row_artifact" : "raw",
-    ...parsed.timeoutMs !== void 0 ? { timeout: parsed.timeoutMs } : {}
+    responseIntent,
+    ...idempotencyKey ? { idempotencyKey } : {},
+    ...parsed.recoveryTimeoutMs !== void 0 ? { recoveryTimeoutMs: parsed.recoveryTimeoutMs } : {}
   });
   const listConversion = tryConvertToList(rawResponse, {
     listExtractorPaths: listExtractorPathsFromUsageGuidance(metadata)
@@ -49687,12 +50053,14 @@ async function executeTool(args) {
   const baseEnvelope = buildToolExecuteBaseEnvelope({
     toolId: parsed.toolId,
     params: parsed.params,
+    ...idempotencyKey ? { idempotencyKey } : {},
     rawResponse,
     listConversion,
     summary
   });
   if (!parsed.outPath && (parsed.outputFormat === "json" || parsed.outputFormat === "auto" && shouldEmitJson())) {
     printCommandEnvelope(baseEnvelope, { json: true });
+    await completePendingToolExecution(pendingRecoveryPath);
     return 0;
   }
   if (parsed.outputFormat === "json_file") {
@@ -49710,6 +50078,7 @@ async function executeTool(args) {
       },
       { json: true }
     );
+    await completePendingToolExecution(pendingRecoveryPath);
     return 0;
   }
   if (!listConversion) {
@@ -49738,9 +50107,11 @@ async function executeTool(args) {
         },
         { json: parsed.outputFormat === "csv_file" || shouldEmitJson() }
       );
+      await completePendingToolExecution(pendingRecoveryPath);
       return 0;
     }
     printCommandEnvelope(baseEnvelope, { json: false });
+    await completePendingToolExecution(pendingRecoveryPath);
     return 0;
   }
   const rowOutput = projectRowOutput(listConversion);
@@ -49763,6 +50134,7 @@ async function executeTool(args) {
   });
   if (parsed.outputFormat === "csv_file") {
     printCommandEnvelope(materializedEnvelope, { json: true });
+    await completePendingToolExecution(pendingRecoveryPath);
     return 0;
   }
   if (parsed.outPath) {
@@ -49771,6 +50143,7 @@ async function executeTool(args) {
       text: `Wrote ${csv.rowCount} row(s) to ${csv.path}
 `
     });
+    await completePendingToolExecution(pendingRecoveryPath);
     return 0;
   }
   if (parsed.noPreview) {
@@ -49785,9 +50158,11 @@ async function executeTool(args) {
       { json: shouldEmitJson(), text: `${csv.path}
 ` }
     );
+    await completePendingToolExecution(pendingRecoveryPath);
     return 0;
   }
   printCommandEnvelope(materializedEnvelope, { json: false });
+  await completePendingToolExecution(pendingRecoveryPath);
   return 0;
 }
 
@@ -49873,7 +50248,7 @@ var import_promises13 = require("fs/promises");
 var import_node_path31 = require("path");
 
 // src/cli/workflow-to-play.ts
-var import_node_crypto12 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var HITL_WAIT_FOR_SIGNAL_TOOL = "deepline_workflow_wait_for_signal";
 var HITL_SLACK_TOOL = "slack_message_with_hitl";
 var SUB_WORKFLOW_TOOL_PREFIX = "deepline_workflow_";
@@ -49979,7 +50354,7 @@ function sanitizePlayNameSegment(value) {
 }
 function deriveWorkflowPlayName(workflowName) {
   const base = sanitizePlayNameSegment(workflowName) || "workflow";
-  const suffix = (0, import_node_crypto12.createHash)("sha256").update(workflowName).digest("hex").slice(0, 8);
+  const suffix = (0, import_node_crypto13.createHash)("sha256").update(workflowName).digest("hex").slice(0, 8);
   const reserved = suffix.length + 1;
   const allowedBase = Math.max(1, MAX_PLAY_NAME_LENGTH - reserved);
   let name = `${base.slice(0, allowedBase)}_${suffix}`;
@@ -50384,6 +50759,7 @@ function registerDeeplineCommandGroups(program) {
   registerAuthCommands(program);
   registerProviderCommands(program);
   registerToolsCommands(program);
+  registerExecutionsCommands(program);
   registerPlayCommands(program);
   registerSessionsCommands(program);
   registerWorkflowCommands(program);