deepline 0.1.274 → 0.1.276

package/dist/cli/index.js

@@ -718,7 +718,7 @@ var SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: "0.1.274",
+  version: "0.1.276",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -932,19 +932,19 @@ function isAbortLikeError(error) {
   const message = error.message.toLowerCase();
   return name === "aborterror" || message.includes("operation was aborted") || message === "aborted";
 }
-function mapNetworkError(baseUrl, error, targetLabel) {
+function mapNetworkError(baseUrl, error, targetLabel2) {
   const tagged = error;
   const timeoutMs = tagged?.[REQUEST_TIMEOUT_MARKER];
   if (typeof timeoutMs === "number") {
     return {
-      message: `Request to ${targetLabel} timed out after ${timeoutMs}ms while waiting for a response.`,
+      message: `Request to ${targetLabel2} timed out after ${timeoutMs}ms while waiting for a response.`,
       code: "NETWORK_TIMEOUT",
-      details: { timeoutMs, target: targetLabel }
+      details: { timeoutMs, target: targetLabel2 }
     };
   }
   if (tagged?.[REQUEST_ABORT_MARKER]) {
     return {
-      message: `Request to ${targetLabel} was aborted before it completed.`,
+      message: `Request to ${targetLabel2} was aborted before it completed.`,
       code: "NETWORK_ABORTED"
     };
   }
@@ -1605,9 +1605,277 @@ var RUNNER_POST_TERMINAL_DIAGNOSTIC_MAX_BYTES = 64 * 1024;
 // ../shared_libs/play-runtime/ledger-safe-payload.ts
 var ledgerIngressRedactor = createSecretRedactionContext();
 
+// ../shared_libs/play-runtime/activity-observation.ts
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isPlayActivityObservation(value) {
+  if (!isRecord(value) || value.schemaVersion !== 1 || typeof value.activityId !== "string" || !value.activityId.trim() || typeof value.observedAt !== "number" || !Number.isFinite(value.observedAt) || !isRecord(value.target) || !isRecord(value.state)) {
+    return false;
+  }
+  const targetKinds = /* @__PURE__ */ new Set([
+    "provider",
+    "dataset",
+    "lease",
+    "runner",
+    "step",
+    "capacity"
+  ]);
+  const stateKinds = /* @__PURE__ */ new Set([
+    "active",
+    "queued",
+    "waiting",
+    "retrying",
+    "scheduled",
+    "completed",
+    "failed"
+  ]);
+  return typeof value.target.kind === "string" && targetKinds.has(value.target.kind) && typeof value.state.kind === "string" && stateKinds.has(value.state.kind);
+}
+function derivePlayActivityVisibility(input2) {
+  const { state } = input2.observation;
+  if (state.kind === "failed") return "action";
+  if (state.kind === "waiting") {
+    return state.reason.kind === "external_event" ? "action" : "headline";
+  }
+  if (state.kind === "queued" || state.kind === "scheduled") return "headline";
+  if (state.kind === "retrying") {
+    return state.retryAt - input2.now <= 3e4 ? "hidden" : "timeline";
+  }
+  if (state.kind === "active") return "headline";
+  return "timeline";
+}
+function targetLabel(target) {
+  switch (target.kind) {
+    case "provider":
+      return target.label ?? `${target.provider} ${target.operation}`;
+    case "dataset":
+      return target.label ?? `dataset ${target.tableNamespace}`;
+    case "lease":
+      return `${target.resourceKind} ${target.resourceLabel}`;
+    case "runner":
+      return target.label ?? `${target.backend} runner`;
+    case "step":
+      return target.label ?? target.stepId;
+    case "capacity":
+      return target.label ?? `${target.pool} capacity`;
+  }
+}
+function summarizePlayActivity(observation) {
+  const label = targetLabel(observation.target);
+  const { state } = observation;
+  switch (state.kind) {
+    case "active": {
+      const progress = state.progress;
+      const counts = typeof progress?.completed === "number" && typeof progress.total === "number" ? ` (${progress.completed}/${progress.total})` : "";
+      return `Active: ${label}${counts}.`;
+    }
+    case "queued":
+      return `Queued: waiting for ${label}.`;
+    case "waiting":
+      if (state.reason.kind === "external_event") {
+        const provider = state.reason.provider ? ` from ${state.reason.provider}` : "";
+        return `Blocked: waiting for an external event${provider}.`;
+      }
+      if (state.reason.kind === "dataset") {
+        return `Blocked: waiting for dataset ${state.reason.tableNamespace} to become ${state.reason.requiredPhase}.`;
+      }
+      if (state.reason.kind === "lease") {
+        return `Contended: waiting for ${state.reason.resourceKind} lease ${state.reason.resourceLabel}.`;
+      }
+      return `Paused: ${label}; the legacy producer did not report a typed reason.`;
+    case "retrying":
+      return `Delayed: ${label} will retry automatically.`;
+    case "scheduled":
+      return `Scheduled: ${label} will resume automatically.`;
+    case "completed":
+      return `Completed: ${label}.`;
+    case "failed":
+      return `Failed: ${label}.`;
+  }
+}
+function isTerminalActivityState(state) {
+  return state.kind === "completed" || state.kind === "failed";
+}
+function projection(observation, now, classified = true) {
+  return {
+    observation,
+    summary: summarizePlayActivity(observation),
+    visibility: derivePlayActivityVisibility({ observation, now }),
+    classified
+  };
+}
+function projectPlayRunActivity(input2) {
+  const now = input2.now ?? Date.now();
+  const observedAt = input2.updatedAt ?? now;
+  const normalizedStatus = input2.status.trim().toLowerCase();
+  if (normalizedStatus === "completed" || normalizedStatus === "failed" || normalizedStatus === "cancelled" || normalizedStatus === "terminated" || normalizedStatus === "timed_out") {
+    return null;
+  }
+  const explicit = [...input2.explicit ?? []].filter((candidate) => !isTerminalActivityState(candidate.state)).sort((left, right) => right.observedAt - left.observedAt)[0];
+  if (explicit) return projection(explicit, now);
+  if (input2.waitKind === "detached_runner") {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: "runner:managed",
+        target: {
+          kind: "runner",
+          backend: input2.runtimeBackend ?? "managed",
+          label: "managed play runner"
+        },
+        state: { kind: "active" },
+        observedAt
+      },
+      now
+    );
+  }
+  if (input2.waitKind === "sleep") {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: "run:sleep",
+        target: {
+          kind: "step",
+          stepId: input2.activeNodeId ?? "run",
+          label: input2.playName ?? "play"
+        },
+        state: {
+          kind: "scheduled",
+          reason: "sleep",
+          resumeAt: input2.waitUntil ?? observedAt
+        },
+        observedAt
+      },
+      now
+    );
+  }
+  if (input2.waitKind === "integration_event" || input2.waitKind === "integration_event_batch") {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: `event:${input2.activeNodeId ?? "run"}`,
+        stepId: input2.activeNodeId ?? void 0,
+        target: {
+          kind: "step",
+          stepId: input2.activeNodeId ?? "run",
+          label: input2.playName ?? "play"
+        },
+        state: {
+          kind: "waiting",
+          reason: {
+            kind: "external_event",
+            eventKey: input2.eventKey ?? void 0,
+            deadlineAt: input2.waitUntil ?? void 0
+          }
+        },
+        observedAt
+      },
+      now
+    );
+  }
+  if (normalizedStatus === "waiting") {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: "run:legacy-wait",
+        target: {
+          kind: "step",
+          stepId: input2.activeNodeId ?? "run",
+          label: input2.playName ?? "play"
+        },
+        state: { kind: "waiting", reason: { kind: "unknown" } },
+        observedAt
+      },
+      now,
+      false
+    );
+  }
+  const pendingDataset = [...input2.datasets ?? []].filter(
+    (dataset) => dataset.phase === "registered" || dataset.complete !== true && dataset.phase !== "failed"
+  ).sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
+  if (pendingDataset) {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: `dataset:${pendingDataset.datasetId ?? pendingDataset.tableNamespace}`,
+        target: {
+          kind: "dataset",
+          tableNamespace: pendingDataset.tableNamespace,
+          operation: "materializing"
+        },
+        state: {
+          kind: "active",
+          progress: {
+            completed: pendingDataset.persistedRows,
+            total: typeof pendingDataset.succeededRows === "number" || typeof pendingDataset.failedRows === "number" ? (pendingDataset.succeededRows ?? 0) + (pendingDataset.failedRows ?? 0) : void 0,
+            failed: pendingDataset.failedRows
+          }
+        },
+        observedAt: pendingDataset.updatedAt ?? observedAt
+      },
+      now
+    );
+  }
+  const activeStep = input2.nodeStates?.find(
+    (candidate) => candidate.nodeId === input2.activeNodeId
+  ) ?? input2.nodeStates?.find((candidate) => candidate.status === "running") ?? null;
+  if (activeStep) {
+    const toolId = activeStep.nodeId.startsWith("tool:") ? activeStep.nodeId.split(":").at(-1)?.trim() || null : null;
+    const provider = toolId?.split(/[._]/)[0]?.trim() || null;
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: `step:${activeStep.nodeId}`,
+        stepId: activeStep.nodeId,
+        target: toolId && provider ? {
+          kind: "provider",
+          provider,
+          operation: toolId,
+          label: activeStep.label ?? toolId
+        } : {
+          kind: "step",
+          stepId: activeStep.nodeId,
+          label: activeStep.label
+        },
+        state: {
+          kind: "active",
+          progress: activeStep.progress ?? void 0
+        },
+        observedAt: activeStep.updatedAt ?? observedAt
+      },
+      now
+    );
+  }
+  if (normalizedStatus === "queued") {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: "capacity:worker",
+        target: { kind: "capacity", pool: "worker" },
+        state: { kind: "queued", reason: "capacity" },
+        observedAt
+      },
+      now
+    );
+  }
+  const fallback = {
+    schemaVersion: 1,
+    activityId: "run:legacy",
+    target: {
+      kind: "step",
+      stepId: input2.activeNodeId ?? "run",
+      label: input2.playName ?? "play"
+    },
+    state: normalizedStatus === "waiting" ? { kind: "waiting", reason: { kind: "unknown" } } : { kind: "active" },
+    observedAt
+  };
+  return projection(fallback, now, normalizedStatus !== "waiting");
+}
+
 // ../shared_libs/play-runtime/run-ledger.ts
 var LOG_TAIL_LIMIT = 100;
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function finiteNumber(value) {
@@ -1691,30 +1959,33 @@ function createEmptyPlayRunLedgerSnapshot(input2) {
     stepsById: {},
     orderedDatasetIds: [],
     datasetsById: {},
+    orderedActivityIds: [],
+    activitiesById: {},
     logTail: [],
     totalLogCount: 0,
     logsTruncated: false,
     activeStepId: null,
+    activeActivityId: null,
     activeArtifactTableNamespace: null,
     resultTableNamespace: null
   };
 }
 function normalizePlayRunLedgerSnapshot(value, fallback) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return createEmptyPlayRunLedgerSnapshot(fallback);
   }
   const orderedStepIds = Array.isArray(value.orderedStepIds) ? value.orderedStepIds.filter(
     (entry) => typeof entry === "string" && Boolean(entry.trim())
   ) : [];
