deepline 0.3.96 → 0.3.98

package/dist/cli/index.js

@@ -1298,7 +1298,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.96",
+  version: "0.3.98",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1
@@ -3370,9 +3370,9 @@ function nonEmptyString(value) {
 }
 function normalizeDatasetBornFrom(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const record2 = value;
-  const table = nonEmptyString(record2.table);
-  const rowCountIn = finiteNonNegativeInteger2(record2.rowCountIn);
+  const record3 = value;
+  const table = nonEmptyString(record3.table);
+  const rowCountIn = finiteNonNegativeInteger2(record3.rowCountIn);
   if (!table || rowCountIn === null) return null;
   return { table, rowCountIn };
 }
@@ -4561,21 +4561,21 @@ function normalizePlayRuntimeNamespace(value) {
 }
 function normalizePlayRuntimeSelection(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const record2 = value;
-  if (Object.keys(record2).some(
+  const record3 = value;
+  if (Object.keys(record3).some(
     (key) => key !== "environment" && key !== "namespace" && key !== "backend"
-  ) || record2.environment !== "preview") {
+  ) || record3.environment !== "preview") {
     return null;
   }
-  const namespace = normalizePlayRuntimeNamespace(record2.namespace);
+  const namespace = normalizePlayRuntimeNamespace(record3.namespace);
   if (!namespace) return null;
-  if (record2.backend === void 0) {
+  if (record3.backend === void 0) {
     return { environment: "preview", namespace };
   }
-  if (record2.backend !== PLAY_RUNTIME_BACKENDS.daytona && record2.backend !== PLAY_RUNTIME_BACKENDS.modal) {
+  if (record3.backend !== PLAY_RUNTIME_BACKENDS.daytona && record3.backend !== PLAY_RUNTIME_BACKENDS.modal) {
     return null;
   }
-  return { environment: "preview", namespace, backend: record2.backend };
+  return { environment: "preview", namespace, backend: record3.backend };
 }
 function normalizePlayRuntimeEnvironment(value) {
   return typeof value === "string" && PLAY_RUNTIME_ENVIRONMENTS.includes(value) ? value : null;
@@ -5220,10 +5220,18 @@ var DeeplineClient = class {
       repair: (options2) => this.repairMonitors(options2),
       health: (options2) => this.readMonitorsHealth(options2),
       batch: {
+        deploy: (definitions, options2) => this.deployMonitorBatch(definitions, options2),
         submit: (options2) => this.submitMonitorBatch(options2),
         get: (operationId, options2) => this.getMonitorBatch(operationId, options2)
       },
+      jobs: {
+        get: (jobId) => this.getMonitorJob(jobId),
+        logs: (jobId, options2) => this.getMonitorJobLogs(jobId, options2),
+        cancel: (jobId) => this.cancelMonitorJob(jobId),
+        wait: (jobId, options2) => this.waitForMonitorJob(jobId, options2)
+      },
       fleets: {
+        deploy: (definitionOrId, options2) => this.syncMonitorFleet(definitionOrId, options2),
         sync: (definitionOrId, options2) => this.syncMonitorFleet(definitionOrId, options2),
         get: (fleetId, options2) => fleetId === void 0 ? this.listMonitorFleets() : this.getMonitorFleet(fleetId, options2),
         list: () => this.listMonitorFleets(),
@@ -7975,6 +7983,68 @@ var DeeplineClient = class {
     );
   }
   // ——————————————————————————————————————————————————————————
+  // Monitor Jobs, Batches, and Fleets
+  // ——————————————————————————————————————————————————————————
+  monitorJobIdempotencyKey(operation) {
+    const uuid = globalThis.crypto?.randomUUID?.();
+    return `monitor-job-${operation}-${uuid ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`}`;
+  }
+  monitorJobHeaders(operation, idempotencyKey) {
+    return {
+      "Idempotency-Key": idempotencyKey?.trim() || this.monitorJobIdempotencyKey(operation)
+    };
+  }
+  async deployMonitorBatch(definitions, options) {
+    return this.http.request(
+      "/api/v2/monitors/batch/deploy",
+      {
+        method: "POST",
+        body: { version: 1, kind: "batch", monitors: definitions },
+        headers: this.monitorJobHeaders(
+          "batch-deploy",
+          options?.idempotencyKey
+        ),
+        maxRetries: 0,
+        exactUrlOnly: true
+      }
+    );
+  }
+  async getMonitorJob(jobId) {
+    return this.http.request(
+      `/api/v2/monitors/jobs/${encodeURIComponent(jobId)}`,
+      { method: "GET" }
+    );
+  }
+  async getMonitorJobLogs(jobId, options) {
+    const query = options?.limit === void 0 ? "" : `?limit=${encodeURIComponent(String(options.limit))}`;
+    return this.http.request(
+      `/api/v2/monitors/jobs/${encodeURIComponent(jobId)}/logs${query}`,
+      { method: "GET" }
+    );
+  }
+  async cancelMonitorJob(jobId) {
+    return this.http.request(
+      `/api/v2/monitors/jobs/${encodeURIComponent(jobId)}/cancel`,
+      { method: "POST", body: {}, maxRetries: 0, exactUrlOnly: true }
+    );
+  }
+  async waitForMonitorJob(jobId, options) {
+    const timeoutMs = Math.max(1, options?.timeoutMs ?? 10 * 6e4);
+    const pollIntervalMs = Math.max(1, options?.pollIntervalMs ?? 2e3);
+    const terminal = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled"]);
+    const startedAt = Date.now();
+    let latest = await this.getMonitorJob(jobId);
+    while (true) {
+      options?.onProgress?.(latest);
+      const job = latest.job;
+      const state = typeof job?.state === "string" ? job.state : void 0;
+      if (state && terminal.has(state)) return latest;
+      if (Date.now() - startedAt >= timeoutMs) return latest;
+      await sleep2(pollIntervalMs);
+      latest = await this.getMonitorJob(jobId);
+    }
+  }
+  // ——————————————————————————————————————————————————————————
   // Monitor Fleets
   // ——————————————————————————————————————————————————————————
   monitorFleetIdempotencyKey(operation) {
@@ -8746,30 +8816,30 @@ function flattenObjectColumns(row, options = {}) {
       continue;
     }
     if (value && typeof value === "object" && !Array.isArray(value)) {
-      const record2 = value;
+      const record3 = value;
       if (options.objectColumns === "json") {
-        flattened[key] = csvSafeJsonString(record2);
+        flattened[key] = csvSafeJsonString(record3);
         continue;
       }
-      const hasMatchedEnvelope = Object.prototype.hasOwnProperty.call(record2, "matched_result") || Object.prototype.hasOwnProperty.call(record2, "matchedResult");
+      const hasMatchedEnvelope = Object.prototype.hasOwnProperty.call(record3, "matched_result") || Object.prototype.hasOwnProperty.call(record3, "matchedResult");
       if (hasMatchedEnvelope) {
-        flattened[key] = csvSafeJsonString(record2);
+        flattened[key] = csvSafeJsonString(record3);
         continue;
       }
       if (parsedFromString && shouldPreserveJsonStringColumn(options.preserveJsonStringColumns, key)) {
         flattened[key] = rawValue;
         continue;
       } else {
-        const failureMessage = failureMessageFromRecord(record2);
+        const failureMessage = failureMessageFromRecord(record3);
         if (failureMessage) {
           flattened[key] = failureMessage;
           continue;
-        } else if (Object.prototype.hasOwnProperty.call(record2, "result")) {
-          flattened[key] = csvSafeJsonString(record2);
+        } else if (Object.prototype.hasOwnProperty.call(record3, "result")) {
+          flattened[key] = csvSafeJsonString(record3);
           continue;
         }
       }
-      for (const [nestedKey, nestedValue] of Object.entries(record2)) {
+      for (const [nestedKey, nestedValue] of Object.entries(record3)) {
         flattened[`${key}.${nestedKey}`] = nestedValue && typeof nestedValue === "object" ? csvSafeJsonString(nestedValue) : nestedValue;
       }
       continue;
@@ -11436,9 +11506,9 @@ function canonicalDatasetJsonValue(value, ancestors) {
   }
   if (ancestors.has(value)) return value;
   ancestors.add(value);
-  const record2 = value;
+  const record3 = value;
   const normalized = Object.fromEntries(
-    Object.keys(record2).sort((left, right) => left.localeCompare(right)).map((key) => [key, canonicalDatasetJsonValue(record2[key], ancestors)])
+    Object.keys(record3).sort((left, right) => left.localeCompare(right)).map((key) => [key, canonicalDatasetJsonValue(record3[key], ancestors)])
   );
   ancestors.delete(value);
   return normalized;
@@ -12635,16 +12705,16 @@ function collectErrorText(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return errorMessage(value);
   }
-  const record2 = value;
+  const record3 = value;
   return [
     errorMessage(value),
-    typeof record2.error === "string" ? record2.error : "",
-    typeof record2.message === "string" ? record2.message : "",
-    typeof record2.detail === "string" ? record2.detail : "",
-    typeof record2.hint === "string" ? record2.hint : "",
-    typeof record2.code === "string" ? record2.code : "",
-    record2.response ? collectErrorText(record2.response) : "",
-    record2.details ? collectErrorText(record2.details) : ""
+    typeof record3.error === "string" ? record3.error : "",
+    typeof record3.message === "string" ? record3.message : "",
+    typeof record3.detail === "string" ? record3.detail : "",
+    typeof record3.hint === "string" ? record3.hint : "",
+    typeof record3.code === "string" ? record3.code : "",
+    record3.response ? collectErrorText(record3.response) : "",
+    record3.details ? collectErrorText(record3.details) : ""
   ].filter(Boolean).join("\n");
 }
 function formatDbQueryError(sql, error) {
@@ -13658,8 +13728,8 @@ function getterNamesFromTool(tool, kind) {
   return extractionEntries(resultGuidance[key] ?? resultGuidance[snakeKey]).map((entry) => stringValue(entry.name)).filter(Boolean);
 }
 function targetGettersFromTool(tool) {
-  const record2 = isRecord9(tool) ? tool : {};
-  const raw = record2.targetGetters ?? record2.target_getters;
+  const record3 = isRecord9(tool) ? tool : {};
+  const raw = record3.targetGetters ?? record3.target_getters;
   if (!isRecord9(raw)) return {};
   const entries = [];
   for (const [target, value] of Object.entries(raw)) {
@@ -17755,13 +17825,13 @@ function validateFixtureBehavior(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return { ok: false, error: "fixtureBehavior must be a JSON object." };
   }
-  const record2 = value;
-  const supportedKeys = record2.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? /* @__PURE__ */ new Set([
+  const record3 = value;
+  const supportedKeys = record3.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record3.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? /* @__PURE__ */ new Set([
     "version",
     "responseSamples",
-    ...record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? ["replayBundle"] : []
+    ...record3.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? ["replayBundle"] : []
   ]) : /* @__PURE__ */ new Set(["version", "responseDelaySamplesMs"]);
-  const unknownKeys = Object.keys(record2).filter(
+  const unknownKeys = Object.keys(record3).filter(
     (key) => !supportedKeys.has(key)
   );
   if (unknownKeys.length > 0) {
@@ -17770,22 +17840,22 @@ function validateFixtureBehavior(value) {
       error: `Unsupported fixtureBehavior field "${unknownKeys[0]}".`
     };
   }
-  if (record2.version !== FIXTURE_BEHAVIOR_VERSION && record2.version !== FIXTURE_BEHAVIOR_RESPONSE_VERSION && record2.version !== FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+  if (record3.version !== FIXTURE_BEHAVIOR_VERSION && record3.version !== FIXTURE_BEHAVIOR_RESPONSE_VERSION && record3.version !== FIXTURE_BEHAVIOR_REPLAY_VERSION) {
     return {
       ok: false,
       error: `fixtureBehavior.version must be ${FIXTURE_BEHAVIOR_VERSION} or ${FIXTURE_BEHAVIOR_RESPONSE_VERSION}, or ${FIXTURE_BEHAVIOR_REPLAY_VERSION}.`
     };
   }
-  if (record2.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
-    if (!Array.isArray(record2.responseSamples) || record2.responseSamples.length === 0 || record2.responseSamples.length > MAX_FIXTURE_RESPONSE_DELAY_SAMPLES) {
+  if (record3.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record3.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+    if (!Array.isArray(record3.responseSamples) || record3.responseSamples.length === 0 || record3.responseSamples.length > MAX_FIXTURE_RESPONSE_DELAY_SAMPLES) {
       return {
         ok: false,
         error: `fixtureBehavior.responseSamples must contain between 1 and ${MAX_FIXTURE_RESPONSE_DELAY_SAMPLES} values.`
       };
     }
     const samples2 = [];
-    for (let index = 0; index < record2.responseSamples.length; index += 1) {
-      const value2 = record2.responseSamples[index];
+    for (let index = 0; index < record3.responseSamples.length; index += 1) {
+      const value2 = record3.responseSamples[index];
       if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) {
         return {
           ok: false,
@@ -17884,14 +17954,14 @@ function validateFixtureBehavior(value) {
       });
     }
     let replayBundle;
-    if (record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
-      if (!record2.replayBundle || typeof record2.replayBundle !== "object" || Array.isArray(record2.replayBundle)) {
+    if (record3.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+      if (!record3.replayBundle || typeof record3.replayBundle !== "object" || Array.isArray(record3.replayBundle)) {
         return {
           ok: false,
           error: "fixtureBehavior.replayBundle must be an object."
         };
       }
-      const replay = record2.replayBundle;
+      const replay = record3.replayBundle;
       const replayUnknownKeys = Object.keys(replay).filter(
         (key) => key !== "bundleId" && key !== "manifestSha256" && key !== "syntheticFallbackToolIds"
       );
@@ -17939,7 +18009,7 @@ function validateFixtureBehavior(value) {
         ...syntheticFallbackToolIds ? { syntheticFallbackToolIds } : {}
       };
     }
-    if (record2.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+    if (record3.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
       return {
         ok: true,
         behavior: {
@@ -17957,15 +18027,15 @@ function validateFixtureBehavior(value) {
       }
     };
   }
-  if (!Array.isArray(record2.responseDelaySamplesMs) || record2.responseDelaySamplesMs.length === 0 || record2.responseDelaySamplesMs.length > MAX_FIXTURE_RESPONSE_DELAY_SAMPLES) {
+  if (!Array.isArray(record3.responseDelaySamplesMs) || record3.responseDelaySamplesMs.length === 0 || record3.responseDelaySamplesMs.length > MAX_FIXTURE_RESPONSE_DELAY_SAMPLES) {
     return {
       ok: false,
       error: `fixtureBehavior.responseDelaySamplesMs must contain between 1 and ${MAX_FIXTURE_RESPONSE_DELAY_SAMPLES} values.`
     };
   }
   const samples = [];
-  for (let index = 0; index < record2.responseDelaySamplesMs.length; index += 1) {
-    const value2 = record2.responseDelaySamplesMs[index];
+  for (let index = 0; index < record3.responseDelaySamplesMs.length; index += 1) {
+    const value2 = record3.responseDelaySamplesMs[index];
     if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < 0 || value2 > MAX_FIXTURE_RESPONSE_DELAY_MS) {
       return {
         ok: false,
@@ -18744,8 +18814,8 @@ function looksLikeStagedFileRef(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
   }
-  const record2 = value;
-  return typeof record2.contentHash === "string" || typeof record2.contentBase64 === "string" || typeof record2.logicalPath === "string" && typeof record2.bytes === "number";
+  const record3 = value;
+  return typeof record3.contentHash === "string" || typeof record3.contentBase64 === "string" || typeof record3.logicalPath === "string" && typeof record3.bytes === "number";
 }
 var CSV_DATA_INPUT_KEY = "csv";
 function collectLocalFileInputRefs(value, inputPath, key, out) {
@@ -19258,8 +19328,8 @@ function readLiveRunField(event, field) {
   const records = [payload, payload.progress, run, run?.progress].filter(
     (value) => Boolean(value && typeof value === "object" && !Array.isArray(value))
   );
-  for (const record2 of records) {
-    if (record2[field] !== void 0) return record2[field];
+  for (const record3 of records) {
+    if (record3[field] !== void 0) return record3[field];
   }
   return void 0;
 }
@@ -19561,8 +19631,8 @@ function getProgressLinesFromLiveEvent(event) {
     if (!state || typeof state !== "object" || Array.isArray(state)) {
       continue;
     }
-    const record2 = state;
-    const progress = record2.progress && typeof record2.progress === "object" && !Array.isArray(record2.progress) ? record2.progress : null;
+    const record3 = state;
+    const progress = record3.progress && typeof record3.progress === "object" && !Array.isArray(record3.progress) ? record3.progress : null;
     if (!progress) {
       continue;
     }
@@ -19579,7 +19649,7 @@ function getProgressLinesFromLiveEvent(event) {
       completed: progress.completed
     });
     lines.push(
-      `progress ${formatProgressLabel(record2.nodeId ?? progress.artifactTableNamespace)}: ${counts}${messageSuffix}`
+      `progress ${formatProgressLabel(record3.nodeId ?? progress.artifactTableNamespace)}: ${counts}${messageSuffix}`
     );
   }
   return lines;
@@ -20259,11 +20329,11 @@ function truncateErrorForDisplay(message, runId, maxChars = RUN_ERROR_DISPLAY_MA
   const fullErrorHint = runId ? ` (full error: deepline runs get ${runId} --full)` : " (full error: deepline runs get <runId> --full)";
   return `${wordBoundary}\u2026${fullErrorHint}`;
 }
-function clampJsonPreviewText(json, maxChars) {
-  if (json.length <= maxChars) {
-    return json;
+function clampJsonPreviewText(json2, maxChars) {
+  if (json2.length <= maxChars) {
+    return json2;
   }
-  const slice = json.slice(0, maxChars);
+  const slice = json2.slice(0, maxChars);
   const lastNewline = slice.lastIndexOf("\n");
   const head = lastNewline > 0 ? slice.slice(0, lastNewline) : slice;
   return `${head}
@@ -20389,12 +20459,12 @@ function defaultResultForEnvelope(value, depth = 0) {
   return output2;
 }
 function formatJsonPreview(value) {
-  const json = JSON.stringify(value, null, 2);
-  if (!json || json === "{}") {
+  const json2 = JSON.stringify(value, null, 2);
+  if (!json2 || json2 === "{}") {
     return [];
   }
   const MAX_CHARS = 4e3;
-  const truncated = clampJsonPreviewText(json, MAX_CHARS);
+  const truncated = clampJsonPreviewText(json2, MAX_CHARS);
   return truncated.split("\n").map((line) => `    ${line}`);
 }
 function formatReturnValue(result) {
@@ -20422,17 +20492,17 @@ function collectDatasetHandleLines(value, path = "result") {
     return [];
   }
   if (isDatasetHandle(value)) {
-    const record2 = value;
-    const count = typeof record2.count === "number" ? record2.count : typeof record2.rowCount === "number" ? record2.rowCount : null;
-    const preview = Array.isArray(record2.preview) ? record2.preview : [];
+    const record3 = value;
+    const count = typeof record3.count === "number" ? record3.count : typeof record3.rowCount === "number" ? record3.rowCount : null;
+    const preview = Array.isArray(record3.preview) ? record3.preview : [];
     const lines2 = [
-      `  dataset ${typeof record2.path === "string" ? record2.path : path}: rows=${count === null ? "-" : formatInteger(count)} preview=${formatInteger(preview.length)}`
+      `  dataset ${typeof record3.path === "string" ? record3.path : path}: rows=${count === null ? "-" : formatInteger(count)} preview=${formatInteger(preview.length)}`
     ];
-    if (typeof record2.queryDatasetCommand === "string") {
-      lines2.push(`  query dataset: ${record2.queryDatasetCommand}`);
+    if (typeof record3.queryDatasetCommand === "string") {
+      lines2.push(`  query dataset: ${record3.queryDatasetCommand}`);
     }
-    if (typeof record2.slowExportAsCsvCommand === "string") {
-      lines2.push(`  export CSV: ${record2.slowExportAsCsvCommand}`);
+    if (typeof record3.slowExportAsCsvCommand === "string") {
+      lines2.push(`  export CSV: ${record3.slowExportAsCsvCommand}`);
     }
     return lines2;
   }
@@ -20829,8 +20899,8 @@ function withTerminalPlayIdentity(status, playName) {
   if (!playName.trim() || getPlayRunPackage(status)) {
     return status;
   }
-  const record2 = status;
-  const hasIdentity = typeof record2.playName === "string" && record2.playName.trim().length > 0 || typeof record2.name === "string" && record2.name.trim().length > 0 || Boolean(getStringField(record2.run, "playName"));
+  const record3 = status;
+  const hasIdentity = typeof record3.playName === "string" && record3.playName.trim().length > 0 || typeof record3.name === "string" && record3.name.trim().length > 0 || Boolean(getStringField(record3.run, "playName"));
   if (hasIdentity) {
     return status;
   }
@@ -20943,9 +21013,9 @@ function formatSummaryScalar(value) {
   }
   return null;
 }
-function formatSummaryScalarParts(record2, skipKeys = /* @__PURE__ */ new Set()) {
+function formatSummaryScalarParts(record3, skipKeys = /* @__PURE__ */ new Set()) {
   const parts = [];
-  for (const [key, value] of Object.entries(record2)) {
+  for (const [key, value] of Object.entries(record3)) {
     if (skipKeys.has(key)) {
       continue;
     }
@@ -20972,13 +21042,13 @@ function formatTopValuesPart(value) {
   return `top_values=${entries.map(([topValue, count]) => `${topValue}=${String(count)}`).join(", ")}`;
 }
 function formatPackageDatasetSummaryLines(summary, indent2 = "    ") {
-  const record2 = readRecord(summary);
-  const columnStats = readRecord(record2?.columnStats);
-  if (!record2 || !columnStats) {
+  const record3 = readRecord(summary);
+  const columnStats = readRecord(record3?.columnStats);
+  if (!record3 || !columnStats) {
     return [];
   }
   const lines = [];
-  const rowCounts = readRecord(record2.rowCounts);
+  const rowCounts = readRecord(record3.rowCounts);
   if (rowCounts) {
     const persisted = readNonNegativeInteger(rowCounts.persisted);
     const succeeded = readNonNegativeInteger(rowCounts.succeeded);
@@ -20994,7 +21064,7 @@ function formatPackageDatasetSummaryLines(summary, indent2 = "    ") {
     }
   }
   const parts = formatSummaryScalarParts(
-    record2,
+    record3,
     /* @__PURE__ */ new Set(["columnStats", "rowCounts"])
   );
   if (parts.length > 0) {
@@ -21024,35 +21094,35 @@ function actionToCommand(action) {
   if (!action || typeof action !== "object" || Array.isArray(action)) {
     return null;
   }
-  const record2 = action;
-  if (typeof record2.command === "string" && record2.command.trim()) {
-    return record2.command.trim();
+  const record3 = action;
+  if (typeof record3.command === "string" && record3.command.trim()) {
+    return record3.command.trim();
   }
-  if (record2.kind === "deepline_run_inspect" && typeof record2.runId === "string") {
-    return `deepline runs get ${record2.runId} --json`;
+  if (record3.kind === "deepline_run_inspect" && typeof record3.runId === "string") {
+    return `deepline runs get ${record3.runId} --json`;
   }
-  if (record2.kind === "deepline_run_full" && typeof record2.runId === "string") {
-    return `deepline runs get ${record2.runId} --full --json`;
+  if (record3.kind === "deepline_run_full" && typeof record3.runId === "string") {
+    return `deepline runs get ${record3.runId} --full --json`;
   }
-  if (record2.kind === "deepline_run_billing" && typeof record2.runId === "string") {
-    return `deepline runs get ${record2.runId} --full --json | jq '.billing'`;
+  if (record3.kind === "deepline_run_billing" && typeof record3.runId === "string") {
+    return `deepline runs get ${record3.runId} --full --json | jq '.billing'`;
   }
-  if (record2.kind === "deepline_run_export" && typeof record2.runId === "string" && typeof record2.datasetPath === "string") {
-    return `deepline runs export ${record2.runId} --dataset ${shellSingleQuote(
-      record2.datasetPath
-    )} --out ${shellSingleQuote(`${record2.datasetPath.split(".").pop() || "dataset"}.csv`)}`;
+  if (record3.kind === "deepline_run_export" && typeof record3.runId === "string" && typeof record3.datasetPath === "string") {
+    return `deepline runs export ${record3.runId} --dataset ${shellSingleQuote(
+      record3.datasetPath
+    )} --out ${shellSingleQuote(`${record3.datasetPath.split(".").pop() || "dataset"}.csv`)}`;
   }
-  if (record2.kind === "deepline_run_logs") {
-    if (typeof record2.command === "string" && record2.command.trim()) {
-      return record2.command;
+  if (record3.kind === "deepline_run_logs") {
+    if (typeof record3.command === "string" && record3.command.trim()) {
+      return record3.command;
     }
-    if (typeof record2.runId === "string") {
-      return record2.view === "failed" ? `deepline runs get ${record2.runId} --log-failed --json` : `deepline runs logs ${record2.runId} --json`;
+    if (typeof record3.runId === "string") {
+      return record3.view === "failed" ? `deepline runs get ${record3.runId} --log-failed --json` : `deepline runs logs ${record3.runId} --json`;
     }
   }
-  if (record2.kind === "deepline_db_query" && typeof record2.sql === "string") {
-    const maxRows = typeof record2.maxRows === "number" && Number.isFinite(record2.maxRows) ? Math.trunc(record2.maxRows) : 20;
-    return `deepline db query --sql ${shellSingleQuote(record2.sql)} --max-rows ${maxRows} --json`;
+  if (record3.kind === "deepline_db_query" && typeof record3.sql === "string") {
+    const maxRows = typeof record3.maxRows === "number" && Number.isFinite(record3.maxRows) ? Math.trunc(record3.maxRows) : 20;
+    return `deepline db query --sql ${shellSingleQuote(record3.sql)} --max-rows ${maxRows} --json`;
   }
   return null;
 }
@@ -21127,8 +21197,8 @@ function formatPackageDatasetActionLines(packaged) {
 }
 function formatInlinePackageValue(value) {
   const compacted = compactReturnValue(value);
-  const json = JSON.stringify(compacted);
-  return clampJsonPreviewText(json ?? String(compacted), 500);
+  const json2 = JSON.stringify(compacted);
+  return clampJsonPreviewText(json2 ?? String(compacted), 500);
 }
 function formatPackageValueOutputLines(packaged) {
   const outputs = packaged.outputs && typeof packaged.outputs === "object" && !Array.isArray(packaged.outputs) ? packaged.outputs : null;
@@ -21461,12 +21531,12 @@ function exportableSheetRow(row) {
   if (!row || typeof row !== "object" || Array.isArray(row)) {
     return null;
   }
-  const record2 = row;
-  const data = record2.data;
+  const record3 = row;
+  const data = record3.data;
   if (data && typeof data === "object" && !Array.isArray(data)) {
     return data;
   }
-  const fallback = { ...record2 };
+  const fallback = { ...record3 };
   for (const key of [
     "key",
     "status",
@@ -21485,7 +21555,7 @@ function exportableSheetRow(row) {
   return fallback;
 }
 function acceptsSettledRowsAsCompleteExport(status) {
-  return status.status === "failed" || status.status === "cancelled";
+  return status.status === "completed" || status.status === "failed" || status.status === "cancelled";
 }
 function mergeExportColumns(preferredColumns, rows) {
   const columns = [];
@@ -21814,8 +21884,8 @@ var PLAY_SYNTAX_MIGRATION_ERROR_MARKERS = [
   "ctx.map(...) has been replaced by ctx.dataset(...)",
   "Dataset .step(...) has been replaced by .withColumn(...)"
 ];
-function stringArrayField(record2, key) {
-  const value = record2[key];
+function stringArrayField(record3, key) {
+  const value = record3[key];
   if (!Array.isArray(value)) return [];
   return value.filter((entry) => typeof entry === "string");
 }
@@ -22646,8 +22716,8 @@ function cronExecutionLabel(status) {
   return status;
 }
 function readLiveCronMetadata(play) {
-  const record2 = readRecord(play);
-  const metadata = readRecord(record2?.triggerMetadata);
+  const record3 = readRecord(play);
+  const metadata = readRecord(record3?.triggerMetadata);
   return {
     schedule: typeof metadata?.cronSchedule === "string" ? metadata.cronSchedule : null,
     timezone: typeof metadata?.cronTimezone === "string" ? metadata.cronTimezone : null,
@@ -27978,9 +28048,9 @@ async function expandCompiledConfigAtFiles(value) {
   if (!value || typeof value !== "object") {
     return value;
   }
-  const record2 = value;
+  const record3 = value;
   const expanded = {};
-  for (const [key, entry] of Object.entries(record2)) {
+  for (const [key, entry] of Object.entries(record3)) {
     expanded[key] = await expandCompiledConfigAtFiles(entry);
   }
   for (const field of ["extract_js", "run_if_js"]) {
@@ -28778,26 +28848,26 @@ function readFirstEnrichDatasetActions(value) {
       }
       return null;
     }
-    const record2 = candidate;
-    const actions = isRecord11(record2.actions) ? record2.actions : null;
+    const record3 = candidate;
+    const actions = isRecord11(record3.actions) ? record3.actions : null;
     const currentQuery = isRecord11(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
     const legacyQuery = isRecord11(actions?.query) ? actions.query : null;
     const query = currentQuery?.kind === "deepline_db_query" ? currentQuery : legacyQuery?.kind === "deepline_db_query" ? legacyQuery : null;
     if (query?.kind === "deepline_db_query") {
       return {
-        dataset: record2,
+        dataset: record3,
         query,
         ...isRecord11(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
       };
     }
-    if (options.allowLegacy && record2.kind === "dataset" && typeof record2.queryDatasetCommand === "string" && record2.queryDatasetCommand.trim()) {
+    if (options.allowLegacy && record3.kind === "dataset" && typeof record3.queryDatasetCommand === "string" && record3.queryDatasetCommand.trim()) {
       return {
-        dataset: record2,
-        queryDatasetCommand: record2.queryDatasetCommand.trim(),
-        ...typeof record2.slowExportAsCsvCommand === "string" && record2.slowExportAsCsvCommand.trim() ? { slowExportAsCsvCommand: record2.slowExportAsCsvCommand.trim() } : {}
+        dataset: record3,
+        queryDatasetCommand: record3.queryDatasetCommand.trim(),
+        ...typeof record3.slowExportAsCsvCommand === "string" && record3.slowExportAsCsvCommand.trim() ? { slowExportAsCsvCommand: record3.slowExportAsCsvCommand.trim() } : {}
       };
     }
-    for (const [key, entry] of Object.entries(record2)) {
+    for (const [key, entry] of Object.entries(record3)) {
       if (key === "preview") {
         continue;
       }
@@ -28813,8 +28883,8 @@ function readFirstEnrichDatasetActions(value) {
   seen.clear();
   return walk(value, { allowLegacy: true });
 }
-function actionStringField(record2, key) {
-  const value = record2[key];
+function actionStringField(record3, key) {
+  const value = record3[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function parseSqlFromDbQueryCommand(command) {
@@ -29158,12 +29228,12 @@ function collectStringFields(value, key, output2, depth = 0) {
     }
     return;
   }
-  const record2 = value;
-  const direct = record2[key];
+  const record3 = value;
+  const direct = record3[key];
   if (typeof direct === "string" && direct.trim()) {
     output2.add(direct.trim());
   }
-  for (const child of Object.values(record2)) {
+  for (const child of Object.values(record3)) {
     collectStringFields(child, key, output2, depth + 1);
   }
 }
@@ -29349,23 +29419,23 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
   if (!row || typeof row !== "object" || Array.isArray(row)) {
     return null;
   }
-  const record2 = row;
-  const data = record2.data;
+  const record3 = row;
+  const data = record3.data;
   if (data && typeof data === "object" && !Array.isArray(data)) {
     const exported = { ...data };
     applyFailureCellMeta(exported, exported[ENRICH_CELL_META_FIELD], {
-      rowError: record2.error
+      rowError: record3.error
     });
-    applyFailureCellMeta(exported, record2.cellMeta, { rowError: record2.error });
-    applyFailureCellMeta(exported, record2.cellMetaPatch, {
-      rowError: record2.error
+    applyFailureCellMeta(exported, record3.cellMeta, { rowError: record3.error });
+    applyFailureCellMeta(exported, record3.cellMetaPatch, {
+      rowError: record3.error
     });
-    applyFailureCellMeta(exported, record2[ENRICH_CELL_META_PATCH_FIELD], {
-      rowError: record2.error
+    applyFailureCellMeta(exported, record3[ENRICH_CELL_META_PATCH_FIELD], {
+      rowError: record3.error
     });
     delete exported[ENRICH_CELL_META_FIELD];
     delete exported[ENRICH_CELL_META_PATCH_FIELD];
-    const inputIndex = typeof record2.inputIndex === "number" ? record2.inputIndex : typeof record2.inputIndex === "string" && record2.inputIndex.trim() ? Number(record2.inputIndex) : Number.NaN;
+    const inputIndex = typeof record3.inputIndex === "number" ? record3.inputIndex : typeof record3.inputIndex === "string" && record3.inputIndex.trim() ? Number(record3.inputIndex) : Number.NaN;
     if (Number.isInteger(inputIndex) && inputIndex >= 0) {
       if (ENRICH_SOURCE_ROW_INDEX_COLUMN in exported) {
         exported[ENRICH_ORIGINAL_SOURCE_ROW_INDEX_COLUMN] = exported[ENRICH_SOURCE_ROW_INDEX_COLUMN];
@@ -29374,18 +29444,18 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
     }
     return exported;
   }
-  const fallback = { ...record2 };
+  const fallback = { ...record3 };
   applyFailureCellMeta(fallback, fallback[ENRICH_CELL_META_FIELD], {
-    rowError: record2.error
+    rowError: record3.error
   });
-  applyFailureCellMeta(fallback, record2.cellMeta, {
-    rowError: record2.error
+  applyFailureCellMeta(fallback, record3.cellMeta, {
+    rowError: record3.error
   });
-  applyFailureCellMeta(fallback, record2.cellMetaPatch, {
-    rowError: record2.error
+  applyFailureCellMeta(fallback, record3.cellMetaPatch, {
+    rowError: record3.error
   });
   applyFailureCellMeta(fallback, fallback[ENRICH_CELL_META_PATCH_FIELD], {
-    rowError: record2.error
+    rowError: record3.error
   });
   for (const key of [
     "key",
@@ -29604,16 +29674,16 @@ function isWaterfallResultMeaningful(value) {
     return value.some(isWaterfallResultMeaningful);
   }
   if (value && typeof value === "object") {
-    const record2 = value;
-    const status = typeof record2.status === "string" ? record2.status.trim().toLowerCase() : "";
+    const record3 = value;
+    const status = typeof record3.status === "string" ? record3.status.trim().toLowerCase() : "";
     if (status === "error" || status === "failed") {
       return false;
     }
-    if (typeof record2.error === "string" && record2.error.trim()) {
+    if (typeof record3.error === "string" && record3.error.trim()) {
       return false;
     }
-    if (Object.prototype.hasOwnProperty.call(record2, "matched_result")) {
-      return isWaterfallResultMeaningful(record2.matched_result);
+    if (Object.prototype.hasOwnProperty.call(record3, "matched_result")) {
+      return isWaterfallResultMeaningful(record3.matched_result);
     }
     for (const key of [
       "value",
@@ -29628,11 +29698,11 @@ function isWaterfallResultMeaningful(value) {
       "result",
       "data"
     ]) {
-      if (isWaterfallResultMeaningful(record2[key])) {
+      if (isWaterfallResultMeaningful(record3[key])) {
         return true;
       }
     }
-    return Object.entries(record2).some(
+    return Object.entries(record3).some(
       ([key, entry]) => !ENRICH_FLATTENED_CONTROL_FIELDS.has(key) && isWaterfallResultMeaningful(entry)
     );
   }
@@ -29648,8 +29718,8 @@ function stableRowSnapshot(value) {
     return `[${value.map(stableRowSnapshot).join(",")}]`;
   }
   if (value && typeof value === "object") {
-    const record2 = value;
-    return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${stableRowSnapshot(record2[key])}`).join(",")}}`;
+    const record3 = value;
+    return `{${Object.keys(record3).sort().map((key) => `${JSON.stringify(key)}:${stableRowSnapshot(record3[key])}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
@@ -30236,8 +30306,8 @@ function addEnrichFollowUpCommand(commands, seen, command) {
   seen.add(normalized);
   commands.push({ ...command, command: normalized });
 }
-function datasetSelectorForEnrichCommand(record2, fallbackPath) {
-  const candidates = [record2.path, record2.tableNamespace, fallbackPath];
+function datasetSelectorForEnrichCommand(record3, fallbackPath) {
+  const candidates = [record3.path, record3.tableNamespace, fallbackPath];
   for (const candidate of candidates) {
     if (typeof candidate === "string" && candidate.trim()) {
       return candidate.trim();
@@ -30299,19 +30369,19 @@ function collectDatasetFollowUpCommands(value, state) {
     );
     return;
   }
-  const record2 = value;
-  const isDataset = record2.kind === "dataset";
+  const record3 = value;
+  const isDataset = record3.kind === "dataset";
   if (isDataset) {
-    const selector = datasetSelectorForEnrichCommand(record2, state.path);
-    const labelPath = typeof record2.path === "string" && record2.path.trim() ? record2.path.trim() : selector ?? state.path;
-    if (typeof record2.queryDatasetCommand === "string") {
+    const selector = datasetSelectorForEnrichCommand(record3, state.path);
+    const labelPath = typeof record3.path === "string" && record3.path.trim() ? record3.path.trim() : selector ?? state.path;
+    if (typeof record3.queryDatasetCommand === "string") {
       addEnrichFollowUpCommand(state.commands, state.seen, {
         label: `query ${labelPath}`,
         path: labelPath,
-        command: record2.queryDatasetCommand
+        command: record3.queryDatasetCommand
       });
     }
-    const exportCommand = typeof record2.slowExportAsCsvCommand === "string" ? record2.slowExportAsCsvCommand : typeof record2.fullExportCommand === "string" ? record2.fullExportCommand : null;
+    const exportCommand = typeof record3.slowExportAsCsvCommand === "string" ? record3.slowExportAsCsvCommand : typeof record3.fullExportCommand === "string" ? record3.fullExportCommand : null;
     if (exportCommand) {
       addEnrichFollowUpCommand(state.commands, state.seen, {
         label: `export ${labelPath}`,
@@ -30328,7 +30398,7 @@ function collectDatasetFollowUpCommands(value, state) {
       });
     }
   }
-  for (const [key, child] of Object.entries(record2)) {
+  for (const [key, child] of Object.entries(record3)) {
     if (key === "preview" || key === "access") {
       continue;
     }
@@ -31795,9 +31865,9 @@ function readCodexSessionId(filePath) {
     )) {
       const parsed = parseJsonLine(line);
       if (!parsed || typeof parsed !== "object") continue;
-      const record2 = parsed;
-      const payload = record2.payload && typeof record2.payload === "object" ? record2.payload : null;
-      const id = record2.type === "session_meta" && typeof payload?.id === "string" ? payload.id : null;
+      const record3 = parsed;
+      const payload = record3.payload && typeof record3.payload === "object" ? record3.payload : null;
+      const id = record3.type === "session_meta" && typeof payload?.id === "string" ? payload.id : null;
       if (id && UUID_RE.test(id)) return id;
     }
   } catch {
@@ -31896,15 +31966,15 @@ function messageContentKey(value) {
   if (!Array.isArray(content)) return null;
   return content.map((block) => {
     if (!block || typeof block !== "object") return String(block);
-    const record2 = block;
-    const type = String(record2.type ?? "");
+    const record3 = block;
+    const type = String(record3.type ?? "");
     if (type === "tool_use") {
-      return `tool_use:${String(record2.name ?? "")}:${String(record2.id ?? "")}`;
+      return `tool_use:${String(record3.name ?? "")}:${String(record3.id ?? "")}`;
     }
     if (type === "tool_result") {
-      return `tool_result:${String(record2.tool_use_id ?? "")}`;
+      return `tool_result:${String(record3.tool_use_id ?? "")}`;
     }
-    return String(record2.text ?? type);
+    return String(record3.text ?? type);
   }).join("\n");
 }
 function dedupConsecutiveEvents(raw) {
@@ -31919,9 +31989,9 @@ function dedupConsecutiveEvents(raw) {
       index += 1;
       continue;
     }
-    const record2 = event;
-    const eventType = String(record2.type ?? "");
-    const eventKey = messageContentKey(record2);
+    const record3 = event;
+    const eventType = String(record3.type ?? "");
+    const eventKey = messageContentKey(record3);
     if (!["user", "assistant"].includes(eventType) || !eventKey) {
       output2.push(rawLines[index] ?? "");
       index += 1;
@@ -31940,9 +32010,9 @@ function dedupConsecutiveEvents(raw) {
       cursor += 1;
     }
     if (runCount > 1) {
-      record2._repeat_count = runCount;
-      record2._repeat_summary = `${runCount} consecutive identical ${eventType} messages collapsed`;
-      output2.push(JSON.stringify(record2));
+      record3._repeat_count = runCount;
+      record3._repeat_summary = `${runCount} consecutive identical ${eventType} messages collapsed`;
+      output2.push(JSON.stringify(record3));
       index = cursor;
       continue;
     }
@@ -31987,9 +32057,9 @@ function selectiveCompactToolResults(raw) {
       lines.push(line);
       continue;
     }
-    const record2 = parsed;
-    if (record2.type === "user") {
-      const message = record2.message;
+    const record3 = parsed;
+    if (record3.type === "user") {
+      const message = record3.message;
       const content = message && typeof message === "object" ? message.content : null;
       if (Array.isArray(content)) {
         message.content = content.map(
@@ -31997,7 +32067,7 @@ function selectiveCompactToolResults(raw) {
         );
       }
     }
-    lines.push(JSON.stringify(record2));
+    lines.push(JSON.stringify(record3));
   }
   return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf8");
@@ -32023,15 +32093,15 @@ function compactCodexEvents(raw) {
       lines.push(rawLines[index] ?? "");
       return;
     }
-    const record2 = event;
-    if (record2.type === "world_state") return;
-    const payload = record2.payload;
+    const record3 = event;
+    if (record3.type === "world_state") return;
+    const payload = record3.payload;
     const payloadType = payload && typeof payload === "object" ? String(payload.type ?? "") : "";
     if (payloadType === "token_count" && index !== lastTokenCountIndex) return;
     if (payloadType === "custom_tool_call_output" || payloadType === "function_call_output" || payloadType === "tool_search_output") {
       const record_payload = payload;
       record_payload.output = compactEventValue(record_payload.output);
-      lines.push(JSON.stringify(record2));
+      lines.push(JSON.stringify(record3));
       return;
     }
     lines.push(rawLines[index] ?? "");
@@ -32237,8 +32307,8 @@ function parsePreparedEvents(buffer) {
     return parsed ?? line;
   });
 }
-function escapeJsonForHtmlScript(json) {
-  return json.replace(/</g, "\\u003c");
+function escapeJsonForHtmlScript(json2) {
+  return json2.replace(/</g, "\\u003c");
 }
 async function handleSessionsRender(options) {
   const targets = resolveSessionTargets({
@@ -32499,11 +32569,317 @@ var import_node_fs15 = require("fs");
 var import_node_path17 = require("path");
 var import_promises8 = require("readline/promises");
 
+// ../integration-contracts/monitor-input-contract.ts
+var import_handlebars = __toESM(require("handlebars"), 1);
+function authoredMonitorFieldPath(path, field) {
+  const batch = /^monitors\.(\d+)$/.exec(path);
+  return `${batch ? `monitors[${batch[1]}]` : path}.${field}`;
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function json(value, path, issues) {
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((child, index) => json(child, `${path}.${index}`, issues));
+    return;
+  }
+  const object = record(value);
+  if (!object) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_json_value",
+      path,
+      message: "Monitor values must be JSON values."
+    });
+    return;
+  }
+  for (const [key, child] of Object.entries(object)) {
+    json(child, `${path}.${key}`, issues);
+  }
+}
+function monitorSpec(value, path, issues) {
+  const input2 = record(value);
+  if (!input2) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_spec",
+      path,
+      message: "A monitor must be a JSON object."
+    });
+    return null;
+  }
+  const allowed = /* @__PURE__ */ new Set(["key", "tool", "name", "payload"]);
+  for (const key2 of Object.keys(input2)) {
+    if (!allowed.has(key2)) {
+      if (key2 === "controls") {
+        issues.push({
+          severity: "error",
+          code: "CONTROLS_NOT_SUPPORTED",
+          path: authoredMonitorFieldPath(path, "controls"),
+          message: "Operational controls are managed by Deepline and cannot be authored in Batch or Fleet JSON.",
+          suggestion: "Remove controls. Bind downstream automation in a Play with sqlListeners."
+        });
+        continue;
+      }
+      if (key2 === "play") {
+        issues.push({
+          severity: "error",
+          code: "PLAY_BINDING_NOT_IN_MONITOR_SPEC",
+          path: authoredMonitorFieldPath(path, "play"),
+          message: "A monitor does not own Play bindings.",
+          suggestion: "Declare sqlListeners in the Play, or run: deepline plays bootstrap monitor-triggered --out on-event.play.ts"
+        });
+        continue;
+      }
+      issues.push({
+        severity: "error",
+        code: "unknown_monitor_field",
+        path: `${path}.${key2}`,
+        message: `Monitor definitions do not accept '${key2}'.`
+      });
+    }
+  }
+  const key = typeof input2.key === "string" ? input2.key.trim() : "";
+  const tool = typeof input2.tool === "string" ? input2.tool.trim() : "";
+  const name = input2.name === void 0 ? void 0 : typeof input2.name === "string" && input2.name.trim() ? input2.name.trim() : null;
+  const payload = record(input2.payload);
+  if (!key) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_key",
+      path: `${path}.key`,
+      message: "Monitor key must be a non-empty string."
+    });
+  }
+  if (!tool) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_tool",
+      path: `${path}.tool`,
+      message: "Monitor tool must be a non-empty literal string."
+    });
+  }
+  if (name === null) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_name",
+      path: `${path}.name`,
+      message: "Monitor name must be a non-empty string when supplied."
+    });
+  }
+  if (!payload) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_payload",
+      path: `${path}.payload`,
+      message: "Monitor payload must be an object."
+    });
+  } else {
+    json(payload, `${path}.payload`, issues);
+  }
+  if (!key || !tool || !payload || name === null) {
+    return null;
+  }
+  return {
+    key,
+    tool,
+    ...name ? { name } : {},
+    payload
+  };
+}
+function issueOrder(left, right) {
+  return left.path.localeCompare(right.path) || left.severity.localeCompare(right.severity) || left.code.localeCompare(right.code);
+}
+function lintMonitorBatchInput(value) {
+  const issues = [];
+  const versionlessEnvelope = !Array.isArray(value) && (() => {
+    const candidate = record(value);
+    return candidate !== null && Object.keys(candidate).length === 1 && Object.prototype.hasOwnProperty.call(candidate, "monitors");
+  })();
+  const legacy = Array.isArray(value) || versionlessEnvelope;
+  const input2 = legacy ? null : record(value);
+  let monitors = Array.isArray(value) ? value : versionlessEnvelope ? (() => {
+    const candidate = record(value)?.monitors;
+    return Array.isArray(candidate) ? candidate : null;
+  })() : null;
+  if (Array.isArray(value)) {
+    issues.push({
+      severity: "warning",
+      code: "deprecated_batch_array",
+      path: "",
+      message: "Bare monitor arrays are supported for compatibility.",
+      suggestion: 'Wrap the list in {"version":1,"kind":"batch","monitors":[...]}.'
+    });
+  } else if (versionlessEnvelope) {
+    issues.push({
+      severity: "warning",
+      code: "deprecated_batch_missing_envelope_fields",
+      path: "",
+      message: "Versionless monitor envelopes are supported for compatibility.",
+      suggestion: 'Add "version": 1 and "kind": "batch".'
+    });
+    if (!monitors) {
+      issues.push({
+        severity: "error",
+        code: "invalid_batch_monitors",
+        path: "monitors",
+        message: "Batch monitors must be an array."
+      });
+    }
+  } else if (!input2) {
+    issues.push({
+      severity: "error",
+      code: "invalid_batch",
+      path: "",
+      message: "Batch input must be an object or a legacy array."
+    });
+  } else {
+    for (const key of Object.keys(input2)) {
+      if (!["version", "kind", "monitors"].includes(key)) {
+        issues.push({
+          severity: "error",
+          code: key === "source" || key === "monitor" ? "batch_fleet_shape_mixup" : "unknown_batch_field",
+          path: key,
+          message: `Batch input does not accept '${key}'.`
+        });
+      }
+    }
+    if (input2.version !== 1) {
+      issues.push({
+        severity: "error",
+        code: "unsupported_batch_version",
+        path: "version",
+        message: "Batch input version must be 1."
+      });
+    }
+    if (input2.kind !== "batch") {
+      issues.push({
+        severity: "error",
+        code: "invalid_batch_kind",
+        path: "kind",
+        message: 'Batch input kind must be "batch".'
+      });
+    }
+    monitors = Array.isArray(input2.monitors) ? input2.monitors : null;
+    if (!monitors) {
+      issues.push({
+        severity: "error",
+        code: "invalid_batch_monitors",
+        path: "monitors",
+        message: "Batch monitors must be an array."
+      });
+    }
+  }
+  if (!monitors || monitors.length === 0) {
+    if (monitors?.length === 0) {
+      issues.push({
+        severity: "error",
+        code: "empty_batch",
+        path: "monitors",
+        message: "A Batch needs at least one monitor."
+      });
+    }
+    return { issues: issues.sort(issueOrder) };
+  }
+  const normalized = monitors.map(
+    (item, index) => monitorSpec(item, `monitors.${index}`, issues)
+  );
+  const seen = /* @__PURE__ */ new Map();
+  normalized.forEach((item, index) => {
+    if (!item) return;
+    const first = seen.get(item.key);
+    if (first !== void 0) {
+      for (const position of [first, index]) {
+        issues.push({
+          severity: "error",
+          code: "duplicate_monitor_key",
+          path: `monitors.${position}.key`,
+          message: `Duplicate monitor key '${item.key}'.`
+        });
+      }
+    } else {
+      seen.set(item.key, index);
+    }
+  });
+  const ordered = issues.sort(issueOrder);
+  return ordered.some((issue) => issue.severity === "error") ? { issues: ordered } : {
+    normalized: {
+      version: 1,
+      kind: "batch",
+      monitors: normalized
+    },
+    issues: ordered
+  };
+}
+function validateHandlebars(value, path, issues) {
+  if (!value.includes("{{")) return;
+  try {
+    import_handlebars.default.parse(value);
+  } catch (error) {
+    issues.push({
+      severity: "error",
+      code: "invalid_handlebars_template",
+      path,
+      message: error instanceof Error ? error.message : "Invalid Handlebars template."
+    });
+    return;
+  }
+  const expressions = value.match(/{{[\s\S]*?}}/g) ?? [];
+  if (expressions.some(
+    (expression) => !/^{{\s*[A-Za-z_][A-Za-z0-9_]*\s*}}$/.test(expression)
+  )) {
+    issues.push({
+      severity: "error",
+      code: "unsupported_handlebars_expression",
+      path,
+      message: "Fleet templates allow only direct source-row fields such as {{domain}}; helpers, blocks, partials, paths, and prototype access are disabled."
+    });
+  }
+}
+function walkTemplates(value, path, issues) {
+  if (typeof value === "string") return validateHandlebars(value, path, issues);
+  if (Array.isArray(value)) {
+    value.forEach(
+      (item, index) => walkTemplates(item, `${path}.${index}`, issues)
+    );
+    return;
+  }
+  const input2 = record(value);
+  if (!input2) return;
+  for (const [key, child] of Object.entries(input2)) {
+    walkTemplates(child, `${path}.${key}`, issues);
+  }
+}
+function lintMonitorSpecTemplate(value, path = "monitor") {
+  const issues = [];
+  const normalized = monitorSpec(value, path, issues);
+  const input2 = record(value);
+  if (input2 && typeof input2.tool === "string" && input2.tool.includes("{{")) {
+    issues.push({
+      severity: "error",
+      code: "templated_monitor_tool",
+      path: `${path}.tool`,
+      message: "Fleet monitor tool must be literal; only key, name, and payload may be templated."
+    });
+  }
+  if (input2) {
+    for (const field of ["key", "name", "payload"]) {
+      if (input2[field] !== void 0)
+        walkTemplates(input2[field], `${path}.${field}`, issues);
+    }
+  }
+  const ordered = issues.sort(issueOrder);
+  return ordered.some((issue) => issue.severity === "error") ? { issues: ordered } : { normalized, issues: ordered };
+}
+
 // ../integration-contracts/monitor-fleet-contract.ts
 var MONITOR_FLEET_MAX_MEMBERS = 1e3;
-var MONITOR_FLEET_AUTHORING_CONTRACT_EDITION = 1;
 var SUPPORTED_MONITOR_FLEET_AUTHORING_CONTRACT_EDITIONS = [
-  MONITOR_FLEET_AUTHORING_CONTRACT_EDITION
+  1,
+  2
 ];
 var MONITOR_FLEET_REMOVAL_GRACE_MS = 7 * 24 * 60 * 6e4;
 var MONITOR_FLEET_DOCUMENTATION = {
@@ -32511,11 +32887,11 @@ var MONITOR_FLEET_DOCUMENTATION = {
   authoredFields: {
     id: "Stable lowercase fleet id used by sync, get, and deactivate.",
     source: "Customer DB table, unique row key, and optional equality filters that select candidate rows.",
-    member: "Ordinary monitor tool, stable key template, and payload evaluated for each selected source row.",
+    monitor: "One Batch-compatible MonitorSpec. Direct Handlebars source-row fields such as {{domain}} are rendered for each selected row.",
     selection: "Deterministic ranking and an active-member limit between 1 and 1,000."
   },
   fixedPolicy: {
-    cadence: "daily",
+    cadence: "60s fair bounded source refresh",
     membership: "sticky",
     removalGrace: "7d",
     onRemoved: "deactivate",
@@ -32523,9 +32899,10 @@ var MONITOR_FLEET_DOCUMENTATION = {
     billing: "No Fleet fee, permit, or renewal. Dry-run reports ordinary monitor lifecycle charges due now."
   },
   stickyMembership: "Ranking fills vacancies but never replaces a current member merely because another row ranks higher.",
-  columnExpression: 'Use { "$fleet": "column", "name": "column_name" } in a member key or payload to read a value from each source row.'
+  templating: "Use direct Handlebars fields such as {{domain}} in monitor key, name, or payload. Helpers, blocks, partials, paths, and prototype access are disabled.",
+  legacyCompatibility: 'Edition 1 member/$fleet files remain readable with a lint warning; new files should use version: 2, kind: "fleet", and monitor.'
 };
-function record(value) {
+function record2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function identifier(value) {
@@ -32550,7 +32927,7 @@ function jsonValue(value, path, issues) {
     value.forEach((item, index) => jsonValue(item, `${path}.${index}`, issues));
     return;
   }
-  const input2 = record(value);
+  const input2 = record2(value);
   if (!input2) {
     issues.push({
       path,
@@ -32564,7 +32941,7 @@ function jsonValue(value, path, issues) {
   }
 }
 function validateExpression(value, path, issues) {
-  const input2 = record(value);
+  const input2 = record2(value);
   if (!input2 || input2.$fleet !== "column" || !identifier(input2.name)) {
     issues.push({
       path,
@@ -32582,7 +32959,7 @@ function walkPayload(value, path, issues) {
     );
     return;
   }
-  const input2 = record(value);
+  const input2 = record2(value);
   if (!input2) return;
   if ("$fleet" in input2) {
     validateExpression(input2, path, issues);
@@ -32592,9 +32969,9 @@ function walkPayload(value, path, issues) {
     walkPayload(item, `${path}.${key}`, issues);
   }
 }
-function validateMonitorFleetDefinition(value) {
+function validateMonitorFleetDefinitionV1(value) {
   const issues = [];
-  const input2 = record(value);
+  const input2 = record2(value);
   if (!input2) {
     return {
       valid: false,
@@ -32615,7 +32992,7 @@ function validateMonitorFleetDefinition(value) {
       message: "Fleet id must be lowercase kebab-case."
     });
   }
-  const source = record(input2.source);
+  const source = record2(input2.source);
   exactKeys(
     source,
     ["kind", "schema", "table", "key", "where"],
@@ -32636,7 +33013,7 @@ function validateMonitorFleetDefinition(value) {
       message: "Source schema and table must be SQL identifiers."
     });
   }
-  const sourceKey = record(source?.key);
+  const sourceKey = record2(source?.key);
   exactKeys(sourceKey, ["column", "type"], "source.key", issues);
   if (!sourceKey || !identifier(sourceKey.column) || !["text", "uuid", "int4", "int8"].includes(String(sourceKey.type))) {
     issues.push({
@@ -32646,7 +33023,7 @@ function validateMonitorFleetDefinition(value) {
     });
   }
   if (source?.where !== void 0) {
-    const where = record(source.where);
+    const where = record2(source.where);
     if (!where) {
       issues.push({
         path: "source.where",
@@ -32672,9 +33049,9 @@ function validateMonitorFleetDefinition(value) {
       }
     }
   }
-  const member = record(input2.member);
+  const member = record2(input2.member);
   exactKeys(member, ["tool", "key", "payload"], "member", issues);
-  const key = record(member?.key);
+  const key = record2(member?.key);
   if (!member || typeof member.tool !== "string" || !member.tool.trim()) {
     issues.push({
       path: "member.tool",
@@ -32695,7 +33072,7 @@ function validateMonitorFleetDefinition(value) {
         validateExpression(part, `member.key.parts.${index}`, issues);
     }
     if (sourceKey && !key.parts.some(
-      (part) => record(part)?.$fleet === "column" && record(part)?.name === sourceKey.column
+      (part) => record2(part)?.$fleet === "column" && record2(part)?.name === sourceKey.column
     )) {
       issues.push({
         path: "member.key.parts",
@@ -32714,7 +33091,7 @@ function validateMonitorFleetDefinition(value) {
     jsonValue(member.payload, "member.payload", issues);
   }
   walkPayload(member?.payload, "member.payload", issues);
-  const selection = record(input2.selection);
+  const selection = record2(input2.selection);
   exactKeys(selection, ["limit", "orderBy", "membership"], "selection", issues);
   if (!selection || !Number.isSafeInteger(selection.limit) || Number(selection.limit) < 1 || Number(selection.limit) > MONITOR_FLEET_MAX_MEMBERS) {
     issues.push({
@@ -32740,7 +33117,7 @@ function validateMonitorFleetDefinition(value) {
   } else {
     const orderColumns = /* @__PURE__ */ new Set();
     for (const [index, order] of orderBy.entries()) {
-      const item = record(order);
+      const item = record2(order);
       exactKeys(
         item,
         ["column", "direction"],
@@ -32763,7 +33140,7 @@ function validateMonitorFleetDefinition(value) {
         orderColumns.add(item.column);
       }
     }
-    if (sourceKey && record(orderBy.at(-1))?.column !== sourceKey.column) {
+    if (sourceKey && record2(orderBy.at(-1))?.column !== sourceKey.column) {
       issues.push({
         path: "selection.orderBy",
         code: "fleet_order_missing_key",
@@ -32782,9 +33159,100 @@ function validateMonitorFleetDefinition(value) {
   }
   return issues.length === 0 ? { valid: true, definition: value, issues } : { valid: false, issues };
 }
-function admitMonitorFleetAuthoringContract(value, edition = MONITOR_FLEET_AUTHORING_CONTRACT_EDITION) {
+function v2Issue(issue) {
+  return { path: issue.path, code: issue.code, message: issue.message };
+}
+function validateMonitorFleetDefinitionV2(value) {
+  const issues = [];
+  const input2 = record2(value);
+  if (!input2) {
+    return {
+      valid: false,
+      issues: [
+        {
+          path: "",
+          code: "invalid_fleet",
+          message: "Fleet must be an object."
+        }
+      ]
+    };
+  }
+  exactKeys(
+    input2,
+    ["version", "kind", "id", "source", "monitor", "selection"],
+    "",
+    issues
+  );
+  if (input2.version !== 2) {
+    issues.push({
+      path: "version",
+      code: "unsupported_fleet_version",
+      message: "Canonical Fleet input version must be 2."
+    });
+  }
+  if (input2.kind !== "fleet") {
+    issues.push({
+      path: "kind",
+      code: "invalid_fleet_kind",
+      message: 'Canonical Fleet input kind must be "fleet".'
+    });
+  }
+  const source = record2(input2.source);
+  const sourceKey = record2(source?.key);
+  const legacyShape = {
+    id: input2.id,
+    source: input2.source,
+    member: {
+      tool: record2(input2.monitor)?.tool,
+      key: {
+        $fleet: "template",
+        parts: [
+          "fleet-",
+          {
+            $fleet: "column",
+            name: typeof sourceKey?.column === "string" ? sourceKey.column : "invalid_source_key"
+          }
+        ]
+      },
+      payload: record2(input2.monitor)?.payload
+    },
+    selection: input2.selection
+  };
+  const legacyCheck = validateMonitorFleetDefinitionV1(legacyShape);
+  for (const issue of legacyCheck.issues) {
+    issues.push({
+      ...issue,
+      path: issue.path.replace(/^member\./, "monitor.")
+    });
+  }
+  const monitorInput = record2(input2.monitor);
+  const monitorKey = monitorInput?.key;
+  const monitor = lintMonitorSpecTemplate(input2.monitor);
+  issues.push(...monitor.issues.map(v2Issue));
+  if (typeof monitorKey === "string" && typeof sourceKey?.column === "string" && !monitorKey.includes(`{{${sourceKey.column}}}`)) {
+    issues.push({
+      path: "monitor.key",
+      code: "fleet_key_missing_source_key",
+      message: "Monitor key must include the source key as a direct Handlebars expression."
+    });
+  }
+  return issues.length === 0 && monitor.normalized ? {
+    valid: true,
+    definition: {
+      version: 2,
+      kind: "fleet",
+      id: String(input2.id),
+      source: input2.source,
+      monitor: monitor.normalized,
+      selection: input2.selection
+    },
+    issues
+  } : { valid: false, issues };
+}
+function admitMonitorFleetAuthoringContract(value, edition) {
+  const detectedEdition = edition ?? (record2(value)?.version === 2 || record2(value)?.kind === "fleet" ? 2 : 1);
   if (!SUPPORTED_MONITOR_FLEET_AUTHORING_CONTRACT_EDITIONS.includes(
-    edition
+    detectedEdition
   )) {
     return {
       valid: false,
@@ -32792,16 +33260,16 @@ function admitMonitorFleetAuthoringContract(value, edition = MONITOR_FLEET_AUTHO
         {
           path: "authoring_contract_edition",
           code: "unsupported_fleet_authoring_contract_edition",
-          message: `Monitor Fleet authoring contract edition ${edition} is not supported.`
+          message: `Monitor Fleet authoring contract edition ${detectedEdition} is not supported.`
         }
       ]
     };
   }
-  const result = validateMonitorFleetDefinition(value);
+  const result = detectedEdition === 2 ? validateMonitorFleetDefinitionV2(value) : validateMonitorFleetDefinitionV1(value);
   return result.valid && result.definition ? {
     valid: true,
     contract: {
-      edition,
+      edition: detectedEdition,
       // JSON cloning prevents later caller mutation from changing the
       // admitted snapshot.
       definition: JSON.parse(
@@ -32811,6 +33279,32 @@ function admitMonitorFleetAuthoringContract(value, edition = MONITOR_FLEET_AUTHO
     issues: []
   } : { valid: false, issues: result.issues };
 }
+function lintMonitorFleetInput(value) {
+  const input2 = record2(value);
+  const legacy = input2?.member !== void 0;
+  const admitted = admitMonitorFleetAuthoringContract(value);
+  const issues = admitted.issues.map((issue) => ({
+    ...issue,
+    severity: "error"
+  }));
+  if (legacy) {
+    issues.push({
+      severity: "warning",
+      code: "deprecated_fleet_member",
+      path: "member",
+      message: "Legacy Fleet member syntax remains supported."
+    });
+    if (JSON.stringify(input2).includes('"$fleet"')) {
+      issues.push({
+        severity: "warning",
+        code: "deprecated_fleet_expression",
+        path: "member",
+        message: "Legacy $fleet expressions remain supported; use direct Handlebars fields in monitor instead."
+      });
+    }
+  }
+  return admitted.valid && admitted.contract ? { normalized: admitted.contract.definition, issues } : { issues };
+}
 
 // src/cli/commands/monitors.ts
 var JSON_OPTION_DESCRIPTION = "Emit JSON output. Also automatic when stdout is piped";
@@ -33496,6 +33990,155 @@ function fleetIdempotencyKey(operation, supplied) {
   }
   return normalized ?? `monitor-fleet-${operation}-${(0, import_node_crypto8.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}-${(0, import_node_crypto8.randomUUID)()}`;
+}
+function readMonitorDefinitionsJsonFile(file) {
+  let raw;
+  try {
+    raw = file === "-" ? (0, import_node_fs15.readFileSync)(0, "utf8") : (0, import_node_fs15.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 = asRecord2(payload.job);
+  if (!job) return void 0;
+  const id = asString(job.id) ?? "<unknown>";
+  const state = asString(job.state) ?? "unknown";
+  const phase = asString(job.phase);
+  const counts = asRecord2(job.counts);
+  const reconciliation = asRecord2(job.reconciliation);
+  const lines = [
+    `Monitor job: ${id}`,
+    `State: ${state}${phase ? ` (${phase})` : ""}`
+  ];
+  if (counts) {
+    lines.push(
+      `Counts: requested ${asFiniteNumber(counts.requested) ?? 0}, created ${asFiniteNumber(counts.created) ?? 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) }
+  );
+}
+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",
@@ -33517,12 +34160,12 @@ var MONITOR_FLEET_LIFECYCLE = [
   {
     step: 2,
     what: "See the plan and the credits before anything changes.",
-    command: "deepline monitors fleets sync --file fleet.json --dry-run"
+    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 sync --file fleet.json --wait"
+    command: "deepline monitors fleets deploy --file fleet.json --wait"
   },
   {
     step: 4,
@@ -33531,6 +34174,11 @@ var MONITOR_FLEET_LIFECYCLE = [
   }
 ];
 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",
@@ -33676,6 +34324,26 @@ function renderFleetGet(payload) {
     `  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 = asRecord2(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}`);
@@ -33852,6 +34520,8 @@ async function handleMonitorFleetsInit(fleetId, options) {
   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",
@@ -33860,12 +34530,9 @@ async function handleMonitorFleetsInit(fleetId, options) {
       key: { column: key, type: keyType },
       ...where ? { where } : {}
     },
-    member: {
+    monitor: {
       tool,
-      key: {
-        $fleet: "template",
-        parts: [`${fleetId}-`, { $fleet: "column", name: key }]
-      },
+      key: `${fleetId}-{{${key}}}`,
       payload
     },
     selection: {
@@ -33878,9 +34545,9 @@ async function handleMonitorFleetsInit(fleetId, options) {
   const file = (0, import_node_path17.resolve)(out);
   (0, import_node_fs15.writeFileSync)(file, `${JSON.stringify(definition, null, 2)}
 `, "utf8");
-  const next = `deepline monitors fleets sync --file ${fleetShellArg(file)} --dry-run --json`;
+  const next = `deepline monitors fleets deploy --file ${fleetShellArg(file)} --dry-run --json`;
   printCommandEnvelope(
-    { schemaVersion: 1, file, definition, next },
+    { schemaVersion: 2, file, definition, next },
     {
       json: options.json,
       text: `Wrote ${file}
@@ -33890,8 +34557,8 @@ Next: ${next}
   );
 }
 function requireCompiledFleetDefinition(definition) {
-  const result = admitMonitorFleetAuthoringContract(definition);
-  if (result.valid && result.contract) return result.contract.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}
@@ -33918,6 +34585,7 @@ function fleetSyncCommandLine(target, 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(
@@ -33925,12 +34593,14 @@ async function handleMonitorFleetsSync(target, options, idempotencyKey) {
     );
   }
   const definition = usesDefinition ? requireCompiledFleetDefinition(
-    resolveMonitorJsonBody({
-      positional: target,
-      file: options.file,
-      argLabel: "<definition>",
-      command: "deepline monitors fleets sync"
-    })
+    asRecord2(
+      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) {
@@ -34331,14 +35001,14 @@ function renderMonitorGet(payload) {
       `  deepline monitors test ${key} '${JSON.stringify(samplePayload2)}' --json`
     );
   }
-  const monitorSpec = asRecord2(payload.monitor_spec);
-  if (monitorSpec?.available === false) {
+  const monitorSpec2 = asRecord2(payload.monitor_spec);
+  if (monitorSpec2?.available === false) {
     lines.push(
       "",
-      `Monitor spec: unavailable \u2014 ${asString(monitorSpec.message) ?? "use the stored definition and check before an update."}`
+      `Monitor spec: unavailable \u2014 ${asString(monitorSpec2.message) ?? "use the stored definition and check before an update."}`
     );
   }
-  const specFields = Array.isArray(monitorSpec?.fields) ? monitorSpec.fields.flatMap((value) => {
+  const specFields = Array.isArray(monitorSpec2?.fields) ? monitorSpec2.fields.flatMap((value) => {
     const field = asRecord2(value);
     const path = asString(field?.path);
     const description = asString(field?.description);
@@ -34812,6 +35482,8 @@ 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
@@ -34924,19 +35596,31 @@ Examples:
   );
   withJsonOption(
     batch.command("deploy").description(
-      "Durably create complete NDJSON monitor definitions through provider bulk create."
+      "Create a Monitor Job from canonical Batch JSON; legacy NDJSON remains available with --yes or --dry-run."
     ).requiredOption(
       "--file <path>",
-      "NDJSON file of complete monitor definitions"
-    ).option("--dry-run", "Validate and record the durable deploy plan").option("--yes", "Confirm asynchronous provider creation").option(
+      'Batch JSON ({"version":1,"kind":"batch","monitors":[...]}), or legacy NDJSON with --yes/--dry-run'
+    ).option("--dry-run", "Use the retained legacy batch-operation plan").option("--yes", "Use the retained legacy NDJSON batch operation").option(
       "--idempotency-key <key>",
       "Stable retry key (generated when omitted)"
     )
   ).action(
-    monitorsAction(
-      (options) => handleMonitorBatchDeploy(options)
-    )
+    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.")
@@ -35105,9 +35789,8 @@ Examples:
       "after",
       `
 Notes:
-  Read-only validation. <definition> is a JSON object with key, tool, payload,
-  and optional controls (Deepline lifecycle metadata). Pass it positionally,
-  via --file <path>, or
+  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
@@ -35115,12 +35798,8 @@ Notes:
   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\`.
-  For a bounded urgent Deepline Native preview, use
-  controls.execution_type="priority". Deepline injects the upstream marker;
-  do not author custom_fields yourself. Priority is capped at ten upstream or
-  reserved recovery, replacement, or reactivation slots per org. Use
-  \`monitors list --status all\` to find priority holders; it is not for regular
-  or bulk-scale monitoring.
+  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"}}'
@@ -35138,8 +35817,8 @@ Examples:
       `
 Notes:
   Mutates workspace state and may spend Deepline credits. <definition> is a JSON
-  object with key, tool, payload, and optional controls. Pass it positionally,
-  via --file <path>, or from stdin with --file -.
+  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.
@@ -35156,10 +35835,8 @@ Notes:
   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.
-  For a bounded urgent Deepline Native preview, set
-  controls.execution_type="priority". Deepline injects the provider custom
-  field and enforces a ten-slot per-org cap; do not use it for regular or bulk
-  monitoring, and do not delete another radar automatically to make room.
+  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"}}'
@@ -35190,10 +35867,6 @@ 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.
-Use {"controls":{"execution_type":"priority"}} only for a bounded urgent
-Deepline Native preview. The ten-radar priority cap applies on update too.
-Use {"controls":{"execution_type":null}} to release priority without
-deleting the monitor.
 
 Examples:
   deepline monitors update my-monitor '{"name":"Interested replies"}' --json
@@ -35241,13 +35914,30 @@ Examples:
 `
     ).option("--dry-run", "Show the reactivation cost without reactivating")
   ).action(monitorsAction(handleMonitorsReactivate));
-  const fleets = monitors.command("fleets").description("Define and reconcile table-backed Monitor Fleets.").addHelpText(
+  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 \`sync\` is the only verb
-  that changes one: applying the same definition twice is the same operation,
+  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.
@@ -35269,6 +35959,29 @@ ${MONITOR_FLEET_HELP_EPILOG}`
     })
   );
   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",
@@ -35282,13 +35995,13 @@ Example:
   deepline monitors fleets init account-job-openings \\
     --source public.accounts --key account_id --key-type uuid \\
     --tool deepline_native.company_radar \\
-    --payload '{"domain":{"$fleet":"column","name":"domain"},"radar_type":"company_job_openings"}' \\
+    --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 $fleet column tags for row values"
+      "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"
@@ -35364,7 +36077,9 @@ Examples:
 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.
+  --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
@@ -37463,8 +38178,8 @@ function classifyNetworkFailure(error) {
   let current = error;
   while (current && !seen.has(current)) {
     seen.add(current);
-    const record2 = typeof current === "object" && current !== null ? current : {};
-    const code = String(record2.code ?? "").toLowerCase();
+    const record3 = typeof current === "object" && current !== null ? current : {};
+    const code = String(record3.code ?? "").toLowerCase();
     const name = current instanceof Error ? current.name.toLowerCase() : "";
     const text = String(
       current instanceof Error ? current.message : current
@@ -37491,7 +38206,7 @@ function classifyNetworkFailure(error) {
     if (combined.includes("ssl") || combined.includes("tls") || combined.includes("unexpected_eof_while_reading")) {
       return "network_ssl_error";
     }
-    current = record2.cause ?? record2.context;
+    current = record3.cause ?? record3.context;
   }
   return "network_error";
 }
@@ -38568,26 +39283,26 @@ function parseSetupPhases(value) {
     if (!phase || typeof phase !== "object" || Array.isArray(phase)) {
       return null;
     }
-    const record2 = phase;
-    if (!isSetupPhaseStatus(record2.status)) return null;
-    switch (record2.status) {
+    const record3 = phase;
+    if (!isSetupPhaseStatus(record3.status)) return null;
+    switch (record3.status) {
       case "pending":
       case "in_progress":
-        phases[name] = { status: record2.status };
+        phases[name] = { status: record3.status };
         break;
       case "complete":
         phases[name] = {
           status: "complete",
-          ...typeof record2.outcome === "string" ? { outcome: record2.outcome } : {}
+          ...typeof record3.outcome === "string" ? { outcome: record3.outcome } : {}
         };
         break;
       case "waiting":
-        if (typeof record2.outcome !== "string") return null;
-        phases[name] = { status: "waiting", outcome: record2.outcome };
+        if (typeof record3.outcome !== "string") return null;
+        phases[name] = { status: "waiting", outcome: record3.outcome };
         break;
       case "failed":
-        if (typeof record2.code !== "string") return null;
-        phases[name] = { status: "failed", code: record2.code };
+        if (typeof record3.code !== "string") return null;
+        phases[name] = { status: "failed", code: record3.code };
         break;
     }
   }
@@ -42003,9 +42718,9 @@ function requiredInputIds(tool) {
   return toolInputFieldsForDisplay(inputSchema).filter((field) => field.required === true).map((field) => String(field.name ?? "")).filter(Boolean);
 }
 function notConnectedSuffix(tool) {
-  const record2 = tool;
-  const status = stringField2(record2, "credentialStatus", "credential_status");
-  const connected = record2.connected;
+  const record3 = tool;
+  const status = stringField2(record3, "credentialStatus", "credential_status");
+  const connected = record3.connected;
   const message = toolConnectionStatusMessage({
     connected: connected === false ? false : void 0,
     credentialStatus: status || void 0
@@ -42384,19 +43099,19 @@ function printPlayAliasToolError(toolId, play) {
   console.error(playAliasToolErrorMessage(toolId, play));
 }
 function isPlayLikeTool(tool) {
-  const record2 = tool;
-  if (record2.isPlay === true || record2.is_play === true) return true;
-  const playExpansion = recordField2(record2, "playExpansion", "play_expansion");
+  const record3 = tool;
+  if (record3.isPlay === true || record3.is_play === true) return true;
+  const playExpansion = recordField2(record3, "playExpansion", "play_expansion");
   if (Object.keys(playExpansion).length > 0) return true;
-  const toolId = typeof record2.toolId === "string" ? record2.toolId : "";
+  const toolId = typeof record3.toolId === "string" ? record3.toolId : "";
   return toolId.endsWith("_waterfall");
 }
 function isMonitorTypeTool(tool) {
   return stringField2(tool, "kind") === "monitor_type";
 }
 function playReferenceForTool(tool) {
-  const record2 = tool;
-  const declared = stringField2(record2, "playReference", "play_reference");
+  const record3 = tool;
+  const declared = stringField2(record3, "playReference", "play_reference");
   if (declared.startsWith("prebuilt/")) {
     return declared;
   }
@@ -43336,12 +44051,12 @@ function singleLineText(value, maxLength = 260) {
   return `${text.slice(0, maxLength - 3).trimEnd()}...`;
 }
 function listedToolDescription(tool) {
-  const record2 = tool;
-  return singleLineText(record2.bestFor ?? record2.best_for ?? tool.description);
+  const record3 = tool;
+  return singleLineText(record3.bestFor ?? record3.best_for ?? tool.description);
 }
 function formatListedToolCost(tool) {
-  const record2 = tool;
-  const pricing = recordField2(record2, "pricing");
+  const record3 = tool;
+  const pricing = recordField2(record3, "pricing");
   const displayText = stringField2(pricing, "displayText", "display_text");
   return displayText ? `Cost: ${displayText}` : "";
 }
@@ -44397,9 +45112,9 @@ function noticeToStderr(command) {
   );
 }
 function emitPassThrough(command, payload, options) {
-  const json = shouldEmitJson(options.json);
+  const json2 = shouldEmitJson(options.json);
   const deprecation = migrationDeprecation(command);
-  if (json) {
+  if (json2) {
     const enriched = payload && typeof payload === "object" && !Array.isArray(payload) ? { ...payload, deprecation } : { result: payload, deprecation };
     printJson(enriched);
     return;
@@ -44420,9 +45135,9 @@ function clientWithTimeout(timeoutSeconds) {
 }
 function readStatus(payload) {
   if (!payload || typeof payload !== "object") return null;
-  const record2 = payload;
-  if (typeof record2.status === "string") return record2.status;
-  const run = record2.run;
+  const record3 = payload;
+  if (typeof record3.status === "string") return record3.status;
+  const run = record3.run;
   if (run && typeof run === "object") {
     const status = run.status;
     if (typeof status === "string") return status;