@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-666656AR.js

@@ -0,0 +1,568 @@
+import {
+  captureWorkspaceDeliverySnapshot,
+  deriveAttemptMutationState,
+  listIgnoredWorkspacePaths
+} from "./chunk-WZFC4V4U.js";
+import {
+  createLogger
+} from "./chunk-3OPP2OZB.js";
+import {
+  getAllProviderRuntimeQuirks,
+  getProviderRuntimeQuirks
+} from "./chunk-Y733RB7T.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  CredentialResidueError
+} from "./chunk-RRC5BL7B.js";
+import {
+  BUILD_CODEX_LOCAL_VERTICAL_SLICE,
+  BUILD_CURSOR_LOCAL_VERTICAL_SLICE,
+  BUILD_JSONL_VALIDATION,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+import {
+  sanitizeString
+} from "./chunk-CPSVQR2I.js";
+
+// src/core/providers/scrub-worktree-credentials.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var logger = createLogger("credential-scrub");
+function resolveProviderWorktreeStateRoot(worktreeStateSubdir, buildSubdir) {
+  const stateSubdir = worktreeStateSubdir ?? buildSubdir;
+  return stateSubdir ? path.posix.join(".build-project", stateSubdir) : void 0;
+}
+function providerWorktreeStateRoot(providerId) {
+  const config = getProviderRuntimeQuirks(providerId)?.config;
+  return resolveProviderWorktreeStateRoot(config?.worktreeStateSubdir, config?.buildSubdir);
+}
+function collectProviderCredentialTargets() {
+  const targets = [];
+  for (const quirks of getAllProviderRuntimeQuirks()) {
+    const authFiles = quirks.config?.authFiles;
+    if (!authFiles || authFiles.length === 0) {
+      continue;
+    }
+    const stateRoot = resolveProviderWorktreeStateRoot(
+      quirks.config?.worktreeStateSubdir,
+      quirks.config?.buildSubdir
+    );
+    if (!stateRoot) {
+      continue;
+    }
+    for (const authFile of authFiles) {
+      targets.push({ stateRoot, relativePath: authFile.path });
+    }
+  }
+  return targets;
+}
+function collectWorktreeCredentialPatterns() {
+  const patterns = [];
+  for (const quirks of getAllProviderRuntimeQuirks()) {
+    const entries = quirks.config?.worktreeCredentialPaths;
+    if (!entries || entries.length === 0) {
+      continue;
+    }
+    for (const entry of entries) {
+      patterns.push(entry.path);
+    }
+  }
+  return patterns;
+}
+async function inspectPath(filePath) {
+  try {
+    await fs.lstat(filePath);
+    return { state: "present" };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { state: "absent" };
+    }
+    return { state: "error", error };
+  }
+}
+function toResidualLabel(worktreePath, filePath) {
+  const relative2 = path.relative(worktreePath, filePath);
+  if (relative2 && relative2 !== ".." && !relative2.startsWith(`..${path.sep}`) && !path.isAbsolute(relative2)) {
+    return sanitizeString(relative2.split(path.sep).join("/"));
+  }
+  const segments = filePath.split(path.sep).filter(Boolean);
+  return sanitizeString(segments.slice(-4).join("/"));
+}
+async function expandSafeGlob(root, pattern) {
+  const segments = pattern.split("/").filter((segment) => segment.length > 0);
+  if (segments.length === 0) {
+    return { matches: [], inspectionErrors: [] };
+  }
+  if (segments.some((segment) => segment === ".." || path.isAbsolute(segment))) {
+    return { matches: [], inspectionErrors: [] };
+  }
+  const matches = [];
+  const inspectionErrors = [];
+  async function walk(currentDir, remaining) {
+    if (remaining.length === 0) {
+      return;
+    }
+    const segment = remaining[0];
+    const rest = remaining.slice(1);
+    const isLast = rest.length === 0;
+    if (segment === "*") {
+      let entries;
+      try {
+        entries = await fs.readdir(currentDir, { withFileTypes: true });
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          inspectionErrors.push({ path: currentDir, error });
+        }
+        return;
+      }
+      for (const entry of entries) {
+        const childPath = path.join(currentDir, entry.name);
+        if (isLast) {
+          matches.push(childPath);
+          continue;
+        }
+        try {
+          const stat = await fs.lstat(childPath);
+          if (stat.isSymbolicLink() || !stat.isDirectory()) {
+            continue;
+          }
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            inspectionErrors.push({ path: childPath, error });
+          }
+          continue;
+        }
+        await walk(childPath, rest);
+      }
+      return;
+    }
+    const nextPath = path.join(currentDir, segment);
+    if (isLast) {
+      const inspection = await inspectPath(nextPath);
+      if (inspection.state === "present") {
+        matches.push(nextPath);
+      } else if (inspection.state === "error") {
+        inspectionErrors.push({ path: nextPath, error: inspection.error });
+      }
+      return;
+    }
+    try {
+      const stat = await fs.lstat(nextPath);
+      if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        return;
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        inspectionErrors.push({ path: nextPath, error });
+      }
+      return;
+    }
+    await walk(nextPath, rest);
+  }
+  await walk(root, segments);
+  return { matches, inspectionErrors };
+}
+async function collectWorktreeCredentialTargets(worktreePath) {
+  const buildRoot = path.join(worktreePath, ".build-project");
+  const targets = [];
+  const inspectionErrors = [];
+  for (const pattern of collectWorktreeCredentialPatterns()) {
+    const { matches, inspectionErrors: patternErrors } = await expandSafeGlob(buildRoot, pattern);
+    targets.push(...matches);
+    inspectionErrors.push(...patternErrors);
+  }
+  return { targets, inspectionErrors };
+}
+async function removeCredentialLinkOrFile(filePath) {
+  try {
+    const stat = await fs.lstat(filePath);
+    if (stat.isDirectory()) {
+      await fs.rm(filePath, { recursive: true, force: true });
+    } else {
+      await fs.unlink(filePath);
+    }
+    return true;
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      return true;
+    }
+    return false;
+  }
+}
+async function scrubWorktreeCredentials(worktreePath, dependencies = {}) {
+  const inspect = dependencies.inspectPath ?? inspectPath;
+  const removeCredential = dependencies.removeCredential ?? removeCredentialLinkOrFile;
+  const buildRoot = path.join(worktreePath, ".build-project");
+  const buildRootInspection = await inspect(buildRoot);
+  if (buildRootInspection.state === "absent") {
+    return;
+  }
+  if (buildRootInspection.state === "error") {
+    throw new CredentialResidueError({
+      residualPaths: [toResidualLabel(worktreePath, buildRoot)],
+      ownership: "worktree-owned",
+      role: "worktree-scrub",
+      primaryError: buildRootInspection.error instanceof Error ? buildRootInspection.error.message : String(buildRootInspection.error),
+      cause: buildRootInspection.error
+    });
+  }
+  const residualPaths = [];
+  let firstInspectionError;
+  for (const { stateRoot, relativePath } of collectProviderCredentialTargets()) {
+    const candidatePath = path.join(worktreePath, stateRoot, relativePath);
+    const before = await inspect(candidatePath);
+    if (before.state === "absent") {
+      continue;
+    }
+    if (before.state === "error") {
+      residualPaths.push(toResidualLabel(worktreePath, candidatePath));
+      firstInspectionError ??= before.error;
+      continue;
+    }
+    const removed = await removeCredential(candidatePath);
+    const after = await inspect(candidatePath);
+    if (!removed || after.state !== "absent") {
+      const label = toResidualLabel(worktreePath, candidatePath);
+      logger.warn("Failed to remove leftover credential file", { path: label });
+      residualPaths.push(label);
+      if (after.state === "error") {
+        firstInspectionError ??= after.error;
+      }
+    }
+  }
+  const nestedTargets = await collectWorktreeCredentialTargets(worktreePath);
+  for (const inspectionError of nestedTargets.inspectionErrors) {
+    residualPaths.push(toResidualLabel(worktreePath, inspectionError.path));
+    firstInspectionError ??= inspectionError.error;
+  }
+  for (const candidatePath of nestedTargets.targets) {
+    const before = await inspect(candidatePath);
+    if (before.state === "absent") {
+      continue;
+    }
+    if (before.state === "error") {
+      residualPaths.push(toResidualLabel(worktreePath, candidatePath));
+      firstInspectionError ??= before.error;
+      continue;
+    }
+    const removed = await removeCredential(candidatePath);
+    const after = await inspect(candidatePath);
+    if (!removed || after.state !== "absent") {
+      const label = toResidualLabel(worktreePath, candidatePath);
+      logger.warn("Failed to remove leftover credential file", { path: label });
+      residualPaths.push(label);
+      if (after.state === "error") {
+        firstInspectionError ??= after.error;
+      }
+    }
+  }
+  if (residualPaths.length > 0) {
+    throw new CredentialResidueError({
+      residualPaths: [...new Set(residualPaths)],
+      ownership: "worktree-owned",
+      role: "worktree-scrub",
+      ...firstInspectionError !== void 0 ? {
+        primaryError: firstInspectionError instanceof Error ? firstInspectionError.message : String(firstInspectionError),
+        cause: firstInspectionError
+      } : {}
+    });
+  }
+}
+
+// src/orchestrator/executors/ignored-content-evidence.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { lstat as lstat2, readFile, readlink } from "fs/promises";
+import path2 from "path";
+var ignoredContentScanLimits = { maxFiles: 5e4, maxBytes: 1024 * 1024 * 1024 };
+var WHOLE_READ_BYTES = 1024 * 1024;
+var SCAN_CONCURRENCY = 16;
+function isUnder(relativePath, root) {
+  return relativePath === root || relativePath.startsWith(`${root}/`);
+}
+async function hashFileContents(absolutePath, size) {
+  const hash = createHash("sha256");
+  if (size <= WHOLE_READ_BYTES) return hash.update(await readFile(absolutePath)).digest("hex");
+  for await (const chunk of createReadStream(absolutePath)) hash.update(chunk);
+  return hash.digest("hex");
+}
+async function fingerprintIgnoredPath(worktreePath, relativePath, reserveBytes) {
+  const absolutePath = path2.join(worktreePath, relativePath);
+  try {
+    const stats = await lstat2(absolutePath);
+    if (stats.isSymbolicLink()) return `symlink:${await readlink(absolutePath)}`;
+    if (stats.isDirectory()) {
+      throw new Error(`ignored directory ${relativePath} was not expanded by Git`);
+    }
+    if (!stats.isFile()) return `other:${stats.mode}`;
+    reserveBytes(stats.size);
+    const executable = (stats.mode & 73) !== 0 ? "x" : "-";
+    return `file:${executable}:${await hashFileContents(absolutePath, stats.size)}`;
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+    if (code === "ENOENT" || code === "ENOTDIR") return "missing";
+    throw error;
+  }
+}
+async function captureIgnoredContent(worktreePath, exemptRoot) {
+  const listed = await listIgnoredWorkspacePaths(worktreePath);
+  if (!listed) return { paths: [], files: 0, bytes: 0, error: "ignored-path listing unavailable" };
+  const scanned = exemptRoot ? listed.filter((entry) => !isUnder(entry, exemptRoot)) : listed;
+  const { maxFiles, maxBytes } = ignoredContentScanLimits;
+  if (scanned.length > maxFiles) {
+    return { paths: listed, files: 0, bytes: 0, error: `more than ${maxFiles} ignored files` };
+  }
+  const fingerprints = /* @__PURE__ */ new Map();
+  let bytes = 0;
+  const reserveBytes = (size) => {
+    bytes += size;
+    if (bytes > maxBytes) throw new Error(`more than ${maxBytes} bytes of ignored files`);
+  };
+  let next = 0;
+  const worker = async () => {
+    while (next < scanned.length) {
+      const relativePath = scanned[next++];
+      fingerprints.set(
+        relativePath,
+        await fingerprintIgnoredPath(worktreePath, relativePath, reserveBytes)
+      );
+    }
+  };
+  try {
+    await Promise.all(Array.from({ length: SCAN_CONCURRENCY }, worker));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { paths: listed, files: fingerprints.size, bytes, error: message };
+  }
+  return { paths: listed, fingerprints, files: fingerprints.size, bytes };
+}
+function changedIgnoredPaths(before, after) {
+  const was = before?.fingerprints;
+  const now = after?.fingerprints;
+  if (!was || !now) return void 0;
+  const changed = /* @__PURE__ */ new Set();
+  for (const [entry, fingerprint] of was) if (now.get(entry) !== fingerprint) changed.add(entry);
+  for (const entry of now.keys()) if (!was.has(entry)) changed.add(entry);
+  return [...changed].sort();
+}
+
+// src/orchestrator/executors/fast-attempt-mutation-state.ts
+async function recordFastAttemptBaseline(worktreePath, provider, before) {
+  const ignoredBefore = await captureIgnoredContent(
+    worktreePath,
+    providerWorktreeStateRoot(provider)
+  );
+  return { worktreePath, provider, before, ignoredBefore };
+}
+async function deriveFastAttemptMutationState(baseline, outcome) {
+  const stateRoot = providerWorktreeStateRoot(baseline.provider);
+  const ignoredAfter = await captureIgnoredContent(baseline.worktreePath, stateRoot);
+  return deriveAttemptMutationState({
+    ...outcome,
+    providerStarted: true,
+    before: baseline.before,
+    stateRoot,
+    ignoredChangedPaths: changedIgnoredPaths(baseline.ignoredBefore, ignoredAfter)
+  });
+}
+async function attachFastAttemptMutationState(error, providerStarted, baseline) {
+  if (!error || typeof error !== "object") return;
+  let state = providerStarted ? "unknown" : "none-observed";
+  if (providerStarted && baseline) {
+    try {
+      const { before } = baseline;
+      const after = await captureWorkspaceDeliverySnapshot(baseline.worktreePath, {
+        baselineHead: before.headSha,
+        baselineWorkspaceTreeSha: before.workspaceTreeSha,
+        includePaths: before.dirtyPaths
+      });
+      const failure = error;
+      state = await deriveFastAttemptMutationState(baseline, { failure, after });
+    } catch {
+      state = "unknown";
+    }
+  }
+  try {
+    error.attemptMutationState = state;
+  } catch {
+  }
+}
+function readAttemptMutationState(result) {
+  const carried = result.error?.attemptMutationState;
+  return result.attemptMutationState ?? (carried === "none-observed" || carried === "observed" || carried === "unknown" ? carried : void 0);
+}
+var RetryAttemptMutationGuard = class {
+  earlierAttemptMayHaveWorked = false;
+  /** Note a finished attempt before the next one starts. */
+  noteAttempt(result) {
+    if (result.attemptMutationState !== "none-observed") this.earlierAttemptMayHaveWorked = true;
+  }
+  /**
+   * Run one attempt. After an earlier attempt that may have worked, its
+   * no-work state, returned or thrown, reads unknown.
+   */
+  async track(run) {
+    try {
+      const outcome = await run();
+      this.settle(outcome.result);
+      return outcome;
+    } catch (error) {
+      if (error && typeof error === "object") this.settle(error);
+      throw error;
+    }
+  }
+  settle(target) {
+    if (this.earlierAttemptMayHaveWorked && target.attemptMutationState === "none-observed") {
+      target.attemptMutationState = "unknown";
+    }
+  }
+};
+
+// src/core/workspace-agent/provider-detection-config.ts
+var PROVIDER_DETECTION_CONFIG = {
+  /**
+   * Claude CLI - Passthrough mode
+   *
+   * Claude manages its own edit workflow and does not emit JSONL.
+   * We leave the prompt untouched and only use git status for detection.
+   */
+  claude: {
+    mode: "git-only",
+    emitsJsonl: false,
+    enforceFileTargets: false
+  },
+  /**
+   * Copilot CLI - Passthrough mode
+   *
+   * Copilot has its own native edit workflow.
+   * We avoid injecting JSONL instructions that would interfere.
+   */
+  copilot: {
+    mode: "git-only",
+    emitsJsonl: false,
+    enforceFileTargets: false
+  },
+  /**
+   * Cursor CLI - Git-only observation
+   *
+   * Cursor owns native disk edits. Git is the source of truth by default.
+   */
+  cursor: {
+    mode: "git-only",
+    emitsJsonl: false,
+    enforceFileTargets: false
+  },
+  /**
+   * Gemini - Git-only observation
+   *
+   * Gemini manages native disk edits. Git is the source of truth by default.
+   */
+  gemini: {
+    mode: "git-only",
+    emitsJsonl: false,
+    enforceFileTargets: false
+  },
+  /**
+   * Codex (OpenAI) - Git-only observation
+   *
+   * Codex owns native disk edits. Git is the source of truth by default.
+   */
+  codex: {
+    mode: "git-only",
+    emitsJsonl: false,
+    enforceFileTargets: false
+  },
+  /**
+   * OpenCode - Git plus provider-native structured events
+   *
+   * OpenCode is a router CLI over many backend providers. Build parses its
+   * structured event stream for text, usage, cost, resolved model, and agent
+   * metadata, but does not inject the workspace JSONL edit protocol.
+   */
+  opencode: {
+    mode: "git-with-provider-events",
+    emitsJsonl: false,
+    enforceFileTargets: false,
+    usesProviderEvents: true
+  }
+};
+var DEFAULT_DETECTION_CONFIG = {
+  mode: "git-only",
+  emitsJsonl: false,
+  enforceFileTargets: false
+};
+var JSONL_VALIDATION_CONFIG = {
+  mode: "git-with-jsonl-hints",
+  // Validation-only opt-in: git remains truth; JSONL declarations are parsed only for comparison.
+  emitsJsonl: true,
+  enforceFileTargets: false
+};
+var VERTICAL_SLICE_FLAG_BY_PROVIDER = {
+  cursor: BUILD_CURSOR_LOCAL_VERTICAL_SLICE,
+  codex: BUILD_CODEX_LOCAL_VERTICAL_SLICE
+};
+var JSONL_VALIDATION_PROVIDERS = /* @__PURE__ */ new Set(["cursor", "codex"]);
+function isJsonlValidationEnabled(provider) {
+  if (!(readEnv(BUILD_JSONL_VALIDATION).value ?? false)) {
+    return false;
+  }
+  return JSONL_VALIDATION_PROVIDERS.has(provider);
+}
+function applyVerticalSliceDetectionOverride(baseProvider, config) {
+  const envKey = VERTICAL_SLICE_FLAG_BY_PROVIDER[baseProvider];
+  if (!envKey) return config;
+  const sliceEnabled = readEnv(envKey).value ?? true;
+  return !sliceEnabled && isJsonlValidationEnabled(baseProvider) ? JSONL_VALIDATION_CONFIG : config;
+}
+function getProviderDetectionMode(provider) {
+  const baseProvider = provider.split(":")[0] ?? provider;
+  const staticConfig = PROVIDER_DETECTION_CONFIG[baseProvider];
+  if (staticConfig) {
+    return applyVerticalSliceDetectionOverride(baseProvider, staticConfig);
+  }
+  try {
+    const providerConfig = ProviderRegistry.getProviderConfig(baseProvider);
+    const edits = providerConfig.workspace_edits;
+    if (!edits) {
+      return DEFAULT_DETECTION_CONFIG;
+    }
+    const mode = edits.mode === "structured" ? "git-with-jsonl-hints" : (
+      // passthrough + text-only default to git-only
+      "git-only"
+    );
+    return {
+      mode,
+      emitsJsonl: edits.inject_jsonl === true || mode === "git-with-jsonl-hints",
+      enforceFileTargets: edits.enforce_file_targets === true
+    };
+  } catch {
+    return DEFAULT_DETECTION_CONFIG;
+  }
+}
+function shouldInjectJsonlInstructions(provider) {
+  const config = getProviderDetectionMode(provider);
+  return config.emitsJsonl;
+}
+function shouldEnforceFileTargets(provider) {
+  const config = getProviderDetectionMode(provider);
+  return config.enforceFileTargets;
+}
+
+export {
+  providerWorktreeStateRoot,
+  scrubWorktreeCredentials,
+  captureIgnoredContent,
+  changedIgnoredPaths,
+  recordFastAttemptBaseline,
+  deriveFastAttemptMutationState,
+  attachFastAttemptMutationState,
+  readAttemptMutationState,
+  RetryAttemptMutationGuard,
+  getProviderDetectionMode,
+  shouldInjectJsonlInstructions,
+  shouldEnforceFileTargets
+};
+//# sourceMappingURL=chunk-666656AR.js.map

