deepline 0.3.213 → 0.3.215

package/dist/cli/index.mjs

@@ -1951,7 +1951,7 @@ configureProxyFromEnv();
 
 // src/cli/index.ts
 import { mkdtemp as mkdtemp4, rm as rm4, writeFile as writeFile6 } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 import { tmpdir as tmpdir7 } from "os";
 import { Command as Command5 } from "commander";
 
@@ -3046,7 +3046,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.213",
+  version: "0.3.215",
   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
@@ -3367,6 +3367,22 @@ function writeSdkSkillsLocalVersion(baseUrl, version, agents) {
   return complete;
 }
 
+// src/deployment-protection.ts
+function deploymentProtectionHeaders() {
+  const token = typeof process !== "undefined" ? process.env?.VERCEL_PROTECTION_BYPASS_TOKEN : void 0;
+  return token ? { "x-vercel-protection-bypass": token } : {};
+}
+var fetchWithDeploymentProtection = (input2, init) => {
+  const headers = new Headers(
+    input2 instanceof Request ? input2.headers : void 0
+  );
+  new Headers(init?.headers).forEach((value, name) => headers.set(name, value));
+  for (const [name, value] of Object.entries(deploymentProtectionHeaders())) {
+    headers.set(name, value);
+  }
+  return fetch(input2, { ...init, headers });
+};
+
 // ../play-runtime/coordinator-headers.ts
 var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
 var COORDINATOR_URL_OVERRIDE_HEADER = "x-deepline-coordinator-url";
@@ -3749,16 +3765,13 @@ var HttpClient = class {
       "X-Deepline-SDK-Version": SDK_VERSION,
       "X-Deepline-API-Contract": SDK_API_CONTRACT,
       "X-Deepline-Run-Result-Shape": "canonical",
-      ...extra
+      ...extra,
+      ...deploymentProtectionHeaders()
     };
     const skillsVersion = this.readSkillsVersionHeader();
     if (skillsVersion) {
       headers["X-Deepline-Skills-Version"] = skillsVersion;
     }
