deepline 0.3.293 → 0.3.295

package/dist/cli/chunk-XRK2TZT5.js

@@ -0,0 +1,1995 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkXNYIZMNQjs = require('./chunk-XNYIZMNQ.js');
+
+
+var _chunkD4AZUZO4js = require('./chunk-D4AZUZO4.js');
+
+
+
+
+
+
+
+
+
+var _chunk7P5AA3SNjs = require('./chunk-7P5AA3SN.js');
+
+// src/errors.ts
+var AuthError = class extends _chunk7P5AA3SNjs.DeeplineError {
+  /** Constructed by the SDK when Deepline rejects the caller's credentials. */
+  constructor(message = "Authentication failed. Check your DEEPLINE_API_KEY.") {
+    super(message, 401, "AUTH_ERROR");
+    this.name = "AuthError";
+  }
+};
+var RateLimitError = class extends _chunk7P5AA3SNjs.DeeplineError {
+  /** Milliseconds to wait before retrying, from the `Retry-After` response header. Defaults to 5000. */
+  
+  /** Constructed by the SDK after exhausting HTTP-level rate-limit retries. */
+  constructor(retryAfterMs = 5e3, message) {
+    super(
+      _nullishCoalesce(message, () => ( `Rate limited. Retry after ${retryAfterMs}ms.`)),
+      429,
+      "RATE_LIMIT"
+    );
+    this.name = "RateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var ToolRateLimitError = class extends RateLimitError {
+  /** Public tool id passed to `tools.execute`. */
+  
+  /** Provider responsible for the operation, or `null`. */
+  
+  /** Provider operation name, or `null`. */
+  
+  /** Stable machine-readable failure code when one exists. */
+  
+  /** Boundary responsible for the failure. */
+  
+  /** Stable reason family for policy and diagnostics. */
+  
+  /** Whether repeating the same semantic call is delivery-safe. */
+  
+  /** Provider or Deepline request id, or `null`. */
+  
+  /** Network failure kind, or `null` for non-network failures. */
+  
+  /** Network boundary that failed, or `null` for non-network failures. */
+  
+  /** Explicitly allowlisted diagnostics safe for SDK callers. */
+  
+  /** Constructed by the SDK after a structured tool HTTP 429. */
+  constructor(message, options) {
+    super(_nullishCoalesce(options.retryAfterMs, () => ( 5e3)), message);
+    this.name = "ToolRateLimitError";
+    this.statusCode = _nullishCoalesce(options.statusCode, () => ( 429));
+    this.code = _nullishCoalesce(options.code, () => ( void 0));
+    this.toolId = options.toolId;
+    this.provider = options.provider;
+    this.operation = options.operation;
+    this.origin = options.origin;
+    this.category = options.category;
+    this.retryable = options.retryable;
+    this.requestId = options.requestId;
+    this.networkKind = options.networkKind;
+    this.networkScope = options.networkScope;
+    this.publicDetails = _nullishCoalesce(options.publicDetails, () => ( null));
+    this.details = options.details;
+    _chunk7P5AA3SNjs.brandAsToolExecutionError.call(void 0, this);
+    if (_chunk7P5AA3SNjs.isProviderTransientFailure.call(void 0, this)) {
+      _chunk7P5AA3SNjs.brandAsProviderTransientError.call(void 0, this);
+    }
+  }
+};
+var ConfigError = class extends _chunk7P5AA3SNjs.DeeplineError {
+  /** Construct a local SDK configuration failure. */
+  constructor(message) {
+    super(message, void 0, "CONFIG_ERROR");
+    this.name = "ConfigError";
+  }
+};
+
+// src/config.ts
+
+
+
+
+
+
+
+
+var _fs = require('fs');
+var _os = require('os');
+var _path = require('path');
+var HOST_URL_ENV = "DEEPLINE_HOST_URL";
+var API_KEY_ENV = "DEEPLINE_API_KEY";
+var ACTIVE_ORG_ID_ENV = "DEEPLINE_ACTIVE_ORG_ID";
+var ACTIVE_ORG_NAME_ENV = "DEEPLINE_ACTIVE_ORG_NAME";
+var FEATURES_ENV = "DEEPLINE_FEATURES";
+var PROD_URL = "https://code.deepline.com";
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_MAX_RETRIES = 3;
+var PROJECT_DEEPLINE_ENV_FILE = ".env.deepline";
+var COWORK_IGNORED_WORKSPACE_DIRS = /* @__PURE__ */ new Set([
+  ".auto-memory",
+  ".claude",
+  ".remote-plugins",
+  "outputs",
+  "plugins",
+  "uploads"
+]);
+var COWORK_PROJECT_MARKERS = [
+  ".deepline",
+  ".env.deepline",
+  ".git",
+  "AGENTS.md",
+  "package.json",
+  "pyproject.toml"
+];
+var CLI_ENV_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  HOST_URL_ENV,
+  API_KEY_ENV,
+  ACTIVE_ORG_ID_ENV,
+  ACTIVE_ORG_NAME_ENV,
+  FEATURES_ENV
+]);
+function featureEnvValues(data) {
+  if (!Array.isArray(data.features)) return {};
+  return {
+    [FEATURES_ENV]: data.features.filter(
+      (key) => typeof key === "string" && key.trim() !== ""
+    ).map((key) => key.trim()).join(",")
+  };
+}
+function storedHostApiKey(baseUrl) {
+  return _nullishCoalesce(loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[API_KEY_ENV], () => ( ""));
+}
+function storedHostFeatures(baseUrl) {
+  return loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[FEATURES_ENV];
+}
+function baseUrlSlug(baseUrl) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch (e) {
+    return "unknown";
+  }
+  const host = url.hostname || "unknown";
+  const port = url.port ? Number.parseInt(url.port, 10) : null;
+  let slug = host.replace(/[^a-zA-Z0-9]/g, "-");
+  if (port && port !== 80 && port !== 443) {
+    slug = `${slug}-${port}`;
+  }
+  return slug.toLowerCase().replace(/^-+|-+$/g, "");
+}
+function parseEnvFile(filePath) {
+  if (!_fs.existsSync.call(void 0, filePath)) return {};
+  const env = {};
+  const content = _fs.readFileSync.call(void 0, filePath, "utf-8");
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex < 0) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+      try {
+        value = JSON.parse(value);
+      } catch (e2) {
+        value = value.slice(1, -1);
+      }
+    } else if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key && value) {
+      env[key] = value;
+    }
+  }
+  return env;
+}
+function findNearestEnvFile(name, startDir = process.cwd()) {
+  let current = _path.resolve.call(void 0, startDir);
+  while (true) {
+    const filePath = _path.join.call(void 0, current, name);
+    if (_fs.existsSync.call(void 0, filePath)) return filePath;
+    const parent = _path.dirname.call(void 0, current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function isDirectory(path) {
+  try {
+    return _fs.statSync.call(void 0, path).isDirectory();
+  } catch (e3) {
+    return false;
+  }
+}
+function canonicalPath(path) {
+  try {
+    return _fs.realpathSync.call(void 0, path);
+  } catch (e4) {
+    return _path.resolve.call(void 0, path);
+  }
+}
+function isTruthy(value) {
+  return /^(1|true|yes|on)$/i.test(_nullishCoalesce(_optionalChain([value, 'optionalAccess', _ => _.trim, 'call', _2 => _2()]), () => ( "")));
+}
+function sessionRootFromPath(path) {
+  const trimmed = _optionalChain([path, 'optionalAccess', _3 => _3.trim, 'call', _4 => _4()]);
+  if (!trimmed) return null;
+  const match = /^\/sessions\/[^/]+(?=\/|$)/.exec(trimmed);
+  return _nullishCoalesce(_optionalChain([match, 'optionalAccess', _5 => _5[0]]), () => ( null));
+}
+function coworkSessionRoot() {
+  const home = _optionalChain([process, 'access', _6 => _6.env, 'access', _7 => _7.HOME, 'optionalAccess', _8 => _8.trim, 'call', _9 => _9()]);
+  const homeSessionRoot = sessionRootFromPath(home);
+  if (homeSessionRoot && isDirectory(_path.join.call(void 0, homeSessionRoot, "mnt"))) {
+    return homeSessionRoot;
+  }
+  const cwdSessionRoot = sessionRootFromPath(process.cwd());
+  if (cwdSessionRoot && isDirectory(_path.join.call(void 0, cwdSessionRoot, "mnt"))) {
+    return cwdSessionRoot;
+  }
+  if (isTruthy(process.env.CLAUDE_CODE_REMOTE) && home) {
+    const mountedRoot = _path.join.call(void 0, home, "mnt");
+    if (isDirectory(mountedRoot)) return _path.resolve.call(void 0, home);
+  }
+  return null;
+}
+function isCoworkLikeSandbox() {
+  const home = _optionalChain([process, 'access', _10 => _10.env, 'access', _11 => _11.HOME, 'optionalAccess', _12 => _12.trim, 'call', _13 => _13()]);
+  return isTruthy(process.env.CLAUDE_CODE_REMOTE) || sessionRootFromPath(home) !== null || sessionRootFromPath(process.cwd()) !== null;
+}
+function coworkProjectScore(path) {
+  let score = 0;
+  for (const marker of COWORK_PROJECT_MARKERS) {
+    if (_fs.existsSync.call(void 0, _path.join.call(void 0, path, marker))) score += 1;
+  }
+  return score;
+}
+function listCoworkWorkspaceDirCandidates() {
+  if (!isCoworkLikeSandbox()) {
+    return [];
+  }
+  const explicitProjectDir = _optionalChain([process, 'access', _14 => _14.env, 'access', _15 => _15.CLAUDE_PROJECT_DIR, 'optionalAccess', _16 => _16.trim, 'call', _17 => _17()]);
+  if (explicitProjectDir && isDirectory(explicitProjectDir)) {
+    return [_path.resolve.call(void 0, explicitProjectDir)];
+  }
+  const sessionRoot = coworkSessionRoot();
+  if (!sessionRoot) return [];
+  const mountedRoot = _path.join.call(void 0, sessionRoot, "mnt");
+  if (!isDirectory(mountedRoot)) return [];
+  let names;
+  try {
+    names = _fs.readdirSync.call(void 0, mountedRoot).sort();
+  } catch (e5) {
+    return [];
+  }
+  const candidates = [];
+  for (const name of names) {
+    if (name.startsWith(".") || COWORK_IGNORED_WORKSPACE_DIRS.has(name)) {
+      continue;
+    }
+    const candidate = _path.join.call(void 0, mountedRoot, name);
+    if (isDirectory(candidate)) candidates.push(candidate);
+  }
+  if (candidates.length <= 1) return candidates;
+  const projectLike = candidates.filter(
+    (candidate) => coworkProjectScore(candidate) > 0
+  );
+  return projectLike.length > 0 ? projectLike : candidates;
+}
+function isInIgnoredCoworkMount(path) {
+  const sessionRoot = coworkSessionRoot();
+  if (!sessionRoot) return false;
+  const mountedRoot = canonicalPath(_path.join.call(void 0, sessionRoot, "mnt"));
+  const resolvedPath = canonicalPath(path);
+  const prefix = `${mountedRoot}/`;
+  if (!resolvedPath.startsWith(prefix)) return false;
+  const relativePath = resolvedPath.slice(prefix.length);
+  const mountName = relativePath.split("/")[0];
+  return mountName.startsWith(".") || COWORK_IGNORED_WORKSPACE_DIRS.has(mountName);
+}
+function detectCoworkWorkspaceDir() {
+  const candidates = listCoworkWorkspaceDirCandidates();
+  return candidates.length === 1 ? candidates[0] : null;
+}
+function loadProjectEnvCandidates(startDir = process.cwd()) {
+  const filePaths = [];
+  const sources = /* @__PURE__ */ new Map();
+  const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
+  if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
+    filePaths.push(nearestFile);
+    sources.set(_path.resolve.call(void 0, nearestFile), "nearest");
+  }
+  const coworkWorkspaceDir = detectCoworkWorkspaceDir();
+  if (coworkWorkspaceDir) {
+    const coworkFile = _path.join.call(void 0, coworkWorkspaceDir, PROJECT_DEEPLINE_ENV_FILE);
+    if (_fs.existsSync.call(void 0, coworkFile) && !filePaths.some((filePath) => _path.resolve.call(void 0, filePath) === _path.resolve.call(void 0, coworkFile))) {
+      filePaths.push(coworkFile);
+      sources.set(_path.resolve.call(void 0, coworkFile), "cowork");
+    }
+  }
+  return filePaths.map((filePath) => ({
+    filePath,
+    env: parseEnvFile(filePath),
+    source: _nullishCoalesce(sources.get(_path.resolve.call(void 0, filePath)), () => ( "nearest"))
+  }));
+}
+function normalizeBaseUrl(baseUrl) {
+  const trimmed = _nullishCoalesce(_optionalChain([baseUrl, 'optionalAccess', _18 => _18.trim, 'call', _19 => _19(), 'access', _20 => _20.replace, 'call', _21 => _21(/\/+$/, "")]), () => ( ""));
+  if (!trimmed) return "";
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return "";
+    }
+    return parsed.toString().replace(/\/+$/, "");
+  } catch (e6) {
+    return "";
+  }
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = _optionalChain([value, 'optionalAccess', _22 => _22.trim, 'call', _23 => _23()]);
+    if (trimmed) return trimmed;
+  }
+  return "";
+}
+function formatEnvFileValue(value) {
+  return /^[a-zA-Z0-9_./:@%+=,-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function mergePersistedEnvValues(existing, values) {
+  const merged = { ...existing, ...values };
+  const nextApiKey = values[API_KEY_ENV];
+  if (nextApiKey !== void 0 && nextApiKey !== existing[API_KEY_ENV] && values[ACTIVE_ORG_ID_ENV] === void 0) {
+    delete merged[ACTIVE_ORG_ID_ENV];
+    delete merged[ACTIVE_ORG_NAME_ENV];
+    delete merged[FEATURES_ENV];
+  }
+  if (values[FEATURES_ENV] === "") {
+    delete merged[FEATURES_ENV];
+  }
+  return merged;
+}
+function persistedEnvLines(values) {
+  return Object.entries(values).filter(
+    ([key, value]) => CLI_ENV_ALLOWED_KEYS.has(key) && value.trim() !== ""
+  ).map(([key, value]) => `${key}=${formatEnvFileValue(value)}`);
+}
+function sdkCliConfigDir(baseUrl) {
+  const home = _optionalChain([process, 'access', _24 => _24.env, 'access', _25 => _25.HOME, 'optionalAccess', _26 => _26.trim, 'call', _27 => _27()]) || _os.homedir.call(void 0, );
+  return _path.join.call(void 0, home, ".local", "deepline", baseUrlSlug(baseUrl || PROD_URL));
+}
+function sdkCliStateDirPath(baseUrl, homeDir = _optionalChain([process, 'access', _28 => _28.env, 'access', _29 => _29.HOME, 'optionalAccess', _30 => _30.trim, 'call', _31 => _31()]) || _os.homedir.call(void 0, )) {
+  return _path.join.call(void 0, 
+    homeDir,
+    ".local",
+    "deepline",
+    baseUrlSlug(baseUrl || PROD_URL),
+    "sdk-cli"
+  );
+}
+function sdkCliEnvFilePath(baseUrl) {
+  return _path.join.call(void 0, sdkCliConfigDir(baseUrl), ".env");
+}
+function loadCliEnv(baseUrl = PROD_URL) {
+  return parseEnvFile(sdkCliEnvFilePath(baseUrl));
+}
+function hostConfigDirPath(baseUrl) {
+  return sdkCliConfigDir(baseUrl);
+}
+function hostEnvFilePath(baseUrl) {
+  return sdkCliEnvFilePath(baseUrl);
+}
+function saveHostEnvValues(baseUrl, values) {
+  const filePath = sdkCliEnvFilePath(baseUrl);
+  const dir = _path.dirname.call(void 0, filePath);
+  if (!_fs.existsSync.call(void 0, dir)) {
+    _fs.mkdirSync.call(void 0, dir, { recursive: true });
+  }
+  const existing = parseEnvFile(filePath);
+  const merged = mergePersistedEnvValues(existing, values);
+  const lines = persistedEnvLines(merged);
+  _fs.writeFileSync.call(void 0, filePath, `${lines.join("\n")}
+`, "utf-8");
+}
+function loadGlobalCliEnv() {
+  return loadCliEnv(PROD_URL);
+}
+function autoDetectBaseUrl() {
+  const projectEnvs = loadProjectEnvCandidates();
+  const globalEnv = loadGlobalCliEnv();
+  return normalizeBaseUrl(_nullishCoalesce(process.env[HOST_URL_ENV], () => ( ""))) || firstNonEmpty(
+    ...projectEnvs.map(({ env }) => normalizeBaseUrl(env[HOST_URL_ENV]))
+  ) || normalizeBaseUrl(_nullishCoalesce(globalEnv[HOST_URL_ENV], () => ( ""))) || PROD_URL;
+}
+function resolveApiKeyForBaseUrl(baseUrl, explicitApiKey) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const projectEnvs = loadProjectEnvCandidates();
+  const cliEnv = loadCliEnv(normalizedBaseUrl || baseUrl);
+  return firstNonEmpty(
+    explicitApiKey,
+    process.env[API_KEY_ENV],
+    ...projectEnvs.map(({ env }) => {
+      const projectBaseUrl = normalizeBaseUrl(_nullishCoalesce(env[HOST_URL_ENV], () => ( "")));
+      return projectBaseUrl === normalizedBaseUrl ? env[API_KEY_ENV] : "";
+    }),
+    cliEnv[API_KEY_ENV]
+  );
+}
+function resolveProjectApiKeyForBaseUrl(baseUrl, startDir = process.cwd()) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  return firstNonEmpty(
+    ...loadProjectEnvCandidates(startDir).map(({ env }) => {
+      const projectBaseUrl = normalizeBaseUrl(_nullishCoalesce(env[HOST_URL_ENV], () => ( "")));
+      return projectBaseUrl === normalizedBaseUrl ? env[API_KEY_ENV] : "";
+    })
+  );
+}
+function resolveGlobalApiKeyForBaseUrl(baseUrl) {
+  return firstNonEmpty(
+    process.env[API_KEY_ENV],
+    loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[API_KEY_ENV]
+  );
+}
+function getResolvedProjectAuthSource(baseUrl, apiKey, startDir = process.cwd()) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const normalizedApiKey = apiKey.trim();
+  if (!normalizedBaseUrl || !normalizedApiKey) return null;
+  return _nullishCoalesce(loadProjectEnvCandidates(startDir).find(({ env }) => {
+    const projectBaseUrl = normalizeBaseUrl(_nullishCoalesce(env[HOST_URL_ENV], () => ( "")));
+    return projectBaseUrl === normalizedBaseUrl && (_nullishCoalesce(env[API_KEY_ENV], () => ( ""))).trim() === normalizedApiKey;
+  }), () => ( null));
+}
+function resolveBaseUrlOnly(options) {
+  const baseUrl = normalizeBaseUrl(
+    _optionalChain([options, 'optionalAccess', _32 => _32.baseUrl, 'optionalAccess', _33 => _33.trim, 'call', _34 => _34()]) || autoDetectBaseUrl()
+  );
+  if (!baseUrl) {
+    throw new ConfigError(
+      `Invalid ${HOST_URL_ENV}. Expected an http(s) URL such as https://code.deepline.com.`
+    );
+  }
+  return baseUrl;
+}
+function resolveConfig(options) {
+  const baseUrl = normalizeBaseUrl(
+    _optionalChain([options, 'optionalAccess', _35 => _35.baseUrl, 'optionalAccess', _36 => _36.trim, 'call', _37 => _37()]) || autoDetectBaseUrl()
+  );
+  if (!baseUrl) {
+    throw new ConfigError(
+      `Invalid ${HOST_URL_ENV}. Expected an http(s) URL such as https://code.deepline.com.`
+    );
+  }
+  const apiKey = resolveApiKeyForBaseUrl(baseUrl, _optionalChain([options, 'optionalAccess', _38 => _38.apiKey]));
+  if (!apiKey) {
+    throw new ConfigError(
+      `No API key found. Set ${API_KEY_ENV}, add it to .env.deepline, or run: deepline auth register`
+    );
+  }
+  return {
+    apiKey,
+    baseUrl,
+    timeout: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _39 => _39.timeout]), () => ( DEFAULT_TIMEOUT)),
+    maxRetries: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _40 => _40.maxRetries]), () => ( DEFAULT_MAX_RETRIES)),
+    // Pass through untouched: the transport owns case-insensitive merging so
+    // there is exactly one place that decides which header wins.
+    ..._optionalChain([options, 'optionalAccess', _41 => _41.headers]) ? { headers: { ...options.headers } } : {}
+  };
+}
+function mergeProjectEnvFile(filePath, values) {
+  const existing = parseEnvFile(filePath);
+  const merged = mergePersistedEnvValues(existing, values);
+  const dir = _path.dirname.call(void 0, filePath);
+  if (!_fs.existsSync.call(void 0, dir)) _fs.mkdirSync.call(void 0, dir, { recursive: true });
+  ensureProjectEnvIsIgnored(dir);
+  const lines = persistedEnvLines(merged);
+  _fs.writeFileSync.call(void 0, filePath, `${lines.join("\n")}
+`, "utf-8");
+}
+function ensureProjectEnvIsIgnored(dir) {
+  ensureProjectPrivatePathsIgnored(dir, [
+    PROJECT_DEEPLINE_ENV_FILE,
+    ".deepline/"
+  ]);
+}
+function ensureProjectPrivatePathsIgnored(dir, entries) {
+  const gitDir = findNearestGitCommonDir(dir);
+  if (gitDir) {
+    const excludePath = _path.join.call(void 0, gitDir, "info", "exclude");
+    const existing2 = _fs.existsSync.call(void 0, excludePath) ? _fs.readFileSync.call(void 0, excludePath, "utf-8") : "";
+    const existingEntries2 = new Set(
+      existing2.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+    );
+    const missing2 = entries.filter(
+      (entry) => !existingEntries2.has(entry) && !existingEntries2.has(`/${entry}`)
+    );
+    if (missing2.length === 0) return;
+    _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, excludePath), { recursive: true });
+    const prefix2 = existing2 && !existing2.endsWith("\n") ? "\n" : "";
+    _fs.writeFileSync.call(void 0, 
+      excludePath,
+      `${existing2}${prefix2}${missing2.join("\n")}
+`,
+      "utf-8"
+    );
+    return;
+  }
+  const gitignorePath = _path.join.call(void 0, dir, ".gitignore");
+  const existing = _fs.existsSync.call(void 0, gitignorePath) ? _fs.readFileSync.call(void 0, gitignorePath, "utf-8") : "";
+  const existingEntries = new Set(
+    existing.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  );
+  const missing = entries.filter(
+    (entry) => !existingEntries.has(entry) && !existingEntries.has(`/${entry}`)
+  );
+  if (missing.length === 0) return;
+  const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+  _fs.writeFileSync.call(void 0, 
+    gitignorePath,
+    `${existing}${prefix}${missing.join("\n")}
+`,
+    "utf-8"
+  );
+}
+function findNearestGitCommonDir(startDir) {
+  let current = _path.resolve.call(void 0, startDir);
+  while (true) {
+    const candidate = _path.join.call(void 0, current, ".git");
+    if (_fs.existsSync.call(void 0, candidate)) {
+      try {
+        const stat = _fs.statSync.call(void 0, candidate);
+        if (stat.isDirectory()) return candidate;
+        if (stat.isFile()) {
+          const match = _fs.readFileSync.call(void 0, candidate, "utf8").match(
+            /^gitdir:\s*(.+)$/m
+          );
+          const rawGitDir = _optionalChain([match, 'optionalAccess', _42 => _42[1], 'optionalAccess', _43 => _43.trim, 'call', _44 => _44()]);
+          if (rawGitDir) {
+            const gitDir = _path.isAbsolute.call(void 0, rawGitDir) ? rawGitDir : _path.resolve.call(void 0, _path.dirname.call(void 0, candidate), rawGitDir);
+            const commonDirPath = _path.join.call(void 0, gitDir, "commondir");
+            if (!_fs.existsSync.call(void 0, commonDirPath)) return gitDir;
+            const rawCommonDir = _fs.readFileSync.call(void 0, commonDirPath, "utf8").trim();
+            return rawCommonDir ? _path.isAbsolute.call(void 0, rawCommonDir) ? rawCommonDir : _path.resolve.call(void 0, gitDir, rawCommonDir) : gitDir;
+          }
+        }
+      } catch (e7) {
+        return null;
+      }
+    }
+    const parent = _path.dirname.call(void 0, current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function saveProjectDeeplineEnvValues(values, startDir = process.cwd()) {
+  const target = resolveProjectPinTarget(startDir);
+  if (!target.ok) {
+    throw new ConfigError(
+      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
+        ", "
+      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder before running this command.`
+    );
+  }
+  const filePath = _path.join.call(void 0, target.dir, PROJECT_DEEPLINE_ENV_FILE);
+  mergeProjectEnvFile(filePath, values);
+  return [filePath];
+}
+function resolveProjectPinTarget(startDir = process.cwd()) {
+  const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
+  if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
+    return { ok: true, dir: _path.dirname.call(void 0, nearestFile), source: "nearest" };
+  }
+  const coworkCandidates = listCoworkWorkspaceDirCandidates();
+  if (coworkCandidates.length === 1) {
+    return { ok: true, dir: coworkCandidates[0], source: "cowork" };
+  }
+  if (coworkCandidates.length > 1) {
+    const resolvedStartDir = canonicalPath(startDir);
+    const cwdCandidate = coworkCandidates.find((candidate) => {
+      const resolvedCandidate = canonicalPath(candidate);
+      return resolvedStartDir === resolvedCandidate || resolvedStartDir.startsWith(`${resolvedCandidate}/`);
+    });
+    if (cwdCandidate) {
+      return { ok: true, dir: cwdCandidate, source: "cowork" };
+    }
+    return {
+      ok: false,
+      reason: "ambiguous_cowork_project",
+      candidates: coworkCandidates
+    };
+  }
+  return { ok: true, dir: _path.resolve.call(void 0, startDir), source: "cwd" };
+}
+function getActiveProjectAuthSource(startDir = process.cwd()) {
+  return _nullishCoalesce(loadProjectEnvCandidates(startDir)[0], () => ( null));
+}
+function findNearestProjectMarkerDir(startDir) {
+  let current = _path.resolve.call(void 0, startDir);
+  while (true) {
+    if (COWORK_PROJECT_MARKERS.some((marker) => _fs.existsSync.call(void 0, _path.join.call(void 0, current, marker)))) {
+      return current;
+    }
+    const parent = _path.dirname.call(void 0, current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function resolveCliAuthProvenance(config, startDir = process.cwd()) {
+  const envApiKey = _optionalChain([process, 'access', _45 => _45.env, 'access', _46 => _46[API_KEY_ENV], 'optionalAccess', _47 => _47.trim, 'call', _48 => _48()]);
+  const folderAuth = getResolvedProjectAuthSource(
+    config.baseUrl,
+    config.apiKey,
+    startDir
+  );
+  const pinTarget = resolveProjectPinTarget(startDir);
+  const markerDir = findNearestProjectMarkerDir(startDir);
+  const project = !pinTarget.ok ? {
+    state: "ambiguous_cowork_project",
+    candidates: pinTarget.candidates
+  } : folderAuth ? {
+    state: "project",
+    dir: _path.dirname.call(void 0, folderAuth.filePath),
+    pinPath: folderAuth.filePath,
+    source: "folder"
+  } : pinTarget.source === "cowork" ? {
+    state: "project",
+    dir: pinTarget.dir,
+    pinPath: _path.join.call(void 0, pinTarget.dir, PROJECT_DEEPLINE_ENV_FILE),
+    source: "cowork"
+  } : markerDir ? {
+    state: "project",
+    dir: markerDir,
+    pinPath: _path.join.call(void 0, markerDir, PROJECT_DEEPLINE_ENV_FILE),
+    source: "marker"
+  } : { state: "not_project" };
+  return {
+    scope: envApiKey ? "env" : folderAuth ? "folder" : "global",
+    project,
+    folderAuthPath: _nullishCoalesce(_optionalChain([folderAuth, 'optionalAccess', _49 => _49.filePath]), () => ( null))
+  };
+}
+function activeOrganizationFromEnv(env) {
+  const orgId = _optionalChain([env, 'access', _50 => _50[ACTIVE_ORG_ID_ENV], 'optionalAccess', _51 => _51.trim, 'call', _52 => _52()]);
+  if (!orgId) return null;
+  const orgName = _optionalChain([env, 'access', _53 => _53[ACTIVE_ORG_NAME_ENV], 'optionalAccess', _54 => _54.trim, 'call', _55 => _55()]) || null;
+  return { org_id: orgId, org_name: orgName };
+}
+function resolveCliCommandContext(inputConfig, requestedScope) {
+  let config = inputConfig;
+  if (!config) {
+    try {
+      config = resolveConfig();
+    } catch (e8) {
+      return {
+        active_organization: null,
+        auth_scope: null,
+        metadata_source: null
+      };
+    }
+  }
+  const contextForScope = (scope) => {
+    if (scope === "env") {
+      const processApiKey = _optionalChain([process, 'access', _56 => _56.env, 'access', _57 => _57[API_KEY_ENV], 'optionalAccess', _58 => _58.trim, 'call', _59 => _59()]);
+      return processApiKey && processApiKey === config.apiKey ? {
+        active_organization: activeOrganizationFromEnv(process.env),
+        auth_scope: "env",
+        metadata_source: "process_env"
+      } : null;
+    }
+    if (scope === "folder") {
+      const projectAuth = getResolvedProjectAuthSource(
+        config.baseUrl,
+        config.apiKey
+      );
+      return projectAuth ? {
+        active_organization: activeOrganizationFromEnv(projectAuth.env),
+        auth_scope: "folder",
+        metadata_source: "folder_env"
+      } : null;
+    }
+    const hostEnv = loadCliEnv(config.baseUrl);
+    return (_nullishCoalesce(hostEnv[API_KEY_ENV], () => ( ""))).trim() === config.apiKey ? {
+      active_organization: activeOrganizationFromEnv(hostEnv),
+      auth_scope: "global",
+      metadata_source: "host_env"
+    } : null;
+  };
+  const processContext = contextForScope("env");
+  if (processContext) return processContext;
+  if (requestedScope) {
+    return _nullishCoalesce(contextForScope(requestedScope), () => ( {
+      active_organization: null,
+      auth_scope: requestedScope,
+      metadata_source: null
+    }));
+  }
+  for (const scope of ["folder", "global"]) {
+    const context = contextForScope(scope);
+    if (context) return context;
+  }
+  return {
+    active_organization: null,
+    auth_scope: null,
+    metadata_source: null
+  };
+}
+
+// src/version.ts
+var SDK_VERSION = _chunkD4AZUZO4js.SDK_RELEASE.version;
+var SDK_API_MAJOR = _chunkD4AZUZO4js.SDK_RELEASE.contracts.api.currentMajor;
+var SDK_API_CONTRACT = _nullishCoalesce(_chunkD4AZUZO4js.SDK_RELEASE.contracts.api.legacyWireIds[0], () => ( `api-v${SDK_API_MAJOR}`));
+
+// src/agent-runtime.ts
+
+var EXPLICIT_AGENT_RUNTIMES = /* @__PURE__ */ new Set([
+  "claude_code",
+  "claude_cowork",
+  "codex",
+  "cline",
+  "cursor",
+  "gemini",
+  "antigravity",
+  "windsurf",
+  "unknown"
+]);
+function truthyEnv(name) {
+  return ["1", "true", "yes", "on"].includes(
+    String(_nullishCoalesce(process.env[name], () => ( ""))).trim().toLowerCase()
+  );
+}
+function normalizeAgentRuntime(value) {
+  const explicit = _optionalChain([value, 'optionalAccess', _60 => _60.trim, 'call', _61 => _61(), 'access', _62 => _62.toLowerCase, 'call', _63 => _63(), 'access', _64 => _64.replace, 'call', _65 => _65(/-/g, "_")]);
+  if (!explicit) return null;
+  if (explicit === "gemini_cli") return "gemini";
+  return EXPLICIT_AGENT_RUNTIMES.has(explicit) ? explicit : null;
+}
+function isCoworkLikeSandbox2() {
+  const pluginMode = truthyEnv("DEEPLINE_PLUGIN_MODE");
+  const claudeRemote = truthyEnv("CLAUDE_CODE_REMOTE");
+  const projectDir = Boolean(_optionalChain([process, 'access', _66 => _66.env, 'access', _67 => _67.CLAUDE_PROJECT_DIR, 'optionalAccess', _68 => _68.trim, 'call', _69 => _69()]));
+  const pluginRoot = Boolean(_optionalChain([process, 'access', _70 => _70.env, 'access', _71 => _71.DEEPLINE_PLUGIN_ROOT, 'optionalAccess', _72 => _72.trim, 'call', _73 => _73()]));
+  const home = _optionalChain([process, 'access', _74 => _74.env, 'access', _75 => _75.HOME, 'optionalAccess', _76 => _76.trim, 'call', _77 => _77()]) || _os.homedir.call(void 0, );
+  const sessionHome = home === "/sessions" || home.startsWith("/sessions/");
+  return claudeRemote || sessionHome || (pluginMode || pluginRoot) && projectDir;
+}
+function detectAgentRuntime(options = {}) {
+  const explicit = normalizeAgentRuntime(process.env.DEEPLINE_AGENT_RUNTIME);
+  if (explicit) return explicit;
+  if (_optionalChain([process, 'access', _78 => _78.env, 'access', _79 => _79.CODEX_THREAD_ID, 'optionalAccess', _80 => _80.trim, 'call', _81 => _81()])) return "codex";
+  if (options.detectCowork !== false && isCoworkLikeSandbox2()) {
+    return "claude_cowork";
+  }
+  if (_optionalChain([process, 'access', _82 => _82.env, 'access', _83 => _83.CLAUDECODE, 'optionalAccess', _84 => _84.trim, 'call', _85 => _85()]) === "1") return "claude_code";
+  if (_optionalChain([process, 'access', _86 => _86.env, 'access', _87 => _87.CLINE_ACTIVE, 'optionalAccess', _88 => _88.trim, 'call', _89 => _89(), 'access', _90 => _90.toLowerCase, 'call', _91 => _91()]) === "true") return "cline";
+  if (_optionalChain([process, 'access', _92 => _92.env, 'access', _93 => _93.CURSOR_TRACE_ID, 'optionalAccess', _94 => _94.trim, 'call', _95 => _95()]) || _optionalChain([process, 'access', _96 => _96.env, 'access', _97 => _97.CURSOR_AGENT, 'optionalAccess', _98 => _98.trim, 'call', _99 => _99()])) {
+    return "cursor";
+  }
+  if (_optionalChain([process, 'access', _100 => _100.env, 'access', _101 => _101.WINDSURF, 'optionalAccess', _102 => _102.trim, 'call', _103 => _103()]) || _optionalChain([process, 'access', _104 => _104.env, 'access', _105 => _105.CASCADE, 'optionalAccess', _106 => _106.trim, 'call', _107 => _107()])) {
+    return "windsurf";
+  }
+  if (_optionalChain([process, 'access', _108 => _108.env, 'access', _109 => _109.ANTIGRAVITY, 'optionalAccess', _110 => _110.trim, 'call', _111 => _111()]) || _optionalChain([process, 'access', _112 => _112.env, 'access', _113 => _113.ANTIGRAVITY_CLI, 'optionalAccess', _114 => _114.trim, 'call', _115 => _115()]) || _optionalChain([process, 'access', _116 => _116.env, 'access', _117 => _117.ANTIGRAVITY_AGENT, 'optionalAccess', _118 => _118.trim, 'call', _119 => _119()]) || _optionalChain([process, 'access', _120 => _120.env, 'access', _121 => _121.ANTIGRAVITY_WORKSPACE, 'optionalAccess', _122 => _122.trim, 'call', _123 => _123()])) {
+    return "antigravity";
+  }
+  if (_optionalChain([process, 'access', _124 => _124.env, 'access', _125 => _125.GEMINI_CLI, 'optionalAccess', _126 => _126.trim, 'call', _127 => _127()]) || _optionalChain([process, 'access', _128 => _128.env, 'access', _129 => _129.GEMINI_CLI_VERSION, 'optionalAccess', _130 => _130.trim, 'call', _131 => _131()]) || _optionalChain([process, 'access', _132 => _132.env, 'access', _133 => _133.GEMINI_SANDBOX, 'optionalAccess', _134 => _134.trim, 'call', _135 => _135()]) || _optionalChain([process, 'access', _136 => _136.env, 'access', _137 => _137.GEMINI_CONFIG_DIR, 'optionalAccess', _138 => _138.trim, 'call', _139 => _139()])) {
+    return "gemini";
+  }
+  return _nullishCoalesce(options.defaultRuntime, () => ( "unknown"));
+}
+
+// src/skills-version.ts
+
+
+function activePluginSkillsDir() {
+  const pluginMode = _optionalChain([process, 'access', _140 => _140.env, 'access', _141 => _141.DEEPLINE_PLUGIN_MODE, 'optionalAccess', _142 => _142.trim, 'call', _143 => _143(), 'access', _144 => _144.toLowerCase, 'call', _145 => _145()]);
+  if (pluginMode !== "true" && pluginMode !== "1" && pluginMode !== "yes" && pluginMode !== "on") {
+    return "";
+  }
+  const dir = _nullishCoalesce(_optionalChain([process, 'access', _146 => _146.env, 'access', _147 => _147.DEEPLINE_PLUGIN_SKILLS_DIR, 'optionalAccess', _148 => _148.trim, 'call', _149 => _149()]), () => ( ""));
+  return dir && _fs.existsSync.call(void 0, dir) ? dir : "";
+}
+function hasActivePluginSkills() {
+  return Boolean(activePluginSkillsDir());
+}
+function readPluginSkillsVersion() {
+  const dir = activePluginSkillsDir();
+  if (!dir) return "";
+  try {
+    return _fs.readFileSync.call(void 0, _path.join.call(void 0, dir, ".version"), "utf-8").trim();
+  } catch (e9) {
+    return "";
+  }
+}
+var KNOWN_SKILL_AGENTS = [
+  "antigravity",
+  "claude-code",
+  "cline",
+  "codex",
+  "cursor",
+  "gemini-cli",
+  "windsurf"
+];
+var DEFAULT_SKILL_AGENTS = [
+  "codex",
+  "claude-code",
+  "cursor",
+  "gemini-cli",
+  "antigravity"
+];
+function skillsAgentPathSegment(agent) {
+  if (agent === "*") return "all";
+  const slug = agent.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "");
+  return slug || "agent";
+}
+function sdkSkillsVersionPath(baseUrl, agents = []) {
+  const suffix = agents.length > 0 ? `-${agents.map(skillsAgentPathSegment).join("-")}` : "";
+  return _path.join.call(void 0, sdkCliStateDirPath(baseUrl), `skills${suffix}-version`);
+}
+function legacySdkSkillsVersionPath(baseUrl) {
+  return _path.join.call(void 0, _path.dirname.call(void 0, sdkCliStateDirPath(baseUrl)), "sdk-skills", ".version");
+}
+function readSkillsVersionFile(path) {
+  try {
+    return _fs.readFileSync.call(void 0, path, "utf-8").trim();
+  } catch (e10) {
+    return "";
+  }
+}
+function resolveAutoSyncSkillAgents() {
+  switch (detectAgentRuntime()) {
+    case "codex":
+      return ["codex"];
+    case "claude_code":
+      return ["claude-code"];
+    case "cursor":
+      return ["cursor"];
+    case "gemini":
+      return ["gemini-cli"];
+    case "antigravity":
+      return ["antigravity"];
+    case "unknown":
+      return [...DEFAULT_SKILL_AGENTS];
+    default:
+      return [];
+  }
+}
+function readSdkSkillsLocalVersion(baseUrl) {
+  const pluginVersion = readPluginSkillsVersion();
+  if (pluginVersion) return pluginVersion;
+  const agents = resolveAutoSyncSkillAgents();
+  if (agents.length > 1) {
+    const versions = agents.map(
+      (agent) => readSkillsVersionFile(sdkSkillsVersionPath(baseUrl, [agent]))
+    );
+    const first = versions[0];
+    return first && versions.every((version) => version === first) ? first : "";
+  }
+  const scopedPath = sdkSkillsVersionPath(baseUrl, agents);
+  if (agents.length > 0 && _fs.existsSync.call(void 0, scopedPath)) {
+    try {
+      return _fs.readFileSync.call(void 0, scopedPath, "utf-8").trim();
+    } catch (e11) {
+      return "";
+    }
+  }
+  if (agents.length > 0) {
+    const legacyPath = legacySdkSkillsVersionPath(baseUrl);
+    if (!_fs.existsSync.call(void 0, legacyPath)) return "";
+    try {
+      return _fs.readFileSync.call(void 0, legacyPath, "utf-8").trim();
+    } catch (e12) {
+      return "";
+    }
+  }
+  const path = _fs.existsSync.call(void 0, sdkSkillsVersionPath(baseUrl)) ? sdkSkillsVersionPath(baseUrl) : legacySdkSkillsVersionPath(baseUrl);
+  if (!_fs.existsSync.call(void 0, path)) return "";
+  try {
+    return _fs.readFileSync.call(void 0, path, "utf-8").trim();
+  } catch (e13) {
+    return "";
+  }
+}
+function writeSdkSkillsLocalVersion(baseUrl, version, agents) {
+  const targets = agents.length > 1 ? agents.map((agent) => [agent]) : [agents];
+  let complete = true;
+  for (const target of targets) {
+    const path = sdkSkillsVersionPath(baseUrl, target);
+    try {
+      _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, path), { recursive: true });
+      _fs.writeFileSync.call(void 0, path, `${version}
+`, "utf-8");
+    } catch (e14) {
+      complete = false;
+    }
+  }
+  return complete;
+}
+
+// ../play-runtime/coordinator-headers.ts
+var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
+var COORDINATOR_URL_OVERRIDE_HEADER = "x-deepline-coordinator-url";
+var WORKER_CALLBACK_URL_OVERRIDE_HEADER = "x-deepline-worker-callback-url";
+var RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER = "x-deepline-runtime-scheduler-schema";
+var RUNTIME_ENVIRONMENT_TOKEN_HEADER = "x-deepline-runtime-environment-token";
+var RETAINED_PIPELINE_RECEIVERS_HEADER = "x-deepline-retained-pipeline-receivers";
+var ABSURD_RELEASE_OVERRIDE_HEADER = "x-deepline-absurd-release";
+var PREFERRED_RECEIPT_GATEWAY_MACHINE_ID_HEADER = "x-deepline-preferred-receipt-gateway-machine-id";
+var SYNTHETIC_RUN_HEADER = "x-deepline-synthetic-run";
+
+// src/deployment-protection.ts
+function deploymentProtectionHeaders() {
+  const token = typeof process !== "undefined" ? _optionalChain([process, 'access', _150 => _150.env, 'optionalAccess', _151 => _151.VERCEL_PROTECTION_BYPASS_TOKEN]) : void 0;
+  return token ? { "x-vercel-protection-bypass": token } : {};
+}
+var fetchWithDeploymentProtection = (input, init) => {
+  const headers = new Headers(
+    input instanceof Request ? input.headers : void 0
+  );
+  new Headers(_optionalChain([init, 'optionalAccess', _152 => _152.headers])).forEach((value, name) => headers.set(name, value));
+  for (const [name, value] of Object.entries(deploymentProtectionHeaders())) {
+    headers.set(name, value);
+  }
+  return fetch(input, { ...init, headers });
+};
+
+// ../play-runtime/runtime-incident-drills.ts
+var RUNTIME_TEST_FAULT_IDS = [
+  "receipt_complete_write_fail",
+  "receipt_fail_write_fail",
+  "worker_receipt_complete_write_fail",
+  "invocation_response_delivery_abort",
+  "execution_upstream_response_loss",
+  "receipt_gateway_hold_ms",
+  "receipt_claim_query_hold_once_ms",
+  "receipt_claim_response_timeout",
+  "modal_sandbox_create_resource_exhausted",
+  "runtime_sheet_page_tail_hold_ms"
+];
+var LOCAL_TOPOLOGY = ["local_daytona"];
+var LOCAL_AND_PREVIEW_TOPOLOGIES = [
+  "local_daytona",
+  "preview_fly",
+  "preview_direct_modal"
+];
+var MODAL_PREVIEW_TOPOLOGY = ["preview_direct_modal"];
+var RUNTIME_INCIDENT_DRILL_CATALOG = [
+  {
+    id: "local_worker_process_outage",
+    description: "Interrupt the scheduler worker in the selected non-production runtime topology.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "process",
+      component: "worker",
+      modes: ["pause", "crash"]
+    },
+    expected: {
+      outcome: "The same logical run stays durable through the worker outage and completes after the selected topology recovers.",
+      safetyFacts: ["same_logical_run", "no_false_success"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "local-component-outage-recovery-e2e"
+    }
+  },
+  {
+    id: "local_gateway_process_outage",
+    description: "Interrupt the receipt gateway in the selected non-production runtime topology.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "process",
+      component: "gateway",
+      modes: ["pause", "crash"]
+    },
+    expected: {
+      outcome: "In-flight work recovers only at a safe receipt boundary and the same logical run completes after the gateway recovers.",
+      safetyFacts: [
+        "same_logical_run",
+        "no_false_success",
+        "bounded_provider_execution"
+      ]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "local-component-outage-recovery-e2e"
+    }
+  },
+  {
+    id: "local_runtime_process_outage",
+    description: "Interrupt both runtime components in the selected non-production topology.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: { kind: "process", component: "all", modes: ["pause", "crash"] },
+    expected: {
+      outcome: "Durable work waits through the combined outage; it never becomes a false success or creates a second logical run.",
+      safetyFacts: ["same_logical_run", "no_false_success"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "local-component-outage-recovery-e2e"
+    }
+  },
+  {
+    id: "receipt_complete_write_fail",
+    description: "Fail the next durable receipt-completion write.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The failed run is loud, and a later bounded recovery may repeat the affected provider operation if its prior completion was not durable.",
+      safetyFacts: ["retry_or_explicit_recovery", "bounded_provider_execution"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "receipt-persist-failure-run-fatal-e2e"
+    }
+  },
+  {
+    id: "receipt_fail_write_fail",
+    description: "Fail the next durable receipt-failure write.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The failure is loud; recovery remains bounded and may repeat an operation whose prior outcome was not durably recorded.",
+      safetyFacts: ["retry_or_explicit_recovery", "bounded_provider_execution"]
+    },
+    verification: {
+      kind: "focused_regression",
+      target: "tests/lib/plays/runtime-test-fault-registry.test.ts"
+    }
+  },
+  {
+    id: "worker_receipt_complete_write_fail",
+    description: "Fail the worker-side receipt-completion write once.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The worker reports the persistence failure loudly; bounded recovery may repeat work whose completion was not durable.",
+      safetyFacts: ["retry_or_explicit_recovery", "bounded_provider_execution"]
+    },
+    verification: {
+      kind: "focused_regression",
+      target: "tests/lib/plays/runtime-test-fault-registry.test.ts"
+    }
+  },
+  {
+    id: "invocation_response_delivery_abort",
+    description: "Abort one receipt-gateway response after invocation delivery.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The same logical run completes through terminal-cache replay; any provider retry is governed by its separate operation policy.",
+      safetyFacts: ["same_logical_run", "bounded_provider_execution"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "invocation-delivery-replay-e2e"
+    }
+  },
+  {
+    id: "execution_upstream_response_loss",
+    description: "Lose the first response of each keyed execution after the upstream app durably stores it.",
+    topologies: ["preview_fly"],
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The same invocation recovers the stored response without repeating provider work or customer charges, and every row retains its usable result.",
+      safetyFacts: [
+        "same_logical_run",
+        "bounded_provider_execution",
+        "all_rows_settle_once",
+        "no_false_success"
+      ]
+    },
+    verification: {
+      kind: "preview_black_box",
+      target: "101-agent-heavy-gateway-load-e2e"
+    }
+  },
+  {
+    id: "receipt_gateway_hold_ms",
+    description: "Hold one checked-out receipt-gateway scheduler client.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 500,
+      valueMeaning: "milliseconds"
+    },
+    expected: {
+      outcome: "The request is delayed inside the real gateway pool and either completes within its deadline or follows bounded transport recovery.",
+      safetyFacts: ["bounded_provider_execution"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "agent-heavy-gateway-load-e2e"
+    }
+  },
+  {
+    id: "receipt_claim_query_hold_once_ms",
+    description: "Hold one physical receipt-claim query.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 500,
+      valueMeaning: "milliseconds"
+    },
+    expected: {
+      outcome: "The checked-out claim either completes or times out through bounded recovery; an ambiguous outcome may be retried within its budget.",
+      safetyFacts: ["bounded_provider_execution"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "receipt-claim-deadline-recovery-e2e"
+    }
+  },
+  {
+    id: "receipt_claim_response_timeout",
+    description: "Report one fully received receipt-claim response as timed out.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The same logical run completes by replaying the committed receipt response or uses bounded recovery if that response is unavailable.",
+      safetyFacts: ["same_logical_run", "bounded_provider_execution"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "receipt-ambiguous-response-recovery-e2e"
+    }
+  },
+  {
+    id: "modal_sandbox_create_resource_exhausted",
+    description: "Make Modal sandbox creation return RESOURCE_EXHAUSTED before user code.",
+    topologies: MODAL_PREVIEW_TOPOLOGY,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The same logical run enters bounded pre-code defer/recovery and later retries sandbox startup; no user code or provider call precedes the retry.",
+      safetyFacts: [
+        "same_logical_run",
+        "no_user_code_before_recovery",
+        "bounded_provider_execution"
+      ]
+    },
+    verification: {
+      kind: "preview_black_box",
+      target: "modal-sandbox-recovery-e2e"
+    }
+  },
+  {
+    id: "runtime_sheet_page_tail_hold_ms",
+    description: "Hold one runtime-sheet tail-page operation.",
+    topologies: LOCAL_TOPOLOGY,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 500,
+      valueMeaning: "milliseconds"
+    },
+    expected: {
+      outcome: "Page-tail work stays pending during the bounded hold, then completes without losing or duplicating rows.",
+      safetyFacts: ["all_rows_settle_once"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "page-tail-sheet-write-hold-e2e"
+    }
+  }
+];
+function isRuntimeTestFaultDrill(drill) {
+  return drill.control.kind === "runtime_test_fault" && RUNTIME_TEST_FAULT_IDS.some((faultId) => faultId === drill.id);
+}
+function runtimeTestFaultDrills() {
+  return RUNTIME_INCIDENT_DRILL_CATALOG.filter(isRuntimeTestFaultDrill);
+}
+
+// ../play-runtime/test-runtime-seams.ts
+var PLAY_RUNTIME_TEST_FAULT_HEADER = "x-deepline-test-fault";
+var SUPPORTED_RUNTIME_TEST_FAULTS = new Set(
+  runtimeTestFaultDrills().map(({ id }) => id)
+);
+var MAX_RUNTIME_TEST_POLICY_MS = 10 * 6e4;
+
+// src/http.ts
+var MAX_DIAGNOSTIC_HEADER_LENGTH = 120;
+var COWORK_NETWORK_HINT = "Claude Cowork appears to be running Deepline in a network-restricted sandbox. In Claude Desktop, open Settings > Capabilities, turn on Allow network egress, and set Domain allowlist to All domains for the Cowork session.";
+var REQUEST_TIMEOUT_MARKER = Symbol("deeplineRequestTimeout");
+var REQUEST_ABORT_MARKER = Symbol("deeplineRequestAbort");
+function requestCancelledError(signal) {
+  const error = withErrorCause(new Error("Request aborted"), signal.reason);
+  error[REQUEST_ABORT_MARKER] = true;
+  return error;
+}
+function normalizeRequestAbortError(error, input) {
+  const normalized = error instanceof Error ? error : new Error(String(error));
+  const tagged = normalized;
+  if (input.timedOut) {
+    tagged[REQUEST_TIMEOUT_MARKER] = input.timeoutMs;
+  } else if (isAbortLikeError(normalized)) {
+    tagged[REQUEST_ABORT_MARKER] = true;
+  }
+  return normalized;
+}
+function applyExplicitHeaders(headers, explicit) {
+  if (!explicit) return headers;
+  for (const [rawName, value] of Object.entries(explicit)) {
+    const name = rawName.trim().toLowerCase();
+    if (!name) continue;
+    for (const existing of Object.keys(headers)) {
+      if (existing.toLowerCase() === name) delete headers[existing];
+    }
+    headers[rawName.trim()] = value;
+  }
+  return headers;
+}
+function isAbortLikeError(error) {
+  const name = error.name.toLowerCase();
+  const message = error.message.toLowerCase();
+  return name === "aborterror" || message.includes("operation was aborted") || message === "aborted";
+}
+function withErrorCause(error, cause) {
+  if (cause !== null && cause !== void 0) {
+    Object.defineProperty(error, "cause", {
+      value: cause,
+      configurable: true,
+      writable: true
+    });
+  }
+  return error;
+}
+function mapNetworkError(baseUrl, error, targetLabel) {
+  const tagged = error;
+  const timeoutMs = _optionalChain([tagged, 'optionalAccess', _153 => _153[REQUEST_TIMEOUT_MARKER]]);
+  if (typeof timeoutMs === "number") {
+    return {
+      message: `Request to ${targetLabel} timed out after ${timeoutMs}ms while waiting for a response.`,
+      code: "NETWORK_TIMEOUT",
+      details: { timeoutMs, target: targetLabel }
+    };
+  }
+  if (_optionalChain([tagged, 'optionalAccess', _154 => _154[REQUEST_ABORT_MARKER]])) {
+    return {
+      message: `Request to ${targetLabel} was aborted before it completed.`,
+      code: "NETWORK_ABORTED"
+    };
+  }
+  return {
+    message: _optionalChain([error, 'optionalAccess', _155 => _155.message]) ? `Unable to connect to ${baseUrl}. ${error.message}` : `Unable to connect to ${baseUrl}. Is the computer able to access the url?`,
+    code: "NETWORK_ERROR"
+  };
+}
+function describeRequestTarget(path) {
+  const toolExecuteMatch = path.match(
+    /^\/api\/v2\/integrations\/([^/?#]+)\/execute(?:[/?#]|$)/
+  );
+  if (toolExecuteMatch) {
+    return providerLabelFromToolId(decodeURIComponent(toolExecuteMatch[1]));
+  }
+  return "Deepline";
+}
+function networkDiagnosticUrl(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" && url.protocol !== "http:") return void 0;
+    return `${url.origin}${url.pathname}`;
+  } catch (e15) {
+    return void 0;
+  }
+}
+function providerLabelFromToolId(toolId) {
+  const normalized = toolId.trim().toLowerCase();
+  const provider = normalized.split(/[_:./-]+/)[0];
+  return provider || normalized || "provider";
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  cleanDiagnosticHeader(value) {
+    const normalized = String(_nullishCoalesce(value, () => ( ""))).replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, MAX_DIAGNOSTIC_HEADER_LENGTH);
+    return normalized || null;
+  }
+  readSkillsVersionHeader() {
+    const explicit = this.cleanDiagnosticHeader(
+      process.env.DEEPLINE_SKILLS_VERSION
+    );
+    if (explicit) return explicit;
+    try {
+      return this.cleanDiagnosticHeader(
+        readSdkSkillsLocalVersion(this.config.baseUrl)
+      );
+    } catch (e16) {
+      return null;
+    }
+  }
+  authHeaders(extra) {
+    const transportHeaders = {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      "User-Agent": `deepline-ts-sdk/${SDK_VERSION}`,
+      "X-Deepline-Client-Family": "sdk",
+      "X-Deepline-CLI-Family": "sdk",
+      "X-Deepline-Agent-Runtime": detectAgentRuntime(),
+      "X-Deepline-CLI-Version": SDK_VERSION,
+      "X-Deepline-SDK-Version": SDK_VERSION,
+      "X-Deepline-API-Contract": SDK_API_CONTRACT,
+      "X-Deepline-Run-Result-Shape": "canonical"
+    };
+    const headers = deploymentProtectionHeaders();
+    const skillsVersion = this.readSkillsVersionHeader();
+    if (skillsVersion) {
+      headers["X-Deepline-Skills-Version"] = skillsVersion;
+    }
+    const playArtifactR2Prefix = typeof process !== "undefined" ? _optionalChain([process, 'access', _156 => _156.env, 'optionalAccess', _157 => _157.DEEPLINE_PLAY_ARTIFACT_R2_PREFIX]) : void 0;
+    if (playArtifactR2Prefix) {
+      headers["x-deepline-play-artifact-r2-prefix"] = playArtifactR2Prefix;
+    }
+    const coordinatorUrl = typeof process !== "undefined" ? _optionalChain([process, 'access', _158 => _158.env, 'optionalAccess', _159 => _159.DEEPLINE_COORDINATOR_URL]) : void 0;
+    const coordinatorInternalToken = typeof process !== "undefined" ? _optionalChain([process, 'access', _160 => _160.env, 'optionalAccess', _161 => _161.DEEPLINE_INTERNAL_TOKEN]) : void 0;
+    const absurdReleaseOverride = typeof process !== "undefined" ? _optionalChain([process, 'access', _162 => _162.env, 'optionalAccess', _163 => _163.DEEPLINE_ABSURD_RELEASE]) : void 0;
+    const preferredReceiptGatewayMachineId = typeof process !== "undefined" ? _optionalChain([process, 'access', _164 => _164.env, 'optionalAccess', _165 => _165.DEEPLINE_PREFERRED_RECEIPT_GATEWAY_MACHINE_ID]) : void 0;
+    if (_optionalChain([coordinatorUrl, 'optionalAccess', _166 => _166.trim, 'call', _167 => _167()])) {
+      headers[COORDINATOR_URL_OVERRIDE_HEADER] = coordinatorUrl.trim();
+    }
+    const workerCallbackUrl = typeof process !== "undefined" ? _optionalChain([process, 'access', _168 => _168.env, 'optionalAccess', _169 => _169.DEEPLINE_WORKER_CALLBACK_URL]) : void 0;
+    if (_optionalChain([workerCallbackUrl, 'optionalAccess', _170 => _170.trim, 'call', _171 => _171()])) {
+      headers[WORKER_CALLBACK_URL_OVERRIDE_HEADER] = workerCallbackUrl.trim();
+    }
+    const runtimeSchedulerSchema = typeof process !== "undefined" ? _optionalChain([process, 'access', _172 => _172.env, 'optionalAccess', _173 => _173.DEEPLINE_RUNTIME_SCHEDULER_SCHEMA]) : void 0;
+    if (_optionalChain([runtimeSchedulerSchema, 'optionalAccess', _174 => _174.trim, 'call', _175 => _175()])) {
+      headers[RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER] = runtimeSchedulerSchema.trim();
+    }
+    const syntheticRun = typeof process !== "undefined" ? _optionalChain([process, 'access', _176 => _176.env, 'optionalAccess', _177 => _177.DEEPLINE_SYNTHETIC_RUN]) : void 0;
+    if (syntheticRun && syntheticRun.trim() && syntheticRun.trim() !== "0") {
+      headers[SYNTHETIC_RUN_HEADER] = "1";
+    }
+    const runtimeTestFault = typeof process !== "undefined" ? _optionalChain([process, 'access', _178 => _178.env, 'optionalAccess', _179 => _179.DEEPLINE_TEST_RUNTIME_FAULT]) : void 0;
+    if (_optionalChain([runtimeTestFault, 'optionalAccess', _180 => _180.trim, 'call', _181 => _181()])) {
+      headers[PLAY_RUNTIME_TEST_FAULT_HEADER] = runtimeTestFault.trim();
+    }
+    const retainedReceivers = typeof process !== "undefined" ? _optionalChain([process, 'access', _182 => _182.env, 'optionalAccess', _183 => _183.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS, 'optionalAccess', _184 => _184.trim, 'call', _185 => _185()]) : void 0;
+    if (retainedReceivers && _optionalChain([coordinatorInternalToken, 'optionalAccess', _186 => _186.trim, 'call', _187 => _187()])) {
+      headers[RETAINED_PIPELINE_RECEIVERS_HEADER] = retainedReceivers;
+      headers[COORDINATOR_INTERNAL_TOKEN_HEADER] = coordinatorInternalToken.trim();
+    }
+    if (_optionalChain([absurdReleaseOverride, 'optionalAccess', _188 => _188.trim, 'call', _189 => _189()]) && _optionalChain([coordinatorInternalToken, 'optionalAccess', _190 => _190.trim, 'call', _191 => _191()])) {
+      headers[ABSURD_RELEASE_OVERRIDE_HEADER] = absurdReleaseOverride.trim();
+    }
+    if (_optionalChain([preferredReceiptGatewayMachineId, 'optionalAccess', _192 => _192.trim, 'call', _193 => _193()]) && _optionalChain([coordinatorInternalToken, 'optionalAccess', _194 => _194.trim, 'call', _195 => _195()])) {
+      headers[PREFERRED_RECEIPT_GATEWAY_MACHINE_ID_HEADER] = preferredReceiptGatewayMachineId.trim();
+    }
+    if (_optionalChain([coordinatorInternalToken, 'optionalAccess', _196 => _196.trim, 'call', _197 => _197()]) && (_optionalChain([coordinatorUrl, 'optionalAccess', _198 => _198.trim, 'call', _199 => _199()]) || _optionalChain([workerCallbackUrl, 'optionalAccess', _200 => _200.trim, 'call', _201 => _201()]) || _optionalChain([runtimeTestFault, 'optionalAccess', _202 => _202.trim, 'call', _203 => _203()]) || _optionalChain([absurdReleaseOverride, 'optionalAccess', _204 => _204.trim, 'call', _205 => _205()]) || _optionalChain([preferredReceiptGatewayMachineId, 'optionalAccess', _206 => _206.trim, 'call', _207 => _207()]))) {
+      headers[COORDINATOR_INTERNAL_TOKEN_HEADER] = coordinatorInternalToken.trim();
+    }
+    return applyExplicitHeaders(
+      applyExplicitHeaders(
+        applyExplicitHeaders(transportHeaders, extra),
+        headers
+      ),
+      this.config.headers
+    );
+  }
+  /**
+   * Send an HTTP request with automatic retries and error handling.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path (e.g. `"/api/v2/tools"`)
+   * @param options - HTTP method, body, headers, and timeout
+   * @returns Parsed JSON response body
+   * @throws {@link AuthError} on Deepline-auth HTTP 401/403 (immediate, no retry)
+   * @throws {@link RateLimitError} on HTTP 429 after all retries exhausted
+   * @throws {@link DeeplineError} on other API errors or connection failures
+   */
+  async request(path, options) {
+    const baseUrl = this.config.baseUrl;
+    const url = `${baseUrl}${path}`;
+    const method = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _208 => _208.method]), () => ( "GET"));
+    const requestStartedAt = Date.now();
+    let fetchAttempts = 0;
+    let lastRequestUrl = url;
+    let networkFailedAt;
+    let networkPhase = "before_request";
+    const headers = this.authHeaders(_optionalChain([options, 'optionalAccess', _209 => _209.headers]));
+    if (_optionalChain([options, 'optionalAccess', _210 => _210.body]) !== void 0) {
+      applyExplicitHeaders(headers, { "Content-Type": "application/json" });
+    }
+    let lastError = null;
+    const candidateUrls = _optionalChain([options, 'optionalAccess', _211 => _211.exactUrlOnly]) ? [url] : buildCandidateUrls(url);
+    let retryAfterDelayMs = null;
+    const maxRetries = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _212 => _212.maxRetries]), () => ( this.config.maxRetries));
+    requestAttempts: for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (_optionalChain([options, 'optionalAccess', _213 => _213.signal, 'optionalAccess', _214 => _214.aborted])) {
+        lastError = requestCancelledError(options.signal);
+        networkFailedAt = Date.now();
+        break;
+      }
+      if (attempt > 0) {
+        const backoffMs = Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
+        const delayMs = retryAfterDelayMs === null ? backoffMs : Math.max(backoffMs, retryAfterDelayMs);
+        retryAfterDelayMs = null;
+        networkPhase = "retry_wait";
+        try {
+          await sleep(delayMs, _optionalChain([options, 'optionalAccess', _215 => _215.signal]));
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          networkFailedAt = Date.now();
+          break;
+        }
+      }
+      for (const candidateUrl of candidateUrls) {
+        if (_optionalChain([options, 'optionalAccess', _216 => _216.signal, 'optionalAccess', _217 => _217.aborted])) {
+          lastError = requestCancelledError(options.signal);
+          networkFailedAt = Date.now();
+          break requestAttempts;
+        }
+        const controller = new AbortController();
+        const timeoutMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _218 => _218.timeout]), () => ( this.config.timeout));
+        let requestTimedOut = false;
+        const timeoutId = setTimeout(() => {
+          requestTimedOut = true;
+          controller.abort();
+        }, timeoutMs);
+        const abortRequest = () => controller.abort();
+        _optionalChain([options, 'optionalAccess', _219 => _219.signal, 'optionalAccess', _220 => _220.addEventListener, 'call', _221 => _221("abort", abortRequest, {
+          once: true
+        })]);
+        networkPhase = "before_request";
+        try {
+          const requestBody = _optionalChain([options, 'optionalAccess', _222 => _222.formData]) !== void 0 ? typeof options.formData === "function" ? options.formData() : options.formData : _optionalChain([options, 'optionalAccess', _223 => _223.body]) !== void 0 ? JSON.stringify(options.body) : void 0;
+          fetchAttempts += 1;
+          lastRequestUrl = candidateUrl;
+          networkPhase = "awaiting_headers";
+          const response = await fetch(candidateUrl, {
+            method,
+            headers,
+            body: requestBody,
+            signal: controller.signal
+          });
+          networkPhase = "reading_body";
+          _optionalChain([options, 'optionalAccess', _224 => _224.onResponse, 'optionalCall', _225 => _225(response)]);
+          if (response.status === 404 && _optionalChain([options, 'optionalAccess', _226 => _226.allowNotFound])) {
+            clearTimeout(timeoutId);
+            return null;
+          }
+          const body = await response.text();
+          clearTimeout(timeoutId);
+          const parsed = parseResponseBody(body);
+          const structuredToolError = _optionalChain([options, 'optionalAccess', _227 => _227.toolId]) && !response.ok ? _chunk7P5AA3SNjs.deserializeToolExecutionFailure.call(void 0, 
+            _chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status),
+            isRecord(parsed) ? parsed.tool_error : null,
+            _chunk7P5AA3SNjs.TOOL_EXECUTION_ERROR_SCHEMA_VERSION
+          ) : null;
+          if (structuredToolError) {
+            if (response.status === 429) {
+              const retryAfter = parseRetryAfter(response);
+              const failure = _chunk7P5AA3SNjs.serializeToolExecutionFailure.call(void 0, structuredToolError);
+              lastError = failure === null ? structuredToolError : new ToolRateLimitError(structuredToolError.message, {
+                ...failure,
+                retryAfterMs: _nullishCoalesce(failure.retryAfterMs, () => ( Math.max(0, retryAfter)))
+              });
+              if (attempt < maxRetries) {
+                retryAfterDelayMs = retryAfter;
+                break;
+              }
+              throw lastError;
+            }
+            throw structuredToolError;
+          }
+          if (response.status === 429) {
+            if (_optionalChain([options, 'optionalAccess', _228 => _228.preserveRateLimitResponse]) && isMonitorRateLimitEnvelope(parsed)) {
+              throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+                _chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status),
+                response.status,
+                _chunkXNYIZMNQjs.apiErrorCodeFromResponse.call(void 0, parsed),
+                { response: parsed }
+              );
+            }
+            const retryAfter = parseRetryAfter(response);
+            lastError = new RateLimitError(retryAfter);
+            if (attempt < maxRetries) {
+              retryAfterDelayMs = retryAfter;
+              break;
+            }
+            throw lastError;
+          }
+          if (response.status === 401 && !isProviderOriginatedHttpError(parsed)) {
+            throw new AuthError(_chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status));
+          }
+          if (!response.ok) {
+            const retryableApiError = _optionalChain([options, 'optionalAccess', _229 => _229.retryApiErrors]) === true && isRetryableApiErrorResponse(response.status);
+            const htmlError = detectHtmlErrorBody(
+              body,
+              response.headers.get("content-type")
+            );
+            if (htmlError) {
+              lastError = new (0, _chunk7P5AA3SNjs.DeeplineError)(
+                htmlError.message(response.status),
+                response.status,
+                "API_ERROR",
+                {
+                  htmlErrorPage: true,
+                  ...htmlError.title ? { title: htmlError.title } : {},
+                  ...htmlError.workerThrewException ? { workerThrewException: true } : {}
+                }
+              );
+              if (retryableApiError && attempt < maxRetries) {
+                retryAfterDelayMs = parseOptionalRetryAfter(response);
+                break;
+              }
+              throw lastError;
+            }
+            const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
+            const msg = typeof errorValue === "string" ? errorValue : errorValue && typeof errorValue === "object" && "message" in errorValue && typeof errorValue.message === "string" ? errorValue.message : typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string" ? parsed.message : `HTTP ${response.status}`;
+            const apiErrorCode = _chunkXNYIZMNQjs.apiErrorCodeFromResponse.call(void 0, parsed);
+            lastError = new (0, _chunk7P5AA3SNjs.DeeplineError)(msg, response.status, apiErrorCode, {
+              response: parsed
+            });
+            if (retryableApiError && attempt < maxRetries) {
+              retryAfterDelayMs = parseOptionalRetryAfter(response);
+              break;
+            }
+            throw lastError;
+          }
+          if (typeof parsed === "string") {
+            const interstitial = detectHtmlErrorBody(
+              body,
+              response.headers.get("content-type")
+            );
+            if (interstitial) {
+              throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+                `${this.config.baseUrl} returned a deployment-protection page instead of JSON. Set VERCEL_PROTECTION_BYPASS_TOKEN, or run \`vercel login\` if the CLI session expired.`,
+                response.status,
+                "DEPLOYMENT_PROTECTED",
+                { htmlErrorPage: true }
+              );
+            }
+          }
+          return parsed;
+        } catch (error) {
+          clearTimeout(timeoutId);
+          networkFailedAt = Date.now();
+          if (_optionalChain([options, 'optionalAccess', _230 => _230.signal, 'optionalAccess', _231 => _231.aborted])) {
+            lastError = requestCancelledError(options.signal);
+            break requestAttempts;
+          }
+          if (error instanceof AuthError || error instanceof _chunk7P5AA3SNjs.DeeplineError) {
+            throw error;
+          }
+          if (error instanceof RateLimitError) {
+            lastError = error;
+            break;
+          }
+          lastError = normalizeRequestAbortError(error, {
+            timeoutMs,
+            timedOut: requestTimedOut
+          });
+        } finally {
+          clearTimeout(timeoutId);
+          _optionalChain([options, 'optionalAccess', _232 => _232.signal, 'optionalAccess', _233 => _233.removeEventListener, 'call', _234 => _234("abort", abortRequest)]);
+        }
+      }
+      if (attempt < maxRetries) continue;
+    }
+    if (lastError instanceof _chunk7P5AA3SNjs.DeeplineError) {
+      throw lastError;
+    }
+    const mappedNetworkError = mapNetworkError(
+      baseUrl,
+      lastError,
+      describeRequestTarget(path)
+    );
+    const failedAt = _nullishCoalesce(networkFailedAt, () => ( Date.now()));
+    const diagnosticUrl = networkDiagnosticUrl(lastRequestUrl);
+    const networkDetails = {
+      ...mappedNetworkError.details,
+      request: {
+        method,
+        ...diagnosticUrl === void 0 ? {} : { url: diagnosticUrl },
+        failedAtUtc: new Date(failedAt).toISOString(),
+        // Elapsed time covers the entire logical request, including retries.
+        elapsedMs: Math.max(0, failedAt - requestStartedAt),
+        attempts: fetchAttempts,
+        phase: networkPhase
+      }
+    };
+    if (_optionalChain([options, 'optionalAccess', _235 => _235.toolId])) {
+      const code = mappedNetworkError.code;
+      throw withErrorCause(
+        new (0, _chunk7P5AA3SNjs.ToolExecutionError)(
+          withCoworkNetworkHint(mappedNetworkError.message),
+          {
+            toolId: options.toolId,
+            provider: providerLabelFromToolId(options.toolId),
+            operation: options.toolId,
+            code,
+            origin: "deepline",
+            category: "network",
+            // A direct client timeout has ambiguous delivery. Fail closed unless
+            // the server returns the authoritative action delivery contract.
+            retryable: false,
+            statusCode: null,
+            requestId: null,
+            retryAfterMs: null,
+            networkKind: code === "NETWORK_TIMEOUT" ? "timeout" : code === "NETWORK_ABORTED" ? "unknown" : "unavailable",
+            networkScope: "client_to_deepline",
+            details: networkDetails,
+            publicDetails: options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : null
+          }
+        ),
+        lastError
+      );
+    }
+    throw withErrorCause(
+      new (0, _chunk7P5AA3SNjs.DeeplineError)(
+        withCoworkNetworkHint(mappedNetworkError.message),
+        void 0,
+        mappedNetworkError.code,
+        networkDetails
+      ),
+      lastError
+    );
+  }
+  /**
+   * Send a GET request.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path (e.g. `"/api/v2/tools"`)
+   */
+  async get(path, options) {
+    return this.request(path, {
+      method: "GET",
+      retryApiErrors: true,
+      ...options
+    });
+  }
+  async *streamSse(path, options) {
+    const url = `${this.config.baseUrl}${path}`;
+    const method = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _236 => _236.method]), () => ( "GET"));
+    const headers = this.authHeaders({
+      Accept: "text/event-stream",
+      ..._optionalChain([options, 'optionalAccess', _237 => _237.headers])
+    });
+    if (_optionalChain([options, 'optionalAccess', _238 => _238.body]) !== void 0) {
+      applyExplicitHeaders(headers, { "Content-Type": "application/json" });
+    }
+    let lastError = null;
+    for (const candidateUrl of buildCandidateUrls(url)) {
+      try {
+        const response = await fetch(candidateUrl, {
+          method,
+          headers,
+          body: _optionalChain([options, 'optionalAccess', _239 => _239.body]) !== void 0 ? JSON.stringify(options.body) : void 0,
+          signal: _optionalChain([options, 'optionalAccess', _240 => _240.signal])
+        });
+        if (!response.ok) {
+          const body = await response.text();
+          const parsed = parseResponseBody(body);
+          if (response.status === 401 && !isProviderOriginatedHttpError(parsed)) {
+            throw new AuthError(_chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status));
+          }
+          const htmlError = detectHtmlErrorBody(
+            body,
+            response.headers.get("content-type")
+          );
+          if (htmlError) {
+            throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+              htmlError.message(response.status),
+              response.status,
+              "API_ERROR",
+              {
+                htmlErrorPage: true,
+                ...htmlError.title ? { title: htmlError.title } : {},
+                ...htmlError.workerThrewException ? { workerThrewException: true } : {}
+              }
+            );
+          }
+          throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+            _chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status),
+            response.status,
+            _chunkXNYIZMNQjs.apiErrorCodeFromResponse.call(void 0, parsed),
+            { response: parsed }
+          );
+        }
+        if (!response.body) {
+          throw new (0, _chunk7P5AA3SNjs.DeeplineError)("SSE response did not include a body.");
+        }
+        yield* decodeSseStream(response.body);
+        return;
+      } catch (error) {
+        if (error instanceof AuthError || error instanceof _chunk7P5AA3SNjs.DeeplineError) {
+          throw error;
+        }
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        if (isAbortLikeError(normalized) && _optionalChain([options, 'optionalAccess', _241 => _241.signal, 'optionalAccess', _242 => _242.aborted])) {
+          throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+            `Stream from ${this.config.baseUrl} was aborted by the caller.`,
+            void 0,
+            "ABORTED"
+          );
+        }
+        lastError = normalized;
+      }
+    }
+    if (lastError && isAbortLikeError(lastError)) {
+      throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+        withCoworkNetworkHint(
+          `Unable to stream from ${this.config.baseUrl}. The remote stream was interrupted.`
+        ),
+        void 0,
+        "PLAY_STREAM_NETWORK_ABORTED"
+      );
+    }
+    throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+      withCoworkNetworkHint(
+        _optionalChain([lastError, 'optionalAccess', _243 => _243.message]) ? `Unable to stream from ${this.config.baseUrl}. ${lastError.message}` : `Unable to stream from ${this.config.baseUrl}.`
+      )
+    );
+  }
+  /**
+   * Send a POST request with a JSON body.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path
+   * @param body - Request body (will be JSON-serialized)
+   */
+  async post(path, body, headers, options) {
+    return this.request(path, {
+      method: "POST",
+      body,
+      headers,
+      ...options
+    });
+  }
+  async postFormData(path, formData, headers) {
+    return this.request(path, {
+      method: "POST",
+      formData,
+      headers
+    });
+  }
+  /**
+   * Send a PATCH request with a JSON body.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path
+   * @param body - JSON-serializable request body
+   */
+  async patch(path, body, headers) {
+    return this.request(path, {
+      method: "PATCH",
+      body,
+      headers
+    });
+  }
+  async put(path, body, headers) {
+    return this.request(path, { method: "PUT", body, headers });
+  }
+  /**
+   * Send a DELETE request.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path
+   */
+  async delete(path) {
+    return this.request(path, { method: "DELETE" });
+  }
+};
+function parseResponseBody(body) {
+  try {
+    return JSON.parse(body);
+  } catch (e17) {
+    return body;
+  }
+}
+function isProviderOriginatedHttpError(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(_optionalChain([response, 'optionalAccess', _244 => _244.error]));
+  const failureOrigin = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _245 => _245.failure_origin]), () => ( _optionalChain([response, 'optionalAccess', _246 => _246.failure_origin])));
+  const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _247 => _247.code]), () => ( _optionalChain([response, 'optionalAccess', _248 => _248.code])));
+  return failureOrigin === "provider" || code === "UPSTREAM_BLOCKED";
+}
+function isMonitorRateLimitEnvelope(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(_optionalChain([response, 'optionalAccess', _249 => _249.error]));
+  return _optionalChain([error, 'optionalAccess', _250 => _250.code]) === "monitor_upstream_rate_limited" && typeof error.message === "string";
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function isRetryableApiErrorResponse(status) {
+  return status === 408 || status === 425 || status >= 500 && status < 600;
+}
+function detectHtmlErrorBody(body, contentType) {
+  const trimmed = body.trim();
+  const lower = trimmed.toLowerCase();
+  const isHtml = (_nullishCoalesce(contentType, () => ( ""))).toLowerCase().includes("text/html") || lower.startsWith("<!doctype") || lower.startsWith("<html");
+  if (!isHtml) {
+    return null;
+  }
+  const titleMatch = trimmed.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = _optionalChain([titleMatch, 'optionalAccess', _251 => _251[1], 'optionalAccess', _252 => _252.replace, 'call', _253 => _253(/\s+/g, " "), 'access', _254 => _254.trim, 'call', _255 => _255()]) || void 0;
+  const workerThrewException = /worker threw exception/i.test(trimmed);
+  return {
+    title,
+    workerThrewException,
+    message: (status) => {
+      const segments = [`HTTP ${status}`];
+      if (workerThrewException) {
+        segments.push("Worker threw exception");
+      }
+      if (title) {
+        segments.push(title);
+      }
+      return `${segments.join(": ")} (Cloudflare HTML error page suppressed)`;
+    }
+  };
+}
+function parseRetryAfter(response) {
+  return _nullishCoalesce(parseOptionalRetryAfter(response), () => ( 5e3));
+}
+function parseOptionalRetryAfter(response) {
+  const header = response.headers.get("retry-after");
+  if (header) {
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return seconds * 1e3;
+    }
+  }
+  return null;
+}
+function buildCandidateUrls(url) {
+  try {
+    const parsed = new URL(url);
+    const candidates = [url];
+    if (parsed.hostname === "localhost") {
+      const loopback = new URL(url);
+      loopback.hostname = "127.0.0.1";
+      candidates.push(loopback.toString());
+    }
+    return [...new Set(candidates)];
+  } catch (e18) {
+    return [url];
+  }
+}
+async function* decodeSseStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffered += decoder.decode(value, { stream: true });
+      const frames = buffered.split(/\r?\n\r?\n/);
+      buffered = _nullishCoalesce(frames.pop(), () => ( ""));
+      for (const frame of frames) {
+        const event2 = decodeSseFrame(frame);
+        if (event2) {
+          yield event2;
+        }
+      }
+    }
+    buffered += decoder.decode();
+    const event = decodeSseFrame(buffered);
+    if (event) {
+      yield event;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function decodeSseFrame(frame) {
+  const data = frame.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).trimStart()).join("\n").trim();
+  if (!data) {
+    return null;
+  }
+  const parsed = JSON.parse(data);
+  if (!parsed || typeof parsed !== "object" || typeof parsed.cursor !== "string" || typeof parsed.streamId !== "string" || typeof parsed.scope !== "string" || typeof parsed.type !== "string" || typeof parsed.at !== "string") {
+    return null;
+  }
+  return parsed;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (_optionalChain([signal, 'optionalAccess', _256 => _256.aborted])) {
+      reject(requestCancelledError(signal));
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      _optionalChain([signal, 'optionalAccess', _257 => _257.removeEventListener, 'call', _258 => _258("abort", abort)]);
+      resolve2();
+    }, ms);
+    const abort = () => {
+      clearTimeout(timeoutId);
+      _optionalChain([signal, 'optionalAccess', _259 => _259.removeEventListener, 'call', _260 => _260("abort", abort)]);
+      reject(requestCancelledError(signal));
+    };
+    _optionalChain([signal, 'optionalAccess', _261 => _261.addEventListener, 'call', _262 => _262("abort", abort, { once: true })]);
+  });
+}
+function withCoworkNetworkHint(message) {
+  if (!isCoworkLikeSandbox2() || message.includes(COWORK_NETWORK_HINT)) {
+    return message;
+  }
+  return `${message}
+${COWORK_NETWORK_HINT}`;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AuthError = AuthError; exports.RateLimitError = RateLimitError; exports.ToolRateLimitError = ToolRateLimitError; exports.ConfigError = ConfigError; exports.HOST_URL_ENV = HOST_URL_ENV; exports.API_KEY_ENV = API_KEY_ENV; exports.ACTIVE_ORG_ID_ENV = ACTIVE_ORG_ID_ENV; exports.ACTIVE_ORG_NAME_ENV = ACTIVE_ORG_NAME_ENV; exports.FEATURES_ENV = FEATURES_ENV; exports.PROD_URL = PROD_URL; exports.featureEnvValues = featureEnvValues; exports.storedHostApiKey = storedHostApiKey; exports.storedHostFeatures = storedHostFeatures; exports.baseUrlSlug = baseUrlSlug; exports.sdkCliStateDirPath = sdkCliStateDirPath; exports.hostConfigDirPath = hostConfigDirPath; exports.hostEnvFilePath = hostEnvFilePath; exports.saveHostEnvValues = saveHostEnvValues; exports.autoDetectBaseUrl = autoDetectBaseUrl; exports.resolveApiKeyForBaseUrl = resolveApiKeyForBaseUrl; exports.resolveProjectApiKeyForBaseUrl = resolveProjectApiKeyForBaseUrl; exports.resolveGlobalApiKeyForBaseUrl = resolveGlobalApiKeyForBaseUrl; exports.getResolvedProjectAuthSource = getResolvedProjectAuthSource; exports.resolveBaseUrlOnly = resolveBaseUrlOnly; exports.resolveConfig = resolveConfig; exports.ensureProjectPrivatePathsIgnored = ensureProjectPrivatePathsIgnored; exports.saveProjectDeeplineEnvValues = saveProjectDeeplineEnvValues; exports.resolveProjectPinTarget = resolveProjectPinTarget; exports.getActiveProjectAuthSource = getActiveProjectAuthSource; exports.resolveCliAuthProvenance = resolveCliAuthProvenance; exports.resolveCliCommandContext = resolveCliCommandContext; exports.SDK_VERSION = SDK_VERSION; exports.SDK_API_MAJOR = SDK_API_MAJOR; exports.SDK_API_CONTRACT = SDK_API_CONTRACT; exports.detectAgentRuntime = detectAgentRuntime; exports.hasActivePluginSkills = hasActivePluginSkills; exports.KNOWN_SKILL_AGENTS = KNOWN_SKILL_AGENTS; exports.DEFAULT_SKILL_AGENTS = DEFAULT_SKILL_AGENTS; exports.skillsAgentPathSegment = skillsAgentPathSegment; exports.resolveAutoSyncSkillAgents = resolveAutoSyncSkillAgents; exports.readSdkSkillsLocalVersion = readSdkSkillsLocalVersion; exports.writeSdkSkillsLocalVersion = writeSdkSkillsLocalVersion; exports.deploymentProtectionHeaders = deploymentProtectionHeaders; exports.fetchWithDeploymentProtection = fetchWithDeploymentProtection; exports.COORDINATOR_INTERNAL_TOKEN_HEADER = COORDINATOR_INTERNAL_TOKEN_HEADER; exports.RUNTIME_ENVIRONMENT_TOKEN_HEADER = RUNTIME_ENVIRONMENT_TOKEN_HEADER; exports.RETAINED_PIPELINE_RECEIVERS_HEADER = RETAINED_PIPELINE_RECEIVERS_HEADER; exports.HttpClient = HttpClient;