package/dist/chunk-67YRJPJO.js

@@ -0,0 +1,19 @@
+// src/core/providers/shared/streaming-policy.ts
+var TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var FALSY = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+var BUILD_PROVIDER_STREAMING_NAME = "BUILD_PROVIDER_STREAMING";
+function resolveProviderStreamingEnabled(env = process.env) {
+  const raw = env[BUILD_PROVIDER_STREAMING_NAME];
+  if (raw === void 0 || raw === "") return true;
+  const lower = raw.toLowerCase();
+  if (TRUTHY.has(lower)) return true;
+  if (FALSY.has(lower)) return false;
+  throw new Error(
+    `Invalid boolean value for ${BUILD_PROVIDER_STREAMING_NAME}: "${raw}". Expected one of: 1, true, yes, on, 0, false, no, off`
+  );
+}
+
+export {
+  resolveProviderStreamingEnabled
+};
+//# sourceMappingURL=chunk-67YRJPJO.js.map

package/dist/chunk-6CAU7VBA.js

@@ -0,0 +1,20 @@
+import {
+  loadConfigLayers
+} from "./chunk-C3DH3NCY.js";
+import {
+  resolveInheritanceModeFromLayers
+} from "./chunk-43OKHTW4.js";
+
+// src/core/config/resolve-inheritance.ts
+function resolveInheritanceMode(setting, cwd = process.cwd()) {
+  return resolveInheritanceModeFromLayers(setting, loadConfigLayers(cwd));
+}
+function resolveLaunchInheritance(scope, cwd = process.cwd()) {
+  return scope === "judge" ? { scope } : { scope, mode: resolveInheritanceMode(scope, cwd)?.value };
+}
+
+export {
+  resolveInheritanceMode,
+  resolveLaunchInheritance
+};
+//# sourceMappingURL=chunk-6CAU7VBA.js.map

