@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-TGXXYDL4.js

@@ -0,0 +1,1012 @@
+import {
+  resolveCursorObservedModelId
+} from "./chunk-7HPCIOMA.js";
+import {
+  appendWorkspaceEditInstructions,
+  extractFileTargets,
+  generateMinimalAdaptation,
+  generateWorkspaceAgentHeader,
+  injectBacklogReviewContract
+} from "./chunk-KUEWV2JH.js";
+import {
+  familyFlagshipModel,
+  isFamilyAlias
+} from "./chunk-FAZBRHGG.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  EFFORT_ORDER,
+  formatReasoningEffortLevelForUser,
+  formatReasoningEffortLevelsForUser,
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  findClosestMatch
+} from "./chunk-O26L6F7F.js";
+import {
+  debugLog
+} from "./chunk-7VRJHTGZ.js";
+import {
+  sanitizeString
+} from "./chunk-CPSVQR2I.js";
+
+// src/core/providers/reasoning-effort/model-capabilities.ts
+function normalizeModelId(value) {
+  return value.trim().toLowerCase().replace(/\[[^\]]*\]\s*$/, "").trim();
+}
+function findRegistryModel(providerId, model) {
+  try {
+    const config = ProviderRegistry.getProviderConfig(providerId);
+    const modelId = model?.trim() || config.models.default;
+    if (isFamilyAlias(providerId, modelId)) {
+      return familyFlagshipModel(providerId, modelId);
+    }
+    let resolvedModelId = modelId;
+    try {
+      resolvedModelId = ProviderRegistry.resolveModel(providerId, modelId);
+    } catch {
+      resolvedModelId = modelId;
+    }
+    const target = normalizeModelId(resolvedModelId);
+    return config.models.available.find((candidate) => {
+      const candidateIds = [candidate.id, candidate.full_name].filter(
+        (id) => typeof id === "string" && id.trim().length > 0
+      );
+      return candidateIds.some((id) => normalizeModelId(id) === target);
+    });
+  } catch {
+    return void 0;
+  }
+}
+function isUnknownRegistryModel(providerId, model) {
+  return findRegistryModel(providerId, model) === void 0;
+}
+function closestOfferedModelId(providerId, model) {
+  try {
+    return findClosestMatch(model, ProviderRegistry.getOfferedModels(providerId));
+  } catch {
+    return void 0;
+  }
+}
+function getModelReasoningEffortLevels(providerId, model) {
+  const levels = getModelAdvertisedReasoningEffortLevels(providerId, model);
+  if (!levels || levels.length === 0) return void 0;
+  return levels.filter(
+    (level) => EFFORT_ORDER.includes(level)
+  );
+}
+function getModelAdvertisedReasoningEffortLevels(providerId, model) {
+  const levels = findRegistryModel(providerId, model)?.reasoning_effort_levels;
+  return levels?.length ? levels : void 0;
+}
+function getModelNativeReasoningEffortLevels(providerId, model) {
+  return (getModelAdvertisedReasoningEffortLevels(providerId, model) ?? []).filter(
+    (level) => !EFFORT_ORDER.includes(level)
+  );
+}
+function modelSupportsAdaptiveThinking(providerId, model) {
+  const modelInfo = findRegistryModel(providerId, model);
+  if (!modelInfo) return false;
+  const capabilities = new Set(
+    (modelInfo.capabilities ?? []).map(
+      (capability) => capability.trim().toLowerCase().replace(/-/g, "_")
+    )
+  );
+  return modelInfo.thinking?.adaptive === true || capabilities.has("adaptive_thinking");
+}
+function modelSupportsManualThinkingBudget(providerId, model) {
+  return modelManualThinkingBudgetSupport(providerId, model) === true;
+}
+function modelManualThinkingBudgetSupport(providerId, model) {
+  const modelInfo = findRegistryModel(providerId, model);
+  if (!modelInfo) return void 0;
+  return modelInfo.thinking?.budget_tokens_supported;
+}
+
+// src/core/providers/reasoning-effort/resolver.ts
+function defaultModelLevelLookup(providerId, model) {
+  return getModelReasoningEffortLevels(providerId, model);
+}
+var PROVIDER_REASONING_REGISTRY = {
+  // With no model pin (`auto`) the Codex CLI picks the model, so Build cannot
+  // know its levels; pass the full ladder through and let Codex decide, as the
+  // Codex config reference says levels depend on the model.
+  codex: {
+    mode: "native",
+    supportedLevels: ["low", "medium", "high", "xhigh"],
+    deferDefaultModelCapability: true,
+    deferredSupportedLevels: ["low", "medium", "high", "xhigh", "max"]
+  },
+  opencode: {
+    mode: "variant_mapping",
+    variantMap: {
+      low: "minimal",
+      medium: "medium",
+      high: "high",
+      xhigh: "max",
+      max: "max"
+    }
+  },
+  claude: {
+    mode: "native",
+    supportedLevels: ["low", "medium", "high", "xhigh", "max"]
+  },
+  gemini: {
+    mode: "prompt_hint",
+    supportedLevels: ["low", "medium", "high", "xhigh"],
+    promptTemplate: "Apply {effort} reasoning effort: think carefully, validate assumptions, and reason step-by-step before producing output."
+  },
+  // Pi's --thinking accepts off|minimal|low|medium|high|xhigh|max, a superset of
+  // Build's five levels, so every level maps natively and exactly. Whether the
+  // configured backend honors it is a backend property, not a Pi one.
+  pi: {
+    mode: "native",
+    supportedLevels: ["low", "medium", "high", "xhigh", "max"]
+  },
+  cursor: { mode: "unsupported" },
+  copilot: {
+    mode: "native",
+    supportedLevels: ["low", "medium", "high", "xhigh"]
+  },
+  grok: {
+    mode: "unsupported",
+    modelCapabilityOptIn: true,
+    deferDefaultModelCapability: true,
+    deferredSupportedLevels: ["low", "medium", "high", "xhigh"]
+  }
+};
+function resolveProviderNativeReasoningEffort(providerId, requested, model) {
+  const wanted = requested.trim().toLowerCase().replace(/[_\s]/g, "-");
+  if (!wanted || normalizeReasoningEffortInput(wanted)) return void 0;
+  return getModelNativeReasoningEffortLevels(providerId, model).find(
+    (level) => level.trim().toLowerCase() === wanted
+  );
+}
+function unknownModelReasoningEffortMessage(providerId, requestedLabel, model) {
+  const entry = PROVIDER_REASONING_REGISTRY[providerId];
+  if (!model || !entry?.modelCapabilityOptIn || !isUnknownRegistryModel(providerId, model)) {
+    return void 0;
+  }
+  const suggestion = closestOfferedModelId(providerId, model);
+  return `Reasoning effort "${requestedLabel}" cannot be checked for ${providerId} model "${model}": the model is not in the model registry, so its effort levels are unknown. ` + (suggestion && suggestion !== model ? `Did you mean "${suggestion}"? ` : "") + "Check the model id, or omit the effort level.";
+}
+function findClosestLevel(requested, supported) {
+  if (supported.includes(requested)) return requested;
+  const idx = EFFORT_ORDER.indexOf(requested);
+  for (let i = idx - 1; i >= 0; i--) {
+    const level = EFFORT_ORDER[i];
+    if (level && supported.includes(level)) return level;
+  }
+  for (let i = idx + 1; i < EFFORT_ORDER.length; i++) {
+    const level = EFFORT_ORDER[i];
+    if (level && supported.includes(level)) return level;
+  }
+  return "medium";
+}
+function resolveFallbackLevel(requested, supported) {
+  if (!supported || supported.includes(requested)) {
+    return { level: requested, exact: true };
+  }
+  return { level: findClosestLevel(requested, supported), exact: false };
+}
+function buildFallbackDowngradeWarning(providerId, requested, resolved, supported) {
+  const requestedLabel = formatReasoningEffortLevelForUser(requested, providerId);
+  const resolvedLabel = formatReasoningEffortLevelForUser(resolved, providerId);
+  const supportedLabels = supported ? formatReasoningEffortLevelsForUser(supported, providerId) : "";
+  return `[${providerId}] Reasoning effort "${requestedLabel}" is not supported. ` + (supportedLabels ? `Supported levels: ${supportedLabels}. ` : "") + `Using "${resolvedLabel}" instead.`;
+}
+function resolveReasoningEffortInternal(registry, providerId, requestedLevel, isExplicitRequest, model, modelLookup, options = {}) {
+  const entry = registry[providerId] ?? { mode: "unsupported" };
+  const modelLevels = model && modelLookup ? modelLookup(providerId, model) : void 0;
+  const shouldDeferDefaultModel = options.deferDefaultModelCapability === true && entry.deferDefaultModelCapability === true && (!model || model === "auto") && entry.deferredSupportedLevels;
+  if (shouldDeferDefaultModel) {
+    const canHonorExactly = shouldDeferDefaultModel.includes(requestedLevel);
+    const resolvedLevel = canHonorExactly ? requestedLevel : findClosestLevel(requestedLevel, shouldDeferDefaultModel);
+    return {
+      requestedLevel,
+      resolvedLevel,
+      outcome: canHonorExactly ? "deferred" : "downgraded",
+      isExplicitRequest,
+      supportedLevels: shouldDeferDefaultModel,
+      canHonorExactly,
+      ...canHonorExactly ? { deferred: true } : {},
+      ...canHonorExactly ? {} : { nativeParam: resolvedLevel },
+      warning: !canHonorExactly && isExplicitRequest ? buildFallbackDowngradeWarning(
+        providerId,
+        requestedLevel,
+        resolvedLevel,
+        shouldDeferDefaultModel
+      ) : void 0
+    };
+  }
+  const effectiveEntry = (entry.mode === "native" || entry.modelCapabilityOptIn) && modelLevels && modelLevels.length > 0 ? { mode: "native", supportedLevels: modelLevels } : entry;
+  switch (effectiveEntry.mode) {
+    case "native": {
+      const supported = effectiveEntry.supportedLevels ?? EFFORT_ORDER;
+      const canHonorExactly = supported.includes(requestedLevel);
+      if (canHonorExactly) {
+        return {
+          requestedLevel,
+          resolvedLevel: requestedLevel,
+          outcome: "applied",
+          isExplicitRequest,
+          supportedLevels: supported,
+          canHonorExactly: true,
+          nativeParam: requestedLevel
+        };
+      }
+      const closest = findClosestLevel(requestedLevel, supported);
+      const modelSuffix = model ? ` (model: ${model})` : "";
+      const requestedLabel = formatReasoningEffortLevelForUser(requestedLevel, providerId);
+      const supportedLabels = formatReasoningEffortLevelsForUser(supported, providerId);
+      const closestLabel = formatReasoningEffortLevelForUser(closest, providerId);
+      return {
+        requestedLevel,
+        resolvedLevel: closest,
+        outcome: "downgraded",
+        isExplicitRequest,
+        supportedLevels: supported,
+        canHonorExactly: false,
+        nativeParam: closest,
+        warning: isExplicitRequest ? `[${providerId}]${modelSuffix} Reasoning effort "${requestedLabel}" is not supported. Supported levels: ${supportedLabels}. Using "${closestLabel}" instead.` : void 0
+      };
+    }
+    case "variant_mapping": {
+      const modelDeclared = modelLevels && modelLevels.length > 0 ? modelLevels : void 0;
+      const supported = modelDeclared ?? entry.supportedLevels ?? (entry.variantMap ? Object.keys(entry.variantMap) : void 0);
+      const resolved = resolveFallbackLevel(requestedLevel, supported);
+      return {
+        requestedLevel,
+        resolvedLevel: resolved.level,
+        outcome: "fallback",
+        isExplicitRequest,
+        ...supported ? { supportedLevels: supported } : {},
+        canHonorExactly: resolved.exact,
+        variantMapping: modelDeclared ? resolved.level : entry.variantMap?.[resolved.level],
+        warning: !resolved.exact && isExplicitRequest ? buildFallbackDowngradeWarning(providerId, requestedLevel, resolved.level, supported) : void 0
+      };
+    }
+    case "prompt_hint": {
+      const supported = entry.supportedLevels;
+      const resolved = resolveFallbackLevel(requestedLevel, supported);
+      return {
+        requestedLevel,
+        resolvedLevel: resolved.level,
+        outcome: "fallback",
+        isExplicitRequest,
+        ...supported ? { supportedLevels: supported } : {},
+        canHonorExactly: resolved.exact,
+        fallbackHint: entry.promptTemplate?.replace(
+          "{effort}",
+          formatReasoningEffortLevelForUser(resolved.level, providerId)
+        ),
+        warning: !resolved.exact && isExplicitRequest ? buildFallbackDowngradeWarning(providerId, requestedLevel, resolved.level, supported) : void 0
+      };
+    }
+    default:
+      return {
+        requestedLevel,
+        resolvedLevel: requestedLevel,
+        outcome: "unsupported",
+        isExplicitRequest,
+        canHonorExactly: false,
+        warning: isExplicitRequest ? `[${providerId}] Reasoning effort "${formatReasoningEffortLevelForUser(
+          requestedLevel,
+          providerId
+        )}" is not supported by this provider and will have no effect. Providers with native effort support: codex, claude, copilot, pi. Grok honors effort only for models that advertise reasoning_effort_levels. Providers with documented fallback: opencode (variant mapping), gemini (prompt hint).` : void 0
+      };
+  }
+}
+function resolveReasoningEffort(providerId, requestedLevel, isExplicitRequest, model, options = {}) {
+  return resolveReasoningEffortInternal(
+    PROVIDER_REASONING_REGISTRY,
+    providerId,
+    requestedLevel,
+    isExplicitRequest,
+    model,
+    defaultModelLevelLookup,
+    options
+  );
+}
+function logReasoningEffortResolution(resolution, providerId) {
+  if (resolution.isExplicitRequest && resolution.warning) {
+    console.warn(resolution.warning);
+    return;
+  }
+  const levelStr = resolution.resolvedLevel !== resolution.requestedLevel ? `${resolution.requestedLevel}->${resolution.resolvedLevel}` : resolution.requestedLevel;
+  debugLog(
+    `[ReasoningEffort:${providerId}] outcome=${resolution.outcome} level=${levelStr} explicit=${resolution.isExplicitRequest}`
+  );
+}
+
+// src/core/providers/shared/prompt-mode.ts
+import { createHash } from "crypto";
+
+// src/core/providers/shared/prompt-strengthening.ts
+function strengthenAmbiguousLanguage(prompt) {
+  const operations = [];
+  const patterns = getAmbiguousLanguagePatterns();
+  const matchedDescriptions = [];
+  for (const { pattern, description } of patterns) {
+    if (clonePattern(pattern).test(prompt)) {
+      matchedDescriptions.push(description);
+    }
+  }
+  if (matchedDescriptions.length === 0) {
+    return { strengthened: prompt, operations };
+  }
+  if (/\b(write|generate|emit|produce)\b[^.\n]{0,40}\bcode\b/i.test(prompt)) {
+    return { strengthened: prompt, operations };
+  }
+  operations.push(...matchedDescriptions);
+  return {
+    strengthened: `${prompt}${buildExecutionFocusNote()}`,
+    operations
+  };
+}
+function buildExecutionFocusNote() {
+  return [
+    "",
+    "",
+    "---",
+    "EXECUTION EXPECTATION",
+    "This task expects working code, not only a plan or description.",
+    "Follow the task text above exactly as written; this note adds no new requirements.",
+    "---"
+  ].join("\n");
+}
+function clonePattern(regex) {
+  return new RegExp(regex.source, regex.flags);
+}
+function getAmbiguousLanguagePatterns() {
+  return [
+    {
+      pattern: /\b(implement|add|create)[ \t]+/gi,
+      description: "Detected ambiguous implementation verb; appended execution expectation"
+    },
+    {
+      pattern: /\b(refactor|update|modify)[ \t]+/gi,
+      description: "Detected ambiguous refactoring verb; appended execution expectation"
+    },
+    {
+      pattern: /\b(fix|resolve)[ \t]+/gi,
+      description: "Detected ambiguous bug-fix verb; appended execution expectation"
+    }
+  ];
+}
+function generateFileModificationChecklist(targetFiles) {
+  if (targetFiles.length < 2) {
+    return "";
+  }
+  const checklistItems = targetFiles.map((file, idx) => `${idx + 1}. [ ] ${file}`);
+  const footer = "Address each file the task requires; if a file needs no change, briefly explain why.";
+  return [
+    "",
+    "---",
+    "RELEVANT FILES (edit those the task requires):",
+    ...checklistItems,
+    "",
+    footer,
+    "---",
+    ""
+  ].join("\n");
+}
+function generateImplementationDirective(executionIntent = "code") {
+  if (executionIntent === "analysis") {
+    return "";
+  }
+  const lines = [
+    "---",
+    "EXECUTION MODE: IMPLEMENTATION",
+    "- Generate working code",
+    "- Emit workspace edits",
+    "---"
+  ];
+  return `
+
+${lines.join("\n")}`;
+}
+function generatePreviousErrorDirective(previousError) {
+  const categoryLabel = {
+    timeout: "Timeout/Deadline",
+    auth: "Authentication/Authorization",
+    syntax: "Syntax/Parse Error",
+    resource: "Resource Exhaustion",
+    unknown: "Unknown Error"
+  }[previousError.category];
+  const lines = [];
+  lines.push("---");
+  lines.push("RETRY CONTEXT: Previous iteration failed");
+  lines.push(
+    `Iteration ${previousError.iteration} failed with error: ${sanitizeString(previousError.message)}`
+  );
+  lines.push(`Error category: ${categoryLabel}`);
+  if (previousError.hint) {
+    lines.push(`Recovery hint: ${sanitizeString(previousError.hint)}`);
+  }
+  lines.push("");
+  lines.push("Adjust your approach to address this failure.");
+  lines.push("---");
+  return `
+
+${lines.join("\n")}`;
+}
+function strengthenPrompt(prompt, options = {}) {
+  const { executionIntent = "code", targetFiles: explicitTargets = [], previousError } = options;
+  const allOperations = [];
+  let strengthened = prompt;
+  if (previousError) {
+    const errorDirective = generatePreviousErrorDirective(previousError);
+    if (errorDirective) {
+      strengthened += errorDirective;
+      allOperations.push(
+        `Added retry context for iteration ${previousError.iteration} (${previousError.category} error)`
+      );
+    }
+  }
+  if (executionIntent !== "analysis") {
+    const langResult = strengthenAmbiguousLanguage(strengthened);
+    strengthened = langResult.strengthened;
+    allOperations.push(...langResult.operations);
+  }
+  const extractedTargets = extractFileTargets(strengthened);
+  const targetFiles = Array.from(/* @__PURE__ */ new Set([...extractedTargets, ...explicitTargets]));
+  if (executionIntent !== "analysis" && targetFiles.length > 1) {
+    const checklist = generateFileModificationChecklist(targetFiles);
+    if (checklist) {
+      strengthened += checklist;
+      allOperations.push(`Added file checklist for ${targetFiles.length} targets`);
+    }
+  }
+  if (executionIntent !== "analysis") {
+    const directive = generateImplementationDirective(executionIntent);
+    if (directive) {
+      strengthened += directive;
+      allOperations.push("Added execution mode directive");
+    }
+  }
+  return {
+    strengthened,
+    operations: allOperations,
+    targetFiles
+  };
+}
+
+// src/core/providers/shared/prompt-mode.ts
+var MODE_DEFAULTS = {
+  passthrough: {
+    injection: {
+      header: false,
+      fileSection: false,
+      protocol: false,
+      protocolExamples: false,
+      strengthen: false,
+      minimalGuidance: false
+    },
+    edit: {
+      injectJsonlInstructions: false,
+      parseJsonl: "best-effort",
+      // Still parse if provider happens to emit JSONL
+      enforceFileTargets: false
+    }
+  },
+  enhanced: {
+    injection: {
+      header: true,
+      fileSection: true,
+      protocol: true,
+      protocolExamples: true,
+      strengthen: false,
+      minimalGuidance: false
+    },
+    edit: {
+      injectJsonlInstructions: true,
+      parseJsonl: "best-effort",
+      enforceFileTargets: true
+    }
+  },
+  strengthened: {
+    injection: {
+      header: true,
+      fileSection: true,
+      protocol: true,
+      protocolExamples: true,
+      strengthen: true,
+      minimalGuidance: false
+    },
+    edit: {
+      injectJsonlInstructions: true,
+      parseJsonl: "best-effort",
+      enforceFileTargets: true
+    }
+  },
+  minimal: {
+    injection: {
+      header: true,
+      fileSection: false,
+      protocol: true,
+      protocolExamples: false,
+      strengthen: false,
+      minimalGuidance: true
+    },
+    edit: {
+      injectJsonlInstructions: true,
+      parseJsonl: "best-effort",
+      enforceFileTargets: false
+      // Minimal mode is more permissive
+    }
+  }
+};
+function applyWorkspaceMode(prompt, options) {
+  const {
+    mode,
+    provider,
+    executionIntent = "code",
+    targetFiles: explicitTargets = [],
+    injectionOverrides = {},
+    editOverrides = {},
+    projectRoot
+  } = options;
+  const defaults = MODE_DEFAULTS[mode];
+  const injection = { ...defaults.injection, ...injectionOverrides };
+  const editContract = { ...defaults.edit, ...editOverrides };
+  const operations = [];
+  let adapted = prompt;
+  let completionSignalVariant;
+  const extractedTargets = extractFileTargets(prompt);
+  const targetFiles = Array.from(/* @__PURE__ */ new Set([...extractedTargets, ...explicitTargets]));
+  if (mode === "passthrough") {
+    operations.push("Passthrough mode - no modifications");
+    return buildResult(prompt, adapted, mode, targetFiles, operations, editContract);
+  }
+  const beforeContract = adapted;
+  adapted = injectBacklogReviewContract(adapted, targetFiles);
+  if (adapted !== beforeContract) {
+    operations.push("Injected backlog review contract (P2: deterministic review behavior)");
+  }
+  if (injection.minimalGuidance) {
+    if (injection.header) {
+      const header = generateWorkspaceAgentHeader(provider, executionIntent);
+      adapted = `${header}
+
+${adapted}`;
+      operations.push(`Added ${provider} workspace agent header`);
+    }
+    const minimalGuidance = generateMinimalAdaptation({
+      executionIntent,
+      targetFiles
+    });
+    adapted = `${minimalGuidance}
+
+${adapted}`;
+    operations.push("Applied minimal adaptation guidance");
+    if (injection.protocol) {
+      const protocolResult = appendWorkspaceEditInstructions(adapted, {
+        targetFiles,
+        executionIntent,
+        includeExamples: false,
+        projectRoot
+      });
+      adapted = protocolResult.text;
+      completionSignalVariant = protocolResult.completionSignalVariant;
+      operations.push("Added workspace edit protocol (minimal, no examples)");
+    }
+    return buildResult(
+      prompt,
+      adapted,
+      mode,
+      targetFiles,
+      operations,
+      editContract,
+      completionSignalVariant
+    );
+  }
+  if (injection.strengthen) {
+    const strengthResult = strengthenPrompt(adapted, {
+      executionIntent,
+      targetFiles,
+      providerName: provider
+    });
+    adapted = strengthResult.strengthened;
+    operations.push(...strengthResult.operations);
+  }
+  if (injection.header) {
+    const header = generateWorkspaceAgentHeader(provider, executionIntent);
+    adapted = `${header}
+
+${adapted}`;
+    operations.push(`Added ${provider} workspace agent header`);
+  }
+  if (injection.fileSection && targetFiles.length > 0) {
+    const separator = "=".repeat(60);
+    const fileSection = [
+      "",
+      separator,
+      targetFiles.length === 1 ? "TARGET FILE:" : "TARGET FILES:",
+      ...targetFiles.map((f) => `  - ${f}`),
+      separator,
+      ""
+    ].join("\n");
+    adapted += fileSection;
+    operations.push(`Added file target section (${targetFiles.length} files)`);
+  }
+  if (injection.protocol) {
+    const protocolResult = appendWorkspaceEditInstructions(adapted, {
+      targetFiles,
+      executionIntent,
+      includeExamples: injection.protocolExamples,
+      projectRoot
+    });
+    adapted = protocolResult.text;
+    completionSignalVariant = protocolResult.completionSignalVariant;
+    operations.push(
+      `Added workspace edit protocol${injection.protocolExamples ? " with examples" : ""}`
+    );
+  }
+  return buildResult(
+    prompt,
+    adapted,
+    mode,
+    targetFiles,
+    operations,
+    editContract,
+    completionSignalVariant
+  );
+}
+function buildResult(original, adapted, mode, targetFiles, operations, editContract, completionSignalVariant) {
+  const hash = createHash("sha256").update(adapted).digest("hex").slice(0, 16);
+  return {
+    original,
+    adapted,
+    mode,
+    targetFiles,
+    operations,
+    editContract,
+    completionSignalVariant,
+    adaptedHash: hash,
+    lengths: {
+      original: original.length,
+      adapted: adapted.length,
+      delta: adapted.length - original.length
+    }
+  };
+}
+function isValidWorkspaceMode(value) {
+  return ["passthrough", "enhanced", "strengthened", "minimal"].includes(value);
+}
+function getProviderDefaultMode(_provider) {
+  return "passthrough";
+}
+var MODE_ORDER = {
+  passthrough: 0,
+  minimal: 1,
+  enhanced: 2,
+  strengthened: 3
+};
+var PROVIDER_MODE_CONSTRAINTS = {
+  claude: {
+    supportedModes: ["passthrough"],
+    defaultMode: "passthrough",
+    maxSafeMode: "passthrough"
+  },
+  cursor: {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "passthrough",
+    maxSafeMode: "enhanced"
+  },
+  codex: {
+    supportedModes: ["passthrough"],
+    defaultMode: "passthrough",
+    maxSafeMode: "passthrough"
+  },
+  gemini: {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "passthrough",
+    maxSafeMode: "enhanced"
+  },
+  copilot: {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "passthrough",
+    maxSafeMode: "enhanced"
+  },
+  opencode: {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "passthrough",
+    maxSafeMode: "enhanced"
+  },
+  grok: {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "passthrough",
+    maxSafeMode: "enhanced"
+  }
+};
+function getProviderModeConstraints(provider) {
+  const normalized = provider.toLowerCase();
+  return PROVIDER_MODE_CONSTRAINTS[normalized] ?? {
+    supportedModes: ["passthrough", "enhanced", "minimal"],
+    defaultMode: "passthrough",
+    maxSafeMode: "enhanced"
+  };
+}
+function clampToMaxSafeMode(mode, constraints) {
+  const modeOrder = MODE_ORDER[mode] ?? 0;
+  const maxOrder = MODE_ORDER[constraints.maxSafeMode] ?? 0;
+  if (modeOrder > maxOrder) {
+    return { mode: constraints.maxSafeMode, clamped: true };
+  }
+  return { mode, clamped: false };
+}
+function resolveEffectiveMode(variantOverride, globalMode, provider) {
+  if (variantOverride) {
+    return variantOverride;
+  }
+  if (globalMode) {
+    return globalMode;
+  }
+  return getProviderDefaultMode(provider);
+}
+
+// src/core/variant-identifier.ts
+var WORKSPACE_PREFIX = "ws-";
+var CURSOR_PROFILE_PREFIX = "cursor-profile-";
+var EFFORT_PREFIX = "effort-";
+function parseEffortToken(part, acceptBare) {
+  if (!part.startsWith(EFFORT_PREFIX) && !acceptBare) return void 0;
+  return normalizeReasoningEffortInput(
+    part.startsWith(EFFORT_PREFIX) ? part.slice(EFFORT_PREFIX.length) : part
+  );
+}
+function formatTransportSegment(transport) {
+  return transport === "cli" || transport === "api" ? `+${transport}` : "";
+}
+function peelTransportSuffix(segment) {
+  const plusIdx = segment.lastIndexOf("+");
+  if (plusIdx <= 0) {
+    return { base: segment };
+  }
+  const suffix = segment.slice(plusIdx + 1).toLowerCase();
+  if (suffix === "cli" || suffix === "api") {
+    return { base: segment.slice(0, plusIdx), transport: suffix };
+  }
+  return { base: segment };
+}
+function formatWorkspaceSegment(mode) {
+  return mode ? `:${WORKSPACE_PREFIX}${mode}` : "";
+}
+function formatCursorPromptProfileSegment(profile) {
+  return profile ? `:${CURSOR_PROFILE_PREFIX}${profile}` : "";
+}
+function isValidCursorPromptProfile(value) {
+  return value === "current" || value === "passthrough-steered" || value === "targets-only" || value === "discipline-only" || value === "protocol-native";
+}
+function normalizeVariantModel(provider, model) {
+  const trimmedModel = model?.trim();
+  if (!trimmedModel || !provider || trimmedModel === "default") {
+    return trimmedModel;
+  }
+  const providerId = provider.trim().toLowerCase();
+  if (providerId === "cursor") {
+    const resolved = resolveCursorObservedModelId(trimmedModel);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  const providerNormalizedModel = (
+    // quirks-allow: opencode display-alias normalization
+    providerId === "opencode" && trimmedModel.startsWith("blackbox/blackboxai/") ? trimmedModel.slice("blackbox/".length) : (
+      // quirks-allow: opencode display-alias normalization
+      providerId === "opencode" && trimmedModel.startsWith("blackbox-ai/moonshot/") ? `blackboxai/moonshotai/${trimmedModel.slice("blackbox-ai/moonshot/".length)}` : (
+        // quirks-allow: opencode display-alias normalization
+        providerId === "opencode" && trimmedModel.startsWith("blackbox-blackboxai-") ? trimmedModel.slice("blackbox-".length) : (
+          // quirks-allow: opencode display-alias normalization
+          providerId === "opencode" && trimmedModel.startsWith("blackbox-ai-moonshot-") ? `blackboxai-moonshotai-${trimmedModel.slice("blackbox-ai-moonshot-".length)}` : trimmedModel
+        )
+      )
+    )
+  );
+  const normalizedAliasInput = providerId === "claude" ? providerNormalizedModel.replace(/(\d)\.(\d)(?=$|[^0-9])/g, "$1-$2") : providerNormalizedModel;
+  try {
+    return ProviderRegistry.resolveModel(provider, normalizedAliasInput);
+  } catch {
+    return normalizedAliasInput;
+  }
+}
+function formatVariantModelSegment(model) {
+  return model.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "default";
+}
+function normalizeCanonicalExecutionMode(executionMode, fallback) {
+  const candidate = executionMode?.trim() || fallback?.trim();
+  return candidate === "local" || candidate === "cloud" || candidate === "cli" || candidate === "api" ? candidate === "cloud" ? "cloud" : "local" : "local";
+}
+function formatParsedEffortSegment(provider, effort) {
+  const level = normalizeReasoningEffortInput(effort);
+  return level ? `:effort-${formatReasoningEffortLevelForUser(level, provider)}` : "";
+}
+function canonicalizeVariantIdentifier(input) {
+  const rawVariant = input.variant.trim();
+  const explicitProvider = input.provider?.trim();
+  if (!rawVariant.includes(":") && !explicitProvider) {
+    return rawVariant;
+  }
+  const parsed = parseVariantIdentifier(rawVariant);
+  const provider = explicitProvider || parsed.provider;
+  const executionMode = normalizeCanonicalExecutionMode(input.executionMode, parsed.executionMode);
+  const model = normalizeVariantModel(
+    provider,
+    input.resolvedModel?.trim() || input.model?.trim() || parsed.model
+  ) ?? (provider ? "default" : void 0);
+  if (!provider || !model) {
+    return rawVariant;
+  }
+  const effortSegment = formatParsedEffortSegment(provider, parsed.reasoningEffort);
+  const workspaceSegment = formatWorkspaceSegment(
+    input.workspaceModeRequested ?? parsed.workspaceModeRequested
+  );
+  const cursorPromptProfileSegment = formatCursorPromptProfileSegment(
+    input.cursorPromptProfile ?? parsed.cursorPromptProfile
+  );
+  const transportSegment = formatTransportSegment(input.transport ?? parsed.transport);
+  return `${provider}:${formatVariantModelSegment(model)}${effortSegment}:${executionMode}${cursorPromptProfileSegment}${workspaceSegment}${transportSegment}`;
+}
+function formatVariantIdentifier(config) {
+  const model = normalizeVariantModel(config.provider, config.model) ?? "default";
+  const mode = config.executionMode ?? "local";
+  const effortSegment = config.modelReasoningEffort && config.modelReasoningEffortSource !== "configured" ? `:effort-${formatReasoningEffortLevelForUser(config.modelReasoningEffort, config.provider)}` : "";
+  const cursorPromptProfileSegment = formatCursorPromptProfileSegment(config.cursorPromptProfile);
+  const workspaceSegment = formatWorkspaceSegment(config.workspaceModeRequested);
+  const transportSegment = formatTransportSegment(config.transport);
+  return `${config.provider}:${formatVariantModelSegment(model)}${effortSegment}:${mode}${cursorPromptProfileSegment}${workspaceSegment}${transportSegment}`;
+}
+function formatVariantIdentifierFromResult(result) {
+  const rawVariant = typeof result.variant === "string" ? result.variant.trim() : "";
+  if (rawVariant.length > 0) {
+    const canonical = canonicalizeVariantIdentifier({
+      variant: rawVariant,
+      provider: result.provider,
+      model: result.model,
+      resolvedModel: result.resolvedModel,
+      executionMode: result.executionMode,
+      workspaceModeRequested: result.workspaceModeRequested,
+      cursorPromptProfile: result.cursorPromptProfile
+    });
+    if (isCanonicalVariantKey(canonical)) {
+      return canonical;
+    }
+  }
+  if (result.provider) {
+    const model = normalizeVariantModel(result.provider, result.resolvedModel || result.model) || "default";
+    const mode = result.executionMode ?? "local";
+    const cursorPromptProfileSegment = formatCursorPromptProfileSegment(result.cursorPromptProfile);
+    const workspaceSegment = formatWorkspaceSegment(result.workspaceModeRequested);
+    return `${result.provider}:${formatVariantModelSegment(model)}:${mode}${cursorPromptProfileSegment}${workspaceSegment}`;
+  }
+  return rawVariant;
+}
+function formatVariantIdentifierForDisplay(variantId) {
+  const trimmed = variantId.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  const parsed = parseVariantIdentifier(trimmed);
+  if (!parsed.provider) {
+    return trimmed;
+  }
+  const effortSegment = formatParsedEffortSegment(parsed.provider, parsed.reasoningEffort);
+  const executionModeSegment = parsed.executionMode && parsed.executionMode !== "local" ? `:${parsed.executionMode}` : "";
+  const transportSegment = formatTransportSegment(parsed.transport);
+  if (!parsed.model) {
+    return `${parsed.provider}${effortSegment}${executionModeSegment}${transportSegment}`;
+  }
+  return `${parsed.provider}:${parsed.model}${effortSegment}${executionModeSegment}${transportSegment}`;
+}
+function normalizeForReconciliation(variantId) {
+  const trimmed = variantId.trim();
+  if (!trimmed) return trimmed;
+  return formatVariantIdentifierForDisplay(canonicalizeVariantIdentifier({ variant: trimmed }));
+}
+function parseVariantIdentifier(variantId, options) {
+  const parts = variantId.split(":");
+  let transport;
+  const lastSegment = parts.at(-1);
+  if (parts.length >= 1 && lastSegment) {
+    const peeled = peelTransportSuffix(lastSegment);
+    if (peeled.transport) {
+      transport = peeled.transport;
+      if (peeled.base.length > 0) {
+        parts[parts.length - 1] = peeled.base;
+      } else {
+        parts.pop();
+      }
+    }
+  }
+  let workspaceModeRequested;
+  const workspaceSuffix = parts.at(-1);
+  if (parts.length >= 2 && workspaceSuffix?.startsWith(WORKSPACE_PREFIX)) {
+    const candidate = workspaceSuffix.slice(WORKSPACE_PREFIX.length);
+    if (isValidWorkspaceMode(candidate)) {
+      workspaceModeRequested = candidate;
+      parts.pop();
+    }
+  }
+  let cursorPromptProfile;
+  const cursorProfileSuffix = parts.at(-1);
+  if (parts.length >= 2 && cursorProfileSuffix?.startsWith(CURSOR_PROFILE_PREFIX)) {
+    const candidate = cursorProfileSuffix.slice(CURSOR_PROFILE_PREFIX.length);
+    if (isValidCursorPromptProfile(candidate)) {
+      cursorPromptProfile = candidate;
+      parts.pop();
+    }
+  }
+  const provider = parts[0] || void 0;
+  const last = parts.at(-1);
+  const executionMode = parts.length >= 2 && (last === "local" || last === "cloud" || last === "cli" || last === "api") ? last === "cloud" ? "cloud" : "local" : void 0;
+  const modelEnd = executionMode ? parts.length - 1 : parts.length;
+  let reasoningEffort;
+  const modelParts = parts.slice(1, Math.max(1, modelEnd)).filter((part) => {
+    const normalizedEffort = parseEffortToken(part, options?.acceptBareEffort);
+    if (normalizedEffort) {
+      reasoningEffort = normalizedEffort;
+      return false;
+    }
+    return true;
+  });
+  const joinedModel = modelParts.join(":").trim();
+  const model = joinedModel.length > 0 ? joinedModel : void 0;
+  return {
+    provider,
+    model,
+    executionMode,
+    reasoningEffort,
+    workspaceModeRequested,
+    cursorPromptProfile,
+    transport
+  };
+}
+function toParseableVariantSpec(serialized) {
+  const parsed = parseVariantIdentifier(serialized);
+  if (!parsed.provider) {
+    return serialized;
+  }
+  const modelPart = parsed.model ? `:${parsed.model}` : "";
+  const effortPart = parsed.reasoningEffort ? `:effort-${parsed.reasoningEffort}` : "";
+  const mode = parsed.executionMode ?? "local";
+  const transportPart = parsed.transport ? `+${parsed.transport}` : "";
+  return `${parsed.provider}${modelPart}${effortPart}:${mode}${transportPart}`;
+}
+function isCanonicalVariantKey(variantId) {
+  const parsed = parseVariantIdentifier(variantId);
+  return Boolean(parsed.provider) && Boolean(parsed.model) && parsed.executionMode !== void 0;
+}
+
+export {
+  isUnknownRegistryModel,
+  closestOfferedModelId,
+  getModelReasoningEffortLevels,
+  getModelNativeReasoningEffortLevels,
+  modelSupportsAdaptiveThinking,
+  modelSupportsManualThinkingBudget,
+  modelManualThinkingBudgetSupport,
+  PROVIDER_REASONING_REGISTRY,
+  resolveProviderNativeReasoningEffort,
+  unknownModelReasoningEffortMessage,
+  resolveReasoningEffort,
+  logReasoningEffortResolution,
+  strengthenPrompt,
+  applyWorkspaceMode,
+  isValidWorkspaceMode,
+  getProviderModeConstraints,
+  clampToMaxSafeMode,
+  resolveEffectiveMode,
+  parseEffortToken,
+  normalizeVariantModel,
+  canonicalizeVariantIdentifier,
+  formatVariantIdentifier,
+  formatVariantIdentifierFromResult,
+  formatVariantIdentifierForDisplay,
+  normalizeForReconciliation,
+  parseVariantIdentifier,
+  toParseableVariantSpec,
+  isCanonicalVariantKey
+};
+//# sourceMappingURL=chunk-TGXXYDL4.js.map