@poetic-ai/poetic 1.42.0

package/dist/chunk-MQ4WA34C.js

@@ -0,0 +1,206 @@
+import {
+  evaluateStaleReclaim
+} from "./chunk-P7CQGPLS.js";
+import {
+  signalCoordinator
+} from "./chunk-72YTZMAM.js";
+
+// src/planning/ingest-lock.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+var DEFAULTS = {
+  timeoutMs: 6e4,
+  staleThresholdMs: 3e5,
+  initialRetryMs: 50,
+  maxRetryMs: 2e3,
+  backoffFactor: 2
+};
+var CROSS_HOST_STALE_MULTIPLIER = 3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getHostIdentity() {
+  const envHostname = process.env.HOSTNAME?.trim();
+  return envHostname || os.hostname() || "unknown";
+}
+async function readLockPayload(lockFile) {
+  const read = await readLockPayloadWithRaw(lockFile);
+  return read?.payload ?? null;
+}
+async function readLockPayloadWithRaw(lockFile) {
+  try {
+    const content = await fs.readFile(lockFile, "utf-8");
+    let payload = null;
+    try {
+      payload = JSON.parse(content);
+    } catch {
+      payload = null;
+    }
+    return { payload, rawContent: content };
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error.code === "EPERM") {
+      return true;
+    }
+    return false;
+  }
+}
+async function isLockStaleAndAbandoned(lockFile, staleThresholdMs) {
+  try {
+    const stat2 = await fs.stat(lockFile);
+    const ageMs = Date.now() - stat2.mtimeMs;
+    const read = await readLockPayloadWithRaw(lockFile);
+    if (!read) {
+      return null;
+    }
+    const payload = read.payload;
+    let holder = null;
+    if (payload && typeof payload.pid === "number") {
+      const currentHostname = getHostIdentity();
+      const hasUnknownHost = payload.hostname === "unknown" || currentHostname === "unknown";
+      const sameHost = !hasUnknownHost && payload.hostname === currentHostname;
+      holder = { sameHost, pidAlive: sameHost ? isProcessAlive(payload.pid) : false };
+    }
+    const decision = evaluateStaleReclaim(
+      { ageMs, holder },
+      {
+        staleMs: staleThresholdMs,
+        corruptPayload: "reclaim",
+        foreignHost: { kind: "after-multiplier", multiplier: CROSS_HOST_STALE_MULTIPLIER },
+        // Preserve the original strict-greater-than age boundary (age <= stale
+        // holds; reclaim only strictly past stale / past 3x for foreign hosts).
+        ageBoundary: "gt"
+      }
+    );
+    return decision === "reclaim" ? { dev: stat2.dev, ino: stat2.ino, rawContent: read.rawContent } : null;
+  } catch {
+    return null;
+  }
+}
+async function releaseOwnLock(lockFile, snapshot) {
+  try {
+    if (!await lockSnapshotStillMatches(lockFile, snapshot)) {
+      return;
+    }
+    try {
+      await fs.unlink(lockFile);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+      }
+    }
+  } finally {
+    await snapshot.fileHandle?.close().catch(() => {
+    });
+  }
+}
+async function lockSnapshotStillMatches(lockFile, snapshot) {
+  try {
+    const [openFileStat, stat2, rawContent] = await Promise.all([
+      snapshot.fileHandle?.stat(),
+      fs.stat(lockFile),
+      fs.readFile(lockFile, "utf-8")
+    ]);
+    const acquiredDev = openFileStat?.dev ?? snapshot.dev;
+    const acquiredIno = openFileStat?.ino ?? snapshot.ino;
+    return stat2.dev === acquiredDev && stat2.ino === acquiredIno && rawContent === snapshot.rawContent;
+  } catch {
+    return false;
+  }
+}
+async function forceRelease(lockFile, snapshot) {
+  if (!await lockSnapshotStillMatches(lockFile, snapshot)) {
+    return;
+  }
+  try {
+    await fs.unlink(lockFile);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+async function withIngestLock(planningRoot, fn, options) {
+  const timeoutMs = options?.timeoutMs ?? DEFAULTS.timeoutMs;
+  const staleThresholdMs = options?.staleThresholdMs ?? DEFAULTS.staleThresholdMs;
+  const initialRetryMs = options?.initialRetryMs ?? DEFAULTS.initialRetryMs;
+  const maxRetryMs = options?.maxRetryMs ?? DEFAULTS.maxRetryMs;
+  const backoffFactor = options?.backoffFactor ?? DEFAULTS.backoffFactor;
+  const operation = options?.operation ?? "ingest";
+  const lockDir = options?.lockDir ?? path.join(planningRoot, ".poetic", "planning", "locks");
+  const lockFile = path.join(lockDir, "ingest.lock");
+  await fs.mkdir(lockDir, { recursive: true });
+  const startTime = Date.now();
+  let retryMs = initialRetryMs;
+  while (Date.now() - startTime < timeoutMs) {
+    const staleSnapshot = await isLockStaleAndAbandoned(lockFile, staleThresholdMs);
+    if (staleSnapshot) {
+      await forceRelease(lockFile, staleSnapshot);
+    }
+    try {
+      const ownerId = randomUUID();
+      const payload = {
+        pid: process.pid,
+        hostname: getHostIdentity(),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        operation,
+        ownerId
+      };
+      const rawContent = JSON.stringify(payload, null, 2);
+      const fileHandle = await fs.open(lockFile, "wx");
+      let lockSnapshot;
+      try {
+        await fileHandle.writeFile(rawContent, "utf-8");
+        const lockStat = await fileHandle.stat();
+        lockSnapshot = { dev: lockStat.dev, ino: lockStat.ino, rawContent, fileHandle };
+      } catch (writeError) {
+        await fileHandle.close().catch(() => {
+        });
+        await fs.unlink(lockFile).catch(() => {
+        });
+        throw writeError;
+      }
+      const cleanupName = `planning-ingest-lock:${process.pid}:${operation}`;
+      const release = async () => {
+        try {
+          await releaseOwnLock(lockFile, lockSnapshot);
+        } finally {
+          signalCoordinator.unregister(cleanupName);
+        }
+      };
+      signalCoordinator.register(cleanupName, release, {
+        priority: "critical",
+        phase: "artifact-cleanup"
+      });
+      try {
+        return await fn();
+      } finally {
+        await release();
+      }
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        await sleep(retryMs);
+        retryMs = Math.min(retryMs * backoffFactor, maxRetryMs);
+        continue;
+      }
+      throw error;
+    }
+  }
+  const lockInfo = await readLockPayload(lockFile);
+  throw new Error(
+    `Ingest lock acquisition timed out after ${timeoutMs}ms. Lock held by PID ${lockInfo?.pid ?? "unknown"} since ${lockInfo?.createdAt ?? "unknown"} (operation: ${lockInfo?.operation ?? "unknown"})`
+  );
+}
+
+export {
+  withIngestLock
+};
+//# sourceMappingURL=chunk-MQ4WA34C.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