deepline 0.3.213 → 0.3.215

package/dist/cli/index.js

@@ -1963,8 +1963,8 @@ function configureProxyFromEnv() {
 configureProxyFromEnv();
 
 // src/cli/index.ts
-var import_promises14 = require("fs/promises");
-var import_node_path32 = require("path");
+var import_promises15 = require("fs/promises");
+var import_node_path33 = require("path");
 var import_node_os20 = require("os");
 var import_commander5 = require("commander");
 
@@ -3051,7 +3051,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
@@ -3372,6 +3372,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";
@@ -3754,16 +3770,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;
@@ -4892,13 +4905,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
@@ -4906,7 +4919,7 @@ function previewValue(value, input2) {
     }
     return {
       kind: "object",
-      fields,
+      fields: fields2,
       totalFields: entries.length,
       ...entries.length > selected.length ? { truncated: true } : {}
     };
@@ -5015,20 +5028,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;
@@ -7040,10 +7053,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
   };
 }
@@ -7225,18 +7247,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;
@@ -7379,14 +7389,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;
@@ -7573,6 +7583,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());
     }
@@ -8634,9 +8650,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;
     }
@@ -8677,7 +8702,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`
@@ -8853,9 +8881,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");
@@ -8906,6 +8932,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, {
@@ -8918,9 +8945,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)) {
@@ -8928,15 +8954,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) {
@@ -9225,6 +9247,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`, {
@@ -10842,6 +10884,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),
@@ -11706,8 +11749,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" };
 }
@@ -15513,14 +15556,14 @@ function customerDbColumnNames(result) {
 function errorMessage(value) {
   return value instanceof Error ? value.message : String(value ?? "");
 }
-function resolveDbQuerySql(rawSql, readFile7 = (path) => (0, import_node_fs8.readFileSync)(path, "utf8")) {
+function resolveDbQuerySql(rawSql, readFile8 = (path) => (0, import_node_fs8.readFileSync)(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((0, import_node_path9.resolve)(filePath)).trim();
+  return readFile8((0, import_node_path9.resolve)(filePath)).trim();
 }
 function collectErrorText(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -15886,16 +15929,342 @@ Examples:
 }
 
 // src/cli/commands/enrich.ts
-var import_promises10 = require("fs/promises");
+var import_promises11 = require("fs/promises");
 var import_node_os10 = require("os");
-var import_node_path18 = require("path");
+var import_node_path19 = require("path");
 var import_commander2 = require("commander");
 
+// ../plays/settings-contract.ts
+var import_zod = require("zod");
+function formatPlaySettingsError(error) {
+  if (error instanceof import_zod.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 = import_zod.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 = import_zod.z.union([
+  import_zod.z.null(),
+  import_zod.z.object({
+    root: import_zod.z.enum(["person", "team"]),
+    folders: import_zod.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 = import_zod.z.object(
+  Object.fromEntries(
+    Object.entries(PLAY_SETTING_FIELDS).map(([key, field]) => [
+      key,
+      field.schema
+    ])
+  )
+).passthrough();
+var playSettingsPatchSchema = import_zod.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
 var import_node_crypto7 = require("crypto");
 var import_node_fs12 = require("fs");
-var import_promises9 = require("fs/promises");
-var import_node_path17 = require("path");
+var import_promises10 = require("fs/promises");
+var import_node_path18 = require("path");
 var import_sync5 = require("csv-parse/sync");
 
 // src/cli/commands/plays/bootstrap.ts
@@ -16506,8 +16875,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}.`
@@ -17596,6 +17965,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
 var import_node_os8 = require("os");
 var import_node_path13 = require("path");
@@ -20481,7 +20889,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();
   }
@@ -20492,7 +20900,7 @@ async function traceCliSpan(phase, fields, run) {
       phase,
       ms: Date.now() - startedAt,
       ok: true,
-      ...fields
+      ...fields2
     });
     return result;
   } catch (error) {
@@ -20501,7 +20909,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;
   }
@@ -21148,13 +21556,13 @@ function normalizeFixtureScopeValue(value, maxLength) {
 
 // src/cli/commands/plays-deploy.ts
 var import_node_crypto6 = require("crypto");
-var import_promises8 = require("fs/promises");
+var import_promises9 = require("fs/promises");
 var import_node_os9 = require("os");
-var import_node_path16 = require("path");
+var import_node_path17 = require("path");
 
 // ../plays/deploy/run-deployment.ts
-var import_node_path15 = require("path");
-var import_promises7 = require("fs/promises");
+var import_node_path16 = require("path");
+var import_promises8 = require("fs/promises");
 
 // ../plays/deployment-status.ts
 var TERMINAL_PLAY_DEPLOYMENT_STATUSES = /* @__PURE__ */ new Set([
@@ -21262,6 +21670,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",
@@ -21314,7 +21737,8 @@ var import_promises6 = require("fs/promises");
 var import_node_path14 = require("path");
 var import_picomatch = __toESM(require_picomatch2(), 1);
 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",
@@ -21328,9 +21752,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 {
@@ -21344,24 +21785,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) {
@@ -21391,7 +21822,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) {
@@ -21408,9 +21839,9 @@ async function discoverPlayFiles(input2) {
       const relativePath = (0, import_node_path14.relative)(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.`
           );
         }
       }
@@ -21425,6 +21856,39 @@ async function discoverPlayFiles(input2) {
   await walk(input2.projectRoot);
   return found.sort();
 }
+var discoverPlayFiles = discoverDeploymentFiles;
+
+// ../plays/deploy/monitor-files.ts
+var import_promises7 = require("fs/promises");
+var import_node_path15 = require("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 (0, import_promises7.readFile)((0, import_node_path15.join)(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";
@@ -21640,12 +22104,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 } : {}
       });
@@ -21664,15 +22131,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 } : {}
       });
@@ -21689,11 +22159,12 @@ async function runDeployment(params, hooks) {
     return {
       finalStatus,
       outcomes,
+      ...monitorRunResult(),
       checkRunId: checkRun?.checkRunId
     };
   };
-  await (0, import_promises7.mkdir)(hooks.workRoot, { recursive: true });
-  const workDir = await (0, import_promises7.mkdtemp)((0, import_node_path15.join)(hooks.workRoot, "deploy-"));
+  await (0, import_promises8.mkdir)(hooks.workRoot, { recursive: true });
+  const workDir = await (0, import_promises8.mkdtemp)((0, import_node_path16.join)(hooks.workRoot, "deploy-"));
   const postCheck = async (postCheckOnce, input2) => {
     let lastError;
     for (let attempt = 0; ; attempt += 1) {
@@ -21769,7 +22240,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;
       });
@@ -21809,6 +22280,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: [] };
@@ -21818,16 +22290,28 @@ async function runDeployment(params, hooks) {
       if (superseded) return superseded;
     }
     const { repoRoot } = await source.open(workDir);
-    const projectRoot = target.rootDirectory ? (0, import_node_path15.join)(repoRoot, target.rootDirectory) : repoRoot;
+    const projectRoot = target.rootDirectory ? (0, import_node_path16.join)(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({
@@ -21852,7 +22336,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",
@@ -21879,7 +22384,7 @@ async function runDeployment(params, hooks) {
       annotations.push(annotationForFailure({ file, message }));
     };
     for (const file of playFiles) {
-      const entryFile = (0, import_node_path15.join)(projectRoot, file);
+      const entryFile = (0, import_node_path16.join)(projectRoot, file);
       const result = await hooks.bundle(entryFile, {
         sourceIdentityRoot: projectRoot
       });
@@ -21985,7 +22490,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])
     );
@@ -22119,12 +22624,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", {
@@ -22138,6 +22646,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);
@@ -22195,12 +22748,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) {
@@ -22246,12 +22802,13 @@ 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);
     throw error;
   } finally {
-    await (0, import_promises7.rm)(workDir, { recursive: true, force: true }).catch(() => void 0);
+    await (0, import_promises8.rm)(workDir, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 function topoSortByPlayDependencies(plays) {
@@ -22315,8 +22872,8 @@ function printResult(input2) {
   );
 }
 async function handlePlaysDeploy(directory, options) {
-  const root = await (0, import_promises8.realpath)((0, import_node_path16.resolve)(directory ?? ".")).catch(() => {
-    throw new Error(`No such directory: ${(0, import_node_path16.resolve)(directory ?? ".")}`);
+  const root = await (0, import_promises9.realpath)((0, import_node_path17.resolve)(directory ?? ".")).catch(() => {
+    throw new Error(`No such directory: ${(0, import_node_path17.resolve)(directory ?? ".")}`);
   });
   const { http, config } = getAuthedHttpClient();
   const deliveryId = `local:${(0, import_node_crypto6.randomUUID)()}`;
@@ -22327,7 +22884,7 @@ async function handlePlaysDeploy(directory, options) {
     ...options.commit ? { commit: options.commit } : {}
   });
   const { bundleDeployPlayFile } = await loadPlayBundler();
-  const workRoot = await (0, import_promises8.mkdtemp)((0, import_node_path16.join)((0, import_node_os9.tmpdir)(), "deepline-deploy-"));
+  const workRoot = await (0, import_promises9.mkdtemp)((0, import_node_path17.join)((0, import_node_os9.tmpdir)(), "deepline-deploy-"));
   const consoleInfo = console.info;
   console.info = console.error;
   try {
@@ -22345,6 +22902,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 })
@@ -22380,7 +22938,7 @@ async function handlePlaysDeploy(directory, options) {
     }
   } finally {
     console.info = consoleInfo;
-    await (0, import_promises8.rm)(workRoot, { recursive: true, force: true });
+    await (0, import_promises9.rm)(workRoot, { recursive: true, force: true });
   }
 }
 
@@ -22728,10 +23286,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(
     {
@@ -22743,7 +23313,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 }] : []
         ]
       }
     },