-    const bypassToken = typeof process !== "undefined" ? process.env?.VERCEL_PROTECTION_BYPASS_TOKEN : void 0;
-    if (bypassToken) {
-      headers["x-vercel-protection-bypass"] = bypassToken;
-    }
     const playArtifactR2Prefix = typeof process !== "undefined" ? process.env?.DEEPLINE_PLAY_ARTIFACT_R2_PREFIX : void 0;
     if (playArtifactR2Prefix) {
       headers["x-deepline-play-artifact-r2-prefix"] = playArtifactR2Prefix;
@@ -4887,13 +4900,13 @@ function previewValue(value, input2) {
       ([, descriptor]) => descriptor.enumerable
     );
     const selected = entries.slice(0, DOCFLOW_NODE_IO_LIMITS.maxObjectFields);
-    const fields = {};
+    const fields2 = {};
     for (const [key, descriptor] of selected) {
       const safeKey = truncateUtf8(
         ledgerSafeDocflowPreviewKey(input2.redactor.redactString(key)),
         DOCFLOW_NODE_IO_LIMITS.maxStringBytes
       );
-      fields[safeKey] = "value" in descriptor ? previewValue(descriptor.value, {
+      fields2[safeKey] = "value" in descriptor ? previewValue(descriptor.value, {
         ...input2,
         depth: input2.depth + 1,
         key
@@ -4901,7 +4914,7 @@ function previewValue(value, input2) {
     }
     return {
       kind: "object",
-      fields,
+      fields: fields2,
       totalFields: entries.length,
       ...entries.length > selected.length ? { truncated: true } : {}
     };
@@ -5010,20 +5023,20 @@ function normalizePreview(value, depth) {
     };
   }
   if (value.kind === "object" && isRecord3(value.fields)) {
-    const fields = {};
+    const fields2 = {};
     for (const [key, field] of Object.entries(value.fields).slice(
       0,
       DOCFLOW_NODE_IO_LIMITS.maxObjectFields
     )) {
       const normalized = normalizePreview(field, depth + 1);
-      if (normalized) fields[ledgerSafeDocflowPreviewKey(key)] = normalized;
+      if (normalized) fields2[ledgerSafeDocflowPreviewKey(key)] = normalized;
     }
-    const totalFields = typeof value.totalFields === "number" && Number.isFinite(value.totalFields) ? Math.max(Object.keys(fields).length, Math.floor(value.totalFields)) : Object.keys(fields).length;
+    const totalFields = typeof value.totalFields === "number" && Number.isFinite(value.totalFields) ? Math.max(Object.keys(fields2).length, Math.floor(value.totalFields)) : Object.keys(fields2).length;
     return {
       kind: "object",
-      fields,
+      fields: fields2,
       totalFields,
-      ...value.truncated === true || totalFields > Object.keys(fields).length ? { truncated: true } : {}
+      ...value.truncated === true || totalFields > Object.keys(fields2).length ? { truncated: true } : {}
     };
   }
   return null;
@@ -7035,10 +7048,19 @@ function normalizePlayStatus(raw) {
     );
   }
   const runId = typeof raw.runId === "string" ? raw.runId : typeof raw.workflowId === "string" ? raw.workflowId : packageRun?.id ?? "";
+  const legacyOverview = runPackage?.overview ?? raw.overview;
+  const runStatus = runPackage?.runStatus ?? raw.runStatus;
   return {
     ...raw,
     runId,
-    ...runPackage ? { package: runPackage, outputs: runPackage.outputs } : {},
+    ...isRecord7(legacyOverview) ? {
+      overview: legacyOverview
+    } : {},
+    ...isRecord7(runStatus) ? { runStatus } : {},
+    ...runPackage ? {
+      package: runPackage,
+      outputs: runPackage.outputs
+    } : {},
     status
   };
 }
@@ -7220,18 +7242,6 @@ function playRunResultFromStatus(status, startedAt, fallbackRunId) {
     error: status.progress?.error ?? (status.status !== "completed" ? status.status : void 0)
   };
 }
-function playRunStatusFromState(state) {
-  return {
-    runId: state.runId,
-    status: state.status,
-    progress: {
-      status: state.status,
-      logs: state.logs,
-      ...state.error ? { error: state.error } : {}
-    },
-    ..."result" in state ? { result: state.result } : {}
-  };
-}
 var DeeplineClient = class _DeeplineClient {
   http;
   config;
@@ -7374,14 +7384,14 @@ var DeeplineClient = class _DeeplineClient {
   }
   compactSchema(schema) {
     if (!schema) return null;
-    const fields = Array.isArray(schema.fields) ? schema.fields.map(
+    const fields2 = Array.isArray(schema.fields) ? schema.fields.map(
       (field) => field && typeof field === "object" ? {
         name: String(field.name ?? ""),
         type: field.type ?? void 0,
         required: field.required ?? void 0
       } : null
     ).filter((field) => Boolean(field?.name)) : [];
-    return fields.length > 0 ? { fields } : schema;
+    return fields2.length > 0 ? { fields: fields2 } : schema;
   }
   schemaMetadata(schema, key) {
     if (!isRecord7(schema)) return null;
@@ -7568,6 +7578,12 @@ var DeeplineClient = class _DeeplineClient {
       options.includeSearchDebug ? "true" : "false"
     );
     params.set("search_mode", options.searchMode ?? "v2");
+    if (options.limit !== void 0) {
+      params.set("limit", String(options.limit));
+    }
+    if (options.offset !== void 0) {
+      params.set("offset", String(options.offset));
+    }
     if (options.categories?.trim()) {
       params.set("categories", options.categories.trim());
     }
@@ -8629,9 +8645,18 @@ var DeeplineClient = class _DeeplineClient {
     }
     const query = params.size > 0 ? `?${params.toString()}` : "";
     const response = await this.http.get(
-      `/api/v2/runs/${encodeURIComponent(runId)}${query}`
+      `/api/v2/runs/${encodeURIComponent(runId)}${query}`,
+      { headers: { "x-deepline-run-status": "1" } }
     );
+    const responseRunStatus = isPlayRunPackage(response) ? response.runStatus : isPlayRunPackage(response.package) ? response.package.runStatus : response.runStatus;
+    const responseOverview = isPlayRunPackage(response) ? response.overview : isPlayRunPackage(response.package) ? response.package.overview : response.overview;
     const status = normalizePlayStatus(response);
+    if (isRecord7(responseRunStatus)) {
+      status.runStatus = responseRunStatus;
+    }
+    if (isRecord7(responseOverview)) {
+      status.overview = responseOverview;
+    }
     if (options?.failedLogs !== true || status.status !== "failed") {
       return status;
     }
@@ -8672,7 +8697,10 @@ var DeeplineClient = class _DeeplineClient {
       }
     };
   }
-  /** Read only the bounded scalar projection; does not hydrate the run package. */
+  /** Fetch only the legacy scalar lifecycle status for a run.
+   *
+   * @deprecated Use `client.runs.get(runId)` for the canonical run read.
+   */
   async getRunLifecycleStatus(runId) {
     const response = await this.http.get(
       `/api/v2/runs/${encodeURIComponent(runId)}/status`
@@ -8848,9 +8876,7 @@ var DeeplineClient = class _DeeplineClient {
       if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
         continue;
       }
-      return await this.getRunStatus(status.runId || runId).catch(
-        () => state.latest ?? playRunStatusFromState(state)
-      );
+      return await this.getRunStatus(status.runId || runId);
     }
     if (options?.signal?.aborted) {
       throw new DeeplineError("Run observation aborted.", void 0, "ABORTED");
@@ -8901,6 +8927,7 @@ var DeeplineClient = class _DeeplineClient {
     for (; ; ) {
       const connectedAt = Date.now();
       let sawEvent = false;
+      let terminalRunId = null;
       let endedReason = "stream window ended before a terminal event";
       try {
         for await (const event of this.streamPlayRunEvents(runId, {
@@ -8913,9 +8940,8 @@ var DeeplineClient = class _DeeplineClient {
           if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
             continue;
           }
-          return await this.getRunStatus(status.runId || runId).catch(
-            () => state.latest ?? playRunStatusFromState(state)
-          );
+          terminalRunId = status.runId || runId;
+          break;
         }
       } catch (error) {
         if (options?.signal?.aborted || !isTransientPlayStreamError(error)) {
@@ -8923,15 +8949,11 @@ var DeeplineClient = class _DeeplineClient {
         }
         endedReason = error instanceof Error ? error.message : String(error);
       }
-      let refreshed = null;
-      try {
-        refreshed = await this.getRunStatus(runId);
-      } catch (error) {
-        if (!isTransientPlayStreamError(error)) {
-          throw error;
-        }
+      if (terminalRunId) {
+        return await this.getRunStatus(terminalRunId);
       }
-      if (refreshed && TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
+      const refreshed = await this.getRunStatus(runId);
+      if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
         return refreshed;
       }
       if (sawEvent || Date.now() - connectedAt >= STREAM_HEALTHY_CONNECTION_MS) {
@@ -9220,6 +9242,26 @@ var DeeplineClient = class _DeeplineClient {
       hasMore: Boolean(response.pagination?.hasMore ?? response.hasMore)
     };
   }
+  /** Read definition-level settings, independently of code revisions. */
+  async getPlaySettings(playName) {
+    return this.http.get(
+      `/api/v2/plays/${encodeURIComponent(playName)}/settings`
+    );
+  }
+  /** Retry-safe field patch; omitted fields retain their current value. */
+  async updatePlaySettings(playName, patch) {
+    return this.http.patch(
+      `/api/v2/plays/${encodeURIComponent(playName)}/settings`,
+      patch
+    );
+  }
+  /** List one bounded page of existing Play locations; continue with cursor. */
+  async listPlaySettingsPaths(options = {}) {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(options))
+      if (value !== void 0) query.set(key, String(value));
+    return this.http.get(`/api/v2/plays/settings/paths?${query}`);
+  }
   /** Set whether an org-owned Play sorts before unpinned Plays. */
   async setPlayPinned(playName, pinned) {
     return this.http.post(`/api/v2/plays/${encodeURIComponent(playName)}/pin`, {
@@ -10837,6 +10879,7 @@ async function checkSdkCompatibility(baseUrl, options = {}) {
     const response = await fetch(url, {
       method: "GET",
       headers: {
+        ...deploymentProtectionHeaders(),
         "User-Agent": `deepline-ts-sdk/${SDK_VERSION}`,
         "X-Deepline-SDK-Version": SDK_VERSION,
         "X-Deepline-API-Major": String(SDK_API_MAJOR),
@@ -11713,8 +11756,8 @@ function resolvePendingAuthClaimForResume(baseUrl, requestedScope) {
     const claim = readPendingAuthClaim(baseUrl, requestedScope);
     return { claim, scope: claim?.scope ?? requestedScope };
   }
-  const folder = readPendingAuthClaim(baseUrl, "folder");
-  if (folder) return { claim: folder, scope: folder.scope };
+  const folder2 = readPendingAuthClaim(baseUrl, "folder");
+  if (folder2) return { claim: folder2, scope: folder2.scope };
   const global = readPendingAuthClaim(baseUrl, "global");
   return { claim: global, scope: global?.scope ?? "global" };
 }
@@ -15528,14 +15571,14 @@ function customerDbColumnNames(result) {
 function errorMessage(value) {
   return value instanceof Error ? value.message : String(value ?? "");
 }
-function resolveDbQuerySql(rawSql, readFile7 = (path) => readFileSync7(path, "utf8")) {
+function resolveDbQuerySql(rawSql, readFile8 = (path) => readFileSync7(path, "utf8")) {
   const value = rawSql.trim();
   if (!value.startsWith("@")) return value;
   const filePath = value.slice(1).trim();
   if (!filePath) {
     throw new Error("--sql @file requires a file path after `@`.");
   }
-  return readFile7(resolve6(filePath)).trim();
+  return readFile8(resolve6(filePath)).trim();
 }
 function collectErrorText(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -15906,7 +15949,7 @@ import {
   lstat as lstat2,
   mkdir as mkdir5,
   mkdtemp as mkdtemp3,
-  readFile as readFile4,
+  readFile as readFile5,
   realpath as realpath4,
   rename as rename2,
   rm as rm3,
@@ -15914,9 +15957,335 @@ import {
   writeFile as writeFile4
 } from "fs/promises";
 import { homedir as homedir6, tmpdir as tmpdir5 } from "os";
-import { basename as basename4, dirname as dirname11, extname as extname3, join as join14, resolve as resolve13 } from "path";
+import { basename as basename4, dirname as dirname11, extname as extname3, join as join15, resolve as resolve13 } from "path";
 import { Option as Option2 } from "commander";
 
+// ../plays/settings-contract.ts
+import { z } from "zod";
+function formatPlaySettingsError(error) {
+  if (error instanceof z.ZodError)
+    return [...new Set(error.issues.map((issue) => issue.message))].join(" ");
+  return error instanceof Error ? error.message : String(error);
+}
+var PLAY_LOCATION_ROOTS = [
+  {
+    value: "person",
+    label: "Personal",
+    description: "The creator\u2019s personal root, displayed as their name followed by \u201C\u2019s team\u201D."
+  },
+  {
+    value: "team",
+    label: "Team library",
+    description: "The shared team library. Publishing moves personal locations here, keeping their folders."
+  }
+];
+var folder = z.string().min(1).max(128).refine(
+  (value) => value === value.trim() && value !== "." && value !== ".." && !/[\\/\u0000-\u001f\u007f]/u.test(value),
+  "Folder names must be trimmed, cannot be . or .., and cannot contain slashes or control characters."
+);
+var playPathSchema = z.union([
+  z.null(),
+  z.object({
+    root: z.enum(["person", "team"]),
+    folders: z.array(folder).max(16).default([])
+  }).strict()
+]).transform(
+  (path) => path?.root === "person" && path.folders.length === 0 ? null : path
+);
+function parsePlayPath(value) {
+  const [root, ...parts] = value.split("/");
+  if (!PLAY_LOCATION_ROOTS.some((option) => option.value === root)) {
+    throw new Error(
+      "Path must start with person or team. Example: person/Research/ICP."
+    );
+  }
+  let folders;
+  try {
+    folders = parts.map(decodeURIComponent);
+  } catch {
+    throw new Error(
+      "Path contains an invalid percent escape. Encode a literal % as %25."
+    );
+  }
+  return playPathSchema.parse({ root, folders });
+}
+function formatPlayPath(path) {
+  return path === null ? "person" : [path.root, ...path.folders.map(encodeURIComponent)].join("/");
+}
+function personalPlayRootLabel(ownerName) {
+  const name = ownerName?.trim();
+  return name ? `${name.split(/\s+/)[0]}\u2019s team` : "Personal";
+}
+function displayPlayPath(path, ownerName) {
+  return [
+    path?.root === "team" ? "Team library" : personalPlayRootLabel(ownerName),
+    ...path?.folders ?? []
+  ].join(" / ");
+}
+var PLAY_SETTING_FIELDS = {
+  path: {
+    schema: playPathSchema.default(null).describe(
+      "Play location. Null means the creator\u2019s personal root. Publishing moves it into Team library, preserving folders."
+    ),
+    label: "Location",
+    description: "Organize this Play in the creator\u2019s personal root or Team library. Publishing moves it to Team library and keeps its folders. Workspace sharing permissions apply in both roots.",
+    get defaultValue() {
+      return this.schema.parse(void 0);
+    },
+    cli: {
+      valueSyntax: "person[/folder/\u2026] | team[/folder/\u2026] | null",
+      examples: [
+        "person",
+        "person/Research/ICP",
+        "team",
+        "team/Research",
+        "null"
+      ],
+      parse: (value) => value === "null" ? null : parsePlayPath(value),
+      format: formatPlayPath
+    },
+    ui: { control: "play-location-picker" }
+  }
+};
+var playSettingsSchema = z.object(
+  Object.fromEntries(
+    Object.entries(PLAY_SETTING_FIELDS).map(([key, field]) => [
+      key,
+      field.schema
+    ])
+  )
+).passthrough();
+var playSettingsPatchSchema = z.object(
+  Object.fromEntries(
+    Object.entries(PLAY_SETTING_FIELDS).map(([key, field]) => [
+      key,
+      field.schema.unwrap().optional()
+    ])
+  )
+).strict().refine(
+  (patch) => Object.keys(patch).length > 0,
+  "Supply at least one setting."
+);
+function parsePlaySettings(value) {
+  return playSettingsSchema.parse(value);
+}
+var DEFAULT_PLAY_SETTINGS = parsePlaySettings({});
+
+// src/cli/commands/plays-settings.ts
+var fields = Object.entries(PLAY_SETTING_FIELDS);
+var help = `
+Settings live on the Play definition. Edits preserve code revisions.
+New Plays start at person (the creator\u2019s personal root, e.g. Chirag\u2019s team).
+Publishing moves a Play into team and keeps its folders. Workspace sharing
+permissions apply in both roots. Folder paths are independent of your cwd.
+
+Setting names and values:
+${fields.map(([key, field]) => `  ${key}: ${field.schema.description}
+    Values: ${field.cli.valueSyntax}
+    Default: ${JSON.stringify(field.defaultValue)} (${field.cli.format(field.defaultValue)})`).join("\n")}
+
+Roots:
+${PLAY_LOCATION_ROOTS.map((root) => `  ${root.value}: ${root.description}`).join("\n")}
+
+Examples:
+  deepline plays settings describe --name path --json
+  deepline plays settings get --play company-research --json
+  deepline plays settings get --play company-research --name path
+  deepline plays settings set --play company-research --name path --value person/Research/ICP
+  deepline plays settings set --play company-research --name path --value team/Research
+  deepline plays settings reset --play company-research --name path
+  deepline plays settings paths --root team --json
+
+Quote values containing spaces. Use percent escapes for literal % characters.
+`;
+function resolveField(key, command) {
+  const entry = fields.find(([name]) => name === key);
+  if (!entry)
+    command.error(
+      `Unknown --name ${JSON.stringify(key)}. Available settings: ${fields.map(([name]) => name).join(", ")}. Run deepline plays settings describe.`,
+      { exitCode: 2 }
+    );
+  return entry[1];
+}
+function printSettings(result, json2, name) {
+  const selected = fields.filter(([key]) => !name || key === name);
+  printCommandEnvelope(
+    {
+      ...result,
+      settings: Object.fromEntries(
+        selected.map(([key]) => [
+          key,
+          result.settings[key]
+        ])
+      ),
+      render: {
+        sections: [
+          {
+            title: "Play settings",
+            lines: selected.map(
+              ([key, field]) => `${field.label}: ${key === "path" ? displayPlayPath(result.settings.path, result.ownerName) : field.cli.format(result.settings[key])} (${field.cli.format(result.settings[key])})`
+            )
+          }
+        ]
+      }
+    },
+    { json: json2 }
+  );
+}
+function registerPlaySettingsCommands(plays) {
+  const settings = plays.command("settings").description("Read and change Play settings by name and value.").exitOverride((error) => {
+    if (error.exitCode !== 0) error.exitCode = 2;
+    throw error;
+  }).addHelpText("after", help);
+  settings.command("describe").usage("[--name <setting>] [options]").description(
+    "List setting names, values, examples and defaults; no authentication required."
+  ).option(
+    "--name <setting>",
+    `Describe one setting. Available: ${fields.map(([key]) => key).join(", ")}`
+  ).option("--json", "Emit JSON; automatic when piped").addHelpText("after", help).action((options, command) => {
+    if (options.name !== void 0) resolveField(options.name, command);
+    const descriptions = fields.filter(([name]) => !options.name || options.name === name).map(([name, field]) => ({
+      key: name,
+      label: field.label,
+      description: field.schema.description ?? field.description,
+      default: field.defaultValue,
+      defaultText: field.cli.format(field.defaultValue),
+      valueSyntax: field.cli.valueSyntax,
+      examples: field.cli.examples
+    }));
+    printCommandEnvelope(
+      {
+        fields: descriptions,
+        render: {
+          sections: descriptions.map((field) => ({
+            title: field.key,
+            lines: [
+              field.description,
+              `Values: ${field.valueSyntax}`,
+              `Default: ${JSON.stringify(field.default)} (${field.defaultText})`,
+              `Examples: ${field.examples.join(", ")}`
+            ]
+          }))
+        }
+      },
+      { json: options.json }
+    );
+  });
+  settings.command("get").usage("--play <play> [--name <setting>] [options]").description("Read all settings, or one setting selected with --name.").requiredOption("--play <play>", "Play to read").option(
+    "--name <setting>",
+    `Read one setting. Available: ${fields.map(([key]) => key).join(", ")}`
+  ).option("--json", "Emit JSON; automatic when piped").addHelpText("after", help).action(
+    async (options, command) => {
+      if (options.name !== void 0) resolveField(options.name, command);
+      printSettings(
+        await new DeeplineClient().getPlaySettings(options.play),
+        options.json,
+        options.name
+      );
+    }
+  );
+  const set = settings.command("set").usage("--play <play> --name <setting> --value <value> [options]").requiredOption("--play <play>", "Play to update").requiredOption(
+    "--name <setting>",
+    `Setting name. Available: ${fields.map(([key]) => key).join(", ")}`
+  ).requiredOption(
+    "--value <value>",
+    "New value; see settings describe --name <setting>"
+  ).description("Set one setting without creating or publishing a revision.");
+  const reset = settings.command("reset").usage("--play <play> --name <setting> [options]").requiredOption("--play <play>", "Play to update").requiredOption(
+    "--name <setting>",
+    `Setting name. Available: ${fields.map(([key]) => key).join(", ")}`
+  ).description("Reset one setting to its schema default.");
+  const change = async (command, play, key, value, options, resetting) => {
+    const field = resolveField(key, command);
+    let patch;
+    try {
+      patch = playSettingsPatchSchema.parse({
+        [key]: resetting ? field.defaultValue : field.cli.parse(value)
+      });
+    } catch (error) {
+      command.error(
+        `Invalid --value for --name ${key}: ${formatPlaySettingsError(error)} Values: ${field.cli.valueSyntax}.`,
+        { exitCode: 2 }
+      );
+    }
+    if (options.dryRun) {
+      printCommandEnvelope(
+        {
+          dryRun: true,
+          play,
+          patch,
+          render: {
+            sections: [
+              {
+                title: "Planned settings patch",
+                lines: Object.entries(patch).map(
+                  ([name, setting]) => `${name}: ${JSON.stringify(setting)}`
+                )
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+      return;
+    }
+    printSettings(
+      await new DeeplineClient().updatePlaySettings(play, patch),
+      options.json
+    );
+  };
+  for (const [command, resetting] of [
+    [set, false],
+    [reset, true]
+  ])
+    command.option("--dry-run", "Show the patch without changing settings").option("--json", "Emit JSON; automatic when piped").addHelpText("after", help).action(
+      (options) => change(
+        command,
+        options.play,
+        options.name,
+        options.value,
+        options,
+        resetting
+      )
+    );
+  settings.command("paths").description("List existing locations (one bounded page).").option("--root <person|team>", "Filter by root").option("--limit <n>", "Plays to inspect, 1\u2013100", "50").option("--cursor <cursor>", "Continue from a previous page").option("--json", "Emit JSON; automatic when piped").addHelpText("after", help).action(
+    async (options, command) => {
+      const limit = Number(options.limit);
+      if (options.root !== void 0 && options.root !== "person" && options.root !== "team" || !Number.isInteger(limit) || limit < 1 || limit > 100)
+        command.error(
+          "--root must be person or team; --limit must be 1\u2013100.",
+          { exitCode: 2 }
+        );
+      const page = await new DeeplineClient().listPlaySettingsPaths({
+        root: options.root,
+        limit,
+        cursor: options.cursor
+      });
+      const nextCommand = page.hasMore ? `deepline plays settings paths --cursor '${page.cursor}'${options.root ? ` --root ${options.root}` : ""} --json` : null;
+      printCommandEnvelope(
+        {
+          ...page,
+          nextCommand,
+          render: {
+            sections: [
+              {
+                title: "Play locations",
+                lines: [
+                  ...page.paths.map(
+                    (item) => `${displayPlayPath(item.path, item.ownerName)} (${formatPlayPath(item.path)}) \u2014 ${item.playName}`
+                  ),
+                  ...nextCommand ? [`More: ${nextCommand}`] : []
+                ]
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+    }
+  );
+}
+
 // src/cli/commands/play.ts
 import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
 import {
@@ -15940,7 +16309,7 @@ import {
   basename as basename3,
   dirname as dirname10,
   isAbsolute as isAbsolute5,
-  join as join13,
+  join as join14,
   relative as relative5,
   resolve as resolve12
 } from "path";
@@ -16560,8 +16929,8 @@ function readCsvHeaderFields(csvPath, sample) {
     skip_empty_lines: false
   });
   const firstRecord = Array.isArray(records) ? records[0] : null;
-  const fields = Array.isArray(firstRecord) ? firstRecord.map((field) => String(field ?? "").trim()).filter(Boolean) : [];
-  const uniqueFields = [...new Set(fields)];
+  const fields2 = Array.isArray(firstRecord) ? firstRecord.map((field) => String(field ?? "").trim()).filter(Boolean) : [];
+  const uniqueFields = [...new Set(fields2)];
   if (uniqueFields.length === 0) {
     throw new PlayBootstrapUsageError(
       `Could not read a header row from --from csv:${csvPath}.`
@@ -17650,6 +18019,45 @@ Examples:
   });
 }
 
+// src/cli/commands/plays/run-history.ts
+async function handleRunsHistory(options) {
+  const query = new URLSearchParams();
+  if (options.cursor) query.set("cursor", options.cursor);
+  if (options.org) query.set("orgId", options.org);
+  if (options.limit !== void 0) {
+    const limit = Number(options.limit);
+    if (!/^\d+$/.test(options.limit) || !Number.isSafeInteger(limit) || limit < 1) {
+      throw new Error("--limit must be a positive integer.");
+    }
+    query.set("limit", String(limit));
+  }
+  const search = query.toString();
+  const page = await new HttpClient(resolveConfig()).get(
+    `/api/v2/dashboard/runs-history${search ? `?${search}` : ""}`
+  );
+  const lines = page.runs.map(
+    (run) => `${run.workflowName} \xB7 ${run.status} \xB7 ${run.runId}`
+  );
+  if (lines.length === 0) lines.push("No runs found on this page.");
+  if (page.hasMore) lines.push(`Next cursor: ${page.nextCursor}`);
+  printCommandEnvelope(
+    { ...page, render: { sections: [{ title: "Run history", lines }] } },
+    options.json ? { json: true } : {}
+  );
+}
+function registerRunHistoryCommand(runs) {
+  runs.command("history").description("Page workspace run history.").option(
+    "--cursor <cursor>",
+    "Opaque nextCursor returned by the previous page"
+  ).option("--limit <count>", "Maximum runs on this page").option(
+    "--org <id>",
+    "Workspace ID (must match the authenticated workspace)"
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").addHelpText(
+    "after",
+    "\nUse the opaque --cursor returned by the previous page to continue.\n\nExample:\n  deepline runs history --limit 100 --json\n"
+  ).action(handleRunsHistory);
+}
+
 // src/plays/bundle-play-file.ts
 import { tmpdir as tmpdir3 } from "os";
 import { dirname as dirname9, join as join9, resolve as resolve10 } from "path";
@@ -20554,7 +20962,7 @@ function recordCliTrace(event) {
   process.stderr.write(`[cli-trace] ${JSON.stringify(payload)}
 `);
 }
-async function traceCliSpan(phase, fields, run) {
+async function traceCliSpan(phase, fields2, run) {
   if (!isCliTraceEnabled()) {
     return run();
   }
@@ -20565,7 +20973,7 @@ async function traceCliSpan(phase, fields, run) {
       phase,
       ms: Date.now() - startedAt,
       ok: true,
-      ...fields
+      ...fields2
     });
     return result;
   } catch (error) {
@@ -20574,7 +20982,7 @@ async function traceCliSpan(phase, fields, run) {
       ms: Date.now() - startedAt,
       ok: false,
       error: error instanceof Error ? error.message : String(error),
-      ...fields
+      ...fields2
     });
     throw error;
   }
@@ -21223,10 +21631,10 @@ function normalizeFixtureScopeValue(value, maxLength) {
 import { randomUUID as randomUUID3 } from "crypto";
 import { mkdtemp as mkdtemp2, realpath as realpath3, rm as rm2 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join12, resolve as resolve11 } from "path";
+import { join as join13, resolve as resolve11 } from "path";
 
 // ../plays/deploy/run-deployment.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { mkdir as mkdir4, mkdtemp, rm } from "fs/promises";
 
 // ../plays/deployment-status.ts
@@ -21335,6 +21743,21 @@ var DeployApiClient = class {
       body: { names }
     });
   }
+  monitors(action, entries) {
+    return this.request({
+      method: "POST",
+      path: this.deploymentPath("/monitors"),
+      body: { action, entries }
+    });
+  }
+  monitorJob(jobId, monitorKey) {
+    return this.request({
+      method: "GET",
+      path: this.deploymentPath(
+        `/monitors?jobId=${encodeURIComponent(jobId)}&monitorKey=${encodeURIComponent(monitorKey)}`
+      )
+    });
+  }
   compileManifest(input2) {
     return this.request({
       method: "POST",
@@ -21387,7 +21810,8 @@ var import_picomatch = __toESM(require_picomatch2(), 1);
 import { readdir, readFile as readFile3, stat as stat3 } from "fs/promises";
 import { join as join10, relative as relative4 } from "path";
 var DEFAULT_PLAY_GLOBS = ["**/*.play.ts"];
-var MAX_DISCOVERED_PLAY_FILES = 200;
+var DEFAULT_MONITOR_GLOBS = ["**/*.monitor.json"];
+var MAX_DISCOVERED_FILES = 200;
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -21401,9 +21825,26 @@ var DeeplineManifestError = class extends Error {
     this.name = "DeeplineManifestError";
   }
 };
+function readGlobs(value, field) {
+  if (!Array.isArray(value) || field === "plays" && value.length === 0 || !value.every((glob) => typeof glob === "string" && glob.trim().length > 0)) {
+    throw new DeeplineManifestError(
+      `deepline.json "${field}" must be ${field === "plays" ? "a non-empty" : "an"} array of glob strings.`
+    );
+  }
+  const globs = value.map((glob) => glob.trim().replace(/^\.\//, ""));
+  if (globs.some((glob) => glob.startsWith("/") || glob.includes(".."))) {
+    throw new DeeplineManifestError(
+      `deepline.json "${field}" globs must be relative and must not contain "..".`
+    );
+  }
+  return globs;
+}
 function parseDeeplineManifest(raw) {
   if (raw === null) {
-    return { plays: DEFAULT_PLAY_GLOBS };
+    return {
+      plays: DEFAULT_PLAY_GLOBS,
+      monitors: DEFAULT_MONITOR_GLOBS
+    };
   }
   let parsed;
   try {
@@ -21417,24 +21858,14 @@ function parseDeeplineManifest(raw) {
     throw new DeeplineManifestError("deepline.json must be a JSON object.");
   }
   const record3 = parsed;
-  let plays = DEFAULT_PLAY_GLOBS;
-  if (record3.plays !== void 0) {
-    if (!Array.isArray(record3.plays) || record3.plays.length === 0 || !record3.plays.every(
-      (glob) => typeof glob === "string" && glob.trim().length > 0
-    )) {
-      throw new DeeplineManifestError(
-        'deepline.json "plays" must be a non-empty array of glob strings, e.g. ["plays/**/*.play.ts"].'
-      );
-    }
-    plays = record3.plays.map((glob) => glob.trim().replace(/^\.\//, ""));
-  }
-  if (plays.some((glob) => glob.startsWith("/") || glob.includes(".."))) {
-    throw new DeeplineManifestError(
-      'deepline.json "plays" globs must be relative and must not contain "..".'
-    );
-  }
+  const plays = record3.plays === void 0 ? DEFAULT_PLAY_GLOBS : readGlobs(record3.plays, "plays");
+  const monitors = record3.monitors === void 0 ? DEFAULT_MONITOR_GLOBS : readGlobs(record3.monitors, "monitors");
   const org = typeof record3.org === "string" && record3.org.trim() ? record3.org.trim() : void 0;
-  return { plays, ...org ? { org } : {} };
+  return {
+    plays,
+    monitors,
+    ...org ? { org } : {}
+  };
 }
 var DEFAULT_MANIFEST_FILE = "deepline.json";
 async function readDeeplineManifest(projectRoot, manifestFile = DEFAULT_MANIFEST_FILE) {
@@ -21464,7 +21895,7 @@ async function readDeeplineManifest(projectRoot, manifestFile = DEFAULT_MANIFEST
     throw error;
   }
 }
-async function discoverPlayFiles(input2) {
+async function discoverDeploymentFiles(input2) {
   const matchers = input2.globs.map((glob) => (0, import_picomatch.default)(glob));
   const found = [];
   async function walk(dir) {
@@ -21481,9 +21912,9 @@ async function discoverPlayFiles(input2) {
       const relativePath = relative4(input2.projectRoot, absolute);
       if (matchers.some((match) => match(relativePath))) {
         found.push(relativePath);
-        if (found.length > MAX_DISCOVERED_PLAY_FILES) {
+        if (found.length > MAX_DISCOVERED_FILES) {
           throw new DeeplineManifestError(
-            `deepline.json globs matched more than ${MAX_DISCOVERED_PLAY_FILES} play files. Tighten the globs.`
+            `deepline.json globs matched more than ${MAX_DISCOVERED_FILES} files. Tighten the globs.`
           );
         }
       }
@@ -21498,6 +21929,39 @@ async function discoverPlayFiles(input2) {
   await walk(input2.projectRoot);
   return found.sort();
 }
+var discoverPlayFiles = discoverDeploymentFiles;
+
+// ../plays/deploy/monitor-files.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join11 } from "path";
+async function readMonitorFiles(input2) {
+  const files = await discoverDeploymentFiles(input2);
+  if (files.length > 100) {
+    throw new DeeplineManifestError(
+      "A deployment may contain at most 100 monitor definitions. Split the repository into multiple linked targets."
+    );
+  }
+  return Promise.all(
+    files.map(async (file) => {
+      const sourcePath = input2.rootDirectory ? `${input2.rootDirectory}/${file}` : file;
+      const raw = await readFile4(join11(input2.projectRoot, file), "utf8");
+      try {
+        return { file: sourcePath, definition: JSON.parse(raw) };
+      } catch {
+        throw new DeeplineManifestError(
+          `${sourcePath} must contain a monitor definition as valid JSON.`
+        );
+      }
+    })
+  );
+}
+function monitorDeploymentSummary(outcomes) {
+  return outcomes.map(
+    (outcome) => `- Monitor \`${outcome.key}\` (\`${outcome.file}\`): ${outcome.status}${outcome.credits != null ? ` (${outcome.credits} Deepline credits)` : ""}${outcome.jobId ? ` \u2014 job \`${outcome.jobId}\`` : ""}${outcome.error ? `
+  - ${outcome.error}` : ""}${outcome.warning ? `
+  - :warning: ${outcome.warning}` : ""}`
+  ).join("\n");
+}
 
 // ../plays/play-reference.ts
 var PREBUILT_PLAY_NAMESPACE = "prebuilt";
@@ -21713,12 +22177,15 @@ async function runDeployment(params, hooks) {
     }
   }
   const buildSeconds = () => Math.max(0, (Date.now() - startedAt) / 1e3);
+  let monitorOutcomes = [];
+  const monitorResults = () => monitorOutcomes.length > 0 ? { monitors: monitorOutcomes } : {};
+  const monitorRunResult = () => monitorOutcomes.length > 0 ? { monitorOutcomes } : {};
   const finishFailed = async (input2) => {
     try {
       await setStatus({
         status: "failed",
         error: input2.error.slice(0, 2e3),
-        results: { plays: input2.outcomes },
+        results: { plays: input2.outcomes, ...monitorResults() },
         buildSeconds: buildSeconds(),
         ...input2.checkRunId ? { checkRunId: input2.checkRunId } : {}
       });
@@ -21737,15 +22204,18 @@ async function runDeployment(params, hooks) {
     return {
       finalStatus: "failed",
       outcomes: input2.outcomes,
+      ...monitorRunResult(),
       checkRunId: input2.checkRunId
     };
   };
   const finishSucceeded = async (outcomes, checkRun) => {
-    const finalStatus = outcomes.some((outcome) => outcome.warning) ? "succeeded_with_warnings" : "succeeded";
+    const finalStatus = [...outcomes, ...monitorOutcomes].some(
+      (outcome) => outcome.warning
+    ) ? "succeeded_with_warnings" : "succeeded";
     try {
       await setStatus({
         status: finalStatus,
-        results: { plays: outcomes },
+        results: { plays: outcomes, ...monitorResults() },
         buildSeconds: buildSeconds(),
         ...checkRun ? { checkRunId: checkRun.checkRunId } : {}
       });
@@ -21762,11 +22232,12 @@ async function runDeployment(params, hooks) {
     return {
       finalStatus,
       outcomes,
+      ...monitorRunResult(),
       checkRunId: checkRun?.checkRunId
     };
   };
   await mkdir4(hooks.workRoot, { recursive: true });
-  const workDir = await mkdtemp(join11(hooks.workRoot, "deploy-"));
+  const workDir = await mkdtemp(join12(hooks.workRoot, "deploy-"));
   const postCheck = async (postCheckOnce, input2) => {
     let lastError;
     for (let attempt = 0; ; attempt += 1) {
@@ -21842,7 +22313,7 @@ async function runDeployment(params, hooks) {
         await writeCheck({
           conclusion: "neutral",
           title: `Deployment ${stopped}`,
-          summary: "This deployment was stopped before it finished. Nothing from it went live."
+          summary: monitorOutcomes.some((outcome) => outcome.jobId) ? "This deployment was stopped before it finished. Monitor jobs already submitted may have changed live resources; inspect the jobs in its receipt." : "This deployment was stopped before it finished. Nothing from it went live."
         }).catch(() => void 0);
         throw revocation;
       });
@@ -21882,6 +22353,7 @@ async function runDeployment(params, hooks) {
         status: "superseded",
         error: `Branch ${deploymentBranch} is now at ${head?.slice(0, 12) ?? "<deleted>"}; this deployment's commit is no longer the head.`,
         buildSeconds: buildSeconds(),
+        ...monitorOutcomes.length > 0 ? { results: monitorResults() } : {},
         ...head ? { observedHeadSha: head } : {}
       });
       return { finalStatus: "superseded", outcomes: [] };
@@ -21891,16 +22363,28 @@ async function runDeployment(params, hooks) {
       if (superseded) return superseded;
     }
     const { repoRoot } = await source.open(workDir);
-    const projectRoot = target.rootDirectory ? join11(repoRoot, target.rootDirectory) : repoRoot;
+    const projectRoot = target.rootDirectory ? join12(repoRoot, target.rootDirectory) : repoRoot;
     const manifestFile = target.manifestPath || DEFAULT_MANIFEST_FILE;
     let manifest;
     let playFiles;
+    let monitorEntries;
     try {
       manifest = await readDeeplineManifest(projectRoot, manifestFile);
       playFiles = await discoverPlayFiles({
         projectRoot,
         globs: manifest.plays
       });
+      const discoveredMonitors = await readMonitorFiles({
+        projectRoot,
+        rootDirectory: target.rootDirectory,
+        globs: manifest.monitors
+      });
+      if (!project && discoveredMonitors.length > 0) {
+        throw new DeeplineManifestError(
+          "Monitor Git deployment requires a linked repository. Deploy individual monitor files with deepline monitors deploy --file."
+        );
+      }
+      monitorEntries = project && discoveredMonitors.length > 0 ? discoveredMonitors : void 0;
     } catch (error) {
       if (error instanceof DeeplineManifestError) {
         return await failWithCheck({
@@ -21925,7 +22409,28 @@ async function runDeployment(params, hooks) {
         });
       }
     }
-    if (playFiles.length === 0) {
+    if (monitorEntries !== void 0) {
+      const plan = await client2.monitors("plan", monitorEntries);
+      monitorOutcomes = plan.monitors;
+      const failed = monitorOutcomes.filter(
+        (outcome) => outcome.status === "failed"
+      );
+      if (failed.length > 0) {
+        return await failWithCheck({
+          title: "Monitor validation failed",
+          summary: monitorDeploymentSummary(monitorOutcomes),
+          error: `${failed.length} monitor definition(s) failed validation.`,
+          outcomes: [],
+          annotations: failed.map(
+            (outcome) => annotationForFailure({
+              file: outcome.file,
+              message: outcome.error ?? "Monitor validation failed."
+            })
+          )
+        });
+      }
+    }
+    if (playFiles.length === 0 && monitorOutcomes.length === 0) {
       const checkRun2 = await postCheckOrNull({
         conclusion: "neutral",
         title: "No plays matched",
@@ -21952,7 +22457,7 @@ async function runDeployment(params, hooks) {
       annotations.push(annotationForFailure({ file, message }));
     };
     for (const file of playFiles) {
-      const entryFile = join11(projectRoot, file);
+      const entryFile = join12(projectRoot, file);
       const result = await hooks.bundle(entryFile, {
         sourceIdentityRoot: projectRoot
       });
@@ -22058,7 +22563,7 @@ async function runDeployment(params, hooks) {
       if (superseded) return superseded;
     }
     await setStatus({ status: "publishing" }).catch(() => void 0);
-    const states = await client2.playsState(ordered.map((play) => play.name));
+    const states = ordered.length > 0 ? await client2.playsState(ordered.map((play) => play.name)) : { plays: [] };
     const stateByName = new Map(
       states.plays.map((play) => [play.name, play])
     );
@@ -22192,12 +22697,15 @@ async function runDeployment(params, hooks) {
       ).length;
       const checkRun2 = await postCheckOrNull({
         conclusion: "success",
-        title: `${ordered.length} play${ordered.length === 1 ? "" : "s"} validated and registered (not deployed)`,
+        title: monitorEntries !== void 0 ? `${ordered.length} play(s) validated and registered; ${monitorEntries.length} monitor(s) checked (not deployed)` : `${ordered.length} play${ordered.length === 1 ? "" : "s"} validated and registered (not deployed)`,
         ...annotations.length > 0 ? { annotations } : {},
-        summary: outcomes.map(
-          (outcome) => `- \`${outcome.name}\`: ${outcome.status}${outcome.version !== void 0 ? ` (v${outcome.version})` : ""}${outcome.sdkUpdated ? " \u2014 SDK updated" : ""}${outcome.warning ? `
+        summary: [
+          outcomes.map(
+            (outcome) => `- \`${outcome.name}\`: ${outcome.status}${outcome.version !== void 0 ? ` (v${outcome.version})` : ""}${outcome.sdkUpdated ? " \u2014 SDK updated" : ""}${outcome.warning ? `
   - :warning: ${outcome.warning}` : ""}`
-        ).join("\n")
+          ).join("\n"),
+          monitorDeploymentSummary(monitorOutcomes)
+        ].filter(Boolean).join("\n")
       });
       const result = await finishSucceeded(outcomes, checkRun2);
       console.info("[deploy-worker] PR registration complete", {
@@ -22211,6 +22719,51 @@ async function runDeployment(params, hooks) {
       const superseded = await supersedeIfHeadMoved();
       if (superseded) return superseded;
     }
+    if (monitorEntries !== void 0) {
+      monitorOutcomes = (await client2.monitors("apply", monitorEntries)).monitors;
+      await setStatus({
+        status: "publishing",
+        results: { plays: outcomes, ...monitorResults() }
+      });
+      const deadline = Date.now() + 10 * 6e4;
+      while (monitorOutcomes.some((outcome) => outcome.status === "applying")) {
+        if (Date.now() >= deadline) {
+          throw new RetryableDeploymentError(
+            "Monitor jobs are still reconciling. Retrying this deployment will resume the same jobs."
+          );
+        }
+        await new Promise((resolve22) => setTimeout(resolve22, 1e3));
+        for (let index = 0; index < monitorOutcomes.length; index += 1) {
+          const outcome = monitorOutcomes[index];
+          if (outcome.status !== "applying") continue;
+          if (!outcome.jobId) {
+            throw new Error(
+              `Monitor ${outcome.key} has no reconciliation job.`
+            );
+          }
+          const result = await client2.monitorJob(outcome.jobId, outcome.key);
+          const settled = result.monitors.find(
+            (monitor) => monitor.key === outcome.key && monitor.jobId === outcome.jobId
+          );
+          if (!settled) {
+            throw new Error(`Monitor job ${outcome.jobId} returned no result.`);
+          }
+          monitorOutcomes[index] = { ...outcome, ...settled };
+        }
+      }
+      if (monitorOutcomes.some(
+        (outcome) => outcome.status === "failed" || outcome.status === "planned"
+      )) {
+        return await failWithCheck({
+          title: "Monitor deployment failed",
+          summary: monitorDeploymentSummary(monitorOutcomes),
+          error: "Some monitor changes failed. Applied changes remain live; inspect the reported jobs before retrying.",
+          outcomes
+        });
+      }
+      const superseded = await supersedeIfHeadMoved();
+      if (superseded) return { ...superseded, ...monitorRunResult() };
+    }
     if (toPromote.length > 0) {
       try {
         const promotion = await client2.promote(toPromote);
@@ -22268,12 +22821,15 @@ async function runDeployment(params, hooks) {
     }
     const checkRun = await postCheckOrNull({
       conclusion: "success",
-      title: `Deployed ${outcomes.filter((o) => o.status === "promoted").length} play(s) (${outcomes.filter((o) => o.status === "unchanged").length} unchanged)`,
+      title: `Deployed ${outcomes.filter((o) => o.status === "promoted").length} play(s) (${outcomes.filter((o) => o.status === "unchanged").length} unchanged)${monitorEntries !== void 0 ? `; ${monitorOutcomes.filter((outcome) => outcome.status === "applied").length} monitor(s) applied` : ""}`,
       ...annotations.length > 0 ? { annotations } : {},
-      summary: outcomes.map(
-        (outcome) => `- \`${outcome.name}\`: ${outcome.status}${outcome.sdkUpdated ? " \u2014 SDK updated" : ""}${outcome.warning ? `
+      summary: [
+        outcomes.map(
+          (outcome) => `- \`${outcome.name}\`: ${outcome.status}${outcome.sdkUpdated ? " \u2014 SDK updated" : ""}${outcome.warning ? `
   - :warning: ${outcome.warning}` : ""}`
-      ).join("\n")
+        ).join("\n"),
+        monitorDeploymentSummary(monitorOutcomes)
+      ].filter(Boolean).join("\n")
     });
     return await finishSucceeded(outcomes, checkRun);
   } catch (error) {
@@ -22319,6 +22875,7 @@ async function runDeployment(params, hooks) {
     await setStatus({
       status: "failed",
       error: message.slice(0, 2e3),
+      ...monitorOutcomes.length > 0 ? { results: monitorResults() } : {},
       buildSeconds: buildSeconds(),
       ...checkRunId ? { checkRunId } : {}
     }).catch(() => void 0);
@@ -22400,7 +22957,7 @@ async function handlePlaysDeploy(directory, options) {
     ...options.commit ? { commit: options.commit } : {}
   });
   const { bundleDeployPlayFile } = await loadPlayBundler();
-  const workRoot = await mkdtemp2(join12(tmpdir4(), "deepline-deploy-"));
+  const workRoot = await mkdtemp2(join13(tmpdir4(), "deepline-deploy-"));
   const consoleInfo = console.info;
   console.info = console.error;
   try {
@@ -22418,6 +22975,7 @@ async function handlePlaysDeploy(directory, options) {
           },
           {
             bundle: bundleDeployPlayFile,
+            fetchImpl: fetchWithDeploymentProtection,
             // The plays are already here: "opening" the source is naming it.
             openSource: async () => ({
               open: async () => ({ repoRoot: root })
@@ -22801,10 +23359,22 @@ function renderDeploymentPlayLines(results) {
     ];
   });
 }
+function renderDeploymentMonitorLines(results) {
+  const monitors = results?.monitors;
+  if (!Array.isArray(monitors)) return [];
+  return monitors.flatMap((monitor) => [
+    `${monitor.key ?? "?"}${monitor.file ? ` (${monitor.file})` : ""} - ${monitor.status ?? "?"}`,
+    ...monitor.jobId ? [`  job: ${monitor.jobId}`] : [],
+    ...monitor.credits != null ? [`  Deepline credits: ${monitor.credits}`] : [],
+    ...monitor.error ? [`  error: ${monitor.error}`] : [],
+    ...monitor.warning ? [`  warning: ${monitor.warning}`] : []
+  ]);
+}
 async function handleDeploymentGet(id, options) {
   const { http } = getAuthedHttpClient();
   const payload = await http.get(`/api/v2/deployments/${encodeURIComponent(id)}`);
   const playLines = renderDeploymentPlayLines(payload.deployment.results);
+  const monitorLines = renderDeploymentMonitorLines(payload.deployment.results);
   const repository = payload.project?.repoFullName ?? payload.deployment.repoFullName;
   printCommandEnvelope(
     {
@@ -22816,7 +23386,8 @@ async function handleDeploymentGet(id, options) {
             title: `deployment ${payload.deployment.id}${repository ? ` (${repository})` : ""}`,
             lines: [renderDeployment(payload.deployment)]
           },
-          ...playLines.length ? [{ title: "plays", lines: playLines }] : []
+          ...playLines.length ? [{ title: "plays", lines: playLines }] : [],
+          ...monitorLines.length ? [{ title: "monitors", lines: monitorLines }] : []
         ]
       }
     },
@@ -23022,7 +23593,7 @@ async function pathExistsIncludingSymlink(path) {
   }
 }
 function runIdFileTempPath(destination) {
-  return join13(
+  return join14(
     dirname10(destination),
     `.${basename3(destination)}.${process.pid}.${randomUUID4()}.tmp`
   );
@@ -23129,7 +23700,7 @@ async function writePlayRunIdFile(destination, runId, options = {}) {
     await removeRunIdTempFile(tempPath);
   }
 }
-function traceCliSync(phase, fields, run) {
+function traceCliSync(phase, fields2, run) {
   const startedAt = Date.now();
   try {
     const result = run();
@@ -23137,7 +23708,7 @@ function traceCliSync(phase, fields, run) {
       phase,
       ms: Date.now() - startedAt,
       ok: true,
-      ...fields
+      ...fields2
     });
     return result;
   } catch (error) {
@@ -23146,7 +23717,7 @@ function traceCliSync(phase, fields, run) {
       ms: Date.now() - startedAt,
       ok: false,
       error: error instanceof Error ? error.message : String(error),
-      ...fields
+      ...fields2
     });
     throw error;
   }
@@ -24470,7 +25041,8 @@ function formatProgressCounts(input2) {
     Math.min(100, Math.round(completed / total * 100))
   );
   const failed = typeof input2.failed === "number" && Number.isFinite(input2.failed) && input2.failed > 0 ? `, failed ${formatInteger(input2.failed)}` : "";
-  return `${formatInteger(completed)}/${formatInteger(total)} (${percent}%)${failed}`;
+  const completedLabel = typeof input2.failed === "number" ? "successful " : "";
+  return `${completedLabel}${formatInteger(completed)}/${formatInteger(total)} (${percent}%)${failed}`;
 }
 function formatProgressMessageSuffix(input2) {
   const message = typeof input2.message === "string" ? input2.message.trim() : "";
@@ -25356,8 +25928,8 @@ function formatPlayLogLine(rawLine, status, state) {
     if (!logLevelReaches("info", state.logLevel ?? "info")) {
       return null;
     }
-    const [, rows, fields, namespace, cached, pending] = mapStart;
-    return `${prefix}map ${sourceLabelForNamespace(namespace)}: ${formatInteger(Number(rows))} rows, ${fields} fields, ${formatInteger(Number(cached))} cached, ${formatInteger(Number(pending))} pending`;
+    const [, rows, fields2, namespace, cached, pending] = mapStart;
+    return `${prefix}map ${sourceLabelForNamespace(namespace)}: ${formatInteger(Number(rows))} rows, ${fields2} fields, ${formatInteger(Number(cached))} cached, ${formatInteger(Number(pending))} pending`;
   }
   const mapDone = message.match(
     /^Map completed: (\d+) results \((\d+) executed, (\d+) already satisfied\)$/
@@ -26411,6 +26983,54 @@ function buildRunActivityTextLines(run) {
   if (observedAt) lines.push(`  observed: ${observedAt}`);
   return lines;
 }
+function formatObservedRunCounter(value) {
+  const counter = readRecord(value);
+  const count = counter?.value;
+  if (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0) {
+    return "unknown";
+  }
+  return counter?.confirmed === true ? formatInteger(count) : `${formatInteger(count)} observed`;
+}
+function buildRunStatusEvidenceTextLines(packaged) {
+  const evidence = readRecord(packaged.runStatus);
+  if (!evidence || evidence.available !== true) return [];
+  const calls = readRecord(evidence.calls);
+  const lines = [];
+  if (calls) {
+    lines.push(
+      `  calls: ${formatObservedRunCounter(calls.logicalCalls)} logical, ${formatObservedRunCounter(calls.toolDispatches)} tool dispatches, ${formatObservedRunCounter(calls.provider429s)} provider 429s`
+    );
+  }
+  const source = readRecord(evidence.source);
+  if (source?.aligned === false) {
+    lines.push(
+      `  consistency: run snapshot event ${String(source.runSnapshotLedgerNextSeq)} and progress event ${String(source.ledgerNextSeq)} differ; retry this read to align them`
+    );
+  }
+  const focus = readRecord(evidence.focusStep);
+  const rows = readRecord(focus?.rows);
+  if (focus) {
+    const id = typeof focus.id === "string" && focus.id.trim() ? focus.id.trim() : "unknown step";
+    const label = typeof focus.label === "string" && focus.label.trim() ? ` (${focus.label.trim()})` : "";
+    const state = typeof focus.status === "string" && focus.status.trim() ? `: ${focus.status.trim()}` : "";
+    const rowCounts = rows ? `; rows ${formatObservedRunCounter({ value: rows.succeeded, confirmed: true })} succeeded, ${formatObservedRunCounter({ value: rows.failed, confirmed: true })} failed, ${formatObservedRunCounter({ value: rows.total, confirmed: true })} total` : "";
+    lines.push(`  current step: ${id}${label}${state}${rowCounts}`);
+  }
+  return lines;
+}
+function buildRecentRunLogTextLines(packaged) {
+  const logs = readRecord(packaged.logs);
+  const tail = Array.isArray(logs?.tail) ? logs.tail.filter((line) => typeof line === "string") : [];
+  if (tail.length === 0) return [];
+  const visible = tail.slice(-5);
+  const total = typeof logs?.totalCount === "number" && Number.isFinite(logs.totalCount) ? ` of ${formatInteger(logs.totalCount)}` : "";
+  const lines = [`  recent logs: showing ${visible.length}${total}`];
+  lines.push(...visible.map((line) => `    ${line}`));
+  if (logs?.truncated === true) {
+    lines.push("    older log lines were truncated by the retention cap");
+  }
+  return lines;
+}
 function buildRunPackageTextLines(packaged) {
   const run = readRunPackageRun(packaged);
   const runId = typeof run.id === "string" ? run.id : "unknown";
@@ -26480,6 +27100,8 @@ function buildRunPackageTextLines(packaged) {
   if (!isRuntimeLimitCheckpoint) {
     lines.push(...buildRunActivityTextLines(run));
   }
+  lines.push(...buildRunStatusEvidenceTextLines(packaged));
+  lines.push(...buildRecentRunLogTextLines(packaged));
   lines.push(...formatPackageValueOutputLines(packaged));
   lines.push(
     ...formatPackageDatasetActionLines(packaged, {
@@ -26487,12 +27109,7 @@ function buildRunPackageTextLines(packaged) {
     })
   );
   const next = packaged.next && typeof packaged.next === "object" && !Array.isArray(packaged.next) ? packaged.next : {};
-  const billingCommand = actionToCommand(next.billing);
   const logsCommand = actionToCommand(next.logs);
-  if (billingCommand) {
-    const costState = status === "completed" || status === "failed" || status === "cancelled" ? "settles asynchronously \u2014 run the billing command below for totals" : "pending";
-    lines.push(`  cost: ${costState}`);
-  }
   for (const step of isRuntimeLimitCheckpoint ? [] : readRecordArray(packaged.steps).slice(0, 8)) {
     const id = typeof step.id === "string" ? step.id : "step";
     const kind = typeof step.kind === "string" ? step.kind : "step";
@@ -26522,7 +27139,6 @@ function buildRunPackageTextLines(packaged) {
       `  ${isRuntimeTimeout ? "full run details" : "full result"}: ${fullResultCommand}`
     );
   if (logsCommand) lines.push(`  logs: ${logsCommand}`);
-  if (billingCommand) lines.push(`  billing: ${billingCommand}`);
   if (legacyExportCommand) {
     lines.push(`  export CSV: ${legacyExportCommand}`);
   }
@@ -28873,7 +29489,7 @@ async function handlePlayRun(args, hooks) {
         if (siblings.length > 0) {
           console.error(`Did you mean one of these?`);
           for (const s of siblings.slice(0, 5)) {
-            console.error(`  ${join13(dir, s)}`);
+            console.error(`  ${join14(dir, s)}`);
           }
         }
       } catch {
@@ -30117,8 +30733,8 @@ function printPlayDescription(play) {
   }
 }
 function inputFieldNames(schema) {
-  const fields = Array.isArray(schema?.fields) ? schema.fields : [];
-  return fields.map(
+  const fields2 = Array.isArray(schema?.fields) ? schema.fields : [];
+  return fields2.map(
     (field) => field && typeof field === "object" ? String(field.name ?? "").trim() : ""
   ).filter(Boolean);
 }
@@ -30135,9 +30751,9 @@ function printCompactPlaySearchResult(play) {
   if (aliases) {
     console.log(`  Aliases: ${aliases}`);
   }
-  const fields = inputFieldNames(play.inputSchema);
-  if (fields.length > 0) {
-    console.log(`  Inputs: ${fields.join(", ")}`);
+  const fields2 = inputFieldNames(play.inputSchema);
+  if (fields2.length > 0) {
+    console.log(`  Inputs: ${fields2.join(", ")}`);
   } else if (play.inputSchema) {
     console.log("  Inputs: see describe");
   }
@@ -30146,14 +30762,14 @@ function printCompactPlaySearchResult(play) {
 }
 function compactPlaySchema(schema) {
   if (!schema) return null;
-  const fields = Array.isArray(schema.fields) ? schema.fields.map(
+  const fields2 = Array.isArray(schema.fields) ? schema.fields.map(
     (field) => field && typeof field === "object" ? {
       name: String(field.name ?? ""),
       type: field.type ?? void 0,
       required: field.required ?? void 0
     } : null
   ).filter((field) => Boolean(field?.name)) : [];
-  return fields.length > 0 ? { fields } : schema;
+  return fields2.length > 0 ? { fields: fields2 } : schema;
 }
 function summarizePlayGrepResult(play) {
   const reference = formatPlayListReference(play);
@@ -30782,6 +31398,8 @@ Concepts:
   Installed npm and repo-local CLIs can run saved/prebuilt plays by name or
   bundle local .play.ts files for development workflows.
   Running a local file does not make it live; use publish or set-live for that.
+  plays settings organizes a Play independently of code revisions.
+  New Plays start at person; publishing moves them to team, preserving folders.
 
 Authoring:
   Use normal TypeScript interpolation for human-facing strings:
@@ -30987,6 +31605,7 @@ Pass-through input flags:
     process.exitCode = exitCode;
   });
   registerPlayBootstrapCommand(play);
+  registerPlaySettingsCommands(play);
   play.command("get <target>").description(
     "Fetch full play details or materialize a saved source bundle."
   ).addHelpText(
@@ -31255,6 +31874,8 @@ Notes:
   plays check to refuse publishing bytes that changed after validation.
   --dry-run bundles only and prints the exact artifact that would be published.
   Running a local file with plays run does not publish it.
+  Publishing moves personal locations into Team library, preserving folders.
+  Change location with: deepline plays settings set --play <play> --name path --value team/Research
 
 Examples:
   deepline plays set-live my-play --latest --json
@@ -31398,7 +32019,10 @@ Examples:
   deepline runs export play/my-play/run/20260501t000000-000 --out output.csv
 `
   );
-  runs.command("status <runId>").description("Read bounded lifecycle and confirmed work counts for a run.").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
+  registerRunHistoryCommand(runs);
+  runs.command("status <runId>").description(
+    "Legacy scalar-only read. Use runs get for canonical status, progress, logs, and results."
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
     process.exitCode = await handleRunLifecycleStatus([
       runId,
       ...options.json ? ["--json"] : []
@@ -33582,7 +34206,7 @@ function expandAtFilePath(rawPath) {
     return homedir6();
   }
   if (expanded.startsWith("~/") || expanded.startsWith("~\\")) {
-    return join14(homedir6(), expanded.slice(2));
+    return join15(homedir6(), expanded.slice(2));
   }
   return expanded;
 }
@@ -33595,7 +34219,7 @@ async function readAtFileReference(value, argumentName, strip = true) {
     throw new Error(`Invalid ${argumentName} value: empty @file path.`);
   }
   try {
-    const text = await readFile4(filePath, "utf8");
+    const text = await readFile5(filePath, "utf8");
     const normalized = text.replace(/^\uFEFF/, "");
     return strip ? normalized.trim() : normalized;
   } catch (error) {
@@ -33946,7 +34570,7 @@ async function regularFileExists(path) {
   }
 }
 async function readConfig(path) {
-  const source = await readFile4(resolve13(path), "utf8");
+  const source = await readFile5(resolve13(path), "utf8");
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -35004,9 +35628,9 @@ function readEnrichRunStatus(status) {
   return null;
 }
 function firstCollectedStringField(value, key) {
-  const fields = /* @__PURE__ */ new Set();
-  collectStringFields(value, key, fields);
-  return fields.values().next().value ?? null;
+  const fields2 = /* @__PURE__ */ new Set();
+  collectStringFields(value, key, fields2);
+  return fields2.values().next().value ?? null;
 }
 function emitPlainRunFailure(status) {
   const runId = extractRunId(status) ?? firstCollectedStringField(status, "runId");
@@ -35964,7 +36588,7 @@ function sidecarEnrichRowsExportPath(outputPath) {
   const resolved = resolve13(outputPath);
   const ext = extname3(resolved) || ".csv";
   const stem = basename4(resolved, ext);
-  return join14(dirname11(resolved), `${stem}.deepline-enrich-rows${ext}`);
+  return join15(dirname11(resolved), `${stem}.deepline-enrich-rows${ext}`);
 }
 function collectDatasetFollowUpCommands(value, state) {
   if (state.depth > 12 || !value || typeof value !== "object" || state.commands.length >= 8) {
@@ -36045,10 +36669,10 @@ async function persistEnrichFailureReport(input2) {
   if (input2.jobs.length === 0 && input2.issues.length === 0) {
     return null;
   }
-  const stateDir = join14(homedir6(), ".local", "deepline", "runtime", "state");
+  const stateDir = join15(homedir6(), ".local", "deepline", "runtime", "state");
   const reportPrefix = input2.jobs.length > 0 ? "run-block-failures" : "enrich-issues";
   await mkdir5(stateDir, { recursive: true });
-  const reportPath = join14(
+  const reportPath = join15(
     stateDir,
     `${reportPrefix}-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
   );
@@ -36977,9 +37601,9 @@ function registerEnrichCommand(program) {
       sdkEnrichTelemetryCompleted = true;
       await completeSdkEnrichTelemetry(sdkEnrichTelemetry, input2);
     };
-    const tempDir = await mkdtemp3(join14(tmpdir5(), "deepline-enrich-play-"));
+    const tempDir = await mkdtemp3(join15(tmpdir5(), "deepline-enrich-play-"));
     await emitSdkEnrichTelemetry(sdkEnrichTelemetry, "enrich_started");
-    const tempPlay = join14(tempDir, "deepline-enrich.play.ts");
+    const tempPlay = join15(tempDir, "deepline-enrich.play.ts");
     let inPlaceTempDir = null;
     let inPlaceTempOutputPath = null;
     const inPlaceFinalOutputPath = options.inPlace ? resolve13(inputCsv) : null;
@@ -37007,12 +37631,12 @@ function registerEnrichCommand(program) {
         await rm3(inPlaceTempDir, { recursive: true, force: true });
       }
       inPlaceTempDir = await mkdtemp3(
-        join14(
+        join15(
           dirname11(inPlaceCommitOutputPath ?? resolve13(inputCsv)),
           ".deepline-enrich-in-place-"
         )
       );
-      inPlaceTempOutputPath = join14(inPlaceTempDir, "output.csv");
+      inPlaceTempOutputPath = join15(inPlaceTempDir, "output.csv");
       await copyFile(resolve13(inputCsv), inPlaceTempOutputPath);
       outputPath = inPlaceTempOutputPath;
     };
@@ -37279,7 +37903,7 @@ async function handleFeedback(text, options) {
     { json: options.json }
   );
 }
-function resolveFeedbackText(text, file, readFile7 = (path) => readFileSync10(path, "utf8")) {
+function resolveFeedbackText(text, file, readFile8 = (path) => readFileSync10(path, "utf8")) {
   if (text !== void 0 && file !== void 0) {
     throw new Error(
       "Pass feedback text positionally or with --file, not both."
@@ -37288,7 +37912,7 @@ function resolveFeedbackText(text, file, readFile7 = (path) => readFileSync10(pa
   let value;
   if (file !== void 0) {
     try {
-      value = readFile7(file === "-" ? 0 : file);
+      value = readFile8(file === "-" ? 0 : file);
     } catch (error) {
       throw new Error(
         `Could not read feedback ${file === "-" ? "from stdin" : `file ${file}`}: ${error instanceof Error ? error.message : String(error)}`
@@ -37297,7 +37921,7 @@ function resolveFeedbackText(text, file, readFile7 = (path) => readFileSync10(pa
   } else if (text !== void 0) {
     value = text;
   } else if (!process.stdin.isTTY) {
-    value = readFile7(0);
+    value = readFile8(0);
   } else {
     throw new Error(
       "Feedback text is required. Pass it positionally, use --file <path>, or pipe stdin."
@@ -37356,7 +37980,7 @@ import {
   writeFileSync as writeFileSync11
 } from "fs";
 import { homedir as homedir7, platform } from "os";
-import { basename as basename5, dirname as dirname12, join as join15, resolve as resolve14 } from "path";
+import { basename as basename5, dirname as dirname12, join as join16, resolve as resolve14 } from "path";
 import { gzipSync } from "zlib";
 import { randomUUID as randomUUID5 } from "crypto";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -37382,10 +38006,10 @@ function detectShellContext() {
   };
 }
 function claudeProjectsRoot() {
-  return join15(homeDir(), ".claude", "projects");
+  return join16(homeDir(), ".claude", "projects");
 }
 function codexSessionsRoot() {
-  return join15(homeDir(), ".codex", "sessions");
+  return join16(homeDir(), ".codex", "sessions");
 }
 function listClaudeSessionFiles() {
   const root = claudeProjectsRoot();
@@ -37393,10 +38017,10 @@ function listClaudeSessionFiles() {
   const projectDirs = readDirectoryNames(root);
   const files = [];
   for (const projectDir of projectDirs) {
-    const fullProjectDir = join15(root, projectDir);
+    const fullProjectDir = join16(root, projectDir);
     for (const fileName of readDirectoryNames(fullProjectDir)) {
       if (fileName.endsWith(".jsonl")) {
-        const filePath = join15(fullProjectDir, fileName);
+        const filePath = join16(fullProjectDir, fileName);
         const sessionId = sessionIdFromClaudeFilePath(filePath);
         const stat5 = statIfReadable(filePath);
         if (sessionId && stat5) {
@@ -37453,7 +38077,7 @@ function listJsonlFilesRecursive(root, maxDepth) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = join15(dir, entry.name);
+      const fullPath = join16(dir, entry.name);
       if (entry.isDirectory()) {
         visit(fullPath, depth + 1);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -37892,8 +38516,8 @@ function loadViewerAssets() {
   const cliEntry = process.argv[1]?.trim() ? realpathSync3(resolve14(process.argv[1])) : null;
   const candidateRoots2 = [
     ...cliEntry ? [
-      join15(dirname12(dirname12(cliEntry)), "viewer"),
-      join15(
+      join16(dirname12(dirname12(cliEntry)), "viewer"),
+      join16(
         dirname12(dirname12(dirname12(cliEntry))),
         "src",
         "lib",
@@ -37901,12 +38525,12 @@ function loadViewerAssets() {
         "viewer"
       )
     ] : [],
-    join15(process.cwd(), "packages", "sdk", "assets", "viewer")
+    join16(process.cwd(), "packages", "sdk", "assets", "viewer")
   ];
   for (const root of candidateRoots2) {
     try {
-      const cssPath = join15(root, "viewer.css");
-      const jsPath = join15(root, "viewer.js");
+      const cssPath = join16(root, "viewer.css");
+      const jsPath = join16(root, "viewer.js");
       if (!existsSync10(cssPath) || !existsSync10(jsPath)) continue;
       return {
         css: readFileSync11(cssPath, "utf8"),
@@ -37938,9 +38562,9 @@ async function handleSessionsRender(options) {
   });
   let outputPath = options.output ? resolve14(options.output) : "";
   if (!outputPath) {
-    const outputDir = join15(process.cwd(), "deepline", "data");
+    const outputDir = join16(process.cwd(), "deepline", "data");
     mkdirSync8(outputDir, { recursive: true });
-    outputPath = join15(
+    outputPath = join16(
       outputDir,
       targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
     );
@@ -39052,7 +39676,7 @@ function parseJsonObjectArg(raw, argLabel) {
   return parsed;
 }
 function resolveMonitorJsonBody(input2) {
-  const readFile7 = input2.readFile ?? ((path) => readFileSync12(path, "utf-8"));
+  const readFile8 = input2.readFile ?? ((path) => readFileSync12(path, "utf-8"));
   const readStdin = input2.readStdin ?? (() => readFileSync12(0, "utf-8"));
   if (input2.positional !== void 0 && input2.file !== void 0) {
     throw new MonitorsUsageError(
@@ -39068,7 +39692,7 @@ function resolveMonitorJsonBody(input2) {
     }
     let raw;
     try {
-      raw = readFile7(input2.file);
+      raw = readFile8(input2.file);
     } catch (error) {
       throw new MonitorsUsageError(
         `Could not read --file ${input2.file}: ${error instanceof Error ? error.message : String(error)}`
@@ -42138,10 +42762,10 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync13
 } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 function pendingOrgCreatePath(baseUrl, accountId, sourceOrgId, name) {
   const intent = createHash5("sha256").update(accountId).update("\0").update(sourceOrgId).update("\0").update(name).digest("hex");
-  return join16(sdkCliStateDirPath(baseUrl), `pending-org-create-${intent}.json`);
+  return join17(sdkCliStateDirPath(baseUrl), `pending-org-create-${intent}.json`);
 }
 function readPendingOrgCreate(path, accountId, sourceOrgId, name) {
   let value;
@@ -43024,7 +43648,7 @@ Deprecated:
 
 // src/cli/commands/secrets.ts
 import { stdin as input, stdout as output } from "process";
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 var hiddenInputBuffer = "";
 function normalizeSecretName(value) {
   const normalized = value.trim().toUpperCase();
@@ -43197,7 +43821,7 @@ async function readSecretValueFromOptions(options) {
     }
     value = envValue;
   } else {
-    value = trimOneTerminalNewline(await readFile5(options.fromFile, "utf8"));
+    value = trimOneTerminalNewline(await readFile6(options.fromFile, "utf8"));
   }
   if (!value) throw new Error("Secret value is required.");
   return value;
@@ -43408,7 +44032,7 @@ import {
   writeFileSync as writeFileSync16
 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname16, join as join20, resolve as resolve17 } from "path";
+import { dirname as dirname16, join as join21, resolve as resolve17 } from "path";
 
 // src/cli/installation-lifecycle.ts
 import {
@@ -43418,7 +44042,7 @@ import {
   realpathSync as realpathSync4,
   rmSync as rmSync4
 } from "fs";
-import { basename as basename6, dirname as dirname13, join as join17, relative as relative6, resolve as resolve16 } from "path";
+import { basename as basename6, dirname as dirname13, join as join18, relative as relative6, resolve as resolve16 } from "path";
 var nodeFileSystem = {
   exists: existsSync12,
   isSymbolicLink(path) {
@@ -43474,25 +44098,25 @@ var CliInstallation = class _CliInstallation {
     });
   }
   static isNpmPackagePath(path) {
-    return path?.includes(`${join17("node_modules", "deepline")}`) ?? false;
+    return path?.includes(`${join18("node_modules", "deepline")}`) ?? false;
   }
   launcher(path) {
     return inspectLauncher(path, this.input.fileSystem);
   }
   retiredArtifacts() {
-    const hostDir = join17(
+    const hostDir = join18(
       this.input.home,
       ".local",
       "deepline",
       this.input.baseUrlSlug
     );
-    const legacyLauncherPath = join17(
+    const legacyLauncherPath = join18(
       this.input.home,
       ".local",
       "bin",
       "deepline"
     );
-    const installerCommandPath = this.input.fileSystem.read(join17(hostDir, "sdk", ".command-path")).trim();
+    const installerCommandPath = this.input.fileSystem.read(join18(hostDir, "sdk", ".command-path")).trim();
     const ownedInstallerCommand = isOwnedInstallerCommandPath({
       hostDir,
       commandPath: installerCommandPath
@@ -43500,16 +44124,16 @@ var CliInstallation = class _CliInstallation {
     const legacyLauncher = this.launcher(legacyLauncherPath);
     const candidates = [
       ...legacyLauncher.ownership === "installer_legacy" ? [legacyLauncherPath] : [],
-      join17(this.input.home, ".local", "bin", "deepline-real"),
-      join17(hostDir, "bin", "deepline"),
-      join17(hostDir, "bin", "deepline-real"),
-      join17(hostDir, "cli", ".install-method"),
-      join17(hostDir, "cli", ".version"),
-      join17(hostDir, "sdk", ".install-method"),
-      join17(hostDir, "sdk", ".command-path"),
+      join18(this.input.home, ".local", "bin", "deepline-real"),
+      join18(hostDir, "bin", "deepline"),
+      join18(hostDir, "bin", "deepline-real"),
+      join18(hostDir, "cli", ".install-method"),
+      join18(hostDir, "cli", ".version"),
+      join18(hostDir, "sdk", ".install-method"),
+      join18(hostDir, "sdk", ".command-path"),
       ...ownedInstallerCommand ? [
         installerCommandPath,
-        join17(dirname13(installerCommandPath), "deepline-sdk")
+        join18(dirname13(installerCommandPath), "deepline-sdk")
       ] : []
     ];
     return {
@@ -43542,7 +44166,7 @@ function isOwnedInstallerCommandPath(input2) {
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync15 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname15, join as join19 } from "path";
+import { dirname as dirname15, join as join20 } from "path";
 
 // contracts/install-commands.json
 var install_commands_default = {
@@ -43669,7 +44293,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync14
 } from "fs";
-import { dirname as dirname14, join as join18 } from "path";
+import { dirname as dirname14, join as join19 } from "path";
 
 // src/cli/windows-arg-escape.ts
 var CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
@@ -44034,7 +44658,7 @@ function shouldSkipSkillsSync() {
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
 function unavailableSkillsNoticePath(baseUrl) {
-  return join18(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
+  return join19(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
 }
 var SKILLS_SYNC_IN_PROGRESS_TTL_MS = 10 * 60 * 1e3;
 var SKILLS_SYNC_IN_PROGRESS_PID_CAP_MS = 6 * 60 * 60 * 1e3;
@@ -44044,21 +44668,21 @@ function sortedLeaseAgents(agents) {
   return [...new Set(expanded)].sort((a, b) => a.localeCompare(b));
 }
 function inProgressSkillsSyncPath(baseUrl, agent) {
-  return join18(
+  return join19(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-in-progress-${agentLeaseSegment(agent)}`
   );
 }
 function readInProgressSkillsSyncLeaseFromDir(dir) {
-  const claim = readMarkedSkillsSyncVersion(join18(dir, "claim"));
+  const claim = readMarkedSkillsSyncVersion(join19(dir, "claim"));
   const [version = "", startedAt = ""] = claim.split(" ");
-  const pidRaw = readMarkedSkillsSyncVersion(join18(dir, "pid"));
+  const pidRaw = readMarkedSkillsSyncVersion(join19(dir, "pid"));
   return {
     claimToken: version && startedAt ? `${version} ${startedAt}` : "",
     version,
     startedAt: Number(startedAt),
     pid: /^\d+$/.test(pidRaw) ? Number(pidRaw) : null,
-    owner: readMarkedSkillsSyncVersion(join18(dir, "owner"))
+    owner: readMarkedSkillsSyncVersion(join19(dir, "owner"))
   };
 }
 function readInProgressSkillsSyncLease(baseUrl, agent) {
@@ -44116,9 +44740,9 @@ function claimOneInProgressSkillsSync(baseUrl, remoteVersion, agent, owner) {
     const claimToken = `${remoteVersion} ${Date.now()}`;
     const staging = `${dir}.staging-${process.pid}-${Date.now()}`;
     mkdirSync10(staging);
-    writeFileSync14(join18(staging, "claim"), `${claimToken}
+    writeFileSync14(join19(staging, "claim"), `${claimToken}
 `, "utf-8");
-    writeFileSync14(join18(staging, "owner"), `${owner}
+    writeFileSync14(join19(staging, "owner"), `${owner}
 `, "utf-8");
     try {
       renameSync(staging, dir);
@@ -44192,7 +44816,7 @@ function recordOwnPidOnInProgressSkillsSync(baseUrl, leases) {
     if (!lease.claimToken) continue;
     try {
       writeFileSync14(
-        join18(inProgressSkillsSyncPath(baseUrl, agent), "pid"),
+        join19(inProgressSkillsSyncPath(baseUrl, agent), "pid"),
         `${process.pid}
 `,
         "utf-8"
@@ -44261,7 +44885,7 @@ function skillsInstallLeasePath(baseUrl, agents) {
   return sortedLeaseAgents(agents).map((agent) => inProgressSkillsSyncPath(baseUrl, agent)).join(", ");
 }
 function deferredSkillsNoticePath(baseUrl, agents) {
-  return join18(
+  return join19(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-notice-${sortedLeaseAgents(agents).map(agentLeaseSegment).join("-")}`
   );
@@ -44312,7 +44936,7 @@ function spawnDetachedSkillsSyncChild(argv, onSpawnError) {
   child.unref();
 }
 function failedSkillsSyncPath(baseUrl, agents) {
-  return join18(
+  return join19(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-failed-${sortedLeaseAgents(agents).map(agentLeaseSegment).join("-")}-version`
   );
@@ -44439,7 +45063,7 @@ function safeSkillFilePath(value) {
 }
 function installedSkillFiles(root, prefix = "") {
   const files = [];
-  for (const entry of readdirSync4(join18(root, prefix), {
+  for (const entry of readdirSync4(join19(root, prefix), {
     withFileTypes: true
   })) {
     const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
@@ -44559,11 +45183,11 @@ async function verifyDefaultAgentSkillsInstall(baseUrl, remoteVersion, skillName
     controller.abort();
   }
   const home = homedir8();
-  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim() || join18(home, ".claude");
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim() || join19(home, ".claude");
   for (const [name, { files }] of published) {
     for (const root of [
-      join18(home, ".agents", "skills", name),
-      join18(claudeConfigDir, "skills", name)
+      join19(home, ".agents", "skills", name),
+      join19(claudeConfigDir, "skills", name)
     ]) {
       const installed = installedSkillFiles(root);
       if (installed.length !== files.length || installed.some((file, index2) => file !== files[index2])) {
@@ -44571,7 +45195,7 @@ async function verifyDefaultAgentSkillsInstall(baseUrl, remoteVersion, skillName
       }
       for (const file of files) {
         const publishedContent = expected.get(`${name}/${file}`);
-        if (!publishedContent || !readFileSync15(join18(root, file)).equals(publishedContent)) {
+        if (!publishedContent || !readFileSync15(join19(root, file)).equals(publishedContent)) {
           throw new Error(`installed content differs for ${name}/${file}`);
         }
       }
@@ -44625,7 +45249,7 @@ function probeInstallers(timeoutMs) {
   };
 }
 function noInstallerProbePath(baseUrl) {
-  return join18(
+  return join19(
     sdkCliStateDirPath(baseUrl),
     "skills-sync-no-installer-unknown.json"
   );
@@ -45094,13 +45718,13 @@ function detectSkillsAgents(input2) {
   ];
   const detected = AGENT_MARKERS.filter(
     (marker) => roots.some(
-      (root) => marker.paths.some((path) => existsSync14(join19(root, path)))
+      (root) => marker.paths.some((path) => existsSync14(join20(root, path)))
     )
   ).map((marker) => marker.agent);
   return detected.length > 0 ? detected : ["*"];
 }
 function skillsStatePathForScope(baseUrl, scope, root) {
-  return scope === "local" && root ? join19(root, ".deepline", "setup", "skills.json") : join19(sdkCliStateDirPath(baseUrl), "skills-install.json");
+  return scope === "local" && root ? join20(root, ".deepline", "setup", "skills.json") : join20(sdkCliStateDirPath(baseUrl), "skills-install.json");
 }
 function buildSkillsPlan(input2) {
   const scopeArgs = input2.scope === "global" ? ["--global"] : [];
@@ -45650,7 +46274,7 @@ function buildPendingAuthorizationOutput(input2) {
   };
 }
 function setupStatePath(baseUrl, scope, root) {
-  return scope === "local" && root ? join20(root, ".deepline", "setup", "state.json") : join20(sdkCliStateDirPath(baseUrl), "setup.json");
+  return scope === "local" && root ? join21(root, ".deepline", "setup", "state.json") : join21(sdkCliStateDirPath(baseUrl), "setup.json");
 }
 async function captureStdout2(run) {
   let stdout = "";
@@ -45731,7 +46355,7 @@ function resolvePersistentGlobalCommand(dependencies = {}) {
   if (prefix.status !== 0) return null;
   const root = String(prefix.stdout ?? "").trim();
   if (!root) return null;
-  const candidates = platform3 === "win32" ? [join20(root, "deepline.cmd"), join20(root, "deepline")] : [join20(root, "bin", "deepline")];
+  const candidates = platform3 === "win32" ? [join21(root, "deepline.cmd"), join21(root, "deepline")] : [join21(root, "bin", "deepline")];
   return candidates.find((candidate) => pathExists(candidate)) ?? null;
 }
 function inspectGlobalCliAvailability(input2) {
@@ -45757,7 +46381,7 @@ function isKnownDeeplineCommand(path) {
   } catch {
   }
   if (entrypoint && resolvedPath === entrypoint) return true;
-  if (resolvedPath.includes(`${join20("node_modules", "deepline")}`)) return true;
+  if (resolvedPath.includes(`${join21("node_modules", "deepline")}`)) return true;
   const content = safeRead(path);
   return content.includes("node_modules/deepline") || content.includes("node_modules\\deepline") || content.includes("DEEPLINE_CONFIG_SCOPE") || content.includes("deepline-real");
 }
@@ -45767,7 +46391,7 @@ function inspectPathConflict() {
   try {
     if (lstatSync2(commandPath).isSymbolicLink()) {
       const target = realpathSync5(commandPath);
-      if (target.includes(`${join20("node_modules", "deepline")}`)) return null;
+      if (target.includes(`${join21("node_modules", "deepline")}`)) return null;
     }
   } catch {
   }
@@ -45816,7 +46440,7 @@ function failSetupPhase(phases, phase, code) {
   phases[phase] = { status: "failed", code };
 }
 function rollbackCommand(scope, root) {
-  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify(join20(root, ".deepline", "runtime"))}` : "";
+  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify(join21(root, ".deepline", "runtime"))}` : "";
   const allowScriptsFlag = npmSupportsAllowScripts(readNpmVersion(process.env)) ? " --allow-scripts=esbuild" : "";
   return `npm install -g${prefix} --no-audit --no-fund --include=optional${allowScriptsFlag} deepline@${SDK_VERSION}`;
 }
@@ -45911,7 +46535,7 @@ function buildDoctorAssessment(input2) {
   const pathGlobalCli = globalCli?.path ?? null;
   const cliPath = input2.scope === "global" ? pathGlobalCli : runningCliPath;
   const cliScopeOk = input2.scope === "global" ? Boolean(pathGlobalCli) : Boolean(
-    input2.root && runningCliPath?.includes(join20(input2.root, ".deepline", "runtime"))
+    input2.root && runningCliPath?.includes(join21(input2.root, ".deepline", "runtime"))
   );
   const checks = {
     cli: {
@@ -46538,7 +47162,7 @@ import {
   writeFileSync as writeFileSync17
 } from "fs";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname17, join as join21 } from "path";
+import { dirname as dirname17, join as join22 } from "path";
 var UPDATE_PREFERENCES_SCHEMA_VERSION = 1;
 var CLI_UPDATE_MESSAGES = [
   {
@@ -46567,7 +47191,7 @@ function unreadablePreferences(path, error) {
   };
 }
 function cliUpdatePreferencesPath(homeDir2 = homedir11()) {
-  return join21(
+  return join22(
     homeDir2,
     ".local",
     "deepline",
@@ -46669,7 +47293,7 @@ import {
   basename as basename7,
   dirname as dirname18,
   isAbsolute as isAbsolute7,
-  join as join23,
+  join as join24,
   relative as relative8,
   resolve as resolve19
 } from "path";
@@ -46677,7 +47301,7 @@ import {
 // src/cli/install-integrity.ts
 import { createRequire } from "module";
 import { existsSync as existsSync17, readFileSync as readFileSync19, statSync as statSync5 } from "fs";
-import { isAbsolute as isAbsolute6, join as join22, relative as relative7, resolve as resolve18 } from "path";
+import { isAbsolute as isAbsolute6, join as join23, relative as relative7, resolve as resolve18 } from "path";
 var SDK_SIDECAR_CRITICAL_PACKAGE_FILES = [
   "dist/cli/index.mjs",
   "dist/index.mjs",
@@ -46722,7 +47346,7 @@ function isFile(path) {
   }
 }
 function readManifest(packageRoot) {
-  const packageJsonPath = join22(packageRoot, "package.json");
+  const packageJsonPath = join23(packageRoot, "package.json");
   let packageJson;
   try {
     packageJson = parseJson(packageJsonPath);
@@ -46796,8 +47420,8 @@ function readManifest(packageRoot) {
   return { mode: "manifest", manifest };
 }
 function inspectSdkSidecarInstall(versionDir) {
-  const nodeModulesRoot = join22(versionDir, "node_modules");
-  const packageRoot = join22(nodeModulesRoot, "deepline");
+  const nodeModulesRoot = join23(versionDir, "node_modules");
+  const packageRoot = join23(nodeModulesRoot, "deepline");
   const manifestResult = readManifest(packageRoot);
   if ("invalidReason" in manifestResult) {
     return {
@@ -46808,8 +47432,8 @@ function inspectSdkSidecarInstall(versionDir) {
     };
   }
   const missing = [
-    ...manifestResult.manifest.packageFiles.filter((path) => !isFile(join22(packageRoot, path))).map((path) => `deepline/${path}`),
-    ...manifestResult.manifest.dependencyFiles.filter((path) => !isFile(join22(nodeModulesRoot, path))).map((path) => `node_modules/${path}`)
+    ...manifestResult.manifest.packageFiles.filter((path) => !isFile(join23(packageRoot, path))).map((path) => `deepline/${path}`),
+    ...manifestResult.manifest.dependencyFiles.filter((path) => !isFile(join23(nodeModulesRoot, path))).map((path) => `node_modules/${path}`)
   ];
   return {
     ok: missing.length === 0,
@@ -46820,7 +47444,7 @@ function inspectSdkSidecarInstall(versionDir) {
 }
 function probeSdkSidecarEsbuild(versionDir) {
   try {
-    const requireFromInstall = createRequire(join22(versionDir, "package.json"));
+    const requireFromInstall = createRequire(join23(versionDir, "package.json"));
     const esbuild = requireFromInstall("esbuild");
     if (typeof esbuild.transformSync !== "function") {
       return "esbuild does not export transformSync";
@@ -46889,7 +47513,7 @@ function sidecarStateDir(input2) {
   if (!scope || scope.includes("/") || scope.includes("\\")) {
     return null;
   }
-  return join23(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
+  return join24(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
 }
 function sidecarRegistryUrl(hostUrl) {
   let url;
@@ -46931,12 +47555,12 @@ function resolvePythonSidecarUpdatePlan(options) {
   if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || isAbsolute7(relativeEntrypoint)) {
     return null;
   }
-  const installMethod = readOptionalText(join23(stateDir, ".install-method"));
+  const installMethod = readOptionalText(join24(stateDir, ".install-method"));
   if (installMethod !== "python-sidecar") return null;
   const scope = options.env.DEEPLINE_CONFIG_SCOPE?.trim() || "";
   const hostUrl = options.env.DEEPLINE_HOST_URL?.trim() || "";
-  const nodeBin = readOptionalText(join23(stateDir, ".node-bin")) || process.execPath;
-  const sidecarPath = readOptionalText(join23(stateDir, ".command-path")) || join23(
+  const nodeBin = readOptionalText(join24(stateDir, ".node-bin")) || process.execPath;
+  const sidecarPath = readOptionalText(join24(stateDir, ".command-path")) || join24(
     stateDir,
     "bin",
     process.platform === "win32" ? "deepline-sdk.cmd" : "deepline-sdk"
@@ -46944,7 +47568,7 @@ function resolvePythonSidecarUpdatePlan(options) {
   const packageSpec = options.packageSpec || "deepline@latest";
   const npmCommand = "npm";
   const registryUrl = sidecarRegistryUrl(hostUrl);
-  const versionDir = join23(stateDir, "versions", "<version>");
+  const versionDir = join24(stateDir, "versions", "<version>");
   const manualCommand = `${buildSidecarProjectConfigCommand(versionDir, nodeBin)} && ${npmCommand} install --prefix ${shellQuote5(versionDir)} --registry ${shellQuote5(registryUrl)} ${NPM_SDK_INSTALL_COMMON_FLAGS.map(shellQuote5).join(" ")} ${shellQuote5(packageSpec)}`;
   return {
     kind: "python-sidecar",
@@ -46962,11 +47586,11 @@ function resolvePythonSidecarUpdatePlan(options) {
 function findRepoBackedSdkRoot(startPath) {
   let current = resolve19(startPath);
   while (true) {
-    if (existsSync18(join23(current, "package.json")) && existsSync18(join23(current, "bin", "deepline-dev.ts"))) {
+    if (existsSync18(join24(current, "package.json")) && existsSync18(join24(current, "bin", "deepline-dev.ts"))) {
       const parent2 = dirname18(current);
       return basename7(parent2) === "packages" && basename7(current) === "sdk" ? dirname18(parent2) : parent2;
     }
-    if (existsSync18(join23(current, "sdk", "package.json")) && existsSync18(join23(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if (existsSync18(join24(current, "sdk", "package.json")) && existsSync18(join24(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
     const parent = dirname18(current);
@@ -46994,7 +47618,7 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
     const directPrefix = prefixParts.join("/").toLowerCase();
     const knownWindowsPrefixes = [
       env.npm_config_prefix,
-      env.APPDATA ? join23(env.APPDATA, "npm") : void 0
+      env.APPDATA ? join24(env.APPDATA, "npm") : void 0
     ].filter((value) => Boolean(value)).map((value) => resolve19(value).replace(/\\/g, "/").toLowerCase());
     if (!knownWindowsPrefixes.includes(
       resolve19(directPrefix).replace(/\\/g, "/").toLowerCase()
@@ -47101,9 +47725,9 @@ var AUTO_UPDATE_FAILURE_FILE = ".auto-update-failure.json";
 function autoUpdateFailurePath(plan) {
   if (plan.kind === "source" || plan.kind === "homebrew") return null;
   if (plan.kind === "python-sidecar") {
-    return join23(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
+    return join24(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
   }
-  return join23(
+  return join24(
     homedir12(),
     ".local",
     "deepline",
@@ -47190,7 +47814,7 @@ function safeVersionSegment(value) {
   return /^[0-9A-Za-z._-]+$/.test(normalized) ? normalized : "";
 }
 function entryPathInVersionDir(versionDir) {
-  return join23(
+  return join24(
     versionDir,
     "node_modules",
     "deepline",
@@ -47200,7 +47824,7 @@ function entryPathInVersionDir(versionDir) {
   );
 }
 function installedPackageVersion(versionDir) {
-  const packageJsonPath = join23(
+  const packageJsonPath = join24(
     versionDir,
     "node_modules",
     "deepline",
@@ -47328,10 +47952,10 @@ function writeSidecarLauncher(input2) {
   const esbuildProbe = "const {createRequire}=require('node:module');const path=require('node:path');const req=createRequire(path.join(process.argv[1],'package.json'));const result=req('esbuild').transformSync('const value: number = 1;',{loader:'ts'});if(!result||typeof result.code!=='string')process.exit(3);";
   const criticalPaths = [
     ...SDK_SIDECAR_CRITICAL_PACKAGE_FILES.map(
-      (path) => join23(packageRoot, path)
+      (path) => join24(packageRoot, path)
     ),
     ...SDK_SIDECAR_CRITICAL_DEPENDENCY_FILES.map(
-      (path) => join23(versionDir, "node_modules", path)
+      (path) => join24(versionDir, "node_modules", path)
     )
   ];
   if (process.platform === "win32") {
@@ -47385,14 +48009,14 @@ function writeSidecarLauncher(input2) {
   );
 }
 async function runPythonSidecarUpdatePlan(plan) {
-  const versionsDir = join23(plan.stateDir, "versions");
-  const tempDir = join23(
+  const versionsDir = join24(plan.stateDir, "versions");
+  const tempDir = join24(
     versionsDir,
     `.tmp-sdk-update-${process.pid}-${Date.now()}`
   );
   rmSync7(tempDir, { recursive: true, force: true });
   mkdirSync14(tempDir, { recursive: true });
-  writeFileSync18(join23(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
+  writeFileSync18(join24(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
   const env = {
     ...process.env,
     PATH: `${dirname18(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
@@ -47432,7 +48056,7 @@ async function runPythonSidecarUpdatePlan(plan) {
     rmSync7(tempDir, { recursive: true, force: true });
     return 1;
   }
-  const finalDir = join23(versionsDir, installedVersion);
+  const finalDir = join24(versionsDir, installedVersion);
   const finalEntryPath = entryPathInVersionDir(finalDir);
   const finalFailure = sidecarInstallFailure(finalDir);
   let backupDir = null;
@@ -47441,7 +48065,7 @@ async function runPythonSidecarUpdatePlan(plan) {
   } else {
     let shouldPublishTemp = true;
     if (existsSync18(finalDir)) {
-      backupDir = join23(
+      backupDir = join24(
         versionsDir,
         `.backup-${installedVersion}-${process.pid}-${Date.now()}`
       );
@@ -47516,27 +48140,27 @@ async function runPythonSidecarUpdatePlan(plan) {
     entryPath: finalEntryPath
   });
   writeFileSync18(
-    join23(plan.stateDir, ".version"),
+    join24(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
   writeFileSync18(
-    join23(plan.stateDir, ".install-method"),
+    join24(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
   writeFileSync18(
-    join23(plan.stateDir, ".command-path"),
+    join24(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  writeFileSync18(join23(plan.stateDir, ".runner"), "node\n", "utf8");
-  writeFileSync18(join23(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  writeFileSync18(join24(plan.stateDir, ".runner"), "node\n", "utf8");
+  writeFileSync18(join24(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
   writeFileSync18(
-    join23(plan.stateDir, ".entry-path"),
+    join24(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
     "utf8"
@@ -47803,7 +48427,7 @@ function requireCatalogEvent(settings, eventType) {
   }
   return event;
 }
-async function printSettings(options) {
+async function printSettings2(options) {
   const settings = await new DeeplineClient().getNotificationSettings();
   const slack = slackDestination(settings);
   const destinationId = typeof slack?._id === "string" ? slack._id : void 0;
@@ -47930,7 +48554,7 @@ Slack is the delivery integration. This command group only manages product
 notifications; there is no general integrations CLI.
 `
   );
-  notifications.command("get").description("Show destination, subscriptions, and DLQ health.").option("--json", "Emit JSON output").action(printSettings);
+  notifications.command("get").description("Show destination, subscriptions, and DLQ health.").option("--json", "Emit JSON output").action(printSettings2);
   notifications.command("connect").description("Start the OAuth connection required by a destination.").argument("<destination>", "Destination kind (currently slack)").option("--open", "Open the Slack authorization URL in a browser").option("--dry-run", "Describe the mutation without starting OAuth").option("--json", "Emit JSON output").action(
     async (destination, options) => {
       if (destination !== "slack")
@@ -48616,7 +49240,7 @@ import {
   writeFileSync as writeFileSync20
 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { dirname as dirname20, join as join25, resolve as resolve20 } from "path";
+import { dirname as dirname20, join as join26, resolve as resolve20 } from "path";
 
 // src/tool-output.ts
 import {
@@ -48627,7 +49251,7 @@ import {
   writeSync
 } from "fs";
 import { homedir as homedir13 } from "os";
-import { dirname as dirname19, join as join24 } from "path";
+import { dirname as dirname19, join as join25 } from "path";
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -48754,18 +49378,18 @@ function projectRowOutput(conversion) {
   };
 }
 function ensureOutputDir() {
-  const outputDir = join24(homedir13(), ".local", "share", "deepline", "data");
+  const outputDir = join25(homedir13(), ".local", "share", "deepline", "data");
   mkdirSync15(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = join24(outputDir, `${stem}_${Date.now()}.json`);
+  const outputPath = join25(outputDir, `${stem}_${Date.now()}.json`);
   writeFileSync19(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem, options) {
-  const outputPath = options?.outPath ? options.outPath : join24(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  const outputPath = options?.outPath ? options.outPath : join25(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
   mkdirSync15(dirname19(outputPath), { recursive: true });
   const columns = columnsForRows(rows);
   const escapeCell = (value) => {
@@ -49368,6 +49992,8 @@ async function searchTools(queryInput, options = {}) {
     query,
     categories: options.categories,
     searchTerms: options.searchTerms,
+    limit: options.limit,
+    offset: options.offset,
     searchMode: options.searchMode,
     includeSearchDebug: options.includeSearchDebug
   });
@@ -49598,13 +50224,15 @@ Notes:
   that can be passed to deepline tools describe or deepline tools execute.
   Provide a query, or omit it only when --categories and/or --search_terms is
   supplied. Providing neither is a usage error. Both filters accept
-  comma-separated values. Use a provider name in the query; --prefix is not a
-  supported option.
+  comma-separated values. Use --limit and --offset to page through ranked
+  results (limit 1-50, offset is zero-based); JSON includes next_offset.
+  Use a provider name in the query; --prefix is not a supported option.
   The grep alias is the same ranked retrieval surface with a more literal name
   for agents that are filtering a registry rather than choosing a workflow.
 
 Examples:
-  deepline tools search email
+  deepline tools search email --limit 10 --json
+  deepline tools search email --limit 10 --offset 10 --json
   deepline tools search --categories company_search --search_terms "investors,funding"
   deepline tools grep "company enrichment" --categories enrichment --json
   deepline tools search verifier --search-mode v2 --json
@@ -49615,10 +50243,12 @@ Examples:
   ).option(
     "--search_terms <terms>",
     "Comma-separated structured search terms; may be used without a query"
-  ).option("--search-terms <terms>", "Alias for --search_terms").option("--search-mode <mode>", "Ranked search mode: v1 or v2").option("--include-search-debug", "Include ranked search debug metadata").option("--compact", "Drop verbose fields from JSON output").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (query, options) => {
+  ).option("--search-terms <terms>", "Alias for --search_terms").option("--limit <count>", "Maximum ranked results to return (1-50)").option("--offset <count>", "Zero-based ranked result offset").option("--search-mode <mode>", "Ranked search mode: v1 or v2").option("--include-search-debug", "Include ranked search debug metadata").option("--compact", "Drop verbose fields from JSON output").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (query, options) => {
     process.exitCode = await searchTools(query, {
       json: options.json,
       compact: options.compact,
+      limit: options.limit !== void 0 ? Number.parseInt(options.limit, 10) : void 0,
+      offset: options.offset !== void 0 ? Number.parseInt(options.offset, 10) : void 0,
       categories: options.categories,
       searchTerms: options.searchTerms ?? options.search_terms,
       searchMode: options.searchMode === "v1" || options.searchMode === "v2" ? options.searchMode : void 0,
@@ -50021,8 +50651,8 @@ function printMonitorTypeFilters(tool) {
 }
 function printMonitorTypeFilterExamples(tool) {
   const documentation = recordField2(tool, "documentation");
-  const fields = recordField2(documentation, "fields");
-  const examples = Object.entries(fields).flatMap(([name, rawField]) => {
+  const fields2 = recordField2(documentation, "fields");
+  const examples = Object.entries(fields2).flatMap(([name, rawField]) => {
     const grammar = recordField2(isRecord12(rawField) ? rawField : {}, "grammar");
     const example = stringField2(grammar, "example");
     const values = [
@@ -50377,9 +51007,9 @@ function sampleValueForField(field) {
   if (type === "object") return {};
   return "...";
 }
-function samplePayloadForInputFields(fields) {
+function samplePayloadForInputFields(fields2) {
   return Object.fromEntries(
-    fields.slice(0, 4).flatMap((field) => {
+    fields2.slice(0, 4).flatMap((field) => {
       if (!isRecord12(field)) return [];
       const name = stringField2(field, "name");
       if (!name) return [];
@@ -50510,8 +51140,8 @@ function formatListedToolCost(tool) {
 }
 function toolInputFieldsForDisplay(inputSchema) {
   if (Array.isArray(inputSchema.fields)) {
-    const fields = inputSchema.fields.filter(isRecord12);
-    if (!isRecord12(inputSchema.jsonSchema)) return fields;
+    const fields2 = inputSchema.fields.filter(isRecord12);
+    if (!isRecord12(inputSchema.jsonSchema)) return fields2;
     const jsonSchemaFields = new Map(
       recursiveToolInputFieldsForDisplay({
         jsonSchema: inputSchema.jsonSchema
@@ -50519,7 +51149,7 @@ function toolInputFieldsForDisplay(inputSchema) {
         (field) => typeof field.name === "string" ? [[field.name, field]] : []
       )
     );
-    return fields.map((field) => {
+    return fields2.map((field) => {
       const jsonSchemaField = typeof field.name === "string" ? jsonSchemaFields.get(field.name) : void 0;
       const minItems = typeof field.minItems === "number" ? field.minItems : jsonSchemaField?.minItems;
       const maxItems = typeof field.maxItems === "number" ? field.maxItems : jsonSchemaField?.maxItems;
@@ -50616,7 +51246,7 @@ function publicToolInputSchemaForDescribe(inputSchema) {
 }
 function recursiveToolInputFieldsForDisplay(inputSchema) {
   const root = canonicalToolJsonSchema(inputSchema);
-  const fields = /* @__PURE__ */ new Map();
+  const fields2 = /* @__PURE__ */ new Map();
   const schemasById = /* @__PURE__ */ new Map();
   const collectSchemaIds = (value) => {
     if (Array.isArray(value)) {
@@ -50644,9 +51274,9 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
   const addField = (field) => {
     const name = typeof field.name === "string" ? field.name : "";
     if (!name) return;
-    const existing = fields.get(name);
+    const existing = fields2.get(name);
     if (!existing || existing.type === "unknown") {
-      fields.set(name, field);
+      fields2.set(name, field);
     }
   };
   const visit = (unresolvedSchema, path, required, activeRefs = /* @__PURE__ */ new Set()) => {
@@ -50694,7 +51324,7 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
     }
   };
   visit(root, "", false);
-  return fields.size ? [...fields.values()] : toolInputFieldsForDisplay(inputSchema);
+  return fields2.size ? [...fields2.values()] : toolInputFieldsForDisplay(inputSchema);
 }
 function inputFieldJsonForDescribe(field) {
   const publicItems = isRecord12(field.items) ? publicToolInputSchemaForDescribe({ items: field.items }).items : void 0;
@@ -51114,7 +51744,7 @@ function parseToolExecuteTimeout(raw) {
 function pendingToolExecutionPath(input2) {
   const config = resolveConfig();
   const fingerprint = createHash7("sha256").update(config.baseUrl).update("\0").update(createHash7("sha256").update(config.apiKey).digest("hex")).update("\0").update(input2.toolId).update("\0").update(stableStringify(input2.params)).update("\0").update(input2.responseIntent).digest("hex");
-  return join25(
+  return join26(
     sdkCliStateDirPath(resolveConfig().baseUrl),
     `pending-tool-execution-${fingerprint}.json`
   );
@@ -51198,9 +51828,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = mkdtempSync(join25(tmpdir6(), "deepline-workflow-seed-"));
+  const scriptDir = mkdtempSync(join26(tmpdir6(), "deepline-workflow-seed-"));
   chmodSync(scriptDir, 448);
-  const scriptPath = join25(scriptDir, fileName);
+  const scriptPath = join26(scriptDir, fileName);
   const projectDir = `deepline/projects/${stem}-workflow`;
   const playName = `${stem}-workflow`;
   const sampleRows = input2.rows.length > 0 ? `${JSON.stringify(input2.rows.slice(0, 2)).replace(/\]$/, "")}, ...]` : "[]";
@@ -51705,8 +52335,8 @@ Examples:
 }
 
 // src/cli/commands/workflow.ts
-import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname21, join as join26, resolve as resolve21 } from "path";
+import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname21, join as join27, resolve as resolve21 } from "path";
 
 // src/cli/workflow-to-play.ts
 import { createHash as createHash8 } from "crypto";
@@ -51923,7 +52553,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await readFile6(resolve21(file), "utf8");
+    const raw = await readFile7(resolve21(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -51957,7 +52587,7 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = join26(resolve21(outDir), `${compiled.playName}.play.ts`);
+    const file = join27(resolve21(outDir), `${compiled.playName}.play.ts`);
     await mkdir6(dirname21(file), { recursive: true });
     await writeFile5(file, compiled.sourceCode, "utf8");
     let published = false;
@@ -52504,8 +53134,8 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await mkdtemp4(join27(tmpdir7(), "deepline-health-play-"));
-  const file = join27(dir, "health-check.play.ts");
+  const dir = await mkdtemp4(join28(tmpdir7(), "deepline-health-play-"));
+  const file = join28(dir, "health-check.play.ts");
   try {
     await writeFile6(
       file,