deepline 0.3.48 → 0.3.50

package/dist/cli/index.mjs

@@ -164,7 +164,7 @@ configureProxyFromEnv();
 
 // src/cli/index.ts
 import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile6 } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { tmpdir as tmpdir6 } from "os";
 import { Command as Command4 } from "commander";
 
@@ -1065,7 +1065,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.48",
+  version: "0.3.50",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1
@@ -1954,7 +1954,7 @@ var HttpClient = class {
           body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
           signal: options?.signal
         });
-        if (!response.ok || response.status === 202) {
+        if (!response.ok) {
           const body = await response.text();
           const parsed = parseResponseBody(body);
           if (response.status === 401 && !isProviderOriginatedHttpError(parsed)) {
@@ -2202,7 +2202,7 @@ function decodeSseFrame(frame) {
   return parsed;
 }
 function sleep(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 function withCoworkNetworkHint(message) {
   if (!isCoworkLikeSandbox2() || message.includes(COWORK_NETWORK_HINT)) {
@@ -3967,14 +3967,14 @@ async function* observeRunEvents(options) {
   try {
     for (; ; ) {
       if (queue.length === 0) {
-        const waitForItem = new Promise((resolve19) => {
-          wake = resolve19;
+        const waitForItem = new Promise((resolve20) => {
+          wake = resolve20;
         });
         if (!sawFirstSnapshot) {
           const timedOut = await Promise.race([
             waitForItem.then(() => false),
             new Promise(
-              (resolve19) => setTimeout(() => resolve19(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
+              (resolve20) => setTimeout(() => resolve20(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
             )
           ]);
           if (timedOut && queue.length === 0) {
@@ -4333,7 +4333,7 @@ function parseEnvTestPolicyOverrides() {
   return normalizeTestPolicyOverrides(parsed, "DEEPLINE_TEST_POLICY_OVERRIDES");
 }
 function sleep2(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 function isTransientCompileManifestError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
@@ -5683,26 +5683,12 @@ var DeeplineClient = class {
     const headers = options?.lastEventId && options.lastEventId.trim() ? { "Last-Event-ID": options.lastEventId.trim() } : void 0;
     const params = new URLSearchParams();
     params.set("mode", options?.mode ?? "cli");
-    const projectionDeadline = Date.now() + 3e4;
-    let projectionAttempt = 0;
-    for (; ; ) {
-      let sawEvent = false;
-      try {
-        for await (const event of this.http.streamSse(
-          `/api/v2/runs/${encodeURIComponent(workflowId)}/tail?${params.toString()}`,
-          { signal: options?.signal, headers }
-        )) {
-          sawEvent = true;
-          if (event.scope === "play") {
-            yield event;
-          }
-        }
-        return;
-      } catch (error) {
-        const projectionPending = options?.waitForProjection === true && !sawEvent && error instanceof DeeplineError && (error.statusCode === 404 || error.statusCode === 202 && error.code === "RUN_PROJECTION_PENDING") && Date.now() < projectionDeadline;
-        if (!projectionPending) throw error;
-        await sleep2(streamReconnectDelayMs(projectionAttempt));
-        projectionAttempt += 1;
+    for await (const event of this.http.streamSse(
+      `/api/v2/runs/${encodeURIComponent(workflowId)}/tail?${params.toString()}`,
+      { signal: options?.signal, headers }
+    )) {
+      if (event.scope === "play") {
+        yield event;
       }
     }
   }
@@ -6731,8 +6717,7 @@ var DeeplineClient = class {
     }
     for await (const event of this.streamPlayRunEvents(workflowId, {
       mode: "cli",
-      signal: options?.signal,
-      waitForProjection: true
+      signal: options?.signal
     })) {
       if (options?.signal?.aborted) {
         await this.cancelPlay(workflowId);
@@ -7767,6 +7752,10 @@ function flattenObjectColumns(row, options = {}) {
     }
     if (value && typeof value === "object" && !Array.isArray(value)) {
       const record = value;
+      if (options.objectColumns === "json") {
+        flattened[key] = csvSafeJsonString(record);
+        continue;
+      }
       const hasMatchedEnvelope = Object.prototype.hasOwnProperty.call(record, "matched_result") || Object.prototype.hasOwnProperty.call(record, "matchedResult");
       if (hasMatchedEnvelope) {
         flattened[key] = csvSafeJsonString(record);
@@ -8091,6 +8080,8 @@ async function httpJson(method, url, apiKey, body) {
     "X-Deepline-API-Contract": SDK_API_CONTRACT
   };
   if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+  const bypassToken = process.env.VERCEL_PROTECTION_BYPASS_TOKEN?.trim();
+  if (bypassToken) headers["x-vercel-protection-bypass"] = bypassToken;
   let response = null;
   let lastError = null;
   for (const candidateUrl of buildCandidateUrls2(url)) {
@@ -8157,7 +8148,7 @@ function buildCandidateUrls2(url) {
   }
 }
 function sleep4(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 function printDeeplineLogo() {
   if (process.stdout.isTTY && (process.stdout.columns ?? 80) >= 70) {
@@ -10128,10 +10119,6 @@ import {
 import { homedir as homedir5 } from "os";
 import { join as join6, resolve as resolve5 } from "path";
 
-// src/cli/dataset-stats.ts
-import { writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve4 } from "path";
-
 // ../plays/dataset-summary.ts
 function formatDatasetRowCountsLine(counts) {
   const { persisted, succeeded, failed } = counts;
@@ -10185,6 +10172,103 @@ function formatDatasetExecutionStats(raw, _persistedRowTotal) {
   return stats;
 }
 
+// src/cli/run-dataset-csv.ts
+import { writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve4 } from "path";
+var RunDatasetCsv = class _RunDatasetCsv {
+  #projection;
+  constructor(input2) {
+    const rows = input2.rows.map(projectRunDatasetRow);
+    this.#projection = {
+      rows,
+      columns: runDatasetCsvColumns(rows, input2.columns)
+    };
+  }
+  static from(input2) {
+    return new _RunDatasetCsv(input2);
+  }
+  projection() {
+    return this.#projection;
+  }
+  write(outPath) {
+    const absolutePath = resolve4(outPath);
+    writeFileSync6(
+      absolutePath,
+      csvStringFromRows(this.#projection.rows, this.#projection.columns),
+      "utf-8"
+    );
+    return absolutePath;
+  }
+};
+function writeRunDatasetCsv(input2) {
+  return RunDatasetCsv.from(input2).write(input2.outPath);
+}
+function projectRunDatasetRow(row) {
+  return Object.fromEntries(
+    Object.entries(row).map(([column, value]) => [
+      column,
+      projectRunDatasetCell(value)
+    ])
+  );
+}
+function projectRunDatasetCell(value) {
+  const logicalValue = parseSerializedDatasetValue(value);
+  if (logicalValue === null || logicalValue === void 0) return logicalValue;
+  if (typeof logicalValue === "object") {
+    return csvSafeJsonString(canonicalDatasetJson(logicalValue));
+  }
+  return logicalValue;
+}
+function canonicalDatasetJson(value) {
+  return canonicalDatasetJsonValue(value, /* @__PURE__ */ new WeakSet());
+}
+function canonicalDatasetJsonValue(value, ancestors) {
+  if (Array.isArray(value)) {
+    if (ancestors.has(value)) return value;
+    ancestors.add(value);
+    const normalized2 = value.map(
+      (item) => canonicalDatasetJsonValue(item, ancestors)
+    );
+    ancestors.delete(value);
+    return normalized2;
+  }
+  if (!value || typeof value !== "object" || value instanceof Date) {
+    return value;
+  }
+  if (ancestors.has(value)) return value;
+  ancestors.add(value);
+  const record = value;
+  const normalized = Object.fromEntries(
+    Object.keys(record).sort((left, right) => left.localeCompare(right)).map((key) => [key, canonicalDatasetJsonValue(record[key], ancestors)])
+  );
+  ancestors.delete(value);
+  return normalized;
+}
+function parseSerializedDatasetValue(value) {
+  if (typeof value !== "string") return value;
+  const text = value.trim();
+  if (!text || !["{", "["].includes(text[0] ?? "")) return value;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return value;
+  }
+}
+function runDatasetCsvColumns(rows, declaredColumns) {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (column) => {
+    if (!column || seen.has(column)) return;
+    seen.add(column);
+    columns.push(column);
+  };
+  for (const column of declaredColumns) add(column);
+  for (const row of rows) {
+    for (const column of Object.keys(row)) add(column);
+  }
+  return columns;
+}
+
 // src/cli/dataset-stats.ts
 function mergeCanonicalRowsInfo(left, right) {
   const preferred = right.rows.length > left.rows.length || right.complete && !left.complete && right.rows.length === left.rows.length ? right : left;
@@ -10602,6 +10686,11 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
   }
   return infos;
 }
+var LegacyRunDatasetCatalogAdapter = class {
+  static datasets(statusOrResult) {
+    return collectSerializedDatasetRowsInfos(statusOrResult);
+  }
+};
 function extractCanonicalRowsInfo(statusOrResult) {
   return collectCanonicalRowsInfos(statusOrResult)[0] ?? null;
 }
@@ -10771,22 +10860,6 @@ function buildDatasetStats(rows, totalRows = rows.length, columns = inferColumns
     columnStats
   };
 }
-function writeCanonicalRowsCsv(rowsInfo, outPath) {
-  if (!rowsInfo.complete) {
-    throw new Error(
-      `Run output only includes ${rowsInfo.rows.length} preview row(s) of ${rowsInfo.totalRows}; cannot export a complete CSV from this status payload yet.`
-    );
-  }
-  const sanitized = sanitizeCsvProjectionInfo({
-    rows: rowsInfo.rows,
-    columns: rowsInfo.columns
-  });
-  const rows = dataExportRows(sanitized.rows);
-  const columns = dataExportColumns(rows, sanitized.columns);
-  const resolved = resolve4(outPath);
-  writeFileSync6(resolved, csvStringFromRows(rows, columns), "utf-8");
-  return resolved;
-}
 
 // src/cli/commands/csv.ts
 function parseRowRange(raw) {
@@ -18324,6 +18397,207 @@ var SDK_PACKAGE_JSON = resolve10(SDK_PACKAGE_ROOT, "package.json");
 var SDK_ENTRY_FILE = resolve10(SDK_SOURCE_ROOT, "index.ts");
 var SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES ? SDK_ENTRY_FILE : resolve10(SDK_PACKAGE_ROOT, "dist", "index.d.ts");
 
+// src/cli/run-dataset-selection.ts
+var Run = class _Run {
+  #datasets;
+  constructor(input2) {
+    this.#datasets = RunDatasetCatalog.from({
+      runPackage: input2.runPackage,
+      datasets: input2.datasets
+    });
+  }
+  static open(input2) {
+    return new _Run(input2);
+  }
+  datasets() {
+    return this.#datasets;
+  }
+  /** Select the Dataset a caller wants to export; enumerate with datasets(). */
+  dataset(path) {
+    return this.#datasets.choose(path);
+  }
+};
+var RunDatasetCatalog = class _RunDatasetCatalog {
+  #available;
+  #returned;
+  #recovered;
+  constructor(input2) {
+    this.#available = input2.available.map((info) => RunDataset.from(info));
+    this.#returned = input2.returned.map((info) => RunDataset.from(info));
+    this.#recovered = input2.available.filter((info) => info.recovered).map((info) => RunDataset.from(info));
+  }
+  static from(input2) {
+    const available = withReturnedDatasetAliases(
+      input2.runPackage,
+      distinctRunDatasets(input2.datasets)
+    );
+    return new _RunDatasetCatalog({
+      available,
+      returned: returnedRunDatasets(input2.runPackage, available)
+    });
+  }
+  available() {
+    return this.#available;
+  }
+  returned() {
+    return this.#returned;
+  }
+  recovered() {
+    return this.#recovered;
+  }
+  /**
+   * Select an exact public Dataset path/id/namespace. With no requested path,
+   * a Run returns its sole returned Dataset, or its sole recovered Dataset.
+   */
+  choose(path) {
+    const requested = path?.trim();
+    if (requested) {
+      return this.#available.find((dataset) => dataset.matches(requested)) ?? null;
+    }
+    if (this.#returned.length === 1) return this.#returned[0];
+    return this.#returned.length === 0 && this.#recovered.length === 1 ? this.#recovered[0] : null;
+  }
+};
+var RunDataset = class _RunDataset {
+  #info;
+  constructor(info) {
+    this.#info = info;
+  }
+  static from(info) {
+    return new _RunDataset(info);
+  }
+  get source() {
+    return this.#info.source;
+  }
+  get datasetId() {
+    return this.#info.datasetId;
+  }
+  get tableNamespace() {
+    return this.#info.tableNamespace;
+  }
+  get rows() {
+    return this.#info.rows;
+  }
+  get totalRows() {
+    return this.#info.totalRows;
+  }
+  get complete() {
+    return this.#info.complete;
+  }
+  get recovered() {
+    return this.#info.recovered;
+  }
+  get exportUnavailableReason() {
+    return this.#info.exportUnavailableReason;
+  }
+  get exportUnavailableMessage() {
+    return this.#info.exportUnavailableMessage;
+  }
+  matches(path) {
+    return this.source === path || this.datasetId === path || this.tableNamespace === path;
+  }
+  /** Return a new Handle when its preview has been replaced by fetched rows. */
+  withRows(info) {
+    return _RunDataset.from(info);
+  }
+  /** Write this Dataset's stable, non-flattening CSV Projection. */
+  exportCsv(outPath) {
+    if (!this.complete) {
+      throw new Error(
+        `Run Dataset '${this.source ?? this.tableNamespace ?? "dataset"}' only includes ${this.rows.length} preview row(s) of ${this.totalRows}; cannot export a complete CSV yet.`
+      );
+    }
+    return writeRunDatasetCsv({
+      rows: this.rows,
+      columns: this.#info.columns,
+      outPath
+    });
+  }
+  /** Compatibility seam for callers which still return CanonicalRowsInfo. */
+  info() {
+    return this.#info;
+  }
+};
+function distinctRunDatasets(infos) {
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const info of infos) {
+    const identity = info.datasetId?.trim() ? `id:${info.datasetId.trim()}` : `path:${info.source ?? info.tableNamespace ?? "dataset"}`;
+    const existing = byIdentity.get(identity);
+    byIdentity.set(
+      identity,
+      existing ? mergeCanonicalRowsInfo(existing, info) : info
+    );
+  }
+  return [...byIdentity.values()];
+}
+function packageForDatasetSelection(runPackage) {
+  const root = recordValue(runPackage);
+  const nested = recordValue(root.package);
+  if (nested?.kind === "play_run") return nested;
+  return root.kind === "play_run" ? root : null;
+}
+function withReturnedDatasetAliases(runPackage, available) {
+  const outputs = recordValue(packageForDatasetSelection(runPackage)?.outputs);
+  if (Object.keys(outputs).length === 0) return available;
+  const expanded = [...available];
+  for (const outputValue of Object.values(outputs)) {
+    const output2 = recordValue(outputValue);
+    if (output2.kind !== "dataset") continue;
+    const alias = stringValue2(output2.path);
+    if (!alias) continue;
+    const datasetId = stringValue2(output2.datasetId);
+    const canonicalPath2 = stringValue2(output2.dataset);
+    const canonical = available.find(
+      (info) => datasetId && info.datasetId === datasetId || canonicalPath2 && info.source === canonicalPath2
+    );
+    if (!canonical) continue;
+    const aliasIndex = expanded.findIndex((info) => info.source === alias);
+    if (aliasIndex >= 0) {
+      expanded[aliasIndex] = {
+        ...mergeCanonicalRowsInfo(expanded[aliasIndex], canonical),
+        source: alias
+      };
+    } else {
+      expanded.push({ ...canonical, source: alias });
+    }
+  }
+  return expanded;
+}
+function returnedRunDatasets(runPackage, available) {
+  const outputs = recordValue(packageForDatasetSelection(runPackage)?.outputs);
+  if (Object.keys(outputs).length > 0) {
+    const selected = /* @__PURE__ */ new Map();
+    for (const outputValue of Object.values(outputs)) {
+      const output2 = recordValue(outputValue);
+      if (output2.kind !== "dataset") continue;
+      const datasetId = stringValue2(output2.datasetId);
+      const alias = stringValue2(output2.path);
+      const canonicalPath2 = stringValue2(output2.dataset);
+      const info = (alias ? available.find((candidate) => candidate.source === alias) : null) ?? (datasetId ? available.find((candidate) => candidate.datasetId === datasetId) : null) ?? (canonicalPath2 ? available.find((candidate) => candidate.source === canonicalPath2) : null);
+      if (!info) continue;
+      const identity = datasetId ? `id:${datasetId}` : `path:${canonicalPath2 ?? alias ?? info.source ?? "dataset"}`;
+      const aliased = { ...info, source: alias ?? info.source };
+      const existing = selected.get(identity);
+      selected.set(
+        identity,
+        existing ? mergeCanonicalRowsInfo(existing, aliased) : aliased
+      );
+    }
+    if (selected.size > 0) return [...selected.values()];
+  }
+  return distinctRunDatasets(
+    available.filter(
+      (info) => Boolean(info.source?.startsWith("result.")) && !info.recovered
+    )
+  );
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
 // src/cli/progress.ts
 import { Worker } from "worker_threads";
 var CliProgress = class {
@@ -18593,7 +18867,7 @@ ${hint}`;
 
 // ../play-runtime/governor/policy.ts
 var DEFAULT_MAX_CONCURRENT_EXTERNAL_CALLS = 64;
-var MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS = 256;
+var MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS = 1e3;
 var MAX_CONFIGURABLE_CONCURRENT_ROWS = 1e3;
 function resolveMaxConcurrentExternalCalls(requested) {
   if (requested === void 0 || requested === null) {
@@ -19135,8 +19409,7 @@ var PLAY_RUN_RESERVED_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "--force",
   "--force-tool-refresh",
   "--open",
-  "--debug-map-latency",
-  "--debug-fixture-provider-pacing"
+  "--debug-map-latency"
 ]);
 async function pathExistsIncludingSymlink(path) {
   try {
@@ -19271,7 +19544,7 @@ function traceCliSync(phase, fields, run) {
   }
 }
 function sleep5(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 function parseReferencedPlayTarget2(target) {
   const trimmed = target.trim();
@@ -20842,7 +21115,7 @@ async function waitForPlayCompletionByStream(input2) {
     try {
       for await (const event of input2.client.streamPlayRunEvents(
         input2.workflowId,
-        { signal: controller.signal, waitForProjection: true }
+        { signal: controller.signal }
       )) {
         sawEvent = true;
         const terminal = await handleLiveEvent(event);
@@ -22584,103 +22857,6 @@ async function fetchBackingDatasetRows(input2) {
     source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
   };
 }
-function resolveDatasetByName(available, datasetPath) {
-  const target = datasetPath.trim();
-  const exact = available.find((info) => info.source === target);
-  if (exact) {
-    return exact;
-  }
-  const byDatasetId = available.find((info) => info.datasetId === target);
-  if (byDatasetId) {
-    return byDatasetId;
-  }
-  const byNamespace = available.find(
-    (info) => info.tableNamespace && info.tableNamespace === target
-  );
-  if (byNamespace) {
-    return byNamespace;
-  }
-  return null;
-}
-function canonicalRowsIdentity(info) {
-  return info.datasetId?.trim() ? `id:${info.datasetId.trim()}` : `path:${info.source ?? info.tableNamespace ?? "dataset"}`;
-}
-function distinctCanonicalRowsInfos(infos) {
-  const byIdentity = /* @__PURE__ */ new Map();
-  for (const info of infos) {
-    const identity = canonicalRowsIdentity(info);
-    const existing = byIdentity.get(identity);
-    byIdentity.set(
-      identity,
-      existing ? mergeCanonicalRowsInfo(existing, info) : info
-    );
-  }
-  return [...byIdentity.values()];
-}
-function packageForExportSelection(status) {
-  const root = status;
-  const nested = readRecord(root.package);
-  if (nested?.kind === "play_run") return nested;
-  return root.kind === "play_run" ? root : null;
-}
-function withReturnedDatasetAliases(status, available) {
-  const packaged = packageForExportSelection(status);
-  const outputs = readRecord(packaged?.outputs);
-  if (!outputs) return available;
-  const expanded = [...available];
-  for (const outputValue of Object.values(outputs)) {
-    const output2 = readRecord(outputValue);
-    if (output2?.kind !== "dataset") continue;
-    const alias = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : null;
-    if (!alias) continue;
-    const datasetId = typeof output2.datasetId === "string" && output2.datasetId.trim() ? output2.datasetId.trim() : null;
-    const canonicalPath2 = typeof output2.dataset === "string" && output2.dataset.trim() ? output2.dataset.trim() : null;
-    const canonical = available.find(
-      (info) => datasetId && info.datasetId === datasetId || canonicalPath2 && info.source === canonicalPath2
-    );
-    if (canonical) {
-      const aliasIndex = expanded.findIndex((info) => info.source === alias);
-      if (aliasIndex >= 0) {
-        expanded[aliasIndex] = {
-          ...mergeCanonicalRowsInfo(expanded[aliasIndex], canonical),
-          source: alias
-        };
-      } else {
-        expanded.push({ ...canonical, source: alias });
-      }
-    }
-  }
-  return expanded;
-}
-function returnedRowsInfos(status, available) {
-  const packaged = packageForExportSelection(status);
-  const outputs = readRecord(packaged?.outputs);
-  if (outputs) {
-    const selected = /* @__PURE__ */ new Map();
-    for (const outputValue of Object.values(outputs)) {
-      const output2 = readRecord(outputValue);
-      if (output2?.kind !== "dataset") continue;
-      const datasetId = typeof output2.datasetId === "string" && output2.datasetId.trim() ? output2.datasetId.trim() : null;
-      const alias = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : null;
-      const canonicalPath2 = typeof output2.dataset === "string" && output2.dataset.trim() ? output2.dataset.trim() : null;
-      const info = (alias ? available.find((candidate) => candidate.source === alias) : null) ?? (datasetId ? available.find((candidate) => candidate.datasetId === datasetId) : null) ?? (canonicalPath2 ? available.find((candidate) => candidate.source === canonicalPath2) : null);
-      if (!info) continue;
-      const identity = datasetId ? `id:${datasetId}` : `path:${canonicalPath2 ?? alias ?? info.source ?? "dataset"}`;
-      const aliased = { ...info, source: alias ?? info.source };
-      const existing = selected.get(identity);
-      selected.set(
-        identity,
-        existing ? mergeCanonicalRowsInfo(existing, aliased) : aliased
-      );
-    }
-    if (selected.size > 0) return [...selected.values()];
-  }
-  return distinctCanonicalRowsInfos(
-    available.filter(
-      (info) => Boolean(info.source?.startsWith("result.")) && !info.recovered
-    )
-  );
-}
 function exportDatasetCommand(input2) {
   return `deepline runs export ${input2.runId} --dataset ${shellSingleQuote(
     input2.datasetPath
@@ -22739,16 +22915,17 @@ async function exportPlayStatusRows(client2, status, outPath, options = {}) {
   if (!outPath) {
     return null;
   }
-  const availableRows = withReturnedDatasetAliases(
-    status,
-    distinctCanonicalRowsInfos(collectSerializedDatasetRowsInfos(status))
-  );
-  const returnedRows = returnedRowsInfos(status, availableRows);
-  const recoveredRows = distinctCanonicalRowsInfos(
-    availableRows.filter((info) => info.recovered)
-  );
-  const rowsInfo = options.datasetPath ? resolveDatasetByName(availableRows, options.datasetPath) ?? null : returnedRows.length === 1 ? returnedRows[0] : returnedRows.length === 0 && recoveredRows.length === 1 ? recoveredRows[0] : null;
-  if (!rowsInfo && options.datasetPath) {
+  const run = Run.open({
+    runPackage: status,
+    datasets: LegacyRunDatasetCatalogAdapter.datasets(status)
+  });
+  const datasets = run.datasets();
+  const availableRows = datasets.available().map((dataset) => dataset.info());
+  const returnedRows = datasets.returned().map((dataset) => dataset.info());
+  const recoveredRows = datasets.recovered().map((dataset) => dataset.info());
+  const selectedDataset = run.dataset(options.datasetPath);
+  const rowsInfo = selectedDataset?.info() ?? null;
+  if (!selectedDataset && options.datasetPath) {
     const available = availableRows.map((info) => info.source).filter((source) => typeof source === "string");
     const commands = datasetChoiceLines({
       runId: status.runId,
@@ -22839,7 +23016,7 @@ ${commands.join("\n")}`,
         datasetPath: options.datasetPath
       });
       return {
-        path: writeCanonicalRowsCsv(guarded2, outPath),
+        path: RunDataset.from(guarded2).exportCsv(outPath),
         rowsInfo: guarded2
       };
     }
@@ -22851,7 +23028,7 @@ ${commands.join("\n")}`,
         datasetPath: options.datasetPath
       });
       return {
-        path: writeCanonicalRowsCsv(guarded2, outPath),
+        path: RunDataset.from(guarded2).exportCsv(outPath),
         rowsInfo: guarded2
       };
     }
@@ -22885,7 +23062,10 @@ ${commands.join("\n")}`,
     availableRows,
     datasetPath: options.datasetPath
   });
-  return { path: writeCanonicalRowsCsv(guarded, outPath), rowsInfo: guarded };
+  return {
+    path: RunDataset.from(guarded).exportCsv(outPath),
+    rowsInfo: guarded
+  };
 }
 function extractActiveRunsFromError(error) {
   if (!(error instanceof DeeplineError)) {
@@ -23179,9 +23359,6 @@ function parsePlayRunOptions(args) {
   const forceToolRefresh = args.includes("--force-tool-refresh");
   const open2 = args.includes("--open");
   const debugMapLatency = args.includes("--debug-map-latency");
-  const debugFixtureProviderPacing = args.includes(
-    "--debug-fixture-provider-pacing"
-  );
   const verboseLogs = args.includes("--logs") || debugMapLatency;
   let waitTimeoutMs = null;
   let maxConcurrentExternalCalls = null;
@@ -23385,7 +23562,6 @@ function parsePlayRunOptions(args) {
     open: open2,
     profile,
     debugMapLatency,
-    debugFixtureProviderPacing,
     fixtureBehavior,
     runIdFile
   };
@@ -23551,7 +23727,7 @@ function formatPlayRuntimeLimit(runtimeLimit) {
 function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function stringValue2(value) {
+function stringValue3(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function asArray(value) {
@@ -23571,11 +23747,11 @@ function firstRawPath(entry) {
     ...asArray(details.raw_tool_output_paths),
     ...asArray(details.candidatePaths),
     ...asArray(details.candidate_paths)
-  ].map(stringValue2).filter(Boolean);
+  ].map(stringValue3).filter(Boolean);
   return paths[0];
 }
 function checkHintExpression(value) {
-  return stringValue2(value).replace(/^toolExecutionResult\./, "result.");
+  return stringValue3(value).replace(/^toolExecutionResult\./, "result.");
 }
 function checkHintRawPath(value) {
   return value?.replace(/^toolResponse\./, "result.toolResponse.");
@@ -23590,7 +23766,7 @@ function collectStaticPipelineToolIds(staticPipeline) {
     ]) {
       if (!isRecord10(step)) continue;
       if (step.type === "tool") {
-        const toolId = stringValue2(step.toolId) || stringValue2(step.tool);
+        const toolId = stringValue3(step.toolId) || stringValue3(step.tool);
         if (toolId) seen.add(toolId);
       }
       if (step.type === "play_call") {
@@ -23608,14 +23784,14 @@ function toolGetterHintFromMetadata(toolId, tool) {
   const lists = extractionEntries2(
     resultGuidance.extractedLists ?? resultGuidance.extracted_lists
   ).map((entry) => ({
-    name: stringValue2(entry.name),
+    name: stringValue3(entry.name),
     expression: checkHintExpression(entry.expression),
     raw: checkHintRawPath(firstRawPath(entry))
   })).filter((entry) => entry.name && entry.expression);
   const values = extractionEntries2(
     resultGuidance.extractedValues ?? resultGuidance.extracted_values
   ).map((entry) => ({
-    name: stringValue2(entry.name),
+    name: stringValue3(entry.name),
     expression: checkHintExpression(entry.expression),
     raw: checkHintRawPath(firstRawPath(entry))
   })).filter((entry) => entry.name && entry.expression);
@@ -24176,14 +24352,8 @@ async function handleFileBackedRun(options, hooks) {
       "--fixture-behavior requires DEEPLINE_EVAL_INTEGRATION_MODE=fixture."
     );
   }
-  if (options.debugFixtureProviderPacing && integrationMode !== "fixture") {
-    throw new Error(
-      "--debug-fixture-provider-pacing requires DEEPLINE_EVAL_INTEGRATION_MODE=fixture."
-    );
-  }
   const testPolicyOverrides = {
-    ...options.debugMapLatency ? { mapLatencyProfile: true } : {},
-    ...options.debugFixtureProviderPacing ? { enforceFixtureProviderPacing: true } : {}
+    ...options.debugMapLatency ? { mapLatencyProfile: true } : {}
   };
   const startRequest = {
     name: playName,
@@ -24365,14 +24535,8 @@ async function handleNamedRun(options, hooks) {
       "--fixture-behavior requires DEEPLINE_EVAL_INTEGRATION_MODE=fixture."
     );
   }
-  if (options.debugFixtureProviderPacing && integrationMode !== "fixture") {
-    throw new Error(
-      "--debug-fixture-provider-pacing requires DEEPLINE_EVAL_INTEGRATION_MODE=fixture."
-    );
-  }
   const testPolicyOverrides = {
-    ...options.debugMapLatency ? { mapLatencyProfile: true } : {},
-    ...options.debugFixtureProviderPacing ? { enforceFixtureProviderPacing: true } : {}
+    ...options.debugMapLatency ? { mapLatencyProfile: true } : {}
   };
   const startRequest = {
     name: playName,
@@ -26257,9 +26421,6 @@ Examples:
   ).option("--open", "Open the play page in a browser after the run starts").option(
     "--debug-map-latency",
     "Internal diagnostics: emit one aggregate latency profile per dataset map"
-  ).option(
-    "--debug-fixture-provider-pacing",
-    "Internal diagnostics: retain provider pacing while fixture mode is active"
   ).option("--json", "Emit JSON output").option("--full", "Debug only: with --json, emit the raw status payload").addHelpText(
     "afterAll",
     `
@@ -26306,7 +26467,6 @@ Pass-through input flags:
       ...options.maxConcurrentRows ? ["--max-concurrent-rows", options.maxConcurrentRows] : [],
       ...options.open ? ["--open"] : [],
       ...options.debugMapLatency ? ["--debug-map-latency"] : [],
-      ...options.debugFixtureProviderPacing ? ["--debug-fixture-provider-pacing"] : [],
       ...options.json ? ["--json"] : [],
       ...options.full ? ["--full"] : [],
       ...passthroughArgs
@@ -28728,7 +28888,7 @@ function emitEnrichDebug(message) {
   );
 }
 function sleep6(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 function enrichExportBackingRowsWaitMs() {
   const raw = process.env.DEEPLINE_ENRICH_EXPORT_BACKING_ROWS_WAIT_MS?.trim();
@@ -35168,7 +35328,7 @@ async function readHiddenLine(prompt, streams = {}) {
   }
   let value = "";
   inputStream.resume();
-  return await new Promise((resolve19, reject) => {
+  return await new Promise((resolve20, reject) => {
     let settled = false;
     const cleanup = () => {
       inputStream.off("data", onData);
@@ -35186,7 +35346,7 @@ async function readHiddenLine(prompt, streams = {}) {
       settled = true;
       outputStream.write("\n");
       cleanup();
-      resolve19(line);
+      resolve20(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -35359,22 +35519,149 @@ Examples:
 // src/cli/commands/setup.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import {
-  existsSync as existsSync13,
-  lstatSync,
+  existsSync as existsSync14,
+  lstatSync as lstatSync2,
   mkdirSync as mkdirSync11,
-  readFileSync as readFileSync13,
-  realpathSync as realpathSync3,
-  rmSync as rmSync4,
+  readFileSync as readFileSync14,
+  realpathSync as realpathSync4,
   writeFileSync as writeFileSync14
 } from "fs";
 import { homedir as homedir9 } from "os";
-import { basename as basename6, dirname as dirname15, join as join15, relative as relative5, resolve as resolve14 } from "path";
+import { dirname as dirname16, join as join16, resolve as resolve15 } from "path";
+
+// src/cli/installation-lifecycle.ts
+import {
+  existsSync as existsSync11,
+  lstatSync,
+  readFileSync as readFileSync11,
+  realpathSync as realpathSync3,
+  rmSync as rmSync4
+} from "fs";
+import { basename as basename6, dirname as dirname13, join as join13, relative as relative5, resolve as resolve14 } from "path";
+var nodeFileSystem = {
+  exists: existsSync11,
+  isSymbolicLink(path) {
+    try {
+      return lstatSync(path).isSymbolicLink();
+    } catch {
+      return false;
+    }
+  },
+  read(path) {
+    try {
+      return readFileSync11(path, "utf8");
+    } catch {
+      return "";
+    }
+  },
+  realpath(path) {
+    try {
+      return realpathSync3(path);
+    } catch {
+      return null;
+    }
+  },
+  remove(path) {
+    rmSync4(path, { force: true });
+  }
+};
+function inspectLauncher(path, fileSystem = nodeFileSystem) {
+  if (!fileSystem.exists(path)) {
+    return { ownership: "missing", resolvedPath: null };
+  }
+  const resolvedPath = fileSystem.realpath(path);
+  if (CliInstallation.isNpmPackagePath(resolvedPath)) {
+    return { ownership: "npm", resolvedPath };
+  }
+  if (fileSystem.isSymbolicLink(path)) {
+    return { ownership: "symlink", resolvedPath };
+  }
+  const content = fileSystem.read(path);
+  if (content.includes("DEEPLINE_REAL_BINARY") && content.includes("DEEPLINE_ACTIVE_FILE")) {
+    return { ownership: "installer_legacy", resolvedPath };
+  }
+  return { ownership: "user", resolvedPath };
+}
+var CliInstallation = class _CliInstallation {
+  constructor(input2) {
+    this.input = input2;
+  }
+  static forUser(input2) {
+    return new _CliInstallation({
+      ...input2,
+      fileSystem: input2.fileSystem ?? nodeFileSystem
+    });
+  }
+  static isNpmPackagePath(path) {
+    return path?.includes(`${join13("node_modules", "deepline")}`) ?? false;
+  }
+  launcher(path) {
+    return inspectLauncher(path, this.input.fileSystem);
+  }
+  retiredArtifacts() {
+    const hostDir = join13(
+      this.input.home,
+      ".local",
+      "deepline",
+      this.input.baseUrlSlug
+    );
+    const legacyLauncherPath = join13(
+      this.input.home,
+      ".local",
+      "bin",
+      "deepline"
+    );
+    const installerCommandPath = this.input.fileSystem.read(join13(hostDir, "sdk", ".command-path")).trim();
+    const ownedInstallerCommand = isOwnedInstallerCommandPath({
+      hostDir,
+      commandPath: installerCommandPath
+    });
+    const legacyLauncher = this.launcher(legacyLauncherPath);
+    const candidates = [
+      ...legacyLauncher.ownership === "installer_legacy" ? [legacyLauncherPath] : [],
+      join13(this.input.home, ".local", "bin", "deepline-real"),
+      join13(hostDir, "bin", "deepline"),
+      join13(hostDir, "bin", "deepline-real"),
+      join13(hostDir, "cli", ".install-method"),
+      join13(hostDir, "cli", ".version"),
+      join13(hostDir, "sdk", ".install-method"),
+      join13(hostDir, "sdk", ".command-path"),
+      ...ownedInstallerCommand ? [
+        installerCommandPath,
+        join13(dirname13(installerCommandPath), "deepline-sdk")
+      ] : []
+    ];
+    return {
+      paths: candidates.filter((path) => {
+        if (!this.input.fileSystem.exists(path)) return false;
+        return this.launcher(path).ownership !== "npm";
+      })
+    };
+  }
+  removeRetiredArtifacts() {
+    return removeArtifacts(this.retiredArtifacts(), this.input.fileSystem);
+  }
+};
+function removeArtifacts(plan, fileSystem) {
+  for (const path of plan.paths) {
+    fileSystem.remove(path);
+  }
+  return plan.paths;
+}
+function isOwnedInstallerCommandPath(input2) {
+  if (!input2.commandPath || basename6(input2.commandPath) !== "deepline") {
+    return false;
+  }
+  const commandPath = resolve14(input2.commandPath);
+  const fromHost = relative5(resolve14(input2.hostDir), commandPath);
+  return fromHost !== "" && fromHost !== ".." && !fromHost.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`);
+}
 
 // src/cli/commands/skills.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync12, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname14, join as join14 } from "path";
+import { dirname as dirname15, join as join15 } from "path";
 
 // ../../shared_libs/cli/install-commands.json
 var install_commands_default = {
@@ -35479,13 +35766,13 @@ function buildSkillsAddArgs(baseUrl, skillName, options = {}) {
 // src/cli/skills-sync.ts
 import { spawn as spawn2, spawnSync } from "child_process";
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   unlinkSync,
   writeFileSync as writeFileSync12
 } from "fs";
-import { dirname as dirname13, join as join13 } from "path";
+import { dirname as dirname14, join as join14 } from "path";
 
 // src/cli/windows-arg-escape.ts
 var CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
@@ -35520,10 +35807,10 @@ function shouldSkipSkillsSync() {
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
 function unavailableSkillsNoticePath(baseUrl) {
-  return join13(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
+  return join14(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
 }
 function failedSkillsSyncPath(baseUrl, agents) {
-  return join13(
+  return join14(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-failed-${agents.join("-")}-version`
   );
@@ -35533,14 +35820,14 @@ function hasMarkedSkillsSyncVersion(path, version) {
 }
 function readMarkedSkillsSyncVersion(path) {
   try {
-    return existsSync11(path) ? readFileSync11(path, "utf-8").trim() : "";
+    return existsSync12(path) ? readFileSync12(path, "utf-8").trim() : "";
   } catch {
     return "";
   }
 }
 function writeMarkedSkillsSyncVersion(path, version) {
   try {
-    mkdirSync9(dirname13(path), { recursive: true });
+    mkdirSync9(dirname14(path), { recursive: true });
     writeFileSync12(path, `${version}
 `, "utf-8");
   } catch {
@@ -35569,7 +35856,7 @@ function hasFailedSkillsSync(baseUrl, remoteVersion, agents) {
   );
 }
 function hasFailedAutomaticSkillsSync(baseUrl, agents) {
-  return existsSync11(failedSkillsSyncPath(baseUrl, agents));
+  return existsSync12(failedSkillsSyncPath(baseUrl, agents));
 }
 function markFailedSkillsSync(baseUrl, remoteVersion, agents) {
   writeMarkedSkillsSyncVersion(
@@ -35694,7 +35981,7 @@ function resolveSkillsInstallCommands(baseUrl, skillNames = DEFAULT_SDK_SKILL_NA
   return commands;
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     const plan = resolveSkillsInstallSpawn(install);
     const child = spawn2(plan.command, plan.args, {
       stdio: ["ignore", "ignore", "pipe"],
@@ -35706,7 +35993,7 @@ function runOneSkillsInstall(install) {
       stderr += chunk.toString("utf-8");
     });
     child.on("error", (error) => {
-      resolve19({
+      resolve20({
         ok: false,
         detail: `failed to start ${install.command}: ${error.message}`,
         manualCommand: install.manualCommand
@@ -35714,11 +36001,11 @@ function runOneSkillsInstall(install) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve19({ ok: true, detail: "", manualCommand: install.manualCommand });
+        resolve20({ ok: true, detail: "", manualCommand: install.manualCommand });
         return;
       }
       const detail = stderr.trim();
-      resolve19({
+      resolve20({
         ok: false,
         detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
         manualCommand: install.manualCommand
@@ -35920,13 +36207,13 @@ function detectSkillsAgents(input2) {
   ];
   const detected = AGENT_MARKERS.filter(
     (marker) => roots.some(
-      (root) => marker.paths.some((path) => existsSync12(join14(root, path)))
+      (root) => marker.paths.some((path) => existsSync13(join15(root, path)))
     )
   ).map((marker) => marker.agent);
   return detected.length > 0 ? detected : ["*"];
 }
 function skillsStatePathForScope(baseUrl, scope, root) {
-  return scope === "local" && root ? join14(root, ".deepline", "setup", "skills.json") : join14(sdkCliStateDirPath(baseUrl), "skills-install.json");
+  return scope === "local" && root ? join15(root, ".deepline", "setup", "skills.json") : join15(sdkCliStateDirPath(baseUrl), "skills-install.json");
 }
 function buildSkillsPlan(input2) {
   const scopeArgs = input2.scope === "global" ? ["--global"] : [];
@@ -35993,14 +36280,14 @@ function isSkillsPlanCurrent(plan, state) {
 }
 function readSkillsInstallState(path) {
   try {
-    const parsed = JSON.parse(readFileSync12(path, "utf8"));
+    const parsed = JSON.parse(readFileSync13(path, "utf8"));
     return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
 function runProcess(command, args, cwd) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const plan = resolveShellSpawn(command, args);
     const child = spawn3(plan.command, plan.args, {
       cwd,
@@ -36019,7 +36306,7 @@ function runProcess(command, args, cwd) {
         process.stderr.write(`${SKILLS_NPX_PACKAGE} exited ${code}.
 `);
       }
-      resolve19(code ?? 1);
+      resolve20(code ?? 1);
     });
   });
 }
@@ -36137,7 +36424,7 @@ async function runSkillsCommand(options, dependencies = {}) {
     );
     return 5;
   }
-  mkdirSync10(dirname14(plan.statePath), { recursive: true });
+  mkdirSync10(dirname15(plan.statePath), { recursive: true });
   writeFileSync13(
     plan.statePath,
     `${JSON.stringify(
@@ -36275,7 +36562,7 @@ function phasesFromLegacyStatus(status) {
 function readSetupState(input2) {
   try {
     const parsed = JSON.parse(
-      readFileSync13(
+      readFileSync14(
         setupStatePath(input2.baseUrl, input2.scope, input2.root),
         "utf8"
       )
@@ -36351,7 +36638,7 @@ function buildPendingAuthorizationOutput(input2) {
   };
 }
 function setupStatePath(baseUrl, scope, root) {
-  return scope === "local" && root ? join15(root, ".deepline", "setup", "state.json") : join15(sdkCliStateDirPath(baseUrl), "setup.json");
+  return scope === "local" && root ? join16(root, ".deepline", "setup", "state.json") : join16(sdkCliStateDirPath(baseUrl), "setup.json");
 }
 async function captureStdout2(run) {
   let stdout = "";
@@ -36380,57 +36667,16 @@ function asRecord3(value) {
 }
 function safeRead(path) {
   try {
-    return readFileSync13(path, "utf8");
+    return readFileSync14(path, "utf8");
   } catch {
     return "";
   }
 }
-function isNpmManagedDeeplinePath(path) {
-  try {
-    return realpathSync3(path).includes(`${join15("node_modules", "deepline")}`);
-  } catch {
-    return false;
-  }
-}
-function isInstallerManagedLegacyLauncher(path) {
-  const content = safeRead(path);
-  return content.includes("DEEPLINE_REAL_BINARY") && content.includes("DEEPLINE_ACTIVE_FILE");
-}
 function removeKnownLegacyPaths(baseUrl) {
-  const home = homedir9();
-  const hostDir = join15(home, ".local", "deepline", baseUrlSlug(baseUrl));
-  const legacyLauncherPath = join15(home, ".local", "bin", "deepline");
-  const installerCommandPath = safeRead(
-    join15(hostDir, "sdk", ".command-path")
-  ).trim();
-  const relativeInstallerCommandPath = installerCommandPath ? relative5(resolve14(hostDir), resolve14(installerCommandPath)) : "";
-  const isOwnedInstallerCommand = Boolean(installerCommandPath) && relativeInstallerCommandPath !== "" && !relativeInstallerCommandPath.startsWith(
-    `..${process.platform === "win32" ? "\\" : "/"}`
-  ) && relativeInstallerCommandPath !== ".." && basename6(installerCommandPath) === "deepline";
-  const candidates = [
-    ...isInstallerManagedLegacyLauncher(legacyLauncherPath) ? [legacyLauncherPath] : [],
-    join15(home, ".local", "bin", "deepline-real"),
-    join15(hostDir, "bin", "deepline"),
-    join15(hostDir, "bin", "deepline-real"),
-    join15(hostDir, "cli", ".install-method"),
-    join15(hostDir, "cli", ".version"),
-    join15(hostDir, "sdk", ".install-method"),
-    join15(hostDir, "sdk", ".command-path"),
-    ...isOwnedInstallerCommand ? [
-      installerCommandPath,
-      join15(dirname15(installerCommandPath), "deepline-sdk")
-    ] : []
-  ];
-  const removed = [];
-  for (const path of candidates) {
-    if (!existsSync13(path)) continue;
-    if (path === installerCommandPath && isNpmManagedDeeplinePath(path)) {
-      continue;
-    }
-    rmSync4(path, { force: true });
-    removed.push(path);
-  }
-  return removed;
+  return CliInstallation.forUser({
+    baseUrlSlug: baseUrlSlug(baseUrl),
+    home: homedir9()
+  }).removeRetiredArtifacts();
 }
 function resolvePathCommands(command) {
   const lookup = spawnSync2(
@@ -36440,7 +36686,7 @@ function resolvePathCommands(command) {
   );
   return [
     ...new Set(
-      String(lookup.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => resolve14(path))
+      String(lookup.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => resolve15(path))
     )
   ];
 }
@@ -36450,7 +36696,7 @@ function resolvePathCommand(command) {
 function isHomebrewFormulaCommand(path) {
   let resolvedPath = path;
   try {
-    resolvedPath = realpathSync3(path);
+    resolvedPath = realpathSync4(path);
   } catch {
     return false;
   }
@@ -36461,7 +36707,7 @@ function isHomebrewFormulaCommand(path) {
 function resolvePersistentGlobalCommand(dependencies = {}) {
   const platform3 = dependencies.platform ?? process.platform;
   const run = dependencies.spawn ?? spawnSync2;
-  const pathExists = dependencies.exists ?? existsSync13;
+  const pathExists = dependencies.exists ?? existsSync14;
   const pathClis = dependencies.pathClis ?? resolvePathCommands("deepline");
   const homebrewCommand = pathClis.find(isHomebrewFormulaCommand);
   if (homebrewCommand) return homebrewCommand;
@@ -36473,7 +36719,7 @@ function resolvePersistentGlobalCommand(dependencies = {}) {
   if (prefix.status !== 0) return null;
   const root = String(prefix.stdout ?? "").trim();
   if (!root) return null;
-  const candidates = platform3 === "win32" ? [join15(root, "deepline.cmd"), join15(root, "deepline")] : [join15(root, "bin", "deepline")];
+  const candidates = platform3 === "win32" ? [join16(root, "deepline.cmd"), join16(root, "deepline")] : [join16(root, "bin", "deepline")];
   return candidates.find((candidate) => pathExists(candidate)) ?? null;
 }
 function inspectGlobalCliAvailability(input2) {
@@ -36486,20 +36732,20 @@ function inspectGlobalCliAvailability(input2) {
 }
 function pathsResolveToSameFile(left, right) {
   try {
-    return realpathSync3(left) === realpathSync3(right);
+    return realpathSync4(left) === realpathSync4(right);
   } catch {
-    return resolve14(left) === resolve14(right);
+    return resolve15(left) === resolve15(right);
   }
 }
 function isKnownDeeplineCommand(path) {
-  const entrypoint = process.argv[1] ? resolve14(process.argv[1]) : "";
+  const entrypoint = process.argv[1] ? resolve15(process.argv[1]) : "";
   let resolvedPath = path;
   try {
-    resolvedPath = realpathSync3(path);
+    resolvedPath = realpathSync4(path);
   } catch {
   }
   if (entrypoint && resolvedPath === entrypoint) return true;
-  if (resolvedPath.includes(`${join15("node_modules", "deepline")}`)) return true;
+  if (resolvedPath.includes(`${join16("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");
 }
@@ -36507,9 +36753,9 @@ function inspectPathConflict() {
   const commandPath = resolvePathCommand("deepline");
   if (!commandPath || isKnownDeeplineCommand(commandPath)) return null;
   try {
-    if (lstatSync(commandPath).isSymbolicLink()) {
-      const target = realpathSync3(commandPath);
-      if (target.includes(`${join15("node_modules", "deepline")}`)) return null;
+    if (lstatSync2(commandPath).isSymbolicLink()) {
+      const target = realpathSync4(commandPath);
+      if (target.includes(`${join16("node_modules", "deepline")}`)) return null;
     }
   } catch {
   }
@@ -36517,7 +36763,7 @@ function inspectPathConflict() {
 }
 function writeSetupState(input2) {
   const path = setupStatePath(input2.baseUrl, input2.scope, input2.root);
-  mkdirSync11(dirname15(path), { recursive: true });
+  mkdirSync11(dirname16(path), { recursive: true });
   writeFileSync14(
     path,
     `${JSON.stringify(
@@ -36558,7 +36804,7 @@ function failSetupPhase(phases, phase, code) {
   phases[phase] = { status: "failed", code };
 }
 function rollbackCommand(scope, root) {
-  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify(join15(root, ".deepline", "runtime"))}` : "";
+  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify(join16(root, ".deepline", "runtime"))}` : "";
   return `npm install -g${prefix} --no-audit --no-fund --include=optional --allow-scripts=esbuild deepline@${SDK_VERSION}`;
 }
 function setupResumeCommand(baseUrl, scope) {
@@ -36645,12 +36891,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] ? resolve14(process.argv[1]) : null;
+  const runningCliPath = process.argv[1] ? resolve15(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(join15(input2.root, ".deepline", "runtime"))
+    input2.root && runningCliPath?.includes(join16(input2.root, ".deepline", "runtime"))
   );
   const checks = {
     cli: {
@@ -37178,15 +37424,15 @@ Examples:
 
 // src/cli/update-preferences.ts
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   mkdirSync as mkdirSync12,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   renameSync,
   rmSync as rmSync5,
   writeFileSync as writeFileSync15
 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname16, join as join16 } from "path";
+import { dirname as dirname17, join as join17 } from "path";
 var UPDATE_PREFERENCES_SCHEMA_VERSION = 1;
 var CLI_UPDATE_MESSAGES = [
   {
@@ -37215,7 +37461,7 @@ function unreadablePreferences(path, error) {
   };
 }
 function cliUpdatePreferencesPath(homeDir2 = homedir10()) {
-  return join16(
+  return join17(
     homeDir2,
     ".local",
     "deepline",
@@ -37225,9 +37471,9 @@ function cliUpdatePreferencesPath(homeDir2 = homedir10()) {
 }
 function readCliUpdatePreferences(homeDir2 = homedir10()) {
   const path = cliUpdatePreferencesPath(homeDir2);
-  if (!existsSync14(path)) return defaultPreferences();
+  if (!existsSync15(path)) return defaultPreferences();
   try {
-    const parsed = JSON.parse(readFileSync14(path, "utf8"));
+    const parsed = JSON.parse(readFileSync15(path, "utf8"));
     return {
       schemaVersion: UPDATE_PREFERENCES_SCHEMA_VERSION,
       autoUpdateEnabled: typeof parsed.autoUpdateEnabled === "boolean" ? parsed.autoUpdateEnabled : true,
@@ -37243,7 +37489,7 @@ function readCliUpdatePreferences(homeDir2 = homedir10()) {
 function writeCliUpdatePreferences(preferences, homeDir2 = homedir10()) {
   const path = cliUpdatePreferencesPath(homeDir2);
   const tempPath = `${path}.${process.pid}.tmp`;
-  mkdirSync12(dirname16(path), { recursive: true });
+  mkdirSync12(dirname17(path), { recursive: true });
   try {
     writeFileSync15(tempPath, `${JSON.stringify(preferences, null, 2)}
 `, {
@@ -37303,10 +37549,10 @@ function consumePendingCliUpdateMessages(homeDir2 = homedir10()) {
 // src/cli/commands/update.ts
 import { spawn as spawn4, spawnSync as spawnSync3 } from "child_process";
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync13,
-  realpathSync as realpathSync4,
-  readFileSync as readFileSync16,
+  realpathSync as realpathSync5,
+  readFileSync as readFileSync17,
   renameSync as renameSync2,
   rmSync as rmSync6,
   unlinkSync as unlinkSync2,
@@ -37315,17 +37561,17 @@ import {
 import { homedir as homedir11 } from "os";
 import {
   basename as basename7,
-  dirname as dirname17,
+  dirname as dirname18,
   isAbsolute as isAbsolute7,
-  join as join18,
+  join as join19,
   relative as relative7,
-  resolve as resolve16
+  resolve as resolve17
 } from "path";
 
 // src/cli/install-integrity.ts
 import { createRequire } from "module";
-import { existsSync as existsSync15, readFileSync as readFileSync15, statSync as statSync5 } from "fs";
-import { isAbsolute as isAbsolute6, join as join17, relative as relative6, resolve as resolve15 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync16, statSync as statSync5 } from "fs";
+import { isAbsolute as isAbsolute6, join as join18, relative as relative6, resolve as resolve16 } from "path";
 var SDK_SIDECAR_CRITICAL_PACKAGE_FILES = [
   "dist/cli/index.mjs",
   "dist/index.mjs",
@@ -37350,15 +37596,15 @@ function safeRelativePath(value) {
 }
 function resolveContainedPath(root, value) {
   if (!safeRelativePath(value)) return null;
-  const target = resolve15(root, value);
-  const relativeTarget = relative6(resolve15(root), target);
+  const target = resolve16(root, value);
+  const relativeTarget = relative6(resolve16(root), target);
   if (!relativeTarget || relativeTarget.startsWith("..") || isAbsolute6(relativeTarget)) {
     return null;
   }
   return target;
 }
 function parseJson(path) {
-  return JSON.parse(readFileSync15(path, "utf8"));
+  return JSON.parse(readFileSync16(path, "utf8"));
 }
 function isFile(path) {
   try {
@@ -37368,7 +37614,7 @@ function isFile(path) {
   }
 }
 function readManifest(packageRoot) {
-  const packageJsonPath = join17(packageRoot, "package.json");
+  const packageJsonPath = join18(packageRoot, "package.json");
   let packageJson;
   try {
     packageJson = parseJson(packageJsonPath);
@@ -37376,7 +37622,7 @@ function readManifest(packageRoot) {
     return {
       mode: "manifest",
       invalidReason: `invalid Deepline package metadata: ${error.message}`,
-      missing: existsSync15(packageJsonPath) ? [] : ["deepline/package.json"]
+      missing: existsSync16(packageJsonPath) ? [] : ["deepline/package.json"]
     };
   }
   if (!packageJson || typeof packageJson !== "object" || Array.isArray(packageJson)) {
@@ -37442,8 +37688,8 @@ function readManifest(packageRoot) {
   return { mode: "manifest", manifest };
 }
 function inspectSdkSidecarInstall(versionDir) {
-  const nodeModulesRoot = join17(versionDir, "node_modules");
-  const packageRoot = join17(nodeModulesRoot, "deepline");
+  const nodeModulesRoot = join18(versionDir, "node_modules");
+  const packageRoot = join18(nodeModulesRoot, "deepline");
   const manifestResult = readManifest(packageRoot);
   if ("invalidReason" in manifestResult) {
     return {
@@ -37454,8 +37700,8 @@ function inspectSdkSidecarInstall(versionDir) {
     };
   }
   const missing = [
-    ...manifestResult.manifest.packageFiles.filter((path) => !isFile(join17(packageRoot, path))).map((path) => `deepline/${path}`),
-    ...manifestResult.manifest.dependencyFiles.filter((path) => !isFile(join17(nodeModulesRoot, path))).map((path) => `node_modules/${path}`)
+    ...manifestResult.manifest.packageFiles.filter((path) => !isFile(join18(packageRoot, path))).map((path) => `deepline/${path}`),
+    ...manifestResult.manifest.dependencyFiles.filter((path) => !isFile(join18(nodeModulesRoot, path))).map((path) => `node_modules/${path}`)
   ];
   return {
     ok: missing.length === 0,
@@ -37466,7 +37712,7 @@ function inspectSdkSidecarInstall(versionDir) {
 }
 function probeSdkSidecarEsbuild(versionDir) {
   try {
-    const requireFromInstall = createRequire(join17(versionDir, "package.json"));
+    const requireFromInstall = createRequire(join18(versionDir, "package.json"));
     const esbuild = requireFromInstall("esbuild");
     if (typeof esbuild.transformSync !== "function") {
       return "esbuild does not export transformSync";
@@ -37541,7 +37787,7 @@ function sidecarStateDir(input2) {
   if (!scope || scope.includes("/") || scope.includes("\\")) {
     return null;
   }
-  return join18(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
+  return join19(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
 }
 function sidecarRegistryUrl(hostUrl) {
   let url;
@@ -37568,7 +37814,7 @@ function publicNpmFallbackRegistryUrl(hostUrl) {
 }
 function readOptionalText(path) {
   try {
-    return readFileSync16(path, "utf8").trim();
+    return readFileSync17(path, "utf8").trim();
   } catch {
     return "";
   }
@@ -37577,18 +37823,18 @@ function resolvePythonSidecarUpdatePlan(options) {
   const stateDir = sidecarStateDir(options);
   if (!stateDir) return null;
   const relativeEntrypoint = relative7(
-    resolve16(stateDir),
-    resolve16(options.entrypoint)
+    resolve17(stateDir),
+    resolve17(options.entrypoint)
   );
   if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || isAbsolute7(relativeEntrypoint)) {
     return null;
   }
-  const installMethod = readOptionalText(join18(stateDir, ".install-method"));
+  const installMethod = readOptionalText(join19(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(join18(stateDir, ".node-bin")) || process.execPath;
-  const sidecarPath = readOptionalText(join18(stateDir, ".command-path")) || join18(
+  const nodeBin = readOptionalText(join19(stateDir, ".node-bin")) || process.execPath;
+  const sidecarPath = readOptionalText(join19(stateDir, ".command-path")) || join19(
     stateDir,
     "bin",
     process.platform === "win32" ? "deepline-sdk.cmd" : "deepline-sdk"
@@ -37596,7 +37842,7 @@ function resolvePythonSidecarUpdatePlan(options) {
   const packageSpec = options.packageSpec || "deepline@latest";
   const npmCommand = "npm";
   const registryUrl = sidecarRegistryUrl(hostUrl);
-  const versionDir = join18(stateDir, "versions", "<version>");
+  const versionDir = join19(stateDir, "versions", "<version>");
   const manualCommand = `${buildSidecarProjectConfigCommand(versionDir, nodeBin)} && ${npmCommand} install --prefix ${shellQuote4(versionDir)} --registry ${shellQuote4(registryUrl)} ${NPM_SDK_INSTALL_COMMON_FLAGS.map(shellQuote4).join(" ")} ${shellQuote4(packageSpec)}`;
   return {
     kind: "python-sidecar",
@@ -37612,16 +37858,16 @@ function resolvePythonSidecarUpdatePlan(options) {
   };
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = resolve16(startPath);
+  let current = resolve17(startPath);
   while (true) {
-    if (existsSync16(join18(current, "package.json")) && existsSync16(join18(current, "bin", "deepline-dev.ts"))) {
-      const parent2 = dirname17(current);
-      return basename7(parent2) === "packages" && basename7(current) === "sdk" ? dirname17(parent2) : parent2;
+    if (existsSync17(join19(current, "package.json")) && existsSync17(join19(current, "bin", "deepline-dev.ts"))) {
+      const parent2 = dirname18(current);
+      return basename7(parent2) === "packages" && basename7(current) === "sdk" ? dirname18(parent2) : parent2;
     }
-    if (existsSync16(join18(current, "sdk", "package.json")) && existsSync16(join18(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if (existsSync17(join19(current, "sdk", "package.json")) && existsSync17(join19(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = dirname17(current);
+    const parent = dirname18(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -37629,9 +37875,9 @@ function findRepoBackedSdkRoot(startPath) {
 function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
   const normalized = (() => {
     try {
-      return realpathSync4(entrypoint);
+      return realpathSync5(entrypoint);
     } catch {
-      return resolve16(entrypoint);
+      return resolve17(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -37646,10 +37892,10 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
     const directPrefix = prefixParts.join("/").toLowerCase();
     const knownWindowsPrefixes = [
       env.npm_config_prefix,
-      env.APPDATA ? join18(env.APPDATA, "npm") : void 0
-    ].filter((value) => Boolean(value)).map((value) => resolve16(value).replace(/\\/g, "/").toLowerCase());
+      env.APPDATA ? join19(env.APPDATA, "npm") : void 0
+    ].filter((value) => Boolean(value)).map((value) => resolve17(value).replace(/\\/g, "/").toLowerCase());
     if (!knownWindowsPrefixes.includes(
-      resolve16(directPrefix).replace(/\\/g, "/").toLowerCase()
+      resolve17(directPrefix).replace(/\\/g, "/").toLowerCase()
     )) {
       return null;
     }
@@ -37662,9 +37908,9 @@ function normalizedNpmPrefix(value) {
   if (!trimmed) return null;
   const normalized = (() => {
     try {
-      return realpathSync4(resolve16(trimmed));
+      return realpathSync5(resolve17(trimmed));
     } catch {
-      return resolve16(trimmed);
+      return resolve17(trimmed);
     }
   })().replace(/\\/g, "/");
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
@@ -37687,9 +37933,9 @@ function resolveNpmGlobalPrefix(env) {
 function isHomebrewFormulaEntrypoint(entrypoint) {
   const normalized = (() => {
     try {
-      return realpathSync4(entrypoint);
+      return realpathSync5(entrypoint);
     } catch {
-      return resolve16(entrypoint);
+      return resolve17(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -37699,8 +37945,8 @@ function isHomebrewFormulaEntrypoint(entrypoint) {
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
   const homeDir2 = options.homeDir ?? homedir11();
-  const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve16(process.argv[1]) : "");
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname17(entrypoint)) : null;
+  const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve17(process.argv[1]) : "");
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname18(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -37751,9 +37997,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 join18(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
+    return join19(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
   }
-  return join18(
+  return join19(
     homedir11(),
     ".local",
     "deepline",
@@ -37771,7 +38017,7 @@ function readAutoUpdateFailure(plan) {
   if (!path) return null;
   try {
     const parsed = JSON.parse(
-      readFileSync16(path, "utf8")
+      readFileSync17(path, "utf8")
     );
     if ((parsed.kind === "npm-global" || parsed.kind === "python-sidecar") && typeof parsed.packageSpec === "string" && typeof parsed.failedAt === "string" && typeof parsed.exitCode === "number" && typeof parsed.manualCommand === "string") {
       return parsed;
@@ -37792,7 +38038,7 @@ function writeAutoUpdateFailure(plan, exitCode) {
     manualCommand: plan.manualCommand
   };
   try {
-    mkdirSync13(dirname17(path), { recursive: true });
+    mkdirSync13(dirname18(path), { recursive: true });
     writeFileSync16(path, `${JSON.stringify(marker, null, 2)}
 `, "utf8");
   } catch {
@@ -37840,7 +38086,7 @@ function safeVersionSegment(value) {
   return /^[0-9A-Za-z._-]+$/.test(normalized) ? normalized : "";
 }
 function entryPathInVersionDir(versionDir) {
-  return join18(
+  return join19(
     versionDir,
     "node_modules",
     "deepline",
@@ -37850,14 +38096,14 @@ function entryPathInVersionDir(versionDir) {
   );
 }
 function installedPackageVersion(versionDir) {
-  const packageJsonPath = join18(
+  const packageJsonPath = join19(
     versionDir,
     "node_modules",
     "deepline",
     "package.json"
   );
   try {
-    const parsed = JSON.parse(readFileSync16(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(readFileSync17(packageJsonPath, "utf8"));
     return typeof parsed.version === "string" ? safeVersionSegment(parsed.version) : "";
   } catch {
     return "";
@@ -37972,16 +38218,16 @@ async function runNpmInstallWithRegistryFallback(input2) {
   return first.exitCode;
 }
 function writeSidecarLauncher(input2) {
-  mkdirSync13(dirname17(input2.path), { recursive: true });
-  const packageRoot = dirname17(dirname17(dirname17(input2.entryPath)));
-  const versionDir = dirname17(dirname17(packageRoot));
+  mkdirSync13(dirname18(input2.path), { recursive: true });
+  const packageRoot = dirname18(dirname18(dirname18(input2.entryPath)));
+  const versionDir = dirname18(dirname18(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) => join18(packageRoot, path)
+      (path) => join19(packageRoot, path)
     ),
     ...SDK_SIDECAR_CRITICAL_DEPENDENCY_FILES.map(
-      (path) => join18(versionDir, "node_modules", path)
+      (path) => join19(versionDir, "node_modules", path)
     )
   ];
   if (process.platform === "win32") {
@@ -38035,17 +38281,17 @@ function writeSidecarLauncher(input2) {
   );
 }
 async function runPythonSidecarUpdatePlan(plan) {
-  const versionsDir = join18(plan.stateDir, "versions");
-  const tempDir = join18(
+  const versionsDir = join19(plan.stateDir, "versions");
+  const tempDir = join19(
     versionsDir,
     `.tmp-sdk-update-${process.pid}-${Date.now()}`
   );
   rmSync6(tempDir, { recursive: true, force: true });
   mkdirSync13(tempDir, { recursive: true });
-  writeFileSync16(join18(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
+  writeFileSync16(join19(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
   const env = {
     ...process.env,
-    PATH: `${dirname17(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
+    PATH: `${dirname18(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
   };
   const installResult = await runCommand(
     plan.npmCommand,
@@ -38082,7 +38328,7 @@ async function runPythonSidecarUpdatePlan(plan) {
     rmSync6(tempDir, { recursive: true, force: true });
     return 1;
   }
-  const finalDir = join18(versionsDir, installedVersion);
+  const finalDir = join19(versionsDir, installedVersion);
   const finalEntryPath = entryPathInVersionDir(finalDir);
   const finalFailure = sidecarInstallFailure(finalDir);
   let backupDir = null;
@@ -38090,8 +38336,8 @@ async function runPythonSidecarUpdatePlan(plan) {
     rmSync6(tempDir, { recursive: true, force: true });
   } else {
     let shouldPublishTemp = true;
-    if (existsSync16(finalDir)) {
-      backupDir = join18(
+    if (existsSync17(finalDir)) {
+      backupDir = join19(
         versionsDir,
         `.backup-${installedVersion}-${process.pid}-${Date.now()}`
       );
@@ -38124,7 +38370,7 @@ async function runPythonSidecarUpdatePlan(plan) {
           backupDir = null;
         } else {
           let restoreFailure = "";
-          if (backupDir && existsSync16(backupDir) && !existsSync16(finalDir)) {
+          if (backupDir && existsSync17(backupDir) && !existsSync17(finalDir)) {
             try {
               renameSync2(backupDir, finalDir);
               backupDir = null;
@@ -38143,7 +38389,7 @@ async function runPythonSidecarUpdatePlan(plan) {
   }
   const publishedFailure = sidecarStructureFailure(finalDir);
   if (publishedFailure) {
-    if (backupDir && existsSync16(backupDir)) {
+    if (backupDir && existsSync17(backupDir)) {
       rmSync6(finalDir, { recursive: true, force: true });
       try {
         renameSync2(backupDir, finalDir);
@@ -38166,27 +38412,27 @@ async function runPythonSidecarUpdatePlan(plan) {
     entryPath: finalEntryPath
   });
   writeFileSync16(
-    join18(plan.stateDir, ".version"),
+    join19(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
   writeFileSync16(
-    join18(plan.stateDir, ".install-method"),
+    join19(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
   writeFileSync16(
-    join18(plan.stateDir, ".command-path"),
+    join19(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  writeFileSync16(join18(plan.stateDir, ".runner"), "node\n", "utf8");
-  writeFileSync16(join18(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  writeFileSync16(join19(plan.stateDir, ".runner"), "node\n", "utf8");
+  writeFileSync16(join19(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
   writeFileSync16(
-    join18(plan.stateDir, ".entry-path"),
+    join19(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
     "utf8"
@@ -39115,13 +39361,13 @@ chooses the connected Slack channel or member and the events it receives.
 import { Option as Option2 } from "commander";
 import {
   chmodSync,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdtempSync,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   writeFileSync as writeFileSync18
 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join20, resolve as resolve17 } from "path";
+import { join as join21, resolve as resolve18 } from "path";
 
 // src/tool-output.ts
 import {
@@ -39132,7 +39378,7 @@ import {
   writeSync
 } from "fs";
 import { homedir as homedir12 } from "os";
-import { dirname as dirname18, join as join19 } from "path";
+import { dirname as dirname19, join as join20 } from "path";
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -39259,19 +39505,19 @@ function projectRowOutput(conversion) {
   };
 }
 function ensureOutputDir() {
-  const outputDir = join19(homedir12(), ".local", "share", "deepline", "data");
+  const outputDir = join20(homedir12(), ".local", "share", "deepline", "data");
   mkdirSync14(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = join19(outputDir, `${stem}_${Date.now()}.json`);
+  const outputPath = join20(outputDir, `${stem}_${Date.now()}.json`);
   writeFileSync17(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem, options) {
-  const outputPath = options?.outPath ? options.outPath : join19(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
-  mkdirSync14(dirname18(outputPath), { recursive: true });
+  const outputPath = options?.outPath ? options.outPath : join20(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  mkdirSync14(dirname19(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);
@@ -39414,6 +39660,78 @@ function arrayField(value, key) {
   return Array.isArray(candidate) ? candidate : [];
 }
 
+// src/cli/tool-description.ts
+var Capability = class _Capability {
+  #catalogEntry;
+  constructor(catalogEntry) {
+    this.#catalogEntry = catalogEntry;
+  }
+  static fromCatalogEntry(catalogEntry) {
+    return new _Capability(catalogEntry);
+  }
+  describe() {
+    return CapabilityDescription.fromCatalogEntry(this.#catalogEntry);
+  }
+};
+var CapabilityDescription = class _CapabilityDescription {
+  #catalogEntry;
+  constructor(catalogEntry) {
+    this.#catalogEntry = catalogEntry;
+  }
+  static fromCatalogEntry(catalogEntry) {
+    return new _CapabilityDescription(catalogEntry);
+  }
+  /**
+   * The customer price already resolved by the catalog. This intentionally
+   * omits provider-price fields, even when a catalog Adapter carried them.
+   */
+  customerCost() {
+    const legacyCost = recordValue2(this.#catalogEntry.cost);
+    const pricing = recordValue2(this.#catalogEntry.pricing);
+    const unit = stringValue4(pricing.unit);
+    const legacyPricingModel = stringValue4(
+      legacyCost.pricingModel ?? legacyCost.pricing_model
+    );
+    const pricingModel = unit === "call" ? "fixed" : unit === "result" || unit === "page" ? `per_${unit}` : unit === "usage" ? "provider_usage" : legacyPricingModel;
+    const canonicalCredits = numberValue(
+      pricing.creditsPerUnit ?? pricing.credits_per_unit
+    );
+    const canonicalUsd = numberValue(
+      pricing.usdPerUnit ?? pricing.usd_per_unit
+    );
+    return {
+      pricingModel: pricingModel || null,
+      unit: unit || null,
+      displayText: stringValue4(pricing.displayText ?? pricing.display_text),
+      summary: stringValue4(pricing.summary),
+      billingMode: stringValue4(
+        legacyCost.billingMode ?? legacyCost.billing_mode
+      ),
+      billingSource: stringValue4(
+        this.#catalogEntry.billingSource ?? this.#catalogEntry.billing_source
+      ),
+      billingSourceLabel: stringValue4(
+        this.#catalogEntry.billingSourceLabel ?? this.#catalogEntry.billing_source_label
+      ),
+      deeplineCreditsPerPricingUnit: canonicalCredits ?? numberValue(
+        this.#catalogEntry.deeplineCreditsPerPricingUnit ?? this.#catalogEntry.deepline_credits_per_pricing_unit
+      ),
+      deeplineUsdPerPricingUnit: canonicalUsd ?? numberValue(
+        this.#catalogEntry.deeplineUsdPerPricingUnit ?? this.#catalogEntry.deepline_usd_per_pricing_unit
+      )
+    };
+  }
+};
+function recordValue2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue4(value) {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
 // src/cli/commands/tools.ts
 var TOOL_COMMAND_TEMPLATES = {
   describe: "deepline tools describe <toolId>",
@@ -40334,7 +40652,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
   const extractedValues = extractionContractEntries(
     arrayField2(toolExecutionResult, "extractedValues", "extracted_values")
   );
-  const pricing = toolPricingContractForDescribe(tool);
+  const pricing = Capability.fromCatalogEntry(tool).describe().customerCost();
   const deprecation = recordField2(tool, "deprecation");
   const replacementToolId = stringField2(
     deprecation,
@@ -40385,38 +40703,6 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
     ...starterScript ? { starterScript } : {}
   };
 }
-function toolPricingContractForDescribe(tool) {
-  const legacyCost = recordField2(tool, "cost");
-  const pricingValue = tool.pricing;
-  const hasCanonicalPricing = isRecord12(pricingValue);
-  const canonicalPricing = hasCanonicalPricing ? pricingValue : {};
-  const unit = stringField2(canonicalPricing, "unit");
-  const legacyPricingModel = stringField2(
-    legacyCost,
-    "pricingModel",
-    "pricing_model"
-  );
-  const pricingModel = unit === "call" ? "fixed" : unit === "result" || unit === "page" ? `per_${unit}` : unit === "usage" ? "provider_usage" : legacyPricingModel;
-  return {
-    pricingModel: pricingModel || null,
-    unit: unit || null,
-    displayText: stringField2(canonicalPricing, "displayText", "display_text") || null,
-    summary: stringField2(canonicalPricing, "summary") || null,
-    billingMode: stringField2(legacyCost, "billingMode", "billing_mode") || null,
-    billingSource: stringField2(tool, "billingSource", "billing_source") || null,
-    billingSourceLabel: stringField2(tool, "billingSourceLabel", "billing_source_label") || null,
-    deeplineCreditsPerPricingUnit: hasCanonicalPricing ? numberField2(canonicalPricing, "creditsPerUnit", "credits_per_unit") : numberField2(
-      tool,
-      "deeplineCreditsPerPricingUnit",
-      "deepline_credits_per_pricing_unit"
-    ),
-    deeplineUsdPerPricingUnit: hasCanonicalPricing ? numberField2(canonicalPricing, "usdPerUnit", "usd_per_unit") : numberField2(
-      tool,
-      "deeplineUsdPerPricingUnit",
-      "deepline_usd_per_pricing_unit"
-    )
-  };
-}
 function extractionContractEntries(entries) {
   return entries.flatMap((entry) => {
     if (!isRecord12(entry)) return [];
@@ -40869,6 +41155,7 @@ function toolMetadataJsonForDescribe(tool, requestedToolId) {
     toolId,
     provider: tool.provider,
     displayName: tool.displayName,
+    cost: Capability.fromCatalogEntry(tool).describe().customerCost(),
     usageGuidance,
     runtimeOutputHelp: {
       contract: "tools describe shows declared schema and Deepline getters; it is not an observed provider response.",
@@ -41199,11 +41486,11 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = resolve17(trimmed);
-  if (existsSync17(resolved)) return resolved;
+  const resolved = resolve18(trimmed);
+  if (existsSync18(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = resolve17(trimmed.replace(/\\/g, "/"));
-    if (existsSync17(normalized)) return normalized;
+    const normalized = resolve18(trimmed.replace(/\\/g, "/"));
+    if (existsSync18(normalized)) return normalized;
   }
   return resolved;
 }
@@ -41214,7 +41501,7 @@ function readJsonArgument(raw, flagName) {
     throw new Error(`Invalid ${flagName} value: empty @file path.`);
   }
   try {
-    return readFileSync17(resolveAtFilePath(filePath), "utf8").replace(
+    return readFileSync18(resolveAtFilePath(filePath), "utf8").replace(
       /^\uFEFF/,
       ""
     );
@@ -41291,7 +41578,7 @@ function parseExecuteOptions(args) {
       continue;
     }
     if ((arg === "--out" || arg === "-o") && args[index + 1]) {
-      outPath = resolve17(args[++index]);
+      outPath = resolve18(args[++index]);
       continue;
     }
     throw new Error(`Unknown option: ${arg}`);
@@ -41321,9 +41608,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = mkdtempSync(join20(tmpdir5(), "deepline-workflow-seed-"));
+  const scriptDir = mkdtempSync(join21(tmpdir5(), "deepline-workflow-seed-"));
   chmodSync(scriptDir, 448);
-  const scriptPath = join20(scriptDir, fileName);
+  const scriptPath = join21(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(/\]$/, "")}, ...]` : "[]";
@@ -41792,7 +42079,7 @@ Examples:
 
 // src/cli/commands/workflow.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname19, join as join21, resolve as resolve18 } from "path";
+import { dirname as dirname20, join as join22, resolve as resolve19 } from "path";
 
 // src/cli/workflow-to-play.ts
 import { createHash as createHash5 } from "crypto";
@@ -42009,7 +42296,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await readFile4(resolve18(file), "utf8");
+    const raw = await readFile4(resolve19(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -42043,8 +42330,8 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = join21(resolve18(outDir), `${compiled.playName}.play.ts`);
-    await mkdir5(dirname19(file), { recursive: true });
+    const file = join22(resolve19(outDir), `${compiled.playName}.play.ts`);
+    await mkdir5(dirname20(file), { recursive: true });
     await writeFile5(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
@@ -42419,7 +42706,7 @@ function isDowngradeAutoUpdateResponse(response) {
   return compareSemver(target, current) < 0;
 }
 function relaunchCurrentCommand(plan) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     const command = plan.kind === "python-sidecar" ? plan.sidecarPath : process.execPath;
     const args = plan.kind === "python-sidecar" ? process.argv.slice(2) : process.argv.slice(1);
     const child = spawn5(command, args, {
@@ -42435,9 +42722,9 @@ function relaunchCurrentCommand(plan) {
         `Deepline SDK/CLI updated, but relaunch failed: ${error.message}
 `
       );
-      resolve19(1);
+      resolve20(1);
     });
-    child.on("close", (code) => resolve19(code ?? 1));
+    child.on("close", (code) => resolve20(code ?? 1));
   });
 }
 async function maybeAutoUpdateAndRelaunch(response, baseUrl) {
@@ -42828,8 +43115,8 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await mkdtemp2(join22(tmpdir6(), "deepline-health-play-"));
-  const file = join22(dir, "health-check.play.ts");
+  const dir = await mkdtemp2(join23(tmpdir6(), "deepline-health-play-"));
+  const file = join23(dir, "health-check.play.ts");
   try {
     await writeFile6(
       file,