-  const rawSteps = isRecord(value.stepsById) ? value.stepsById : {};
+  const rawSteps = isRecord2(value.stepsById) ? value.stepsById : {};
   const stepsById = {};
   for (const [stepId, rawStep] of Object.entries(rawSteps)) {
-    if (!stepId.trim() || !isRecord(rawStep)) continue;
+    if (!stepId.trim() || !isRecord2(rawStep)) continue;
     const rawStatus = normalizeStepStatus(rawStep.status);
     if (!rawStatus) continue;
     const completedAt = finiteNumber(rawStep.completedAt);
     const status = rawStatus === "running" && completedAt !== null ? "completed" : rawStatus;
-    const rawProgress = isRecord(rawStep.progress) ? rawStep.progress : null;
+    const rawProgress = isRecord2(rawStep.progress) ? rawStep.progress : null;
     stepsById[stepId] = {
       stepId,
       label: optionalString(rawStep.label),
@@ -1730,10 +2001,10 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       progress: rawProgress ? normalizeStepProgress(rawProgress) : null
     };
   }
-  const rawDatasets = isRecord(value.datasetsById) ? value.datasetsById : {};
+  const rawDatasets = isRecord2(value.datasetsById) ? value.datasetsById : {};
   const datasetsById = {};
   for (const [datasetId, rawDataset] of Object.entries(rawDatasets)) {
-    if (!datasetId.trim() || !isRecord(rawDataset)) continue;
+    if (!datasetId.trim() || !isRecord2(rawDataset)) continue;
     const phase = rawDataset.phase === "available" || rawDataset.phase === "failed" ? rawDataset.phase : "registered";
     datasetsById[datasetId] = {
       datasetId,
@@ -1747,6 +2018,13 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       updatedAt: finiteNumber(rawDataset.updatedAt) ?? 0
     };
   }
+  const rawActivities = isRecord2(value.activitiesById) ? value.activitiesById : {};
+  const activitiesById = {};
+  for (const [activityId, rawActivity] of Object.entries(rawActivities)) {
+    if (activityId.trim() && isPlayActivityObservation(rawActivity) && rawActivity.activityId === activityId) {
+      activitiesById[activityId] = rawActivity;
+    }
+  }
   const createdAt = finiteNumber(value.createdAt) ?? fallback.createdAt ?? null;
   const startedAt = finiteNumber(value.startedAt) ?? fallback.startedAt ?? null;
   const finishedAt = finiteNumber(value.finishedAt) ?? fallback.finishedAt ?? null;
@@ -1770,6 +2048,10 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       (datasetId) => typeof datasetId === "string" && Boolean(datasetsById[datasetId])
     ),
     datasetsById,
+    orderedActivityIds: (Array.isArray(value.orderedActivityIds) ? value.orderedActivityIds : Object.keys(activitiesById)).filter(
+      (activityId) => typeof activityId === "string" && Boolean(activitiesById[activityId])
+    ),
+    activitiesById,
     logTail: logTail.slice(-LOG_TAIL_LIMIT),
     // Snapshots persisted before totalLogCount existed only know the retained
     // tail, so the best lower bound for the cumulative count is the tail size.
@@ -1779,6 +2061,7 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
     ),
     logsTruncated: value.logsTruncated === true,
     activeStepId: optionalNullableString(value.activeStepId),
+    activeActivityId: optionalNullableString(value.activeActivityId),
     activeArtifactTableNamespace: optionalNullableString(
       value.activeArtifactTableNamespace
     ),
