deepline 0.3.409 → 0.3.410

package/dist/cli/{chunk-N44JHMKY.mjs → chunk-IPG42SD2.mjs}

@@ -1,11 +1,11 @@
 import {
   addDescribeOptions,
   recordApiResponse
-} from "./chunk-OSDXE27V.mjs";
+} from "./chunk-4PG4ARL2.mjs";
 import {
   recentSearchRef,
   registerDeprecatedSearchCommand
-} from "./chunk-7AALNGTA.mjs";
+} from "./chunk-XNZJKRJA.mjs";
 import {
   arrayField,
   formatModelDescription,
@@ -24,7 +24,7 @@ import {
   toolInputFieldsForDisplay,
   toolMetadataJsonForDescribe,
   toolOutputFieldsForDisplay
-} from "./chunk-BZAMOCPA.mjs";
+} from "./chunk-IMZ56EOH.mjs";
 import {
   shellQuote
 } from "./chunk-OVDNJAJN.mjs";
@@ -32,6 +32,9 @@ import {
   Capability,
   observedMaxText
 } from "./chunk-LJ5747UC.mjs";
+import {
+  playToolListGetterMode
+} from "./chunk-FR2ILQ4G.mjs";
 import {
   extractSummaryFields,
   projectRowOutput,
@@ -39,22 +42,31 @@ import {
   writeCsvOutputFile,
   writeJsonOutputFile
 } from "./chunk-FIVKWNMT.mjs";
-import {
-  playToolListGetterMode
-} from "./chunk-CLJGSOVM.mjs";
 import {
   DeeplineClient,
   validateExecutionIdempotencyKey
-} from "./chunk-PBZYY7VZ.mjs";
+} from "./chunk-4XQLVUC7.mjs";
 import {
   stableStringify
 } from "./chunk-UBKA33KY.mjs";
 import {
   beginToolExecuteCommand,
   getToolExecuteInvocationId,
+  maybeAutoUpdateAndRelaunch,
   registerCompatibilityCatalog,
   runToolExecuteStage
-} from "./chunk-264PC2RN.mjs";
+} from "./chunk-XHLKJOTN.mjs";
+import {
+  isCliTraceEnabled,
+  recordCliTrace,
+  resolveCliMaintenancePolicy
+} from "./chunk-ZKYEW55U.mjs";
+import {
+  checkSdkCompatibility,
+  enforceSdkCompatibilityResponse,
+  flushDeferredSkillsSyncNotices,
+  syncSdkSkillsIfNeeded
+} from "./chunk-XIHWSXSV.mjs";
 import {
   printCommandEnvelope,
   printCompactJson,
@@ -62,14 +74,15 @@ import {
   printJsonError,
   renderCommandEnvelopeText,
   shouldEmitJson
-} from "./chunk-JRAVVJ3T.mjs";
+} from "./chunk-5V5Y37BC.mjs";
 import {
+  readSdkSkillsLocalVersion,
   resolveConfig,
   sdkCliStateDirPath
-} from "./chunk-2PRO2JTX.mjs";
+} from "./chunk-RFB25DSQ.mjs";
 import {
   DeeplineError
-} from "./chunk-NXGCO4JB.mjs";
+} from "./chunk-E4IXDAZI.mjs";
 
 // src/cli/commands/tools.ts
 import { Option } from "commander";
@@ -251,6 +264,7 @@ function toolConnectionStatusMessage(input) {
 }
 
 // src/cli/commands/tools.ts
