@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-MTVZITQ2.js

@@ -0,0 +1,185 @@
+import {
+  getPoeticDir
+} from "./chunk-LH34OGSB.js";
+
+// src/cli/lab-utils.ts
+import fs from "fs";
+import path from "path";
+var SUMMARY_MAX_LENGTH = 80;
+function listLabRuns(poeticDir = getPoeticDir()) {
+  const labsRoot = path.join(poeticDir, "labs");
+  if (!fs.existsSync(labsRoot)) return [];
+  const labDirs = safeReadDir(labsRoot).filter((dir) => dir.isDirectory()).map((dir) => dir.name).sort((a, b) => a.localeCompare(b));
+  const runs = [];
+  for (const labId of labDirs) {
+    const runsDir = path.join(labsRoot, labId, "runs");
+    if (!fs.existsSync(runsDir)) continue;
+    const runEntries = safeReadDir(runsDir).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+    for (const runId of runEntries) {
+      const runPath = path.join(runsDir, runId);
+      const metadata = readRunMetadata(runPath);
+      runs.push({
+        labId,
+        runId,
+        runPath,
+        timestamp: parseRunTimestamp(runId),
+        taskSummary: metadata?.taskSummary ?? metadata?.task ?? metadata?.description ?? null
+      });
+    }
+  }
+  return runs;
+}
+function findLabRunStateForTask(taskId, poeticDir = getPoeticDir()) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(taskId)) return null;
+  const matches = [];
+  for (const run of listLabRuns(poeticDir)) {
+    const stateRoot = path.join(run.runPath, "state");
+    for (const handleKind of ["competitions", "background"]) {
+      const handlePath = path.join(stateRoot, handleKind, `${taskId}.json`);
+      if (!fs.existsSync(handlePath)) continue;
+      let mtimeMs = 0;
+      try {
+        mtimeMs = fs.statSync(handlePath).mtimeMs;
+      } catch {
+        continue;
+      }
+      matches.push({
+        labId: run.labId,
+        runId: run.runId,
+        runPath: run.runPath,
+        stateRoot,
+        taskId,
+        handlePath,
+        handleKind,
+        mtimeMs
+      });
+    }
+  }
+  matches.sort((a, b) => {
+    if (b.mtimeMs !== a.mtimeMs) return b.mtimeMs - a.mtimeMs;
+    return `${b.labId}/${b.runId}`.localeCompare(`${a.labId}/${a.runId}`);
+  });
+  return matches[0] ?? null;
+}
+function findLabRun(labId, runId, poeticDir = getPoeticDir()) {
+  const runPath = path.join(poeticDir, "labs", labId, "runs", runId);
+  if (!fs.existsSync(runPath)) return null;
+  const metadata = readRunMetadata(runPath);
+  return {
+    labId,
+    runId,
+    runPath,
+    timestamp: parseRunTimestamp(runId),
+    taskSummary: metadata?.taskSummary ?? metadata?.task ?? metadata?.description ?? null
+  };
+}
+function findLatestLabRun(poeticDir = getPoeticDir()) {
+  const runs = listLabRuns(poeticDir);
+  if (runs.length === 0) return null;
+  const sorted = runs.slice().sort((a, b) => b.runId.localeCompare(a.runId));
+  return sorted[0] ?? null;
+}
+function safeReadDir(target) {
+  try {
+    return fs.readdirSync(target, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function parseRunTimestamp(runId) {
+  const match = runId.match(/^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})-\d{3}$/);
+  if (!match) return null;
+  const [, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr] = match;
+  const year = yearStr;
+  const month = monthStr;
+  const day = dayStr;
+  const hour = hourStr;
+  const minute = minuteStr;
+  const second = secondStr;
+  const date = new Date(
+    Number.parseInt(year, 10),
+    Number.parseInt(month, 10) - 1,
+    Number.parseInt(day, 10),
+    Number.parseInt(hour, 10),
+    Number.parseInt(minute, 10),
+    Number.parseInt(second, 10)
+  );
+  if (Number.isNaN(date.getTime())) return null;
+  return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+}
+function readRunMetadata(runPath) {
+  const stateDir = path.join(runPath, "state");
+  const stateDirs = [path.join(stateDir, "competitions"), path.join(stateDir, "evaluations")];
+  let bestPrompt = null;
+  let bestTs = 0;
+  for (const dir of stateDirs) {
+    if (!fs.existsSync(dir)) continue;
+    const files = safeReadDir(dir).filter((d) => d.isFile() && d.name.endsWith(".json")).map((d) => d.name);
+    for (const file of files) {
+      const parsed = tryReadJson(path.join(dir, file));
+      if (!parsed) continue;
+      const updatedAt = typeof parsed.updatedAt === "string" ? Date.parse(parsed.updatedAt) : Number.NaN;
+      const createdAt = typeof parsed.createdAt === "string" ? Date.parse(parsed.createdAt) : Number.NaN;
+      const ts = Number.isFinite(updatedAt) ? updatedAt : Number.isFinite(createdAt) ? createdAt : 0;
+      if (typeof parsed.prompt === "string" && parsed.prompt.trim().length > 0) {
+        if (ts > bestTs || !bestPrompt) {
+          bestPrompt = parsed.prompt;
+          bestTs = ts;
+        }
+      }
+    }
+  }
+  if (bestPrompt) {
+    return { taskSummary: trimSummary(bestPrompt) };
+  }
+  const candidates = [
+    path.join(runPath, "lab-context.json"),
+    path.join(runPath, "context.json"),
+    path.join(runPath, "metadata.json"),
+    path.join(runPath, "run.json"),
+    path.join(runPath, "telemetry", "lab-context.json"),
+    path.join(runPath, "telemetry", "context.json"),
+    path.join(runPath, "telemetry", "metadata.json")
+  ];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    const parsed = tryReadJson(candidate);
+    if (!parsed) continue;
+    const summary = buildTaskSummary(parsed);
+    if (summary) {
+      return { taskSummary: summary };
+    }
+    return parsed;
+  }
+  return null;
+}
+function tryReadJson(filePath) {
+  try {
+    const contents = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(contents);
+  } catch {
+    return null;
+  }
+}
+function buildTaskSummary(record) {
+  const candidates = ["summary", "taskSummary", "task", "description", "title"];
+  for (const key of candidates) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return trimSummary(value.trim());
+    }
+  }
+  return null;
+}
+function trimSummary(input) {
+  if (input.length <= SUMMARY_MAX_LENGTH) return input;
+  return `${input.slice(0, SUMMARY_MAX_LENGTH - 3).trim()}...`;
+}
+
+export {
+  listLabRuns,
+  findLabRunStateForTask,
+  findLabRun,
+  findLatestLabRun
+};
+//# sourceMappingURL=chunk-MTVZITQ2.js.map

