deepline 0.3.55 → 0.3.56

package/dist/cli/index.mjs

@@ -1060,7 +1060,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.56",
   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
@@ -2197,7 +2197,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)) {
@@ -3100,9 +3100,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 };
 }
@@ -3962,14 +3962,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) {
@@ -4162,21 +4162,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;
@@ -4328,7 +4328,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") {
@@ -4760,7 +4760,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"`). */
@@ -7068,6 +7075,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.
    *
@@ -7746,30 +7851,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;
@@ -8158,7 +8263,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) {
@@ -10261,9 +10366,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;
@@ -11430,16 +11535,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) {
@@ -12491,8 +12596,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)) {
@@ -15370,11 +15475,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
@@ -15398,11 +15503,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
   );
@@ -15470,11 +15575,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
   );
@@ -16546,13 +16651,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) {
@@ -16561,22 +16666,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,
@@ -16675,14 +16780,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"
       );
@@ -16730,7 +16835,7 @@ function validateFixtureBehavior(value) {
         ...syntheticFallbackToolIds ? { syntheticFallbackToolIds } : {}
       };
     }
-    if (record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+    if (record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
       return {
         ok: true,
         behavior: {
@@ -16748,15 +16853,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,
@@ -16965,7 +17070,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();
@@ -17498,8 +17603,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) {
@@ -18000,8 +18105,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;
 }
@@ -18303,8 +18408,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;
     }
@@ -18321,7 +18426,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;
@@ -19150,17 +19255,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;
   }
@@ -19557,8 +19662,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;
   }
@@ -19671,9 +19776,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;
     }
@@ -19700,13 +19805,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);
@@ -19722,7 +19827,7 @@ function formatPackageDatasetSummaryLines(summary, indent2 = "    ") {
     }
   }
   const parts = formatSummaryScalarParts(
-    record,
+    record2,
     /* @__PURE__ */ new Set(["columnStats", "rowCounts"])
   );
   if (parts.length > 0) {
@@ -19752,35 +19857,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;
 }
@@ -20185,12 +20290,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",
@@ -20542,8 +20647,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");
 }
@@ -26315,7 +26420,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();
@@ -26424,9 +26529,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"]) {
@@ -27224,26 +27329,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;
       }
@@ -27259,8 +27364,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) {
@@ -27604,12 +27709,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);
   }
 }
@@ -27795,23 +27900,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];
@@ -27820,18 +27925,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",
@@ -28050,16 +28155,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",
@@ -28074,11 +28179,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)
     );
   }
@@ -28094,8 +28199,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);
 }
