deepline 0.3.55 → 0.3.57

package/dist/cli/index.js

@@ -182,7 +182,7 @@ configureProxyFromEnv();
 
 // src/cli/index.ts
 var import_promises10 = require("fs/promises");
-var import_node_path27 = require("path");
+var import_node_path28 = require("path");
 var import_node_os18 = require("os");
 var import_commander4 = require("commander");
 
@@ -1075,7 +1075,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.55",
+  version: "0.3.57",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1
@@ -2212,7 +2212,7 @@ function decodeSseFrame(frame) {
   return parsed;
 }
 function sleep(ms) {
-  return new Promise((resolve20) => setTimeout(resolve20, ms));
+  return new Promise((resolve21) => setTimeout(resolve21, ms));
 }
 function withCoworkNetworkHint(message) {
   if (!isCoworkLikeSandbox2() || message.includes(COWORK_NETWORK_HINT)) {
@@ -3115,9 +3115,9 @@ function nonEmptyString(value) {
 }
 function normalizeDatasetBornFrom(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const record = value;
-  const table = nonEmptyString(record.table);
-  const rowCountIn = finiteNonNegativeInteger2(record.rowCountIn);
+  const record2 = value;
+  const table = nonEmptyString(record2.table);
+  const rowCountIn = finiteNonNegativeInteger2(record2.rowCountIn);
   if (!table || rowCountIn === null) return null;
   return { table, rowCountIn };
 }
@@ -3977,14 +3977,14 @@ async function* observeRunEvents(options) {
   try {
     for (; ; ) {
       if (queue.length === 0) {
-        const waitForItem = new Promise((resolve20) => {
-          wake = resolve20;
+        const waitForItem = new Promise((resolve21) => {
+          wake = resolve21;
         });
         if (!sawFirstSnapshot) {
           const timedOut = await Promise.race([
             waitForItem.then(() => false),
             new Promise(
-              (resolve20) => setTimeout(() => resolve20(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
+              (resolve21) => setTimeout(() => resolve21(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
             )
           ]);
           if (timedOut && queue.length === 0) {
@@ -4177,21 +4177,21 @@ function normalizePlayRuntimeNamespace(value) {
 }
 function normalizePlayRuntimeSelection(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const record = value;
-  if (Object.keys(record).some(
+  const record2 = value;
+  if (Object.keys(record2).some(
     (key) => key !== "environment" && key !== "namespace" && key !== "backend"
-  ) || record.environment !== "preview") {
+  ) || record2.environment !== "preview") {
     return null;
   }
-  const namespace = normalizePlayRuntimeNamespace(record.namespace);
+  const namespace = normalizePlayRuntimeNamespace(record2.namespace);
   if (!namespace) return null;
-  if (record.backend === void 0) {
+  if (record2.backend === void 0) {
     return { environment: "preview", namespace };
   }
-  if (record.backend !== PLAY_RUNTIME_BACKENDS.daytona && record.backend !== PLAY_RUNTIME_BACKENDS.modal) {
+  if (record2.backend !== PLAY_RUNTIME_BACKENDS.daytona && record2.backend !== PLAY_RUNTIME_BACKENDS.modal) {
     return null;
   }
-  return { environment: "preview", namespace, backend: record.backend };
+  return { environment: "preview", namespace, backend: record2.backend };
 }
 function normalizePlayRuntimeEnvironment(value) {
   return typeof value === "string" && PLAY_RUNTIME_ENVIRONMENTS.includes(value) ? value : null;
@@ -4343,7 +4343,7 @@ function parseEnvTestPolicyOverrides() {
   return normalizeTestPolicyOverrides(parsed, "DEEPLINE_TEST_POLICY_OVERRIDES");
 }
 function sleep2(ms) {
-  return new Promise((resolve20) => setTimeout(resolve20, ms));
+  return new Promise((resolve21) => setTimeout(resolve21, ms));
 }
 function isTransientCompileManifestError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
@@ -4775,7 +4775,14 @@ var DeeplineClient = class {
       dependents: (key) => this.getMonitorDependents(key),
       update: (key, patch) => this.updateMonitor(key, patch),
       delete: (key, options2) => this.deleteMonitor(key, options2),
-      reactivate: (key, options2) => this.reactivateMonitor(key, options2)
+      reactivate: (key, options2) => this.reactivateMonitor(key, options2),
+      fleets: {
+        sync: (definitionOrId, options2) => this.syncMonitorFleet(definitionOrId, options2),
+        get: (fleetId, options2) => fleetId === void 0 ? this.listMonitorFleets() : this.getMonitorFleet(fleetId, options2),
+        list: () => this.listMonitorFleets(),
+        deactivate: (fleetId, options2) => this.deactivateMonitorFleet(fleetId, options2),
+        waitForConvergence: (fleetId, options2) => this.waitForMonitorFleetConvergence(fleetId, options2)
+      }
     };
   }
   /** The resolved base URL this client is targeting (e.g. `"http://localhost:3000"`). */
@@ -7083,6 +7090,104 @@ var DeeplineClient = class {
       { method: "POST", body: {} }
     );
   }
+  // ——————————————————————————————————————————————————————————
+  // Monitor Fleets
+  // ——————————————————————————————————————————————————————————
+  monitorFleetIdempotencyKey(operation) {
+    const uuid = globalThis.crypto?.randomUUID?.();
+    return `monitor-fleet-${operation}-${uuid ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`}`;
+  }
+  monitorFleetHeaders(operation, idempotencyKey) {
+    return {
+      "Idempotency-Key": idempotencyKey?.trim() || this.monitorFleetIdempotencyKey(operation)
+    };
+  }
+  monitorFleetPath(fleetId) {
+    return `/api/v2/monitors/fleets/${encodeURIComponent(fleetId)}`;
+  }
+  /**
+   * Create, update, or re-plan one fleet.
+   *
+   * The fleet id is always the resource path, so the same definition PUT twice
+   * is the same operation and the server can answer `replayed: true` instead of
+   * building a second set of monitors. Re-planning an existing fleet from its
+   * stored definition sends an EMPTY body: there is no second definition to
+   * send, and an empty body cannot be mistaken for "replace the definition with
+   * nothing".
+   */
+  async syncMonitorFleet(definitionOrId, options) {
+    const fleetId = typeof definitionOrId === "string" ? definitionOrId : definitionOrId.id;
+    const body = {
+      ...typeof definitionOrId === "string" ? {} : { definition: definitionOrId },
+      ...options?.dryRun ? { dry_run: true } : {},
+      ...options?.expectedGeneration !== void 0 ? { expected_generation: options.expectedGeneration } : {}
+    };
+    return this.http.request(
+      this.monitorFleetPath(fleetId),
+      {
+        method: "PUT",
+        body,
+        headers: this.monitorFleetHeaders("sync", options?.idempotencyKey),
+        maxRetries: 0,
+        exactUrlOnly: true
+      }
+    );
+  }
+  async listMonitorFleets() {
+    return this.http.request("/api/v2/monitors/fleets", {
+      method: "GET"
+    });
+  }
+  async getMonitorFleet(fleetId, options) {
+    const params = new URLSearchParams();
+    if (options?.drift) params.set("drift", "1");
+    if (options?.limit !== void 0)
+      params.set("limit", String(options.limit));
+    const query = params.toString();
+    return this.http.request(
+      `${this.monitorFleetPath(fleetId)}${query ? `?${query}` : ""}`,
+      { method: "GET" }
+    );
+  }
+  async deactivateMonitorFleet(fleetId, options) {
+    return this.http.request(
+      this.monitorFleetPath(fleetId),
+      {
+        method: "DELETE",
+        body: options?.dryRun ? { dry_run: true } : {},
+        headers: this.monitorFleetHeaders(
+          "deactivate",
+          options?.idempotencyKey
+        ),
+        maxRetries: 0,
+        exactUrlOnly: true
+      }
+    );
+  }
+  /**
+   * Poll one fleet until the server reports a terminal status.
+   *
+   * Convergence is the server's verdict, read from `status`. The timeout is not
+   * a failure and does not throw: a fleet still `converging` after ten minutes
+   * is healthy and slow, not broken, so the caller gets the last snapshot and
+   * decides what that means. Throwing here would have made "still working" look
+   * identical to "the request failed".
+   */
+  async waitForMonitorFleetConvergence(fleetId, options) {
+    const timeoutMs = Math.max(1, options?.timeoutMs ?? 10 * 6e4);
+    const pollIntervalMs = Math.max(1, options?.pollIntervalMs ?? 2e3);
+    const terminal = options?.until === "deactivated" ? /* @__PURE__ */ new Set(["deactivated", "degraded"]) : /* @__PURE__ */ new Set(["converged", "degraded", "deactivated"]);
+    const startedAt = Date.now();
+    let latest = await this.getMonitorFleet(fleetId);
+    while (true) {
+      options?.onProgress?.(latest);
+      const status = typeof latest.status === "string" ? latest.status : void 0;
+      if (status && terminal.has(status)) return latest;
+      if (Date.now() - startedAt >= timeoutMs) return latest;
+      await sleep2(pollIntervalMs);
+      latest = await this.getMonitorFleet(fleetId);
+    }
+  }
   /**
    * Check API connectivity and server health.
    *
@@ -7749,30 +7854,30 @@ function flattenObjectColumns(row, options = {}) {
       continue;
     }
     if (value && typeof value === "object" && !Array.isArray(value)) {
-      const record = value;
+      const record2 = value;
       if (options.objectColumns === "json") {
-        flattened[key] = csvSafeJsonString(record);
+        flattened[key] = csvSafeJsonString(record2);
         continue;
       }
-      const hasMatchedEnvelope = Object.prototype.hasOwnProperty.call(record, "matched_result") || Object.prototype.hasOwnProperty.call(record, "matchedResult");
+      const hasMatchedEnvelope = Object.prototype.hasOwnProperty.call(record2, "matched_result") || Object.prototype.hasOwnProperty.call(record2, "matchedResult");
       if (hasMatchedEnvelope) {
-        flattened[key] = csvSafeJsonString(record);
+        flattened[key] = csvSafeJsonString(record2);
         continue;
       }
       if (parsedFromString && shouldPreserveJsonStringColumn(options.preserveJsonStringColumns, key)) {
         flattened[key] = rawValue;
         continue;
       } else {
-        const failureMessage = failureMessageFromRecord(record);
+        const failureMessage = failureMessageFromRecord(record2);
         if (failureMessage) {
           flattened[key] = failureMessage;
           continue;
-        } else if (Object.prototype.hasOwnProperty.call(record, "result")) {
-          flattened[key] = csvSafeJsonString(record);
+        } else if (Object.prototype.hasOwnProperty.call(record2, "result")) {
+          flattened[key] = csvSafeJsonString(record2);
           continue;
         }
       }
-      for (const [nestedKey, nestedValue] of Object.entries(record)) {
+      for (const [nestedKey, nestedValue] of Object.entries(record2)) {
         flattened[`${key}.${nestedKey}`] = nestedValue && typeof nestedValue === "object" ? csvSafeJsonString(nestedValue) : nestedValue;
       }
       continue;
@@ -8161,7 +8266,7 @@ function buildCandidateUrls2(url) {
   }
 }
 function sleep4(ms) {
-  return new Promise((resolve20) => setTimeout(resolve20, ms));
+  return new Promise((resolve21) => setTimeout(resolve21, ms));
 }
 function printDeeplineLogo() {
   if (process.stdout.isTTY && (process.stdout.columns ?? 80) >= 70) {
@@ -10256,9 +10361,9 @@ function canonicalDatasetJsonValue(value, ancestors) {
   }
   if (ancestors.has(value)) return value;
   ancestors.add(value);
-  const record = value;
+  const record2 = value;
   const normalized = Object.fromEntries(
-    Object.keys(record).sort((left, right) => left.localeCompare(right)).map((key) => [key, canonicalDatasetJsonValue(record[key], ancestors)])
+    Object.keys(record2).sort((left, right) => left.localeCompare(right)).map((key) => [key, canonicalDatasetJsonValue(record2[key], ancestors)])
   );
   ancestors.delete(value);
   return normalized;
@@ -11425,16 +11530,16 @@ function collectErrorText(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return errorMessage(value);
   }
-  const record = value;
+  const record2 = value;
   return [
     errorMessage(value),
-    typeof record.error === "string" ? record.error : "",
-    typeof record.message === "string" ? record.message : "",
-    typeof record.detail === "string" ? record.detail : "",
-    typeof record.hint === "string" ? record.hint : "",
-    typeof record.code === "string" ? record.code : "",
-    record.response ? collectErrorText(record.response) : "",
-    record.details ? collectErrorText(record.details) : ""
+    typeof record2.error === "string" ? record2.error : "",
+    typeof record2.message === "string" ? record2.message : "",
+    typeof record2.detail === "string" ? record2.detail : "",
+    typeof record2.hint === "string" ? record2.hint : "",
+    typeof record2.code === "string" ? record2.code : "",
+    record2.response ? collectErrorText(record2.response) : "",
+    record2.details ? collectErrorText(record2.details) : ""
   ].filter(Boolean).join("\n");
 }
 function formatDbQueryError(sql, error) {
@@ -12448,8 +12553,8 @@ function getterNamesFromTool(tool, kind) {
   return extractionEntries(resultGuidance[key] ?? resultGuidance[snakeKey]).map((entry) => stringValue(entry.name)).filter(Boolean);
 }
 function targetGettersFromTool(tool) {
-  const record = isRecord9(tool) ? tool : {};
-  const raw = record.targetGetters ?? record.target_getters;
+  const record2 = isRecord9(tool) ? tool : {};
+  const raw = record2.targetGetters ?? record2.target_getters;
   if (!isRecord9(raw)) return {};
   const entries = [];
   for (const [target, value] of Object.entries(raw)) {
@@ -15315,11 +15420,11 @@ function staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Se
     if (!value?.trim()) return null;
     return trimResult ? value.trim() : value;
   }
-  const identifier = getIdentifierName2(expression);
-  if (!identifier || seen.has(identifier)) return null;
-  seen.add(identifier);
+  const identifier2 = getIdentifierName2(expression);
+  if (!identifier2 || seen.has(identifier2)) return null;
+  seen.add(identifier2);
   return staticStringFromExpression(
-    context.declarations.get(identifier),
+    context.declarations.get(identifier2),
     context,
     seen,
     trimResult
@@ -15343,11 +15448,11 @@ function objectExpressionFromNode(node, context, seen = /* @__PURE__ */ new Set(
   const expression = unwrapStaticExpression2(node);
   if (!expression) return null;
   if (expression.type === "ObjectExpression") return expression;
-  const identifier = getIdentifierName2(expression);
-  if (!identifier || seen.has(identifier)) return null;
-  seen.add(identifier);
+  const identifier2 = getIdentifierName2(expression);
+  if (!identifier2 || seen.has(identifier2)) return null;
+  seen.add(identifier2);
   return objectExpressionFromNode(
-    context.declarations.get(identifier),
+    context.declarations.get(identifier2),
     context,
     seen
   );
@@ -15415,11 +15520,11 @@ function staticNumberFromExpression(node, context, seen = /* @__PURE__ */ new Se
   if (expression.type === "Literal" && typeof expression.value === "number") {
     return expression.value;
   }
-  const identifier = getIdentifierName2(expression);
-  if (!identifier || seen.has(identifier)) return null;
-  seen.add(identifier);
+  const identifier2 = getIdentifierName2(expression);
+  if (!identifier2 || seen.has(identifier2)) return null;
+  seen.add(identifier2);
   return staticNumberFromExpression(
-    context.declarations.get(identifier),
+    context.declarations.get(identifier2),
     context,
     seen
   );
@@ -16484,13 +16589,13 @@ function validateFixtureBehavior(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return { ok: false, error: "fixtureBehavior must be a JSON object." };
   }
-  const record = value;
-  const supportedKeys = record.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? /* @__PURE__ */ new Set([
+  const record2 = value;
+  const supportedKeys = record2.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? /* @__PURE__ */ new Set([
     "version",
     "responseSamples",
-    ...record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? ["replayBundle"] : []
+    ...record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? ["replayBundle"] : []
   ]) : /* @__PURE__ */ new Set(["version", "responseDelaySamplesMs"]);
-  const unknownKeys = Object.keys(record).filter(
+  const unknownKeys = Object.keys(record2).filter(
     (key) => !supportedKeys.has(key)
   );
   if (unknownKeys.length > 0) {
@@ -16499,22 +16604,22 @@ function validateFixtureBehavior(value) {
       error: `Unsupported fixtureBehavior field "${unknownKeys[0]}".`
     };
   }
-  if (record.version !== FIXTURE_BEHAVIOR_VERSION && record.version !== FIXTURE_BEHAVIOR_RESPONSE_VERSION && record.version !== FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+  if (record2.version !== FIXTURE_BEHAVIOR_VERSION && record2.version !== FIXTURE_BEHAVIOR_RESPONSE_VERSION && record2.version !== FIXTURE_BEHAVIOR_REPLAY_VERSION) {
     return {
       ok: false,
       error: `fixtureBehavior.version must be ${FIXTURE_BEHAVIOR_VERSION} or ${FIXTURE_BEHAVIOR_RESPONSE_VERSION}, or ${FIXTURE_BEHAVIOR_REPLAY_VERSION}.`
     };
   }
-  if (record.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
-    if (!Array.isArray(record.responseSamples) || record.responseSamples.length === 0 || record.responseSamples.length > MAX_FIXTURE_RESPONSE_DELAY_SAMPLES) {
+  if (record2.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+    if (!Array.isArray(record2.responseSamples) || record2.responseSamples.length === 0 || record2.responseSamples.length > MAX_FIXTURE_RESPONSE_DELAY_SAMPLES) {
       return {
         ok: false,
         error: `fixtureBehavior.responseSamples must contain between 1 and ${MAX_FIXTURE_RESPONSE_DELAY_SAMPLES} values.`
       };
     }
     const samples2 = [];
-    for (let index = 0; index < record.responseSamples.length; index += 1) {
-      const value2 = record.responseSamples[index];
+    for (let index = 0; index < record2.responseSamples.length; index += 1) {
+      const value2 = record2.responseSamples[index];
       if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) {
         return {
           ok: false,
@@ -16613,14 +16718,14 @@ function validateFixtureBehavior(value) {
       });
     }
     let replayBundle;
-    if (record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
-      if (!record.replayBundle || typeof record.replayBundle !== "object" || Array.isArray(record.replayBundle)) {
+    if (record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+      if (!record2.replayBundle || typeof record2.replayBundle !== "object" || Array.isArray(record2.replayBundle)) {
         return {
           ok: false,
           error: "fixtureBehavior.replayBundle must be an object."
         };
       }
-      const replay = record.replayBundle;
+      const replay = record2.replayBundle;
       const replayUnknownKeys = Object.keys(replay).filter(
         (key) => key !== "bundleId" && key !== "manifestSha256" && key !== "syntheticFallbackToolIds"
       );
@@ -16668,7 +16773,7 @@ function validateFixtureBehavior(value) {
         ...syntheticFallbackToolIds ? { syntheticFallbackToolIds } : {}
       };
     }
-    if (record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+    if (record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
       return {
         ok: true,
         behavior: {
@@ -16686,15 +16791,15 @@ function validateFixtureBehavior(value) {
       }
     };
   }
-  if (!Array.isArray(record.responseDelaySamplesMs) || record.responseDelaySamplesMs.length === 0 || record.responseDelaySamplesMs.length > MAX_FIXTURE_RESPONSE_DELAY_SAMPLES) {
+  if (!Array.isArray(record2.responseDelaySamplesMs) || record2.responseDelaySamplesMs.length === 0 || record2.responseDelaySamplesMs.length > MAX_FIXTURE_RESPONSE_DELAY_SAMPLES) {
     return {
       ok: false,
       error: `fixtureBehavior.responseDelaySamplesMs must contain between 1 and ${MAX_FIXTURE_RESPONSE_DELAY_SAMPLES} values.`
     };
   }
   const samples = [];
-  for (let index = 0; index < record.responseDelaySamplesMs.length; index += 1) {
-    const value2 = record.responseDelaySamplesMs[index];
+  for (let index = 0; index < record2.responseDelaySamplesMs.length; index += 1) {
+    const value2 = record2.responseDelaySamplesMs[index];
     if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < 0 || value2 > MAX_FIXTURE_RESPONSE_DELAY_MS) {
       return {
         ok: false,
@@ -16903,7 +17008,7 @@ function traceCliSync(phase, fields, run) {
   }
 }
 function sleep5(ms) {
-  return new Promise((resolve20) => setTimeout(resolve20, ms));
+  return new Promise((resolve21) => setTimeout(resolve21, ms));
 }
 function parseReferencedPlayTarget2(target) {
   const trimmed = target.trim();
@@ -17436,8 +17541,8 @@ 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";
+  const record2 = value;
+  return typeof record2.contentHash === "string" || typeof record2.contentBase64 === "string" || typeof record2.logicalPath === "string" && typeof record2.bytes === "number";
 }
 var CSV_DATA_INPUT_KEY = "csv";
 function collectLocalFileInputRefs(value, inputPath, key, out) {
@@ -17938,8 +18043,8 @@ function readLiveRunField(event, field) {
   const records = [payload, payload.progress, run, run?.progress].filter(
     (value) => Boolean(value && typeof value === "object" && !Array.isArray(value))
   );
-  for (const record of records) {
-    if (record[field] !== void 0) return record[field];
+  for (const record2 of records) {
+    if (record2[field] !== void 0) return record2[field];
   }
   return void 0;
 }
@@ -18241,8 +18346,8 @@ function getProgressLinesFromLiveEvent(event) {
     if (!state || typeof state !== "object" || Array.isArray(state)) {
       continue;
     }
-    const record = state;
-    const progress = record.progress && typeof record.progress === "object" && !Array.isArray(record.progress) ? record.progress : null;
+    const record2 = state;
+    const progress = record2.progress && typeof record2.progress === "object" && !Array.isArray(record2.progress) ? record2.progress : null;
     if (!progress) {
       continue;
     }
@@ -18259,7 +18364,7 @@ function getProgressLinesFromLiveEvent(event) {
       completed: progress.completed
     });
     lines.push(
-      `progress ${formatProgressLabel(record.nodeId ?? progress.artifactTableNamespace)}: ${counts}${messageSuffix}`
+      `progress ${formatProgressLabel(record2.nodeId ?? progress.artifactTableNamespace)}: ${counts}${messageSuffix}`
     );
   }
   return lines;
@@ -19088,17 +19193,17 @@ function collectDatasetHandleLines(value, path = "result") {
     return [];
   }
   if (isDatasetHandle(value)) {
-    const record = value;
-    const count = typeof record.count === "number" ? record.count : typeof record.rowCount === "number" ? record.rowCount : null;
-    const preview = Array.isArray(record.preview) ? record.preview : [];
+    const record2 = value;
+    const count = typeof record2.count === "number" ? record2.count : typeof record2.rowCount === "number" ? record2.rowCount : null;
+    const preview = Array.isArray(record2.preview) ? record2.preview : [];
     const lines2 = [
-      `  dataset ${typeof record.path === "string" ? record.path : path}: rows=${count === null ? "-" : formatInteger(count)} preview=${formatInteger(preview.length)}`
+      `  dataset ${typeof record2.path === "string" ? record2.path : path}: rows=${count === null ? "-" : formatInteger(count)} preview=${formatInteger(preview.length)}`
     ];
-    if (typeof record.queryDatasetCommand === "string") {
-      lines2.push(`  query dataset: ${record.queryDatasetCommand}`);
+    if (typeof record2.queryDatasetCommand === "string") {
+      lines2.push(`  query dataset: ${record2.queryDatasetCommand}`);
     }
-    if (typeof record.slowExportAsCsvCommand === "string") {
-      lines2.push(`  export CSV: ${record.slowExportAsCsvCommand}`);
+    if (typeof record2.slowExportAsCsvCommand === "string") {
+      lines2.push(`  export CSV: ${record2.slowExportAsCsvCommand}`);
     }
     return lines2;
   }
@@ -19495,8 +19600,8 @@ function withTerminalPlayIdentity(status, playName) {
   if (!playName.trim() || getPlayRunPackage(status)) {
     return status;
   }
-  const record = status;
-  const hasIdentity = typeof record.playName === "string" && record.playName.trim().length > 0 || typeof record.name === "string" && record.name.trim().length > 0 || Boolean(getStringField(record.run, "playName"));
+  const record2 = status;
+  const hasIdentity = typeof record2.playName === "string" && record2.playName.trim().length > 0 || typeof record2.name === "string" && record2.name.trim().length > 0 || Boolean(getStringField(record2.run, "playName"));
   if (hasIdentity) {
     return status;
   }
@@ -19609,9 +19714,9 @@ function formatSummaryScalar(value) {
   }
   return null;
 }
-function formatSummaryScalarParts(record, skipKeys = /* @__PURE__ */ new Set()) {
+function formatSummaryScalarParts(record2, skipKeys = /* @__PURE__ */ new Set()) {
   const parts = [];
-  for (const [key, value] of Object.entries(record)) {
+  for (const [key, value] of Object.entries(record2)) {
     if (skipKeys.has(key)) {
       continue;
     }
@@ -19638,13 +19743,13 @@ function formatTopValuesPart(value) {
   return `top_values=${entries.map(([topValue, count]) => `${topValue}=${String(count)}`).join(", ")}`;
 }
 function formatPackageDatasetSummaryLines(summary, indent2 = "    ") {
-  const record = readRecord(summary);
-  const columnStats = readRecord(record?.columnStats);
-  if (!record || !columnStats) {
+  const record2 = readRecord(summary);
+  const columnStats = readRecord(record2?.columnStats);
+  if (!record2 || !columnStats) {
     return [];
   }
   const lines = [];
-  const rowCounts = readRecord(record.rowCounts);
+  const rowCounts = readRecord(record2.rowCounts);
   if (rowCounts) {
     const persisted = readNonNegativeInteger(rowCounts.persisted);
     const succeeded = readNonNegativeInteger(rowCounts.succeeded);
@@ -19660,7 +19765,7 @@ function formatPackageDatasetSummaryLines(summary, indent2 = "    ") {
     }
   }
   const parts = formatSummaryScalarParts(
-    record,
+    record2,
     /* @__PURE__ */ new Set(["columnStats", "rowCounts"])
   );
   if (parts.length > 0) {
@@ -19690,35 +19795,35 @@ function actionToCommand(action) {
   if (!action || typeof action !== "object" || Array.isArray(action)) {
     return null;
   }
-  const record = action;
-  if (typeof record.command === "string" && record.command.trim()) {
-    return record.command.trim();
+  const record2 = action;
+  if (typeof record2.command === "string" && record2.command.trim()) {
+    return record2.command.trim();
   }
-  if (record.kind === "deepline_run_inspect" && typeof record.runId === "string") {
-    return `deepline runs get ${record.runId} --json`;
+  if (record2.kind === "deepline_run_inspect" && typeof record2.runId === "string") {
+    return `deepline runs get ${record2.runId} --json`;
   }
-  if (record.kind === "deepline_run_full" && typeof record.runId === "string") {
-    return `deepline runs get ${record.runId} --full --json`;
+  if (record2.kind === "deepline_run_full" && typeof record2.runId === "string") {
+    return `deepline runs get ${record2.runId} --full --json`;
   }
-  if (record.kind === "deepline_run_billing" && typeof record.runId === "string") {
-    return `deepline runs get ${record.runId} --full --json | jq '.billing'`;
+  if (record2.kind === "deepline_run_billing" && typeof record2.runId === "string") {
+    return `deepline runs get ${record2.runId} --full --json | jq '.billing'`;
   }
-  if (record.kind === "deepline_run_export" && typeof record.runId === "string" && typeof record.datasetPath === "string") {
-    return `deepline runs export ${record.runId} --dataset ${shellSingleQuote(
-      record.datasetPath
-    )} --out ${shellSingleQuote(`${record.datasetPath.split(".").pop() || "dataset"}.csv`)}`;
+  if (record2.kind === "deepline_run_export" && typeof record2.runId === "string" && typeof record2.datasetPath === "string") {
+    return `deepline runs export ${record2.runId} --dataset ${shellSingleQuote(
+      record2.datasetPath
+    )} --out ${shellSingleQuote(`${record2.datasetPath.split(".").pop() || "dataset"}.csv`)}`;
   }
-  if (record.kind === "deepline_run_logs") {
-    if (typeof record.command === "string" && record.command.trim()) {
-      return record.command;
+  if (record2.kind === "deepline_run_logs") {
+    if (typeof record2.command === "string" && record2.command.trim()) {
+      return record2.command;
     }
-    if (typeof record.runId === "string") {
-      return record.view === "failed" ? `deepline runs get ${record.runId} --log-failed --json` : `deepline runs logs ${record.runId} --json`;
+    if (typeof record2.runId === "string") {
+      return record2.view === "failed" ? `deepline runs get ${record2.runId} --log-failed --json` : `deepline runs logs ${record2.runId} --json`;
     }
   }
-  if (record.kind === "deepline_db_query" && typeof record.sql === "string") {
-    const maxRows = typeof record.maxRows === "number" && Number.isFinite(record.maxRows) ? Math.trunc(record.maxRows) : 20;
-    return `deepline db query --sql ${shellSingleQuote(record.sql)} --max-rows ${maxRows} --json`;
+  if (record2.kind === "deepline_db_query" && typeof record2.sql === "string") {
+    const maxRows = typeof record2.maxRows === "number" && Number.isFinite(record2.maxRows) ? Math.trunc(record2.maxRows) : 20;
+    return `deepline db query --sql ${shellSingleQuote(record2.sql)} --max-rows ${maxRows} --json`;
   }
   return null;
 }
@@ -20123,12 +20228,12 @@ function exportableSheetRow(row) {
   if (!row || typeof row !== "object" || Array.isArray(row)) {
     return null;
   }
-  const record = row;
-  const data = record.data;
+  const record2 = row;
+  const data = record2.data;
   if (data && typeof data === "object" && !Array.isArray(data)) {
     return data;
   }
-  const fallback = { ...record };
+  const fallback = { ...record2 };
   for (const key of [
     "key",
     "status",
@@ -20480,8 +20585,8 @@ var PLAY_SYNTAX_MIGRATION_ERROR_MARKERS = [
   "ctx.map(...) has been replaced by ctx.dataset(...)",
   "Dataset .step(...) has been replaced by .withColumn(...)"
 ];
-function stringArrayField(record, key) {
-  const value = record[key];
+function stringArrayField(record2, key) {
+  const value = record2[key];
   if (!Array.isArray(value)) return [];
   return value.filter((entry) => typeof entry === "string");
 }
@@ -23654,10 +23759,16 @@ Concepts:
 Authoring:
   Use normal TypeScript interpolation for human-facing strings:
     const readyMessage = \`Put \${input.title} through to send-ready.\`;
-  An authored diagram is optional. Docflow parses only an explicit
+  An authored diagram is optional but highly recommended for every new or
+  substantially changed Play. Docflow parses only an explicit
   /** @mermaid ... */ block and its // @mermaid-node annotations; ordinary
   prose comments are never Docflow syntax. When Docflow is enabled, plays check
-  gives missing diagrams a non-blocking visualization warning.
+  gives missing diagrams a high-priority, non-blocking warning with the exact
+  Mermaid repair steps. Without a diagram, users see only an inferred execution
+  graph rather than a clear business-language map. It is easy to add: write a
+  short top-of-file flowchart, annotate its visible executable steps, then run
+  plays check again. Treat that warning as an authoring task before finishing
+  Play work unless the caller explicitly asks to leave the inferred graph.
 
 Common commands:
   deepline plays search email --json
@@ -26253,7 +26364,7 @@ function emitEnrichDebug(message) {
   );
 }
 function sleep6(ms) {
-  return new Promise((resolve20) => setTimeout(resolve20, ms));
+  return new Promise((resolve21) => setTimeout(resolve21, ms));
 }
 function enrichExportBackingRowsWaitMs() {
   const raw = process.env.DEEPLINE_ENRICH_EXPORT_BACKING_ROWS_WAIT_MS?.trim();
@@ -26362,9 +26473,9 @@ async function expandCompiledConfigAtFiles(value) {
   if (!value || typeof value !== "object") {
     return value;
   }
-  const record = value;
+  const record2 = value;
   const expanded = {};
-  for (const [key, entry] of Object.entries(record)) {
+  for (const [key, entry] of Object.entries(record2)) {
     expanded[key] = await expandCompiledConfigAtFiles(entry);
   }
   for (const field of ["extract_js", "run_if_js"]) {
@@ -27162,26 +27273,26 @@ function readFirstEnrichDatasetActions(value) {
       }
       return null;
     }
-    const record = candidate;
-    const actions = isRecord11(record.actions) ? record.actions : null;
+    const record2 = candidate;
+    const actions = isRecord11(record2.actions) ? record2.actions : null;
     const currentQuery = isRecord11(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
     const legacyQuery = isRecord11(actions?.query) ? actions.query : null;
     const query = currentQuery?.kind === "deepline_db_query" ? currentQuery : legacyQuery?.kind === "deepline_db_query" ? legacyQuery : null;
     if (query?.kind === "deepline_db_query") {
       return {
-        dataset: record,
+        dataset: record2,
         query,
         ...isRecord11(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
       };
     }
-    if (options.allowLegacy && record.kind === "dataset" && typeof record.queryDatasetCommand === "string" && record.queryDatasetCommand.trim()) {
+    if (options.allowLegacy && record2.kind === "dataset" && typeof record2.queryDatasetCommand === "string" && record2.queryDatasetCommand.trim()) {
       return {
-        dataset: record,
-        queryDatasetCommand: record.queryDatasetCommand.trim(),
-        ...typeof record.slowExportAsCsvCommand === "string" && record.slowExportAsCsvCommand.trim() ? { slowExportAsCsvCommand: record.slowExportAsCsvCommand.trim() } : {}
+        dataset: record2,
+        queryDatasetCommand: record2.queryDatasetCommand.trim(),
+        ...typeof record2.slowExportAsCsvCommand === "string" && record2.slowExportAsCsvCommand.trim() ? { slowExportAsCsvCommand: record2.slowExportAsCsvCommand.trim() } : {}
       };
     }
-    for (const [key, entry] of Object.entries(record)) {
+    for (const [key, entry] of Object.entries(record2)) {
       if (key === "preview") {
         continue;
       }
@@ -27197,8 +27308,8 @@ function readFirstEnrichDatasetActions(value) {
   seen.clear();
   return walk(value, { allowLegacy: true });
 }
-function actionStringField(record, key) {
-  const value = record[key];
+function actionStringField(record2, key) {
+  const value = record2[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function parseSqlFromDbQueryCommand(command) {
@@ -27542,12 +27653,12 @@ function collectStringFields(value, key, output2, depth = 0) {
     }
     return;
   }
-  const record = value;
-  const direct = record[key];
+  const record2 = value;
+  const direct = record2[key];
   if (typeof direct === "string" && direct.trim()) {
     output2.add(direct.trim());
   }
-  for (const child of Object.values(record)) {
+  for (const child of Object.values(record2)) {
     collectStringFields(child, key, output2, depth + 1);
   }
 }
@@ -27733,23 +27844,23 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
   if (!row || typeof row !== "object" || Array.isArray(row)) {
     return null;
   }
-  const record = row;
-  const data = record.data;
+  const record2 = row;
+  const data = record2.data;
   if (data && typeof data === "object" && !Array.isArray(data)) {
     const exported = { ...data };
     applyFailureCellMeta(exported, exported[ENRICH_CELL_META_FIELD], {
-      rowError: record.error
+      rowError: record2.error
     });
-    applyFailureCellMeta(exported, record.cellMeta, { rowError: record.error });
-    applyFailureCellMeta(exported, record.cellMetaPatch, {
-      rowError: record.error
+    applyFailureCellMeta(exported, record2.cellMeta, { rowError: record2.error });
+    applyFailureCellMeta(exported, record2.cellMetaPatch, {
+      rowError: record2.error
     });
-    applyFailureCellMeta(exported, record[ENRICH_CELL_META_PATCH_FIELD], {
-      rowError: record.error
+    applyFailureCellMeta(exported, record2[ENRICH_CELL_META_PATCH_FIELD], {
+      rowError: record2.error
     });
     delete exported[ENRICH_CELL_META_FIELD];
     delete exported[ENRICH_CELL_META_PATCH_FIELD];
-    const inputIndex = typeof record.inputIndex === "number" ? record.inputIndex : typeof record.inputIndex === "string" && record.inputIndex.trim() ? Number(record.inputIndex) : Number.NaN;
+    const inputIndex = typeof record2.inputIndex === "number" ? record2.inputIndex : typeof record2.inputIndex === "string" && record2.inputIndex.trim() ? Number(record2.inputIndex) : Number.NaN;
     if (Number.isInteger(inputIndex) && inputIndex >= 0) {
       if (ENRICH_SOURCE_ROW_INDEX_COLUMN in exported) {
         exported[ENRICH_ORIGINAL_SOURCE_ROW_INDEX_COLUMN] = exported[ENRICH_SOURCE_ROW_INDEX_COLUMN];
@@ -27758,18 +27869,18 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
     }
     return exported;
   }
-  const fallback = { ...record };
+  const fallback = { ...record2 };
   applyFailureCellMeta(fallback, fallback[ENRICH_CELL_META_FIELD], {
-    rowError: record.error
+    rowError: record2.error
   });
-  applyFailureCellMeta(fallback, record.cellMeta, {
-    rowError: record.error
+  applyFailureCellMeta(fallback, record2.cellMeta, {
+    rowError: record2.error
   });
-  applyFailureCellMeta(fallback, record.cellMetaPatch, {
-    rowError: record.error
+  applyFailureCellMeta(fallback, record2.cellMetaPatch, {
+    rowError: record2.error
   });
   applyFailureCellMeta(fallback, fallback[ENRICH_CELL_META_PATCH_FIELD], {
-    rowError: record.error
+    rowError: record2.error
   });
   for (const key of [
     "key",
@@ -27988,16 +28099,16 @@ function isWaterfallResultMeaningful(value) {
     return value.some(isWaterfallResultMeaningful);
   }
   if (value && typeof value === "object") {
-    const record = value;
-    const status = typeof record.status === "string" ? record.status.trim().toLowerCase() : "";
+    const record2 = value;
+    const status = typeof record2.status === "string" ? record2.status.trim().toLowerCase() : "";
     if (status === "error" || status === "failed") {
       return false;
     }
-    if (typeof record.error === "string" && record.error.trim()) {
+    if (typeof record2.error === "string" && record2.error.trim()) {
       return false;
     }
-    if (Object.prototype.hasOwnProperty.call(record, "matched_result")) {
-      return isWaterfallResultMeaningful(record.matched_result);
+    if (Object.prototype.hasOwnProperty.call(record2, "matched_result")) {
+      return isWaterfallResultMeaningful(record2.matched_result);
     }
     for (const key of [
       "value",
@@ -28012,11 +28123,11 @@ function isWaterfallResultMeaningful(value) {
       "result",
       "data"
     ]) {
-      if (isWaterfallResultMeaningful(record[key])) {
+      if (isWaterfallResultMeaningful(record2[key])) {
         return true;
       }
     }
-    return Object.entries(record).some(
+    return Object.entries(record2).some(
       ([key, entry]) => !ENRICH_FLATTENED_CONTROL_FIELDS.has(key) && isWaterfallResultMeaningful(entry)
     );
   }
@@ -28032,8 +28143,8 @@ function stableRowSnapshot(value) {
     return `[${value.map(stableRowSnapshot).join(",")}]`;
   }
   if (value && typeof value === "object") {
-    const record = value;
-    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableRowSnapshot(record[key])}`).join(",")}}`;
+    const record2 = value;
+    return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${stableRowSnapshot(record2[key])}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
@@ -28620,8 +28731,8 @@ function addEnrichFollowUpCommand(commands, seen, command) {
   seen.add(normalized);
   commands.push({ ...command, command: normalized });
 }
-function datasetSelectorForEnrichCommand(record, fallbackPath) {
-  const candidates = [record.path, record.tableNamespace, fallbackPath];
+function datasetSelectorForEnrichCommand(record2, fallbackPath) {
+  const candidates = [record2.path, record2.tableNamespace, fallbackPath];
   for (const candidate of candidates) {
     if (typeof candidate === "string" && candidate.trim()) {
       return candidate.trim();
@@ -28683,19 +28794,19 @@ function collectDatasetFollowUpCommands(value, state) {
     );
     return;
   }
-  const record = value;
-  const isDataset = record.kind === "dataset";
+  const record2 = value;
+  const isDataset = record2.kind === "dataset";
   if (isDataset) {
-    const selector = datasetSelectorForEnrichCommand(record, state.path);
-    const labelPath = typeof record.path === "string" && record.path.trim() ? record.path.trim() : selector ?? state.path;
-    if (typeof record.queryDatasetCommand === "string") {
+    const selector = datasetSelectorForEnrichCommand(record2, state.path);
+    const labelPath = typeof record2.path === "string" && record2.path.trim() ? record2.path.trim() : selector ?? state.path;
+    if (typeof record2.queryDatasetCommand === "string") {
       addEnrichFollowUpCommand(state.commands, state.seen, {
         label: `query ${labelPath}`,
         path: labelPath,
-        command: record.queryDatasetCommand
+        command: record2.queryDatasetCommand
       });
     }
-    const exportCommand = typeof record.slowExportAsCsvCommand === "string" ? record.slowExportAsCsvCommand : typeof record.fullExportCommand === "string" ? record.fullExportCommand : null;
+    const exportCommand = typeof record2.slowExportAsCsvCommand === "string" ? record2.slowExportAsCsvCommand : typeof record2.fullExportCommand === "string" ? record2.fullExportCommand : null;
     if (exportCommand) {
       addEnrichFollowUpCommand(state.commands, state.seen, {
         label: `export ${labelPath}`,
@@ -28712,7 +28823,7 @@ function collectDatasetFollowUpCommands(value, state) {
       });
     }
   }
-  for (const [key, child] of Object.entries(record)) {
+  for (const [key, child] of Object.entries(record2)) {
     if (key === "preview" || key === "access") {
       continue;
     }
@@ -30137,9 +30248,9 @@ function readCodexSessionId(filePath) {
     )) {
       const parsed = parseJsonLine(line);
       if (!parsed || typeof parsed !== "object") continue;
-      const record = parsed;
-      const payload = record.payload && typeof record.payload === "object" ? record.payload : null;
-      const id = record.type === "session_meta" && typeof payload?.id === "string" ? payload.id : null;
+      const record2 = parsed;
+      const payload = record2.payload && typeof record2.payload === "object" ? record2.payload : null;
+      const id = record2.type === "session_meta" && typeof payload?.id === "string" ? payload.id : null;
       if (id && UUID_RE.test(id)) return id;
     }
   } catch {
@@ -30238,15 +30349,15 @@ function messageContentKey(value) {
   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 ?? "");
+    const record2 = block;
+    const type = String(record2.type ?? "");
     if (type === "tool_use") {
-      return `tool_use:${String(record.name ?? "")}:${String(record.id ?? "")}`;
+      return `tool_use:${String(record2.name ?? "")}:${String(record2.id ?? "")}`;
     }
     if (type === "tool_result") {
-      return `tool_result:${String(record.tool_use_id ?? "")}`;
+      return `tool_result:${String(record2.tool_use_id ?? "")}`;
     }
-    return String(record.text ?? type);
+    return String(record2.text ?? type);
   }).join("\n");
 }
 function dedupConsecutiveEvents(raw) {
@@ -30261,9 +30372,9 @@ function dedupConsecutiveEvents(raw) {
       index += 1;
       continue;
     }
-    const record = event;
-    const eventType = String(record.type ?? "");
-    const eventKey = messageContentKey(record);
+    const record2 = event;
+    const eventType = String(record2.type ?? "");
+    const eventKey = messageContentKey(record2);
     if (!["user", "assistant"].includes(eventType) || !eventKey) {
       output2.push(rawLines[index] ?? "");
       index += 1;
@@ -30282,9 +30393,9 @@ function dedupConsecutiveEvents(raw) {
       cursor += 1;
     }
     if (runCount > 1) {
-      record._repeat_count = runCount;
-      record._repeat_summary = `${runCount} consecutive identical ${eventType} messages collapsed`;
-      output2.push(JSON.stringify(record));
+      record2._repeat_count = runCount;
+      record2._repeat_summary = `${runCount} consecutive identical ${eventType} messages collapsed`;
+      output2.push(JSON.stringify(record2));
       index = cursor;
       continue;
     }
@@ -30329,9 +30440,9 @@ function selectiveCompactToolResults(raw) {
       lines.push(line);
       continue;
     }
-    const record = parsed;
-    if (record.type === "user") {
-      const message = record.message;
+    const record2 = parsed;
+    if (record2.type === "user") {
+      const message = record2.message;
       const content = message && typeof message === "object" ? message.content : null;
       if (Array.isArray(content)) {
         message.content = content.map(
@@ -30339,7 +30450,7 @@ function selectiveCompactToolResults(raw) {
         );
       }
     }
-    lines.push(JSON.stringify(record));
+    lines.push(JSON.stringify(record2));
   }
   return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf8");
@@ -30365,15 +30476,15 @@ function compactCodexEvents(raw) {
       lines.push(rawLines[index] ?? "");
       return;
     }
-    const record = event;
-    if (record.type === "world_state") return;
-    const payload = record.payload;
+    const record2 = event;
+    if (record2.type === "world_state") return;
+    const payload = record2.payload;
     const payloadType = payload && typeof payload === "object" ? String(payload.type ?? "") : "";
     if (payloadType === "token_count" && index !== lastTokenCountIndex) return;
     if (payloadType === "custom_tool_call_output" || payloadType === "function_call_output" || payloadType === "tool_search_output") {
       const record_payload = payload;
       record_payload.output = compactEventValue(record_payload.output);
-      lines.push(JSON.stringify(record));
+      lines.push(JSON.stringify(record2));
       return;
     }
     lines.push(rawLines[index] ?? "");
@@ -30836,8 +30947,325 @@ Examples:
 }
 
 // src/cli/commands/monitors.ts
+var import_node_crypto8 = require("crypto");
 var import_node_fs14 = require("fs");
+var import_node_path17 = require("path");
 var import_promises8 = require("readline/promises");
+
+// src/monitor-fleet-contract.ts
+var MONITOR_FLEET_MAX_MEMBERS = 1e3;
+var MONITOR_FLEET_AUTHORING_CONTRACT_EDITION = 1;
+var SUPPORTED_MONITOR_FLEET_AUTHORING_CONTRACT_EDITIONS = [
+  MONITOR_FLEET_AUTHORING_CONTRACT_EDITION
+];
+var MONITOR_FLEET_REMOVAL_GRACE_MS = 7 * 24 * 60 * 6e4;
+var MONITOR_FLEET_DOCUMENTATION = {
+  summary: "A Monitor Fleet keeps one bounded, sticky set of ordinary monitors aligned with Customer DB rows.",
+  authoredFields: {
+    id: "Stable lowercase fleet id used by sync, pause, resume, and deactivate.",
+    source: "Customer DB table, unique row key, and optional equality filters that select candidate rows.",
+    member: "Ordinary monitor tool, stable key template, and payload evaluated for each selected source row.",
+    selection: "Deterministic ranking and an active-member limit between 1 and 1,000."
+  },
+  fixedPolicy: {
+    cadence: "daily",
+    membership: "sticky",
+    removalGrace: "7d",
+    onRemoved: "deactivate",
+    ownership: "A Fleet may adopt a same-tool ordinary monitor with its deterministic member key. The first Fleet claim wins; another Fleet or a different tool receives a conflict.",
+    billing: "No Fleet fee, permit, or renewal. Dry-run reports ordinary monitor lifecycle charges due now."
+  },
+  stickyMembership: "Ranking fills vacancies but never replaces a current member merely because another row ranks higher.",
+  columnExpression: 'Use { "$fleet": "column", "name": "column_name" } in a member key or payload to read a value from each source row.'
+};
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function identifier(value) {
+  return typeof value === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+function exactKeys(input2, keys, path, issues) {
+  if (!input2) return;
+  for (const key of Object.keys(input2)) {
+    if (keys.includes(key)) continue;
+    issues.push({
+      path: path ? `${path}.${key}` : key,
+      code: "unknown_fleet_field",
+      message: `${path || "Fleet"} does not accept '${key}'.`
+    });
+  }
+}
+function jsonValue(value, path, issues) {
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => jsonValue(item, `${path}.${index}`, issues));
+    return;
+  }
+  const input2 = record(value);
+  if (!input2) {
+    issues.push({
+      path,
+      code: "invalid_fleet_json_value",
+      message: "Fleet payload values must be JSON values."
+    });
+    return;
+  }
+  for (const [key, item] of Object.entries(input2)) {
+    jsonValue(item, `${path}.${key}`, issues);
+  }
+}
+function validateExpression(value, path, issues) {
+  const input2 = record(value);
+  if (!input2 || input2.$fleet !== "column" || !identifier(input2.name)) {
+    issues.push({
+      path,
+      code: "invalid_fleet_expression",
+      message: "Fleet expressions must be an exact tagged column reference."
+    });
+    return;
+  }
+  exactKeys(input2, ["$fleet", "name"], path, issues);
+}
+function walkPayload(value, path, issues) {
+  if (Array.isArray(value)) {
+    value.forEach(
+      (item, index) => walkPayload(item, `${path}.${index}`, issues)
+    );
+    return;
+  }
+  const input2 = record(value);
+  if (!input2) return;
+  if ("$fleet" in input2) {
+    validateExpression(input2, path, issues);
+    return;
+  }
+  for (const [key, item] of Object.entries(input2)) {
+    walkPayload(item, `${path}.${key}`, issues);
+  }
+}
+function validateMonitorFleetDefinition(value) {
+  const issues = [];
+  const input2 = record(value);
+  if (!input2) {
+    return {
+      valid: false,
+      issues: [
+        {
+          path: "",
+          code: "invalid_fleet",
+          message: "Fleet must be an object."
+        }
+      ]
+    };
+  }
+  exactKeys(input2, ["id", "source", "member", "selection"], "", issues);
+  if (typeof input2.id !== "string" || !/^[a-z][a-z0-9-]{0,199}$/.test(input2.id)) {
+    issues.push({
+      path: "id",
+      code: "invalid_fleet_id",
+      message: "Fleet id must be lowercase kebab-case."
+    });
+  }
+  const source = record(input2.source);
+  exactKeys(
+    source,
+    ["kind", "schema", "table", "key", "where"],
+    "source",
+    issues
+  );
+  if (!source || source.kind !== "customer_db_table") {
+    issues.push({
+      path: "source.kind",
+      code: "invalid_fleet_source",
+      message: "Beta fleets require customer_db_table."
+    });
+  }
+  if (!identifier(source?.schema) || !identifier(source?.table)) {
+    issues.push({
+      path: "source",
+      code: "invalid_fleet_table",
+      message: "Source schema and table must be SQL identifiers."
+    });
+  }
+  const sourceKey = record(source?.key);
+  exactKeys(sourceKey, ["column", "type"], "source.key", issues);
+  if (!sourceKey || !identifier(sourceKey.column) || !["text", "uuid", "int4", "int8"].includes(String(sourceKey.type))) {
+    issues.push({
+      path: "source.key",
+      code: "invalid_fleet_source_key",
+      message: "Source key must name a supported typed column."
+    });
+  }
+  if (source?.where !== void 0) {
+    const where = record(source.where);
+    if (!where) {
+      issues.push({
+        path: "source.where",
+        code: "invalid_fleet_where",
+        message: "source.where must be an object of equality values."
+      });
+    } else {
+      for (const [column, expected] of Object.entries(where)) {
+        if (!identifier(column)) {
+          issues.push({
+            path: `source.where.${column}`,
+            code: "invalid_fleet_where_column",
+            message: "source.where keys must be SQL identifiers."
+          });
+        }
+        if (expected !== null && typeof expected !== "string" && typeof expected !== "boolean" && !(typeof expected === "number" && Number.isFinite(expected))) {
+          issues.push({
+            path: `source.where.${column}`,
+            code: "invalid_fleet_where_value",
+            message: "source.where values must be finite JSON scalars or null."
+          });
+        }
+      }
+    }
+  }
+  const member = record(input2.member);
+  exactKeys(member, ["tool", "key", "payload"], "member", issues);
+  const key = record(member?.key);
+  if (!member || typeof member.tool !== "string" || !member.tool.trim()) {
+    issues.push({
+      path: "member.tool",
+      code: "invalid_fleet_tool",
+      message: "Member tool is required."
+    });
+  }
+  if (!key || key.$fleet !== "template" || !Array.isArray(key.parts) || key.parts.length === 0) {
+    issues.push({
+      path: "member.key",
+      code: "invalid_fleet_key",
+      message: "Member key must be a tagged fleet template."
+    });
+  } else {
+    exactKeys(key, ["$fleet", "parts"], "member.key", issues);
+    for (const [index, part] of key.parts.entries()) {
+      if (typeof part !== "string")
+        validateExpression(part, `member.key.parts.${index}`, issues);
+    }
+    if (sourceKey && !key.parts.some(
+      (part) => record(part)?.$fleet === "column" && record(part)?.name === sourceKey.column
+    )) {
+      issues.push({
+        path: "member.key.parts",
+        code: "fleet_key_missing_source_key",
+        message: "Member key must include the source key column."
+      });
+    }
+  }
+  if (!member || !("payload" in member)) {
+    issues.push({
+      path: "member.payload",
+      code: "invalid_fleet_payload",
+      message: "Member payload is required."
+    });
+  } else {
+    jsonValue(member.payload, "member.payload", issues);
+  }
+  walkPayload(member?.payload, "member.payload", issues);
+  const selection = record(input2.selection);
+  exactKeys(selection, ["limit", "orderBy", "membership"], "selection", issues);
+  if (!selection || !Number.isSafeInteger(selection.limit) || Number(selection.limit) < 1 || Number(selection.limit) > MONITOR_FLEET_MAX_MEMBERS) {
+    issues.push({
+      path: "selection.limit",
+      code: "MONITOR_FLEET_LIMIT_EXCEEDED",
+      message: "selection.limit must be between 1 and 1,000."
+    });
+  }
+  if (selection?.membership !== "sticky") {
+    issues.push({
+      path: "selection.membership",
+      code: "invalid_fleet_membership",
+      message: `Fleet membership is fixed to ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.membership}. ${MONITOR_FLEET_DOCUMENTATION.stickyMembership}`
+    });
+  }
+  const orderBy = selection?.orderBy;
+  if (!Array.isArray(orderBy) || orderBy.length === 0) {
+    issues.push({
+      path: "selection.orderBy",
+      code: "invalid_fleet_order",
+      message: "At least one deterministic order field is required."
+    });
+  } else {
+    const orderColumns = /* @__PURE__ */ new Set();
+    for (const [index, order] of orderBy.entries()) {
+      const item = record(order);
+      exactKeys(
+        item,
+        ["column", "direction"],
+        `selection.orderBy.${index}`,
+        issues
+      );
+      if (!item || !identifier(item.column) || !["asc", "desc"].includes(String(item.direction))) {
+        issues.push({
+          path: `selection.orderBy.${index}`,
+          code: "invalid_fleet_order",
+          message: "Order fields need a column and asc/desc direction."
+        });
+      } else if (orderColumns.has(item.column)) {
+        issues.push({
+          path: `selection.orderBy.${index}.column`,
+          code: "duplicate_fleet_order_column",
+          message: "Each selection order column may appear only once."
+        });
+      } else {
+        orderColumns.add(item.column);
+      }
+    }
+    if (sourceKey && record(orderBy.at(-1))?.column !== sourceKey.column) {
+      issues.push({
+        path: "selection.orderBy",
+        code: "fleet_order_missing_key",
+        message: "The final order field must be the source key."
+      });
+    }
+  }
+  for (const removedOption of ["spendLimits", "lifecycle", "reconciliation"]) {
+    if (removedOption in input2) {
+      issues.push({
+        path: removedOption,
+        code: "unsupported_fleet_option",
+        message: `${removedOption} is fixed by Monitor Fleets and must be omitted. Fleets sync ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.cadence} and ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.onRemoved} members after ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.removalGrace} absent from the source.`
+      });
+    }
+  }
+  return issues.length === 0 ? { valid: true, definition: value, issues } : { valid: false, issues };
+}
+function admitMonitorFleetAuthoringContract(value, edition = MONITOR_FLEET_AUTHORING_CONTRACT_EDITION) {
+  if (!SUPPORTED_MONITOR_FLEET_AUTHORING_CONTRACT_EDITIONS.includes(
+    edition
+  )) {
+    return {
+      valid: false,
+      issues: [
+        {
+          path: "authoring_contract_edition",
+          code: "unsupported_fleet_authoring_contract_edition",
+          message: `Monitor Fleet authoring contract edition ${edition} is not supported.`
+        }
+      ]
+    };
+  }
+  const result = validateMonitorFleetDefinition(value);
+  return result.valid && result.definition ? {
+    valid: true,
+    contract: {
+      edition,
+      // JSON cloning prevents later caller mutation from changing the
+      // admitted snapshot.
+      definition: JSON.parse(
+        JSON.stringify(result.definition)
+      )
+    },
+    issues: []
+  } : { valid: false, issues: result.issues };
+}
+
+// src/cli/commands/monitors.ts
 var JSON_OPTION_DESCRIPTION = "Emit JSON output. Also automatic when stdout is piped";
 function withJsonOption(command) {
   return command.option("--json", JSON_OPTION_DESCRIPTION);
@@ -30859,6 +31287,7 @@ var MonitorDryRunUnsupportedError = class extends Error {
 };
 function monitorsErrorExitCode(error) {
   if (error instanceof MonitorsUsageError) return 2;
+  if (error instanceof MonitorFleetStateError) return 6;
   if (error instanceof AuthError) return 3;
   if (error instanceof DeeplineError) {
     const status = error.statusCode;
@@ -30869,12 +31298,14 @@ function monitorsErrorExitCode(error) {
   }
   return 5;
 }
-function monitorsFailureNextCommand(error, exitCode) {
+function monitorsFailureNextCommand(error, exitCode, options) {
+  if (error instanceof MonitorFleetStateError) return error.next;
   if (error instanceof DeeplineError) {
     const response = asRecord2(asRecord2(error.details)?.response);
-    const serverNextAction = asString(response?.next_action);
-    if (serverNextAction) return serverNextAction;
+    const serverNext = asString(response?.next) ?? asString(response?.next_action);
+    if (serverNext) return serverNext;
   }
+  if (exitCode === 5 && options?.retryCommand) return options.retryCommand;
   if (error instanceof DeeplineError && error.code === "monitor_access_required") {
     return "deepline monitors status";
   }
@@ -30900,9 +31331,10 @@ function readValidationIssues(error) {
     ];
   });
 }
-function reportMonitorsFailure(error) {
+function reportMonitorsFailure(error, options) {
   const exitCode = monitorsErrorExitCode(error);
-  const next = monitorsFailureNextCommand(error, exitCode);
+  const next = monitorsFailureNextCommand(error, exitCode, options);
+  const retrySafe = exitCode === 5 && options?.retryCommand !== void 0;
   const wantsJson = shouldEmitJson(process.argv.includes("--json"));
   if (wantsJson) {
     const payload = errorToJsonPayload(error);
@@ -30910,10 +31342,15 @@ function reportMonitorsFailure(error) {
       ok: false,
       exitCode,
       ...next ? { next } : {},
-      error: payload.error
+      ...retrySafe ? { retry_safe: true } : {},
+      error: retrySafe ? {
+        ...payload.error,
+        message: `${payload.error.message} ${FLEET_RETRY_SAFE_NOTE}`
+      } : payload.error
     });
   } else {
-    const message = error instanceof Error ? error.message : String(error);
+    const base = error instanceof Error ? error.message : String(error);
+    const message = retrySafe ? `${base} ${FLEET_RETRY_SAFE_NOTE}` : base;
     process.stderr.write(`Error: ${message}
 `);
     for (const issue of readValidationIssues(error)) {
@@ -31464,6 +31901,724 @@ async function handleMonitorsDeploy(definition, options) {
     text: renderMonitorDeployCompletion(payload)
   });
 }
+function fleetIntegerOption(raw, flag) {
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new MonitorsUsageError(`${flag} must be a non-negative integer.`);
+  }
+  return value;
+}
+function fleetIdempotencyKey(operation, supplied) {
+  const normalized = supplied?.trim();
+  if (supplied !== void 0 && !normalized) {
+    throw new MonitorsUsageError("--idempotency-key must not be empty.");
+  }
+  return normalized ?? `monitor-fleet-${operation}-${(0, import_node_crypto8.randomUUID)()}`;
+}
+var FLEET_COUNT_KEYS = [
+  "pending",
+  "submitting",
+  "rate_limited",
+  "settled",
+  "blocked",
+  "failed"
+];
+var FLEET_DEFAULT_WAIT_MS = 10 * 6e4;
+var FLEET_POLL_INTERVAL_MS = 2e3;
+var FLEET_PLAIN_PROGRESS_INTERVAL_MS = 15e3;
+var FLEET_RETRY_SAFE_NOTE = "Safe to retry \u2014 every fleet command is idempotent.";
+var MONITOR_FLEET_LIFECYCLE = [
+  {
+    step: 1,
+    what: "Write a definition file you can read and edit.",
+    command: "deepline monitors fleets init <fleet-id> --source public.accounts --key account_id --tool <tool> --payload '<json>' --out fleet.json"
+  },
+  {
+    step: 2,
+    what: "See the plan and the credits before anything changes.",
+    command: "deepline monitors fleets sync --file fleet.json --dry-run"
+  },
+  {
+    step: 3,
+    what: "Apply it and wait for the server to call it converged.",
+    command: "deepline monitors fleets sync --file fleet.json --wait"
+  },
+  {
+    step: 4,
+    what: "Read live state; add --drift to see what has not settled.",
+    command: "deepline monitors fleets get <fleet-id>"
+  }
+];
+var MONITOR_FLEET_COMMANDS = [
+  { name: "init", summary: "Write a Fleet definition JSON file." },
+  {
+    name: "sync",
+    summary: "Create or re-plan a fleet from a definition file or its stored config."
+  },
+  {
+    name: "get",
+    summary: "Read one fleet, list every fleet, or inspect drift."
+  },
+  {
+    name: "deactivate",
+    summary: "Deactivate a fleet and the monitors it owns."
+  }
+];
+var MONITOR_FLEET_AGENT_NOTES = [
+  "Add --json for stable output; stdout is always exactly one JSON object.",
+  "Every error includes a runnable `next` command \u2014 run it, do not guess.",
+  "Exit 5 = retry the same command; 6 = inspect counts with `get --drift`; 7 = change the request."
+];
+var MONITOR_FLEET_HELP_EPILOG = `
+Agent notes:
+  ${MONITOR_FLEET_AGENT_NOTES.join("\n  ")}
+`;
+var MonitorFleetStateError = class extends Error {
+  code;
+  next;
+  constructor(input2) {
+    super(input2.message);
+    this.name = "MonitorFleetStateError";
+    this.code = input2.code;
+    this.next = input2.next;
+  }
+};
+function fleetCounts(payload) {
+  const raw = asRecord2(payload.counts) ?? {};
+  const counts = {};
+  for (const key of FLEET_COUNT_KEYS) {
+    counts[key] = asFiniteNumber(raw[key]) ?? 0;
+  }
+  return counts;
+}
+function fleetShellArg(value) {
+  return /^[A-Za-z0-9._/@:=-]+$/.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function fleetJsonFlag(options) {
+  return options.json ? ["--json"] : [];
+}
+function fleetTimeoutMs(raw) {
+  if (raw === void 0) return FLEET_DEFAULT_WAIT_MS;
+  const match = /^(\d+)(ms|s|m|h)?$/.exec(raw.trim());
+  if (!match) {
+    throw new MonitorsUsageError(
+      "--timeout must be a duration like 500ms, 90s, 10m, or 1h (a bare number is seconds)."
+    );
+  }
+  const value = Number(match[1]);
+  if (!value) {
+    throw new MonitorsUsageError("--timeout must be greater than zero.");
+  }
+  const unit = match[2] ?? "s";
+  const factor = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
+  return value * factor;
+}
+function fleetServerNext(payload) {
+  return asString(payload.next) ?? asString(payload.next_action);
+}
+function fleetStatus(payload) {
+  return asString(payload.status);
+}
+function fleetProgressReporter() {
+  const interactive = process.stderr.isTTY === true;
+  let wrote = false;
+  let lastPlainAt = 0;
+  return {
+    report: (payload) => {
+      const counts = fleetCounts(payload);
+      const expected = asFiniteNumber(payload.expected) ?? FLEET_COUNT_KEYS.reduce((sum, key) => sum + counts[key], 0);
+      const line = `settled ${counts.settled}/${expected} \xB7 rate_limited ${counts.rate_limited} \xB7 blocked ${counts.blocked}`;
+      if (interactive) {
+        process.stderr.write(`\r\x1B[2K${line}`);
+        wrote = true;
+        return;
+      }
+      const now = Date.now();
+      if (wrote && now - lastPlainAt < FLEET_PLAIN_PROGRESS_INTERVAL_MS) return;
+      lastPlainAt = now;
+      wrote = true;
+      process.stderr.write(`${line}
+`);
+    },
+    finish: () => {
+      if (interactive && wrote) process.stderr.write("\n");
+    }
+  };
+}
+function fleetPlanLine(payload) {
+  const plan = asRecord2(payload.plan) ?? {};
+  const blocked = asRecord2(plan.blocked) ?? {};
+  const entries = Object.entries(blocked).flatMap(([limitId, raw]) => {
+    const count = asFiniteNumber(raw);
+    return count === void 0 ? [] : [[limitId, count]];
+  }).sort(([left], [right]) => left.localeCompare(right));
+  const blockedTotal = entries.reduce((sum, [, count]) => sum + count, 0);
+  const detail = entries.length === 0 ? "" : entries.length === 1 ? ` (${entries[0][0]})` : ` (${entries.map(([id, count]) => `${id}: ${count}`).join(", ")})`;
+  return [
+    `creates ${asFiniteNumber(plan.creates) ?? 0}`,
+    `updates ${asFiniteNumber(plan.updates) ?? 0}`,
+    `removes ${asFiniteNumber(plan.removes) ?? 0}`,
+    `blocked ${blockedTotal}${detail}`
+  ].join(" \xB7 ");
+}
+function fleetCountsLine(payload) {
+  const counts = fleetCounts(payload);
+  return FLEET_COUNT_KEYS.map((key) => `${key} ${counts[key]}`).join(" \xB7 ");
+}
+function renderFleetSync(payload, input2) {
+  const lines = [
+    input2.dryRun ? `Fleet ${input2.fleetId} \u2014 plan only, nothing changed` : `Fleet ${input2.fleetId} \u2014 accepted`,
+    `  plan  ${fleetPlanLine(payload)}`
+  ];
+  const credits = asFiniteNumber(payload.credits_due_now);
+  lines.push(`  credits due now  ${credits ?? 0}`);
+  lines.push(
+    `  generation ${asFiniteNumber(payload.generation) ?? "unknown"} \xB7 replayed ${yesNo(
+      payload.replayed
+    )} \xB7 idempotency key ${input2.idempotencyKey}`
+  );
+  const next = fleetServerNext(payload);
+  if (next) lines.push(`Next: ${next}`);
+  return `${lines.join("\n")}
+`;
+}
+function renderFleetGet(payload) {
+  const id = asString(payload.id) ?? "unknown";
+  const status = fleetStatus(payload) ?? "unknown";
+  const lines = [
+    `Fleet ${id} \u2014 ${status}`,
+    `  monitors  ${asFiniteNumber(payload.live) ?? 0} live / ${asFiniteNumber(payload.expected) ?? 0} expected`,
+    `  counts  ${fleetCountsLine(payload)}`,
+    `  generation ${asFiniteNumber(payload.generation) ?? "unknown"} \xB7 converged generation ${asFiniteNumber(payload.converged_generation) ?? "none"}`
+  ];
+  lines.push(...renderFleetDriftRows(payload));
+  const next = fleetServerNext(payload) ?? (status === "degraded" ? `deepline monitors fleets get ${fleetShellArg(id)} --drift` : void 0);
+  if (next) lines.push(`Next: ${next}`);
+  return `${lines.join("\n")}
+`;
+}
+function renderFleetDriftRows(payload) {
+  const drift = Array.isArray(payload.drift) ? payload.drift : void 0;
+  if (!drift) return [];
+  const rows = drift.flatMap((raw) => {
+    const row = asRecord2(raw);
+    return row ? [row] : [];
+  }).map((row) => ({
+    monitorKey: asString(row.monitor_key) ?? "-",
+    entityKey: asString(row.entity_key) ?? "-",
+    convergence: asString(row.convergence) ?? "-",
+    since: asString(row.since) ?? "-",
+    detail: asString(row.error) ?? (asString(row.blocked_by) ? `blocked_by ${asString(row.blocked_by)}` : asString(row.next_attempt_at) ? `next_attempt_at ${asString(row.next_attempt_at)}` : "")
+  })).sort(
+    (left, right) => left.monitorKey.localeCompare(right.monitorKey) || left.entityKey.localeCompare(right.entityKey)
+  );
+  if (rows.length === 0) {
+    return [`  drift  none${payload.truncated === true ? " (truncated)" : ""}`];
+  }
+  const width = (values) => values.reduce((max, value) => Math.max(max, value.length), 0);
+  const monitorWidth = width(rows.map((row) => row.monitorKey));
+  const entityWidth = width(rows.map((row) => row.entityKey));
+  const convergenceWidth = width(rows.map((row) => row.convergence));
+  const lines = [
+    `  drift (${rows.length}${payload.truncated === true ? ", truncated" : ""})`
+  ];
+  for (const row of rows) {
+    lines.push(
+      `    ${row.monitorKey.padEnd(monitorWidth)}  ${row.entityKey.padEnd(
+        entityWidth
+      )}  ${row.convergence.padEnd(convergenceWidth)}  ${row.since}${row.detail ? `  ${row.detail}` : ""}`
+    );
+  }
+  return lines;
+}
+function renderFleetList(payload) {
+  const fleets = (Array.isArray(payload.fleets) ? payload.fleets : []).flatMap((raw) => {
+    const fleet = asRecord2(raw);
+    return fleet ? [fleet] : [];
+  }).sort(
+    (left, right) => (asString(left.id) ?? "").localeCompare(asString(right.id) ?? "")
+  );
+  if (fleets.length === 0) {
+    return "No Monitor Fleets in this workspace.\nNext: deepline monitors fleets init <fleet-id> --help\n";
+  }
+  const idWidth = fleets.reduce(
+    (max, fleet) => Math.max(max, (asString(fleet.id) ?? "").length),
+    0
+  );
+  const statusWidth = fleets.reduce(
+    (max, fleet) => Math.max(max, (fleetStatus(fleet) ?? "unknown").length),
+    0
+  );
+  const lines = [`Fleets (${fleets.length})`];
+  for (const fleet of fleets) {
+    const counts = fleetCounts(fleet);
+    const trouble = [
+      counts.blocked ? `blocked ${counts.blocked}` : "",
+      counts.failed ? `failed ${counts.failed}` : ""
+    ].filter(Boolean);
+    lines.push(
+      `  ${(asString(fleet.id) ?? "-").padEnd(idWidth)}  ${(fleetStatus(fleet) ?? "unknown").padEnd(statusWidth)}  ${asFiniteNumber(fleet.live) ?? 0}/${asFiniteNumber(fleet.expected) ?? 0}${trouble.length ? `  ${trouble.join(" \xB7 ")}` : ""}`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+function renderFleetDeactivatePlan(payload, fleetId) {
+  const radius = asRecord2(payload.would_deactivate) ?? {};
+  const lines = [
+    `Deactivate fleet ${fleetId} \u2014 plan only, nothing changed`,
+    `  would deactivate  ${asFiniteNumber(radius.monitors) ?? 0} monitors \xB7 ${asFiniteNumber(radius.accounts) ?? 0} accounts`
+  ];
+  const note = asString(payload.note);
+  if (note) lines.push(`  ${note}`);
+  lines.push(
+    `Next: ${fleetServerNext(payload) ?? `deepline monitors fleets deactivate ${fleetShellArg(fleetId)} --yes`}`
+  );
+  return `${lines.join("\n")}
+`;
+}
+function reportFleetState(payload, error, options) {
+  printCommandEnvelope(
+    {
+      ...payload,
+      code: error.code,
+      message: error.message,
+      next: error.next
+    },
+    {
+      json: options.json,
+      text: `${options.text}${error.message}
+Next: ${error.next}
+`
+    }
+  );
+  process.exitCode = monitorsErrorExitCode(error);
+}
+function fleetSourceTable(value) {
+  const [schema, table, extra] = value?.trim().split(".") ?? [];
+  if (!schema || !table || extra || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(schema) || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(table)) {
+    throw new MonitorsUsageError(
+      "--source must be a Customer DB table in schema.table form."
+    );
+  }
+  return { schema, table };
+}
+function fleetColumnName(value, flag) {
+  const name = value?.trim();
+  if (!name || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+    throw new MonitorsUsageError(`${flag} must be a SQL column identifier.`);
+  }
+  return name;
+}
+function fleetMemberLimit(value) {
+  if (value === void 0) return 1e3;
+  const limit = fleetIntegerOption(value, "--limit");
+  if (!limit || limit > 1e3) {
+    throw new MonitorsUsageError("--limit must be between 1 and 1,000.");
+  }
+  return limit;
+}
+function fleetOrderBy(values, sourceKey) {
+  const parsed = (values ?? []).map((value) => {
+    const match = /^([A-Za-z_][A-Za-z0-9_]*):(asc|desc)$/.exec(value.trim());
+    if (!match) {
+      throw new MonitorsUsageError(
+        "--order-by must use column:asc or column:desc."
+      );
+    }
+    return { column: match[1], direction: match[2] };
+  });
+  const seen = /* @__PURE__ */ new Set();
+  for (const order of parsed) {
+    if (seen.has(order.column)) {
+      throw new MonitorsUsageError(
+        `--order-by repeats '${order.column}'. Each column may appear once.`
+      );
+    }
+    seen.add(order.column);
+  }
+  const sourceOrder = parsed.find((order) => order.column === sourceKey);
+  return [
+    ...parsed.filter((order) => order.column !== sourceKey),
+    sourceOrder ?? { column: sourceKey, direction: "asc" }
+  ];
+}
+async function handleMonitorFleetsInit(fleetId, options) {
+  if (!/^[a-z][a-z0-9-]{0,199}$/.test(fleetId)) {
+    throw new MonitorsUsageError("<fleet-id> must be lowercase kebab-case.");
+  }
+  const source = fleetSourceTable(options.source);
+  const key = fleetColumnName(options.key, "--key");
+  const keyType = options.keyType?.trim() ?? "text";
+  if (!["text", "uuid", "int4", "int8"].includes(keyType)) {
+    throw new MonitorsUsageError(
+      "--key-type must be text, uuid, int4, or int8."
+    );
+  }
+  const tool = options.tool?.trim();
+  if (!tool) throw new MonitorsUsageError("--tool is required.");
+  if (!options.payload) {
+    throw new MonitorsUsageError(
+      "--payload is required and must be the monitor payload JSON for --tool."
+    );
+  }
+  const payload = parseJsonObjectArg(options.payload, "--payload");
+  const where = options.where ? parseJsonObjectArg(options.where, "--where") : void 0;
+  const out = options.out?.trim();
+  if (!out) throw new MonitorsUsageError("--out is required.");
+  const authoredDefinition = {
+    id: fleetId,
+    source: {
+      kind: "customer_db_table",
+      schema: source.schema,
+      table: source.table,
+      key: { column: key, type: keyType },
+      ...where ? { where } : {}
+    },
+    member: {
+      tool,
+      key: {
+        $fleet: "template",
+        parts: [`${fleetId}-`, { $fleet: "column", name: key }]
+      },
+      payload
+    },
+    selection: {
+      limit: fleetMemberLimit(options.limit),
+      orderBy: fleetOrderBy(options.orderBy, key),
+      membership: "sticky"
+    }
+  };
+  const definition = requireCompiledFleetDefinition(authoredDefinition);
+  const file = (0, import_node_path17.resolve)(out);
+  (0, import_node_fs14.writeFileSync)(file, `${JSON.stringify(definition, null, 2)}
+`, "utf8");
+  const next = `deepline monitors fleets sync --file ${fleetShellArg(file)} --dry-run --json`;
+  printCommandEnvelope(
+    { schemaVersion: 1, file, definition, next },
+    {
+      json: options.json,
+      text: `Wrote ${file}
+Next: ${next}
+`
+    }
+  );
+}
+function requireCompiledFleetDefinition(definition) {
+  const result = admitMonitorFleetAuthoringContract(definition);
+  if (result.valid && result.contract) return result.contract.definition;
+  const messages = result.issues.map((issue) => `${issue.path || "definition"}: ${issue.message}`).join("; ");
+  throw new MonitorsUsageError(
+    `Monitor Fleet definition failed local contract check. ${messages}
+Fix the file, then re-run: deepline monitors fleets sync --file <fleet.json> --dry-run`
+  );
+}
+function fleetSyncCommandLine(target, options) {
+  const parts = ["deepline monitors fleets sync"];
+  if (options.file) parts.push(`--file ${fleetShellArg(options.file)}`);
+  else if (target) parts.push(fleetShellArg(target));
+  if (options.dryRun) parts.push("--dry-run");
+  if (options.wait) parts.push("--wait");
+  if (options.timeout)
+    parts.push(`--timeout ${fleetShellArg(options.timeout)}`);
+  if (options.expectedGeneration !== void 0) {
+    parts.push(
+      `--expected-generation ${fleetShellArg(options.expectedGeneration)}`
+    );
+  }
+  if (options.idempotencyKey) {
+    parts.push(`--idempotency-key ${fleetShellArg(options.idempotencyKey)}`);
+  }
+  parts.push(...fleetJsonFlag(options));
+  return parts.join(" ");
+}
+async function handleMonitorFleetsSync(target, options, idempotencyKey) {
+  const usesDefinition = options.file !== void 0 || target?.trim().startsWith("{") === true;
+  if (!usesDefinition && !target?.trim()) {
+    throw new MonitorsUsageError(
+      "sync needs a fleet: pass --file fleet.json to apply a definition, or <fleet-id> to re-plan the stored one.\n  deepline monitors fleets sync --file fleet.json --dry-run\n  deepline monitors fleets sync <fleet-id> --dry-run"
+    );
+  }
+  const definition = usesDefinition ? requireCompiledFleetDefinition(
+    resolveMonitorJsonBody({
+      positional: target,
+      file: options.file,
+      argLabel: "<definition>",
+      command: "deepline monitors fleets sync"
+    })
+  ) : void 0;
+  const fleetId = definition ? asString(definition.id) ?? "" : target.trim();
+  if (!fleetId) {
+    throw new MonitorsUsageError(
+      'The Fleet definition has no id. Add a top-level "id" and re-run.'
+    );
+  }
+  const client2 = new DeeplineClient();
+  const payload = await client2.monitors.fleets.sync(
+    definition ?? fleetId,
+    {
+      ...options.dryRun ? { dryRun: true } : {},
+      ...options.expectedGeneration !== void 0 ? {
+        expectedGeneration: fleetIntegerOption(
+          options.expectedGeneration,
+          "--expected-generation"
+        )
+      } : {},
+      idempotencyKey
+    }
+  );
+  if (options.dryRun) {
+    assertMonitorDryRunAcknowledged(payload, {
+      command: "deepline monitors fleets sync",
+      mutation: "fleet sync"
+    });
+  }
+  const accepted = { ...payload, idempotency_key: idempotencyKey };
+  if (!options.wait || options.dryRun) {
+    printCommandEnvelope(accepted, {
+      json: options.json,
+      text: renderFleetSync(payload, {
+        fleetId,
+        dryRun: options.dryRun === true,
+        idempotencyKey
+      })
+    });
+    return;
+  }
+  const timeoutMs = fleetTimeoutMs(options.timeout);
+  const progress = fleetProgressReporter();
+  let final;
+  try {
+    final = await client2.monitors.fleets.waitForConvergence(fleetId, {
+      timeoutMs,
+      pollIntervalMs: FLEET_POLL_INTERVAL_MS,
+      onProgress: progress.report
+    });
+  } finally {
+    progress.finish();
+  }
+  const envelope = { ...accepted, ...final };
+  const status = fleetStatus(final);
+  const summary = renderFleetGet(final);
+  if (status === "converged") {
+    printCommandEnvelope(envelope, { json: options.json, text: summary });
+    return;
+  }
+  const driftCommand = `deepline monitors fleets get ${fleetShellArg(fleetId)} --drift --json`;
+  if (status === "degraded") {
+    reportFleetState(
+      envelope,
+      new MonitorFleetStateError({
+        code: "MONITOR_FLEET_DEGRADED",
+        message: `Fleet ${fleetId} is degraded: some members will not converge without a change. Retrying sync will not fix it.`,
+        next: fleetServerNext(final) ?? driftCommand
+      }),
+      { json: options.json, text: summary }
+    );
+    return;
+  }
+  reportFleetState(
+    envelope,
+    new MonitorFleetStateError({
+      code: "MONITOR_FLEET_WAIT_TIMEOUT",
+      message: `Stopped waiting after ${timeoutMs}ms. Nothing is broken and nothing was lost \u2014 fleet ${fleetId} is still ${status ?? "working"} on the server.`,
+      next: fleetServerNext(final) ?? driftCommand
+    }),
+    { json: options.json, text: summary }
+  );
+}
+async function handleMonitorFleetsGet(fleetId, options) {
+  if (options.drift && !fleetId) {
+    throw new MonitorsUsageError(
+      "--drift needs a fleet id: deepline monitors fleets get <fleet-id> --drift"
+    );
+  }
+  const limit = options.limit === void 0 ? void 0 : fleetIntegerOption(options.limit, "--limit");
+  const client2 = new DeeplineClient();
+  const payload = await client2.monitors.fleets.get(fleetId, {
+    ...options.drift ? { drift: true } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+  const text = fleetId ? renderFleetGet(payload) : renderFleetList(payload);
+  if (!options.check) {
+    printCommandEnvelope(payload, { json: options.json, text });
+    return;
+  }
+  const statuses = fleetId ? [fleetStatus(payload)] : (Array.isArray(payload.fleets) ? payload.fleets : []).map(
+    (raw) => fleetStatus(asRecord2(raw) ?? {})
+  );
+  const unconverged = statuses.filter((status) => status !== "converged");
+  if (unconverged.length === 0) {
+    printCommandEnvelope(payload, { json: options.json, text });
+    return;
+  }
+  const target = fleetId ?? "<fleet-id>";
+  const degraded = unconverged.includes("degraded");
+  reportFleetState(
+    payload,
+    new MonitorFleetStateError({
+      code: degraded ? "MONITOR_FLEET_DEGRADED" : "MONITOR_FLEET_NOT_CONVERGED",
+      message: degraded ? `Fleet ${target} is degraded: members are stuck and retrying will not move them.` : `Fleet ${target} has not converged yet.`,
+      next: fleetServerNext(payload) ?? `deepline monitors fleets get ${fleetShellArg(target)} --drift --json`
+    }),
+    { json: options.json, text }
+  );
+}
+function fleetDeactivateCommandLine(fleetId, options) {
+  const parts = [
+    "deepline monitors fleets deactivate",
+    fleetShellArg(fleetId),
+    "--yes"
+  ];
+  if (options.dryRun) parts.push("--dry-run");
+  if (options.wait) parts.push("--wait");
+  if (options.timeout)
+    parts.push(`--timeout ${fleetShellArg(options.timeout)}`);
+  if (options.idempotencyKey) {
+    parts.push(`--idempotency-key ${fleetShellArg(options.idempotencyKey)}`);
+  }
+  parts.push(...fleetJsonFlag(options));
+  return parts.join(" ");
+}
+async function confirmFleetDeactivate(fleetId, plan) {
+  process.stderr.write(renderFleetDeactivatePlan(plan, fleetId));
+  const rl = (0, import_promises8.createInterface)({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await rl.question(
+      `Deactivate fleet "${fleetId}" and the monitors it owns? [y/N] `
+    );
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function handleMonitorFleetsDeactivate(fleetId, options, idempotencyKey) {
+  const client2 = new DeeplineClient();
+  if (options.dryRun) {
+    const plan = await client2.monitors.fleets.deactivate(fleetId, {
+      dryRun: true,
+      idempotencyKey
+    });
+    assertMonitorDryRunAcknowledged(plan, {
+      command: "deepline monitors fleets deactivate",
+      mutation: "fleet deactivate"
+    });
+    printCommandEnvelope(plan, {
+      json: options.json,
+      text: renderFleetDeactivatePlan(plan, fleetId)
+    });
+    return;
+  }
+  if (!options.yes) {
+    const interactive = process.stdout.isTTY === true && process.stdin.isTTY === true;
+    if (!interactive) {
+      throw new MonitorsUsageError(
+        `deactivate is destructive: it deactivates fleet "${fleetId}" and every monitor it owns. Non-interactive runs must confirm with --yes:
+  ${fleetDeactivateCommandLine(fleetId, options)}
+Preview the blast radius first:
+  deepline monitors fleets deactivate ${fleetShellArg(fleetId)} --dry-run`
+      );
+    }
+    const plan = await client2.monitors.fleets.deactivate(fleetId, {
+      dryRun: true,
+      idempotencyKey: `${idempotencyKey}-plan`
+    });
+    assertMonitorDryRunAcknowledged(plan, {
+      command: "deepline monitors fleets deactivate",
+      mutation: "fleet deactivate"
+    });
+    if (!await confirmFleetDeactivate(fleetId, plan)) {
+      process.stderr.write(
+        `Aborted. Fleet "${fleetId}" was not deactivated.
+`
+      );
+      process.exitCode = 2;
+      return;
+    }
+  }
+  const payload = await client2.monitors.fleets.deactivate(fleetId, {
+    idempotencyKey
+  });
+  const accepted = { ...payload, idempotency_key: idempotencyKey };
+  if (payload.already === true) {
+    printCommandEnvelope(accepted, {
+      json: options.json,
+      text: `Fleet ${fleetId} is already deactivated.
+`
+    });
+    return;
+  }
+  const acceptedText = `Fleet ${fleetId} \u2014 ${asString(payload.status) ?? "deactivating"}
+  idempotency key ${idempotencyKey}
+` + (fleetServerNext(payload) ? `Next: ${fleetServerNext(payload)}
+` : "");
+  if (!options.wait) {
+    printCommandEnvelope(accepted, {
+      json: options.json,
+      text: acceptedText
+    });
+    return;
+  }
+  const timeoutMs = fleetTimeoutMs(options.timeout);
+  const progress = fleetProgressReporter();
+  let final;
+  try {
+    final = await client2.monitors.fleets.waitForConvergence(fleetId, {
+      timeoutMs,
+      pollIntervalMs: FLEET_POLL_INTERVAL_MS,
+      onProgress: progress.report,
+      until: "deactivated"
+    });
+  } finally {
+    progress.finish();
+  }
+  const envelope = { ...accepted, ...final };
+  const summary = renderFleetGet(final);
+  if (fleetStatus(final) === "deactivated") {
+    printCommandEnvelope(envelope, { json: options.json, text: summary });
+    return;
+  }
+  reportFleetState(
+    envelope,
+    new MonitorFleetStateError({
+      code: "MONITOR_FLEET_WAIT_TIMEOUT",
+      message: `Stopped waiting after ${timeoutMs}ms. Deactivation of fleet ${fleetId} is still in progress on the server; nothing was lost.`,
+      next: fleetServerNext(final) ?? `deepline monitors fleets get ${fleetShellArg(fleetId)} --json`
+    }),
+    { json: options.json, text: summary }
+  );
+}
+function handleMonitorFleetsOverview(options) {
+  const lines = [
+    "Monitor Fleets \u2014 one Customer DB table row, one ordinary monitor.",
+    "",
+    "Lifecycle:",
+    ...MONITOR_FLEET_LIFECYCLE.flatMap((entry) => [
+      `  ${entry.step}. ${entry.what}`,
+      `     ${entry.command}`
+    ]),
+    "",
+    "Commands:",
+    ...MONITOR_FLEET_COMMANDS.map(
+      (command) => `  ${command.name.padEnd(12)}${command.summary}`
+    ),
+    "",
+    "Agent notes:",
+    ...MONITOR_FLEET_AGENT_NOTES.map((note) => `  ${note}`)
+  ];
+  printCommandEnvelope(
+    {
+      schemaVersion: 1,
+      lifecycle: MONITOR_FLEET_LIFECYCLE,
+      commands: MONITOR_FLEET_COMMANDS,
+      agent_notes: MONITOR_FLEET_AGENT_NOTES,
+      next: MONITOR_FLEET_LIFECYCLE[0].command
+    },
+    { json: options.json, text: `${lines.join("\n")}
+` }
+  );
+}
 function renderMonitorGet(payload) {
   const key = asString(payload.key);
   const tool = asString(payload.tool);
@@ -31713,7 +32868,9 @@ Notes:
 
 Exit codes:
   0 success; 2 usage/local input; 3 auth or permission; 4 not found;
-  5 server failure; 7 validation failed.
+  5 server failure (retry the same command); 6 not at the desired state
+  (fleets: degraded, or --wait/--check stopped while healthy \u2014 retrying
+  changes nothing); 7 refused, change the request.
   \`monitors status\` exits 1 when you lack monitor access (documented contract).
 
 Examples:
@@ -31984,6 +33141,181 @@ Examples:
 `
     ).option("--dry-run", "Show the reactivation cost without reactivating")
   ).action(monitorsAction(handleMonitorsReactivate));
+  const fleets = monitors.command("fleets").description("Define and reconcile table-backed Monitor Fleets.").addHelpText(
+    "after",
+    `
+Notes:
+  A Monitor Fleet maps eligible rows in one Customer DB table to ordinary
+  monitors. Fleet definitions are canonical JSON, and \`sync\` is the only verb
+  that changes one: applying the same definition twice is the same operation,
+  so the server answers \`replayed: true\` instead of building a second fleet.
+  The fleet's status is computed by Deepline; this CLI reports it and never
+  recomputes a verdict from the counts.
+
+Exit codes:
+  0 converged or done; 2 usage or local validation; 3 auth; 4 not found;
+  5 server failure (retry the same command); 6 not at the desired state
+  (degraded, or --wait/--check stopped while healthy); 7 refused (change the
+  request).
+
+Lifecycle:
+${MONITOR_FLEET_LIFECYCLE.map(
+      (entry) => `  ${entry.step}. ${entry.command}`
+    ).join("\n")}
+${MONITOR_FLEET_HELP_EPILOG}`
+  ).action(
+    monitorsAction(async (options) => {
+      handleMonitorFleetsOverview(options);
+    })
+  );
+  withJsonOption(fleets);
+  withJsonOption(
+    fleets.command("init <fleet-id>").description("Write an opinionated Fleet definition JSON file.").addHelpText(
+      "after",
+      `
+Creates a ready-to-review JSON definition. Fleets always sync ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.cadence} and retain
+a missing member for ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.removalGrace} before it is ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.onRemoved}d; those
+policies are not authored in the file. ${MONITOR_FLEET_DOCUMENTATION.stickyMembership} The payload remains the actual monitor payload for the chosen tool, so use
+\`deepline monitors available\` to discover a tool first.
+
+Example:
+  deepline monitors fleets init account-job-openings \\
+    --source public.accounts --key account_id --key-type uuid \\
+    --tool deepline_native.company_radar \\
+    --payload '{"domain":{"$fleet":"column","name":"domain"},"radar_type":"company_job_openings"}' \\
+    --order-by intent_score:desc \\
+    --out fleet.json
+`
+    ).requiredOption("--source <schema.table>", "Customer DB source table").requiredOption("--key <column>", "Unique source-row key column").option("--key-type <type>", "text, uuid, int4, or int8 (default text)").requiredOption("--tool <tool>", "Monitor tool to create per source row").requiredOption(
+      "--payload <json>",
+      "Monitor payload JSON for --tool; use $fleet column tags for row values"
+    ).option(
+      "--where <json>",
+      "Optional source-row equality filter JSON; not arbitrary SQL"
+    ).option(
+      "--order-by <column:direction>",
+      "Rank candidates; repeatable, with the source key appended for stability",
+      (value, previous = []) => [...previous, value],
+      []
+    ).option(
+      "--limit <n>",
+      "Maximum active members; ranking changes do not churn sticky members (default 1,000)"
+    ).requiredOption("--out <path>", "Write the definition JSON to this path")
+  ).action(monitorsAction(handleMonitorFleetsInit));
+  withJsonOption(
+    fleets.command("sync [fleet-id]").description(
+      "Apply a Fleet definition, or re-plan an existing fleet from its stored one."
+    ).addHelpText(
+      "after",
+      `
+Notes:
+  --file (or an inline definition, or --file - for stdin) is compiled locally
+  BEFORE any network call: a definition that fails the contract exits 2 and
+  never becomes a request. A bare <fleet-id> re-plans the stored definition.
+  The plan always shows blocked members; they are never hidden.
+  --wait polls until Deepline reports a terminal status: converged exits 0,
+  degraded exits 6, and a timeout exits 6 without implying anything broke.
+  Progress goes to stderr, so stdout stays exactly one JSON object.
+
+Examples:
+  deepline monitors fleets sync --file fleet.json --dry-run
+  deepline monitors fleets sync --file fleet.json --wait --timeout 20m
+  deepline monitors fleets sync account-job-openings --wait --json
+  cat fleet.json | deepline monitors fleets sync --file - --dry-run --json
+`
+    ).option(
+      "-f, --file <path>",
+      "Apply definition JSON from a file, or - for stdin"
+    ).option(
+      "--dry-run",
+      "Show the plan and the credits due without changing state"
+    ).option("--wait", "Poll until the fleet reaches a terminal status").option(
+      "--timeout <duration>",
+      "How long --wait may poll: 500ms, 90s, 10m, 1h (default 10m)"
+    ).option(
+      "--expected-generation <generation>",
+      "Refuse the write unless the fleet is at this generation"
+    ).option(
+      "--idempotency-key <key>",
+      "Stable retry key (generated and returned when omitted)"
+    )
+  ).action(async (target, options) => {
+    let retryCommand = fleetSyncCommandLine(target, options);
+    try {
+      const idempotencyKey = fleetIdempotencyKey(
+        "sync",
+        options.idempotencyKey
+      );
+      retryCommand = fleetSyncCommandLine(target, {
+        ...options,
+        idempotencyKey
+      });
+      await handleMonitorFleetsSync(target, options, idempotencyKey);
+    } catch (error) {
+      reportMonitorsFailure(error, { retryCommand });
+    }
+  });
+  withJsonOption(
+    fleets.command("get [fleet-id]").description(
+      "Read one fleet, or list every fleet when the id is omitted."
+    ).addHelpText(
+      "after",
+      `
+Notes:
+  Status is the server's verdict. --check turns it into an exit code so a
+  script can branch without parsing output: 0 converged, 6 anything else.
+  --drift lists the members that have not settled and why.
+
+Examples:
+  deepline monitors fleets get --json
+  deepline monitors fleets get account-job-openings --json
+  deepline monitors fleets get account-job-openings --drift --limit 50 --json
+  deepline monitors fleets get account-job-openings --check
+`
+    ).option("--drift", "Include the members that have not settled, and why").option("--limit <n>", "Maximum drift rows to return").option(
+      "--check",
+      "Exit 0 when converged and 6 otherwise, for scripts and agents"
+    )
+  ).action(monitorsAction(handleMonitorFleetsGet));
+  withJsonOption(
+    fleets.command("deactivate <fleet-id>").description("Deactivate a fleet and the monitors it owns.").addHelpText(
+      "after",
+      `
+Notes:
+  Destructive. --dry-run shows the blast radius without changing anything.
+  An interactive terminal is shown that blast radius and asked to confirm;
+  a non-interactive run must pass --yes. Re-running after a failure is safe.
+
+Examples:
+  deepline monitors fleets deactivate account-job-openings --dry-run
+  deepline monitors fleets deactivate account-job-openings --yes --wait --json
+`
+    ).option("--dry-run", "Show the blast radius without deactivating").option("--wait", "Poll until the fleet reports deactivated").option(
+      "--timeout <duration>",
+      "How long --wait may poll: 500ms, 90s, 10m, 1h (default 10m)"
+    ).option(
+      "--yes",
+      "Skip the confirmation prompt (required non-interactively)"
+    ).option(
+      "--idempotency-key <key>",
+      "Stable retry key (generated and returned when omitted)"
+    )
+  ).action(async (fleetId, options) => {
+    let retryCommand = fleetDeactivateCommandLine(fleetId, options);
+    try {
+      const idempotencyKey = fleetIdempotencyKey(
+        "deactivate",
+        options.idempotencyKey
+      );
+      retryCommand = fleetDeactivateCommandLine(fleetId, {
+        ...options,
+        idempotencyKey
+      });
+      await handleMonitorFleetsDeactivate(fleetId, options, idempotencyKey);
+    } catch (error) {
+      reportMonitorsFailure(error, { retryCommand });
+    }
+  });
   const deployed = withJsonOption(
     monitors.command("deployed", { hidden: true }).description("Alias of `monitors list` (plus get/update/delete aliases).").option(
       "--status <status>",
@@ -32686,7 +34018,7 @@ async function readHiddenLine(prompt, streams = {}) {
   }
   let value = "";
   inputStream.resume();
-  return await new Promise((resolve20, reject) => {
+  return await new Promise((resolve21, reject) => {
     let settled = false;
     const cleanup = () => {
       inputStream.off("data", onData);
@@ -32704,7 +34036,7 @@ async function readHiddenLine(prompt, streams = {}) {
       settled = true;
       outputStream.write("\n");
       cleanup();
-      resolve20(line);
+      resolve21(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -32878,11 +34210,11 @@ Examples:
 var import_node_child_process4 = require("child_process");
 var import_node_fs18 = require("fs");
 var import_node_os12 = require("os");
-var import_node_path20 = require("path");
+var import_node_path21 = require("path");
 
 // src/cli/installation-lifecycle.ts
 var import_node_fs15 = require("fs");
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 var nodeFileSystem = {
   exists: import_node_fs15.existsSync,
   isSymbolicLink(path) {
@@ -32938,25 +34270,25 @@ var CliInstallation = class _CliInstallation {
     });
   }
   static isNpmPackagePath(path) {
-    return path?.includes(`${(0, import_node_path17.join)("node_modules", "deepline")}`) ?? false;
+    return path?.includes(`${(0, import_node_path18.join)("node_modules", "deepline")}`) ?? false;
   }
   launcher(path) {
     return inspectLauncher(path, this.input.fileSystem);
   }
   retiredArtifacts() {
-    const hostDir = (0, import_node_path17.join)(
+    const hostDir = (0, import_node_path18.join)(
       this.input.home,
       ".local",
       "deepline",
       this.input.baseUrlSlug
     );
-    const legacyLauncherPath = (0, import_node_path17.join)(
+    const legacyLauncherPath = (0, import_node_path18.join)(
       this.input.home,
       ".local",
       "bin",
       "deepline"
     );
-    const installerCommandPath = this.input.fileSystem.read((0, import_node_path17.join)(hostDir, "sdk", ".command-path")).trim();
+    const installerCommandPath = this.input.fileSystem.read((0, import_node_path18.join)(hostDir, "sdk", ".command-path")).trim();
     const ownedInstallerCommand = isOwnedInstallerCommandPath({
       hostDir,
       commandPath: installerCommandPath
@@ -32964,16 +34296,16 @@ var CliInstallation = class _CliInstallation {
     const legacyLauncher = this.launcher(legacyLauncherPath);
     const candidates = [
       ...legacyLauncher.ownership === "installer_legacy" ? [legacyLauncherPath] : [],
-      (0, import_node_path17.join)(this.input.home, ".local", "bin", "deepline-real"),
-      (0, import_node_path17.join)(hostDir, "bin", "deepline"),
-      (0, import_node_path17.join)(hostDir, "bin", "deepline-real"),
-      (0, import_node_path17.join)(hostDir, "cli", ".install-method"),
-      (0, import_node_path17.join)(hostDir, "cli", ".version"),
-      (0, import_node_path17.join)(hostDir, "sdk", ".install-method"),
-      (0, import_node_path17.join)(hostDir, "sdk", ".command-path"),
+      (0, import_node_path18.join)(this.input.home, ".local", "bin", "deepline-real"),
+      (0, import_node_path18.join)(hostDir, "bin", "deepline"),
+      (0, import_node_path18.join)(hostDir, "bin", "deepline-real"),
+      (0, import_node_path18.join)(hostDir, "cli", ".install-method"),
+      (0, import_node_path18.join)(hostDir, "cli", ".version"),
+      (0, import_node_path18.join)(hostDir, "sdk", ".install-method"),
+      (0, import_node_path18.join)(hostDir, "sdk", ".command-path"),
       ...ownedInstallerCommand ? [
         installerCommandPath,
-        (0, import_node_path17.join)((0, import_node_path17.dirname)(installerCommandPath), "deepline-sdk")
+        (0, import_node_path18.join)((0, import_node_path18.dirname)(installerCommandPath), "deepline-sdk")
       ] : []
     ];
     return {
@@ -32994,11 +34326,11 @@ function removeArtifacts(plan, fileSystem) {
   return plan.paths;
 }
 function isOwnedInstallerCommandPath(input2) {
-  if (!input2.commandPath || (0, import_node_path17.basename)(input2.commandPath) !== "deepline") {
+  if (!input2.commandPath || (0, import_node_path18.basename)(input2.commandPath) !== "deepline") {
     return false;
   }
-  const commandPath = (0, import_node_path17.resolve)(input2.commandPath);
-  const fromHost = (0, import_node_path17.relative)((0, import_node_path17.resolve)(input2.hostDir), commandPath);
+  const commandPath = (0, import_node_path18.resolve)(input2.commandPath);
+  const fromHost = (0, import_node_path18.relative)((0, import_node_path18.resolve)(input2.hostDir), commandPath);
   return fromHost !== "" && fromHost !== ".." && !fromHost.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`);
 }
 
@@ -33006,7 +34338,7 @@ function isOwnedInstallerCommandPath(input2) {
 var import_node_child_process3 = require("child_process");
 var import_node_fs17 = require("fs");
 var import_node_os11 = require("os");
-var import_node_path19 = require("path");
+var import_node_path20 = require("path");
 
 // ../../shared_libs/cli/install-commands.json
 var install_commands_default = {
@@ -33117,7 +34449,7 @@ function buildSkillsAddArgs(baseUrl, skillName, options = {}) {
 // src/cli/skills-sync.ts
 var import_node_child_process2 = require("child_process");
 var import_node_fs16 = require("fs");
-var import_node_path18 = require("path");
+var import_node_path19 = require("path");
 
 // src/cli/windows-arg-escape.ts
 var CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
@@ -33152,10 +34484,10 @@ function shouldSkipSkillsSync() {
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
 function unavailableSkillsNoticePath(baseUrl) {
-  return (0, import_node_path18.join)(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
+  return (0, import_node_path19.join)(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
 }
 function failedSkillsSyncPath(baseUrl, agents) {
-  return (0, import_node_path18.join)(
+  return (0, import_node_path19.join)(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-failed-${agents.join("-")}-version`
   );
@@ -33172,7 +34504,7 @@ function readMarkedSkillsSyncVersion(path) {
 }
 function writeMarkedSkillsSyncVersion(path, version) {
   try {
-    (0, import_node_fs16.mkdirSync)((0, import_node_path18.dirname)(path), { recursive: true });
+    (0, import_node_fs16.mkdirSync)((0, import_node_path19.dirname)(path), { recursive: true });
     (0, import_node_fs16.writeFileSync)(path, `${version}
 `, "utf-8");
   } catch {
@@ -33326,7 +34658,7 @@ function resolveSkillsInstallCommands(baseUrl, skillNames = DEFAULT_SDK_SKILL_NA
   return commands;
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const plan = resolveSkillsInstallSpawn(install);
     const child = (0, import_node_child_process2.spawn)(plan.command, plan.args, {
       stdio: ["ignore", "ignore", "pipe"],
@@ -33338,7 +34670,7 @@ function runOneSkillsInstall(install) {
       stderr += chunk.toString("utf-8");
     });
     child.on("error", (error) => {
-      resolve20({
+      resolve21({
         ok: false,
         detail: `failed to start ${install.command}: ${error.message}`,
         manualCommand: install.manualCommand
@@ -33346,11 +34678,11 @@ function runOneSkillsInstall(install) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve20({ ok: true, detail: "", manualCommand: install.manualCommand });
+        resolve21({ ok: true, detail: "", manualCommand: install.manualCommand });
         return;
       }
       const detail = stderr.trim();
-      resolve20({
+      resolve21({
         ok: false,
         detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
         manualCommand: install.manualCommand
@@ -33552,13 +34884,13 @@ function detectSkillsAgents(input2) {
   ];
   const detected = AGENT_MARKERS.filter(
     (marker) => roots.some(
-      (root) => marker.paths.some((path) => (0, import_node_fs17.existsSync)((0, import_node_path19.join)(root, path)))
+      (root) => marker.paths.some((path) => (0, import_node_fs17.existsSync)((0, import_node_path20.join)(root, path)))
     )
   ).map((marker) => marker.agent);
   return detected.length > 0 ? detected : ["*"];
 }
 function skillsStatePathForScope(baseUrl, scope, root) {
-  return scope === "local" && root ? (0, import_node_path19.join)(root, ".deepline", "setup", "skills.json") : (0, import_node_path19.join)(sdkCliStateDirPath(baseUrl), "skills-install.json");
+  return scope === "local" && root ? (0, import_node_path20.join)(root, ".deepline", "setup", "skills.json") : (0, import_node_path20.join)(sdkCliStateDirPath(baseUrl), "skills-install.json");
 }
 function buildSkillsPlan(input2) {
   const scopeArgs = input2.scope === "global" ? ["--global"] : [];
@@ -33632,7 +34964,7 @@ function readSkillsInstallState(path) {
   }
 }
 function runProcess(command, args, cwd) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     const plan = resolveShellSpawn(command, args);
     const child = (0, import_node_child_process3.spawn)(plan.command, plan.args, {
       cwd,
@@ -33651,7 +34983,7 @@ function runProcess(command, args, cwd) {
         process.stderr.write(`${SKILLS_NPX_PACKAGE} exited ${code}.
 `);
       }
-      resolve20(code ?? 1);
+      resolve21(code ?? 1);
     });
   });
 }
@@ -33778,7 +35110,7 @@ async function runSkillsCommand(options, dependencies = {}) {
 `
     );
   }
-  (0, import_node_fs17.mkdirSync)((0, import_node_path19.dirname)(plan.statePath), { recursive: true });
+  (0, import_node_fs17.mkdirSync)((0, import_node_path20.dirname)(plan.statePath), { recursive: true });
   (0, import_node_fs17.writeFileSync)(
     plan.statePath,
     `${JSON.stringify(
@@ -33874,26 +35206,26 @@ function parseSetupPhases(value) {
     if (!phase || typeof phase !== "object" || Array.isArray(phase)) {
       return null;
     }
-    const record = phase;
-    if (!isSetupPhaseStatus(record.status)) return null;
-    switch (record.status) {
+    const record2 = phase;
+    if (!isSetupPhaseStatus(record2.status)) return null;
+    switch (record2.status) {
       case "pending":
       case "in_progress":
-        phases[name] = { status: record.status };
+        phases[name] = { status: record2.status };
         break;
       case "complete":
         phases[name] = {
           status: "complete",
-          ...typeof record.outcome === "string" ? { outcome: record.outcome } : {}
+          ...typeof record2.outcome === "string" ? { outcome: record2.outcome } : {}
         };
         break;
       case "waiting":
-        if (typeof record.outcome !== "string") return null;
-        phases[name] = { status: "waiting", outcome: record.outcome };
+        if (typeof record2.outcome !== "string") return null;
+        phases[name] = { status: "waiting", outcome: record2.outcome };
         break;
       case "failed":
-        if (typeof record.code !== "string") return null;
-        phases[name] = { status: "failed", code: record.code };
+        if (typeof record2.code !== "string") return null;
+        phases[name] = { status: "failed", code: record2.code };
         break;
     }
   }
@@ -33993,7 +35325,7 @@ function buildPendingAuthorizationOutput(input2) {
   };
 }
 function setupStatePath(baseUrl, scope, root) {
-  return scope === "local" && root ? (0, import_node_path20.join)(root, ".deepline", "setup", "state.json") : (0, import_node_path20.join)(sdkCliStateDirPath(baseUrl), "setup.json");
+  return scope === "local" && root ? (0, import_node_path21.join)(root, ".deepline", "setup", "state.json") : (0, import_node_path21.join)(sdkCliStateDirPath(baseUrl), "setup.json");
 }
 async function captureStdout2(run) {
   let stdout = "";
@@ -34041,7 +35373,7 @@ function resolvePathCommands(command) {
   );
   return [
     ...new Set(
-      String(lookup.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => (0, import_node_path20.resolve)(path))
+      String(lookup.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => (0, import_node_path21.resolve)(path))
     )
   ];
 }
@@ -34074,7 +35406,7 @@ function resolvePersistentGlobalCommand(dependencies = {}) {
   if (prefix.status !== 0) return null;
   const root = String(prefix.stdout ?? "").trim();
   if (!root) return null;
-  const candidates = platform3 === "win32" ? [(0, import_node_path20.join)(root, "deepline.cmd"), (0, import_node_path20.join)(root, "deepline")] : [(0, import_node_path20.join)(root, "bin", "deepline")];
+  const candidates = platform3 === "win32" ? [(0, import_node_path21.join)(root, "deepline.cmd"), (0, import_node_path21.join)(root, "deepline")] : [(0, import_node_path21.join)(root, "bin", "deepline")];
   return candidates.find((candidate) => pathExists(candidate)) ?? null;
 }
 function inspectGlobalCliAvailability(input2) {
@@ -34089,18 +35421,18 @@ function pathsResolveToSameFile(left, right) {
   try {
     return (0, import_node_fs18.realpathSync)(left) === (0, import_node_fs18.realpathSync)(right);
   } catch {
-    return (0, import_node_path20.resolve)(left) === (0, import_node_path20.resolve)(right);
+    return (0, import_node_path21.resolve)(left) === (0, import_node_path21.resolve)(right);
   }
 }
 function isKnownDeeplineCommand(path) {
-  const entrypoint = process.argv[1] ? (0, import_node_path20.resolve)(process.argv[1]) : "";
+  const entrypoint = process.argv[1] ? (0, import_node_path21.resolve)(process.argv[1]) : "";
   let resolvedPath = path;
   try {
     resolvedPath = (0, import_node_fs18.realpathSync)(path);
   } catch {
   }
   if (entrypoint && resolvedPath === entrypoint) return true;
-  if (resolvedPath.includes(`${(0, import_node_path20.join)("node_modules", "deepline")}`)) return true;
+  if (resolvedPath.includes(`${(0, import_node_path21.join)("node_modules", "deepline")}`)) return true;
   const content = safeRead(path);
   return content.includes("node_modules/deepline") || content.includes("node_modules\\deepline") || content.includes("DEEPLINE_CONFIG_SCOPE") || content.includes("deepline-real");
 }
@@ -34110,7 +35442,7 @@ function inspectPathConflict() {
   try {
     if ((0, import_node_fs18.lstatSync)(commandPath).isSymbolicLink()) {
       const target = (0, import_node_fs18.realpathSync)(commandPath);
-      if (target.includes(`${(0, import_node_path20.join)("node_modules", "deepline")}`)) return null;
+      if (target.includes(`${(0, import_node_path21.join)("node_modules", "deepline")}`)) return null;
     }
   } catch {
   }
@@ -34118,7 +35450,7 @@ function inspectPathConflict() {
 }
 function writeSetupState(input2) {
   const path = setupStatePath(input2.baseUrl, input2.scope, input2.root);
-  (0, import_node_fs18.mkdirSync)((0, import_node_path20.dirname)(path), { recursive: true });
+  (0, import_node_fs18.mkdirSync)((0, import_node_path21.dirname)(path), { recursive: true });
   (0, import_node_fs18.writeFileSync)(
     path,
     `${JSON.stringify(
@@ -34159,7 +35491,7 @@ function failSetupPhase(phases, phase, code) {
   phases[phase] = { status: "failed", code };
 }
 function rollbackCommand(scope, root) {
-  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify((0, import_node_path20.join)(root, ".deepline", "runtime"))}` : "";
+  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify((0, import_node_path21.join)(root, ".deepline", "runtime"))}` : "";
   return `npm install -g${prefix} --no-audit --no-fund --include=optional --allow-scripts=esbuild deepline@${SDK_VERSION}`;
 }
 function setupResumeCommand(baseUrl, scope) {
@@ -34246,12 +35578,12 @@ function buildDoctorAssessment(input2) {
   const connected = input2.authStatus.payload?.connected === true;
   const authScopeOk = input2.scope === "local" ? Boolean(projectAuth) : Boolean(apiKey && !projectAuth);
   const skillsOk = skillsState?.scope === input2.scope && typeof skillsState.skillsVersion === "string" && Array.isArray(skillsState.agents) && skillsState.agents.length > 0;
-  const runningCliPath = process.argv[1] ? (0, import_node_path20.resolve)(process.argv[1]) : null;
+  const runningCliPath = process.argv[1] ? (0, import_node_path21.resolve)(process.argv[1]) : null;
   const globalCli = input2.scope === "global" ? inspectGlobalCliAvailability() : null;
   const pathGlobalCli = globalCli?.path ?? null;
   const cliPath = input2.scope === "global" ? pathGlobalCli : runningCliPath;
   const cliScopeOk = input2.scope === "global" ? Boolean(pathGlobalCli) : Boolean(
-    input2.root && runningCliPath?.includes((0, import_node_path20.join)(input2.root, ".deepline", "runtime"))
+    input2.root && runningCliPath?.includes((0, import_node_path21.join)(input2.root, ".deepline", "runtime"))
   );
   const checks = {
     cli: {
@@ -34785,7 +36117,7 @@ Examples:
 // src/cli/update-preferences.ts
 var import_node_fs19 = require("fs");
 var import_node_os13 = require("os");
-var import_node_path21 = require("path");
+var import_node_path22 = require("path");
 var UPDATE_PREFERENCES_SCHEMA_VERSION = 1;
 var CLI_UPDATE_MESSAGES = [
   {
@@ -34814,7 +36146,7 @@ function unreadablePreferences(path, error) {
   };
 }
 function cliUpdatePreferencesPath(homeDir2 = (0, import_node_os13.homedir)()) {
-  return (0, import_node_path21.join)(
+  return (0, import_node_path22.join)(
     homeDir2,
     ".local",
     "deepline",
@@ -34842,7 +36174,7 @@ function readCliUpdatePreferences(homeDir2 = (0, import_node_os13.homedir)()) {
 function writeCliUpdatePreferences(preferences, homeDir2 = (0, import_node_os13.homedir)()) {
   const path = cliUpdatePreferencesPath(homeDir2);
   const tempPath = `${path}.${process.pid}.tmp`;
-  (0, import_node_fs19.mkdirSync)((0, import_node_path21.dirname)(path), { recursive: true });
+  (0, import_node_fs19.mkdirSync)((0, import_node_path22.dirname)(path), { recursive: true });
   try {
     (0, import_node_fs19.writeFileSync)(tempPath, `${JSON.stringify(preferences, null, 2)}
 `, {
@@ -34903,12 +36235,12 @@ function consumePendingCliUpdateMessages(homeDir2 = (0, import_node_os13.homedir
 var import_node_child_process5 = require("child_process");
 var import_node_fs21 = require("fs");
 var import_node_os14 = require("os");
-var import_node_path23 = require("path");
+var import_node_path24 = require("path");
 
 // src/cli/install-integrity.ts
 var import_node_module2 = require("module");
 var import_node_fs20 = require("fs");
-var import_node_path22 = require("path");
+var import_node_path23 = require("path");
 var SDK_SIDECAR_CRITICAL_PACKAGE_FILES = [
   "dist/cli/index.mjs",
   "dist/index.mjs",
@@ -34925,7 +36257,7 @@ var SDK_SIDECAR_CRITICAL_DEPENDENCY_FILES = [
   "esbuild/lib/main.js"
 ];
 function safeRelativePath(value) {
-  if (typeof value !== "string" || !value || (0, import_node_path22.isAbsolute)(value)) return false;
+  if (typeof value !== "string" || !value || (0, import_node_path23.isAbsolute)(value)) return false;
   const segments = value.split(/[\\/]+/);
   return segments.every(
     (segment) => Boolean(segment) && segment !== "." && segment !== ".."
@@ -34933,9 +36265,9 @@ function safeRelativePath(value) {
 }
 function resolveContainedPath(root, value) {
   if (!safeRelativePath(value)) return null;
-  const target = (0, import_node_path22.resolve)(root, value);
-  const relativeTarget = (0, import_node_path22.relative)((0, import_node_path22.resolve)(root), target);
-  if (!relativeTarget || relativeTarget.startsWith("..") || (0, import_node_path22.isAbsolute)(relativeTarget)) {
+  const target = (0, import_node_path23.resolve)(root, value);
+  const relativeTarget = (0, import_node_path23.relative)((0, import_node_path23.resolve)(root), target);
+  if (!relativeTarget || relativeTarget.startsWith("..") || (0, import_node_path23.isAbsolute)(relativeTarget)) {
     return null;
   }
   return target;
@@ -34951,7 +36283,7 @@ function isFile(path) {
   }
 }
 function readManifest(packageRoot) {
-  const packageJsonPath = (0, import_node_path22.join)(packageRoot, "package.json");
+  const packageJsonPath = (0, import_node_path23.join)(packageRoot, "package.json");
   let packageJson;
   try {
     packageJson = parseJson(packageJsonPath);
@@ -35025,8 +36357,8 @@ function readManifest(packageRoot) {
   return { mode: "manifest", manifest };
 }
 function inspectSdkSidecarInstall(versionDir) {
-  const nodeModulesRoot = (0, import_node_path22.join)(versionDir, "node_modules");
-  const packageRoot = (0, import_node_path22.join)(nodeModulesRoot, "deepline");
+  const nodeModulesRoot = (0, import_node_path23.join)(versionDir, "node_modules");
+  const packageRoot = (0, import_node_path23.join)(nodeModulesRoot, "deepline");
   const manifestResult = readManifest(packageRoot);
   if ("invalidReason" in manifestResult) {
     return {
@@ -35037,8 +36369,8 @@ function inspectSdkSidecarInstall(versionDir) {
     };
   }
   const missing = [
-    ...manifestResult.manifest.packageFiles.filter((path) => !isFile((0, import_node_path22.join)(packageRoot, path))).map((path) => `deepline/${path}`),
-    ...manifestResult.manifest.dependencyFiles.filter((path) => !isFile((0, import_node_path22.join)(nodeModulesRoot, path))).map((path) => `node_modules/${path}`)
+    ...manifestResult.manifest.packageFiles.filter((path) => !isFile((0, import_node_path23.join)(packageRoot, path))).map((path) => `deepline/${path}`),
+    ...manifestResult.manifest.dependencyFiles.filter((path) => !isFile((0, import_node_path23.join)(nodeModulesRoot, path))).map((path) => `node_modules/${path}`)
   ];
   return {
     ok: missing.length === 0,
@@ -35049,7 +36381,7 @@ function inspectSdkSidecarInstall(versionDir) {
 }
 function probeSdkSidecarEsbuild(versionDir) {
   try {
-    const requireFromInstall = (0, import_node_module2.createRequire)((0, import_node_path22.join)(versionDir, "package.json"));
+    const requireFromInstall = (0, import_node_module2.createRequire)((0, import_node_path23.join)(versionDir, "package.json"));
     const esbuild = requireFromInstall("esbuild");
     if (typeof esbuild.transformSync !== "function") {
       return "esbuild does not export transformSync";
@@ -35124,7 +36456,7 @@ function sidecarStateDir(input2) {
   if (!scope || scope.includes("/") || scope.includes("\\")) {
     return null;
   }
-  return (0, import_node_path23.join)(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
+  return (0, import_node_path24.join)(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
 }
 function sidecarRegistryUrl(hostUrl) {
   let url;
@@ -35159,19 +36491,19 @@ function readOptionalText(path) {
 function resolvePythonSidecarUpdatePlan(options) {
   const stateDir = sidecarStateDir(options);
   if (!stateDir) return null;
-  const relativeEntrypoint = (0, import_node_path23.relative)(
-    (0, import_node_path23.resolve)(stateDir),
-    (0, import_node_path23.resolve)(options.entrypoint)
+  const relativeEntrypoint = (0, import_node_path24.relative)(
+    (0, import_node_path24.resolve)(stateDir),
+    (0, import_node_path24.resolve)(options.entrypoint)
   );
-  if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || (0, import_node_path23.isAbsolute)(relativeEntrypoint)) {
+  if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || (0, import_node_path24.isAbsolute)(relativeEntrypoint)) {
     return null;
   }
-  const installMethod = readOptionalText((0, import_node_path23.join)(stateDir, ".install-method"));
+  const installMethod = readOptionalText((0, import_node_path24.join)(stateDir, ".install-method"));
   if (installMethod !== "python-sidecar") return null;
   const scope = options.env.DEEPLINE_CONFIG_SCOPE?.trim() || "";
   const hostUrl = options.env.DEEPLINE_HOST_URL?.trim() || "";
-  const nodeBin = readOptionalText((0, import_node_path23.join)(stateDir, ".node-bin")) || process.execPath;
-  const sidecarPath = readOptionalText((0, import_node_path23.join)(stateDir, ".command-path")) || (0, import_node_path23.join)(
+  const nodeBin = readOptionalText((0, import_node_path24.join)(stateDir, ".node-bin")) || process.execPath;
+  const sidecarPath = readOptionalText((0, import_node_path24.join)(stateDir, ".command-path")) || (0, import_node_path24.join)(
     stateDir,
     "bin",
     process.platform === "win32" ? "deepline-sdk.cmd" : "deepline-sdk"
@@ -35179,7 +36511,7 @@ function resolvePythonSidecarUpdatePlan(options) {
   const packageSpec = options.packageSpec || "deepline@latest";
   const npmCommand = "npm";
   const registryUrl = sidecarRegistryUrl(hostUrl);
-  const versionDir = (0, import_node_path23.join)(stateDir, "versions", "<version>");
+  const versionDir = (0, import_node_path24.join)(stateDir, "versions", "<version>");
   const manualCommand = `${buildSidecarProjectConfigCommand(versionDir, nodeBin)} && ${npmCommand} install --prefix ${shellQuote4(versionDir)} --registry ${shellQuote4(registryUrl)} ${NPM_SDK_INSTALL_COMMON_FLAGS.map(shellQuote4).join(" ")} ${shellQuote4(packageSpec)}`;
   return {
     kind: "python-sidecar",
@@ -35195,16 +36527,16 @@ function resolvePythonSidecarUpdatePlan(options) {
   };
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = (0, import_node_path23.resolve)(startPath);
+  let current = (0, import_node_path24.resolve)(startPath);
   while (true) {
-    if ((0, import_node_fs21.existsSync)((0, import_node_path23.join)(current, "package.json")) && (0, import_node_fs21.existsSync)((0, import_node_path23.join)(current, "bin", "deepline-dev.ts"))) {
-      const parent2 = (0, import_node_path23.dirname)(current);
-      return (0, import_node_path23.basename)(parent2) === "packages" && (0, import_node_path23.basename)(current) === "sdk" ? (0, import_node_path23.dirname)(parent2) : parent2;
+    if ((0, import_node_fs21.existsSync)((0, import_node_path24.join)(current, "package.json")) && (0, import_node_fs21.existsSync)((0, import_node_path24.join)(current, "bin", "deepline-dev.ts"))) {
+      const parent2 = (0, import_node_path24.dirname)(current);
+      return (0, import_node_path24.basename)(parent2) === "packages" && (0, import_node_path24.basename)(current) === "sdk" ? (0, import_node_path24.dirname)(parent2) : parent2;
     }
-    if ((0, import_node_fs21.existsSync)((0, import_node_path23.join)(current, "sdk", "package.json")) && (0, import_node_fs21.existsSync)((0, import_node_path23.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if ((0, import_node_fs21.existsSync)((0, import_node_path24.join)(current, "sdk", "package.json")) && (0, import_node_fs21.existsSync)((0, import_node_path24.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = (0, import_node_path23.dirname)(current);
+    const parent = (0, import_node_path24.dirname)(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -35214,7 +36546,7 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
     try {
       return (0, import_node_fs21.realpathSync)(entrypoint);
     } catch {
-      return (0, import_node_path23.resolve)(entrypoint);
+      return (0, import_node_path24.resolve)(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -35229,10 +36561,10 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
     const directPrefix = prefixParts.join("/").toLowerCase();
     const knownWindowsPrefixes = [
       env.npm_config_prefix,
-      env.APPDATA ? (0, import_node_path23.join)(env.APPDATA, "npm") : void 0
-    ].filter((value) => Boolean(value)).map((value) => (0, import_node_path23.resolve)(value).replace(/\\/g, "/").toLowerCase());
+      env.APPDATA ? (0, import_node_path24.join)(env.APPDATA, "npm") : void 0
+    ].filter((value) => Boolean(value)).map((value) => (0, import_node_path24.resolve)(value).replace(/\\/g, "/").toLowerCase());
     if (!knownWindowsPrefixes.includes(
-      (0, import_node_path23.resolve)(directPrefix).replace(/\\/g, "/").toLowerCase()
+      (0, import_node_path24.resolve)(directPrefix).replace(/\\/g, "/").toLowerCase()
     )) {
       return null;
     }
@@ -35245,9 +36577,9 @@ function normalizedNpmPrefix(value) {
   if (!trimmed) return null;
   const normalized = (() => {
     try {
-      return (0, import_node_fs21.realpathSync)((0, import_node_path23.resolve)(trimmed));
+      return (0, import_node_fs21.realpathSync)((0, import_node_path24.resolve)(trimmed));
     } catch {
-      return (0, import_node_path23.resolve)(trimmed);
+      return (0, import_node_path24.resolve)(trimmed);
     }
   })().replace(/\\/g, "/");
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
@@ -35272,7 +36604,7 @@ function isHomebrewFormulaEntrypoint(entrypoint) {
     try {
       return (0, import_node_fs21.realpathSync)(entrypoint);
     } catch {
-      return (0, import_node_path23.resolve)(entrypoint);
+      return (0, import_node_path24.resolve)(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -35282,8 +36614,8 @@ function isHomebrewFormulaEntrypoint(entrypoint) {
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
   const homeDir2 = options.homeDir ?? (0, import_node_os14.homedir)();
-  const entrypoint = options.entrypoint ?? (process.argv[1] ? (0, import_node_path23.resolve)(process.argv[1]) : "");
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path23.dirname)(entrypoint)) : null;
+  const entrypoint = options.entrypoint ?? (process.argv[1] ? (0, import_node_path24.resolve)(process.argv[1]) : "");
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path24.dirname)(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -35334,9 +36666,9 @@ var AUTO_UPDATE_FAILURE_FILE = ".auto-update-failure.json";
 function autoUpdateFailurePath(plan) {
   if (plan.kind === "source" || plan.kind === "homebrew") return null;
   if (plan.kind === "python-sidecar") {
-    return (0, import_node_path23.join)(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
+    return (0, import_node_path24.join)(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
   }
-  return (0, import_node_path23.join)(
+  return (0, import_node_path24.join)(
     (0, import_node_os14.homedir)(),
     ".local",
     "deepline",
@@ -35375,7 +36707,7 @@ function writeAutoUpdateFailure(plan, exitCode) {
     manualCommand: plan.manualCommand
   };
   try {
-    (0, import_node_fs21.mkdirSync)((0, import_node_path23.dirname)(path), { recursive: true });
+    (0, import_node_fs21.mkdirSync)((0, import_node_path24.dirname)(path), { recursive: true });
     (0, import_node_fs21.writeFileSync)(path, `${JSON.stringify(marker, null, 2)}
 `, "utf8");
   } catch {
@@ -35423,7 +36755,7 @@ function safeVersionSegment(value) {
   return /^[0-9A-Za-z._-]+$/.test(normalized) ? normalized : "";
 }
 function entryPathInVersionDir(versionDir) {
-  return (0, import_node_path23.join)(
+  return (0, import_node_path24.join)(
     versionDir,
     "node_modules",
     "deepline",
@@ -35433,7 +36765,7 @@ function entryPathInVersionDir(versionDir) {
   );
 }
 function installedPackageVersion(versionDir) {
-  const packageJsonPath = (0, import_node_path23.join)(
+  const packageJsonPath = (0, import_node_path24.join)(
     versionDir,
     "node_modules",
     "deepline",
@@ -35555,16 +36887,16 @@ async function runNpmInstallWithRegistryFallback(input2) {
   return first.exitCode;
 }
 function writeSidecarLauncher(input2) {
-  (0, import_node_fs21.mkdirSync)((0, import_node_path23.dirname)(input2.path), { recursive: true });
-  const packageRoot = (0, import_node_path23.dirname)((0, import_node_path23.dirname)((0, import_node_path23.dirname)(input2.entryPath)));
-  const versionDir = (0, import_node_path23.dirname)((0, import_node_path23.dirname)(packageRoot));
+  (0, import_node_fs21.mkdirSync)((0, import_node_path24.dirname)(input2.path), { recursive: true });
+  const packageRoot = (0, import_node_path24.dirname)((0, import_node_path24.dirname)((0, import_node_path24.dirname)(input2.entryPath)));
+  const versionDir = (0, import_node_path24.dirname)((0, import_node_path24.dirname)(packageRoot));
   const esbuildProbe = "const {createRequire}=require('node:module');const path=require('node:path');const req=createRequire(path.join(process.argv[1],'package.json'));const result=req('esbuild').transformSync('const value: number = 1;',{loader:'ts'});if(!result||typeof result.code!=='string')process.exit(3);";
   const criticalPaths = [
     ...SDK_SIDECAR_CRITICAL_PACKAGE_FILES.map(
-      (path) => (0, import_node_path23.join)(packageRoot, path)
+      (path) => (0, import_node_path24.join)(packageRoot, path)
     ),
     ...SDK_SIDECAR_CRITICAL_DEPENDENCY_FILES.map(
-      (path) => (0, import_node_path23.join)(versionDir, "node_modules", path)
+      (path) => (0, import_node_path24.join)(versionDir, "node_modules", path)
     )
   ];
   if (process.platform === "win32") {
@@ -35618,17 +36950,17 @@ function writeSidecarLauncher(input2) {
   );
 }
 async function runPythonSidecarUpdatePlan(plan) {
-  const versionsDir = (0, import_node_path23.join)(plan.stateDir, "versions");
-  const tempDir = (0, import_node_path23.join)(
+  const versionsDir = (0, import_node_path24.join)(plan.stateDir, "versions");
+  const tempDir = (0, import_node_path24.join)(
     versionsDir,
     `.tmp-sdk-update-${process.pid}-${Date.now()}`
   );
   (0, import_node_fs21.rmSync)(tempDir, { recursive: true, force: true });
   (0, import_node_fs21.mkdirSync)(tempDir, { recursive: true });
-  (0, import_node_fs21.writeFileSync)((0, import_node_path23.join)(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
+  (0, import_node_fs21.writeFileSync)((0, import_node_path24.join)(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
   const env = {
     ...process.env,
-    PATH: `${(0, import_node_path23.dirname)(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
+    PATH: `${(0, import_node_path24.dirname)(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
   };
   const installResult = await runCommand(
     plan.npmCommand,
@@ -35665,7 +36997,7 @@ async function runPythonSidecarUpdatePlan(plan) {
     (0, import_node_fs21.rmSync)(tempDir, { recursive: true, force: true });
     return 1;
   }
-  const finalDir = (0, import_node_path23.join)(versionsDir, installedVersion);
+  const finalDir = (0, import_node_path24.join)(versionsDir, installedVersion);
   const finalEntryPath = entryPathInVersionDir(finalDir);
   const finalFailure = sidecarInstallFailure(finalDir);
   let backupDir = null;
@@ -35674,7 +37006,7 @@ async function runPythonSidecarUpdatePlan(plan) {
   } else {
     let shouldPublishTemp = true;
     if ((0, import_node_fs21.existsSync)(finalDir)) {
-      backupDir = (0, import_node_path23.join)(
+      backupDir = (0, import_node_path24.join)(
         versionsDir,
         `.backup-${installedVersion}-${process.pid}-${Date.now()}`
       );
@@ -35749,27 +37081,27 @@ async function runPythonSidecarUpdatePlan(plan) {
     entryPath: finalEntryPath
   });
   (0, import_node_fs21.writeFileSync)(
-    (0, import_node_path23.join)(plan.stateDir, ".version"),
+    (0, import_node_path24.join)(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
   (0, import_node_fs21.writeFileSync)(
-    (0, import_node_path23.join)(plan.stateDir, ".install-method"),
+    (0, import_node_path24.join)(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
   (0, import_node_fs21.writeFileSync)(
-    (0, import_node_path23.join)(plan.stateDir, ".command-path"),
+    (0, import_node_path24.join)(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  (0, import_node_fs21.writeFileSync)((0, import_node_path23.join)(plan.stateDir, ".runner"), "node\n", "utf8");
-  (0, import_node_fs21.writeFileSync)((0, import_node_path23.join)(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  (0, import_node_fs21.writeFileSync)((0, import_node_path24.join)(plan.stateDir, ".runner"), "node\n", "utf8");
+  (0, import_node_fs21.writeFileSync)((0, import_node_path24.join)(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
   (0, import_node_fs21.writeFileSync)(
-    (0, import_node_path23.join)(plan.stateDir, ".entry-path"),
+    (0, import_node_path24.join)(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
     "utf8"
@@ -36698,12 +38030,12 @@ chooses the connected Slack channel or member and the events it receives.
 var import_commander3 = require("commander");
 var import_node_fs23 = require("fs");
 var import_node_os16 = require("os");
-var import_node_path25 = require("path");
+var import_node_path26 = require("path");
 
 // src/tool-output.ts
 var import_node_fs22 = require("fs");
 var import_node_os15 = require("os");
-var import_node_path24 = require("path");
+var import_node_path25 = require("path");
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -36830,19 +38162,19 @@ function projectRowOutput(conversion) {
   };
 }
 function ensureOutputDir() {
-  const outputDir = (0, import_node_path24.join)((0, import_node_os15.homedir)(), ".local", "share", "deepline", "data");
+  const outputDir = (0, import_node_path25.join)((0, import_node_os15.homedir)(), ".local", "share", "deepline", "data");
   (0, import_node_fs22.mkdirSync)(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = (0, import_node_path24.join)(outputDir, `${stem}_${Date.now()}.json`);
+  const outputPath = (0, import_node_path25.join)(outputDir, `${stem}_${Date.now()}.json`);
   (0, import_node_fs22.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem, options) {
-  const outputPath = options?.outPath ? options.outPath : (0, import_node_path24.join)(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
-  (0, import_node_fs22.mkdirSync)((0, import_node_path24.dirname)(outputPath), { recursive: true });
+  const outputPath = options?.outPath ? options.outPath : (0, import_node_path25.join)(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  (0, import_node_fs22.mkdirSync)((0, import_node_path25.dirname)(outputPath), { recursive: true });
   const columns = columnsForRows(rows);
   const escapeCell = (value) => {
     const normalized = value == null ? "" : typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
@@ -37178,9 +38510,9 @@ function requiredInputIds(tool) {
   return toolInputFieldsForDisplay(inputSchema).filter((field) => field.required === true).map((field) => String(field.name ?? "")).filter(Boolean);
 }
 function notConnectedSuffix(tool) {
-  const record = tool;
-  const status = stringField2(record, "credentialStatus", "credential_status");
-  const connected = record.connected;
+  const record2 = tool;
+  const status = stringField2(record2, "credentialStatus", "credential_status");
+  const connected = record2.connected;
   if (status === "requires_connection" || connected === false) {
     return " - \u26A0 requires your credentials \u2014 not connected (connect to use)";
   }
@@ -37555,19 +38887,19 @@ function printPlayAliasToolError(toolId, play) {
   console.error(playAliasToolErrorMessage(toolId, play));
 }
 function isPlayLikeTool(tool) {
-  const record = tool;
-  if (record.isPlay === true || record.is_play === true) return true;
-  const playExpansion = recordField2(record, "playExpansion", "play_expansion");
+  const record2 = tool;
+  if (record2.isPlay === true || record2.is_play === true) return true;
+  const playExpansion = recordField2(record2, "playExpansion", "play_expansion");
   if (Object.keys(playExpansion).length > 0) return true;
-  const toolId = typeof record.toolId === "string" ? record.toolId : "";
+  const toolId = typeof record2.toolId === "string" ? record2.toolId : "";
   return toolId.endsWith("_waterfall");
 }
 function isMonitorTypeTool(tool) {
   return stringField2(tool, "kind") === "monitor_type";
 }
 function playReferenceForTool(tool) {
-  const record = tool;
-  const declared = stringField2(record, "playReference", "play_reference");
+  const record2 = tool;
+  const declared = stringField2(record2, "playReference", "play_reference");
   if (declared.startsWith("prebuilt/")) {
     return declared;
   }
@@ -38525,12 +39857,12 @@ function singleLineText(value, maxLength = 260) {
   return `${text.slice(0, maxLength - 3).trimEnd()}...`;
 }
 function listedToolDescription(tool) {
-  const record = tool;
-  return singleLineText(record.bestFor ?? record.best_for ?? tool.description);
+  const record2 = tool;
+  return singleLineText(record2.bestFor ?? record2.best_for ?? tool.description);
 }
 function formatListedToolCost(tool) {
-  const record = tool;
-  const pricing = recordField2(record, "pricing");
+  const record2 = tool;
+  const pricing = recordField2(record2, "pricing");
   const displayText = stringField2(pricing, "displayText", "display_text");
   return displayText ? `Cost: ${displayText}` : "";
 }
@@ -38811,10 +40143,10 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = (0, import_node_path25.resolve)(trimmed);
+  const resolved = (0, import_node_path26.resolve)(trimmed);
   if ((0, import_node_fs23.existsSync)(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = (0, import_node_path25.resolve)(trimmed.replace(/\\/g, "/"));
+    const normalized = (0, import_node_path26.resolve)(trimmed.replace(/\\/g, "/"));
     if ((0, import_node_fs23.existsSync)(normalized)) return normalized;
   }
   return resolved;
@@ -38903,7 +40235,7 @@ function parseExecuteOptions(args) {
       continue;
     }
     if ((arg === "--out" || arg === "-o") && args[index + 1]) {
-      outPath = (0, import_node_path25.resolve)(args[++index]);
+      outPath = (0, import_node_path26.resolve)(args[++index]);
       continue;
     }
     throw new Error(`Unknown option: ${arg}`);
@@ -38933,9 +40265,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = (0, import_node_fs23.mkdtempSync)((0, import_node_path25.join)((0, import_node_os16.tmpdir)(), "deepline-workflow-seed-"));
+  const scriptDir = (0, import_node_fs23.mkdtempSync)((0, import_node_path26.join)((0, import_node_os16.tmpdir)(), "deepline-workflow-seed-"));
   (0, import_node_fs23.chmodSync)(scriptDir, 448);
-  const scriptPath = (0, import_node_path25.join)(scriptDir, fileName);
+  const scriptPath = (0, import_node_path26.join)(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(/\]$/, "")}, ...]` : "[]";
@@ -39404,10 +40736,10 @@ Examples:
 
 // src/cli/commands/workflow.ts
 var import_promises9 = require("fs/promises");
-var import_node_path26 = require("path");
+var import_node_path27 = require("path");
 
 // src/cli/workflow-to-play.ts
-var import_node_crypto8 = require("crypto");
+var import_node_crypto9 = 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_";
@@ -39513,7 +40845,7 @@ function sanitizePlayNameSegment(value) {
 }
 function deriveWorkflowPlayName(workflowName) {
   const base = sanitizePlayNameSegment(workflowName) || "workflow";
-  const suffix = (0, import_node_crypto8.createHash)("sha256").update(workflowName).digest("hex").slice(0, 8);
+  const suffix = (0, import_node_crypto9.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}`;
@@ -39610,9 +40942,9 @@ function clientWithTimeout(timeoutSeconds) {
 }
 function readStatus(payload) {
   if (!payload || typeof payload !== "object") return null;
-  const record = payload;
-  if (typeof record.status === "string") return record.status;
-  const run = record.run;
+  const record2 = payload;
+  if (typeof record2.status === "string") return record2.status;
+  const run = record2.run;
   if (run && typeof run === "object") {
     const status = run.status;
     if (typeof status === "string") return status;
@@ -39621,7 +40953,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await (0, import_promises9.readFile)((0, import_node_path26.resolve)(file), "utf8");
+    const raw = await (0, import_promises9.readFile)((0, import_node_path27.resolve)(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -39655,8 +40987,8 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = (0, import_node_path26.join)((0, import_node_path26.resolve)(outDir), `${compiled.playName}.play.ts`);
-    await (0, import_promises9.mkdir)((0, import_node_path26.dirname)(file), { recursive: true });
+    const file = (0, import_node_path27.join)((0, import_node_path27.resolve)(outDir), `${compiled.playName}.play.ts`);
+    await (0, import_promises9.mkdir)((0, import_node_path27.dirname)(file), { recursive: true });
     await (0, import_promises9.writeFile)(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
@@ -40035,7 +41367,7 @@ function isDowngradeAutoUpdateResponse(response) {
   return compareSemver(target, current) < 0;
 }
 function relaunchCurrentCommand(plan) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const command = plan.kind === "python-sidecar" ? plan.sidecarPath : process.execPath;
     const args = plan.kind === "python-sidecar" ? process.argv.slice(2) : process.argv.slice(1);
     const child = (0, import_node_child_process6.spawn)(command, args, {
@@ -40051,9 +41383,9 @@ function relaunchCurrentCommand(plan) {
         `Deepline SDK/CLI updated, but relaunch failed: ${error.message}
 `
       );
-      resolve20(1);
+      resolve21(1);
     });
-    child.on("close", (code) => resolve20(code ?? 1));
+    child.on("close", (code) => resolve21(code ?? 1));
   });
 }
 async function maybeAutoUpdateAndRelaunch(response, baseUrl) {
@@ -40201,8 +41533,8 @@ function classifyNetworkFailure(error) {
   let current = error;
   while (current && !seen.has(current)) {
     seen.add(current);
-    const record = typeof current === "object" && current !== null ? current : {};
-    const code = String(record.code ?? "").toLowerCase();
+    const record2 = typeof current === "object" && current !== null ? current : {};
+    const code = String(record2.code ?? "").toLowerCase();
     const name = current instanceof Error ? current.name.toLowerCase() : "";
     const text = String(
       current instanceof Error ? current.message : current
@@ -40229,7 +41561,7 @@ function classifyNetworkFailure(error) {
     if (combined.includes("ssl") || combined.includes("tls") || combined.includes("unexpected_eof_while_reading")) {
       return "network_ssl_error";
     }
-    current = record.cause ?? record.context;
+    current = record2.cause ?? record2.context;
   }
   return "network_error";
 }
@@ -40444,8 +41776,8 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await (0, import_promises10.mkdtemp)((0, import_node_path27.join)((0, import_node_os18.tmpdir)(), "deepline-health-play-"));
-  const file = (0, import_node_path27.join)(dir, "health-check.play.ts");
+  const dir = await (0, import_promises10.mkdtemp)((0, import_node_path28.join)((0, import_node_os18.tmpdir)(), "deepline-health-play-"));
+  const file = (0, import_node_path28.join)(dir, "health-check.play.ts");
   try {
     await (0, import_promises10.writeFile)(
       file,