@@ -22939,7 +23510,7 @@ function isBarePlayRunDebugFlag(args, index) {
 }
 async function pathExistsIncludingSymlink(path) {
   try {
-    await (0, import_promises9.lstat)(path);
+    await (0, import_promises10.lstat)(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -22949,14 +23520,14 @@ async function pathExistsIncludingSymlink(path) {
   }
 }
 function runIdFileTempPath(destination) {
-  return (0, import_node_path17.join)(
-    (0, import_node_path17.dirname)(destination),
-    `.${(0, import_node_path17.basename)(destination)}.${process.pid}.${(0, import_node_crypto7.randomUUID)()}.tmp`
+  return (0, import_node_path18.join)(
+    (0, import_node_path18.dirname)(destination),
+    `.${(0, import_node_path18.basename)(destination)}.${process.pid}.${(0, import_node_crypto7.randomUUID)()}.tmp`
   );
 }
 async function removeRunIdTempFile(path) {
   try {
-    await (0, import_promises9.unlink)(path);
+    await (0, import_promises10.unlink)(path);
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -22964,7 +23535,7 @@ async function removeRunIdTempFile(path) {
   }
 }
 async function preflightRunIdFile(path) {
-  const destination = (0, import_node_path17.resolve)(path);
+  const destination = (0, import_node_path18.resolve)(path);
   if (await pathExistsIncludingSymlink(destination)) {
     throw new Error(
       `--run-id-file destination already exists: ${destination}. Choose a new path so this run cannot overwrite another run identity.`
@@ -22973,7 +23544,7 @@ async function preflightRunIdFile(path) {
   const tempPath = runIdFileTempPath(destination);
   let handle = null;
   try {
-    handle = await (0, import_promises9.open)(tempPath, "wx", 384);
+    handle = await (0, import_promises10.open)(tempPath, "wx", 384);
     await handle.sync();
   } catch (error) {
     throw new Error(
@@ -22991,7 +23562,7 @@ async function readRunIdFile(destination) {
   }
   let parsed;
   try {
-    parsed = JSON.parse(await (0, import_promises9.readFile)(destination, "utf8"));
+    parsed = JSON.parse(await (0, import_promises10.readFile)(destination, "utf8"));
   } catch (error) {
     throw new Error(
       `--run-id-file destination contains invalid JSON: ${destination}. Refusing to overwrite it (${error instanceof Error ? error.message : String(error)}).`
@@ -23017,7 +23588,7 @@ async function writePlayRunIdFile(destination, runId, options = {}) {
   const tempPath = runIdFileTempPath(destination);
   let handle = null;
   try {
-    handle = await (0, import_promises9.open)(tempPath, "wx", 384);
+    handle = await (0, import_promises10.open)(tempPath, "wx", 384);
     await handle.writeFile(
       `${JSON.stringify({ version: 1, runId, ...options })}
 `,
@@ -23027,10 +23598,10 @@ async function writePlayRunIdFile(destination, runId, options = {}) {
     await handle.close();
     handle = null;
     if (existing) {
-      await (0, import_promises9.rename)(tempPath, destination);
+      await (0, import_promises10.rename)(tempPath, destination);
     } else {
       try {
-        await (0, import_promises9.link)(tempPath, destination);
+        await (0, import_promises10.link)(tempPath, destination);
       } catch (error) {
         if (error.code !== "EEXIST") throw error;
         const raced = await readRunIdFile(destination);
@@ -23040,11 +23611,11 @@ async function writePlayRunIdFile(destination, runId, options = {}) {
           );
         }
         if (!options.launchConfirmed || raced.launchConfirmed) return;
-        await (0, import_promises9.rename)(tempPath, destination);
+        await (0, import_promises10.rename)(tempPath, destination);
       }
     }
     if (process.platform !== "win32") {
-      const directory = await (0, import_promises9.open)((0, import_node_path17.dirname)(destination), "r");
+      const directory = await (0, import_promises10.open)((0, import_node_path18.dirname)(destination), "r");
       try {
         await directory.sync();
       } finally {
@@ -23056,7 +23627,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();
@@ -23064,7 +23635,7 @@ function traceCliSync(phase, fields, run) {
       phase,
       ms: Date.now() - startedAt,
       ok: true,
-      ...fields
+      ...fields2
     });
     return result;
   } catch (error) {
@@ -23073,7 +23644,7 @@ function traceCliSync(phase, fields, run) {
       ms: Date.now() - startedAt,
       ok: false,
       error: error instanceof Error ? error.message : String(error),
-      ...fields
+      ...fields2
     });
     throw error;
   }
@@ -23333,7 +23904,7 @@ function formatPlayListReference(play) {
   return play.reference || play.name;
 }
 function defaultMaterializedPlayPath(reference) {
-  return (0, import_node_path17.resolve)(defaultStarterPlayPath(reference));
+  return (0, import_node_path18.resolve)(defaultStarterPlayPath(reference));
 }
 function defaultStarterPlayPath(reference) {
   const playName = parseReferencedPlayTarget2(reference).unqualifiedPlayName;
@@ -23366,18 +23937,18 @@ function materializeRemotePlaySource(input2) {
         `Play ${input2.playName} has ${files.length} source files. Use --out <directory> to write the complete bundle.`
       );
     }
-    const outputDirectory = (0, import_node_path17.resolve)(input2.outPath);
+    const outputDirectory = (0, import_node_path18.resolve)(input2.outPath);
     let created = 0;
     let updated = 0;
     for (const [logicalPath, sourceCode] of files) {
-      const outputPath2 = (0, import_node_path17.resolve)(outputDirectory, logicalPath);
-      const outputRelativePath = (0, import_node_path17.relative)(outputDirectory, outputPath2);
-      if (!outputRelativePath || outputRelativePath.startsWith("..") || (0, import_node_path17.isAbsolute)(outputRelativePath)) {
+      const outputPath2 = (0, import_node_path18.resolve)(outputDirectory, logicalPath);
+      const outputRelativePath = (0, import_node_path18.relative)(outputDirectory, outputPath2);
+      if (!outputRelativePath || outputRelativePath.startsWith("..") || (0, import_node_path18.isAbsolute)(outputRelativePath)) {
         throw new Error(
           `Refusing to materialize unsafe Play source path ${JSON.stringify(logicalPath)}.`
         );
       }
-      (0, import_node_fs12.mkdirSync)((0, import_node_path17.dirname)(outputPath2), { recursive: true });
+      (0, import_node_fs12.mkdirSync)((0, import_node_path18.dirname)(outputPath2), { recursive: true });
       if (!(0, import_node_fs12.existsSync)(outputPath2)) {
         (0, import_node_fs12.writeFileSync)(outputPath2, sourceCode, "utf-8");
         created += 1;
@@ -23447,7 +24018,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return (0, import_node_fs12.existsSync)((0, import_node_path17.resolve)(target));
+  return (0, import_node_fs12.existsSync)((0, import_node_path18.resolve)(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -23476,7 +24047,7 @@ function parsePositiveInteger3(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? (0, import_node_fs12.readFileSync)((0, import_node_path17.resolve)(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? (0, import_node_fs12.readFileSync)((0, import_node_path18.resolve)(raw.slice(1)), "utf-8") : raw;
   const parsed = JSON.parse(source);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("--input must be a JSON object.");
@@ -23580,7 +24151,7 @@ function fileInputBindingsFromStaticPipeline(staticPipeline) {
 function isLocalFilePathValue(value) {
   if (typeof value !== "string" || !value.trim()) return false;
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
-  return (0, import_node_fs12.existsSync)((0, import_node_path17.resolve)(value));
+  return (0, import_node_fs12.existsSync)((0, import_node_path18.resolve)(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -23627,7 +24198,7 @@ function collectLocalFileInputRefs(value, inputPath, key, out) {
     const looksLikeFile = /\.[a-z0-9]{1,8}$/i.test(trimmed);
     if (keyIsCsvData) {
       out.push({ inputPath, value: trimmed, isCsvData: true });
-    } else if (endsWithCsv || looksLikeFile && (0, import_node_fs12.existsSync)((0, import_node_path17.resolve)(trimmed))) {
+    } else if (endsWithCsv || looksLikeFile && (0, import_node_fs12.existsSync)((0, import_node_path18.resolve)(trimmed))) {
       out.push({ inputPath, value: trimmed, isCsvData: false });
     }
     return;
@@ -23669,7 +24240,7 @@ function preflightLocalFileInputs(runtimeInput) {
     collectLocalFileInputRefs(value, key, key, refs);
   }
   for (const ref of refs) {
-    const absolutePath = (0, import_node_path17.resolve)(ref.value);
+    const absolutePath = (0, import_node_path18.resolve)(ref.value);
     if (!(0, import_node_fs12.existsSync)(absolutePath)) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that does not exist: ${ref.value} (resolved to ${absolutePath}). No run was created.`,
@@ -23788,8 +24359,8 @@ async function stageFileInputArgs(input2) {
   const localFiles = uniqueBindings.flatMap((binding) => {
     const value = getDottedInputValue(input2.runtimeInput, binding.inputPath);
     if (!isLocalFilePathValue(value)) return [];
-    const absolutePath = (0, import_node_path17.resolve)(value);
-    return [{ binding, absolutePath, logicalPath: (0, import_node_path17.basename)(absolutePath) }];
+    const absolutePath = (0, import_node_path18.resolve)(value);
+    return [{ binding, absolutePath, logicalPath: (0, import_node_path18.basename)(absolutePath) }];
   });
   if (localFiles.length === 0) {
     return { inputFile: null, packagedFiles: [] };
@@ -23832,9 +24403,9 @@ function stageFile(logicalPath, absolutePath) {
 }
 function normalizePlayPath(filePath) {
   try {
-    return import_node_fs12.realpathSync.native((0, import_node_path17.resolve)(filePath));
+    return import_node_fs12.realpathSync.native((0, import_node_path18.resolve)(filePath));
   } catch {
-    return (0, import_node_path17.resolve)(filePath);
+    return (0, import_node_path18.resolve)(filePath);
   }
 }
 function formatBundlingErrors(filePath, errors) {
@@ -24397,7 +24968,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() : "";
@@ -25283,8 +25855,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\)$/
@@ -26338,6 +26910,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";
@@ -26407,6 +27027,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, {
@@ -26414,12 +27036,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";
@@ -26449,7 +27066,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}`);
   }
@@ -26649,7 +27265,7 @@ function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function runExportRetryCommand(runId, outPath, datasetPath) {
-  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote((0, import_node_path17.resolve)(outPath))}`;
+  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote((0, import_node_path18.resolve)(outPath))}`;
 }
 function extractRunPlayName(status) {
   const run = status.run;
@@ -26791,7 +27407,7 @@ async function fetchBackingDatasetRows(input2) {
 function exportDatasetCommand(input2) {
   return `deepline runs export ${input2.runId} --dataset ${shellSingleQuote(
     input2.datasetPath
-  )} --out ${shellSingleQuote((0, import_node_path17.resolve)(input2.outPath))}`;
+  )} --out ${shellSingleQuote((0, import_node_path18.resolve)(input2.outPath))}`;
 }
 function datasetChoiceLines(input2) {
   return input2.datasets.flatMap((dataset) => {
@@ -28115,7 +28731,7 @@ async function handlePlayCheck(args) {
       }
       return 0;
     } catch (error) {
-      const resolved = (0, import_node_path17.resolve)(options.target);
+      const resolved = (0, import_node_path18.resolve)(options.target);
       const message = error instanceof Error && error.message ? error.message : `File not found: ${resolved}`;
       if (options.jsonOutput) {
         printCompactJson({
@@ -28129,7 +28745,7 @@ async function handlePlayCheck(args) {
       return 1;
     }
   }
-  const absolutePlayPath = (0, import_node_path17.resolve)(options.target);
+  const absolutePlayPath = (0, import_node_path18.resolve)(options.target);
   const sourceCode = (0, import_node_fs12.readFileSync)(absolutePlayPath, "utf-8");
   const exportNames = resolvePlayCheckExportNames(sourceCode);
   const outcomes = [];
@@ -28371,7 +28987,7 @@ async function handleFileBackedRun(options, hooks) {
   }
   const client2 = new DeeplineClient(playRunClientOptions(options));
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  const absolutePlayPath = (0, import_node_path17.resolve)(options.target.path);
+  const absolutePlayPath = (0, import_node_path18.resolve)(options.target.path);
   progress.phase("compiling play");
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
@@ -28788,11 +29404,11 @@ async function handlePlayRun(args, hooks) {
     if (isFileTarget(options.target.path)) {
       return handleFileBackedRun(options, runHooks);
     }
-    const resolved = (0, import_node_path17.resolve)(options.target.path);
+    const resolved = (0, import_node_path18.resolve)(options.target.path);
     console.error(`File not found: ${resolved}`);
-    const dir = (0, import_node_path17.dirname)(resolved);
+    const dir = (0, import_node_path18.dirname)(resolved);
     if ((0, import_node_fs12.existsSync)(dir)) {
-      const base = (0, import_node_path17.basename)(resolved);
+      const base = (0, import_node_path18.basename)(resolved);
       try {
         const siblings = (0, import_node_fs12.readdirSync)(dir).filter(
           (f) => f.includes(base.replace(/\.(play\.)?ts$/, "")) || f.endsWith(".play.ts")
@@ -28800,7 +29416,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(`  ${(0, import_node_path17.join)(dir, s)}`);
+            console.error(`  ${(0, import_node_path18.join)(dir, s)}`);
           }
         }
       } catch {
@@ -29237,7 +29853,7 @@ async function handleRunLogs(args) {
       continue;
     }
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path17.resolve)(args[++index]);
+      outPath = (0, import_node_path18.resolve)(args[++index]);
       continue;
     }
     if (arg.startsWith("--")) {
@@ -29533,7 +30149,7 @@ async function handleRunExport(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path17.resolve)(args[++index]);
+      outPath = (0, import_node_path18.resolve)(args[++index]);
       continue;
     }
     if (arg === "--dataset" && args[index + 1]) {
@@ -29541,7 +30157,7 @@ async function handleRunExport(args) {
       continue;
     }
     if (arg === "--metadata-out" && args[index + 1]) {
-      metadataOutPath = (0, import_node_path17.resolve)(args[++index]);
+      metadataOutPath = (0, import_node_path18.resolve)(args[++index]);
     }
   }
   if (!outPath) {
@@ -29637,7 +30253,7 @@ async function handlePlayGet(args) {
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path17.resolve)(args[++index]);
+      outPath = (0, import_node_path18.resolve)(args[++index]);
     }
     if (arg === "--revision") {
       const rawVersion = args[++index];
@@ -29658,7 +30274,7 @@ async function handlePlayGet(args) {
     );
     return 2;
   }
-  const playName = isFileTarget(target) ? extractPlayName((0, import_node_fs12.readFileSync)((0, import_node_path17.resolve)(target), "utf-8"), (0, import_node_path17.resolve)(target)) : parseReferencedPlayTarget2(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName((0, import_node_fs12.readFileSync)((0, import_node_path18.resolve)(target), "utf-8"), (0, import_node_path18.resolve)(target)) : parseReferencedPlayTarget2(target).playName;
   const includeSource = sourceOutput || outPath !== null;
   const detail = isFileTarget(target) ? await client2.getPlay(
     playName,
@@ -30044,8 +30660,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);
 }
@@ -30062,9 +30678,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");
   }
@@ -30073,14 +30689,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);
@@ -30204,7 +30820,7 @@ async function handlePlayDescribe(args) {
     const definedName = isFileTarget(playName) ? (() => {
       try {
         return extractPlayName(
-          (0, import_node_fs12.readFileSync)((0, import_node_path17.resolve)(playName), "utf-8"),
+          (0, import_node_fs12.readFileSync)((0, import_node_path18.resolve)(playName), "utf-8"),
           playName
         );
       } catch {
@@ -30266,7 +30882,7 @@ async function handlePlaySave(args) {
     graph = await traceCliSpan(
       "cli.play_save_bundle_graph",
       { targetKind: "file" },
-      () => collectBundledPlayGraph((0, import_node_path17.resolve)(options.target))
+      () => collectBundledPlayGraph((0, import_node_path18.resolve)(options.target))
     );
     assertBundledPlayGraphDescriptions(graph);
   } catch (error) {
@@ -30391,7 +31007,7 @@ async function handlePlayPublish(args) {
       graph = await traceCliSpan(
         "cli.play_publish_bundle_graph",
         { targetKind: "file" },
-        () => collectBundledPlayGraph((0, import_node_path17.resolve)(playName))
+        () => collectBundledPlayGraph((0, import_node_path18.resolve)(playName))
       );
       assertBundledPlayGraphDescriptions(graph);
     } catch (error) {
@@ -30709,6 +31325,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:
@@ -30914,6 +31532,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(
@@ -31182,6 +31801,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
@@ -31325,7 +31946,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"] : []
@@ -33509,7 +34133,7 @@ function expandAtFilePath(rawPath) {
     return (0, import_node_os10.homedir)();
   }
   if (expanded.startsWith("~/") || expanded.startsWith("~\\")) {
-    return (0, import_node_path18.join)((0, import_node_os10.homedir)(), expanded.slice(2));
+    return (0, import_node_path19.join)((0, import_node_os10.homedir)(), expanded.slice(2));
   }
   return expanded;
 }
@@ -33522,7 +34146,7 @@ async function readAtFileReference(value, argumentName, strip = true) {
     throw new Error(`Invalid ${argumentName} value: empty @file path.`);
   }
   try {
-    const text = await (0, import_promises10.readFile)(filePath, "utf8");
+    const text = await (0, import_promises11.readFile)(filePath, "utf8");
     const normalized = text.replace(/^\uFEFF/, "");
     return strip ? normalized.trim() : normalized;
   } catch (error) {
@@ -33686,7 +34310,7 @@ function createSdkEnrichTelemetryContext(input2) {
     runId: `sdk-enrich-${process.pid}-${Date.now()}`,
     command: sdkEnrichCommandText(input2.args),
     rowsRange: input2.rowsRange,
-    inputPath: (0, import_node_path18.basename)(input2.inputCsv),
+    inputPath: (0, import_node_path19.basename)(input2.inputCsv),
     startedAtMs: Date.now(),
     rowsTargeted: input2.selectedRange.count,
     columnsTargeted: countConfiguredEnrichColumns(input2.config)
@@ -33818,9 +34442,9 @@ async function buildPlanArgs(args) {
   return planArgs;
 }
 async function assertInputCsvExists(inputCsv) {
-  const path = (0, import_node_path18.resolve)(inputCsv);
+  const path = (0, import_node_path19.resolve)(inputCsv);
   try {
-    const info = await (0, import_promises10.stat)(path);
+    const info = await (0, import_promises11.stat)(path);
     if (info.isFile()) {
       return;
     }
@@ -33832,8 +34456,8 @@ async function assertInputCsvExists(inputCsv) {
   }
 }
 async function assertSafeOutputPath(inputCsv, outputPath) {
-  const input2 = (0, import_node_path18.resolve)(inputCsv);
-  const output2 = (0, import_node_path18.resolve)(outputPath);
+  const input2 = (0, import_node_path19.resolve)(inputCsv);
+  const output2 = (0, import_node_path19.resolve)(outputPath);
   if (input2 === output2) {
     throw new Error(
       "--input and --output must be different files when not using --in-place."
@@ -33841,8 +34465,8 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
   }
   try {
     const [inputInfo, outputInfo] = await Promise.all([
-      (0, import_promises10.stat)(input2),
-      (0, import_promises10.stat)(output2)
+      (0, import_promises11.stat)(input2),
+      (0, import_promises11.stat)(output2)
     ]);
     if (inputInfo.dev === outputInfo.dev && inputInfo.ino === outputInfo.ino) {
       throw new Error(
@@ -33862,7 +34486,7 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
 }
 async function regularFileExists(path) {
   try {
-    const info = await (0, import_promises10.stat)((0, import_node_path18.resolve)(path));
+    const info = await (0, import_promises11.stat)((0, import_node_path19.resolve)(path));
     return info.isFile();
   } catch (error) {
     const code = error && typeof error === "object" ? error.code : void 0;
@@ -33873,7 +34497,7 @@ async function regularFileExists(path) {
   }
 }
 async function readConfig(path) {
-  const source = await (0, import_promises10.readFile)((0, import_node_path18.resolve)(path), "utf8");
+  const source = await (0, import_promises11.readFile)((0, import_node_path19.resolve)(path), "utf8");
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -34294,8 +34918,8 @@ async function writeOutputCsv(outputPath, status, options) {
     ]),
     options?.config
   );
-  await (0, import_promises10.writeFile)(
-    (0, import_node_path18.resolve)(outputPath),
+  await (0, import_promises11.writeFile)(
+    (0, import_node_path19.resolve)(outputPath),
     csvStringFromRows(merged.rows, columns),
     "utf8"
   );
@@ -34305,7 +34929,7 @@ async function writeOutputCsv(outputPath, status, options) {
     selectedRows: rowsInfo.totalRows,
     enrichedRows: rowsInfo.rows.length,
     rows: merged.rows.length,
-    path: (0, import_node_path18.resolve)(outputPath),
+    path: (0, import_node_path19.resolve)(outputPath),
     partial: !rowsInfo.complete,
     enrichedDataRows: rowsInfo.rows
   };
@@ -34486,7 +35110,7 @@ function enrichCustomerDbJson(input2) {
         ...actions.slowExportAsCsvCommand ? { command: actions.slowExportAsCsvCommand } : runId && input2.outputPath ? {
           command: `deepline runs export ${runId} --dataset ${shellSingleQuote2(
             exportDatasetPath
-          )} --out ${shellSingleQuote2((0, import_node_path18.resolve)(input2.outputPath))}`
+          )} --out ${shellSingleQuote2((0, import_node_path19.resolve)(input2.outputPath))}`
         } : {},
         action: actions.exportCsv ?? {}
       }
@@ -34931,9 +35555,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");
@@ -35883,15 +36507,15 @@ function addEnrichRowsExportFollowUpCommand(commands, seen, input2) {
     label: "export enrich rows",
     path: GENERATED_ENRICH_ROWS_TABLE_NAMESPACE,
     command: `deepline runs export ${input2.runId} --dataset ${GENERATED_ENRICH_ROWS_TABLE_NAMESPACE} --out ${shellSingleQuote2(
-      (0, import_node_path18.resolve)(input2.outputPath)
+      (0, import_node_path19.resolve)(input2.outputPath)
     )}`
   });
 }
 function sidecarEnrichRowsExportPath(outputPath) {
-  const resolved = (0, import_node_path18.resolve)(outputPath);
-  const ext = (0, import_node_path18.extname)(resolved) || ".csv";
-  const stem = (0, import_node_path18.basename)(resolved, ext);
-  return (0, import_node_path18.join)((0, import_node_path18.dirname)(resolved), `${stem}.deepline-enrich-rows${ext}`);
+  const resolved = (0, import_node_path19.resolve)(outputPath);
+  const ext = (0, import_node_path19.extname)(resolved) || ".csv";
+  const stem = (0, import_node_path19.basename)(resolved, ext);
+  return (0, import_node_path19.join)((0, import_node_path19.dirname)(resolved), `${stem}.deepline-enrich-rows${ext}`);
 }
 function collectDatasetFollowUpCommands(value, state) {
   if (state.depth > 12 || !value || typeof value !== "object" || state.commands.length >= 8) {
@@ -35932,7 +36556,7 @@ function collectDatasetFollowUpCommands(value, state) {
         path: selector,
         command: `deepline runs export ${state.runId} --dataset ${shellSingleQuote2(
           selector
-        )} --out ${shellSingleQuote2((0, import_node_path18.resolve)(state.outputPath))}`
+        )} --out ${shellSingleQuote2((0, import_node_path19.resolve)(state.outputPath))}`
       });
     }
   }
@@ -35972,10 +36596,10 @@ async function persistEnrichFailureReport(input2) {
   if (input2.jobs.length === 0 && input2.issues.length === 0) {
     return null;
   }
-  const stateDir = (0, import_node_path18.join)((0, import_node_os10.homedir)(), ".local", "deepline", "runtime", "state");
+  const stateDir = (0, import_node_path19.join)((0, import_node_os10.homedir)(), ".local", "deepline", "runtime", "state");
   const reportPrefix = input2.jobs.length > 0 ? "run-block-failures" : "enrich-issues";
-  await (0, import_promises10.mkdir)(stateDir, { recursive: true });
-  const reportPath = (0, import_node_path18.join)(
+  await (0, import_promises11.mkdir)(stateDir, { recursive: true });
+  const reportPath = (0, import_node_path19.join)(
     stateDir,
     `${reportPrefix}-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
   );
@@ -36000,7 +36624,7 @@ async function persistEnrichFailureReport(input2) {
   if (input2.rows.rowStart !== null && input2.rows.rowEnd !== null) {
     report.rows = { start: input2.rows.rowStart, end: input2.rows.rowEnd };
   }
-  await (0, import_promises10.writeFile)(reportPath, `${JSON.stringify(report, null, 2)}
+  await (0, import_promises11.writeFile)(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   return reportPath;
 }
@@ -36858,8 +37482,8 @@ function registerEnrichCommand(program) {
       if (options.json) {
         printJson({
           dryRun: true,
-          input: (0, import_node_path18.resolve)(inputCsv),
-          output: options.output ? (0, import_node_path18.resolve)(options.output) : null,
+          input: (0, import_node_path19.resolve)(inputCsv),
+          output: options.output ? (0, import_node_path19.resolve)(options.output) : null,
           plan: summary
         });
         return;
@@ -36870,7 +37494,7 @@ function registerEnrichCommand(program) {
     }
     const rows = parseRows(options.rows, options.all);
     let outputPath = options.inPlace ? inputCsv : options.output;
-    const requestedOutputPath = options.inPlace ? (0, import_node_path18.resolve)(inputCsv) : options.output ? (0, import_node_path18.resolve)(options.output) : void 0;
+    const requestedOutputPath = options.inPlace ? (0, import_node_path19.resolve)(inputCsv) : options.output ? (0, import_node_path19.resolve)(options.output) : void 0;
     const sourceCsvPath = !options.inPlace && outputPath && await regularFileExists(outputPath) ? outputPath : inputCsv;
     const forceAliases = resolveForceAliases(config, options);
     for (const alias of collectFailedInputAliases(
@@ -36904,13 +37528,13 @@ function registerEnrichCommand(program) {
       sdkEnrichTelemetryCompleted = true;
       await completeSdkEnrichTelemetry(sdkEnrichTelemetry, input2);
     };
-    const tempDir = await (0, import_promises10.mkdtemp)((0, import_node_path18.join)((0, import_node_os10.tmpdir)(), "deepline-enrich-play-"));
+    const tempDir = await (0, import_promises11.mkdtemp)((0, import_node_path19.join)((0, import_node_os10.tmpdir)(), "deepline-enrich-play-"));
     await emitSdkEnrichTelemetry(sdkEnrichTelemetry, "enrich_started");
-    const tempPlay = (0, import_node_path18.join)(tempDir, "deepline-enrich.play.ts");
+    const tempPlay = (0, import_node_path19.join)(tempDir, "deepline-enrich.play.ts");
     let inPlaceTempDir = null;
     let inPlaceTempOutputPath = null;
-    const inPlaceFinalOutputPath = options.inPlace ? (0, import_node_path18.resolve)(inputCsv) : null;
-    const inPlaceCommitOutputPath = options.inPlace ? (await (0, import_promises10.lstat)(inputCsv)).isSymbolicLink() ? await (0, import_promises10.realpath)(inputCsv) : inPlaceFinalOutputPath : null;
+    const inPlaceFinalOutputPath = options.inPlace ? (0, import_node_path19.resolve)(inputCsv) : null;
+    const inPlaceCommitOutputPath = options.inPlace ? (await (0, import_promises11.lstat)(inputCsv)).isSymbolicLink() ? await (0, import_promises11.realpath)(inputCsv) : inPlaceFinalOutputPath : null;
     const failureReportOutputPath = options.inPlace ? inPlaceFinalOutputPath : null;
     const enrichIssueFollowUpOutputPath = options.inPlace && inPlaceFinalOutputPath ? sidecarEnrichRowsExportPath(inPlaceFinalOutputPath) : null;
     let activeRunId2 = null;
@@ -36931,16 +37555,16 @@ function registerEnrichCommand(program) {
         return;
       }
       if (inPlaceTempDir) {
-        await (0, import_promises10.rm)(inPlaceTempDir, { recursive: true, force: true });
+        await (0, import_promises11.rm)(inPlaceTempDir, { recursive: true, force: true });
       }
-      inPlaceTempDir = await (0, import_promises10.mkdtemp)(
-        (0, import_node_path18.join)(
-          (0, import_node_path18.dirname)(inPlaceCommitOutputPath ?? (0, import_node_path18.resolve)(inputCsv)),
+      inPlaceTempDir = await (0, import_promises11.mkdtemp)(
+        (0, import_node_path19.join)(
+          (0, import_node_path19.dirname)(inPlaceCommitOutputPath ?? (0, import_node_path19.resolve)(inputCsv)),
           ".deepline-enrich-in-place-"
         )
       );
-      inPlaceTempOutputPath = (0, import_node_path18.join)(inPlaceTempDir, "output.csv");
-      await (0, import_promises10.copyFile)((0, import_node_path18.resolve)(inputCsv), inPlaceTempOutputPath);
+      inPlaceTempOutputPath = (0, import_node_path19.join)(inPlaceTempDir, "output.csv");
+      await (0, import_promises11.copyFile)((0, import_node_path19.resolve)(inputCsv), inPlaceTempOutputPath);
       outputPath = inPlaceTempOutputPath;
     };
     const commitInPlaceOutput = async (exportResult) => {
@@ -36948,12 +37572,12 @@ function registerEnrichCommand(program) {
         return exportResult;
       }
       const committedTempDir = inPlaceTempDir;
-      await (0, import_promises10.rename)(inPlaceTempOutputPath, inPlaceCommitOutputPath);
+      await (0, import_promises11.rename)(inPlaceTempOutputPath, inPlaceCommitOutputPath);
       inPlaceTempDir = null;
       inPlaceTempOutputPath = null;
       outputPath = inPlaceFinalOutputPath;
       if (committedTempDir) {
-        await (0, import_promises10.rm)(committedTempDir, { recursive: true, force: true });
+        await (0, import_promises11.rm)(committedTempDir, { recursive: true, force: true });
       }
       if (!exportResult) {
         return null;
@@ -36966,13 +37590,13 @@ function registerEnrichCommand(program) {
     try {
       process.once("SIGINT", onSigint);
       process.once("SIGTERM", onSigterm);
-      await (0, import_promises10.writeFile)(tempPlay, playSource, "utf8");
+      await (0, import_promises11.writeFile)(tempPlay, playSource, "utf8");
       if (options.inPlace) {
         await prepareInPlaceOutput();
       }
       const runOne = async (input2) => {
         const runtimeInput = {
-          file: (0, import_node_path18.resolve)(input2.sourceCsvPath),
+          file: (0, import_node_path19.resolve)(input2.sourceCsvPath),
           ...input2.rows.rowStart !== null ? { rowStart: input2.rows.rowStart } : {},
           ...input2.rows.rowEnd !== null ? { rowEnd: input2.rows.rowEnd } : {}
         };
@@ -37160,11 +37784,11 @@ function registerEnrichCommand(program) {
       process.removeListener("SIGINT", onSigint);
       process.removeListener("SIGTERM", onSigterm);
       if (inPlaceTempDir) {
-        await (0, import_promises10.rm)(inPlaceTempDir, { recursive: true, force: true });
+        await (0, import_promises11.rm)(inPlaceTempDir, { recursive: true, force: true });
       } else if (inPlaceTempOutputPath) {
-        await (0, import_promises10.rm)(inPlaceTempOutputPath, { force: true });
+        await (0, import_promises11.rm)(inPlaceTempOutputPath, { force: true });
       }
-      await (0, import_promises10.rm)(tempDir, { recursive: true, force: true });
+      await (0, import_promises11.rm)(tempDir, { recursive: true, force: true });
     }
   });
 }
@@ -37206,7 +37830,7 @@ async function handleFeedback(text, options) {
     { json: options.json }
   );
 }
-function resolveFeedbackText(text, file, readFile7 = (path) => (0, import_node_fs13.readFileSync)(path, "utf8")) {
+function resolveFeedbackText(text, file, readFile8 = (path) => (0, import_node_fs13.readFileSync)(path, "utf8")) {
   if (text !== void 0 && file !== void 0) {
     throw new Error(
       "Pass feedback text positionally or with --file, not both."
@@ -37215,7 +37839,7 @@ function resolveFeedbackText(text, file, readFile7 = (path) => (0, import_node_f
   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)}`
@@ -37224,7 +37848,7 @@ function resolveFeedbackText(text, file, readFile7 = (path) => (0, import_node_f
   } 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."
@@ -37275,7 +37899,7 @@ Examples:
 // src/cli/commands/sessions.ts
 var import_node_fs14 = require("fs");
 var import_node_os11 = require("os");
-var import_node_path19 = require("path");
+var import_node_path20 = require("path");
 var import_node_zlib = require("zlib");
 var import_node_crypto8 = require("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;
@@ -37294,17 +37918,17 @@ function homeDir() {
 function detectShellContext() {
   const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
   return {
-    shell: shellPath ? (0, import_node_path19.basename)(shellPath).replace(/\.exe$/i, "") : "unknown",
+    shell: shellPath ? (0, import_node_path20.basename)(shellPath).replace(/\.exe$/i, "") : "unknown",
     shell_path: shellPath || null,
     os: (0, import_node_os11.platform)(),
     cwd: process.cwd()
   };
 }
 function claudeProjectsRoot() {
-  return (0, import_node_path19.join)(homeDir(), ".claude", "projects");
+  return (0, import_node_path20.join)(homeDir(), ".claude", "projects");
 }
 function codexSessionsRoot() {
-  return (0, import_node_path19.join)(homeDir(), ".codex", "sessions");
+  return (0, import_node_path20.join)(homeDir(), ".codex", "sessions");
 }
 function listClaudeSessionFiles() {
   const root = claudeProjectsRoot();
@@ -37312,10 +37936,10 @@ function listClaudeSessionFiles() {
   const projectDirs = readDirectoryNames(root);
   const files = [];
   for (const projectDir of projectDirs) {
-    const fullProjectDir = (0, import_node_path19.join)(root, projectDir);
+    const fullProjectDir = (0, import_node_path20.join)(root, projectDir);
     for (const fileName of readDirectoryNames(fullProjectDir)) {
       if (fileName.endsWith(".jsonl")) {
-        const filePath = (0, import_node_path19.join)(fullProjectDir, fileName);
+        const filePath = (0, import_node_path20.join)(fullProjectDir, fileName);
         const sessionId = sessionIdFromClaudeFilePath(filePath);
         const stat5 = statIfReadable(filePath);
         if (sessionId && stat5) {
@@ -37372,7 +37996,7 @@ function listJsonlFilesRecursive(root, maxDepth) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = (0, import_node_path19.join)(dir, entry.name);
+      const fullPath = (0, import_node_path20.join)(dir, entry.name);
       if (entry.isDirectory()) {
         visit(fullPath, depth + 1);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -37400,10 +38024,10 @@ function newestSessionFile(agent) {
   return newest;
 }
 function sessionIdFromClaudeFilePath(filePath) {
-  return (0, import_node_path19.basename)(filePath, ".jsonl");
+  return (0, import_node_path20.basename)(filePath, ".jsonl");
 }
 function sessionIdFromCodexFilePath(filePath) {
-  const match = (0, import_node_path19.basename)(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
+  const match = (0, import_node_path20.basename)(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
   return match?.[0] ?? null;
 }
 function readCodexSessionId(filePath) {
@@ -37732,26 +38356,26 @@ async function uploadChunkedSessions(sessions, options) {
 async function handleSessionsSend(options) {
   const rating = parseSessionRating(options.rating);
   if (options.file) {
-    const filePath = (0, import_node_path19.resolve)(options.file);
+    const filePath = (0, import_node_path20.resolve)(options.file);
     if (!(0, import_node_fs14.existsSync)(filePath)) {
       throw new Error(`File not found: ${options.file}`);
     }
     const response2 = await uploadPayload("/api/v2/cli/send-session", {
       file: (0, import_node_fs14.readFileSync)(filePath).toString("base64"),
-      filename: (0, import_node_path19.basename)(filePath),
+      filename: (0, import_node_path20.basename)(filePath),
       ...rating ? { rating } : {}
     });
     printCommandEnvelope(
       {
         ...response2,
         ok: true,
-        filename: (0, import_node_path19.basename)(filePath),
+        filename: (0, import_node_path20.basename)(filePath),
         render: {
           sections: [
             {
               title: "sessions send",
               lines: [
-                `File '${(0, import_node_path19.basename)(filePath)}' uploaded to #internal-reports.`
+                `File '${(0, import_node_path20.basename)(filePath)}' uploaded to #internal-reports.`
               ]
             }
           ]
@@ -37808,24 +38432,24 @@ async function handleSessionsSend(options) {
   );
 }
 function loadViewerAssets() {
-  const cliEntry = process.argv[1]?.trim() ? (0, import_node_fs14.realpathSync)((0, import_node_path19.resolve)(process.argv[1])) : null;
+  const cliEntry = process.argv[1]?.trim() ? (0, import_node_fs14.realpathSync)((0, import_node_path20.resolve)(process.argv[1])) : null;
   const candidateRoots2 = [
     ...cliEntry ? [
-      (0, import_node_path19.join)((0, import_node_path19.dirname)((0, import_node_path19.dirname)(cliEntry)), "viewer"),
-      (0, import_node_path19.join)(
-        (0, import_node_path19.dirname)((0, import_node_path19.dirname)((0, import_node_path19.dirname)(cliEntry))),
+      (0, import_node_path20.join)((0, import_node_path20.dirname)((0, import_node_path20.dirname)(cliEntry)), "viewer"),
+      (0, import_node_path20.join)(
+        (0, import_node_path20.dirname)((0, import_node_path20.dirname)((0, import_node_path20.dirname)(cliEntry))),
         "src",
         "lib",
         "cli",
         "viewer"
       )
     ] : [],
-    (0, import_node_path19.join)(process.cwd(), "packages", "sdk", "assets", "viewer")
+    (0, import_node_path20.join)(process.cwd(), "packages", "sdk", "assets", "viewer")
   ];
   for (const root of candidateRoots2) {
     try {
-      const cssPath = (0, import_node_path19.join)(root, "viewer.css");
-      const jsPath = (0, import_node_path19.join)(root, "viewer.js");
+      const cssPath = (0, import_node_path20.join)(root, "viewer.css");
+      const jsPath = (0, import_node_path20.join)(root, "viewer.js");
       if (!(0, import_node_fs14.existsSync)(cssPath) || !(0, import_node_fs14.existsSync)(jsPath)) continue;
       return {
         css: (0, import_node_fs14.readFileSync)(cssPath, "utf8"),
@@ -37855,16 +38479,16 @@ async function handleSessionsRender(options) {
     currentSession: options.currentSession,
     agent: options.agent
   });
-  let outputPath = options.output ? (0, import_node_path19.resolve)(options.output) : "";
+  let outputPath = options.output ? (0, import_node_path20.resolve)(options.output) : "";
   if (!outputPath) {
-    const outputDir = (0, import_node_path19.join)(process.cwd(), "deepline", "data");
+    const outputDir = (0, import_node_path20.join)(process.cwd(), "deepline", "data");
     (0, import_node_fs14.mkdirSync)(outputDir, { recursive: true });
-    outputPath = (0, import_node_path19.join)(
+    outputPath = (0, import_node_path20.join)(
       outputDir,
       targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
     );
   } else {
-    (0, import_node_fs14.mkdirSync)((0, import_node_path19.dirname)(outputPath), { recursive: true });
+    (0, import_node_fs14.mkdirSync)((0, import_node_path20.dirname)(outputPath), { recursive: true });
   }
   const sessions = targets.map((target) => ({
     label: target.label,
@@ -38108,8 +38732,8 @@ Examples:
 // src/cli/commands/monitors.ts
 var import_node_crypto9 = require("crypto");
 var import_node_fs15 = require("fs");
-var import_node_path20 = require("path");
-var import_promises11 = require("readline/promises");
+var import_node_path21 = require("path");
+var import_promises12 = require("readline/promises");
 
 // ../integration-contracts/monitor-input-contract.ts
 var import_handlebars = __toESM(require("handlebars"), 1);
@@ -38971,7 +39595,7 @@ function parseJsonObjectArg(raw, argLabel) {
   return parsed;
 }
 function resolveMonitorJsonBody(input2) {
-  const readFile7 = input2.readFile ?? ((path) => (0, import_node_fs15.readFileSync)(path, "utf-8"));
+  const readFile8 = input2.readFile ?? ((path) => (0, import_node_fs15.readFileSync)(path, "utf-8"));
   const readStdin = input2.readStdin ?? (() => (0, import_node_fs15.readFileSync)(0, "utf-8"));
   if (input2.positional !== void 0 && input2.file !== void 0) {
     throw new MonitorsUsageError(
@@ -38987,7 +39611,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)}`
@@ -40269,7 +40893,7 @@ async function handleMonitorFleetsInit(fleetId, options) {
     }
   };
   const definition = requireCompiledFleetDefinition(authoredDefinition);
-  const file = (0, import_node_path20.resolve)(out);
+  const file = (0, import_node_path21.resolve)(out);
   (0, import_node_fs15.writeFileSync)(file, `${JSON.stringify(definition, null, 2)}
 `, "utf8");
   const next = `deepline monitors fleets deploy --file ${fleetShellArg(file)} --dry-run --json`;
@@ -40530,7 +41154,7 @@ function fleetDeactivateCommandLine(fleetId, options) {
 }
 async function confirmFleetDeactivate(fleetId, plan) {
   process.stderr.write(renderFleetDeactivatePlan(plan, fleetId));
-  const rl = (0, import_promises11.createInterface)({ input: process.stdin, output: process.stderr });
+  const rl = (0, import_promises12.createInterface)({ input: process.stdin, output: process.stderr });
   try {
     const answer = await rl.question(
       `Deactivate fleet "${fleetId}" and the monitors it owns? [y/N] `
@@ -40844,7 +41468,7 @@ async function handleMonitorsValidate(key, options) {
   if (result.valid === false) process.exitCode = 7;
 }
 async function confirmMonitorDelete(key) {
-  const rl = (0, import_promises11.createInterface)({
+  const rl = (0, import_promises12.createInterface)({
     input: process.stdin,
     output: process.stderr
   });
@@ -41150,7 +41774,7 @@ async function handleMonitorBatchDeploy(options) {
   }
   let manifestNdjson;
   try {
-    manifestNdjson = (0, import_node_fs15.readFileSync)((0, import_node_path20.resolve)(options.file), "utf8");
+    manifestNdjson = (0, import_node_fs15.readFileSync)((0, import_node_path21.resolve)(options.file), "utf8");
   } catch (error) {
     throw new MonitorsUsageError(
       `Could not read monitor batch manifest '${options.file}': ${error instanceof Error ? error.message : String(error)}`
@@ -42051,10 +42675,10 @@ Example:
 // src/cli/commands/org.ts
 var import_node_crypto10 = require("crypto");
 var import_node_fs16 = require("fs");
-var import_node_path21 = require("path");
+var import_node_path22 = require("path");
 function pendingOrgCreatePath(baseUrl, accountId, sourceOrgId, name) {
   const intent = (0, import_node_crypto10.createHash)("sha256").update(accountId).update("\0").update(sourceOrgId).update("\0").update(name).digest("hex");
-  return (0, import_node_path21.join)(sdkCliStateDirPath(baseUrl), `pending-org-create-${intent}.json`);
+  return (0, import_node_path22.join)(sdkCliStateDirPath(baseUrl), `pending-org-create-${intent}.json`);
 }
 function readPendingOrgCreate(path, accountId, sourceOrgId, name) {
   let value;
@@ -42937,7 +43561,7 @@ Deprecated:
 
 // src/cli/commands/secrets.ts
 var import_node_process = require("process");
-var import_promises12 = require("fs/promises");
+var import_promises13 = require("fs/promises");
 var hiddenInputBuffer = "";
 function normalizeSecretName(value) {
   const normalized = value.trim().toUpperCase();
@@ -43110,7 +43734,7 @@ async function readSecretValueFromOptions(options) {
     }
     value = envValue;
   } else {
-    value = trimOneTerminalNewline(await (0, import_promises12.readFile)(options.fromFile, "utf8"));
+    value = trimOneTerminalNewline(await (0, import_promises13.readFile)(options.fromFile, "utf8"));
   }
   if (!value) throw new Error("Secret value is required.");
   return value;
@@ -43314,11 +43938,11 @@ Examples:
 var import_node_child_process5 = require("child_process");
 var import_node_fs20 = require("fs");
 var import_node_os15 = require("os");
-var import_node_path25 = require("path");
+var import_node_path26 = require("path");
 
 // src/cli/installation-lifecycle.ts
 var import_node_fs17 = require("fs");
-var import_node_path22 = require("path");
+var import_node_path23 = require("path");
 var nodeFileSystem = {
   exists: import_node_fs17.existsSync,
   isSymbolicLink(path) {
@@ -43374,25 +43998,25 @@ var CliInstallation = class _CliInstallation {
     });
   }
   static isNpmPackagePath(path) {
-    return path?.includes(`${(0, import_node_path22.join)("node_modules", "deepline")}`) ?? false;
+    return path?.includes(`${(0, import_node_path23.join)("node_modules", "deepline")}`) ?? false;
   }
   launcher(path) {
     return inspectLauncher(path, this.input.fileSystem);
   }
   retiredArtifacts() {
-    const hostDir = (0, import_node_path22.join)(
+    const hostDir = (0, import_node_path23.join)(
       this.input.home,
       ".local",
       "deepline",
       this.input.baseUrlSlug
     );
-    const legacyLauncherPath = (0, import_node_path22.join)(
+    const legacyLauncherPath = (0, import_node_path23.join)(
       this.input.home,
       ".local",
       "bin",
       "deepline"
     );
-    const installerCommandPath = this.input.fileSystem.read((0, import_node_path22.join)(hostDir, "sdk", ".command-path")).trim();
+    const installerCommandPath = this.input.fileSystem.read((0, import_node_path23.join)(hostDir, "sdk", ".command-path")).trim();
     const ownedInstallerCommand = isOwnedInstallerCommandPath({
       hostDir,
       commandPath: installerCommandPath
@@ -43400,16 +44024,16 @@ var CliInstallation = class _CliInstallation {
     const legacyLauncher = this.launcher(legacyLauncherPath);
     const candidates = [
       ...legacyLauncher.ownership === "installer_legacy" ? [legacyLauncherPath] : [],
-      (0, import_node_path22.join)(this.input.home, ".local", "bin", "deepline-real"),
-      (0, import_node_path22.join)(hostDir, "bin", "deepline"),
-      (0, import_node_path22.join)(hostDir, "bin", "deepline-real"),
-      (0, import_node_path22.join)(hostDir, "cli", ".install-method"),
-      (0, import_node_path22.join)(hostDir, "cli", ".version"),
-      (0, import_node_path22.join)(hostDir, "sdk", ".install-method"),
-      (0, import_node_path22.join)(hostDir, "sdk", ".command-path"),
+      (0, import_node_path23.join)(this.input.home, ".local", "bin", "deepline-real"),
+      (0, import_node_path23.join)(hostDir, "bin", "deepline"),
+      (0, import_node_path23.join)(hostDir, "bin", "deepline-real"),
+      (0, import_node_path23.join)(hostDir, "cli", ".install-method"),
+      (0, import_node_path23.join)(hostDir, "cli", ".version"),
+      (0, import_node_path23.join)(hostDir, "sdk", ".install-method"),
+      (0, import_node_path23.join)(hostDir, "sdk", ".command-path"),
       ...ownedInstallerCommand ? [
         installerCommandPath,
-        (0, import_node_path22.join)((0, import_node_path22.dirname)(installerCommandPath), "deepline-sdk")
+        (0, import_node_path23.join)((0, import_node_path23.dirname)(installerCommandPath), "deepline-sdk")
       ] : []
     ];
     return {
@@ -43430,11 +44054,11 @@ function removeArtifacts(plan, fileSystem) {
   return plan.paths;
 }
 function isOwnedInstallerCommandPath(input2) {
-  if (!input2.commandPath || (0, import_node_path22.basename)(input2.commandPath) !== "deepline") {
+  if (!input2.commandPath || (0, import_node_path23.basename)(input2.commandPath) !== "deepline") {
     return false;
   }
-  const commandPath = (0, import_node_path22.resolve)(input2.commandPath);
-  const fromHost = (0, import_node_path22.relative)((0, import_node_path22.resolve)(input2.hostDir), commandPath);
+  const commandPath = (0, import_node_path23.resolve)(input2.commandPath);
+  const fromHost = (0, import_node_path23.relative)((0, import_node_path23.resolve)(input2.hostDir), commandPath);
   return fromHost !== "" && fromHost !== ".." && !fromHost.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`);
 }
 
@@ -43442,7 +44066,7 @@ function isOwnedInstallerCommandPath(input2) {
 var import_node_child_process3 = require("child_process");
 var import_node_fs19 = require("fs");
 var import_node_os14 = require("os");
-var import_node_path24 = require("path");
+var import_node_path25 = require("path");
 
 // contracts/install-commands.json
 var install_commands_default = {
@@ -43559,7 +44183,7 @@ var import_node_crypto11 = require("crypto");
 var import_node_os13 = require("os");
 var import_node_zlib2 = require("zlib");
 var import_node_fs18 = require("fs");
-var import_node_path23 = require("path");
+var import_node_path24 = require("path");
 
 // src/cli/windows-arg-escape.ts
 var CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
@@ -43924,7 +44548,7 @@ function shouldSkipSkillsSync() {
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
 function unavailableSkillsNoticePath(baseUrl) {
-  return (0, import_node_path23.join)(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
+  return (0, import_node_path24.join)(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;
@@ -43934,21 +44558,21 @@ function sortedLeaseAgents(agents) {
   return [...new Set(expanded)].sort((a, b) => a.localeCompare(b));
 }
 function inProgressSkillsSyncPath(baseUrl, agent) {
-  return (0, import_node_path23.join)(
+  return (0, import_node_path24.join)(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-in-progress-${agentLeaseSegment(agent)}`
   );
 }
 function readInProgressSkillsSyncLeaseFromDir(dir) {
-  const claim = readMarkedSkillsSyncVersion((0, import_node_path23.join)(dir, "claim"));
+  const claim = readMarkedSkillsSyncVersion((0, import_node_path24.join)(dir, "claim"));
   const [version = "", startedAt = ""] = claim.split(" ");
-  const pidRaw = readMarkedSkillsSyncVersion((0, import_node_path23.join)(dir, "pid"));
+  const pidRaw = readMarkedSkillsSyncVersion((0, import_node_path24.join)(dir, "pid"));
   return {
     claimToken: version && startedAt ? `${version} ${startedAt}` : "",
     version,
     startedAt: Number(startedAt),
     pid: /^\d+$/.test(pidRaw) ? Number(pidRaw) : null,
-    owner: readMarkedSkillsSyncVersion((0, import_node_path23.join)(dir, "owner"))
+    owner: readMarkedSkillsSyncVersion((0, import_node_path24.join)(dir, "owner"))
   };
 }
 function readInProgressSkillsSyncLease(baseUrl, agent) {
@@ -44006,9 +44630,9 @@ function claimOneInProgressSkillsSync(baseUrl, remoteVersion, agent, owner) {
     const claimToken = `${remoteVersion} ${Date.now()}`;
     const staging = `${dir}.staging-${process.pid}-${Date.now()}`;
     (0, import_node_fs18.mkdirSync)(staging);
-    (0, import_node_fs18.writeFileSync)((0, import_node_path23.join)(staging, "claim"), `${claimToken}
+    (0, import_node_fs18.writeFileSync)((0, import_node_path24.join)(staging, "claim"), `${claimToken}
 `, "utf-8");
-    (0, import_node_fs18.writeFileSync)((0, import_node_path23.join)(staging, "owner"), `${owner}
+    (0, import_node_fs18.writeFileSync)((0, import_node_path24.join)(staging, "owner"), `${owner}
 `, "utf-8");
     try {
       (0, import_node_fs18.renameSync)(staging, dir);
@@ -44022,7 +44646,7 @@ function claimOneInProgressSkillsSync(baseUrl, remoteVersion, agent, owner) {
     return { state: "claimed", claimToken };
   };
   try {
-    (0, import_node_fs18.mkdirSync)((0, import_node_path23.dirname)(dir), { recursive: true });
+    (0, import_node_fs18.mkdirSync)((0, import_node_path24.dirname)(dir), { recursive: true });
     return create();
   } catch (error) {
     if (errorCode(error) !== "EEXIST") return { state: "unavailable" };
@@ -44082,7 +44706,7 @@ function recordOwnPidOnInProgressSkillsSync(baseUrl, leases) {
     if (!lease.claimToken) continue;
     try {
       (0, import_node_fs18.writeFileSync)(
-        (0, import_node_path23.join)(inProgressSkillsSyncPath(baseUrl, agent), "pid"),
+        (0, import_node_path24.join)(inProgressSkillsSyncPath(baseUrl, agent), "pid"),
         `${process.pid}
 `,
         "utf-8"
@@ -44151,7 +44775,7 @@ function skillsInstallLeasePath(baseUrl, agents) {
   return sortedLeaseAgents(agents).map((agent) => inProgressSkillsSyncPath(baseUrl, agent)).join(", ");
 }
 function deferredSkillsNoticePath(baseUrl, agents) {
-  return (0, import_node_path23.join)(
+  return (0, import_node_path24.join)(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-notice-${sortedLeaseAgents(agents).map(agentLeaseSegment).join("-")}`
   );
@@ -44160,7 +44784,7 @@ function deferSkillsNotice(baseUrl, agents) {
   const path = deferredSkillsNoticePath(baseUrl, agents);
   return (text) => {
     try {
-      (0, import_node_fs18.mkdirSync)((0, import_node_path23.dirname)(path), { recursive: true });
+      (0, import_node_fs18.mkdirSync)((0, import_node_path24.dirname)(path), { recursive: true });
       (0, import_node_fs18.appendFileSync)(path, `${text.trimEnd()}
 `, "utf-8");
     } catch {
@@ -44202,7 +44826,7 @@ function spawnDetachedSkillsSyncChild(argv, onSpawnError) {
   child.unref();
 }
 function failedSkillsSyncPath(baseUrl, agents) {
-  return (0, import_node_path23.join)(
+  return (0, import_node_path24.join)(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-failed-${sortedLeaseAgents(agents).map(agentLeaseSegment).join("-")}-version`
   );
@@ -44219,7 +44843,7 @@ function readMarkedSkillsSyncVersion(path) {
 }
 function writeMarkedSkillsSyncVersion(path, version) {
   try {
-    (0, import_node_fs18.mkdirSync)((0, import_node_path23.dirname)(path), { recursive: true });
+    (0, import_node_fs18.mkdirSync)((0, import_node_path24.dirname)(path), { recursive: true });
     (0, import_node_fs18.writeFileSync)(path, `${version}
 `, "utf-8");
     return true;
@@ -44329,7 +44953,7 @@ function safeSkillFilePath(value) {
 }
 function installedSkillFiles(root, prefix = "") {
   const files = [];
-  for (const entry of (0, import_node_fs18.readdirSync)((0, import_node_path23.join)(root, prefix), {
+  for (const entry of (0, import_node_fs18.readdirSync)((0, import_node_path24.join)(root, prefix), {
     withFileTypes: true
   })) {
     const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
@@ -44449,11 +45073,11 @@ async function verifyDefaultAgentSkillsInstall(baseUrl, remoteVersion, skillName
     controller.abort();
   }
   const home = (0, import_node_os13.homedir)();
-  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim() || (0, import_node_path23.join)(home, ".claude");
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim() || (0, import_node_path24.join)(home, ".claude");
   for (const [name, { files }] of published) {
     for (const root of [
-      (0, import_node_path23.join)(home, ".agents", "skills", name),
-      (0, import_node_path23.join)(claudeConfigDir, "skills", name)
+      (0, import_node_path24.join)(home, ".agents", "skills", name),
+      (0, import_node_path24.join)(claudeConfigDir, "skills", name)
     ]) {
       const installed = installedSkillFiles(root);
       if (installed.length !== files.length || installed.some((file, index2) => file !== files[index2])) {
@@ -44461,7 +45085,7 @@ async function verifyDefaultAgentSkillsInstall(baseUrl, remoteVersion, skillName
       }
       for (const file of files) {
         const publishedContent = expected.get(`${name}/${file}`);
-        if (!publishedContent || !(0, import_node_fs18.readFileSync)((0, import_node_path23.join)(root, file)).equals(publishedContent)) {
+        if (!publishedContent || !(0, import_node_fs18.readFileSync)((0, import_node_path24.join)(root, file)).equals(publishedContent)) {
           throw new Error(`installed content differs for ${name}/${file}`);
         }
       }
@@ -44515,7 +45139,7 @@ function probeInstallers(timeoutMs) {
   };
 }
 function noInstallerProbePath(baseUrl) {
-  return (0, import_node_path23.join)(
+  return (0, import_node_path24.join)(
     sdkCliStateDirPath(baseUrl),
     "skills-sync-no-installer-unknown.json"
   );
@@ -44532,7 +45156,7 @@ function dueUnknownInstallerProbes(baseUrl, remoteVersion) {
   const probes = probeInstallers(INSTALLER_PROBE_TIMEOUT_MS);
   if (probes.bunx !== "available" && probes.npx !== "available") {
     try {
-      (0, import_node_fs18.mkdirSync)((0, import_node_path23.dirname)(path), { recursive: true });
+      (0, import_node_fs18.mkdirSync)((0, import_node_path24.dirname)(path), { recursive: true });
       (0, import_node_fs18.writeFileSync)(
         path,
         JSON.stringify({
@@ -44984,13 +45608,13 @@ function detectSkillsAgents(input2) {
   ];
   const detected = AGENT_MARKERS.filter(
     (marker) => roots.some(
-      (root) => marker.paths.some((path) => (0, import_node_fs19.existsSync)((0, import_node_path24.join)(root, path)))
+      (root) => marker.paths.some((path) => (0, import_node_fs19.existsSync)((0, import_node_path25.join)(root, path)))
     )
   ).map((marker) => marker.agent);
   return detected.length > 0 ? detected : ["*"];
 }
 function skillsStatePathForScope(baseUrl, scope, root) {
-  return scope === "local" && root ? (0, import_node_path24.join)(root, ".deepline", "setup", "skills.json") : (0, import_node_path24.join)(sdkCliStateDirPath(baseUrl), "skills-install.json");
+  return scope === "local" && root ? (0, import_node_path25.join)(root, ".deepline", "setup", "skills.json") : (0, import_node_path25.join)(sdkCliStateDirPath(baseUrl), "skills-install.json");
 }
 function buildSkillsPlan(input2) {
   const scopeArgs = input2.scope === "global" ? ["--global"] : [];
@@ -45261,7 +45885,7 @@ async function runSkillsInstallWithLease(input2) {
 `
     );
   }
-  (0, import_node_fs19.mkdirSync)((0, import_node_path24.dirname)(plan.statePath), { recursive: true });
+  (0, import_node_fs19.mkdirSync)((0, import_node_path25.dirname)(plan.statePath), { recursive: true });
   (0, import_node_fs19.writeFileSync)(
     plan.statePath,
     `${JSON.stringify(
@@ -45540,7 +46164,7 @@ function buildPendingAuthorizationOutput(input2) {
   };
 }
 function setupStatePath(baseUrl, scope, root) {
-  return scope === "local" && root ? (0, import_node_path25.join)(root, ".deepline", "setup", "state.json") : (0, import_node_path25.join)(sdkCliStateDirPath(baseUrl), "setup.json");
+  return scope === "local" && root ? (0, import_node_path26.join)(root, ".deepline", "setup", "state.json") : (0, import_node_path26.join)(sdkCliStateDirPath(baseUrl), "setup.json");
 }
 async function captureStdout2(run) {
   let stdout = "";
@@ -45588,7 +46212,7 @@ function resolvePathCommands(command) {
   );
   return [
     ...new Set(
-      String(lookup.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => (0, import_node_path25.resolve)(path))
+      String(lookup.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => (0, import_node_path26.resolve)(path))
     )
   ];
 }
@@ -45621,7 +46245,7 @@ function resolvePersistentGlobalCommand(dependencies = {}) {
   if (prefix.status !== 0) return null;
   const root = String(prefix.stdout ?? "").trim();
   if (!root) return null;
-  const candidates = platform3 === "win32" ? [(0, import_node_path25.join)(root, "deepline.cmd"), (0, import_node_path25.join)(root, "deepline")] : [(0, import_node_path25.join)(root, "bin", "deepline")];
+  const candidates = platform3 === "win32" ? [(0, import_node_path26.join)(root, "deepline.cmd"), (0, import_node_path26.join)(root, "deepline")] : [(0, import_node_path26.join)(root, "bin", "deepline")];
   return candidates.find((candidate) => pathExists(candidate)) ?? null;
 }
 function inspectGlobalCliAvailability(input2) {
@@ -45636,18 +46260,18 @@ function pathsResolveToSameFile(left, right) {
   try {
     return (0, import_node_fs20.realpathSync)(left) === (0, import_node_fs20.realpathSync)(right);
   } catch {
-    return (0, import_node_path25.resolve)(left) === (0, import_node_path25.resolve)(right);
+    return (0, import_node_path26.resolve)(left) === (0, import_node_path26.resolve)(right);
   }
 }
 function isKnownDeeplineCommand(path) {
-  const entrypoint = process.argv[1] ? (0, import_node_path25.resolve)(process.argv[1]) : "";
+  const entrypoint = process.argv[1] ? (0, import_node_path26.resolve)(process.argv[1]) : "";
   let resolvedPath = path;
   try {
     resolvedPath = (0, import_node_fs20.realpathSync)(path);
   } catch {
   }
   if (entrypoint && resolvedPath === entrypoint) return true;
-  if (resolvedPath.includes(`${(0, import_node_path25.join)("node_modules", "deepline")}`)) return true;
+  if (resolvedPath.includes(`${(0, import_node_path26.join)("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");
 }
@@ -45657,7 +46281,7 @@ function inspectPathConflict() {
   try {
     if ((0, import_node_fs20.lstatSync)(commandPath).isSymbolicLink()) {
       const target = (0, import_node_fs20.realpathSync)(commandPath);
-      if (target.includes(`${(0, import_node_path25.join)("node_modules", "deepline")}`)) return null;
+      if (target.includes(`${(0, import_node_path26.join)("node_modules", "deepline")}`)) return null;
     }
   } catch {
   }
@@ -45665,7 +46289,7 @@ function inspectPathConflict() {
 }
 function writeSetupState(input2) {
   const path = setupStatePath(input2.baseUrl, input2.scope, input2.root);
-  (0, import_node_fs20.mkdirSync)((0, import_node_path25.dirname)(path), { recursive: true });
+  (0, import_node_fs20.mkdirSync)((0, import_node_path26.dirname)(path), { recursive: true });
   (0, import_node_fs20.writeFileSync)(
     path,
     `${JSON.stringify(
@@ -45706,7 +46330,7 @@ function failSetupPhase(phases, phase, code) {
   phases[phase] = { status: "failed", code };
 }
 function rollbackCommand(scope, root) {
-  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify((0, import_node_path25.join)(root, ".deepline", "runtime"))}` : "";
+  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify((0, import_node_path26.join)(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}`;
 }
@@ -45796,12 +46420,12 @@ function buildDoctorAssessment(input2) {
   const connected = input2.authStatus.payload?.connected === true;
   const authScopeOk = input2.scope === "local" ? Boolean(projectAuth) : Boolean(apiKey && !projectAuth);
   const skillsOk = skillsState?.scope === input2.scope && typeof skillsState.skillsVersion === "string" && Array.isArray(skillsState.agents) && skillsState.agents.length > 0;
-  const runningCliPath = process.argv[1] ? (0, import_node_path25.resolve)(process.argv[1]) : null;
+  const runningCliPath = process.argv[1] ? (0, import_node_path26.resolve)(process.argv[1]) : null;
   const globalCli = input2.scope === "global" ? inspectGlobalCliAvailability() : null;
   const pathGlobalCli = globalCli?.path ?? null;
   const cliPath = input2.scope === "global" ? pathGlobalCli : runningCliPath;
   const cliScopeOk = input2.scope === "global" ? Boolean(pathGlobalCli) : Boolean(
-    input2.root && runningCliPath?.includes((0, import_node_path25.join)(input2.root, ".deepline", "runtime"))
+    input2.root && runningCliPath?.includes((0, import_node_path26.join)(input2.root, ".deepline", "runtime"))
   );
   const checks = {
     cli: {
@@ -46421,7 +47045,7 @@ var import_node_fs24 = require("fs");
 // src/cli/update-preferences.ts
 var import_node_fs21 = require("fs");
 var import_node_os16 = require("os");
-var import_node_path26 = require("path");
+var import_node_path27 = require("path");
 var UPDATE_PREFERENCES_SCHEMA_VERSION = 1;
 var CLI_UPDATE_MESSAGES = [
   {
@@ -46450,7 +47074,7 @@ function unreadablePreferences(path, error) {
   };
 }
 function cliUpdatePreferencesPath(homeDir2 = (0, import_node_os16.homedir)()) {
-  return (0, import_node_path26.join)(
+  return (0, import_node_path27.join)(
     homeDir2,
     ".local",
     "deepline",
@@ -46478,7 +47102,7 @@ function readCliUpdatePreferences(homeDir2 = (0, import_node_os16.homedir)()) {
 function writeCliUpdatePreferences(preferences, homeDir2 = (0, import_node_os16.homedir)()) {
   const path = cliUpdatePreferencesPath(homeDir2);
   const tempPath = `${path}.${process.pid}.tmp`;
-  (0, import_node_fs21.mkdirSync)((0, import_node_path26.dirname)(path), { recursive: true });
+  (0, import_node_fs21.mkdirSync)((0, import_node_path27.dirname)(path), { recursive: true });
   try {
     (0, import_node_fs21.writeFileSync)(tempPath, `${JSON.stringify(preferences, null, 2)}
 `, {
@@ -46539,12 +47163,12 @@ function consumePendingCliUpdateMessages(homeDir2 = (0, import_node_os16.homedir
 var import_node_child_process6 = require("child_process");
 var import_node_fs23 = require("fs");
 var import_node_os17 = require("os");
-var import_node_path28 = require("path");
+var import_node_path29 = require("path");
 
 // src/cli/install-integrity.ts
 var import_node_module2 = require("module");
 var import_node_fs22 = require("fs");
-var import_node_path27 = require("path");
+var import_node_path28 = require("path");
 var SDK_SIDECAR_CRITICAL_PACKAGE_FILES = [
   "dist/cli/index.mjs",
   "dist/index.mjs",
@@ -46563,7 +47187,7 @@ var SDK_SIDECAR_CRITICAL_DEPENDENCY_FILES = [
   "esbuild/lib/main.js"
 ];
 function safeRelativePath(value) {
-  if (typeof value !== "string" || !value || (0, import_node_path27.isAbsolute)(value)) return false;
+  if (typeof value !== "string" || !value || (0, import_node_path28.isAbsolute)(value)) return false;
   const segments = value.split(/[\\/]+/);
   return segments.every(
     (segment) => Boolean(segment) && segment !== "." && segment !== ".."
@@ -46571,9 +47195,9 @@ function safeRelativePath(value) {
 }
 function resolveContainedPath(root, value) {
   if (!safeRelativePath(value)) return null;
-  const target = (0, import_node_path27.resolve)(root, value);
-  const relativeTarget = (0, import_node_path27.relative)((0, import_node_path27.resolve)(root), target);
-  if (!relativeTarget || relativeTarget.startsWith("..") || (0, import_node_path27.isAbsolute)(relativeTarget)) {
+  const target = (0, import_node_path28.resolve)(root, value);
+  const relativeTarget = (0, import_node_path28.relative)((0, import_node_path28.resolve)(root), target);
+  if (!relativeTarget || relativeTarget.startsWith("..") || (0, import_node_path28.isAbsolute)(relativeTarget)) {
     return null;
   }
   return target;
@@ -46589,7 +47213,7 @@ function isFile(path) {
   }
 }
 function readManifest(packageRoot) {
-  const packageJsonPath = (0, import_node_path27.join)(packageRoot, "package.json");
+  const packageJsonPath = (0, import_node_path28.join)(packageRoot, "package.json");
   let packageJson;
   try {
     packageJson = parseJson(packageJsonPath);
@@ -46663,8 +47287,8 @@ function readManifest(packageRoot) {
   return { mode: "manifest", manifest };
 }
 function inspectSdkSidecarInstall(versionDir) {
-  const nodeModulesRoot = (0, import_node_path27.join)(versionDir, "node_modules");
-  const packageRoot = (0, import_node_path27.join)(nodeModulesRoot, "deepline");
+  const nodeModulesRoot = (0, import_node_path28.join)(versionDir, "node_modules");
+  const packageRoot = (0, import_node_path28.join)(nodeModulesRoot, "deepline");
   const manifestResult = readManifest(packageRoot);
   if ("invalidReason" in manifestResult) {
     return {
@@ -46675,8 +47299,8 @@ function inspectSdkSidecarInstall(versionDir) {
     };
   }
   const missing = [
-    ...manifestResult.manifest.packageFiles.filter((path) => !isFile((0, import_node_path27.join)(packageRoot, path))).map((path) => `deepline/${path}`),
-    ...manifestResult.manifest.dependencyFiles.filter((path) => !isFile((0, import_node_path27.join)(nodeModulesRoot, path))).map((path) => `node_modules/${path}`)
+    ...manifestResult.manifest.packageFiles.filter((path) => !isFile((0, import_node_path28.join)(packageRoot, path))).map((path) => `deepline/${path}`),
+    ...manifestResult.manifest.dependencyFiles.filter((path) => !isFile((0, import_node_path28.join)(nodeModulesRoot, path))).map((path) => `node_modules/${path}`)
   ];
   return {
     ok: missing.length === 0,
@@ -46687,7 +47311,7 @@ function inspectSdkSidecarInstall(versionDir) {
 }
 function probeSdkSidecarEsbuild(versionDir) {
   try {
-    const requireFromInstall = (0, import_node_module2.createRequire)((0, import_node_path27.join)(versionDir, "package.json"));
+    const requireFromInstall = (0, import_node_module2.createRequire)((0, import_node_path28.join)(versionDir, "package.json"));
     const esbuild = requireFromInstall("esbuild");
     if (typeof esbuild.transformSync !== "function") {
       return "esbuild does not export transformSync";
@@ -46756,7 +47380,7 @@ function sidecarStateDir(input2) {
   if (!scope || scope.includes("/") || scope.includes("\\")) {
     return null;
   }
-  return (0, import_node_path28.join)(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
+  return (0, import_node_path29.join)(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
 }
 function sidecarRegistryUrl(hostUrl) {
   let url;
@@ -46791,19 +47415,19 @@ function readOptionalText(path) {
 function resolvePythonSidecarUpdatePlan(options) {
   const stateDir = sidecarStateDir(options);
   if (!stateDir) return null;
-  const relativeEntrypoint = (0, import_node_path28.relative)(
-    (0, import_node_path28.resolve)(stateDir),
-    (0, import_node_path28.resolve)(options.entrypoint)
+  const relativeEntrypoint = (0, import_node_path29.relative)(
+    (0, import_node_path29.resolve)(stateDir),
+    (0, import_node_path29.resolve)(options.entrypoint)
   );
-  if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || (0, import_node_path28.isAbsolute)(relativeEntrypoint)) {
+  if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || (0, import_node_path29.isAbsolute)(relativeEntrypoint)) {
     return null;
   }
-  const installMethod = readOptionalText((0, import_node_path28.join)(stateDir, ".install-method"));
+  const installMethod = readOptionalText((0, import_node_path29.join)(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((0, import_node_path28.join)(stateDir, ".node-bin")) || process.execPath;
-  const sidecarPath = readOptionalText((0, import_node_path28.join)(stateDir, ".command-path")) || (0, import_node_path28.join)(
+  const nodeBin = readOptionalText((0, import_node_path29.join)(stateDir, ".node-bin")) || process.execPath;
+  const sidecarPath = readOptionalText((0, import_node_path29.join)(stateDir, ".command-path")) || (0, import_node_path29.join)(
     stateDir,
     "bin",
     process.platform === "win32" ? "deepline-sdk.cmd" : "deepline-sdk"
@@ -46811,7 +47435,7 @@ function resolvePythonSidecarUpdatePlan(options) {
   const packageSpec = options.packageSpec || "deepline@latest";
   const npmCommand = "npm";
   const registryUrl = sidecarRegistryUrl(hostUrl);
-  const versionDir = (0, import_node_path28.join)(stateDir, "versions", "<version>");
+  const versionDir = (0, import_node_path29.join)(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",
@@ -46827,16 +47451,16 @@ function resolvePythonSidecarUpdatePlan(options) {
   };
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = (0, import_node_path28.resolve)(startPath);
+  let current = (0, import_node_path29.resolve)(startPath);
   while (true) {
-    if ((0, import_node_fs23.existsSync)((0, import_node_path28.join)(current, "package.json")) && (0, import_node_fs23.existsSync)((0, import_node_path28.join)(current, "bin", "deepline-dev.ts"))) {
-      const parent2 = (0, import_node_path28.dirname)(current);
-      return (0, import_node_path28.basename)(parent2) === "packages" && (0, import_node_path28.basename)(current) === "sdk" ? (0, import_node_path28.dirname)(parent2) : parent2;
+    if ((0, import_node_fs23.existsSync)((0, import_node_path29.join)(current, "package.json")) && (0, import_node_fs23.existsSync)((0, import_node_path29.join)(current, "bin", "deepline-dev.ts"))) {
+      const parent2 = (0, import_node_path29.dirname)(current);
+      return (0, import_node_path29.basename)(parent2) === "packages" && (0, import_node_path29.basename)(current) === "sdk" ? (0, import_node_path29.dirname)(parent2) : parent2;
     }
-    if ((0, import_node_fs23.existsSync)((0, import_node_path28.join)(current, "sdk", "package.json")) && (0, import_node_fs23.existsSync)((0, import_node_path28.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if ((0, import_node_fs23.existsSync)((0, import_node_path29.join)(current, "sdk", "package.json")) && (0, import_node_fs23.existsSync)((0, import_node_path29.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = (0, import_node_path28.dirname)(current);
+    const parent = (0, import_node_path29.dirname)(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -46846,7 +47470,7 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
     try {
       return (0, import_node_fs23.realpathSync)(entrypoint);
     } catch {
-      return (0, import_node_path28.resolve)(entrypoint);
+      return (0, import_node_path29.resolve)(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -46861,10 +47485,10 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
     const directPrefix = prefixParts.join("/").toLowerCase();
     const knownWindowsPrefixes = [
       env.npm_config_prefix,
-      env.APPDATA ? (0, import_node_path28.join)(env.APPDATA, "npm") : void 0
-    ].filter((value) => Boolean(value)).map((value) => (0, import_node_path28.resolve)(value).replace(/\\/g, "/").toLowerCase());
+      env.APPDATA ? (0, import_node_path29.join)(env.APPDATA, "npm") : void 0
+    ].filter((value) => Boolean(value)).map((value) => (0, import_node_path29.resolve)(value).replace(/\\/g, "/").toLowerCase());
     if (!knownWindowsPrefixes.includes(
-      (0, import_node_path28.resolve)(directPrefix).replace(/\\/g, "/").toLowerCase()
+      (0, import_node_path29.resolve)(directPrefix).replace(/\\/g, "/").toLowerCase()
     )) {
       return null;
     }
@@ -46877,9 +47501,9 @@ function normalizedNpmPrefix(value) {
   if (!trimmed) return null;
   const normalized = (() => {
     try {
-      return (0, import_node_fs23.realpathSync)((0, import_node_path28.resolve)(trimmed));
+      return (0, import_node_fs23.realpathSync)((0, import_node_path29.resolve)(trimmed));
     } catch {
-      return (0, import_node_path28.resolve)(trimmed);
+      return (0, import_node_path29.resolve)(trimmed);
     }
   })().replace(/\\/g, "/");
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
@@ -46904,7 +47528,7 @@ function isHomebrewFormulaEntrypoint(entrypoint) {
     try {
       return (0, import_node_fs23.realpathSync)(entrypoint);
     } catch {
-      return (0, import_node_path28.resolve)(entrypoint);
+      return (0, import_node_path29.resolve)(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -46914,8 +47538,8 @@ function isHomebrewFormulaEntrypoint(entrypoint) {
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
   const homeDir2 = options.homeDir ?? (0, import_node_os17.homedir)();
-  const entrypoint = options.entrypoint ?? (process.argv[1] ? (0, import_node_path28.resolve)(process.argv[1]) : "");
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path28.dirname)(entrypoint)) : null;
+  const entrypoint = options.entrypoint ?? (process.argv[1] ? (0, import_node_path29.resolve)(process.argv[1]) : "");
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path29.dirname)(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -46968,9 +47592,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 (0, import_node_path28.join)(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
+    return (0, import_node_path29.join)(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
   }
-  return (0, import_node_path28.join)(
+  return (0, import_node_path29.join)(
     (0, import_node_os17.homedir)(),
     ".local",
     "deepline",
@@ -47009,7 +47633,7 @@ function writeAutoUpdateFailure(plan, exitCode) {
     manualCommand: plan.manualCommand
   };
   try {
-    (0, import_node_fs23.mkdirSync)((0, import_node_path28.dirname)(path), { recursive: true });
+    (0, import_node_fs23.mkdirSync)((0, import_node_path29.dirname)(path), { recursive: true });
     (0, import_node_fs23.writeFileSync)(path, `${JSON.stringify(marker, null, 2)}
 `, "utf8");
   } catch {
@@ -47057,7 +47681,7 @@ function safeVersionSegment(value) {
   return /^[0-9A-Za-z._-]+$/.test(normalized) ? normalized : "";
 }
 function entryPathInVersionDir(versionDir) {
-  return (0, import_node_path28.join)(
+  return (0, import_node_path29.join)(
     versionDir,
     "node_modules",
     "deepline",
@@ -47067,7 +47691,7 @@ function entryPathInVersionDir(versionDir) {
   );
 }
 function installedPackageVersion(versionDir) {
-  const packageJsonPath = (0, import_node_path28.join)(
+  const packageJsonPath = (0, import_node_path29.join)(
     versionDir,
     "node_modules",
     "deepline",
@@ -47189,16 +47813,16 @@ async function runNpmInstallWithRegistryFallback(input2) {
   return first.exitCode;
 }
 function writeSidecarLauncher(input2) {
-  (0, import_node_fs23.mkdirSync)((0, import_node_path28.dirname)(input2.path), { recursive: true });
-  const packageRoot = (0, import_node_path28.dirname)((0, import_node_path28.dirname)((0, import_node_path28.dirname)(input2.entryPath)));
-  const versionDir = (0, import_node_path28.dirname)((0, import_node_path28.dirname)(packageRoot));
+  (0, import_node_fs23.mkdirSync)((0, import_node_path29.dirname)(input2.path), { recursive: true });
+  const packageRoot = (0, import_node_path29.dirname)((0, import_node_path29.dirname)((0, import_node_path29.dirname)(input2.entryPath)));
+  const versionDir = (0, import_node_path29.dirname)((0, import_node_path29.dirname)(packageRoot));
   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) => (0, import_node_path28.join)(packageRoot, path)
+      (path) => (0, import_node_path29.join)(packageRoot, path)
     ),
     ...SDK_SIDECAR_CRITICAL_DEPENDENCY_FILES.map(
-      (path) => (0, import_node_path28.join)(versionDir, "node_modules", path)
+      (path) => (0, import_node_path29.join)(versionDir, "node_modules", path)
     )
   ];
   if (process.platform === "win32") {
@@ -47252,17 +47876,17 @@ function writeSidecarLauncher(input2) {
   );
 }
 async function runPythonSidecarUpdatePlan(plan) {
-  const versionsDir = (0, import_node_path28.join)(plan.stateDir, "versions");
-  const tempDir = (0, import_node_path28.join)(
+  const versionsDir = (0, import_node_path29.join)(plan.stateDir, "versions");
+  const tempDir = (0, import_node_path29.join)(
     versionsDir,
     `.tmp-sdk-update-${process.pid}-${Date.now()}`
   );
   (0, import_node_fs23.rmSync)(tempDir, { recursive: true, force: true });
   (0, import_node_fs23.mkdirSync)(tempDir, { recursive: true });
-  (0, import_node_fs23.writeFileSync)((0, import_node_path28.join)(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
+  (0, import_node_fs23.writeFileSync)((0, import_node_path29.join)(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
   const env = {
     ...process.env,
-    PATH: `${(0, import_node_path28.dirname)(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
+    PATH: `${(0, import_node_path29.dirname)(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
   };
   const installResult = await runCommand(
     plan.npmCommand,
@@ -47299,7 +47923,7 @@ async function runPythonSidecarUpdatePlan(plan) {
     (0, import_node_fs23.rmSync)(tempDir, { recursive: true, force: true });
     return 1;
   }
-  const finalDir = (0, import_node_path28.join)(versionsDir, installedVersion);
+  const finalDir = (0, import_node_path29.join)(versionsDir, installedVersion);
   const finalEntryPath = entryPathInVersionDir(finalDir);
   const finalFailure = sidecarInstallFailure(finalDir);
   let backupDir = null;
@@ -47308,7 +47932,7 @@ async function runPythonSidecarUpdatePlan(plan) {
   } else {
     let shouldPublishTemp = true;
     if ((0, import_node_fs23.existsSync)(finalDir)) {
-      backupDir = (0, import_node_path28.join)(
+      backupDir = (0, import_node_path29.join)(
         versionsDir,
         `.backup-${installedVersion}-${process.pid}-${Date.now()}`
       );
@@ -47383,27 +48007,27 @@ async function runPythonSidecarUpdatePlan(plan) {
     entryPath: finalEntryPath
   });
   (0, import_node_fs23.writeFileSync)(
-    (0, import_node_path28.join)(plan.stateDir, ".version"),
+    (0, import_node_path29.join)(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
   (0, import_node_fs23.writeFileSync)(
-    (0, import_node_path28.join)(plan.stateDir, ".install-method"),
+    (0, import_node_path29.join)(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
   (0, import_node_fs23.writeFileSync)(
-    (0, import_node_path28.join)(plan.stateDir, ".command-path"),
+    (0, import_node_path29.join)(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  (0, import_node_fs23.writeFileSync)((0, import_node_path28.join)(plan.stateDir, ".runner"), "node\n", "utf8");
-  (0, import_node_fs23.writeFileSync)((0, import_node_path28.join)(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  (0, import_node_fs23.writeFileSync)((0, import_node_path29.join)(plan.stateDir, ".runner"), "node\n", "utf8");
+  (0, import_node_fs23.writeFileSync)((0, import_node_path29.join)(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
   (0, import_node_fs23.writeFileSync)(
-    (0, import_node_path28.join)(plan.stateDir, ".entry-path"),
+    (0, import_node_path29.join)(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
     "utf8"
@@ -47670,7 +48294,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;
@@ -47797,7 +48421,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")
@@ -48474,12 +49098,12 @@ function stableStringify(value) {
 // src/cli/commands/tools.ts
 var import_node_fs26 = require("fs");
 var import_node_os19 = require("os");
-var import_node_path30 = require("path");
+var import_node_path31 = require("path");
 
 // src/tool-output.ts
 var import_node_fs25 = require("fs");
 var import_node_os18 = require("os");
-var import_node_path29 = require("path");
+var import_node_path30 = require("path");
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -48606,19 +49230,19 @@ function projectRowOutput(conversion) {
   };
 }
 function ensureOutputDir() {
-  const outputDir = (0, import_node_path29.join)((0, import_node_os18.homedir)(), ".local", "share", "deepline", "data");
+  const outputDir = (0, import_node_path30.join)((0, import_node_os18.homedir)(), ".local", "share", "deepline", "data");
   (0, import_node_fs25.mkdirSync)(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = (0, import_node_path29.join)(outputDir, `${stem}_${Date.now()}.json`);
+  const outputPath = (0, import_node_path30.join)(outputDir, `${stem}_${Date.now()}.json`);
   (0, import_node_fs25.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem, options) {
-  const outputPath = options?.outPath ? options.outPath : (0, import_node_path29.join)(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
-  (0, import_node_fs25.mkdirSync)((0, import_node_path29.dirname)(outputPath), { recursive: true });
+  const outputPath = options?.outPath ? options.outPath : (0, import_node_path30.join)(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  (0, import_node_fs25.mkdirSync)((0, import_node_path30.dirname)(outputPath), { recursive: true });
   const columns = columnsForRows(rows);
   const escapeCell = (value) => {
     const normalized = value == null ? "" : typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
@@ -49220,6 +49844,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
   });
@@ -49450,13 +50076,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
@@ -49467,10 +50095,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,
@@ -49873,8 +50503,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 = [
@@ -50229,9 +50859,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 [];
@@ -50362,8 +50992,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
@@ -50371,7 +51001,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;
@@ -50468,7 +51098,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)) {
@@ -50496,9 +51126,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()) => {
@@ -50546,7 +51176,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;
@@ -50812,10 +51442,10 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = (0, import_node_path30.resolve)(trimmed);
+  const resolved = (0, import_node_path31.resolve)(trimmed);
   if ((0, import_node_fs26.existsSync)(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = (0, import_node_path30.resolve)(trimmed.replace(/\\/g, "/"));
+    const normalized = (0, import_node_path31.resolve)(trimmed.replace(/\\/g, "/"));
     if ((0, import_node_fs26.existsSync)(normalized)) return normalized;
   }
   return resolved;
@@ -50928,7 +51558,7 @@ function parseExecuteOptions(args) {
       continue;
     }
     if ((arg === "--out" || arg === "-o") && args[index + 1]) {
-      outPath = (0, import_node_path30.resolve)(args[++index]);
+      outPath = (0, import_node_path31.resolve)(args[++index]);
       continue;
     }
     throw new Error(`Unknown option: ${arg}`);
@@ -50966,13 +51596,13 @@ function parseToolExecuteTimeout(raw) {
 function pendingToolExecutionPath(input2) {
   const config = resolveConfig();
   const fingerprint = (0, import_node_crypto12.createHash)("sha256").update(config.baseUrl).update("\0").update((0, import_node_crypto12.createHash)("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 (0, import_node_path30.join)(
+  return (0, import_node_path31.join)(
     sdkCliStateDirPath(resolveConfig().baseUrl),
     `pending-tool-execution-${fingerprint}.json`
   );
 }
 function loadOrCreatePendingToolExecution(path) {
-  (0, import_node_fs26.mkdirSync)((0, import_node_path30.dirname)(path), { recursive: true });
+  (0, import_node_fs26.mkdirSync)((0, import_node_path31.dirname)(path), { recursive: true });
   if ((0, import_node_fs26.existsSync)(path)) {
     return readPendingToolExecution(path);
   }
@@ -51050,9 +51680,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = (0, import_node_fs26.mkdtempSync)((0, import_node_path30.join)((0, import_node_os19.tmpdir)(), "deepline-workflow-seed-"));
+  const scriptDir = (0, import_node_fs26.mkdtempSync)((0, import_node_path31.join)((0, import_node_os19.tmpdir)(), "deepline-workflow-seed-"));
   (0, import_node_fs26.chmodSync)(scriptDir, 448);
-  const scriptPath = (0, import_node_path30.join)(scriptDir, fileName);
+  const scriptPath = (0, import_node_path31.join)(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(/\]$/, "")}, ...]` : "[]";
@@ -51557,8 +52187,8 @@ Examples:
 }
 
 // src/cli/commands/workflow.ts
-var import_promises13 = require("fs/promises");
-var import_node_path31 = require("path");
+var import_promises14 = require("fs/promises");
+var import_node_path32 = require("path");
 
 // src/cli/workflow-to-play.ts
 var import_node_crypto13 = require("crypto");
@@ -51775,7 +52405,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await (0, import_promises13.readFile)((0, import_node_path31.resolve)(file), "utf8");
+    const raw = await (0, import_promises14.readFile)((0, import_node_path32.resolve)(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -51809,9 +52439,9 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = (0, import_node_path31.join)((0, import_node_path31.resolve)(outDir), `${compiled.playName}.play.ts`);
-    await (0, import_promises13.mkdir)((0, import_node_path31.dirname)(file), { recursive: true });
-    await (0, import_promises13.writeFile)(file, compiled.sourceCode, "utf8");
+    const file = (0, import_node_path32.join)((0, import_node_path32.resolve)(outDir), `${compiled.playName}.play.ts`);
+    await (0, import_promises14.mkdir)((0, import_node_path32.dirname)(file), { recursive: true });
+    await (0, import_promises14.writeFile)(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
       const code = await handlePlayPublish([file]);
@@ -52356,10 +52986,10 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await (0, import_promises14.mkdtemp)((0, import_node_path32.join)((0, import_node_os20.tmpdir)(), "deepline-health-play-"));
-  const file = (0, import_node_path32.join)(dir, "health-check.play.ts");
+  const dir = await (0, import_promises15.mkdtemp)((0, import_node_path33.join)((0, import_node_os20.tmpdir)(), "deepline-health-play-"));
+  const file = (0, import_node_path33.join)(dir, "health-check.play.ts");
   try {
-    await (0, import_promises14.writeFile)(
+    await (0, import_promises15.writeFile)(
       file,
       [
         "import { definePlay } from 'deepline';",
@@ -52408,7 +53038,7 @@ async function runPlayRunnerHealthCheck() {
       }
     };
   } finally {
-    await (0, import_promises14.rm)(dir, { recursive: true, force: true });
+    await (0, import_promises15.rm)(dir, { recursive: true, force: true });
   }
 }
 function pickString(value, ...keys) {