@@ -28682,8 +28787,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();
@@ -28745,19 +28850,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}`,
@@ -28774,7 +28879,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;
     }
@@ -30206,9 +30311,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 {
@@ -30307,15 +30412,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) {
@@ -30330,9 +30435,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;
@@ -30351,9 +30456,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;
     }
@@ -30398,9 +30503,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(
@@ -30408,7 +30513,7 @@ function selectiveCompactToolResults(raw) {
         );
       }
     }
-    lines.push(JSON.stringify(record));
+    lines.push(JSON.stringify(record2));
   }
   return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf8");
@@ -30434,15 +30539,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] ?? "");
@@ -30905,8 +31010,325 @@ Examples:
 }
 
 // src/cli/commands/monitors.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync12 } from "fs";
+import { resolve as resolve14 } from "path";
 import { createInterface } from "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);
@@ -30928,6 +31350,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;
@@ -30938,12 +31361,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";
   }
@@ -30969,9 +31394,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);
@@ -30979,10 +31405,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)) {
@@ -31533,6 +31964,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}-${randomUUID5()}`;
+}
+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 = resolve14(out);
+  writeFileSync12(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 = 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);
@@ -31782,7 +32931,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:
@@ -32053,6 +33204,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>",
@@ -32755,7 +34081,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);
@@ -32773,7 +34099,7 @@ async function readHiddenLine(prompt, streams = {}) {
       settled = true;
       outputStream.write("\n");
       cleanup();
-      resolve20(line);
+      resolve21(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -32951,10 +34277,10 @@ import {
   mkdirSync as mkdirSync11,
   readFileSync as readFileSync14,
   realpathSync as realpathSync4,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname16, join as join16, resolve as resolve15 } from "path";
+import { dirname as dirname16, join as join16, resolve as resolve16 } from "path";
 
 // src/cli/installation-lifecycle.ts
 import {
@@ -32964,7 +34290,7 @@ import {
   realpathSync as realpathSync3,
   rmSync as rmSync4
 } from "fs";
-import { basename as basename6, dirname as dirname13, join as join13, relative as relative5, resolve as resolve14 } from "path";
+import { basename as basename6, dirname as dirname13, join as join13, relative as relative5, resolve as resolve15 } from "path";
 var nodeFileSystem = {
   exists: existsSync11,
   isSymbolicLink(path) {
@@ -33079,14 +34405,14 @@ function isOwnedInstallerCommandPath(input2) {
   if (!input2.commandPath || basename6(input2.commandPath) !== "deepline") {
     return false;
   }
-  const commandPath = resolve14(input2.commandPath);
-  const fromHost = relative5(resolve14(input2.hostDir), commandPath);
+  const commandPath = resolve15(input2.commandPath);
+  const fromHost = relative5(resolve15(input2.hostDir), commandPath);
   return fromHost !== "" && fromHost !== ".." && !fromHost.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`);
 }
 
 // src/cli/commands/skills.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir8 } from "os";
 import { dirname as dirname15, join as join15 } from "path";
 
@@ -33203,7 +34529,7 @@ import {
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync12,
   unlinkSync,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "fs";
 import { dirname as dirname14, join as join14 } from "path";
 
@@ -33261,7 +34587,7 @@ function readMarkedSkillsSyncVersion(path) {
 function writeMarkedSkillsSyncVersion(path, version) {
   try {
     mkdirSync9(dirname14(path), { recursive: true });
-    writeFileSync12(path, `${version}
+    writeFileSync13(path, `${version}
 `, "utf-8");
   } catch {
   }
@@ -33414,7 +34740,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 = spawn2(plan.command, plan.args, {
       stdio: ["ignore", "ignore", "pipe"],
@@ -33426,7 +34752,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
@@ -33434,11 +34760,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
@@ -33720,7 +35046,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 = spawn3(plan.command, plan.args, {
       cwd,
@@ -33739,7 +35065,7 @@ function runProcess(command, args, cwd) {
         process.stderr.write(`${SKILLS_NPX_PACKAGE} exited ${code}.
 `);
       }
-      resolve20(code ?? 1);
+      resolve21(code ?? 1);
     });
   });
 }
@@ -33867,7 +35193,7 @@ async function runSkillsCommand(options, dependencies = {}) {
     );
   }
   mkdirSync10(dirname15(plan.statePath), { recursive: true });
-  writeFileSync13(
+  writeFileSync14(
     plan.statePath,
     `${JSON.stringify(
       {
@@ -33962,26 +35288,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;
     }
   }
@@ -34129,7 +35455,7 @@ function resolvePathCommands(command) {
   );
   return [
     ...new Set(
-      String(lookup.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => resolve15(path))
+      String(lookup.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => resolve16(path))
     )
   ];
 }
@@ -34177,11 +35503,11 @@ function pathsResolveToSameFile(left, right) {
   try {
     return realpathSync4(left) === realpathSync4(right);
   } catch {
-    return resolve15(left) === resolve15(right);
+    return resolve16(left) === resolve16(right);
   }
 }
 function isKnownDeeplineCommand(path) {
-  const entrypoint = process.argv[1] ? resolve15(process.argv[1]) : "";
+  const entrypoint = process.argv[1] ? resolve16(process.argv[1]) : "";
   let resolvedPath = path;
   try {
     resolvedPath = realpathSync4(path);
@@ -34207,7 +35533,7 @@ function inspectPathConflict() {
 function writeSetupState(input2) {
   const path = setupStatePath(input2.baseUrl, input2.scope, input2.root);
   mkdirSync11(dirname16(path), { recursive: true });
-  writeFileSync14(
+  writeFileSync15(
     path,
     `${JSON.stringify(
       {
@@ -34334,7 +35660,7 @@ 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] ? resolve15(process.argv[1]) : null;
+  const runningCliPath = process.argv[1] ? resolve16(process.argv[1]) : null;
   const globalCli = input2.scope === "global" ? inspectGlobalCliAvailability() : null;
   const pathGlobalCli = globalCli?.path ?? null;
   const cliPath = input2.scope === "global" ? pathGlobalCli : runningCliPath;
@@ -34877,7 +36203,7 @@ import {
   readFileSync as readFileSync15,
   renameSync,
   rmSync as rmSync5,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync16
 } from "fs";
 import { homedir as homedir10 } from "os";
 import { dirname as dirname17, join as join17 } from "path";
@@ -34939,7 +36265,7 @@ function writeCliUpdatePreferences(preferences, homeDir2 = homedir10()) {
   const tempPath = `${path}.${process.pid}.tmp`;
   mkdirSync12(dirname17(path), { recursive: true });
   try {
-    writeFileSync15(tempPath, `${JSON.stringify(preferences, null, 2)}
+    writeFileSync16(tempPath, `${JSON.stringify(preferences, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384
@@ -35004,7 +36330,7 @@ import {
   renameSync as renameSync2,
   rmSync as rmSync6,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync16
+  writeFileSync as writeFileSync17
 } from "fs";
 import { homedir as homedir11 } from "os";
 import {
@@ -35013,13 +36339,13 @@ import {
   isAbsolute as isAbsolute7,
   join as join19,
   relative as relative7,
-  resolve as resolve17
+  resolve as resolve18
 } from "path";
 
 // src/cli/install-integrity.ts
 import { createRequire } from "module";
 import { existsSync as existsSync16, readFileSync as readFileSync16, statSync as statSync5 } from "fs";
-import { isAbsolute as isAbsolute6, join as join18, relative as relative6, resolve as resolve16 } from "path";
+import { isAbsolute as isAbsolute6, join as join18, relative as relative6, resolve as resolve17 } from "path";
 var SDK_SIDECAR_CRITICAL_PACKAGE_FILES = [
   "dist/cli/index.mjs",
   "dist/index.mjs",
@@ -35044,8 +36370,8 @@ function safeRelativePath(value) {
 }
 function resolveContainedPath(root, value) {
   if (!safeRelativePath(value)) return null;
-  const target = resolve16(root, value);
-  const relativeTarget = relative6(resolve16(root), target);
+  const target = resolve17(root, value);
+  const relativeTarget = relative6(resolve17(root), target);
   if (!relativeTarget || relativeTarget.startsWith("..") || isAbsolute6(relativeTarget)) {
     return null;
   }
@@ -35271,8 +36597,8 @@ function resolvePythonSidecarUpdatePlan(options) {
   const stateDir = sidecarStateDir(options);
   if (!stateDir) return null;
   const relativeEntrypoint = relative7(
-    resolve17(stateDir),
-    resolve17(options.entrypoint)
+    resolve18(stateDir),
+    resolve18(options.entrypoint)
   );
   if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || isAbsolute7(relativeEntrypoint)) {
     return null;
@@ -35306,7 +36632,7 @@ function resolvePythonSidecarUpdatePlan(options) {
   };
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = resolve17(startPath);
+  let current = resolve18(startPath);
   while (true) {
     if (existsSync17(join19(current, "package.json")) && existsSync17(join19(current, "bin", "deepline-dev.ts"))) {
       const parent2 = dirname18(current);
@@ -35325,7 +36651,7 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
     try {
       return realpathSync5(entrypoint);
     } catch {
-      return resolve17(entrypoint);
+      return resolve18(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -35341,9 +36667,9 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
     const knownWindowsPrefixes = [
       env.npm_config_prefix,
       env.APPDATA ? join19(env.APPDATA, "npm") : void 0
-    ].filter((value) => Boolean(value)).map((value) => resolve17(value).replace(/\\/g, "/").toLowerCase());
+    ].filter((value) => Boolean(value)).map((value) => resolve18(value).replace(/\\/g, "/").toLowerCase());
     if (!knownWindowsPrefixes.includes(
-      resolve17(directPrefix).replace(/\\/g, "/").toLowerCase()
+      resolve18(directPrefix).replace(/\\/g, "/").toLowerCase()
     )) {
       return null;
     }
@@ -35356,9 +36682,9 @@ function normalizedNpmPrefix(value) {
   if (!trimmed) return null;
   const normalized = (() => {
     try {
-      return realpathSync5(resolve17(trimmed));
+      return realpathSync5(resolve18(trimmed));
     } catch {
-      return resolve17(trimmed);
+      return resolve18(trimmed);
     }
   })().replace(/\\/g, "/");
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
@@ -35383,7 +36709,7 @@ function isHomebrewFormulaEntrypoint(entrypoint) {
     try {
       return realpathSync5(entrypoint);
     } catch {
-      return resolve17(entrypoint);
+      return resolve18(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -35393,7 +36719,7 @@ function isHomebrewFormulaEntrypoint(entrypoint) {
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
   const homeDir2 = options.homeDir ?? homedir11();
-  const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve17(process.argv[1]) : "");
+  const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve18(process.argv[1]) : "");
   const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname18(entrypoint)) : null;
   if (sourceRoot) {
     return {
@@ -35487,7 +36813,7 @@ function writeAutoUpdateFailure(plan, exitCode) {
   };
   try {
     mkdirSync13(dirname18(path), { recursive: true });
-    writeFileSync16(path, `${JSON.stringify(marker, null, 2)}
+    writeFileSync17(path, `${JSON.stringify(marker, null, 2)}
 `, "utf8");
   } catch {
   }
@@ -35679,7 +37005,7 @@ function writeSidecarLauncher(input2) {
     )
   ];
   if (process.platform === "win32") {
-    writeFileSync16(
+    writeFileSync17(
       input2.path,
       [
         `@set DEEPLINE_HOST_URL=${input2.hostUrl.replace(/\r?\n/g, "")}`,
@@ -35702,7 +37028,7 @@ function writeSidecarLauncher(input2) {
     );
     return;
   }
-  writeFileSync16(
+  writeFileSync17(
     input2.path,
     [
       "#!/usr/bin/env sh",
@@ -35736,7 +37062,7 @@ async function runPythonSidecarUpdatePlan(plan) {
   );
   rmSync6(tempDir, { recursive: true, force: true });
   mkdirSync13(tempDir, { recursive: true });
-  writeFileSync16(join19(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
+  writeFileSync17(join19(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
   const env = {
     ...process.env,
     PATH: `${dirname18(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
@@ -35859,27 +37185,27 @@ async function runPythonSidecarUpdatePlan(plan) {
     nodeBin: plan.nodeBin,
     entryPath: finalEntryPath
   });
-  writeFileSync16(
+  writeFileSync17(
     join19(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
-  writeFileSync16(
+  writeFileSync17(
     join19(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
-  writeFileSync16(
+  writeFileSync17(
     join19(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  writeFileSync16(join19(plan.stateDir, ".runner"), "node\n", "utf8");
-  writeFileSync16(join19(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  writeFileSync17(join19(plan.stateDir, ".runner"), "node\n", "utf8");
+  writeFileSync17(join19(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
-  writeFileSync16(
+  writeFileSync17(
     join19(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
@@ -36812,17 +38138,17 @@ import {
   existsSync as existsSync18,
   mkdtempSync,
   readFileSync as readFileSync18,
-  writeFileSync as writeFileSync18
+  writeFileSync as writeFileSync19
 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join21, resolve as resolve18 } from "path";
+import { join as join21, resolve as resolve19 } from "path";
 
 // src/tool-output.ts
 import {
   closeSync as closeSync3,
   mkdirSync as mkdirSync14,
   openSync as openSync3,
-  writeFileSync as writeFileSync17,
+  writeFileSync as writeFileSync18,
   writeSync
 } from "fs";
 import { homedir as homedir12 } from "os";
@@ -36960,7 +38286,7 @@ function ensureOutputDir() {
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
   const outputPath = join20(outputDir, `${stem}_${Date.now()}.json`);
-  writeFileSync17(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  writeFileSync18(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem, options) {
@@ -37301,9 +38627,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)";
   }
@@ -37678,19 +39004,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;
   }
@@ -38648,12 +39974,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}` : "";
 }
@@ -38934,10 +40260,10 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = resolve18(trimmed);
+  const resolved = resolve19(trimmed);
   if (existsSync18(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = resolve18(trimmed.replace(/\\/g, "/"));
+    const normalized = resolve19(trimmed.replace(/\\/g, "/"));
     if (existsSync18(normalized)) return normalized;
   }
   return resolved;
@@ -39026,7 +40352,7 @@ function parseExecuteOptions(args) {
       continue;
     }
     if ((arg === "--out" || arg === "-o") && args[index + 1]) {
-      outPath = resolve18(args[++index]);
+      outPath = resolve19(args[++index]);
       continue;
     }
     throw new Error(`Unknown option: ${arg}`);
@@ -39101,7 +40427,7 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
   description: ${JSON.stringify(`Seed ${input2.toolId} rows into a Deepline workflow-ready dataset.`)},
 });
 `;
-  writeFileSync18(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  writeFileSync19(scriptPath, script, { encoding: "utf-8", mode: 384 });
   return {
     path: scriptPath,
     sourceCode: script,
@@ -39527,7 +40853,7 @@ Examples:
 
 // src/cli/commands/workflow.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname20, join as join22, resolve as resolve19 } from "path";
+import { dirname as dirname20, join as join22, resolve as resolve20 } from "path";
 
 // src/cli/workflow-to-play.ts
 import { createHash as createHash5 } from "crypto";
@@ -39733,9 +41059,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;
@@ -39744,7 +41070,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await readFile4(resolve19(file), "utf8");
+    const raw = await readFile4(resolve20(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -39778,7 +41104,7 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = join22(resolve19(outDir), `${compiled.playName}.play.ts`);
+    const file = join22(resolve20(outDir), `${compiled.playName}.play.ts`);
     await mkdir5(dirname20(file), { recursive: true });
     await writeFile5(file, compiled.sourceCode, "utf8");
     let published = false;
@@ -40158,7 +41484,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 = spawn5(command, args, {
@@ -40174,9 +41500,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) {
@@ -40324,8 +41650,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
@@ -40352,7 +41678,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";
 }