@@ -1865,18 +2148,18 @@ function normalizePlayRunLiveStatus(value) {
 function isTerminalPlayRunLiveStatus(status) {
   return isTerminalPlayRunLifecycleStatus(status);
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function finiteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function extractTerminalRunLogTail(result) {
-  if (!isRecord2(result) || !isRecord2(result._metadata)) {
+  if (!isRecord3(result) || !isRecord3(result._metadata)) {
     return null;
   }
   const runLogTail = result._metadata.runLogTail;
-  if (!isRecord2(runLogTail) || !Array.isArray(runLogTail.tail)) {
+  if (!isRecord3(runLogTail) || !Array.isArray(runLogTail.tail)) {
     return null;
   }
   const logTail = runLogTail.tail.filter(
@@ -1936,6 +2219,10 @@ function buildSnapshotFromLedger(snapshot) {
     datasets: snapshot.orderedDatasetIds.map((datasetId) => snapshot.datasetsById[datasetId]).filter(
       (dataset) => Boolean(dataset)
     ),
+    activities: snapshot.orderedActivityIds.map((activityId) => snapshot.activitiesById[activityId]).filter(
+      (activity) => Boolean(activity)
+    ),
+    activeActivity: snapshot.activeActivityId ? snapshot.activitiesById[snapshot.activeActivityId] ?? null : null,
     nodeStates,
     activeNodeId: snapshot.activeStepId ?? null,
     ...rowOutcomes ? { rowOutcomes } : {}
@@ -1952,14 +2239,29 @@ function buildPlayRunStatusSnapshot(input2) {
     finishedAt: input2.run.finishedAt ?? null
   });
   const terminalRunLogTail = extractTerminalRunLogTail(input2.run.result);
-  if (terminalRunLogTail && terminalRunLogTail.totalLogCount > ledgerSnapshot.totalLogCount) {
-    return buildSnapshotFromLedger({
-      ...ledgerSnapshot,
-      logTail: terminalRunLogTail.logTail,
-      totalLogCount: terminalRunLogTail.totalLogCount
-    });
-  }
-  return buildSnapshotFromLedger(ledgerSnapshot);
+  const projectedSnapshot = terminalRunLogTail && terminalRunLogTail.totalLogCount > ledgerSnapshot.totalLogCount ? buildSnapshotFromLedger({
+    ...ledgerSnapshot,
+    logTail: terminalRunLogTail.logTail,
+    totalLogCount: terminalRunLogTail.totalLogCount
+  }) : buildSnapshotFromLedger(ledgerSnapshot);
+  const activity = projectPlayRunActivity({
+    runId: input2.run.workflowId,
+    playName: input2.run.name,
+    status: projectedSnapshot.status,
+    updatedAt: projectedSnapshot.updatedAt,
+    waitKind: input2.run.waitKind ?? input2.run.wait?.kind ?? null,
+    waitUntil: input2.run.waitUntil,
+    eventKey: input2.run.wait?.eventKey ?? null,
+    runtimeBackend: input2.run.runtimeBackend,
+    activeNodeId: input2.run.activeBoundaryId ?? projectedSnapshot.activeNodeId,
+    nodeStates: projectedSnapshot.nodeStates,
+    datasets: projectedSnapshot.datasets,
+    explicit: projectedSnapshot.activities
+  });
+  return {
+    ...projectedSnapshot,
+    activity
+  };
 }
 function makeRunStreamEvent(input2) {
   return {
@@ -2180,7 +2482,8 @@ function diffPlayRunStreamEvents(input2) {
         payload: {
           runId: snapshot.runId,
           status: snapshot.status,
-          updatedAt: snapshot.updatedAt
+          updatedAt: snapshot.updatedAt,
+          ...snapshot.activity ? { activity: snapshot.activity } : {}
         }
       })
     );
@@ -2700,7 +3003,7 @@ function resolveToolExecuteTimeoutMs(toolId, input2) {
 }
 var RUNS_FAILED_LOG_LIMIT = 20;
 var RUN_LOGS_PAGE_LIMIT = 1e3;
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPrebuiltPlayDescription(play) {
@@ -2857,7 +3160,7 @@ function updatePlayLiveStatusState(state, event) {
   }
   const runId = typeof payload.runId === "string" && payload.runId ? payload.runId : isPlayRunPackage(payload) ? payload.run.id : state.runId;
   const status = normalizeLiveStatus(payload.status) ?? (isPlayRunPackage(payload) ? normalizeLiveStatus(payload.run.status) : null) ?? state.status;
-  const progressPayload = isRecord3(payload.progress) ? payload.progress : {};
+  const progressPayload = isRecord4(payload.progress) ? payload.progress : {};
   if (event.type === "play.run.final_status" && state.logs.length === 0 && state.lastLogSeq === 0) {
     const payloadLogs = readStringArray(payload.logs);
     const progressLogs = readStringArray(progressPayload.logs);
@@ -2991,9 +3294,9 @@ var DeeplineClient = class {
     return fields.length > 0 ? { fields } : schema;
   }
   schemaMetadata(schema, key) {
-    if (!isRecord3(schema)) return null;
+    if (!isRecord4(schema)) return null;
     const value = schema[key];
-    return isRecord3(value) ? value : null;
+    return isRecord4(value) ? value : null;
   }
   playRunCommand(play, options) {
     const target = play.reference || play.name;
@@ -3042,7 +3345,7 @@ var DeeplineClient = class {
       aliases,
       inputSchema: options?.compact ? this.compactSchema(play.inputSchema) : play.inputSchema ?? null,
       outputSchema: options?.compact ? this.compactSchema(play.outputSchema) : play.outputSchema ?? null,
-      staticPipeline: isRecord3(play.staticPipeline) ? play.staticPipeline : isRecord3(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord3(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
+      staticPipeline: isRecord4(play.staticPipeline) ? play.staticPipeline : isRecord4(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord4(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
       ...csvInput ? { csvInput } : {},
       ...rowOutputSchema ? { rowOutputSchema } : {},
       runCommand: runCommand2,
@@ -3120,6 +3423,14 @@ var DeeplineClient = class {
     );
     return res.tools;
   }
+  /** List discoverable providers without requiring a local plugin catalog. */
+  async listProviders(options) {
+    const suffix = options?.changed ? "?changed=true" : "";
+    const res = await this.http.get(
+      `/api/v2/tools/providers${suffix}`
+    );
+    return res.providers;
+  }
   /**
    * Search available tools using Deepline's ranked backend search.
    *
@@ -7859,14 +8170,14 @@ function sanitizeCsvProjectionInfo(input2) {
   const rows = input2.rows.map(stripCsvProjectionFields);
   return { rows, columns };
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSerializedDataset(value) {
-  return isRecord4(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
+  return isRecord5(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
 }
 function isPackagedDatasetOutput(value) {
-  return isRecord4(value) && value.kind === "dataset" && isRecord4(value.preview) && Array.isArray(value.preview.rows);
+  return isRecord5(value) && value.kind === "dataset" && isRecord5(value.preview) && Array.isArray(value.preview.rows);
 }
 function pathParts(path) {
   return path.split(".").map((part) => part.trim()).filter(Boolean);
@@ -7874,7 +8185,7 @@ function pathParts(path) {
 function valueAtPath(root, path) {
   let cursor = root;
   for (const part of pathParts(path)) {
-    if (!isRecord4(cursor)) {
+    if (!isRecord5(cursor)) {
       return void 0;
     }
     cursor = cursor[part];
@@ -7882,17 +8193,17 @@ function valueAtPath(root, path) {
   return cursor;
 }
 function totalRowsForDataset(result, datasetPath) {
-  const metadata = isRecord4(result._metadata) ? result._metadata : null;
+  const metadata = isRecord5(result._metadata) ? result._metadata : null;
   const parentPath = datasetPath.split(".").slice(0, -1).join(".");
   const parent = parentPath ? valueAtPath({ result }, parentPath) : result;
-  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord4(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
+  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord5(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
 }
 function rowArray(value) {
   if (!Array.isArray(value)) {
     return null;
   }
   const rows = value.filter(
-    (row) => isRecord4(row)
+    (row) => isRecord5(row)
   );
   return rows.length === value.length ? rows : null;
 }
@@ -7916,7 +8227,7 @@ function inferColumns(rows) {
   return columns;
 }
 function columnsFromDatasetSummary(summary) {
-  if (!isRecord4(summary) || !isRecord4(summary.columnStats)) {
+  if (!isRecord5(summary) || !isRecord5(summary.columnStats)) {
     return [];
   }
   return Object.keys(summary.columnStats).filter((column) => column);
@@ -7964,7 +8275,7 @@ function canonicalRowsInfoFromCandidate(input2) {
       datasetId: typeof candidate.value.datasetId === "string" ? candidate.value.datasetId : null,
       tableNamespace: typeof candidate.value.tableNamespace === "string" ? candidate.value.tableNamespace : null,
       ...candidate.value.recovered === true ? { recovered: true } : {},
-      ...isRecord4(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace") ? {
+      ...isRecord5(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace") ? {
         exportUnavailableReason: candidate.value.exportUnavailable.reason,
         ...typeof candidate.value.exportUnavailable.message === "string" ? {
           exportUnavailableMessage: candidate.value.exportUnavailable.message
@@ -8012,7 +8323,7 @@ function collectDatasetCandidates(input2) {
     });
     return;
   }
-  if (!isRecord4(input2.value)) {
+  if (!isRecord5(input2.value)) {
     return;
   }
   for (const [key, child] of Object.entries(input2.value)) {
@@ -8029,12 +8340,12 @@ function collectDatasetCandidates(input2) {
   }
 }
 function collectCanonicalRowsInfos(statusOrResult) {
-  const root = isRecord4(statusOrResult) ? statusOrResult : null;
-  const result = isRecord4(root?.result) ? root.result : root;
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
+  const result = isRecord5(root?.result) ? root.result : root;
   if (!result) {
     return [];
   }
-  const metadata = isRecord4(result._metadata) ? result._metadata : null;
+  const metadata = isRecord5(result._metadata) ? result._metadata : null;
   const totalFromMetadata = metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count;
   const candidates = [
     {
@@ -8058,8 +8369,8 @@ function collectCanonicalRowsInfos(statusOrResult) {
       total: totalFromMetadata ?? result.totalRows ?? result.rowCount ?? result.count
     }
   ];
-  if (isRecord4(result.output)) {
-    const outputMetadata = isRecord4(result.output._metadata) ? result.output._metadata : null;
+  if (isRecord5(result.output)) {
+    const outputMetadata = isRecord5(result.output._metadata) ? result.output._metadata : null;
     const outputTotalFromMetadata = outputMetadata?.totalRows ?? outputMetadata?.rowCount ?? outputMetadata?.count;
     candidates.push(
       {
@@ -8086,14 +8397,14 @@ function collectCanonicalRowsInfos(statusOrResult) {
   }
   if (Array.isArray(result.steps)) {
     result.steps.forEach((step, index) => {
-      if (!isRecord4(step) || !isRecord4(step.output)) {
+      if (!isRecord5(step) || !isRecord5(step.output)) {
         return;
       }
       const source = typeof step.output.path === "string" ? step.output.path : typeof step.id === "string" ? `steps.${step.id}.output` : `steps.${index}.output`;
       candidates.push({
         source,
         value: step.output,
-        total: step.output.rowCount ?? (isRecord4(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord4(step.progress) ? step.progress.total : void 0)
+        total: step.output.rowCount ?? (isRecord5(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord5(step.progress) ? step.progress.total : void 0)
       });
     });
   }
@@ -8121,15 +8432,15 @@ function collectCanonicalRowsInfos(statusOrResult) {
   return infos;
 }
 function collectPackagedDatasetCandidates(statusOrResult) {
-  const root = isRecord4(statusOrResult) ? statusOrResult : null;
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
   if (!root) {
     return [];
   }
-  const pkg = isRecord4(root.package) ? root.package : root;
+  const pkg = isRecord5(root.package) ? root.package : root;
   const datasets = Array.isArray(pkg.datasets) ? pkg.datasets : [];
   const candidates = [];
   for (const output2 of datasets) {
-    if (!isRecord4(output2) || !isPackagedDatasetOutput(output2)) {
+    if (!isRecord5(output2) || !isPackagedDatasetOutput(output2)) {
       continue;
     }
     const source = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : null;
@@ -8139,18 +8450,18 @@ function collectPackagedDatasetCandidates(statusOrResult) {
     candidates.push({
       source,
       value: output2,
-      total: output2.rowCount ?? (isRecord4(output2.preview) ? output2.preview.totalRows : void 0)
+      total: output2.rowCount ?? (isRecord5(output2.preview) ? output2.preview.totalRows : void 0)
     });
   }
   return candidates;
 }
 function collectPackagedStepDatasetCandidates(statusOrResult) {
-  const root = isRecord4(statusOrResult) ? statusOrResult : null;
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
   if (!root) return [];
-  const pkg = isRecord4(root.package) ? root.package : root;
+  const pkg = isRecord5(root.package) ? root.package : root;
   const steps = Array.isArray(pkg.steps) ? pkg.steps : [];
   return steps.flatMap((step) => {
-    if (!isRecord4(step) || !isPackagedDatasetOutput(step.output)) return [];
+    if (!isRecord5(step) || !isPackagedDatasetOutput(step.output)) return [];
     const source = typeof step.output.path === "string" && step.output.path.trim() ? step.output.path.trim() : null;
     return source ? [
       {
@@ -8162,8 +8473,8 @@ function collectPackagedStepDatasetCandidates(statusOrResult) {
   });
 }
 function collectSerializedDatasetRowsInfos(statusOrResult) {
-  const root = isRecord4(statusOrResult) ? statusOrResult : null;
-  const result = isRecord4(root?.result) ? root.result : root;
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
+  const result = isRecord5(root?.result) ? root.result : root;
   const candidates = [];
   if (result) {
     collectDatasetCandidates({
@@ -8171,7 +8482,7 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
       path: "result",
       output: candidates
     });
-    if (isRecord4(result.output)) {
+    if (isRecord5(result.output)) {
       collectDatasetCandidates({
         value: result.output,
         path: "result",
@@ -8249,13 +8560,13 @@ function summarizeSampleValue(value, depth = 0) {
   if (typeof parsed === "number" || typeof parsed === "boolean") return parsed;
   if (depth >= 3) {
     if (Array.isArray(parsed)) return [];
-    if (isRecord4(parsed)) return {};
+    if (isRecord5(parsed)) return {};
     return compactScalar(parsed);
   }
   if (Array.isArray(parsed)) {
     return parsed.slice(0, 3).map((item) => summarizeSampleValue(item, depth + 1));
   }
-  if (isRecord4(parsed)) {
+  if (isRecord5(parsed)) {
     const out = {};
     for (const [key, nested] of Object.entries(parsed)) {
       if (["__dl", "meta", "metadata"].includes(key)) {
@@ -8286,7 +8597,7 @@ function compactCell(value) {
     }
     return `[${parsed.length} items]`;
   }
-  if (isRecord4(parsed)) {
+  if (isRecord5(parsed)) {
     for (const key of ["matched_result", "output"]) {
       if (parsed[key] !== null && parsed[key] !== void 0 && parsed[key] !== "") {
         return compactCell(parsed[key]);
@@ -9351,17 +9662,17 @@ function parsePositiveInteger2(value, flagName) {
   }
   return parsed;
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringValue(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function extractionEntries(value) {
-  if (Array.isArray(value)) return value.filter(isRecord5);
-  if (!isRecord5(value)) return [];
+  if (Array.isArray(value)) return value.filter(isRecord6);
+  if (!isRecord6(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord5(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord6(entry) ? { name, ...entry } : { name }
   );
 }
 var PlayBootstrapError = class extends Error {
@@ -9923,7 +10234,7 @@ function readCsvSampleRows(sample) {
     relax_column_count: true,
     trim: true
   });
-  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord5) : [];
+  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord6) : [];
 }
 function readSourceCsvColumnSpecs(csvPath) {
   const sample = readCsvSample(csvPath);
@@ -9956,16 +10267,16 @@ function packagedCsvPathForPlay(csvPath) {
   return portablePath.startsWith(".") ? portablePath : `./${portablePath}`;
 }
 function getterNamesFromTool(tool, kind) {
-  const usageGuidance = isRecord5(tool?.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord5(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord5(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const usageGuidance = isRecord6(tool?.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord6(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord6(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
   const key = kind === "list" ? "extractedLists" : "extractedValues";
   const snakeKey = kind === "list" ? "extracted_lists" : "extracted_values";
   return extractionEntries(resultGuidance[key] ?? resultGuidance[snakeKey]).map((entry) => stringValue(entry.name)).filter(Boolean);
 }
 function targetGettersFromTool(tool) {
-  const record = isRecord5(tool) ? tool : {};
+  const record = isRecord6(tool) ? tool : {};
   const raw = record.targetGetters ?? record.target_getters;
-  if (!isRecord5(raw)) return {};
+  if (!isRecord6(raw)) return {};
   const entries = [];
   for (const [target, value] of Object.entries(raw)) {
     const paths = Array.isArray(value) ? value.map((path) => typeof path === "string" ? path.trim() : "").filter(Boolean) : [];
@@ -9986,10 +10297,10 @@ function listRowCandidateKeysFromTool(tool) {
   return [...keys].sort();
 }
 function inputPropertyNames(schema) {
-  if (!isRecord5(schema)) return [];
-  if (isRecord5(schema.properties)) return Object.keys(schema.properties);
+  if (!isRecord6(schema)) return [];
+  if (isRecord6(schema.properties)) return Object.keys(schema.properties);
   if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord5).map((field) => stringValue(field.name)).filter(Boolean);
+    return schema.fields.filter(isRecord6).map((field) => stringValue(field.name)).filter(Boolean);
   }
   return [];
 }
@@ -10003,7 +10314,7 @@ function schemaFieldDetails(schema) {
   return { required, optional };
 }
 function jsonSchemaTypeExpression(schema) {
-  if (!isRecord5(schema)) return "unknown";
+  if (!isRecord6(schema)) return "unknown";
   const type = schema.type;
   if (Array.isArray(type)) {
     return type.map((entry) => jsonSchemaTypeExpression({ ...schema, type: entry })).join(" | ");
@@ -10033,7 +10344,7 @@ function jsonSchemaTypeExpression(schema) {
   }
 }
 function objectPropertySchema(schema, property) {
-  return isRecord5(schema) && isRecord5(schema.properties) ? schema.properties[property] : null;
+  return isRecord6(schema) && isRecord6(schema.properties) ? schema.properties[property] : null;
 }
 function playOutputHasField(schema, field) {
   return objectPropertySchema(schema, field) != null;
@@ -10209,14 +10520,14 @@ ${indent2.slice(2)}}`;
 }
 function requiredPlayInputFields(play) {
   const schema = play?.inputSchema;
-  if (!isRecord5(schema)) return [];
+  if (!isRecord6(schema)) return [];
   if (Array.isArray(schema.required)) {
     return schema.required.filter(
       (value) => typeof value === "string"
     );
   }
   if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord5).filter(
+    return schema.fields.filter(isRecord6).filter(
       (field) => field.required === true && typeof field.name === "string"
     ).map((field) => String(field.name));
   }
@@ -10397,7 +10708,7 @@ function validateBootstrapRoutes(input2) {
   }
 }
 function staticPipelineSubsteps(pipeline) {
-  if (!isRecord5(pipeline)) return [];
+  if (!isRecord6(pipeline)) return [];
   return [
     ...extractionEntries(pipeline.stages),
     ...extractionEntries(pipeline.substeps)
@@ -10405,7 +10716,7 @@ function staticPipelineSubsteps(pipeline) {
 }
 function playUsesMapBackedRuntime(play) {
   const pipeline = play?.staticPipeline;
-  if (!isRecord5(pipeline)) return false;
+  if (!isRecord6(pipeline)) return false;
   if (stringValue(pipeline.tableNamespace)) return true;
   return staticPipelineSubsteps(pipeline).some((substep) => {
     if (stringValue(substep.type) === "map") return true;
@@ -10414,7 +10725,7 @@ function playUsesMapBackedRuntime(play) {
       aliases: [],
       runCommand: "",
       examples: [],
-      staticPipeline: isRecord5(substep.pipeline) ? substep.pipeline : null
+      staticPipeline: isRecord6(substep.pipeline) ? substep.pipeline : null
     });
   });
 }
@@ -12537,22 +12848,96 @@ function getStatusFromLiveEvent(event) {
   const payload = getEventPayload(event);
   return playStatusValue(payload.status) ?? playStatusValue(getRunRecordFromPackage(payload)?.status);
 }
-function getWaitKindFromLiveEvent(event) {
+function readLiveRunField(event, field) {
   const payload = getEventPayload(event);
-  const progress = payload.progress && typeof payload.progress === "object" ? payload.progress : null;
-  const waitKind = payload.waitKind ?? progress?.waitKind;
-  return typeof waitKind === "string" && waitKind.trim() ? waitKind.trim() : null;
+  const run = getRunRecordFromPackage(payload);
+  const records = [payload, payload.progress, run, run?.progress].filter(
+    (value) => Boolean(value && typeof value === "object" && !Array.isArray(value))
+  );
+  for (const record of records) {
+    if (record[field] !== void 0) return record[field];
+  }
+  return void 0;
 }
-function writePlayWaitingHint(input2) {
-  if (getStatusFromLiveEvent(input2.event) !== "waiting") return;
+function getLiveRunStringField(event, field) {
+  const value = readLiveRunField(event, field);
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function getLiveRunActivity(event) {
+  const payload = getEventPayload(event);
+  const run = getRunRecordFromPackage(payload);
+  const candidates = [payload.activity, run?.activity];
+  for (const candidate of candidates) {
+    if (candidate && typeof candidate === "object" && !Array.isArray(candidate) && typeof candidate.summary === "string" && candidate.observation && typeof candidate.observation === "object") {
+      return candidate;
+    }
+  }
+  return null;
+}
+function getRunLifecycleHint(input2) {
   const runId = getRunIdFromLiveEvent(input2.event);
-  if (!runId || input2.state.waitingRunId === runId) return;
-  input2.state.waitingRunId = runId;
-  const waitKind = getWaitKindFromLiveEvent(input2.event);
-  const message = waitKind === "integration_event" || waitKind === "integration_event_batch" ? "is waiting for an external event." : waitKind === "sleep" ? "is waiting for its scheduled resume." : waitKind === "detached_runner" ? "is executing in the runtime." : "is waiting on a durable runtime boundary.";
-  input2.progress.writeLine(
-    `[play waiting] ${runId} ${message} The command will continue watching; inspect it with 'deepline runs get ${runId} --full --json'.`
+  const status = getStatusFromLiveEvent(input2.event);
+  if (!runId || status !== "queued" && status !== "running" && status !== "waiting") {
+    return null;
+  }
+  const activity = getLiveRunActivity(input2.event);
+  const activityConflictsWithDurableWait = status === "waiting" && activity?.observation.state.kind === "active" && activity.observation.target.kind !== "runner";
+  if (activity && activity.classified !== false && !activityConflictsWithDurableWait) {
+    const state = activity.observation.state;
+    const signature2 = [
+      runId,
+      "activity",
+      activity.observation.activityId,
+      JSON.stringify(state)
+    ].join(":");
+    const inspect2 = `'deepline runs get ${runId} --full --json'`;
+    const followUp = state.kind === "active" ? `The command will keep watching; if no new evidence arrives, check again in ~5 minutes with ${inspect2}.` : `The command will continue watching; inspect it with ${inspect2}.`;
+    return {
+      signature: signature2,
+      line: `[play activity] ${runId} ${activity.summary} ${followUp}`
+    };
+  }
+  const waitKind = getLiveRunStringField(input2.event, "waitKind");
+  const activeBoundaryId = getLiveRunStringField(
+    input2.event,
+    "activeBoundaryId"
   );
+  const signature = [
+    runId,
+    status,
+    waitKind ?? "",
+    activeBoundaryId ?? ""
+  ].join(":");
+  const inspect = `'deepline runs get ${runId} --full --json'`;
+  if (waitKind === "detached_runner") {
+    return {
+      signature,
+      line: `[play running] ${runId} is executing in a managed runtime (the runner started and connected its receipt gateway). This can take several minutes. The command will keep watching; if no new update arrives, check again in ~5 minutes with ${inspect}.`
+    };
+  }
+  if (status !== "waiting") return null;
+  if (waitKind === "sleep") {
+    return {
+      signature,
+      line: `[play waiting] ${runId} is sleeping until its scheduled resume. The command will continue watching; inspect it with ${inspect}.`
+    };
+  }
+  if (waitKind === "integration_event" || waitKind === "integration_event_batch" || waitKind === null) {
+    return {
+      signature,
+      line: `[play waiting] ${runId} is waiting for an external approval or event. The command will continue watching; inspect it with ${inspect}.`
+    };
+  }
+  return {
+    signature,
+    line: `[play waiting] ${runId} is paused on durable work (${waitKind}). The command will continue watching; inspect it with ${inspect}.`
+  };
+}
+function writePlayWaitingHint(input2) {
+  const hint = getRunLifecycleHint({ event: input2.event });
+  if (!hint || input2.state.lifecycleHintSignature === hint.signature) return;
+  input2.state.lifecycleHintSignature = hint.signature;
+  input2.progress.writeLine(hint.line);
 }
 function getFinalStatusFromLiveEvent(event) {
   if (event.type !== "play.run.snapshot" && event.type !== "play.run.status" && event.type !== "play.run.final_status") {
@@ -12808,13 +13193,18 @@ function getRunningHeartbeatLine(input2) {
   if (status !== "queued" && status !== "running" && status !== "waiting") {
     return null;
   }
+  const activity = getLiveRunActivity(input2.event);
+  const activityConflictsWithDurableWait = status === "waiting" && activity?.observation.state.kind === "active" && activity.observation.target.kind !== "runner";
+  if (activity && activity.classified !== false && !activityConflictsWithDurableWait) {
+    return `activity ${input2.playName}: ${activity.summary}`;
+  }
   const tableNamespace = extractTableNamespaceFromLiveEvent(input2.event);
   const target = tableNamespace ? formatProgressLabel(tableNamespace) : input2.playName;
   if (status === "queued") {
     return `queued ${target}: waiting for worker capacity`;
   }
   if (status === "waiting") {
-    if (getWaitKindFromLiveEvent(input2.event) === "detached_runner") {
+    if (getLiveRunStringField(input2.event, "waitKind") === "detached_runner") {
       return `running ${target}: executing in detached runtime`;
     }
     return `waiting ${target}: waiting on external work`;
@@ -15073,7 +15463,7 @@ function extractPlayValidationErrors(value) {
   if (value instanceof DeeplineError) {
     return extractPlayValidationErrors(value.details);
   }
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     return [];
   }
   const directErrors = stringArrayField(value, "errors");
@@ -15513,7 +15903,7 @@ function shouldUseLocalOnlyPlayCheck() {
   const value = process.env.DEEPLINE_PLAY_CHECK_LOCAL_ONLY?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringValue2(value) {
@@ -15523,14 +15913,14 @@ function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
 function extractionEntries2(value) {
-  if (Array.isArray(value)) return value.filter(isRecord6);
-  if (!isRecord6(value)) return [];
+  if (Array.isArray(value)) return value.filter(isRecord7);
+  if (!isRecord7(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord6(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord7(entry) ? { name, ...entry } : { name }
   );
 }
 function firstRawPath(entry) {
-  const details = isRecord6(entry.details) ? entry.details : {};
+  const details = isRecord7(entry.details) ? entry.details : {};
   const paths = [
     ...asArray(details.rawToolOutputPaths),
     ...asArray(details.raw_tool_output_paths),
@@ -15548,12 +15938,12 @@ function checkHintRawPath(value) {
 function collectStaticPipelineToolIds(staticPipeline) {
   const seen = /* @__PURE__ */ new Set();
   const visitPipeline = (pipeline) => {
-    if (!isRecord6(pipeline)) return;
+    if (!isRecord7(pipeline)) return;
     for (const step of [
       ...asArray(pipeline.stages),
       ...asArray(pipeline.substeps)
     ]) {
-      if (!isRecord6(step)) continue;
+      if (!isRecord7(step)) continue;
       if (step.type === "tool") {
         const toolId = stringValue2(step.toolId) || stringValue2(step.tool);
         if (toolId) seen.add(toolId);
@@ -15567,9 +15957,9 @@ function collectStaticPipelineToolIds(staticPipeline) {
   return [...seen].sort();
 }
 function toolGetterHintFromMetadata(toolId, tool) {
-  const usageGuidance = isRecord6(tool.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord6(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord6(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
-  const toolResponse = isRecord6(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord6(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
+  const usageGuidance = isRecord7(tool.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord7(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord7(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const toolResponse = isRecord7(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord7(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
   const lists = extractionEntries2(
     resultGuidance.extractedLists ?? resultGuidance.extracted_lists
   ).map((entry) => ({
@@ -19819,7 +20209,7 @@ function isMarkedTestAiInferenceCommand(command) {
   if (normalizeEnrichPlayRef(command.tool) !== "run_javascript") {
     return false;
   }
-  return isRecord7(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
+  return isRecord8(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
 }
 function enrichDebugEnabled(env = process.env) {
   const raw = String(env.DEEPLINE_DEBUG_ENRICH ?? "").trim().toLowerCase();
@@ -20083,7 +20473,7 @@ function rewriteGeneratedPlayRerunForEnrich(status, enrichCommand) {
     if (Array.isArray(value)) {
       return value.map(rewrite);
     }
-    if (!isRecord7(value)) {
+    if (!isRecord8(value)) {
       return value;
     }
     const next = Object.fromEntries(
@@ -20092,7 +20482,7 @@ function rewriteGeneratedPlayRerunForEnrich(status, enrichCommand) {
         key === "rerunCommand" && typeof entry === "string" ? enrichCommand : rewrite(entry)
       ])
     );
-    if (isRecord7(next.next) && typeof next.next.run === "string") {
+    if (isRecord8(next.next) && typeof next.next.run === "string") {
       next.next = { ...next.next, run: enrichCommand };
     }
     return next;
@@ -20563,7 +20953,7 @@ async function resolveWatchedGeneratedPlayStatus(input2) {
   }
   return input2.client.runs.get(runId, { full: true });
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 async function captureStdout(run, options = {}) {
@@ -20815,15 +21205,15 @@ function readFirstEnrichDatasetActions(value) {
       return null;
     }
     const record = candidate;
-    const actions = isRecord7(record.actions) ? record.actions : null;
-    const currentQuery = isRecord7(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
-    const legacyQuery = isRecord7(actions?.query) ? actions.query : null;
+    const actions = isRecord8(record.actions) ? record.actions : null;
+    const currentQuery = isRecord8(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
+    const legacyQuery = isRecord8(actions?.query) ? actions.query : null;
     const query = currentQuery?.kind === "deepline_db_query" ? currentQuery : legacyQuery?.kind === "deepline_db_query" ? legacyQuery : null;
     if (query?.kind === "deepline_db_query") {
       return {
         dataset: record,
         query,
-        ...isRecord7(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
+        ...isRecord8(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
       };
     }
     if (options.allowLegacy && record.kind === "dataset" && typeof record.queryDatasetCommand === "string" && record.queryDatasetCommand.trim()) {
@@ -20876,7 +21266,7 @@ function enrichCustomerDbJson(input2) {
   const dataset = actions.dataset;
   const sql = actionStringField(query, "sql") ?? parseSqlFromDbQueryCommand(actions.queryDatasetCommand);
   const datasetPath = actionStringField(query, "datasetPath") ?? actionStringField(dataset, "path") ?? actionStringField(dataset, "tableNamespace");
-  const api = isRecord7(query.api) ? query.api : null;
+  const api = isRecord8(query.api) ? query.api : null;
   const apiPath = actionStringField(api ?? {}, "path") ?? "/api/v2/db/query";
   const apiMethod = actionStringField(api ?? {}, "method") ?? "POST";
   if (!datasetPath) {
@@ -20945,11 +21335,11 @@ function sqlStringLiteral(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
 function failureAliasFromCellMeta(cellMeta) {
-  if (!isRecord7(cellMeta)) {
+  if (!isRecord8(cellMeta)) {
     return null;
   }
   for (const [alias, meta] of Object.entries(cellMeta)) {
-    if (!isRecord7(meta)) {
+    if (!isRecord8(meta)) {
       continue;
     }
     const failure = failureCellFromMeta(meta, {});
@@ -21442,7 +21832,7 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
   return fallback;
 }
 function failureCellFromMeta(meta, fallback) {
-  if (!isRecord7(meta)) {
+  if (!isRecord8(meta)) {
     return null;
   }
   const status = typeof meta.status === "string" ? meta.status.trim().toLowerCase() : "";
@@ -21462,7 +21852,7 @@ function failureCellFromMeta(meta, fallback) {
   };
 }
 function applyFailureCellMeta(row, cellMeta, fallback) {
-  if (!isRecord7(cellMeta)) {
+  if (!isRecord8(cellMeta)) {
     return;
   }
   for (const [field, meta] of Object.entries(cellMeta)) {
@@ -21690,7 +22080,7 @@ function stableRowSnapshot(value) {
 }
 function cellFailureError(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord7(parsed)) {
+  if (!isRecord8(parsed)) {
     const text = typeof parsed === "string" ? parsed.trim() : "";
     if (/^(?:[A-Za-z0-9_:-]+:\s*)?(?:Error|TypeError|ReferenceError|SyntaxError|RangeError):\s+/.test(
       text
@@ -21698,12 +22088,12 @@ function cellFailureError(value) {
       return { message: text };
     }
   }
-  if (!isRecord7(parsed)) {
+  if (!isRecord8(parsed)) {
     return null;
   }
   const status = typeof parsed.status === "string" ? parsed.status.trim().toLowerCase() : "";
   const directError = typeof parsed.error === "string" ? parsed.error.trim() : typeof parsed.last_error === "string" ? parsed.last_error.trim() : "";
-  const result = isRecord7(parsed.result) ? parsed.result : null;
+  const result = isRecord8(parsed.result) ? parsed.result : null;
   const resultError = typeof result?.error === "string" ? result.error.trim() : typeof result?.message === "string" ? result.message.trim() : "";
   if (!directError && !resultError && status !== "error" && status !== "failed") {
     return null;
@@ -21773,7 +22163,7 @@ function assignFlattenedFailurePath(target, field, value) {
   let cursor = target;
   for (const part of normalized.slice(0, -1)) {
     const existing = cursor[part];
-    if (!isRecord7(existing)) {
+    if (!isRecord8(existing)) {
       const next = {};
       cursor[part] = next;
       cursor = next;
@@ -21937,10 +22327,10 @@ function waterfallExecutionSignal(status, spec) {
   let everyChildStatOnlyConditionSkipped = true;
   const childAliasesWithStats = /* @__PURE__ */ new Set();
   for (const childAlias of childAliases) {
-    for (const stat2 of summaries.map((summary) => summary[childAlias]).filter(isRecord7)) {
+    for (const stat2 of summaries.map((summary) => summary[childAlias]).filter(isRecord8)) {
       sawChildStats = true;
       childAliasesWithStats.add(childAlias);
-      const execution = isRecord7(stat2.execution) ? stat2.execution : null;
+      const execution = isRecord8(stat2.execution) ? stat2.execution : null;
       const executedSummary = parseExecutionSummary(
         execution?.["completed:executed"]
       );
@@ -21970,7 +22360,7 @@ function waterfallExecutionSignal(status, spec) {
 }
 function emptyWaterfallStatsEvidence(status, spec) {
   const summaries = collectColumnStats(status);
-  const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord7);
+  const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord8);
   for (const stat2 of parentStats) {
     const nonEmpty = parseExecutionSummary(stat2.non_empty);
     if (nonEmpty?.total && nonEmpty.count === 0) {
@@ -21984,7 +22374,7 @@ function emptyWaterfallStatsEvidence(status, spec) {
   let selectedRows = 0;
   let sawStatsForEveryChild = true;
   for (const childAlias of childAliases) {
-    const stat2 = summaries.map((summary) => summary[childAlias]).find(isRecord7);
+    const stat2 = summaries.map((summary) => summary[childAlias]).find(isRecord8);
     if (!stat2) {
       sawStatsForEveryChild = false;
       break;
@@ -21993,7 +22383,7 @@ function emptyWaterfallStatsEvidence(status, spec) {
     if ((nonEmpty?.count ?? 0) > 0) {
       return null;
     }
-    const execution = isRecord7(stat2.execution) ? stat2.execution : null;
+    const execution = isRecord8(stat2.execution) ? stat2.execution : null;
     const executed = parseExecutionSummary(execution?.["completed:executed"]);
     const reused = parseExecutionSummary(execution?.["completed:reused"]);
     const skipped = parseExecutionSummary(execution?.["skipped:condition"]);
@@ -22035,11 +22425,11 @@ function collectStatusFailureJobs(input2) {
   const jobs = [];
   aliases.forEach((spec, aliasIndex) => {
     const { alias } = spec;
-    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord7);
+    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord8);
     if (!stat2) {
       return;
     }
-    const execution = isRecord7(stat2.execution) ? stat2.execution : null;
+    const execution = isRecord8(stat2.execution) ? stat2.execution : null;
     const failedCount = Math.min(
       selectedRows,
       Math.max(
@@ -22146,10 +22536,10 @@ function collectColumnStats(status) {
       value.forEach(visit);
       return;
     }
-    if (!isRecord7(value)) {
+    if (!isRecord8(value)) {
       return;
     }
-    if (isRecord7(value.columnStats)) {
+    if (isRecord8(value.columnStats)) {
       summaries.push(value.columnStats);
     }
     Object.values(value).forEach(visit);
@@ -22161,12 +22551,12 @@ function firstAliasExecutionCounts(input2) {
   const aliases = collectConfigScalarAliasOrder(input2.config);
   const summaries = collectColumnStats(input2.status);
   for (const alias of aliases) {
-    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord7);
+    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord8);
     if (!stat2) continue;
     if (input2.forceAliases.has(normalizeAlias2(alias))) {
       return { executed: input2.selectedRows, reused: 0 };
     }
-    const execution = isRecord7(stat2.execution) ? stat2.execution : null;
+    const execution = isRecord8(stat2.execution) ? stat2.execution : null;
     if (!execution) continue;
     return {
       executed: parseExecutionCount(execution["completed:executed"]),
@@ -22193,14 +22583,14 @@ function rewriteEnrichJsonStatus(input2) {
     if (Array.isArray(value)) {
       return value.map(rewrite);
     }
-    if (!isRecord7(value)) {
+    if (!isRecord8(value)) {
       return value;
     }
     const next = {};
     for (const [key, entry] of Object.entries(value)) {
       next[key] = rewrite(entry);
     }
-    if (isRecord7(next.progress)) {
+    if (isRecord8(next.progress)) {
       next.progress = {
         ...next.progress,
         ...selectedRows > 0 ? { total: selectedRows } : {},
@@ -22209,8 +22599,8 @@ function rewriteEnrichJsonStatus(input2) {
         ...failedRows > 0 ? { failed: failedRows, pending: 0 } : {}
       };
     }
-    if (isRecord7(next.summary)) {
-      const rowCounts = isRecord7(next.summary.rowCounts) ? next.summary.rowCounts : null;
+    if (isRecord8(next.summary)) {
+      const rowCounts = isRecord8(next.summary.rowCounts) ? next.summary.rowCounts : null;
       if (failedRows > 0) {
         next.summary = {
           ...next.summary,
@@ -22223,11 +22613,11 @@ function rewriteEnrichJsonStatus(input2) {
         };
       }
     }
-    if (isRecord7(next.columnStats) && selectedRows > 0) {
+    if (isRecord8(next.columnStats) && selectedRows > 0) {
       const columnStats = { ...next.columnStats };
       for (const alias of forcedAliases) {
-        const stat2 = isRecord7(columnStats[alias]) ? columnStats[alias] : null;
-        const execution = isRecord7(stat2?.execution) ? stat2.execution : null;
+        const stat2 = isRecord8(columnStats[alias]) ? columnStats[alias] : null;
+        const execution = isRecord8(stat2?.execution) ? stat2.execution : null;
         if (!stat2 || !execution) continue;
         columnStats[alias] = {
           ...stat2,
@@ -22246,14 +22636,14 @@ function rewriteEnrichJsonStatus(input2) {
     return next;
   };
   const rewritten = rewrite(input2.status);
-  if (failedRows === 0 || !isRecord7(rewritten)) {
+  if (failedRows === 0 || !isRecord8(rewritten)) {
     return rewritten;
   }
   const partialStatus = selectedRows > 0 && failedRows < selectedRows ? "partial_success" : "failed";
   return {
     ...rewritten,
     ...rewritten.status === "completed" || rewritten.status === "failed" ? { status: partialStatus } : {},
-    ...isRecord7(rewritten.run) && (rewritten.run.status === "completed" || rewritten.run.status === "failed") ? { run: { ...rewritten.run, status: partialStatus } } : {}
+    ...isRecord8(rewritten.run) && (rewritten.run.status === "completed" || rewritten.run.status === "failed") ? { run: { ...rewritten.run, status: partialStatus } } : {}
   };
 }
 function summarizeFailedJobError(value) {
@@ -22859,7 +23249,7 @@ function materializeCsvCellValue(value) {
   return value;
 }
 function compactArrayEnvelopeCompleteValue(value) {
-  if (!isRecord7(value) || value.kind !== "array") {
+  if (!isRecord8(value) || value.kind !== "array") {
     return null;
   }
   if (!Array.isArray(value.preview)) {
@@ -22873,7 +23263,7 @@ function compactArrayEnvelopeCompleteValue(value) {
 }
 function disambiguateCompactAiInferencePayload(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord7(parsed) || !cellFailureError(parsed)) {
+  if (!isRecord8(parsed) || !cellFailureError(parsed)) {
     return value;
   }
   return {
@@ -22882,14 +23272,14 @@ function disambiguateCompactAiInferencePayload(value) {
   };
 }
 function compactAiInferenceCellForCsv(value) {
-  if (!isRecord7(value)) {
+  if (!isRecord8(value)) {
     return value;
   }
   const extractedJson = value.extracted_json;
   if (extractedJson !== null && extractedJson !== void 0) {
     return disambiguateCompactAiInferencePayload(extractedJson);
   }
-  const result = isRecord7(value.result) ? value.result : null;
+  const result = isRecord8(value.result) ? value.result : null;
   const object = result?.object;
   if (object !== null && object !== void 0) {
     return disambiguateCompactAiInferencePayload(object);
@@ -22906,12 +23296,12 @@ function compactAiInferenceCellForCsv(value) {
 }
 function materializeEnrichAliasCellForCsv(row, alias, options) {
   const direct = row[alias];
-  if (isRecord7(direct)) {
+  if (isRecord8(direct)) {
     const completeArray = compactArrayEnvelopeCompleteValue(direct);
     if (completeArray) {
       return materializeCsvCellValue(completeArray);
     }
-    if (options?.compactAiCell && direct.status === "completed" && (isRecord7(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
+    if (options?.compactAiCell && direct.status === "completed" && (isRecord8(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
       return materializeCsvCellValue(compactAiInferenceCellForCsv(direct));
     }
     if (Object.prototype.hasOwnProperty.call(direct, "matched_result") || Object.prototype.hasOwnProperty.call(direct, "matchedResult") || Object.prototype.hasOwnProperty.call(direct, "result")) {
@@ -23052,11 +23442,11 @@ function normalizeEnrichRowsForCsvExport(rows, config, options) {
 }
 function legacyMetadataFromRow(row) {
   const direct = parseLegacyMetadataCell(row._metadata);
-  if (direct && isRecord7(direct.columns)) {
+  if (direct && isRecord8(direct.columns)) {
     return direct;
   }
   const relocated = parseLegacyMetadataCell(row.metadata);
-  if (relocated && isRecord7(relocated.columns)) {
+  if (relocated && isRecord8(relocated.columns)) {
     return relocated;
   }
   const flattenedColumns = parseLegacyMetadataCell(row["metadata.columns"]);
@@ -23073,7 +23463,7 @@ function legacyMetadataFromRow(row) {
 }
 function parseLegacyMetadataCell(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (isRecord7(parsed)) {
+  if (isRecord8(parsed)) {
     return parsed;
   }
   if (typeof value !== "string") {
@@ -23090,12 +23480,12 @@ function parseLegacyMetadataCell(value) {
   for (const candidate of candidates) {
     try {
       const decoded = JSON.parse(candidate);
-      if (isRecord7(decoded)) {
+      if (isRecord8(decoded)) {
         return decoded;
       }
       if (typeof decoded === "string") {
         const nested = JSON.parse(decoded);
-        if (isRecord7(nested)) {
+        if (isRecord8(nested)) {
           return nested;
         }
       }
@@ -23105,8 +23495,8 @@ function parseLegacyMetadataCell(value) {
   return null;
 }
 function mergeLegacyMetadataRecords(base, enriched) {
-  const baseColumns = isRecord7(base.columns) ? base.columns : null;
-  const enrichedColumns = isRecord7(enriched.columns) ? enriched.columns : null;
+  const baseColumns = isRecord8(base.columns) ? base.columns : null;
+  const enrichedColumns = isRecord8(enriched.columns) ? enriched.columns : null;
   const merged = {
     ...base,
     ...enriched
@@ -26975,6 +27365,43 @@ async function listTools(category, options = {}) {
   }
   return listToolCategories(emitJson, compact);
 }
+async function listProviders(options = {}) {
+  const client2 = new DeeplineClient();
+  const changed = options.changed === true;
+  const emitJson = options.json === true || shouldEmitJson();
+  const providers = await client2.listProviders({ changed });
+  const render = {
+    sections: [
+      {
+        title: changed ? `${providers.length} recently added providers:` : `${providers.length} providers:`,
+        lines: providers.map((provider) => {
+          const release2 = provider.releasedAt ? ` - v${provider.version ?? "unknown"} (${provider.releasedAt})` : "";
+          return `${provider.provider} (${provider.displayName}) - ${provider.toolCount} tools${release2}`;
+        })
+      },
+      {
+        title: "next",
+        lines: [
+          "Run `deepline tools list <category>` to browse provider tools by category."
+        ]
+      }
+    ]
+  };
+  printCommandEnvelope(
+    {
+      providers,
+      count: providers.length,
+      filters: { changed },
+      commandTemplates: {
+        list: "deepline tools providers",
+        changed: "deepline tools providers --changed"
+      },
+      render
+    },
+    { json: emitJson }
+  );
+  return 0;
+}
 async function searchTools(queryInput, options = {}) {
   const query = queryInput?.trim() ?? "";
   const hasStructuredSearch = Boolean(
@@ -27167,6 +27594,7 @@ Concepts:
   through the plays namespace.
 
 Common commands:
+  deepline tools providers --changed --json
   deepline tools search email --json
   deepline tools describe hunter_email_verifier --json
   deepline tools execute hunter_email_verifier --input '{"email":"a@b.com"}'
@@ -27176,6 +27604,28 @@ Output:
   Use execute to run a tool.
 `
   );
+  tools.command("providers").description("List discoverable providers and their available tool counts.").addHelpText(
+    "after",
+    `
+Notes:
+  This directory is served by Deepline's provider catalog; it does not require
+  cloning a public plugins repository. Use --changed to show recently added
+  providers with their catalog version and release date.
+
+Examples:
+  deepline tools providers
+  deepline tools providers --changed
+  deepline tools providers --changed --json
+`
+  ).option(
+    "--changed",
+    "Only list recently added providers with release metadata"
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (options) => {
+    process.exitCode = await listProviders({
+      changed: Boolean(options.changed),
+      json: Boolean(options.json)
+    });
+  });
   tools.command("list [category]").description("Browse tool categories, or list every tool in a category.").addHelpText(
     "after",
     `
@@ -27537,7 +27987,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
 }
 function extractionContractEntries(entries) {
   return entries.flatMap((entry) => {
-    if (!isRecord8(entry)) return [];
+    if (!isRecord9(entry)) return [];
     const name = stringField2(entry, "name");
     const expression = stringField2(entry, "expression");
     return name && expression ? [{ name, expression }] : [];
@@ -27558,7 +28008,7 @@ function printMonitorTypeFilters(tool) {
   }
   console.log("Deploy filters (set in the monitor payload):");
   for (const name of names) {
-    const field = isRecord8(properties[name]) ? properties[name] : {};
+    const field = isRecord9(properties[name]) ? properties[name] : {};
     const star = required.has(name) ? "*" : "";
     const enumVals = arrayField2(field, "enum").filter(
       (v) => typeof v === "string"
@@ -27569,13 +28019,13 @@ function printMonitorTypeFilters(tool) {
   }
 }
 function printMonitorTypeStreams(tool) {
-  const streams = arrayField2(tool, "streams", "output_streams").filter(isRecord8);
+  const streams = arrayField2(tool, "streams", "output_streams").filter(isRecord9);
   if (!streams.length) return;
   console.log("");
   console.log("Filter columns (a play's sqlListeners.where, per stream):");
   for (const stream of streams) {
     const name = stringField2(stream, "stream");
-    const cols = arrayField2(stream, "columns").filter(isRecord8).map((col) => stringField2(col, "name")).filter(Boolean);
+    const cols = arrayField2(stream, "columns").filter(isRecord9).map((col) => stringField2(col, "name")).filter(Boolean);
     console.log(`- ${name}: ${cols.join(", ")}`);
   }
 }
@@ -27593,7 +28043,7 @@ function printMonitorTypePricing(tool) {
   }
   console.log("Pricing (Deepline credits per accepted event):");
   for (const key of keys) {
-    const entry = isRecord8(byType[key]) ? byType[key] : {};
+    const entry = isRecord9(byType[key]) ? byType[key] : {};
     const credits = numberField2(entry, "deepline_credits", "deeplineCredits");
     const display = stringField2(entry, "display");
     const shown = display || (credits !== null ? `${formatDecimal(credits)} credits/event` : "see --json");
@@ -27638,8 +28088,8 @@ function printCompactToolContract(tool, requestedToolId) {
     return;
   }
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord8(contract.cost) ? contract.cost : {};
-  const getters = isRecord8(contract.getters) ? contract.getters : {};
+  const cost = isRecord9(contract.cost) ? contract.cost : {};
+  const getters = isRecord9(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const inputFields = Array.isArray(contract.inputFields) ? contract.inputFields : [];
@@ -27656,7 +28106,7 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("");
     console.log("Inputs:");
     for (const field of inputFields) {
-      if (!isRecord8(field)) continue;
+      if (!isRecord9(field)) continue;
       const name = stringField2(field, "name");
       if (!name) continue;
       const required = field.required ? "*" : "";
@@ -27669,7 +28119,7 @@ function printCompactToolContract(tool, requestedToolId) {
   }
   console.log("");
   printToolExamplesOnly(tool, requestedToolId, { includeSamples: false });
-  const starterScript = isRecord8(contract.starterScript) ? contract.starterScript : {};
+  const starterScript = isRecord9(contract.starterScript) ? contract.starterScript : {};
   const starterPath = stringField2(starterScript, "path");
   if (starterPath) {
     console.log("");
@@ -27683,14 +28133,14 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("Getters:");
     if (listGetters.length) console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord8(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
     }
     if (valueGetters.length) console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord8(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -27707,7 +28157,7 @@ function printToolPricingOnly(tool, requestedToolId, options = {}) {
     return;
   }
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord8(contract.cost) ? contract.cost : {};
+  const cost = isRecord9(contract.cost) ? contract.cost : {};
   const pricingModel = stringField2(cost, "pricingModel") || "unknown";
   const billingMode = stringField2(cost, "billingMode") || "unknown";
   const unit = pricingModel === "per_page" ? "page" : pricingModel === "per_result" ? "result" : pricingModel === "fixed" ? "call" : pricingModel.replace(/^per_/, "") || "unit";
@@ -27732,7 +28182,7 @@ function printToolSchemaOnly(tool, requestedToolId) {
   }
   console.log("Inputs:");
   for (const field of inputFields) {
-    if (!isRecord8(field)) continue;
+    if (!isRecord9(field)) continue;
     const name = stringField2(field, "name");
     if (!name) continue;
     const required = field.required ? "*" : "";
@@ -27766,10 +28216,10 @@ function printToolExamplesOnly(tool, requestedToolId, options = {}) {
     `  input: ${JSON.stringify(sampleInput || {}, null, 2).replace(/\n/g, "\n  ")},`
   );
   console.log("});");
-  const getters = isRecord8(contract.getters) ? contract.getters : {};
+  const getters = isRecord9(contract.getters) ? contract.getters : {};
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
-  const firstGetter = [...valueGetters, ...listGetters].find(isRecord8);
+  const firstGetter = [...valueGetters, ...listGetters].find(isRecord9);
   if (firstGetter) {
     const name = stringField2(firstGetter, "name") || "value";
     const expression = stringField2(firstGetter, "expression");
@@ -27805,7 +28255,7 @@ function printPlayLikeToolUsage(tool, requestedToolId) {
 }
 function printToolGettersOnly(tool, requestedToolId) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const getters = isRecord8(contract.getters) ? contract.getters : {};
+  const getters = isRecord9(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   console.log(`Getters: ${contract.toolId}`);
@@ -27818,7 +28268,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (listGetters.length) {
     console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord8(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -27827,7 +28277,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (valueGetters.length) {
     console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord8(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -27853,7 +28303,7 @@ function sampleValueForField(field) {
 function samplePayloadForInputFields(fields) {
   return Object.fromEntries(
     fields.slice(0, 4).flatMap((field) => {
-      if (!isRecord8(field)) return [];
+      if (!isRecord9(field)) return [];
       const name = stringField2(field, "name");
       if (!name) return [];
       return [[name, sampleValueForField(field)]];
@@ -27971,12 +28421,12 @@ function formatListedToolCost(tool) {
 }
 function toolInputFieldsForDisplay(inputSchema) {
   if (Array.isArray(inputSchema.fields))
-    return inputSchema.fields.filter(isRecord8);
-  const jsonSchema = isRecord8(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
-  const properties = isRecord8(jsonSchema.properties) ? jsonSchema.properties : {};
+    return inputSchema.fields.filter(isRecord9);
+  const jsonSchema = isRecord9(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  const properties = isRecord9(jsonSchema.properties) ? jsonSchema.properties : {};
   const required = Array.isArray(jsonSchema.required) ? new Set(jsonSchema.required.map(String)) : /* @__PURE__ */ new Set();
   return Object.entries(properties).map(([name, value]) => {
-    const property = isRecord8(value) ? value : {};
+    const property = isRecord9(value) ? value : {};
     return {
       name,
       type: typeof property.type === "string" ? property.type : "unknown",
@@ -28005,14 +28455,14 @@ function printJsonPreview(label, payload) {
 }
 function samplePayload(samples, key) {
   const entry = samples[key];
-  if (!isRecord8(entry)) return void 0;
+  if (!isRecord9(entry)) return void 0;
   return Object.prototype.hasOwnProperty.call(entry, "payload") ? entry.payload : entry;
 }
 function commandEnvelopeFromRawResponse(rawResponse) {
-  return isRecord8(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
+  return isRecord9(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
 }
 function apifySyncRecoveryNext(rawResponse) {
-  if (!isRecord8(rawResponse) || rawResponse.status !== "running") return null;
+  if (!isRecord9(rawResponse) || rawResponse.status !== "running") return null;
   const toolResponse = recordField2(rawResponse, "toolResponse");
   const raw = recordField2(toolResponse, "raw");
   if (raw.state !== "awaiting_apify") return null;
@@ -28035,7 +28485,7 @@ function apifySyncRecoveryNext(rawResponse) {
 }
 function listExtractorPathsFromUsageGuidance(tool) {
   const toolExecutionResult = tool.usageGuidance?.toolExecutionResult;
-  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord8(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
+  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord9(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
   return extractedLists.flatMap((entry) => {
     const paths = entry.details?.candidatePaths ?? entry.details?.rawToolOutputPaths;
     if (!Array.isArray(paths)) return [];
@@ -28051,7 +28501,7 @@ function formatDecimal(value) {
 function formatUsd(value) {
   return `$${formatDecimal(value)}`;
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringField2(source, ...keys) {
@@ -28078,7 +28528,7 @@ function arrayField2(source, ...keys) {
 function recordField2(source, ...keys) {
   for (const key of keys) {
     const value = source[key];
-    if (isRecord8(value)) return value;
+    if (isRecord9(value)) return value;
   }
   return {};
 }
@@ -28144,7 +28594,7 @@ function parseJsonObjectArgument(raw, flagName) {
     }
     throw invalidJsonError(flagName, message);
   }
-  if (!isRecord8(parsed)) {
+  if (!isRecord9(parsed)) {
     throw invalidJsonError(flagName, "expected an object.");
   }
   return parsed;
@@ -28291,7 +28741,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     kind: summaryEntries.length > 0 ? "object" : "raw",
     summary: input2.summary
   };
-  const envelopeHasCanonicalOutput = isRecord8(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
+  const envelopeHasCanonicalOutput = isRecord9(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
   const envelopeHasDeclaredOutput = Object.prototype.hasOwnProperty.call(
     envelope,
     "output"
@@ -28521,7 +28971,7 @@ async function executeTool(args) {
       {
         ...baseEnvelope,
         local: {
-          ...isRecord8(baseEnvelope.local) ? baseEnvelope.local : {},
+          ...isRecord9(baseEnvelope.local) ? baseEnvelope.local : {},
           payload_file: jsonPath
         }
       },
@@ -31987,7 +32437,9 @@ function shouldDeferSkillsSyncForCommand() {
   const args = process.argv.slice(2);
   const command = args[0];
   const subcommand = args[1];
-  if (command === "tools" && ["list", "search", "grep", "describe", "get"].includes(subcommand ?? "")) {
+  if (command === "tools" && ["list", "providers", "search", "grep", "describe", "get"].includes(
+    subcommand ?? ""
+  )) {
     return true;
   }
   return (command === "play" || command === "plays") && subcommand === "run" && args.includes("--json");
@@ -32213,6 +32665,7 @@ Common commands:
   deepline plays describe prebuilt/person-linkedin-to-email --json
   deepline plays run my.play.ts --input '{"domain":"stripe.com"}'
   deepline secrets check HUBSPOT_TOKEN
+  deepline tools providers --changed --json
   deepline tools execute hunter_email_verifier --input '{"email":"a@b.com"}'
   deepline update