+var TOOL_EXECUTE_PREFLIGHT_TIMEOUT_MS = 750;
 var TOOL_COMMAND_TEMPLATES = {
   describe: "deepline describe <toolId>",
   execute: "deepline tools execute <toolId> --input '{...}'"
@@ -437,6 +451,17 @@ function categoryEnumerationRender(summaries) {
 }
 async function listToolCategories(emitJson, compact) {
   const client = new DeeplineClient();
+  if (!emitJson) {
+    const summaries2 = (await client.listToolCategories()).map((category) => ({
+      ...category,
+      description: describeToolCategory(category.name)
+    }));
+    printCommandEnvelope(
+      { categories: summaries2, render: categoryEnumerationRender(summaries2) },
+      { json: false }
+    );
+    return 0;
+  }
   const rawTools = await client.listTools({ compact });
   const items = rawTools.map(toListedTool);
   const summaries = aggregateCategorySummaries(rawTools);
@@ -481,12 +506,11 @@ function unknownCategoryError(category, summaries, emitJson) {
 }
 async function listToolsInCategory(category, emitJson) {
   const client = new DeeplineClient();
-  const rawTools = await client.listTools({
-    categories: category,
-    compact: false
-  });
-  const allTools = await client.listTools({ compact: true });
-  const summaries = aggregateCategorySummaries(allTools);
+  const { tools: rawTools, categories } = await client.listToolsInCategory(category);
+  const summaries = categories.map((item) => ({
+    ...item,
+    description: describeToolCategory(item.name)
+  }));
   if (!summaries.some((item) => item.name === category)) {
     return unknownCategoryError(category, summaries, emitJson);
   }
@@ -733,9 +757,6 @@ function playLikeToolExecuteErrorMessage(toolId, tool) {
     'Or search provider tools only with: deepline search "<input you have -> result you need>" --type tools'
   ].join("\n");
 }
-function printPlayLikeToolExecuteError(toolId, tool) {
-  console.error(playLikeToolExecuteErrorMessage(toolId, tool));
-}
 var TOOL_ONLY_VIEWS = [
   "compact",
   "contractJson",
@@ -941,7 +962,7 @@ Examples:
         process.exitCode = await narrowView();
         return;
       }
-      const { describeAnything } = await import("./describe-XYJ2ZT4M.mjs");
+      const { describeAnything } = await import("./describe-Q23DWJUK.mjs");
       process.exitCode = await describeAnything(
         toolId,
         {
@@ -1018,9 +1039,59 @@ Examples:
   ).option(
     "--recovery-timeout-ms <milliseconds>",
     "Maximum wait for a keyed execution to finish (default: 900000)"
-  ).action(async (toolId, options) => {
-    process.exitCode = await executeTool(toolId, options);
-  });
+  ).action(
+    async (toolId, options, command) => {
+      process.exitCode = await executeTool(
+        toolId,
+        options,
+        void 0,
+        true,
+        resolveCliMaintenancePolicy(command.optsWithGlobals())
+      );
+    }
+  );
+}
+function beginDeferredToolExecuteCompatibility(toolId, cliInvocationId) {
+  let metadata;
+  const startedAt = performance.now();
+  const baseUrl = resolveConfig().baseUrl;
+  recordCliTrace({ phase: "cli.tool_execute_compatibility_start" });
+  const result = runToolExecuteStage(
+    "SDK compatibility",
+    () => checkSdkCompatibility(baseUrl, {
+      command: "tools execute",
+      skillsVersion: readSdkSkillsLocalVersion(baseUrl),
+      persistCache: false,
+      timeoutMs: TOOL_EXECUTE_PREFLIGHT_TIMEOUT_MS,
+      catalog: {
+        toolId,
+        cliInvocationId,
+        purpose: "execution_warnings",
+        acceptMetadata: (value) => {
+          metadata = value;
+        }
+      }
+    })
+  ).then(
+    (compatibility) => {
+      recordCliTrace({
+        phase: "cli.tool_execute_compatibility_ready",
+        ms: performance.now() - startedAt,
+        ok: compatibility.error === null,
+        hasMetadata: metadata !== void 0
+      });
+      return compatibility;
+    },
+    (error) => {
+      recordCliTrace({
+        phase: "cli.tool_execute_compatibility_ready",
+        ms: performance.now() - startedAt,
+        ok: false
+      });
+      throw error;
+    }
+  );
+  return { result, readMetadata: () => metadata };
 }
 async function getTool(toolId, options = {}, compatibilityMetadata) {
   if (!toolId) {
@@ -2300,9 +2371,23 @@ function buildToolExecuteRowArtifactEnvelope(input) {
     }
   };
 }
-async function executeTool(toolId, options) {
+function printToolExecutionWarnings(toolId, params, metadata) {
+  if (metadata.deprecation?.message) {
+    console.error(
+      `Warning: ${toolId} is deprecated. ${metadata.deprecation.message}`
+    );
+  }
+  const requestWarning = firstMatchingToolRequestWarning(
+    metadata.requestWarnings,
+    params
+  );
+  if (requestWarning) {
+    console.error(`Warning: ${requestWarning.message}`);
+  }
+}
+async function executeTool(toolId, options, compatibilityMetadata, deferCompatibility = false, maintenancePolicy = "configured") {
   const output = toolExecuteJsonOption(options.json);
-  const wantsJson = shouldEmitJson(output.requested) || (options.outputFormat ?? "auto").trim().toLowerCase() !== "csv";
+  const wantsJson = (options.outputFormat ?? "auto").trim().toLowerCase() !== "csv";
   let parsed;
   try {
     parsed = parseExecuteOptions(toolId, options, output);
@@ -2315,61 +2400,88 @@ async function executeTool(toolId, options) {
     return error instanceof DeeplineError && error.code === "IDEMPOTENCY_KEY_INVALID" ? 2 : 1;
   }
   const cliInvocationId = getToolExecuteInvocationId() ?? beginToolExecuteCommand();
+  const deferredCompatibility = deferCompatibility ? beginDeferredToolExecuteCompatibility(toolId, cliInvocationId) : void 0;
+  const tracing = isCliTraceEnabled();
+  const clientStartedAt = tracing ? performance.now() : void 0;
   const client = new DeeplineClient();
-  let metadata;
-  try {
-    metadata = await runToolExecuteStage(
-      "tool metadata lookup",
-      () => client.getTool(parsed.toolId, { cliInvocationId })
-    );
-  } catch (error) {
-    if (isMissingToolMetadataError(error)) {
-      const play = await runToolExecuteStage(
-        "play alias lookup",
-        () => findPlayForToolId(client, parsed.toolId, cliInvocationId)
+  if (clientStartedAt !== void 0) {
+    recordCliTrace({
+      phase: "cli.tool_execute_client_setup",
+      ms: performance.now() - clientStartedAt
+    });
+  }
+  let metadata = compatibilityMetadata;
+  const readMetadata = async () => {
+    if (metadata) return metadata;
+    try {
+      metadata = await runToolExecuteStage(
+        "tool metadata lookup",
+        () => client.getTool(parsed.toolId, { cliInvocationId })
       );
-      if (play) {
-        if (wantsJson) {
-          printJsonError(
-            new Error(playAliasToolErrorMessage(parsed.toolId, play))
+    } catch (error) {
+      if (isMissingToolMetadataError(error)) {
+        const play = await runToolExecuteStage(
+          "play alias lookup",
+          () => findPlayForToolId(client, parsed.toolId, cliInvocationId)
+        );
+        if (play) {
+          throw new DeeplineError(
+            playAliasToolErrorMessage(parsed.toolId, play),
+            400,
+            "PLAY_ALIAS_USED_AS_TOOL"
           );
-        } else {
-          printPlayAliasToolError(parsed.toolId, play);
         }
-        return 2;
       }
+      throw error;
     }
-    throw error;
-  }
-  if (isPlayLikeTool(metadata)) {
-    if (wantsJson) {
-      printJsonError(
-        new Error(
-          playLikeToolExecuteErrorMessage(
-            parsed.toolId,
-            metadata
-          )
-        )
-      );
-    } else {
-      printPlayLikeToolExecuteError(
-        parsed.toolId,
-        metadata
+    if (isPlayLikeTool(metadata)) {
+      throw new DeeplineError(
+        playLikeToolExecuteErrorMessage(
+          parsed.toolId,
+          metadata
+        ),
+        400,
+        "PLAY_ALIAS_USED_AS_TOOL"
       );
     }
-    return 2;
-  }
-  if (metadata.deprecation?.message) {
-    console.error(
-      `Warning: ${parsed.toolId} is deprecated. ${metadata.deprecation.message}`
-    );
-  }
-  const requestWarning = firstMatchingToolRequestWarning(
-    metadata.requestWarnings,
-    parsed.params
-  );
-  if (requestWarning) {
-    console.error(`Warning: ${requestWarning.message}`);
+    return metadata;
+  };
+  let executionWarningsPrinted = false;
+  if (deferredCompatibility) {
+    let preflightCompatibility;
+    try {
+      preflightCompatibility = await deferredCompatibility.result;
+    } catch {
+    }
+    metadata = deferredCompatibility.readMetadata() ?? metadata;
+    if (!metadata && preflightCompatibility?.response?.update_required !== true) {
+      try {
+        metadata = await readMetadata();
+      } catch (error) {
+        if (error instanceof DeeplineError && error.code === "PLAY_ALIAS_USED_AS_TOOL") {
+          if (wantsJson) printJsonError(error);
+          else console.error(error.message);
+          return 2;
+        }
+        throw error;
+      }
+    }
+    if (metadata) {
+      printToolExecutionWarnings(parsed.toolId, parsed.params, metadata);
+      executionWarningsPrinted = true;
+    }
+  } else {
+    try {
+      metadata = await readMetadata();
+    } catch (error) {
+      if (error instanceof DeeplineError && error.code === "PLAY_ALIAS_USED_AS_TOOL") {
+        if (wantsJson) printJsonError(error);
+        else console.error(error.message);
+        return 2;
+      }
+      throw error;
+    }
+    printToolExecutionWarnings(parsed.toolId, parsed.params, metadata);
   }
   const responseIntent = parsed.outPath || parsed.outputFormat === "csv" || parsed.outputFormat === "csv_file" ? "row_artifact" : "raw";
   const recovery = ToolCallRecovery.open({
@@ -2383,38 +2495,195 @@ async function executeTool(toolId, options) {
   if (idempotencyKey) {
     console.error(`Tool execution recovery key: ${idempotencyKey}`);
   }
-  const rawResponse = await runToolExecuteStage(
-    "execute request",
-    () => client.executeTool(parsed.toolId, parsed.params, {
-      ...parsed.timeoutMs !== void 0 ? { timeout: parsed.timeoutMs } : {},
-      ...metadata.executionMetadata?.retrySafeTransientHttp === true ? { maxRetries: 2, retryApiErrors: true } : {},
-      responseIntent,
-      ...idempotencyKey ? { idempotencyKey } : {},
-      ...parsed.recoveryTimeoutMs !== void 0 ? { recoveryTimeoutMs: parsed.recoveryTimeoutMs } : {},
-      searchRef: recentSearchRef(),
-      cliInvocationId,
-      onResponseReceived: recordApiResponse
-    }).catch((error) => {
-      const guidanceLines = toolGuidanceLines(metadata.guidance);
-      if (guidanceLines.length > 0) {
-        if (wantsJson && error instanceof Error) {
-          Object.assign(error, { guidance: metadata.guidance });
-        } else {
-          console.error(
-            [`Guidance for ${parsed.toolId}:`, ...guidanceLines].join("\n")
+  let submissionStartedAt = 0;
+  const executeOptions = {
+    ...parsed.timeoutMs !== void 0 ? { timeout: parsed.timeoutMs } : {},
+    responseIntent,
+    ...idempotencyKey ? { idempotencyKey } : {},
+    ...parsed.recoveryTimeoutMs !== void 0 ? { recoveryTimeoutMs: parsed.recoveryTimeoutMs } : {},
+    searchRef: recentSearchRef(),
+    cliInvocationId,
+    onResponseReceived: recordApiResponse,
+    ...tracing ? {
+      onServerTiming: (serverTiming) => recordCliTrace({
+        phase: "tool_execute_server_timing",
+        cliInvocationId,
+        serverTiming,
+        submissionToHeadersMs: performance.now() - submissionStartedAt
+      })
+    } : {}
+  };
+  let rawResponse;
+  let successfulCompatibilityResponse;
+  try {
+    const executeResult = await runToolExecuteStage(
+      "execute request",
+      async () => {
+        try {
+          if (tracing) {
+            submissionStartedAt = performance.now();
+            recordCliTrace({ phase: "cli.tool_execute_request_start" });
+          }
+          return await client.executeTool(parsed.toolId, parsed.params, {
+            ...executeOptions,
+            atomicToolOnly: true
+          });
+        } catch (error) {
+          if (!(error instanceof DeeplineError) || error.code !== "ATOMIC_TOOL_EXECUTE_UNSUPPORTED")
+            throw error;
+          const baseUrl = resolveConfig().baseUrl;
+          if (maintenancePolicy !== "off") {
+            flushDeferredSkillsSyncNotices(baseUrl);
+          }
+          const compatibility = deferredCompatibility ? await deferredCompatibility.result : await runToolExecuteStage(
+            "SDK compatibility",
+            () => checkSdkCompatibility(baseUrl, {
+              command: "tools execute",
+              skillsVersion: readSdkSkillsLocalVersion(baseUrl),
+              persistCache: maintenancePolicy !== "off"
+            })
           );
+          if (compatibility.error) throw compatibility.error;
+          metadata = deferredCompatibility?.readMetadata() ?? metadata;
+          if (maintenancePolicy !== "off" && await maybeAutoUpdateAndRelaunch(
+            compatibility.response,
+            baseUrl,
+            maintenancePolicy
+          )) {
+            return void 0;
+          }
+          enforceSdkCompatibilityResponse(compatibility.response, {
+            quietAdvisory: wantsJson
+          });
+          if (maintenancePolicy !== "off") {
+            await runToolExecuteStage(
+              "agent skills sync",
+              () => syncSdkSkillsIfNeeded(baseUrl, {
+                update: compatibility.response?.skills,
+                mode: "detached"
+              })
+            );
+          }
+          const legacyMetadata = await readMetadata();
+          if (tracing) {
+            submissionStartedAt = performance.now();
+            recordCliTrace({ phase: "cli.tool_execute_request_start" });
+          }
+          return client.executeTool(parsed.toolId, parsed.params, {
+            ...executeOptions,
+            ...legacyMetadata.executionMetadata?.retrySafeTransientHttp === true ? { maxRetries: 2, retryApiErrors: true } : {}
+          });
+        }
+      }
+    );
+    if (executeResult === void 0) return 0;
+    rawResponse = executeResult;
+  } catch (error) {
+    if (deferredCompatibility) {
+      let compatibility;
+      try {
+        compatibility = await deferredCompatibility.result;
+      } catch {
+      }
+      metadata = deferredCompatibility.readMetadata() ?? metadata;
+      const updateRequiredBeforeExecution = error instanceof DeeplineError && error.code === "SDK_UPDATE_REQUIRED";
+      if (updateRequiredBeforeExecution && maintenancePolicy !== "off" && compatibility && !compatibility.error) {
+        const baseUrl = resolveConfig().baseUrl;
+        if (await maybeAutoUpdateAndRelaunch(
+          compatibility.response,
+          baseUrl,
+          maintenancePolicy
+        )) {
+          return 0;
         }
       }
+    }
+    if (error instanceof DeeplineError && error.code === "SDK_UPDATE_REQUIRED")
       throw error;
-    })
+    let failure = error;
+    try {
+      await readMetadata();
+    } catch (diagnosticError) {
+      if (diagnosticError instanceof DeeplineError && diagnosticError.code === "PLAY_ALIAS_USED_AS_TOOL")
+        failure = diagnosticError;
+    }
+    if (failure instanceof DeeplineError && failure.code === "PLAY_ALIAS_USED_AS_TOOL") {
+      if (wantsJson) printJsonError(failure);
+      else console.error(failure.message);
+      return 2;
+    }
+    const guidanceLines = toolGuidanceLines(metadata?.guidance);
+    if (guidanceLines.length > 0) {
+      if (wantsJson && failure instanceof Error) {
+        Object.assign(failure, { guidance: metadata?.guidance });
+      } else {
+        console.error(
+          [`Guidance for ${parsed.toolId}:`, ...guidanceLines].join("\n")
+        );
+      }
+    }
+    throw failure;
+  }
+  if (deferredCompatibility) {
+    let compatibility;
+    try {
+      compatibility = await deferredCompatibility.result;
+    } catch {
+    }
+    metadata = deferredCompatibility.readMetadata() ?? metadata;
+    const compatibilityResponse = compatibility?.response;
+    successfulCompatibilityResponse = compatibilityResponse ?? void 0;
+    const autoUpdate = compatibilityResponse?.auto_update;
+    if (maintenancePolicy !== "off" && compatibilityResponse && autoUpdate?.should_auto_update && !autoUpdate.required && autoUpdate.reason !== "rollback_forced") {
+      await maybeAutoUpdateAndRelaunch(
+        compatibilityResponse,
+        resolveConfig().baseUrl,
+        maintenancePolicy
+      );
+    }
+    if (!metadata) {
+      try {
+        metadata = await readMetadata();
+      } catch {
+      }
+    }
+    if (metadata && !executionWarningsPrinted) {
+      printToolExecutionWarnings(parsed.toolId, parsed.params, metadata);
+    } else if (!metadata) {
+      console.error(
+        `Warning: execution metadata for ${parsed.toolId} was unavailable; the result is unchanged.`
+      );
+    }
+  }
+  const responseMetadata = recordField(
+    recordField(rawResponse, "_metadata"),
+    "tool"
   );
+  const listOutputPaths = responseMetadata.listOutputPaths;
+  let listExtractorPaths;
+  if (Array.isArray(listOutputPaths) && listOutputPaths.every((path) => typeof path === "string")) {
+    listExtractorPaths = listOutputPaths;
+  } else {
+    listExtractorPaths = listExtractorPathsFromUsageGuidance(
+      await readMetadata()
+    );
+  }
+  if (isRecord(rawResponse)) {
+    const { _metadata, ...execution } = rawResponse;
+    rawResponse = execution;
+  }
   const { listConversion, summary, baseEnvelope } = await runToolExecuteStage(
     "result formatting",
-    () => {
-      const listExtractorPaths = listExtractorPathsFromUsageGuidance(metadata);
+    async () => {
       const listConversion2 = tryConvertToList(rawResponse, {
         listExtractorPaths
       });
+      if (toolExecuteExitCode(commandEnvelopeFromRawResponse(rawResponse)) !== 0 || listExtractorPaths.length > 0 && !listConversion2) {
+        try {
+          await readMetadata();
+        } catch {
+        }
+      }
       const summary2 = extractSummaryFields(rawResponse);
       const baseEnvelope2 = buildToolExecuteBaseEnvelope({
         toolId: parsed.toolId,
@@ -2423,16 +2692,45 @@ async function executeTool(toolId, options) {
         rawResponse,
         listConversion: listConversion2,
         summary: summary2,
-        guidance: metadata.guidance,
+        guidance: metadata?.guidance,
         listExpected: listExtractorPaths.length > 0
       });
       return { listConversion: listConversion2, summary: summary2, baseEnvelope: baseEnvelope2 };
     }
   );
   const executeExitCode = toolExecuteExitCode(baseEnvelope);
-  const delivered = await runToolExecuteStage("output delivery", () => {
+  const deliveredCompatibilityResponse = successfulCompatibilityResponse;
+  let skillsSyncAttempted = false;
+  const syncSkillsForDeliveredOutput = async () => {
+    if (skillsSyncAttempted || maintenancePolicy === "off" || !deliveredCompatibilityResponse) {
+      return;
+    }
+    skillsSyncAttempted = true;
+    try {
+      await runToolExecuteStage(
+        "agent skills sync",
+        () => syncSdkSkillsIfNeeded(resolveConfig().baseUrl, {
+          update: deliveredCompatibilityResponse.skills,
+          mode: "detached"
+        })
+      );
+    } catch (error) {
+      console.error(
+        `Warning: automatic skills sync failed; the tool result is unchanged. ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+  const printDeliveredEnvelope = (envelope, options2 = {}) => printCommandEnvelope(envelope, {
+    ...options2,
+    json: options2.json ?? wantsJson
+  });
+  const printDeliveredJsonEnvelope = async (envelope, options2 = {}) => {
+    await syncSkillsForDeliveredOutput();
+    printCommandEnvelope(envelope, { ...options2, json: true });
+  };
+  const delivered = await runToolExecuteStage("output delivery", async () => {
     if (!parsed.outPath && (parsed.outputFormat === "json" || parsed.outputFormat === "auto" && wantsJson)) {
-      printCommandEnvelope(baseEnvelope, { json: true });
+      await printDeliveredJsonEnvelope(baseEnvelope);
       return true;
     }
     if (parsed.outputFormat === "json_file") {
@@ -2440,16 +2738,13 @@ async function executeTool(toolId, options) {
         rawResponse,
         `payload_${parsed.toolId}`
       );
-      printCommandEnvelope(
-        {
-          ...baseEnvelope,
-          local: {
-            ...isRecord(baseEnvelope.local) ? baseEnvelope.local : {},
-            payload_file: jsonPath
-          }
-        },
-        { json: true }
-      );
+      await printDeliveredJsonEnvelope({
+        ...baseEnvelope,
+        local: {
+          ...isRecord(baseEnvelope.local) ? baseEnvelope.local : {},
+          payload_file: jsonPath
+        }
+      });
       return true;
     }
     if (!listConversion) {
@@ -2473,18 +2768,20 @@ async function executeTool(toolId, options) {
           rawResponse,
           `payload_${parsed.toolId}`
         );
-        printCommandEnvelope(
-          {
-            ...baseEnvelope,
-            local: {
-              payload_file: jsonPath
-            }
-          },
-          { json: parsed.outputFormat === "csv_file" || wantsJson }
-        );
+        const payloadEnvelope = {
+          ...baseEnvelope,
+          local: {
+            payload_file: jsonPath
+          }
+        };
+        if (parsed.outputFormat === "csv_file" || wantsJson) {
+          await printDeliveredJsonEnvelope(payloadEnvelope);
+        } else {
+          printDeliveredEnvelope(payloadEnvelope);
+        }
         return true;
       }
-      printCommandEnvelope(baseEnvelope, { json: false });
+      await printDeliveredEnvelope(baseEnvelope, { json: false });
       return true;
     }
     const rowOutput = projectRowOutput(listConversion);
@@ -2508,7 +2805,7 @@ async function executeTool(toolId, options) {
       seededScript
     });
     if (parsed.outputFormat === "csv_file") {
-      printCommandEnvelope(materializedEnvelope, { json: true });
+      await printDeliveredJsonEnvelope(materializedEnvelope);
       return true;
     }
     if (parsed.outPath) {
@@ -2516,31 +2813,42 @@ async function executeTool(toolId, options) {
         toolId: parsed.toolId,
         idempotencyKey
       });
-      printCommandEnvelope(materializedEnvelope, {
-        json: wantsJson,
-        text: `Wrote ${csv.rowCount} row(s) to ${csv.path}
+      const outputText = `Wrote ${csv.rowCount} row(s) to ${csv.path}
 inspect: ${inspection.inspect}
-`
-      });
+`;
+      if (wantsJson) {
+        await printDeliveredJsonEnvelope(materializedEnvelope, {
+          text: outputText
+        });
+      } else {
+        printDeliveredEnvelope(materializedEnvelope, { text: outputText });
+      }
       return true;
     }
     if (parsed.noPreview) {
-      printCommandEnvelope(
-        {
-          ...materializedEnvelope,
-          local: {
-            ...materializedEnvelope.local ?? {},
-            output_path: csv.path
-          }
-        },
-        { json: wantsJson, text: `${csv.path}
-` }
-      );
+      const outputEnvelope = {
+        ...materializedEnvelope,
+        local: {
+          ...materializedEnvelope.local ?? {},
+          output_path: csv.path
+        }
+      };
+      if (wantsJson) {
+        await printDeliveredJsonEnvelope(outputEnvelope, {
+          text: `${csv.path}
+`
+        });
+      } else {
+        printDeliveredEnvelope(outputEnvelope, { text: `${csv.path}
+` });
+      }
       return true;
     }
-    printCommandEnvelope(materializedEnvelope, {
-      json: wantsJson && parsed.outputFormat !== "csv"
-    });
+    if (wantsJson && parsed.outputFormat !== "csv") {
+      await printDeliveredJsonEnvelope(materializedEnvelope);
+    } else {
+      printDeliveredEnvelope(materializedEnvelope);
+    }
     return true;
   });
   if (delivered) {
@@ -2549,6 +2857,12 @@ inspect: ${inspection.inspect}
       () => recovery.acknowledgeDelivery()
     );
   }
+  if (delivered && deliveredCompatibilityResponse && deliveredCompatibilityResponse.update_required !== true) {
+    enforceSdkCompatibilityResponse(deliveredCompatibilityResponse, {
+      quietAdvisory: wantsJson || maintenancePolicy === "off" || deliveredCompatibilityResponse.auto_update?.should_auto_update === true
+    });
+  }
+  if (delivered && !skillsSyncAttempted) await syncSkillsForDeliveredOutput();
   return delivered ? executeExitCode : 1;
 }