package/dist/chunk-6CB3KJRY.js

@@ -0,0 +1,21 @@
+// src/utils/process-group-signal.ts
+function isSignalableProcessGroupId(pgid) {
+  return typeof pgid === "number" && Number.isSafeInteger(pgid) && pgid > 1;
+}
+function signalProcessGroup(pgid, signal) {
+  if (!isSignalableProcessGroupId(pgid)) {
+    throw Object.assign(
+      new Error(
+        `Refusing to signal process group ${String(pgid)}: ids must be integers greater than 1`
+      ),
+      { code: "EINVAL" }
+    );
+  }
+  return process.kill(-pgid, signal);
+}
+
+export {
+  isSignalableProcessGroupId,
+  signalProcessGroup
+};
+//# sourceMappingURL=chunk-6CB3KJRY.js.map

package/dist/chunk-6DBMALXL.js

@@ -0,0 +1,29 @@
+import {
+  isFamilyAlias
+} from "./chunk-FAZBRHGG.js";
+
+// src/core/providers/invocation/exact-model-selectors.ts
+var NON_CONCRETE_MODEL_SELECTORS = /* @__PURE__ */ new Set(["auto", "default"]);
+function isNonConcreteModelSelector(model, providerId) {
+  if (model === void 0) {
+    return false;
+  }
+  const normalized = model.trim().toLowerCase();
+  if (normalized.length === 0) {
+    return false;
+  }
+  if (NON_CONCRETE_MODEL_SELECTORS.has(normalized)) {
+    return true;
+  }
+  return providerId !== void 0 && isFamilyAlias(providerId, model);
+}
+function nonConcreteModelSelectorRefusalMessage(model) {
+  const display = model.trim() || model;
+  return `Model selector '${display}' is not a concrete model pin. Provider invoke requires an exact concrete model id (not a default sentinel such as 'auto' or 'default', and not a provider model family alias the provider CLI resolves itself).`;
+}
+
+export {
+  isNonConcreteModelSelector,
+  nonConcreteModelSelectorRefusalMessage
+};
+//# sourceMappingURL=chunk-6DBMALXL.js.map