deepline 0.3.293 → 0.3.295

package/dist/cli/monitors-TTD55HMK.mjs

@@ -0,0 +1,3251 @@
+import "./chunk-EXMLR72R.mjs";
+import {
+  DeeplineClient
+} from "./chunk-XL2FO6CW.mjs";
+import "./chunk-CBVIJSHF.mjs";
+import {
+  MONITOR_FLEET_DOCUMENTATION,
+  lintMonitorFleetInput
+} from "./chunk-HUZXWOSK.mjs";
+import "./chunk-4MBOJQPL.mjs";
+import {
+  lintMonitorBatchInput
+} from "./chunk-TAC3JIFE.mjs";
+import {
+  errorToJsonPayload,
+  printCommandEnvelope,
+  printJson,
+  shouldEmitJson
+} from "./chunk-6O5YZOVN.mjs";
+import {
+  AuthError
+} from "./chunk-EACVZI6N.mjs";
+import "./chunk-DLIRSHV6.mjs";
+import "./chunk-LDWT7RJK.mjs";
+import "./chunk-GVUJJJ5G.mjs";
+import {
+  DeeplineError
+} from "./chunk-NXGCO4JB.mjs";
+import "./chunk-WZYKRD7T.mjs";
+import "./chunk-KRD6H754.mjs";
+
+// src/cli/commands/monitors.ts
+import { randomUUID } from "crypto";
+import { readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { createInterface } from "readline/promises";
+var JSON_OPTION_DESCRIPTION = "Emit JSON output. Also automatic when stdout is piped";
+function withJsonOption(command) {
+  return command.option("--json", JSON_OPTION_DESCRIPTION);
+}
+var COMPACT_OPTION_DESCRIPTION = "Ask the server for high-signal fields only (smaller output for agent loops)";
+var MonitorsUsageError = class extends Error {
+  code = "MONITORS_USAGE_ERROR";
+  constructor(message) {
+    super(message);
+    this.name = "MonitorsUsageError";
+  }
+};
+var MonitorDryRunUnsupportedError = class extends Error {
+  code = "MONITOR_DRY_RUN_UNSUPPORTED";
+  constructor(message) {
+    super(message);
+    this.name = "MonitorDryRunUnsupportedError";
+  }
+};
+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;
+    if (status === 401 || status === 403) return 3;
+    if (status === 404) return 4;
+    if (status === 400 || status === 409 || status === 422) return 7;
+    return 5;
+  }
+  return 5;
+}
+function monitorsFailureNextCommand(error, exitCode, options) {
+  if (error instanceof MonitorFleetStateError) return error.next;
+  if (error instanceof DeeplineError) {
+    const response = asRecord(asRecord(error.details)?.response);
+    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";
+  }
+  if (error instanceof DeeplineError && error.code === "monitor_tool_not_found") {
+    return "deepline monitors available --json";
+  }
+  if (exitCode === 3) return "deepline auth status --json";
+  if (exitCode === 4) return "deepline monitors list --status all --json";
+  return void 0;
+}
+function readValidationIssues(error) {
+  if (!(error instanceof DeeplineError)) return [];
+  const response = asRecord(asRecord(error.details)?.response);
+  const issues = Array.isArray(response?.issues) ? response.issues : [];
+  return issues.flatMap((raw) => {
+    const issue = asRecord(raw);
+    if (!issue) return [];
+    return [
+      {
+        ...asString(issue.path) ? { path: asString(issue.path) } : {},
+        ...asString(issue.message) ? { message: asString(issue.message) } : {}
+      }
+    ];
+  });
+}
+function reportMonitorsFailure(error, options) {
+  const exitCode = monitorsErrorExitCode(error);
+  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);
+    printJson({
+      ok: false,
+      exitCode,
+      ...next ? { next } : {},
+      ...retrySafe ? { retry_safe: true } : {},
+      error: retrySafe ? {
+        ...payload.error,
+        message: `${payload.error.message} ${FLEET_RETRY_SAFE_NOTE}`
+      } : payload.error
+    });
+  } else {
+    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)) {
+      process.stderr.write(
+        `  - ${issue.path ? `${issue.path}: ` : ""}${issue.message ?? ""}
+`
+      );
+    }
+    if (next) process.stderr.write(`Next: ${next}
+`);
+  }
+  process.exitCode = exitCode;
+}
+function monitorsAction(handler) {
+  return async (...args) => {
+    try {
+      await handler(...args);
+    } catch (error) {
+      reportMonitorsFailure(error);
+    }
+  };
+}
+function parseJsonObjectArg(raw, argLabel) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new MonitorsUsageError(
+      `${argLabel} must be a JSON object. ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new MonitorsUsageError(`${argLabel} must be a JSON object.`);
+  }
+  return parsed;
+}
+function resolveMonitorJsonBody(input) {
+  const readFile = input.readFile ?? ((path) => readFileSync(path, "utf-8"));
+  const readStdin = input.readStdin ?? (() => readFileSync(0, "utf-8"));
+  if (input.positional !== void 0 && input.file !== void 0) {
+    throw new MonitorsUsageError(
+      `Pass exactly one source for ${input.argLabel}: the positional JSON or --file, not both.`
+    );
+  }
+  if (input.positional !== void 0) {
+    return parseJsonObjectArg(input.positional, input.argLabel);
+  }
+  if (input.file !== void 0) {
+    if (input.file === "-") {
+      return parseJsonObjectArg(readStdin(), `${input.argLabel} (stdin)`);
+    }
+    let raw;
+    try {
+      raw = readFile(input.file);
+    } catch (error) {
+      throw new MonitorsUsageError(
+        `Could not read --file ${input.file}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return parseJsonObjectArg(raw, `${input.argLabel} (--file ${input.file})`);
+  }
+  throw new MonitorsUsageError(
+    `${input.command} needs ${input.argLabel} (a JSON object). Pass it positionally:
+  ${input.command} '{"key":"job-openings","tool":"deepline_native.company_radar","payload":{"domain":"stripe.com","radar_type":"company_job_openings"}}'
+or from a file / stdin:
+  ${input.command} --file monitor.json
+  cat monitor.json | ${input.command} --file -`
+  );
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+var MONITOR_STATES = /* @__PURE__ */ new Set([
+  "active",
+  "billing_suspended",
+  "disabled"
+]);
+function customerMonitorState(value) {
+  if (typeof value === "string" && MONITOR_STATES.has(value)) {
+    return value;
+  }
+  return void 0;
+}
+function readMonitorState(record) {
+  const state = customerMonitorState(record.state);
+  if (state) return state;
+  const legacyStatus = asString(record.status);
+  if (legacyStatus === "active") return "active";
+  if (legacyStatus === "billing_suspended") return "billing_suspended";
+  if (legacyStatus === "disabled") return "disabled";
+  if (legacyStatus === "inactive") return "disabled";
+  if (typeof record.active === "boolean") {
+    return record.active ? "active" : "disabled";
+  }
+  return void 0;
+}
+function monitorStateFilter(value) {
+  if (value === "all") return "all";
+  return customerMonitorState(value);
+}
+function monitorStateFilterLabel(value, fallback = "active") {
+  const canonical = monitorStateFilter(value);
+  if (canonical) return canonical;
+  if (value === "inactive") return "disabled";
+  return fallback;
+}
+function asFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function monitorPricingLine(rawPricing) {
+  const pricing = asRecord(rawPricing);
+  if (!pricing) return void 0;
+  const display = asString(pricing.display);
+  if (display) return display;
+  const credits = asFiniteNumber(pricing.deepline_credits);
+  const basis = asString(pricing.billing_basis);
+  if (credits === void 0 || !basis) return void 0;
+  return `${credits} Deepline credits (${basis.replaceAll("_", " ")})`;
+}
+function yesNo(value) {
+  if (value === true) return "yes";
+  if (value === false) return "no";
+  return "unknown";
+}
+function readDeployOutputContract(payload) {
+  const contract = asRecord(payload.output_contract);
+  if (!contract) return { streams: [] };
+  const rawOutputs = Array.isArray(contract.outputs) ? contract.outputs : [];
+  const streams = rawOutputs.flatMap((raw) => {
+    const output = asRecord(raw);
+    const stream = output ? asString(output.stream) : void 0;
+    const table = output ? asString(output.table) : void 0;
+    if (!output || !stream || !table) return [];
+    const columns = Array.isArray(output.columns) ? output.columns.flatMap((rawColumn) => {
+      const column = asRecord(rawColumn);
+      const name = column ? asString(column.name) : void 0;
+      return name ? [name] : [];
+    }) : [];
+    return [
+      {
+        stream,
+        table,
+        columns,
+        isEvent: output.is_event_stream === true,
+        matchesPayload: output.matches_payload === true
+      }
+    ];
+  });
+  return { tool: asString(contract.tool), streams };
+}
+function renderDeployReplacementWarning(input) {
+  const summary = asRecord(input.payload.change_summary);
+  const upstream = summary ? asRecord(summary.upstream) : void 0;
+  if (!summary || !upstream || upstream.resource_replaced !== true) return [];
+  const definition = asRecord(summary.definition);
+  const changed = definition && Array.isArray(definition.changed) ? definition.changed : [];
+  const lines = [
+    input.completed ? "WARNING: this deploy replaced the existing upstream monitor." : "WARNING: this deploy replaces the existing upstream monitor.",
+    "Existing Customer DB rows are preserved. Provider backfill is not implied."
+  ];
+  for (const raw of changed) {
+    const item = asRecord(raw);
+    const path = item ? asString(item.path) : void 0;
+    if (!item || !path) continue;
+    lines.push(
+      `  ${path}: ${JSON.stringify(item.before ?? null)} \u2192 ${JSON.stringify(
+        item.after ?? null
+      )}`
+    );
+  }
+  lines.push(
+    input.monitorKey ? `Use \`deepline monitors update ${input.monitorKey} <patch>\` for a patch-style change.` : "Use `deepline monitors update <key> <patch>` for a patch-style change."
+  );
+  return lines;
+}
+function renderDeployFilterRemovalWarning(payload) {
+  const summary = asRecord(payload.change_summary);
+  const definition = summary ? asRecord(summary.definition) : void 0;
+  const changed = definition && Array.isArray(definition.changed) ? definition.changed : [];
+  const removed = changed.some((raw) => {
+    const item = asRecord(raw);
+    return asString(item?.path) === "payload.job_titles" && item?.before != null && item.after == null;
+  });
+  return removed ? [
+    "WARNING: this full deploy removes the job_titles filter.",
+    "Future findings will be unfiltered. Existing Customer DB rows are preserved.",
+    'Use `deepline monitors update <key> {"payload":{"job_titles":"..."}}` to change only the filter.'
+  ] : [];
+}
+function renderMonitorDeployCompletion(payload) {
+  const monitor = asRecord(payload.monitor);
+  const key = monitor ? asString(monitor.key) : void 0;
+  const { tool, streams } = readDeployOutputContract(payload);
+  if (!key || streams.length === 0) return void 0;
+  const toolId = tool ?? (monitor ? asString(monitor.tool) : void 0) ?? "<tool>";
+  const name = monitor ? asString(monitor.name) : void 0;
+  const state = monitor ? readMonitorState(monitor) : void 0;
+  const pricingLine = monitorPricingLine(monitor?.pricing ?? payload.pricing);
+  const eventStreams = streams.filter((stream) => stream.isEvent);
+  const matched = eventStreams.filter((stream) => stream.matchesPayload);
+  const shown = matched.length ? matched : eventStreams.length ? eventStreams : streams;
+  const primary = shown[0];
+  const lines = [
+    `\u2713 Deployed monitor "${key}"${name ? ` (${name})` : ""} \u2014 tool ${toolId}${state ? `, status ${state}` : ""}`,
+    "",
+    "Output \u2192 Customer DB:"
+  ];
+  for (const stream of shown) {
+    lines.push(`  ${stream.table}  (stream: ${stream.stream})`);
+    lines.push(
+      `    columns: ${stream.columns.length ? stream.columns.join(", ") : "(promoted dynamically as events arrive)"}`
+    );
+  }
+  if (pricingLine) {
+    lines.push("", `Pricing: ${pricingLine}`);
+  }
+  const replacementWarning = renderDeployReplacementWarning({
+    payload,
+    completed: true,
+    monitorKey: key
+  });
+  if (replacementWarning.length) lines.push("", ...replacementWarning);
+  const filterRemovalWarning = renderDeployFilterRemovalWarning(payload);
+  if (filterRemovalWarning.length) lines.push("", ...filterRemovalWarning);
+  const guidance = asRecord(payload.setup_guidance);
+  if (guidance) {
+    const callbackUrl = asString(guidance.callback_url);
+    const steps = Array.isArray(guidance.steps) ? guidance.steps : [];
+    const docs = Array.isArray(guidance.documentation) ? guidance.documentation : [];
+    lines.push("", asString(guidance.title) ?? "Provider setup:");
+    if (callbackUrl) lines.push(`  Callback URL: ${callbackUrl}`);
+    for (const step of steps)
+      if (asString(step)) lines.push(`  \u2022 ${asString(step)}`);
+    for (const raw of docs) {
+      const doc = asRecord(raw);
+      const label = asString(doc?.label);
+      const url = asString(doc?.url);
+      if (label && url) lines.push(`  Docs: ${label} \u2014 ${url}`);
+    }
+    const payloadExample = asRecord(guidance.payload_example);
+    if (payloadExample) {
+      lines.push(`  Payload example: ${JSON.stringify(payloadExample)}`);
+    }
+  }
+  lines.push(
+    "",
+    "This monitor streams new rows into your Customer DB \u2014 there is no manual run.",
+    "Next:",
+    "  \u2022 Query the table above directly, or",
+    "  \u2022 Run a play on each new row (third arg to definePlay in your .play.ts):",
+    `      sqlListeners: [{ id: '${primary.stream}', tool: '${toolId}', stream: '${primary.stream}', operations: ['INSERT'] }]`,
+    "    The changed row arrives to your handler as the sqlListener event's `after`.",
+    "",
+    "Reuse: many plays can bind to this one stream \u2014 you do NOT need a separate",
+    "monitor per play. Before deploying another monitor on this tool, run",
+    "`deepline monitors list` and reuse an existing one that covers your scope."
+  );
+  return `${lines.join("\n")}
+`;
+}
+function renderMonitorDeployPlan(payload) {
+  const valid = payload.valid !== false;
+  const lines = [
+    "DRY RUN \u2014 nothing was deployed.",
+    valid ? "Definition: valid" : "Definition: INVALID"
+  ];
+  if (!valid) {
+    const issues = Array.isArray(payload.issues) ? payload.issues : [];
+    for (const raw of issues) {
+      const issue = asRecord(raw);
+      const path = issue ? asString(issue.path) : void 0;
+      const message = issue ? asString(issue.message) : void 0;
+      if (message) lines.push(`  - ${path ? `${path}: ` : ""}${message}`);
+    }
+  }
+  const replacementWarning = renderDeployReplacementWarning({
+    payload,
+    completed: false
+  });
+  if (replacementWarning.length) lines.push("", ...replacementWarning);
+  const filterRemovalWarning = renderDeployFilterRemovalWarning(payload);
+  if (filterRemovalWarning.length) lines.push("", ...filterRemovalWarning);
+  const estimate = asRecord(payload.deploy_cost_estimate);
+  const credits = estimate ? asFiniteNumber(estimate.credits) : void 0;
+  if (credits !== void 0) {
+    const note = estimate ? asString(estimate.note) : void 0;
+    lines.push(
+      `Deploy cost: would cost ${credits} Deepline credits${note ? ` \u2014 ${note}` : ""}.`
+    );
+  } else {
+    lines.push(
+      "Deploy cost: estimate unavailable from this server (validation only)."
+    );
+  }
+  const pricingLine = monitorPricingLine(payload.pricing);
+  if (pricingLine) {
+    lines.push(`Selected pricing: ${pricingLine}`);
+  }
+  const candidates = Array.isArray(payload.reuse_candidates) ? payload.reuse_candidates : [];
+  const candidateLines = candidates.flatMap((raw) => {
+    const candidate = asRecord(raw);
+    const key = candidate ? asString(candidate.key) : void 0;
+    if (!candidate || !key) return [];
+    const name = asString(candidate.name);
+    const state = readMonitorState(candidate);
+    const covers = asString(candidate.covers);
+    return [
+      `  ${key}${name ? ` (${name})` : ""}${state ? ` \u2014 ${state}` : ""}${covers ? `; covers ${covers}` : ""}`
+    ];
+  });
+  if (candidateLines.length > 0) {
+    lines.push(
+      "",
+      "You may already have a monitor covering this \u2014 check before deploying:",
+      ...candidateLines,
+      "  Inspect: deepline monitors get <key> --json"
+    );
+  }
+  const identityConflict = asRecord(payload.identity_conflict);
+  const identityOwner = identityConflict ? asRecord(identityConflict.existing_monitor) : null;
+  const identityOwnerKey = identityOwner ? asString(identityOwner.key) : void 0;
+  const identityOwnerStatus = identityOwner ? asString(identityOwner.status) : void 0;
+  if (identityConflict) {
+    if (identityOwnerStatus === "provisioning") {
+      lines.push(
+        "",
+        "An in-progress provider operation owns this upstream identity.",
+        "Do not deploy this key yet. Wait, then rerun this dry run."
+      );
+    } else if (identityOwnerKey) {
+      lines.push(
+        "",
+        `An existing monitor owns this upstream identity: ${identityOwnerKey}.`,
+        `Inspect: deepline monitors get ${identityOwnerKey} --json`,
+        "Do not deploy this key unless that conflict is resolved."
+      );
+    } else {
+      lines.push(
+        "",
+        "An existing monitor owns this upstream identity.",
+        "Do not deploy this key until that conflict is resolved."
+      );
+    }
+  }
+  lines.push(
+    "",
+    identityConflict ? "Do not deploy for real until this identity conflict clears." : valid ? "Deploy for real: re-run this command without --dry-run." : "Fix the definition, then re-run this command."
+  );
+  return `${lines.join("\n")}
+`;
+}
+function renderMonitorDeletePlan(payload, fallbackKey) {
+  const plan = asRecord(payload.plan);
+  const key = (plan ? asString(plan.monitor_key) : void 0) ?? fallbackKey;
+  const lines = [
+    "DRY RUN \u2014 nothing was deleted.",
+    `Delete plan for monitor "${key}":`,
+    `  delete Deepline record: ${yesNo(plan?.would_delete_record)}`,
+    `  deprovision upstream provider resource: ${yesNo(plan?.would_deprovision_upstream)}`,
+    "",
+    `Delete for real: deepline monitors delete ${key} --yes`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function renderMonitorReactivatePlan(payload, key) {
+  const estimate = asRecord(payload.cost_estimate);
+  const credits = estimate ? asFiniteNumber(estimate.credits) : void 0;
+  const monitor = asRecord(payload.monitor);
+  const tool = monitor ? asString(monitor.tool) : void 0;
+  const hasTamradarHistoricalCatchup = tool === "deepline_native.company_radar" || tool === "deepline_native.contact_radar" || tool === "deepline_native.industry_radar";
+  const lines = [
+    "DRY RUN \u2014 nothing was reactivated.",
+    credits !== void 0 ? `Reactivate cost: would cost ${credits} Deepline credits.` : "Reactivate cost: estimate unavailable from this server.",
+    ...hasTamradarHistoricalCatchup ? [
+      "Source boundary: ordinary reactivation starts at provider creation. Saved updates_since values are not forwarded during reactivation."
+    ] : [],
+    "",
+    `Reactivate for real: deepline monitors reactivate ${key}`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function assertMonitorDryRunAcknowledged(payload, context) {
+  if (payload.dry_run === true) return;
+  throw new MonitorDryRunUnsupportedError(
+    `${context.command} --dry-run: the server response did not acknowledge dry-run mode (missing "dry_run": true). This Deepline server may not support --dry-run for ${context.mutation}, so the response cannot be trusted as a plan. Nothing was rendered as a plan. Verify current state with \`deepline monitors get <key> --json\`, and re-run without --dry-run only when you intend the real ${context.mutation}.`
+  );
+}
+function monitorDeleteRequiresYesError(key) {
+  return new MonitorsUsageError(
+    `monitors delete is destructive: it deletes monitor "${key}" and deprovisions its upstream provider resource. Non-interactive runs must confirm with --yes:
+  deepline monitors delete ${key} --yes
+Preview the plan first with:
+  deepline monitors delete ${key} --dry-run`
+  );
+}
+async function handleMonitorsStatus(options) {
+  const payload = await new DeeplineClient().monitors.status();
+  const hasAccess = payload.has_access === true;
+  const reason = typeof payload.reason === "string" && payload.reason.trim() ? payload.reason.trim() : void 0;
+  const text = hasAccess ? `\u2713 You have access to Deepline Monitors${reason ? `
+  ${reason}` : ""}
+` : `\u2717 No access to Deepline Monitors${reason ? ` \u2014 ${reason}` : ""}
+`;
+  printCommandEnvelope(
+    { has_access: hasAccess, ...reason ? { reason } : {} },
+    { json: options.json, text }
+  );
+  if (!hasAccess) {
+    process.exitCode = 1;
+  }
+}
+function renderAvailableToolsText(payload) {
+  const tools = Array.isArray(payload.tools) ? payload.tools : null;
+  if (!tools) return void 0;
+  const returned = asFiniteNumber(payload.returned) ?? tools.length;
+  const total = asFiniteNumber(payload.total);
+  const lines = [
+    total !== void 0 ? `Monitor types you can deploy (${returned} of ${total}):` : "Monitor types you can deploy:"
+  ];
+  let currentProvider;
+  for (const raw of tools) {
+    const entry = asRecord(raw);
+    const id = entry ? asString(entry.tool) : void 0;
+    if (!entry || !id) continue;
+    const name = asString(entry.name) ?? asString(entry.display_name);
+    const deployedCount = asFiniteNumber(entry.deployed_count);
+    const description = asString(entry.description);
+    const streams = Array.isArray(entry.streams) ? entry.streams.map((stream) => asString(stream)).filter((stream) => Boolean(stream)) : [];
+    const provider = id.split(".")[0];
+    if (provider && provider !== currentProvider) {
+      currentProvider = provider;
+      lines.push("", `  ${provider}:`);
+    }
+    lines.push(
+      `    ${id.split(".").slice(1).join(".") || id}${name ? ` \u2014 ${name}` : ""}${deployedCount !== void 0 ? `  (${deployedCount} deployed)` : ""}`
+    );
+    if (description) lines.push(`      ${description}`);
+    if (streams.length > 0) {
+      lines.push(`      emits: ${streams.join(", ")}`);
+    }
+  }
+  if (payload.is_truncated === true) {
+    lines.push("List truncated; raise --limit to see more.");
+  }
+  lines.push(
+    "",
+    "Next:",
+    "  Inspect payload fields, output columns, and a play binding:",
+    "    deepline monitors available <provider.tool> --json",
+    "  See monitors already deployed in this workspace:",
+    "    deepline monitors list",
+    "  Validate a monitor definition before deploying:",
+    `    deepline monitors check '{"key":"my-monitor","tool":"<provider.tool>","payload":{...}}'`
+  );
+  return `${lines.join("\n")}
+`;
+}
+async function handleMonitorsAvailable(toolId, options) {
+  process.stderr.write(
+    "`deepline monitors available` is deprecated.\n  Browse types:    deepline tools list --categories monitors\n  Inspect a type:  deepline tools get <monitor-type>\n"
+  );
+  if (toolId !== void 0 && options.tool !== void 0) {
+    if (toolId !== options.tool) {
+      throw new MonitorsUsageError(
+        `Pass the tool id once: got positional "${toolId}" and --tool "${options.tool}". Use: deepline monitors available ${toolId}`
+      );
+    }
+  }
+  const tool = toolId ?? options.tool;
+  const payload = await new DeeplineClient().monitors.available(tool, {
+    ...options.provider ? { provider: options.provider } : {},
+    ...options.search ? { search: options.search } : {},
+    ...options.limit ? { limit: options.limit } : {},
+    ...options.full ? { full: true } : {},
+    ...options.compact ? { compact: true } : {}
+  });
+  printCommandEnvelope(payload, {
+    json: options.json,
+    // Human list view shows id + name + deployed_count ("deployed: N") so
+    // can-deploy vs already-deployed is visible in one view. Describing a
+    // single tool keeps the full JSON contract (payload schema, streams).
+    text: tool ? void 0 : renderAvailableToolsText(payload)
+  });
+}
+function renderDeployedListText(payload, requestedStatus, filterKind = "status") {
+  const monitors = Array.isArray(payload.monitors) ? payload.monitors : null;
+  if (!monitors) return void 0;
+  const total = asFiniteNumber(payload.total);
+  const header = monitors.length === 0 ? "No deployed monitors matched." : total !== void 0 && total > monitors.length ? `Deployed monitors (${monitors.length} of ${total}):` : `Deployed monitors (${monitors.length}):`;
+  const lines = [header];
+  for (const raw of monitors) {
+    const entry = asRecord(raw);
+    const key = entry ? asString(entry.key) ?? asString(entry.monitor_key) : void 0;
+    if (!entry || !key) continue;
+    const state = readMonitorState(entry);
+    const tool = asString(entry.tool);
+    const monitorType = asString(entry.type);
+    const name = asString(entry.name);
+    const outputTable = asString(entry.output_table);
+    const webhookState = asString(entry.webhook_state);
+    const executionType = asString(entry.execution_type);
+    const hasLastReceivedEvent = "last_received_event" in entry;
+    const lastReceivedEvent = asString(entry.last_received_event);
+    const boundPlays = Array.isArray(entry.bound_plays) ? entry.bound_plays.length : void 0;
+    lines.push(
+      `  ${key}${state ? `  ${state}` : ""}${tool ? `  ${tool}` : ""}${name ? `  (${name})` : ""}`
+    );
+    if (outputTable || monitorType || webhookState || executionType || boundPlays !== void 0) {
+      lines.push(
+        `    ${[
+          outputTable ? `table: ${outputTable}` : null,
+          monitorType ? `type: ${monitorType}` : null,
+          webhookState ? `webhook: ${webhookState}` : null,
+          executionType ? `execution: ${executionType}` : null,
+          boundPlays !== void 0 ? `bound Plays: ${boundPlays}` : null
+        ].filter(Boolean).join("  ")}`
+      );
+    }
+    if (hasLastReceivedEvent) {
+      lines.push(`    last received: ${lastReceivedEvent ?? "never"}`);
+    }
+    if (Array.isArray(entry.bound_plays)) {
+      for (const rawPlay of entry.bound_plays) {
+        const play = asRecord(rawPlay);
+        const playName = asString(play?.name) ?? "unnamed Play";
+        const health = asRecord(play?.consumer_health);
+        const healthRequested = Boolean(play && "consumer_health" in play);
+        const state2 = healthRequested ? asString(health?.last_run_status) ?? "no delivery yet" : "health not requested";
+        const lastError = asString(health?.last_error);
+        lines.push(
+          `    consumer: ${playName} \u2014 ${state2}${lastError ? ` (${lastError})` : ""}`
+        );
+      }
+    }
+  }
+  const applied = monitorStateFilterLabel(
+    payload.state_filter_applied ?? payload.status_filter_applied,
+    monitorStateFilterLabel(requestedStatus)
+  );
+  lines.push(
+    `State filter: ${applied}${requestedStatus === void 0 && applied === "active" ? " (default)" : ""} \u2014 use --state all to include all monitors.`
+  );
+  const rawSummary = Array.isArray(payload.state_summary) ? payload.state_summary : Array.isArray(payload.status_summary) ? payload.status_summary : [];
+  const summary = rawSummary.flatMap((raw) => {
+    const item = asRecord(raw);
+    const state = item ? readMonitorState(item) : void 0;
+    const count = item ? asFiniteNumber(item.count) : void 0;
+    return state && count !== void 0 ? [`${state}: ${count}`] : [];
+  }).join("  ");
+  if (summary) {
+    lines.push(
+      `${payload.state_summary_scope === "filter_total" ? "Matching monitors" : "Current page states"}: ${summary}`
+    );
+  }
+  if (payload.has_more === true || payload.is_truncated === true) {
+    const nextCursor = asString(payload.next_cursor);
+    lines.push(
+      total !== void 0 ? `List truncated \u2014 showing ${monitors.length} of ${total}. Before concluding "no matching monitor exists," page the full registry:` : 'List truncated. Before concluding "no matching monitor exists," page the full registry:',
+      nextCursor ? `  deepline monitors list${requestedStatus ? ` --${filterKind} ${filterKind === "state" ? monitorStateFilterLabel(requestedStatus) : requestedStatus}` : ""} --cursor ${nextCursor}` : "  raise --limit above the reported total."
+    );
+  }
+  if (monitors.length > 0) {
+    lines.push("", "Inspect one: deepline monitors get <key> --json");
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function handleMonitorsList(options) {
+  const state = options.state ? monitorStateFilter(options.state) : void 0;
+  if (options.state !== void 0 && !state) {
+    throw new MonitorsUsageError(
+      `--state must be active, billing_suspended, disabled, or all; received ${options.state}.`
+    );
+  }
+  if (options.compact) {
+    process.stderr.write(
+      "`--compact` is deprecated and now does nothing; returning the complete monitor records.\n"
+    );
+  }
+  const payload = await new DeeplineClient().monitors.list({
+    ...state ? { state } : {},
+    ...options.status ? { status: options.status } : {},
+    ...options.limit ? { limit: options.limit } : {},
+    ...options.cursor ? { cursor: options.cursor } : {},
+    ...options.includeConsumers ? { includeConsumers: true } : {}
+  });
+  printCommandEnvelope(payload, {
+    json: options.json,
+    text: renderDeployedListText(
+      payload,
+      options.state ?? options.status,
+      options.state !== void 0 ? "state" : "status"
+    )
+  });
+}
+async function handleMonitorsCheck(definition, options) {
+  const body = resolveMonitorJsonBody({
+    positional: definition,
+    file: options.file,
+    argLabel: "<definition>",
+    command: "deepline monitors check"
+  });
+  const payload = await new DeeplineClient().monitors.check(
+    body
+  );
+  printCommandEnvelope(payload, { json: options.json });
+}
+async function handleMonitorsDeploy(definition, options) {
+  const body = resolveMonitorJsonBody({
+    positional: definition,
+    file: options.file,
+    argLabel: "<definition>",
+    command: "deepline monitors deploy"
+  });
+  const client = new DeeplineClient();
+  const definitionArg = body;
+  if (options.dryRun) {
+    const payload2 = await client.monitors.deploy(definitionArg, {
+      dryRun: true
+    });
+    const valid = payload2.valid !== false;
+    const hasIdentityConflict = Boolean(asRecord(payload2)?.identity_conflict);
+    printCommandEnvelope(
+      { dry_run: true, ...payload2 },
+      { json: options.json, text: renderMonitorDeployPlan(payload2) }
+    );
+    if (!valid || hasIdentityConflict) {
+      process.exitCode = 7;
+    }
+    return;
+  }
+  const payload = await client.monitors.deploy(definitionArg);
+  printCommandEnvelope(payload, {
+    json: options.json,
+    text: renderMonitorDeployCompletion(payload)
+  });
+}
+async function handleMonitorsSync(definition, options) {
+  const body = resolveMonitorJsonBody({
+    positional: definition,
+    file: options.file,
+    argLabel: "<definition>",
+    command: "deepline monitors sync"
+  });
+  const payload = await new DeeplineClient().monitors.sync(body, {
+    ...options.dryRun ? { dryRun: true } : {},
+    idempotencyKey: options.idempotencyKey ?? monitorJobIdempotencyKey("scalar-sync", void 0)
+  });
+  if (options.dryRun) {
+    const plan = payload;
+    printCommandEnvelope(
+      { dry_run: true, ...plan },
+      { json: options.json, text: renderMonitorDeployPlan(plan) }
+    );
+    return;
+  }
+  printCommandEnvelope(payload, {
+    json: options.json,
+    text: renderMonitorJob(payload)
+  });
+}
+async function handleScalarMonitorLifecycle(action, key, options) {
+  const payload = await new DeeplineClient().monitors[action](key, {
+    ...options.dryRun ? { dryRun: true } : {},
+    idempotencyKey: options.idempotencyKey ?? monitorJobIdempotencyKey(`${action}-${key}`, void 0)
+  });
+  printCommandEnvelope(payload, {
+    json: options.json,
+    text: options.dryRun ? void 0 : renderMonitorJob(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}-${randomUUID()}`;
+}
+function monitorJobIdempotencyKey(operation, supplied) {
+  const normalized = supplied?.trim();
+  if (supplied !== void 0 && !normalized) {
+    throw new MonitorsUsageError("--idempotency-key must not be empty.");
+  }
+  return normalized ?? `monitor-job-${operation}-${randomUUID()}`;
+}
+function readMonitorDefinitionsJsonFile(file) {
+  let raw;
+  try {
+    raw = file === "-" ? readFileSync(0, "utf8") : readFileSync(file, "utf8");
+  } catch (error) {
+    throw new MonitorsUsageError(
+      `Could not read --file ${file}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new MonitorsUsageError(
+      `Monitor definitions must be valid JSON. ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function renderMonitorJob(payload) {
+  const job = asRecord(payload.job);
+  if (!job) return void 0;
+  const id = asString(job.id) ?? "<unknown>";
+  const state = asString(job.state) ?? "unknown";
+  const outcome = asString(job.outcome);
+  const phase = asString(job.phase);
+  const counts = asRecord(job.counts);
+  const reconciliation = asRecord(job.reconciliation);
+  const lines = [
+    `Monitor job: ${id}`,
+    `State: ${state}${phase ? ` (${phase})` : ""}`
+  ];
+  if (outcome) lines.push(`Outcome: ${outcome}`);
+  const operationId = asString(job.operation_id);
+  if (operationId) lines.push(`Operation: ${operationId}`);
+  if (counts) {
+    lines.push(
+      `Counts: requested ${asFiniteNumber(counts.requested) ?? 0}, created ${asFiniteNumber(counts.created) ?? 0}, updated ${asFiniteNumber(counts.updated) ?? 0}, removed ${asFiniteNumber(counts.removed) ?? 0}, unchanged ${asFiniteNumber(counts.unchanged) ?? 0}, verified ${asFiniteNumber(counts.verified) ?? 0}, failed ${asFiniteNumber(counts.failed) ?? 0}`
+    );
+  }
+  if (reconciliation) {
+    lines.push(
+      `Reconciliation: ${asString(reconciliation.state) ?? "pending"} (${asFiniteNumber(reconciliation.observed_bindings) ?? 0}/${asFiniteNumber(reconciliation.expected_bindings) ?? 0} bindings observed)`
+    );
+  }
+  const next = asString(payload.next);
+  if (next) lines.push(`Next: ${next}`);
+  return `${lines.join("\n")}
+`;
+}
+async function handleMonitorJobBatchDeploy(options, idempotencyKey) {
+  if (!options.file) {
+    throw new MonitorsUsageError(
+      "A Batch file is required. Pass --file batch.json (or --file - for stdin)."
+    );
+  }
+  const lint = lintMonitorBatchInput(
+    readMonitorDefinitionsJsonFile(options.file)
+  );
+  if (!lint.normalized) {
+    throw new MonitorsUsageError(
+      lint.issues.filter((issue) => issue.severity === "error").map((issue) => `${issue.path || "batch"}: ${issue.message}`).join("; ")
+    );
+  }
+  const payload = await new DeeplineClient().monitors.batch.deploy(
+    lint.normalized.monitors,
+    { idempotencyKey }
+  );
+  printCommandEnvelope(
+    {
+      ...payload,
+      idempotency_key: idempotencyKey,
+      ...lint.issues.length ? { lint: { issues: lint.issues } } : {}
+    },
+    { json: options.json, text: renderMonitorJob(payload) }
+  );
+}
+function namedBatchIdempotencyKey(batchId, intent, supplied) {
+  return supplied?.trim() || `monitor-batch-${intent}-${batchId}-${randomUUID()}`;
+}
+async function handleNamedMonitorBatchSync(batchId, options) {
+  if (!options.file) {
+    throw new MonitorsUsageError(
+      "monitors batches sync requires --file <batch.json>."
+    );
+  }
+  const lint = lintMonitorBatchInput(
+    readMonitorDefinitionsJsonFile(options.file)
+  );
+  if (!lint.normalized) {
+    throw new MonitorsUsageError(
+      lint.issues.filter((issue) => issue.severity === "error").map((issue) => `${issue.path || "batch"}: ${issue.message}`).join("; ")
+    );
+  }
+  const parsedGeneration = options.expectedGeneration === void 0 ? void 0 : Number(options.expectedGeneration);
+  if (parsedGeneration !== void 0 && (!Number.isSafeInteger(parsedGeneration) || parsedGeneration < 0)) {
+    throw new MonitorsUsageError(
+      "--expected-generation must be a non-negative integer."
+    );
+  }
+  if (options.dryRun) {
+    printCommandEnvelope(
+      {
+        ok: true,
+        dry_run: true,
+        batch: { id: batchId, desired_count: lint.normalized.monitors.length },
+        issues: lint.issues,
+        next: `deepline monitors batches sync ${batchId} --file ${options.file} --idempotency-key <stable-key> --json`
+      },
+      { json: options.json }
+    );
+    return;
+  }
+  const idempotencyKey = namedBatchIdempotencyKey(
+    batchId,
+    "sync",
+    options.idempotencyKey
+  );
+  const payload = await new DeeplineClient().monitors.batches.sync(
+    batchId,
+    lint.normalized.monitors,
+    {
+      idempotencyKey,
+      ...parsedGeneration === void 0 ? {} : { expectedGeneration: parsedGeneration }
+    }
+  );
+  printCommandEnvelope(
+    { ...payload, idempotency_key: idempotencyKey },
+    { json: options.json, text: renderMonitorJob(payload) }
+  );
+}
+async function handleNamedMonitorBatchLifecycle(batchId, intent, options) {
+  if (options.dryRun) {
+    printCommandEnvelope(
+      {
+        ok: true,
+        dry_run: true,
+        batch: { id: batchId, intent },
+        next: `deepline monitors batches ${intent} ${batchId} --idempotency-key <stable-key> --json`
+      },
+      { json: options.json }
+    );
+    return;
+  }
+  const idempotencyKey = namedBatchIdempotencyKey(
+    batchId,
+    intent,
+    options.idempotencyKey
+  );
+  const payload = await new DeeplineClient().monitors.batches[intent](batchId, {
+    idempotencyKey
+  });
+  printCommandEnvelope(
+    { ...payload, idempotency_key: idempotencyKey },
+    { json: options.json, text: renderMonitorJob(payload) }
+  );
+}
+async function handleNamedMonitorBatchGet(batchId, options) {
+  const payload = await new DeeplineClient().monitors.batches.get(batchId);
+  printCommandEnvelope(payload, {
+    json: options.json,
+    text: renderMonitorJob(payload)
+  });
+}
+async function handleMonitorBatchLint(options) {
+  if (!options.file) {
+    throw new MonitorsUsageError(
+      "monitors batch lint requires --file <batch.json>."
+    );
+  }
+  const result = lintMonitorBatchInput(
+    readMonitorDefinitionsJsonFile(options.file)
+  );
+  printCommandEnvelope(
+    {
+      ok: !result.issues.some((issue) => issue.severity === "error"),
+      ...result.normalized ? { normalized: result.normalized } : {},
+      issues: result.issues
+    },
+    { json: options.json }
+  );
+  if (result.issues.some((issue) => issue.severity === "error"))
+    process.exitCode = 2;
+}
+async function handleMonitorFleetLint(options) {
+  if (!options.file) {
+    throw new MonitorsUsageError(
+      "monitors fleets lint requires --file <fleet.json>."
+    );
+  }
+  const result = lintMonitorFleetInput(
+    readMonitorDefinitionsJsonFile(options.file)
+  );
+  printCommandEnvelope(
+    {
+      ok: !result.issues.some((issue) => issue.severity === "error"),
+      ...result.normalized ? { normalized: result.normalized } : {},
+      issues: result.issues
+    },
+    { json: options.json }
+  );
+  if (result.issues.some((issue) => issue.severity === "error"))
+    process.exitCode = 2;
+}
+async function handleMonitorJobGet(jobId, options) {
+  const payload = await new DeeplineClient().monitors.jobs.get(jobId);
+  printCommandEnvelope(payload, {
+    json: options.json,
+    text: renderMonitorJob(payload)
+  });
+}
+async function handleMonitorJobWait(jobId, options) {
+  const payload = await new DeeplineClient().monitors.jobs.wait(jobId, {
+    timeoutMs: fleetTimeoutMs(options.timeout),
+    pollIntervalMs: FLEET_POLL_INTERVAL_MS
+  });
+  printCommandEnvelope(payload, {
+    json: options.json,
+    text: renderMonitorJob(payload)
+  });
+}
+async function handleMonitorJobLogs(jobId, options) {
+  const limit = options.limit ? fleetIntegerOption(options.limit, "--limit") : void 0;
+  const payload = await new DeeplineClient().monitors.jobs.logs(jobId, {
+    ...limit === void 0 ? {} : { limit }
+  });
+  printCommandEnvelope(payload, { json: options.json });
+}
+async function handleMonitorJobCancel(jobId, options) {
+  const payload = await new DeeplineClient().monitors.jobs.cancel(jobId);
+  printCommandEnvelope(payload, {
+    json: options.json,
+    text: renderMonitorJob(payload)
+  });
+}
+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 deploy --file fleet.json --dry-run"
+  },
+  {
+    step: 3,
+    what: "Apply it and wait for the server to call it converged.",
+    command: "deepline monitors fleets deploy --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: "deploy",
+    summary: "Create or update one table-backed Fleet from Customer DB rows."
+  },
+  { name: "lint", summary: "Validate and normalize Fleet JSON locally." },
+  { 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."
+  },
+  {
+    name: "reactivate",
+    summary: "Explicitly recreate a fleet after a credit-triggered suspension."
+  }
+];
+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(input) {
+    super(input.message);
+    this.name = "MonitorFleetStateError";
+    this.code = input.code;
+    this.next = input.next;
+  }
+};
+function fleetCounts(payload) {
+  const raw = asRecord(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 = asRecord(payload.plan) ?? {};
+  const blocked = asRecord(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, input) {
+  const lines = [
+    input.dryRun ? `Fleet ${input.fleetId} \u2014 plan only, nothing changed` : `Fleet ${input.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 ${input.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 state = readMonitorState(payload) ?? "unknown";
+  const status = fleetStatus(payload);
+  const lines = [
+    `Fleet ${id} \u2014 state ${state}`,
+    `  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"}`
+  ];
+  const boundPlays = Array.isArray(payload.bound_plays) ? payload.bound_plays.flatMap((value) => {
+    const play = asRecord(value);
+    return play ? [play] : [];
+  }) : [];
+  lines.push("", `Observed Play bindings (${boundPlays.length}):`);
+  if (boundPlays.length === 0) {
+    lines.push("  none");
+  } else {
+    for (const play of boundPlays) {
+      const name = asString(play.name) ?? "unnamed Play";
+      const listeners = asFiniteNumber(play.listener_count) ?? 0;
+      const status2 = asString(play.status);
+      lines.push(
+        `  ${name}${listeners ? ` (${listeners} listener${listeners === 1 ? "" : "s"})` : ""}${status2 ? ` \u2014 ${status2}` : ""}`
+      );
+    }
+  }
+  lines.push(
+    "  Read-only observation. Define or change bindings in the Play with sqlListeners."
+  );
+  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 = asRecord(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 = asRecord(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 stateWidth = fleets.reduce(
+    (max, fleet) => Math.max(max, (readMonitorState(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)}  ${(readMonitorState(fleet) ?? "unknown").padEnd(stateWidth)}  ${asFiniteNumber(fleet.live) ?? 0}/${asFiniteNumber(fleet.expected) ?? 0}${trouble.length ? `  ${trouble.join(" \xB7 ")}` : ""}`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+function renderFleetDeactivatePlan(payload, fleetId) {
+  const radius = asRecord(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 = {
+    version: 2,
+    kind: "fleet",
+    id: fleetId,
+    source: {
+      kind: "customer_db_table",
+      schema: source.schema,
+      table: source.table,
+      key: { column: key, type: keyType },
+      ...where ? { where } : {}
+    },
+    monitor: {
+      tool,
+      key: `${fleetId}-{{${key}}}`,
+      payload
+    },
+    selection: {
+      limit: fleetMemberLimit(options.limit),
+      orderBy: fleetOrderBy(options.orderBy, key),
+      membership: "sticky"
+    }
+  };
+  const definition = requireCompiledFleetDefinition(authoredDefinition);
+  const file = resolve(out);
+  writeFileSync(file, `${JSON.stringify(definition, null, 2)}
+`, "utf8");
+  const next = `deepline monitors fleets deploy --file ${fleetShellArg(file)} --dry-run --json`;
+  printCommandEnvelope(
+    { schemaVersion: 2, file, definition, next },
+    {
+      json: options.json,
+      text: `Wrote ${file}
+Next: ${next}
+`
+    }
+  );
+}
+function requireCompiledFleetDefinition(definition) {
+  const result = lintMonitorFleetInput(definition);
+  if (result.normalized) return result.normalized;
+  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 fileDefinitions = options.file ? readMonitorDefinitionsJsonFile(options.file) : void 0;
+  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(
+    asRecord(
+      fileDefinitions ?? 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 client = new DeeplineClient();
+  const payload = await client.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 client.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 client = new DeeplineClient();
+  const payload = await client.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(asRecord(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 fleetReactivateCommandLine(fleetId, options) {
+  const parts = [
+    "deepline",
+    "monitors",
+    "fleets",
+    "reactivate",
+    fleetShellArg(fleetId),
+    "--yes"
+  ];
+  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 handleMonitorFleetsReactivate(fleetId, options, idempotencyKey) {
+  if (!options.yes) {
+    throw new MonitorsUsageError(
+      `reactivate can recreate every suspended provider monitor and restart lifecycle billing. Confirm with --yes:
+  ${fleetReactivateCommandLine(fleetId, options)}`
+    );
+  }
+  const client = new DeeplineClient();
+  const payload = await client.monitors.fleets.reactivate(fleetId, {
+    idempotencyKey
+  });
+  const accepted = { ...payload, idempotency_key: idempotencyKey };
+  if (!options.wait) {
+    printCommandEnvelope(accepted, {
+      json: options.json,
+      text: `Fleet ${fleetId} \u2014 ${readMonitorState(payload) ? `state ${readMonitorState(payload)}` : "reactivation accepted"}
+  idempotency key ${idempotencyKey}
+`
+    });
+    return;
+  }
+  const timeoutMs = fleetTimeoutMs(options.timeout);
+  const progress = fleetProgressReporter();
+  let final;
+  try {
+    final = await client.monitors.fleets.waitForConvergence(fleetId, {
+      timeoutMs,
+      pollIntervalMs: FLEET_POLL_INTERVAL_MS,
+      onProgress: progress.report
+    });
+  } finally {
+    progress.finish();
+  }
+  const envelope = { ...accepted, ...final };
+  const text = renderFleetGet(final);
+  if (fleetStatus(final) === "converged") {
+    printCommandEnvelope(envelope, { json: options.json, text });
+    return;
+  }
+  reportFleetState(
+    envelope,
+    new MonitorFleetStateError({
+      code: "MONITOR_FLEET_WAIT_TIMEOUT",
+      message: `Stopped waiting after ${timeoutMs}ms. Fleet ${fleetId} recovery is still in progress on the server.`,
+      next: fleetServerNext(final) ?? `deepline monitors fleets get ${fleetShellArg(fleetId)} --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 client = new DeeplineClient();
+  if (options.dryRun) {
+    const plan = await client.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 client.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 client.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 ${readMonitorState(payload) ? `state ${readMonitorState(payload)}` : "deactivation accepted"}
+  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 client.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);
+  if (!key || !tool) return void 0;
+  const state = readMonitorState(payload);
+  const monitorType = asString(payload.type);
+  const hasLastReceivedEvent = "last_received_event" in payload;
+  const lastReceivedEvent = asString(payload.last_received_event);
+  const definition = asRecord(payload.definition);
+  const pricingLine = monitorPricingLine(payload.pricing);
+  const billing = asRecord(payload.billing);
+  const nextRenewalAt = billing ? asString(billing.next_renewal_at) : void 0;
+  const dependents = asRecord(payload.dependents);
+  const webhook = asRecord(payload.webhook);
+  const guidance = asRecord(payload.setup_guidance);
+  const plays = dependents && Array.isArray(dependents.plays) ? dependents.plays : [];
+  const boundPlays = Array.isArray(payload.bound_plays) ? payload.bound_plays.flatMap((value) => {
+    const play = asRecord(value);
+    return play ? [play] : [];
+  }) : [];
+  const lines = [
+    `Monitor: ${key}`,
+    `Tool: ${tool}`,
+    ...monitorType ? [`Type: ${monitorType}`] : [],
+    ...state ? [`Status: ${state}`] : [],
+    ...hasLastReceivedEvent ? [`Latest inbound event: ${lastReceivedEvent ?? "never"}`] : [],
+    ...pricingLine ? [`Pricing: ${pricingLine}`] : [],
+    ...nextRenewalAt ? [`Next renewal: ${nextRenewalAt}`] : []
+  ];
+  if (definition) {
+    lines.push("", "Current definition:", `  ${JSON.stringify(definition)}`);
+  }
+  if (webhook) {
+    lines.push("", `Webhook: ${asString(webhook.state) ?? "unknown"}`);
+    const callbackUrl = asString(webhook.callback_url);
+    if (callbackUrl) lines.push(`  Callback URL (sensitive): ${callbackUrl}`);
+  }
+  if (guidance) {
+    lines.push("", asString(guidance.title) ?? "Provider setup:");
+    for (const step of Array.isArray(guidance.steps) ? guidance.steps : []) {
+      const text = asString(step);
+      if (text) lines.push(`  \u2022 ${text}`);
+    }
+    for (const raw of Array.isArray(guidance.documentation) ? guidance.documentation : []) {
+      const doc = asRecord(raw);
+      const label = asString(doc?.label);
+      const url = asString(doc?.url);
+      if (label && url) lines.push(`  Docs: ${label} \u2014 ${url}`);
+    }
+    const payloadExample = asRecord(guidance.payload_example);
+    if (payloadExample) {
+      lines.push(`  Payload example: ${JSON.stringify(payloadExample)}`);
+    }
+  }
+  const samplePayload = asRecord(payload.sample_payload);
+  if (samplePayload) {
+    lines.push(
+      "",
+      `Sample test payload: ${JSON.stringify(samplePayload)}`,
+      `  deepline monitors test ${key} '${JSON.stringify(samplePayload)}' --json`
+    );
+  }
+  const monitorSpec = asRecord(payload.monitor_spec);
+  if (monitorSpec?.available === false) {
+    lines.push(
+      "",
+      `Monitor spec: unavailable \u2014 ${asString(monitorSpec.message) ?? "use the stored definition and check before an update."}`
+    );
+  }
+  const specFields = Array.isArray(monitorSpec?.fields) ? monitorSpec.fields.flatMap((value) => {
+    const field = asRecord(value);
+    const path = asString(field?.path);
+    const description = asString(field?.description);
+    const semantics = asString(field?.semantics);
+    const applicability = asString(field?.applicability);
+    const grammar = asRecord(field?.grammar);
+    const grammarSyntax = asString(grammar?.syntax);
+    return path ? [
+      {
+        path,
+        description,
+        semantics,
+        applicability,
+        grammarSyntax
+      }
+    ] : [];
+  }) : [];
+  if (specFields.length > 0) {
+    lines.push("", "Monitor spec:");
+    for (const field of specFields) {
+      lines.push(
+        `  ${field.path}${field.description ? ` \u2014 ${field.description}` : ""}`
+      );
+      if (field.semantics && field.semantics !== field.description) {
+        lines.push(`    Behavior: ${field.semantics}`);
+      }
+      if (field.applicability) {
+        lines.push(`    Applies to: ${field.applicability}`);
+      }
+      if (field.grammarSyntax) {
+        lines.push(`    Format: ${field.grammarSyntax}`);
+      }
+    }
+  }
+  lines.push("", `Current SQL listener consumers (${boundPlays.length}):`);
+  if (boundPlays.length === 0) {
+    lines.push("  none");
+  } else {
+    for (const play of boundPlays) {
+      const name = asString(play.name) ?? "unnamed Play";
+      const listener = asString(play.listener_key);
+      const health = asRecord(play.consumer_health);
+      const runStatus = asString(health?.last_run_status);
+      const lastDelivery = asFiniteNumber(health?.last_delivery_at);
+      const runId = asString(health?.last_run_id);
+      const error = asString(health?.last_error);
+      lines.push(`  ${name}${listener ? ` (listener: ${listener})` : ""}:`);
+      lines.push(
+        `    Latest delivered event: ${lastDelivery !== void 0 ? new Date(lastDelivery).toISOString() : "never"}`,
+        `    Latest consumer run: ${runId ?? "never"}${runStatus ? ` (${runStatus})` : ""}`
+      );
+      if (error) lines.push(`    error: ${error}`);
+    }
+  }
+  if (payload.consumer_health_truncated === true) {
+    lines.push("  Results are truncated; use --json for the returned detail.");
+  }
+  lines.push("", `Dependent published plays (${plays.length}):`);
+  if (plays.length === 0) {
+    lines.push("  none");
+  } else {
+    for (const raw of plays) {
+      const play = asRecord(raw);
+      const name = play ? asString(play.name) : void 0;
+      if (!play || !name) continue;
+      const listener = asString(play.listener_key);
+      const output = asString(play.output_key);
+      lines.push(
+        `  ${name}${listener ? ` (listener: ${listener})` : ""}${output ? ` \u2014 stream: ${output}` : ""}`
+      );
+    }
+  }
+  if (dependents?.truncated === true) {
+    lines.push("  Results are truncated; use --json for the returned detail.");
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function handleMonitorsGet(key, options) {
+  const client = new DeeplineClient();
+  const payload = await client.monitors.get(key);
+  const boundPlays = Array.isArray(payload.bound_plays) ? payload.bound_plays : null;
+  const dependents = boundPlays ? {
+    plays: boundPlays,
+    truncated: payload.consumer_health_truncated === true
+  } : await client.monitors.dependents(key);
+  const detail = { ...payload, dependents };
+  printCommandEnvelope(detail, {
+    json: options.json,
+    text: renderMonitorGet(detail)
+  });
+}
+async function handleMonitorsTest(key, payload, options) {
+  const explicitPayload = parseJsonObjectArg(payload, "<payload>");
+  const result = await new DeeplineClient().monitors.test(key, explicitPayload);
+  const text = `Monitor diagnostic for ${key}: ${result.accepted === true ? "accepted" : "rejected"}
+  mode: validation_only (no rows written, credits spent, or Plays dispatched)
+persisted rows: ${asFiniteNumber(result.persisted_rows) ?? 0}
+dispatched bound Plays: ${asFiniteNumber(result.dispatched_bound_plays) ?? 0}
+`;
+  printCommandEnvelope(result, { json: options.json, text });
+}
+async function handleMonitorsValidate(key, options) {
+  const result = await new DeeplineClient().monitors.validate(key);
+  printCommandEnvelope(result, { json: options.json });
+  if (result.valid === false) process.exitCode = 7;
+}
+async function confirmMonitorDelete(key) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  try {
+    const answer = await rl.question(
+      `Delete monitor "${key}"? This deprovisions the upstream provider resource. [y/N] `
+    );
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function handleMonitorsDelete(key, options) {
+  const client = new DeeplineClient();
+  if (options.dryRun) {
+    const payload2 = await client.monitors.delete(key, { dryRun: true });
+    assertMonitorDryRunAcknowledged(payload2, {
+      command: "deepline monitors delete",
+      mutation: "delete"
+    });
+    printCommandEnvelope(payload2, {
+      json: options.json,
+      text: renderMonitorDeletePlan(payload2, key)
+    });
+    return;
+  }
+  if (!options.yes) {
+    const interactive = process.stdout.isTTY === true && process.stdin.isTTY === true;
+    if (!interactive) {
+      throw monitorDeleteRequiresYesError(key);
+    }
+    const confirmed = await confirmMonitorDelete(key);
+    if (!confirmed) {
+      process.stderr.write(`Aborted. Monitor "${key}" was not deleted.
+`);
+      process.exitCode = 2;
+      return;
+    }
+  }
+  const payload = await client.monitors.delete(key);
+  printCommandEnvelope(payload, { json: options.json });
+}
+async function handleMonitorsUpdate(key, patch, options) {
+  const body = resolveMonitorJsonBody({
+    positional: patch,
+    file: options.file,
+    argLabel: "<patch>",
+    command: `deepline monitors update ${key}`
+  });
+  const payload = await new DeeplineClient().monitors.update(key, body);
+  printCommandEnvelope(payload, { json: options.json });
+}
+async function handleMonitorsReactivate(key, options) {
+  const client = new DeeplineClient();
+  if (options.dryRun) {
+    const payload2 = await client.monitors.reactivate(key, { dryRun: true });
+    assertMonitorDryRunAcknowledged(payload2, {
+      command: "deepline monitors reactivate",
+      mutation: "reactivate"
+    });
+    printCommandEnvelope(payload2, {
+      json: options.json,
+      text: renderMonitorReactivatePlan(payload2, key)
+    });
+    return;
+  }
+  const payload = await client.monitors.reactivate(key);
+  printCommandEnvelope(payload, { json: options.json });
+}
+var MONITOR_VERB_POLL_INTERVAL_MS = 2e3;
+function monitorHealthLine(health) {
+  if (health.refresh?.state === "running") {
+    return `refreshing whole scope \xB7 scanned ${health.scanned} so far`;
+  }
+  const alignmentRequired = health.alignment_required ?? 0;
+  return [
+    `converged ${health.converged}/${health.scanned}`,
+    `needs_repair ${health.needs_repair}`,
+    `missing ${health.observed.missing}`,
+    `unaudited ${health.observed.unknown + health.observed.unset}`,
+    ...alignmentRequired > 0 ? [`needs_alignment ${alignmentRequired}`] : [],
+    `silent ${health.silent}`
+  ].join(" \xB7 ");
+}
+function monitorVerbProgressReporter() {
+  const interactive = process.stderr.isTTY === true;
+  let wrote = false;
+  let lastPlainAt = 0;
+  return {
+    report: (health) => {
+      const line = monitorHealthLine(health);
+      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");
+    }
+  };
+}
+async function watchMonitorHealth(input) {
+  const deadlineAt = Date.now() + input.timeoutMs;
+  const scope = input.fleetId ? { fleetId: input.fleetId } : {};
+  let last = await input.client.monitors.health(scope);
+  input.onProgress(last);
+  while (Date.now() < deadlineAt) {
+    const unresolved = last.observed.unknown + last.observed.unset;
+    const alignmentRequired = last.alignment_required ?? 0;
+    if (last.refresh?.state !== "running" && !last.truncated && last.needs_repair === 0 && (unresolved === 0 || alignmentRequired === unresolved)) {
+      return last;
+    }
+    await new Promise(
+      (resolve2) => setTimeout(resolve2, MONITOR_VERB_POLL_INTERVAL_MS)
+    );
+    last = await input.client.monitors.health(scope);
+    input.onProgress(last);
+  }
+  return last;
+}
+function monitorHealthText(health) {
+  const partial = health.refresh?.state === "running" ? " (refreshing \u2014 counts below are not final)" : health.truncated ? " (partial \u2014 scope larger than one read)" : "";
+  const unauditedMonitors = health.unaudited_monitors ?? [];
+  const lines = [
+    `scope: ${health.scope.fleet_id ?? "workspace"}${partial}`,
+    monitorHealthLine(health)
+  ];
+  if ((health.batch_operations?.length ?? 0) > 0) {
+    lines.push("");
+    lines.push("batch work in progress:");
+    for (const operation of health.batch_operations ?? []) {
+      const retry = operation.next_attempt_at === void 0 ? "" : ` \xB7 next ${new Date(operation.next_attempt_at).toISOString()}`;
+      lines.push(
+        `  ${operation.kind} ${operation.run_id} \xB7 ${operation.state}${retry}`
+      );
+    }
+  }
+  if (health.deactivation_reasons.length > 0) {
+    lines.push("");
+    lines.push("deactivated by Deepline:");
+    for (const entry of health.deactivation_reasons) {
+      const how = entry.resolution ? ` \u2014 ${entry.resolution}` : "";
+      lines.push(`  ${entry.reason} (${entry.count})${how}`);
+    }
+  }
+  if (unauditedMonitors.length > 0) {
+    const reason = {
+      not_yet_audited: "has not been observed yet",
+      missing_provider_resource_id: "has no stored upstream resource id",
+      provider_observation_unknown: "the provider observation is still unknown"
+    };
+    lines.push("");
+    lines.push("unresolved monitor observations:");
+    for (const entry of unauditedMonitors) {
+      lines.push(
+        `  ${entry.monitor_key}  ${entry.tool}  \u2014 ${reason[entry.reason]}`
+      );
+    }
+  }
+  if ((health.alignment_required ?? 0) > 0) {
+    lines.push("");
+    lines.push(
+      `${health.alignment_required} monitor(s) need provider identity alignment; normal repair intentionally will not guess or create a paid replacement.`
+    );
+    lines.push(
+      `Run the exact inventory audit, then review one safe adoption candidate: deepline-admin monitors reconcile ${health.scope.org_id} --monitor <monitor-key> --environment production --json`
+    );
+  }
+  if (health.worst_offenders.length > 0) {
+    lines.push("");
+    lines.push(
+      `silent longest (no delivery in ${health.silent_window_days}d):`
+    );
+    for (const entry of health.worst_offenders) {
+      const when = entry.last_event_at === null ? "never" : new Date(entry.last_event_at).toISOString();
+      lines.push(`  ${entry.monitor_key}  ${entry.tool}  last event ${when}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function handleMonitorsAudit(options) {
+  const client = new DeeplineClient();
+  const fleetId = options.fleet?.trim() || void 0;
+  const scope = fleetId ? { fleetId } : {};
+  let result = await client.monitors.audit(scope);
+  const passes = [result.audit];
+  while (result.audit.cursor !== null) {
+    result = await client.monitors.audit({
+      ...scope,
+      cursor: result.audit.cursor
+    });
+    passes.push(result.audit);
+  }
+  const totals = passes.reduce(
+    (sum, pass) => ({
+      scanned: sum.scanned + pass.scanned,
+      asked: sum.asked + pass.asked,
+      stale: sum.stale + pass.stale,
+      missing: sum.missing + pass.observed.missing
+    }),
+    { scanned: 0, asked: 0, stale: 0, missing: 0 }
+  );
+  let health = result.health;
+  if (options.watch) {
+    const progress = monitorVerbProgressReporter();
+    try {
+      health = await watchMonitorHealth({
+        client,
+        ...scope,
+        timeoutMs: fleetTimeoutMs(options.timeout),
+        onProgress: progress.report
+      });
+    } finally {
+      progress.finish();
+    }
+  }
+  const unauditable = result.audit.unauditable_capabilities;
+  const overtaken = totals.stale > 0 ? ` \xB7 ${totals.stale} observations overtaken by a concurrent settle` : "";
+  const text = [
+    `audited ${totals.scanned} monitors \xB7 asked the provider about ${totals.asked}`,
+    `missing ${totals.missing}${overtaken}`,
+    ...unauditable.length > 0 ? [`not auditable (no batch-read contract): ${unauditable.join(", ")}`] : [],
+    "",
+    monitorHealthText(health)
+  ].join("\n");
+  printCommandEnvelope(
+    { ...result, audit: { ...result.audit, totals }, health },
+    { json: options.json, text }
+  );
+}
+async function handleMonitorsRepair(options) {
+  return await handleMonitorBatch("repair", {
+    ...options,
+    ...options.fleet?.trim() ? {} : { target: "needs-repair" }
+  });
+}
+async function handleMonitorsHealth(options) {
+  const fleetId = options.fleet?.trim() || void 0;
+  const health = await new DeeplineClient().monitors.health(
+    fleetId ? { fleetId } : {}
+  );
+  printCommandEnvelope(health, {
+    json: options.json,
+    text: monitorHealthText(health)
+  });
+}
+function monitorBatchScope(options, kind) {
+  const selectors = [
+    options.target ? "target" : null,
+    options.fleet?.trim() ? "fleet" : null,
+    options.keys?.trim() ? "keys" : null
+  ].filter((value) => value !== null);
+  if (selectors.length === 0 && kind === "audit") {
+    return { kind: "target", target: "all" };
+  }
+  if (selectors.length !== 1) {
+    throw new MonitorsUsageError(
+      `monitors batch ${kind} needs exactly one selector: --target, --fleet, or --keys.`
+    );
+  }
+  if (options.target) return { kind: "target", target: options.target };
+  if (options.fleet?.trim())
+    return { kind: "fleet", fleetId: options.fleet.trim() };
+  const monitorKeys = (options.keys ?? "").split(",").map((key) => key.trim()).filter(Boolean);
+  if (monitorKeys.length === 0) {
+    throw new MonitorsUsageError(
+      "--keys needs one or more comma-separated monitor keys."
+    );
+  }
+  return { kind: "keys", monitorKeys };
+}
+function monitorBatchIdempotencyKey(kind, value) {
+  return value?.trim() || `monitor-batch-${kind}-${randomUUID()}`;
+}
+function isCanonicalBatchJsonDocument(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return true;
+    const input = asRecord(parsed);
+    return input !== null && (input.kind === "batch" || Object.prototype.hasOwnProperty.call(input, "monitors") || Object.prototype.hasOwnProperty.call(input, "version"));
+  } catch {
+    return false;
+  }
+}
+async function handleMonitorBatchDeploy(options) {
+  if (!options.file?.trim()) {
+    throw new MonitorsUsageError(
+      "monitors batch deploy requires --file <monitors.ndjson>."
+    );
+  }
+  if (options.dryRun !== true && options.yes !== true) {
+    throw new MonitorsUsageError(
+      "monitors batch deploy changes provider monitors asynchronously. Preview with --dry-run, then confirm with --yes."
+    );
+  }
+  let manifestNdjson;
+  try {
+    manifestNdjson = readFileSync(resolve(options.file), "utf8");
+  } catch (error) {
+    throw new MonitorsUsageError(
+      `Could not read monitor batch manifest '${options.file}': ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!manifestNdjson.trim()) {
+    throw new MonitorsUsageError("Monitor batch manifest is empty.");
+  }
+  if (isCanonicalBatchJsonDocument(manifestNdjson)) {
+    throw new MonitorsUsageError(
+      "Canonical Batch JSON cannot use --dry-run or --yes; those flags select the retained legacy NDJSON operation. Run `deepline monitors batch lint --file <batch.json> --json`, then submit the Monitor Job with `deepline monitors batch deploy --file <batch.json> --idempotency-key <key> --json`."
+    );
+  }
+  const idempotencyKey = monitorBatchIdempotencyKey(
+    "deploy",
+    options.idempotencyKey
+  );
+  const result = await new DeeplineClient().monitors.batch.submit({
+    kind: "deploy",
+    manifestNdjson,
+    dryRun: options.dryRun === true,
+    idempotencyKey
+  });
+  const operation = result.operation;
+  printCommandEnvelope(
+    { ...result, idempotency_key: idempotencyKey },
+    {
+      json: options.json,
+      text: [
+        `${result.rejoined ? "rejoined" : "submitted"} deploy batch ${operation.runId}`,
+        `state ${operation.state} \xB7 retry key ${idempotencyKey}`,
+        `inspect: deepline monitors batch get ${operation.runId} --json`
+      ].join("\n") + "\n"
+    }
+  );
+}
+async function handleMonitorBatch(kind, options) {
+  if ((kind === "deactivate" || kind === "reactivate" || kind === "repair") && options.dryRun !== true && options.yes !== true) {
+    throw new MonitorsUsageError(
+      `monitors batch ${kind} changes provider monitors asynchronously. Preview with --dry-run, then confirm with --yes.`
+    );
+  }
+  const scope = monitorBatchScope(options, kind);
+  if (kind === "deactivate" && scope.kind === "target" && !options.reason?.trim()) {
+    throw new MonitorsUsageError(
+      "monitors batch deactivate --target requires --reason (for example insufficient_balance or billing_failure). Omit --reason with --keys for a customer-requested teardown."
+    );
+  }
+  const idempotencyKey = monitorBatchIdempotencyKey(
+    kind,
+    options.idempotencyKey
+  );
+  const result = await new DeeplineClient().monitors.batch.submit({
+    kind,
+    scope,
+    dryRun: options.dryRun === true,
+    ...options.reason?.trim() ? { deactivationReason: options.reason.trim() } : {},
+    idempotencyKey
+  });
+  const operation = result.operation;
+  const text = [
+    `${result.rejoined ? "rejoined" : "submitted"} ${operation.kind} batch ${operation.runId}`,
+    `state ${operation.state} \xB7 retry key ${idempotencyKey}`,
+    `inspect: deepline monitors batch get ${operation.runId} --json`
+  ].join("\n");
+  printCommandEnvelope(
+    { ...result, idempotency_key: idempotencyKey },
+    { json: options.json, text: `${text}
+` }
+  );
+}
+async function handleMonitorBatchGet(operationId, options) {
+  const result = await new DeeplineClient().monitors.batch.get(operationId, {
+    ...options.cursor ? { cursor: options.cursor } : {}
+  });
+  const summary = result.operation.summary ?? {};
+  const text = [
+    `${result.operation.kind} batch ${result.operation.runId}`,
+    `state ${result.operation.state}`,
+    `progress ${JSON.stringify(summary)}`,
+    ...result.results ? [
+      `results ${result.results.page.length}${result.results.isDone ? "" : " (more; pass --cursor)"}`
+    ] : []
+  ].join("\n");
+  printCommandEnvelope(result, { json: options.json, text: `${text}
+` });
+}
+function registerMonitorsCommands(program) {
+  const monitors = program.command("monitors").description("Discover, deploy, and manage Deepline monitors.").showSuggestionAfterError(true).addHelpText(
+    "after",
+    `
+Notes:
+  Deepline monitors are Deepline-native signal feeds: a monitor writes events
+  into a Customer DB table; a play reacts to each new row via a
+  sqlListeners trigger \u2014 see \`deepline plays bootstrap monitor-triggered\`.
+  Monitor JSON declares only what to watch (key, tool, optional name, payload).
+  Play bindings belong in the Play; monitor deployment never changes them.
+  The Monitors rollout controls access to the live provider catalog; use
+  \`deepline tools list --categories monitors\` for the exact tool ids available to you.
+  Contact the Deepline team to request access; until access is enabled, these
+  commands return a clear monitor_access_required error.
+
+Exit codes:
+  0 success; 2 usage/local input; 3 auth or permission; 4 not found;
+  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:
+  deepline monitors status --json
+  deepline tools list --categories monitors --json
+  deepline tools get deepline_native.company_radar --json
+  deepline monitors check '{"key":"job-openings","tool":"deepline_native.company_radar","payload":{"domain":"stripe.com","radar_type":"company_job_openings"}}'
+  deepline monitors deploy --dry-run --file monitor.json
+  deepline monitors deploy --file monitor.json
+  deepline monitors list --status all --json
+  deepline monitors get my-monitor --json
+  deepline monitors update my-monitor '{"name":"Interested replies"}' --json
+  deepline monitors delete my-monitor --dry-run
+  deepline monitors reactivate my-monitor --dry-run
+`
+  );
+  withJsonOption(
+    monitors.command("audit").description(
+      "Re-read what the provider actually holds for your monitors."
+    ).option("--fleet <fleet-id>", "Audit one fleet instead of every monitor").option("--watch", "Keep polling health until the scope settles").option(
+      "--timeout <duration>",
+      "How long --watch waits, e.g. 90s, 5m, 1h (default 10m)"
+    ).addHelpText(
+      "after",
+      `
+Notes:
+  Asks the provider, by resource id, what it still holds, and records the answer
+  on each monitor. It changes nothing upstream: no creates, no deletes, no
+  intent. Safe to run at any time, as often as you like \u2014 running it twice is
+  running it once, twice.
+
+  A monitor the provider does not return is recorded "missing". Use
+  'deepline monitors repair' to act on that.
+
+Examples:
+  deepline monitors audit
+  deepline monitors audit --fleet accounts-eu --json
+  deepline monitors audit --fleet accounts-eu --watch --timeout 5m
+`
+    )
+  ).action(monitorsAction(handleMonitorsAudit));
+  withJsonOption(
+    monitors.command("repair").description(
+      "Converge the monitors whose desired and observed states disagree."
+    ).option("--fleet <fleet-id>", "Repair one fleet instead of every monitor").option(
+      "--dry-run",
+      "Record the bounded repair plan without provider changes"
+    ).option("--yes", "Confirm the asynchronous provider repair").option(
+      "--idempotency-key <key>",
+      "Stable retry key (generated when omitted)"
+    ).addHelpText(
+      "after",
+      `
+Notes:
+  This is the short spelling of 'monitors batch repair --target needs-repair'.
+  It handles both direct monitors and Fleet members through one durable
+  service-account worker. An active historical monitor without an upstream id
+  is selected for repair; current Convex writes cannot create that state.
+
+  It returns a run id immediately. Inspect retained results with
+  'deepline monitors batch get <run-id> --json'. Reuse --idempotency-key after
+  a lost response to rejoin the exact run without another provider request.
+
+Examples:
+  deepline monitors repair --dry-run
+  deepline monitors repair --yes
+  deepline monitors repair --fleet accounts-eu --yes --idempotency-key repair-eu-2026-09-09
+`
+    )
+  ).action(monitorsAction(handleMonitorsRepair));
+  withJsonOption(
+    monitors.command("health").description("Delivery and convergence health for your monitors.").option(
+      "--fleet <fleet-id>",
+      "Report on one fleet instead of every monitor"
+    ).addHelpText(
+      "after",
+      `
+Notes:
+  Read-only. Reports how many monitors the provider holds as asked, how many
+  disagree, how many Deepline deactivated and why, and how many are "silent" \u2014
+  the provider holds them but nothing has been delivered recently. The worst
+  offenders are listed longest-quiet first.
+
+Examples:
+  deepline monitors health
+  deepline monitors health --fleet accounts-eu --json
+`
+    )
+  ).action(monitorsAction(handleMonitorsHealth));
+  const batch = monitors.command("batch").description("Submit or inspect durable bulk monitor operations.");
+  const batchSelectorOptions = (command) => command.option(
+    "--target <target>",
+    "One of: all, all-active, billing-suspended, needs-repair"
+  ).option("--fleet <fleet-id>", "Select one Fleet").option("--keys <keys>", "Up to 100 comma-separated monitor keys").option(
+    "--dry-run",
+    "Record the same bounded plan without provider changes"
+  ).option(
+    "--idempotency-key <key>",
+    "Stable retry key (generated when omitted)"
+  );
+  withJsonOption(
+    batch.command("deploy").description(
+      "Create a Monitor Job from canonical Batch JSON; legacy NDJSON remains available with --yes or --dry-run."
+    ).requiredOption(
+      "--file <path>",
+      'Batch JSON ({"version":1,"kind":"batch","monitors":[...]}), or legacy NDJSON with --yes/--dry-run'
+    ).option("--dry-run", "Preview a retained legacy NDJSON batch operation").option("--yes", "Confirm a retained legacy NDJSON batch operation").option(
+      "--idempotency-key <key>",
+      "Stable retry key (generated when omitted)"
+    )
+  ).action(
+    monitorsAction(async (options) => {
+      if (options.dryRun === true || options.yes === true) {
+        return await handleMonitorBatchDeploy(options);
+      }
+      const idempotencyKey = monitorJobIdempotencyKey(
+        "batch-deploy",
+        options.idempotencyKey
+      );
+      return await handleMonitorJobBatchDeploy(options, idempotencyKey);
+    })
+  );
+  withJsonOption(
+    batch.command("lint").description(
+      "Validate and normalize Batch JSON without network or provider work."
+    ).requiredOption("--file <path>", "Batch JSON file, or - for stdin")
+  ).action(monitorsAction(handleMonitorBatchLint));
+  withJsonOption(
+    batchSelectorOptions(
+      batch.command("audit").description("Durably audit a selection; defaults to --target all.")
+    )
+  ).action(
+    monitorsAction(
+      (options) => handleMonitorBatch("audit", options)
+    )
+  );
+  withJsonOption(
+    batchSelectorOptions(
+      batch.command("repair").description(
+        "Durably re-audit and converge a selection through the existing lifecycle fences."
+      )
+    ).option("--yes", "Confirm the asynchronous provider repair")
+  ).action(
+    monitorsAction(
+      (options) => handleMonitorBatch("repair", options)
+    )
+  );
+  withJsonOption(
+    batchSelectorOptions(
+      batch.command("deactivate").description(
+        "Durably deactivate a selection through provider batch deletes."
+      )
+    ).option(
+      "--reason <reason>",
+      "Declared policy reason; required with --target and omitted for a customer-requested --keys teardown"
+    ).option("--yes", "Confirm the asynchronous provider deactivation")
+  ).action(
+    monitorsAction(
+      (options) => handleMonitorBatch("deactivate", options)
+    )
+  );
+  withJsonOption(
+    batchSelectorOptions(
+      batch.command("reactivate").description("Durably reactivate a selection after a suspension.")
+    ).option("--yes", "Confirm provider reactivation and possible billing")
+  ).action(
+    monitorsAction(
+      (options) => handleMonitorBatch("reactivate", options)
+    )
+  );
+  withJsonOption(
+    batch.command("get <operation-id>").description("Read batch progress and one bounded evidence page.").option("--cursor <cursor>", "Read the next retained evidence page")
+  ).action(monitorsAction(handleMonitorBatchGet));
+  const namedBatches = monitors.command("batches").description(
+    "Manage stable named Batches whose omitted members are stopped."
+  );
+  withJsonOption(namedBatches);
+  withJsonOption(
+    namedBatches.command("sync <batch-id>").description(
+      "Publish the complete desired member set and return one Monitor Job."
+    ).requiredOption(
+      "--file <path>",
+      "Canonical Batch JSON file, or - for stdin"
+    ).option(
+      "--dry-run",
+      "Validate and show the desired count without publishing"
+    ).option("--expected-generation <n>", "Reject a stale concurrent update").option("--idempotency-key <key>", "Stable retry key")
+  ).action(monitorsAction(handleNamedMonitorBatchSync));
+  withJsonOption(
+    namedBatches.command("start <batch-id>").description("Reapply the retained member set through one Monitor Job.").option(
+      "--dry-run",
+      "Show the retained-intent operation without publishing"
+    ).option("--idempotency-key <key>", "Stable retry key")
+  ).action(
+    monitorsAction(
+      (batchId, options) => handleNamedMonitorBatchLifecycle(batchId, "start", options)
+    )
+  );
+  withJsonOption(
+    namedBatches.command("stop <batch-id>").description(
+      "Publish an empty desired set while retaining members for start."
+    ).option(
+      "--dry-run",
+      "Show the retained-intent operation without publishing"
+    ).option("--idempotency-key <key>", "Stable retry key")
+  ).action(
+    monitorsAction(
+      (batchId, options) => handleNamedMonitorBatchLifecycle(batchId, "stop", options)
+    )
+  );
+  withJsonOption(
+    namedBatches.command("get <batch-id>").description("Read named Batch intent and its latest Monitor Job.")
+  ).action(monitorsAction(handleNamedMonitorBatchGet));
+  withJsonOption(
+    monitors.command("status").description("Check whether you have access to Deepline monitors.").addHelpText(
+      "after",
+      `
+Notes:
+  Read-only access check. Requires authentication but NOT monitor access, so it
+  is safe to run first to confirm whether you can use the monitor commands. Exits
+  0 when you have access and 1 when you do not, so agents can branch on it (this
+  exit-1 denial contract predates the typed monitor exit codes and is kept).
+
+Examples:
+  deepline monitors status
+  deepline monitors status --json
+`
+    )
+  ).action(monitorsAction(handleMonitorsStatus));
+  withJsonOption(
+    monitors.command("available [tool-id]", { hidden: true }).alias("tools").description(
+      "List the monitor types you can deploy, or describe one by tool id."
+    ).addHelpText(
+      "after",
+      `
+Notes:
+  Read-only catalog of deployable monitor types. Pass a tool id positionally to
+  describe one (payload schema + output streams). Filter the list with
+  --provider, --search, or --limit. List entries include how many monitors you
+  already have deployed on each tool ("deployed: N") when the server reports it.
+  The list is compact by default (id + name + deployed count); pass --full to
+  get the complete catalog (payload schemas + output streams for every tool).
+  Describing a single tool by id always returns the full contract.
+
+Examples:
+  deepline monitors available
+  deepline monitors available --full --json
+  deepline monitors available --provider deepline_native --json
+  deepline monitors available deepline_native.company_radar --json
+  deepline monitors available --search jobs --json
+`
+    ).option("--provider <provider>", "Filter by provider").option(
+      "--tool <tool>",
+      "Describe a single monitor tool by id (same as the positional tool-id)"
+    ).option("--search <query>", "Search monitor tools by text").option("--limit <n>", "Limit the number of monitor tools returned").option(
+      "--full",
+      "Return the complete monitor catalog (payload schemas + output streams). The list is compact by default."
+    ).option("--compact", COMPACT_OPTION_DESCRIPTION)
+  ).action(monitorsAction(handleMonitorsAvailable));
+  withJsonOption(
+    monitors.command("list").description("List the monitors you have deployed.").addHelpText(
+      "after",
+      `
+Notes:
+  Read-only. A monitor has one of three customer states: active,
+  billing_suspended, or disabled. Provisioning, cleanup, retries, and failures
+  are reported by Monitor Jobs; provider disagreement is reported separately by
+  audit/health. The output echoes the canonical state filter that was applied.
+  The legacy --status flag remains accepted for installed clients. The response reports
+  total (the true registry count, not the page size), returned, has_more, and
+  next_cursor. When has_more is true, page with --cursor <next_cursor> until it
+  is false \u2014 a "no matching
+  monitor" reuse conclusion off a truncated page deploys a duplicate paid feed.
+  The default list stays cheap: it includes the current downstream Play binding
+  metadata but does not resolve per-monitor delivery/run health. Pass
+  --include-consumers with --limit 20 or fewer to include the current
+  SQL-listener delivery/run health for each returned monitor.
+
+Examples:
+  deepline monitors list
+  deepline monitors list --state billing_suspended --json
+  deepline monitors list --state all --json
+  deepline monitors list --status all --json
+  deepline monitors list --status all --cursor <next_cursor> --json
+  deepline monitors list --include-consumers --limit 20 --json
+`
+    ).option(
+      "--state <state>",
+      "Filter by customer state: active (default), billing_suspended, disabled, or all"
+    ).option(
+      "--status <status>",
+      "Deprecated compatibility filter; use --state (active, billing_suspended, disabled, or all)"
+    ).option("--limit <n>", "Limit the number of deployed monitors returned").option(
+      "--cursor <cursor>",
+      "Page past a truncated result using the next_cursor from a prior list response"
+    ).option(
+      "--compact",
+      "Deprecated no-op; complete records are always returned"
+    ).option(
+      "--include-consumers",
+      "Include current SQL-listener consumer health (requires --limit 20 or fewer)"
+    )
+  ).action(monitorsAction(handleMonitorsList));
+  withJsonOption(
+    monitors.command("get <key>").description("Show a single deployed monitor by its public key.").addHelpText(
+      "after",
+      `
+Notes:
+  Read-only. Returns the exact editable definition, selected Deepline pricing,
+  billing state, output streams, dependent published plays, and monitor_spec.
+  When monitor_spec.available is true, its fields describe the deployed type's
+  editable fields, constraints, and provider-specific behavior. For TAMRadar,
+  this includes the effective updates_since precision and engagement timing
+  rules. Otherwise use the stored definition and check before proposing an
+  update so scope and downstream effects are visible.
+
+Examples:
+  deepline monitors get my-monitor --json
+`
+    )
+  ).action(monitorsAction(handleMonitorsGet));
+  withJsonOption(
+    monitors.command("test <key> <payload>").description(
+      "Validate an explicit payload against a monitor\u2019s webhook contract."
+    ).addHelpText(
+      "after",
+      `
+Notes:
+  <payload> must be an explicit JSON object. The command uses the deployed
+  monitor\u2019s real binding and payload validation, but is a side-effect-free
+  diagnostic: it does not persist rows, spend credits, dispatch Plays, or alter
+  monitor state. It does not synthesize a provider event or accept an omitted
+  payload.
+
+Examples:
+  deepline monitors test rb2b-website-visitors '{"LinkedIn URL":"https://www.linkedin.com/in/example","Website":"https://example.com"}' --json
+`
+    )
+  ).action(monitorsAction(handleMonitorsTest));
+  withJsonOption(
+    monitors.command("validate <key>").description("Validate a deployed monitor\u2019s provider configuration.")
+  ).action(monitorsAction(handleMonitorsValidate));
+  withJsonOption(
+    monitors.command("check [definition]").description("Validate a monitor definition without deploying it.").addHelpText(
+      "after",
+      `
+Notes:
+  Read-only validation. <definition> is a JSON object with key, tool, optional
+  name, and payload. Pass it positionally, via --file <path>, or
+  from stdin with --file -. Does not deploy or spend credits.
+  Check validates the local definition only. It does not contact an existing
+  upstream resource, prove that future events will arrive, or verify downstream
+  Play delivery. The JSON response reports this validation scope explicitly.
+  Provider-specific grammar, precedence, enum applicability, examples, and
+  update semantics are returned by the live monitor contract. Inspect it with
+  \`deepline tools get deepline_native.company_radar --json\`.
+  Operational controls are Deepline-managed. Bind downstream automation in a
+  Play with sqlListeners; monitor definitions never name Plays.
+
+Examples:
+  deepline monitors check '{"key":"job-openings","tool":"deepline_native.company_radar","payload":{"domain":"stripe.com","radar_type":"company_job_openings"}}'
+  deepline monitors check --file monitor.json
+  cat monitor.json | deepline monitors check --file -
+`
+    ).option(
+      "-f, --file <path>",
+      "Read the definition JSON from a file, or - for stdin"
+    )
+  ).action(monitorsAction(handleMonitorsCheck));
+  withJsonOption(
+    monitors.command("deploy [definition]").description("Deploy a monitor from a definition.").addHelpText(
+      "after",
+      `
+Notes:
+  Mutates workspace state and may spend Deepline credits. <definition> is a JSON
+  object with key, tool, optional name, and payload. Pass it positionally, via
+  --file <path>, or from stdin with --file -.
+  --dry-run validates the definition and shows the plan (deploy cost in Deepline
+  credits when the server reports it, plus any existing monitors that may
+  already cover this scope) WITHOUT deploying. Exits 0 when valid, 7 when not.
+  Deploy is a full desired definition for its key: omitting a previously stored
+  field removes it and can replace the upstream resource. Use \`monitors update\`
+  for a patch-style change.
+  Repeating the exact saved definition resumes an incomplete deploy cleanup:
+  Deepline keeps the replacement, removes only the stored previous binding after
+  provider confirmation, and never creates or charges another monitor. There is
+  no separate repair command or retry queue: rerun the same deploy/update.
+  Scheduled reconciliation can also finish that exact saved cleanup; it never
+  creates another monitor.
+  For TamRadar, deliberately changing payload.updates_since is an explicit
+  historical replay request, including when redeploying a disabled monitor.
+  Deepline preserves that selected boundary; filter-only deploys and ordinary
+  reactivation start from a fresh future-only source boundary instead.
+  Operational controls are Deepline-managed. A monitor writes rows; downstream
+  automation belongs in a Play with sqlListeners.
+
+Examples:
+  deepline monitors deploy '{"key":"job-openings","tool":"deepline_native.company_radar","payload":{"domain":"stripe.com","radar_type":"company_job_openings"}}'
+  deepline monitors deploy --dry-run --file monitor.json
+  deepline monitors deploy --file monitor.json
+`
+    ).option(
+      "-f, --file <path>",
+      "Read the definition JSON from a file, or - for stdin"
+    ).option(
+      "--dry-run",
+      "Validate and show the deploy plan (cost, reuse candidates) without deploying"
+    )
+  ).action(monitorsAction(handleMonitorsDeploy));
+  withJsonOption(
+    monitors.command("sync [definition]").description(
+      "Publish one complete desired monitor definition and return a Monitor Job."
+    ).option(
+      "-f, --file <path>",
+      "Read definition JSON from a file, or - for stdin"
+    ).option(
+      "--dry-run",
+      "Validate and show the deploy plan without publishing"
+    ).option("--idempotency-key <key>", "Stable retry key")
+  ).action(monitorsAction(handleMonitorsSync));
+  withJsonOption(
+    monitors.command("update <key> [patch]").description("Update a deployed monitor by its public key.").addHelpText(
+      "after",
+      `
+Notes:
+Mutates workspace state. <patch> is a JSON object of fields to update. Pass it
+positionally, via --file <path>, or from stdin with --file -.
+
+When <patch> includes payload, its top-level fields are merged with the stored
+payload before validation. This lets you change one filter without resending
+domain or radar_type; nested values and arrays replace atomically.
+For TamRadar, changing payload.updates_since on an initial or active definition
+is an explicit historical replay request. Deepline passes that requested boundary upstream, but previously
+delivered canonical findings are deduplicated before dispatch and billing; only
+previously unseen historical findings are chargeable. Filter-only updates,
+repair, and reactivation instead use a fresh future-only source boundary.
+
+Examples:
+  deepline monitors update my-monitor '{"name":"Interested replies"}' --json
+  deepline monitors update job-openings '{"payload":{"job_titles":"CEO OR CFO"}}' --json
+  deepline monitors update my-monitor --file patch.json
+`
+    ).option(
+      "-f, --file <path>",
+      "Read the patch JSON from a file, or - for stdin"
+    )
+  ).action(monitorsAction(handleMonitorsUpdate));
+  withJsonOption(
+    monitors.command("delete <key>").description("Delete a deployed monitor by its public key.").addHelpText(
+      "after",
+      `
+Notes:
+DESTRUCTIVE. Deprovisions the upstream provider resource and removes its
+Deepline-managed monitor. Retries are safe: a delete that already reached its requested terminal state
+returns already_deleted without making another upstream call.
+--dry-run shows the delete plan without deleting anything.
+  Interactive terminals get a y/N confirmation; non-interactive runs (agents,
+  scripts, pipes) must pass --yes.
+
+Examples:
+  deepline monitors delete my-monitor --dry-run
+  deepline monitors delete my-monitor --yes --json
+`
+    ).option("--dry-run", "Show the delete plan without deleting anything").option(
+      "--yes",
+      "Skip the confirmation prompt (required non-interactively)"
+    )
+  ).action(monitorsAction(handleMonitorsDelete));
+  withJsonOption(
+    monitors.command("reactivate <key>").description("Reactivate a previously disabled deployed monitor.").addHelpText(
+      "after",
+      `
+Notes:
+  Mutates workspace state and may spend Deepline credits.
+  --dry-run shows the reactivation cost (in Deepline credits) without changing
+  anything.
+  Deepline Native radars create a replacement upstream radar from the saved
+  filters. Reactivation always omits updates_since and starts at provider
+  creation; a disabled monitor cannot stage an updates_since change. New Hire
+  and Promotion source dates use calendar-month precision upstream, so
+  current-month updates_since values are rejected for those radar types.
+
+Examples:
+  deepline monitors reactivate my-monitor --dry-run
+  deepline monitors reactivate my-monitor --json
+`
+    ).option("--dry-run", "Show the reactivation cost without reactivating")
+  ).action(monitorsAction(handleMonitorsReactivate));
+  withJsonOption(
+    monitors.command("start <key>").description("Apply the retained definition for a stopped monitor.").option("--dry-run", "Show the start plan without changing anything").option("--idempotency-key <key>", "Stable retry key")
+  ).action(
+    monitorsAction(
+      (key, options) => handleScalarMonitorLifecycle("start", key, options)
+    )
+  );
+  withJsonOption(
+    monitors.command("stop <key>").description(
+      "Stop a monitor upstream while retaining its definition for `start`."
+    ).option("--dry-run", "Show the stop plan without changing anything").option("--idempotency-key <key>", "Stable retry key")
+  ).action(
+    monitorsAction(
+      (key, options) => handleScalarMonitorLifecycle("stop", key, options)
+    )
+  );
+  const jobs = monitors.command("jobs").description("Read, wait for, inspect, or cancel Monitor Jobs.");
+  withJsonOption(jobs);
+  withJsonOption(
+    jobs.command("get <job-id>").description("Read the durable Monitor Job state.")
+  ).action(monitorsAction(handleMonitorJobGet));
+  withJsonOption(
+    jobs.command("wait <job-id>").description(
+      "Wait for real provider reconciliation, not request acceptance."
+    ).option("--timeout <duration>", "How long to wait (default 10m)")
+  ).action(monitorsAction(handleMonitorJobWait));
+  withJsonOption(
+    jobs.command("logs <job-id>").description("Read bounded operator logs for one Monitor Job.").option("--limit <n>", "Maximum log entries (1..200)")
+  ).action(monitorsAction(handleMonitorJobLogs));
+  withJsonOption(
+    jobs.command("cancel <job-id>").description("Stop unscheduled work and reconcile the partial result.")
+  ).action(monitorsAction(handleMonitorJobCancel));
+  const fleets = monitors.command("fleets").description("Manage table-backed Fleets.").addHelpText(
+    "after",
+    `
+Notes:
+  A Monitor Fleet maps eligible rows in one Customer DB table to ordinary
+  monitors. Fleet definitions are canonical JSON, and \`deploy\` applies one;
+  \`sync\` remains its exact compatibility alias. 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("deploy [fleet-id]").description(
+      "Apply a table-backed Fleet definition; sync remains an exact alias."
+    ).option("-f, --file <path>", "Fleet JSON file, or - for stdin").option("--dry-run", "Show the table-backed convergence plan").option("--wait", "Wait for the current Fleet generation to converge").option("--timeout <duration>", "How long --wait may poll (default 10m)").option(
+      "--expected-generation <generation>",
+      "Optimistic generation fence"
+    ).option("--idempotency-key <key>", "Stable retry key")
+  ).action(
+    monitorsAction(
+      async (fleetId, options) => {
+        const idempotencyKey = fleetIdempotencyKey(
+          "deploy",
+          options.idempotencyKey
+        );
+        await handleMonitorFleetsSync(fleetId, options, idempotencyKey);
+      }
+    )
+  );
+  withJsonOption(
+    fleets.command("lint").description(
+      "Validate and normalize Fleet JSON without network or provider work."
+    ).requiredOption("--file <path>", "Fleet JSON file, or - for stdin")
+  ).action(monitorsAction(handleMonitorFleetLint));
+  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 tools list --categories monitors\` 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":"{{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 Handlebars fields such as {{domain}} 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. The detail also
+  shows the current Plays that observe this Fleet's output; those bindings are
+  read-only here and are defined by each Play's sqlListeners.
+
+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>").alias("stop").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 });
+    }
+  });
+  withJsonOption(
+    fleets.command("reactivate <fleet-id>").alias("start").description(
+      "Explicitly recreate a fleet after a credit-triggered suspension."
+    ).addHelpText(
+      "after",
+      `
+Notes:
+  TAMRadar cannot reactivate a deleted radar. This command starts normal,
+  fenced provider creates from the fleet's retained desired definitions and
+  may restart lifecycle billing. A credit top-up alone never does this.
+
+Example:
+  deepline monitors fleets reactivate account-job-openings --yes --wait --json
+`
+    ).option("--wait", "Poll until the fleet reports converged").option(
+      "--timeout <duration>",
+      "How long --wait may poll: 500ms, 90s, 10m, 1h (default 10m)"
+    ).option("--yes", "Confirm recreating suspended provider monitors").option("--idempotency-key <key>", "Stable retry key")
+  ).action(async (fleetId, options) => {
+    let retryCommand = fleetReactivateCommandLine(fleetId, options);
+    try {
+      const idempotencyKey = fleetIdempotencyKey(
+        "reactivate",
+        options.idempotencyKey
+      );
+      retryCommand = fleetReactivateCommandLine(fleetId, {
+        ...options,
+        idempotencyKey
+      });
+      await handleMonitorFleetsReactivate(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(
+      "--state <state>",
+      "Filter by customer state: active (default), billing_suspended, disabled, or all"
+    ).option(
+      "--status <status>",
+      "Deprecated compatibility filter; use --state (active, billing_suspended, disabled, or all)"
+    ).option("--limit <n>", "Limit the number of deployed monitors returned").option(
+      "--cursor <cursor>",
+      "Page past a truncated result using the next_cursor from a prior list response"
+    ).option(
+      "--compact",
+      "Deprecated no-op; complete records are always returned"
+    ).option(
+      "--include-consumers",
+      "Include current SQL-listener consumer health (requires --limit 20 or fewer)"
+    )
+  ).action(monitorsAction(handleMonitorsList));
+  withJsonOption(
+    deployed.command("get <key>").description("Alias of `monitors get <key>`.")
+  ).action(monitorsAction(handleMonitorsGet));
+  withJsonOption(
+    deployed.command("update <key> [patch]").description("Alias of `monitors update <key>`.").option(
+      "-f, --file <path>",
+      "Read the patch JSON from a file, or - for stdin"
+    )
+  ).action(monitorsAction(handleMonitorsUpdate));
+  withJsonOption(
+    deployed.command("delete <key>").description("Alias of `monitors delete <key>`.").option("--dry-run", "Show the delete plan without deleting anything").option(
+      "--yes",
+      "Skip the confirmation prompt (required non-interactively)"
+    )
+  ).action(monitorsAction(handleMonitorsDelete));
+}
+export {
+  MonitorDryRunUnsupportedError,
+  MonitorFleetStateError,
+  MonitorsUsageError,
+  assertMonitorDryRunAcknowledged,
+  monitorDeleteRequiresYesError,
+  monitorsErrorExitCode,
+  registerMonitorsCommands,
+  renderAvailableToolsText,
+  renderDeployedListText,
+  renderMonitorDeletePlan,
+  renderMonitorDeployCompletion,
+  renderMonitorDeployPlan,
+  renderMonitorGet,
+  renderMonitorReactivatePlan,
+  resolveMonitorJsonBody
+};