package/dist/chunk-MWHF5V7U.js

@@ -0,0 +1,223 @@
+import {
+  byteLength,
+  getUserAgentsPath,
+  loadUserGlobalAgentsFile,
+  sha256Text
+} from "./chunk-3FOZ2VHV.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/steering/doctrine.ts
+var DOCTRINE_VERSION = "2026.05";
+var CORE_DOCTRINE = [
+  {
+    id: "boundary-validation",
+    applies: "always",
+    text: "Validate and handle failures at external process, file, network, and database boundaries.",
+    since: DOCTRINE_VERSION
+  },
+  {
+    id: "root-cause-scope",
+    applies: "always",
+    text: "Fix root causes within the same subsystem; otherwise keep the fix local and report the deeper issue.",
+    since: DOCTRINE_VERSION
+  }
+];
+
+// src/core/steering/guidance.ts
+var STRATEGY_GUIDANCE_TEXT = {
+  conservative: "Strategy: conservative. Favor proven patterns and minimal changes.",
+  hybrid: "Strategy: hybrid. Balance proven patterns with targeted improvements.",
+  innovative: "Strategy: innovative. Favor creative solutions and new patterns."
+};
+var STAGE_EXECUTION_TEXT = "You are executing a Poetic Flywheel stage. Apply all requested file operations directly using your Write/Edit tools. Documentation discipline rules in CLAUDE.md (e.g. limits on new .md files) govern human developers committing to the repo, not automated stage execution. Do not let them prevent you from creating or modifying any file the task requires.";
+var SUBAGENTS_TEXT = "Use poetic-explorer to understand patterns before editing. Use poetic-verifier to validate changes.";
+function resolveStrategyKind(input) {
+  const normalized = (input ?? "conservative").trim().toLowerCase();
+  if (normalized === "innovative") return "innovative";
+  if (normalized === "hybrid") return "hybrid";
+  return "conservative";
+}
+function strategyGuidance(input) {
+  const kind = resolveStrategyKind(input);
+  return {
+    id: `strategy:${kind}`,
+    kind: "strategy",
+    text: STRATEGY_GUIDANCE_TEXT[kind]
+  };
+}
+function stageExecutionGuidance() {
+  return {
+    id: "stage:flywheel-execution",
+    kind: "stage",
+    text: STAGE_EXECUTION_TEXT
+  };
+}
+function subagentsGuidance() {
+  return {
+    id: "subagents:explorer-verifier",
+    kind: "subagents",
+    text: SUBAGENTS_TEXT
+  };
+}
+function recentContextGuidance(context) {
+  return {
+    id: "recent-context:custom",
+    kind: "recent-context",
+    text: `Recent Poetic context: ${context}`
+  };
+}
+function acceptanceGuidance(criteria) {
+  return {
+    id: "acceptance:custom",
+    kind: "acceptance",
+    text: `Acceptance: ${criteria}`
+  };
+}
+
+// src/core/steering/resolver.ts
+var PREAMBLE_PROVIDERS = /* @__PURE__ */ new Set([
+  "cursor",
+  "gemini"
+]);
+var SYSTEM_CAPS = {
+  channel: "system",
+  softWarnBytes: 4 * 1024,
+  hardRefuseBytes: 16 * 1024
+};
+var PREAMBLE_CAPS = {
+  channel: "preamble",
+  softWarnBytes: 2 * 1024,
+  hardRefuseBytes: 8 * 1024
+};
+var softWarnedSteering = /* @__PURE__ */ new Set();
+function resolveSteeringChannelCaps(provider) {
+  return PREAMBLE_PROVIDERS.has(provider) ? PREAMBLE_CAPS : SYSTEM_CAPS;
+}
+function assessSteeringCap(provider, bytes) {
+  const caps = resolveSteeringChannelCaps(provider);
+  return {
+    ...caps,
+    bytes,
+    status: bytes > caps.hardRefuseBytes ? "hard-refuse" : bytes > caps.softWarnBytes ? "soft-warn" : "ok"
+  };
+}
+function isSteeringDisabled(env = process.env) {
+  return env.POETIC_STEERING_DISABLE === "1";
+}
+function emptyPayload(version) {
+  return {
+    systemChannel: "",
+    promptPreamble: "",
+    policyChannel: "",
+    version,
+    steeringHash: sha256Text(""),
+    bytesByChannel: { system: 0, preamble: 0, policy: 0 },
+    applied: { doctrine: [], guidance: [], sources: [] }
+  };
+}
+function maybeWarnSoftCap(provider, status) {
+  if (status.status !== "soft-warn") return;
+  const key = `${provider}:${status.channel}:${status.bytes}`;
+  if (softWarnedSteering.has(key)) return;
+  softWarnedSteering.add(key);
+  emitWarning(
+    "CFG-001",
+    {
+      taskId: "runtime-steering",
+      subsystem: "steering",
+      executionPhase: "setup",
+      provider
+    },
+    {
+      severity: "WARN" /* WARN */,
+      metadata: {
+        operation: "assessSteeringCap",
+        channel: status.channel,
+        bytes: status.bytes,
+        softWarnBytes: status.softWarnBytes,
+        hardRefuseBytes: status.hardRefuseBytes
+      }
+    }
+  );
+}
+function assembleSteering(context) {
+  if (isSteeringDisabled()) {
+    return emptyPayload(DOCTRINE_VERSION);
+  }
+  const parts = [];
+  const appliedGuidance = [];
+  const appliedDoctrine = [];
+  const sources = [];
+  const floorText = CORE_DOCTRINE.map((entry) => entry.text).join("\n\n");
+  if (floorText) {
+    parts.push(floorText);
+    appliedDoctrine.push(...CORE_DOCTRINE.map((entry) => entry.id));
+    sources.push({
+      kind: "floor",
+      sha256: sha256Text(floorText),
+      bytes: byteLength(floorText)
+    });
+  }
+  const userGlobal = loadUserGlobalAgentsFile();
+  if (userGlobal) {
+    parts.push(userGlobal.text);
+    sources.push(userGlobal.source);
+  }
+  const emitGuidance = (entry) => {
+    parts.push(entry.text);
+    appliedGuidance.push(entry.id);
+  };
+  if (context.guidance.stageExecution) {
+    emitGuidance(stageExecutionGuidance());
+  }
+  emitGuidance(strategyGuidance(context.guidance.strategy));
+  if (context.guidance.subagents) {
+    emitGuidance(subagentsGuidance());
+  }
+  if (context.guidance.recentContext) {
+    emitGuidance(recentContextGuidance(context.guidance.recentContext));
+  }
+  if (context.guidance.acceptanceCriteria) {
+    emitGuidance(acceptanceGuidance(context.guidance.acceptanceCriteria));
+  }
+  const assembled = parts.join("\n\n");
+  const usesPreamble = PREAMBLE_PROVIDERS.has(context.provider);
+  const systemChannel = usesPreamble ? "" : assembled;
+  const promptPreamble = usesPreamble ? assembled : "";
+  const policyChannel = "";
+  const bytesByChannel = {
+    system: byteLength(systemChannel),
+    preamble: byteLength(promptPreamble),
+    policy: byteLength(policyChannel)
+  };
+  const routedBytes = usesPreamble ? bytesByChannel.preamble : bytesByChannel.system;
+  const capStatus = assessSteeringCap(context.provider, routedBytes);
+  if (capStatus.status === "hard-refuse" && context.enforceCaps !== false) {
+    throw new Error(
+      `Poetic runtime AGENTS.md steering is ${capStatus.bytes} bytes for ${context.provider} (${capStatus.channel} hard limit ${capStatus.hardRefuseBytes} bytes). Run "poetic instructions lint" and shorten ${getUserAgentsPath()}.`
+    );
+  }
+  maybeWarnSoftCap(context.provider, capStatus);
+  return {
+    systemChannel,
+    promptPreamble,
+    policyChannel,
+    version: DOCTRINE_VERSION,
+    steeringHash: sha256Text(assembled),
+    bytesByChannel,
+    applied: {
+      doctrine: appliedDoctrine,
+      guidance: appliedGuidance,
+      sources
+    }
+  };
+}
+
+export {
+  resolveSteeringChannelCaps,
+  assessSteeringCap,
+  assembleSteering
+};
+//# sourceMappingURL=chunk-MWHF5V7U.js.map

package/dist/chunk-MWHLBPNU.js

@@ -0,0 +1,211 @@
+// src/core/providers/claude/config.ts
+var CLAUDE_MODELS = {
+  // Current models
+  OPUS: "opus",
+  SONNET: "sonnet",
+  HAIKU: "haiku",
+  FABLE: "fable",
+  // Fable 5 is Anthropic's most capable widely released model. The Claude CLI
+  // accepts both the `fable` alias and the `claude-fable-5` full id (per its own
+  // --help, verified against CLI 2.1.177). NOTE: Fable 5 is temporarily
+  // Verified live 2026-07-25: `claude -p --model claude-fable-5` succeeds and
+  // both global./us. Bedrock inference profiles are enumerated. The earlier
+  // export-control suspension no longer blocks invocation; error-parser.ts still
+  // surfaces a clear "temporarily unavailable" message if upstream availability
+  // regresses.
+  CLAUDE_FABLE_5: "claude-fable-5",
+  // 5-series. Verified live on Bedrock 2026-07-26 (`claude -p --output-format json`,
+  // reading modelUsage[].contextWindow): both ids invoke successfully, and
+  // global./us. inference profiles are enumerated (see providers.yaml). Opus 5
+  // reports 200000 unsuffixed and 1000000 with `[1m]`; Sonnet 5 reports 1000000
+  // either way (it has no 200K variant — see CLAUDE_CONTEXT_SUFFIXES).
+  CLAUDE_OPUS_5: "claude-opus-5",
+  CLAUDE_SONNET_5: "claude-sonnet-5",
+  // Legacy canonical IDs retained for compatibility with existing callers/tests.
+  SONNET_3_5: "claude-3-5-sonnet-latest",
+  OPUS_3: "claude-3-opus-latest",
+  HAIKU_3: "claude-3-haiku-latest",
+  CLAUDE_OPUS_4_8: "claude-opus-4-8",
+  CLAUDE_OPUS_4_7: "claude-opus-4-7",
+  CLAUDE_OPUS_4_6: "claude-opus-4-6",
+  CLAUDE_OPUS_4_5: "claude-opus-4-5",
+  CLAUDE_SONNET_4_6: "claude-sonnet-4-6",
+  CLAUDE_SONNET_4_5: "claude-sonnet-4-5",
+  CLAUDE_HAIKU_4_5: "claude-haiku-4-5"
+};
+var CLAUDE_BEDROCK_MODELS = {
+  // claude-opus-4-7 uses the bare (undated) base id. Verified live 2026-06-14
+  // via bedrock list-inference-profiles + bedrock-runtime converse: the
+  // global/us/eu/jp `anthropic.claude-opus-4-7` profiles all invoke OK. The
+  // primary source of truth is the providers.yaml bedrock block (which also
+  // pins each regional profile and intentionally omits apac, since
+  // apac.anthropic.claude-opus-4-7 is NOT invokable); this flat entry is the
+  // registry-miss fallback that mirrors that base id.
+  // claude-fable-5 is VERIFIED (2026-07-25): `claude -p --model claude-fable-5`
+  // succeeds, and `aws bedrock list-inference-profiles` returns both
+  // global.anthropic.claude-fable-5 and us.anthropic.claude-fable-5.
+  // claude-opus-5 / claude-sonnet-5 are VERIFIED (2026-07-26): both invoke on
+  // Bedrock and their global./us. inference profiles are enumerated.
+  "claude-opus-5": "anthropic.claude-opus-5",
+  "claude-sonnet-5": "anthropic.claude-sonnet-5",
+  "claude-fable-5": "anthropic.claude-fable-5",
+  "claude-opus-4-8": "anthropic.claude-opus-4-8",
+  "claude-opus-4-7": "anthropic.claude-opus-4-7",
+  "claude-opus-4-6": "anthropic.claude-opus-4-6-v1",
+  "claude-opus-4-5": "anthropic.claude-opus-4-5-20251101-v1:0",
+  "claude-sonnet-4-6": "anthropic.claude-sonnet-4-6",
+  "claude-sonnet-4-5": "anthropic.claude-sonnet-4-5-20250929-v1:0",
+  "claude-haiku-4-5": "anthropic.claude-haiku-4-5-20251001-v1:0"
+};
+var CLAUDE_ALIAS_TO_MODEL_ID = {
+  // Generic aliases → latest *backend-executable* version. This is POETIC'S
+  // cross-backend latest-pin POLICY, not a mirror of Claude Code's native alias
+  // resolution. Native Claude Code resolves a bare alias to a DIFFERENT version
+  // per backend (verified 2026-06-19, https://code.claude.com/docs/en/model-config):
+  // Anthropic API `opus` → Opus 4.8, Claude Platform on AWS → Opus 4.7, and
+  // Bedrock/Vertex/Foundry → Opus 4.6 unless pinned. Poetic deliberately pins
+  // bare `opus` to claude-opus-4-8 on EVERY backend (mirrored in providers.yaml
+  // mappings.opus) so a bare family alias means "latest Opus" uniformly rather
+  // than the CLI's conservative, backend-specific default. claude-opus-4-8 carries
+  // a verified Bedrock id (CLAUDE_BEDROCK_MODELS + providers.yaml bedrock block),
+  // so `--model opus` works on Anthropic, Vertex, and Bedrock. An explicit pin
+  // (`opus-4-8` / `claude-opus-4-8`) selects the same 4.8.
+  sonnet: CLAUDE_MODELS.CLAUDE_SONNET_4_6,
+  opus: CLAUDE_MODELS.CLAUDE_OPUS_4_8,
+  haiku: CLAUDE_MODELS.CLAUDE_HAIKU_4_5,
+  // bare `fable` -> claude-fable-5 (latest Fable). Verified on Anthropic and
+  // Bedrock (2026-07-25); resolves on Vertex per Anthropic's published id table.
+  fable: CLAUDE_MODELS.CLAUDE_FABLE_5,
+  "fable-5": CLAUDE_MODELS.CLAUDE_FABLE_5,
+  // Version-pinned shorthands → exact version
+  "opus-5": CLAUDE_MODELS.CLAUDE_OPUS_5,
+  "opus.5": CLAUDE_MODELS.CLAUDE_OPUS_5,
+  "sonnet-5": CLAUDE_MODELS.CLAUDE_SONNET_5,
+  "sonnet.5": CLAUDE_MODELS.CLAUDE_SONNET_5,
+  "sonnet-4-6": CLAUDE_MODELS.CLAUDE_SONNET_4_6,
+  "sonnet-4.6": CLAUDE_MODELS.CLAUDE_SONNET_4_6,
+  "sonnet-4-5": CLAUDE_MODELS.CLAUDE_SONNET_4_5,
+  "sonnet-4.5": CLAUDE_MODELS.CLAUDE_SONNET_4_5,
+  "opus-4-8": CLAUDE_MODELS.CLAUDE_OPUS_4_8,
+  "opus-4.8": CLAUDE_MODELS.CLAUDE_OPUS_4_8,
+  "opus-4-7": CLAUDE_MODELS.CLAUDE_OPUS_4_7,
+  "opus-4.7": CLAUDE_MODELS.CLAUDE_OPUS_4_7,
+  "opus-4-6": CLAUDE_MODELS.CLAUDE_OPUS_4_6,
+  "opus-4.6": CLAUDE_MODELS.CLAUDE_OPUS_4_6,
+  "opus-4-5": CLAUDE_MODELS.CLAUDE_OPUS_4_5,
+  "opus-4.5": CLAUDE_MODELS.CLAUDE_OPUS_4_5,
+  "haiku-4-5": CLAUDE_MODELS.CLAUDE_HAIKU_4_5,
+  "haiku-4.5": CLAUDE_MODELS.CLAUDE_HAIKU_4_5
+};
+var CLAUDE_VERTEX_VERSION_PINS = Object.freeze({
+  "claude-sonnet-4-5": "claude-sonnet-4-5@20250929",
+  "claude-opus-4-5": "claude-opus-4-5@20251101",
+  "claude-haiku-4-5": "claude-haiku-4-5@20251001",
+  "claude-opus-4-1": "claude-opus-4-1@20250805"
+});
+var CLAUDE_CONTEXT_SUFFIXES = /* @__PURE__ */ new Set(["[1m]"]);
+var CLAUDE_DISABLE_1M_CONTEXT_ENV = "CLAUDE_CODE_DISABLE_1M_CONTEXT";
+function is1MContextDisabled(env) {
+  const raw = (env ?? process.env)[CLAUDE_DISABLE_1M_CONTEXT_ENV];
+  if (typeof raw !== "string") {
+    return false;
+  }
+  const normalized = raw.trim().toLowerCase();
+  return normalized === "1" || normalized === "true";
+}
+function splitClaudeModelContextSuffix(model) {
+  const match = model.match(/^(.*?)(\[[^\]]*\])\s*$/);
+  if (!match || match[1] === void 0 || match[2] === void 0) {
+    return { base: model, suffix: "" };
+  }
+  const suffix = match[2].toLowerCase();
+  if (!CLAUDE_CONTEXT_SUFFIXES.has(suffix)) {
+    return { base: model, suffix: "" };
+  }
+  return { base: match[1].trim(), suffix };
+}
+function getClaudeModelContextSuffixWarning(model) {
+  const trimmed = model.trim();
+  const match = trimmed.match(/^(.*?)(\[[^\]]*\])\s*$/);
+  if (!match || match[2] === void 0) {
+    return void 0;
+  }
+  const suffix = match[2].toLowerCase();
+  if (CLAUDE_CONTEXT_SUFFIXES.has(suffix)) {
+    return void 0;
+  }
+  return `Claude model '${model}' has unrecognized trailing context suffix '${match[2]}'; supported suffixes: ${Array.from(CLAUDE_CONTEXT_SUFFIXES).join(", ")}`;
+}
+var CLAUDE_FAMILY_TOKENS = ["opus", "sonnet", "haiku", "fable", "mythos"];
+var CLAUDE_FAMILY_LIKE_PIN_PATTERN = new RegExp(
+  `^(${CLAUDE_FAMILY_TOKENS.join("|")})(?:[-.]\\d+)?$`
+);
+var CLAUDE_SPECIFIC_PIN_PATTERN = new RegExp(
+  `^(?:${CLAUDE_FAMILY_TOKENS.join("|")})(?:[-.]\\d+){2,}$`
+);
+function isSpecificClaudeVersionPin(model) {
+  const normalized = model.trim().toLowerCase();
+  if (normalized === "") return false;
+  return CLAUDE_SPECIFIC_PIN_PATTERN.test(normalized);
+}
+function extractClaudeFamilyToken(model) {
+  const match = model.trim().toLowerCase().match(CLAUDE_FAMILY_LIKE_PIN_PATTERN);
+  return match?.[1];
+}
+function resolveModel(model) {
+  if (!model) {
+    return void 0;
+  }
+  const trimmed = model.trim();
+  if (trimmed === "") {
+    return void 0;
+  }
+  const { base, suffix } = splitClaudeModelContextSuffix(trimmed);
+  if (base === "") {
+    return void 0;
+  }
+  const resolvedBase = resolveModelBase(base);
+  if (resolvedBase === void 0) {
+    return void 0;
+  }
+  return suffix ? `${resolvedBase}${suffix}` : resolvedBase;
+}
+var CLAUDE_CLI_ONLY_LEGACY_ALIASES = {
+  "opus-4-1": "claude-opus-4-1",
+  "opus-4.1": "claude-opus-4-1"
+};
+function resolveModelBase(base) {
+  const trimmed = base;
+  const normalized = trimmed.toLowerCase();
+  const claudeValues = Object.values(CLAUDE_MODELS);
+  const knownClaudeModel = claudeValues.find((value) => value.toLowerCase() === normalized);
+  if (knownClaudeModel) {
+    return knownClaudeModel;
+  }
+  const mapped = CLAUDE_ALIAS_TO_MODEL_ID[normalized] ?? CLAUDE_CLI_ONLY_LEGACY_ALIASES[normalized];
+  if (mapped) {
+    return mapped;
+  }
+  if (normalized.startsWith("claude-")) {
+    return normalized;
+  }
+  if (normalized.startsWith("anthropic.claude-") || normalized.includes(".anthropic.claude-")) {
+    return trimmed;
+  }
+  return void 0;
+}
+
+export {
+  CLAUDE_MODELS,
+  CLAUDE_BEDROCK_MODELS,
+  CLAUDE_ALIAS_TO_MODEL_ID,
+  CLAUDE_VERTEX_VERSION_PINS,
+  CLAUDE_DISABLE_1M_CONTEXT_ENV,
+  is1MContextDisabled,
+  splitClaudeModelContextSuffix,
+  getClaudeModelContextSuffixWarning,
+  isSpecificClaudeVersionPin,
+  extractClaudeFamilyToken,
+  resolveModel
+};
+//# sourceMappingURL=chunk-MWHLBPNU.js.map