@iderouter/index-mcp 0.2.0-beta.1

package/src/job-supersession.js

@@ -0,0 +1,25 @@
+function timestampMs(value) {
+  const parsed = Date.parse(value || "");
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function jobIdOrder(job) {
+  const match = String(job?.id || "").match(/-(\d+)$/);
+  if (!match) return 0;
+  const numeric = Number(match[1]);
+  return Number.isFinite(numeric) ? numeric : 0;
+}
+
+export function jobInstanceOrder(job) {
+  return Math.max(
+    timestampMs(job?.startedAt),
+    jobIdOrder(job),
+  );
+}
+
+export function isSupersededByJob(currentJob, latestJob) {
+  if (!currentJob || !latestJob) return false;
+  if (String(currentJob.id || "") === String(latestJob.id || "")) return false;
+  if (currentJob.codebasePath && latestJob.codebasePath && currentJob.codebasePath !== latestJob.codebasePath) return false;
+  return jobInstanceOrder(latestJob) > jobInstanceOrder(currentJob);
+}

package/src/priority-progress.js

@@ -0,0 +1,20 @@
+export function priorityReadyProgressValue(anchorTargets, completedFineFiles) {
+  const total = anchorTargets instanceof Set ? anchorTargets.size : 0;
+  if (total === 0) return 100;
+  let completed = 0;
+  for (const file of anchorTargets) {
+    if (completedFineFiles?.has?.(file)) completed += 1;
+  }
+  return Math.min(100, Math.round((completed / total) * 100));
+}
+
+export function mergeCompletedFineFiles(...completedSets) {
+  const merged = new Set();
+  for (const set of completedSets) {
+    if (!set?.values) continue;
+    for (const file of set.values()) {
+      if (file) merged.add(file);
+    }
+  }
+  return merged;
+}

package/src/priority-ready-anchor-coverage-normalize.js

@@ -0,0 +1,18 @@
+import { buildPriorityReadyAnchorCoverage } from "./priority-ready-anchor-coverage.js";
+
+export function normalizePriorityReadyAnchorCoverage(index) {
+  const next = { ...(index || {}) };
+  if (
+    next.priorityReadyAnchorCoverage &&
+    typeof next.priorityReadyAnchorCoverage.total === "number" &&
+    typeof next.priorityReadyAnchorCoverage.completed === "number" &&
+    Array.isArray(next.priorityReadyAnchorCoverage.completed_paths) &&
+    Array.isArray(next.priorityReadyAnchorCoverage.pending_paths)
+  ) {
+    return next;
+  }
+  next.priorityReadyAnchorCoverage = buildPriorityReadyAnchorCoverage(next.chunks || [], {
+    availablePaths: Array.isArray(next.files) ? next.files.map((file) => file?.relativePath).filter(Boolean) : [],
+  });
+  return next;
+}

package/src/priority-ready-anchor-coverage.js

@@ -0,0 +1,23 @@
+import { priorityReadyAnchorPaths } from "./priority-ready-hotspots.js";
+
+export function buildPriorityReadyAnchorCoverage(chunks, options = {}) {
+  const allAnchors = priorityReadyAnchorPaths();
+  const availablePaths = new Set(Array.isArray(options.availablePaths) ? options.availablePaths.filter(Boolean) : []);
+  const anchors = availablePaths.size > 0
+    ? allAnchors.filter((item) => availablePaths.has(item))
+    : allAnchors;
+  const completed = new Set(
+    (Array.isArray(chunks) ? chunks : [])
+      .filter((chunk) => Array.isArray(chunk?.vector) ? chunk.vector.length > 0 : typeof chunk?.vectorBase64 === "string" && chunk.vectorBase64.length > 0)
+      .map((chunk) => chunk.relativePath)
+      .filter(Boolean),
+  );
+  const completedAnchors = anchors.filter((item) => completed.has(item));
+  const pendingAnchors = anchors.filter((item) => !completed.has(item));
+  return {
+    total: anchors.length,
+    completed: completedAnchors.length,
+    completed_paths: completedAnchors,
+    pending_paths: pendingAnchors,
+  };
+}

package/src/priority-ready-hotspots.js

@@ -0,0 +1,344 @@
+import crypto from "node:crypto";
+import path from "node:path";
+
+export function priorityReadyAnchorPaths() {
+  return [
+    "relay/common/relay_info.go",
+    "relay/compatible_handler.go",
+    "pkg/billingexpr/run.go",
+  ];
+}
+
+export function priorityReadyHotspotTerms(relativePathInput) {
+  const relativePath = String(relativePathInput || "").toLowerCase().split(path.sep).join("/");
+  if (relativePath === "relay/common/relay_info.go") {
+    return ["streamsupportedchannels", "supportstreamoptions", "removedisabledfields", "allowsafetyidentifier", "allowincludeobfuscation"];
+  }
+  if (relativePath === "relay/compatible_handler.go") {
+    return ["supportstreamoptions", "forcestreamoption", "removedisabledfields", "buildusermemorypromptforrequest", "injectusermemoryintoopenairequest"];
+  }
+  if (relativePath === "relay/claude_handler.go") {
+    return ["claudehelper", "buildusermemorypromptforclauderequest", "injectusermemoryintoclauderequest", "removedisabledfields"];
+  }
+  if (relativePath === "pkg/billingexpr/run.go") {
+    return ["runexprwithrequest", "runexprbyhashwithrequest", "runprogram"];
+  }
+  if (relativePath === "relay/helper/price.go") {
+    return ["modelpricehelpertiered", "runexprwithrequest", "resolvepricingmodelname", "modelpricehelper"];
+  }
+  if (relativePath === "service/tiered_settle.go") {
+    return ["trytieredsettle", "buildtieredtokenparams"];
+  }
+  return [];
+}
+
+function priorityReadyPreferredDefinitions(relativePathInput) {
+  const relativePath = String(relativePathInput || "").toLowerCase().split(path.sep).join("/");
+  if (relativePath === "relay/common/relay_info.go") {
+    return ["streamSupportedChannels"];
+  }
+  if (relativePath === "pkg/billingexpr/run.go") {
+    return ["RunExprWithRequest", "RunExpr"];
+  }
+  return [];
+}
+
+function priorityReadyPreferredRegion(relativePathInput) {
+  const relativePath = String(relativePathInput || "").toLowerCase().split(path.sep).join("/");
+  if (relativePath === "relay/compatible_handler.go") {
+    return {
+      anchorTerms: [
+        "if request.StreamOptions != nil {",
+        "if !info.SupportStreamOptions || !lo.FromPtrOr(request.Stream, false) {",
+      ],
+      chunkSize: 320,
+      startContextChars: 64,
+    };
+  }
+  if (relativePath === "relay/common/relay_info.go") {
+    return {
+      chunkSize: 240,
+    };
+  }
+  if (relativePath === "pkg/billingexpr/run.go") {
+    return {
+      chunkSize: 320,
+    };
+  }
+  return null;
+}
+
+export function compactAlphaNum(value) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+export function buildLineOffsets(content) {
+  const offsets = [0];
+  for (let i = 0; i < content.length; i += 1) {
+    if (content.charCodeAt(i) === 10) offsets.push(i + 1);
+  }
+  return offsets;
+}
+
+export function lineForOffsetFromIndex(lineOffsets, offset) {
+  let low = 0;
+  let high = lineOffsets.length - 1;
+  while (low <= high) {
+    const mid = (low + high) >> 1;
+    if (lineOffsets[mid] <= offset) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return Math.max(1, high + 1);
+}
+
+function snippetWindow(content, start, size) {
+  const safeStart = Math.max(0, start);
+  const safeEnd = Math.min(content.length, safeStart + Math.max(1, size));
+  return {
+    start: safeStart,
+    end: safeEnd,
+    content: content.slice(safeStart, safeEnd).trim(),
+  };
+}
+
+const DEFINITION_PATTERNS = [
+  /^(?:func|type|const|var)\s+[A-Za-z0-9_]+/gm,
+  /^(?:export\s+)?(?:async\s+)?function\s+[A-Za-z0-9_]+\s*\(/gm,
+  /^(?:export\s+)?(?:const|let|var)\s+[A-Za-z0-9_]+\s*=/gm,
+  /^(?:export\s+)?(?:class|interface)\s+[A-Za-z0-9_]+/gm,
+];
+
+const PREFERRED_LEADING_DEFINITION_PATTERNS = [
+  /^(?:func)\s+(?:\([^)]+\)\s*)?[A-Za-z0-9_]+\s*\(/gm,
+  /^(?:export\s+)?(?:async\s+)?function\s+[A-Za-z0-9_]+\s*\(/gm,
+  /^(?:export\s+)?(?:class|interface)\s+[A-Za-z0-9_]+/gm,
+  /^(?:type)\s+[A-Za-z0-9_]+/gm,
+];
+
+function findDefinitionStartBeforeOffset(content, offset) {
+  const boundary = Math.max(0, Number(offset) || 0);
+  let best = -1;
+  for (const pattern of DEFINITION_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      if (match.index > boundary) break;
+      best = Math.max(best, match.index);
+    }
+  }
+  return best >= 0 ? best : Math.max(0, content.lastIndexOf("\n", boundary) + 1);
+}
+
+function findFirstDefinitionStart(content) {
+  let preferred = -1;
+  for (const pattern of PREFERRED_LEADING_DEFINITION_PATTERNS) {
+    pattern.lastIndex = 0;
+    const match = pattern.exec(content);
+    if (!match) continue;
+    if (preferred < 0 || match.index < preferred) {
+      preferred = match.index;
+    }
+  }
+  if (preferred >= 0) return preferred;
+  let best = -1;
+  for (const pattern of DEFINITION_PATTERNS) {
+    pattern.lastIndex = 0;
+    const match = pattern.exec(content);
+    if (!match) continue;
+    if (best < 0 || match.index < best) {
+      best = match.index;
+    }
+  }
+  return best >= 0 ? best : 0;
+}
+
+function trimWindowToNextDefinition(content, start, end) {
+  let best = end;
+  for (const pattern of DEFINITION_PATTERNS) {
+    pattern.lastIndex = Math.max(0, start + 1);
+    const match = pattern.exec(content);
+    if (!match) continue;
+    if (match.index <= start || match.index >= end) continue;
+    best = Math.min(best, match.index);
+  }
+  return best;
+}
+
+function hotspotMatchCount(windowContent, hotspotTerms) {
+  const compactWindow = compactAlphaNum(windowContent);
+  let count = 0;
+  for (const term of hotspotTerms) {
+    if (compactWindow.includes(term)) count += 1;
+  }
+  return count;
+}
+
+function findNamedDefinitionStart(content, definitionName) {
+  const escaped = String(definitionName || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (!escaped) return -1;
+  const patterns = [
+    new RegExp(`^func\\s+(?:\\([^)]+\\)\\s*)?${escaped}\\s*\\(`, "m"),
+    new RegExp(`^(?:var|const|type)\\s+${escaped}\\b`, "m"),
+    new RegExp(`^(?:export\\s+)?(?:async\\s+)?function\\s+${escaped}\\s*\\(`, "m"),
+    new RegExp(`^(?:export\\s+)?(?:const|let|var)\\s+${escaped}\\s*=`, "m"),
+    new RegExp(`^(?:export\\s+)?(?:class|interface)\\s+${escaped}\\b`, "m"),
+  ];
+  for (const pattern of patterns) {
+    const match = pattern.exec(content);
+    if (match) return match.index;
+  }
+  return -1;
+}
+
+function findLineStartContaining(content, needle) {
+  const index = String(content || "").indexOf(String(needle || ""));
+  if (index < 0) return -1;
+  return Math.max(0, content.lastIndexOf("\n", index) + 1);
+}
+
+function primaryWindowStart(content, hitOffset, chunkSize) {
+  const definitionStart = findDefinitionStartBeforeOffset(content, hitOffset);
+  const distance = Math.max(0, hitOffset - definitionStart);
+  if (distance <= Math.floor(chunkSize * 0.5)) return definitionStart;
+  return Math.max(definitionStart, hitOffset - Math.floor(chunkSize * 0.35));
+}
+
+function extractGenericPriorityReadyFallbackChunk(content, file, chunkSize) {
+  const lineOffsets = buildLineOffsets(content);
+  const definitionStart = findFirstDefinitionStart(content);
+  const start = Math.max(0, definitionStart);
+  const window = snippetWindow(content, start, chunkSize);
+  window.end = trimWindowToNextDefinition(content, window.start, window.end);
+  window.content = content.slice(window.start, window.end).trim();
+  if (!window.content) return [];
+  return [{
+    id: crypto
+      .createHash("sha256")
+      .update(`${file.relativePath}:${window.start}:${window.content}`)
+      .digest("hex")
+      .slice(0, 24),
+    contentHash: crypto.createHash("sha256").update(window.content).digest("hex"),
+    relativePath: file.relativePath,
+    extension: file.extension,
+    startLine: lineForOffsetFromIndex(lineOffsets, window.start),
+    endLine: lineForOffsetFromIndex(lineOffsets, window.end),
+    content: window.content,
+  }];
+}
+
+export function extractPriorityReadyHotspotChunks(content, file, options = {}) {
+  const hotspotTerms = priorityReadyHotspotTerms(file.relativePath);
+  const preferredRegion = priorityReadyPreferredRegion(file.relativePath);
+  const chunkSize = Math.max(1, Number(preferredRegion?.chunkSize || options.chunkSize) || 720);
+  const chunkCap = Math.max(1, Number(options.chunkCap) || 3);
+  const primaryOnly = Boolean(options.primaryOnly);
+  if (hotspotTerms.length === 0) {
+    return extractGenericPriorityReadyFallbackChunk(content, file, chunkSize);
+  }
+  const preferredDefinitions = priorityReadyPreferredDefinitions(file.relativePath);
+  const compactContent = compactAlphaNum(content);
+  if (!hotspotTerms.some((term) => compactContent.includes(term))) return [];
+
+  const lineOffsets = buildLineOffsets(content);
+  if (primaryOnly && preferredRegion?.anchorTerms?.length) {
+    for (const anchorTerm of preferredRegion.anchorTerms) {
+      const lineStart = findLineStartContaining(content, anchorTerm);
+      if (lineStart < 0) continue;
+      const start = Math.max(0, lineStart - Math.max(0, Number(preferredRegion.startContextChars) || 0));
+      const window = snippetWindow(content, start, chunkSize);
+      if (!window.content) continue;
+      return [{
+        id: crypto
+          .createHash("sha256")
+          .update(`${file.relativePath}:${window.start}:${window.content}`)
+          .digest("hex")
+          .slice(0, 24),
+        contentHash: crypto.createHash("sha256").update(window.content).digest("hex"),
+        relativePath: file.relativePath,
+        extension: file.extension,
+        startLine: lineForOffsetFromIndex(lineOffsets, window.start),
+        endLine: lineForOffsetFromIndex(lineOffsets, window.end),
+        content: window.content,
+      }];
+    }
+  }
+  if (primaryOnly && preferredDefinitions.length > 0) {
+    for (const definitionName of preferredDefinitions) {
+      const start = findNamedDefinitionStart(content, definitionName);
+      if (start < 0) continue;
+      const window = snippetWindow(content, start, chunkSize);
+      window.end = trimWindowToNextDefinition(content, window.start, window.end);
+      window.content = content.slice(window.start, window.end).trim();
+      if (!window.content) continue;
+      return [{
+        id: crypto
+          .createHash("sha256")
+          .update(`${file.relativePath}:${window.start}:${window.content}`)
+          .digest("hex")
+          .slice(0, 24),
+        contentHash: crypto.createHash("sha256").update(window.content).digest("hex"),
+        relativePath: file.relativePath,
+        extension: file.extension,
+        startLine: lineForOffsetFromIndex(lineOffsets, window.start),
+        endLine: lineForOffsetFromIndex(lineOffsets, window.end),
+        content: window.content,
+      }];
+    }
+  }
+  const chunks = [];
+  const seen = new Set();
+  const rawLower = String(content || "").toLowerCase();
+  let bestPrimaryChunk = null;
+
+  for (let index = 0; index < hotspotTerms.length; index += 1) {
+    const term = hotspotTerms[index];
+    const first = rawLower.indexOf(term);
+    if (first < 0) continue;
+    const start = primaryOnly
+      ? primaryWindowStart(content, first, chunkSize)
+      : first;
+    const window = snippetWindow(content, start, chunkSize);
+    if (primaryOnly) {
+      window.end = trimWindowToNextDefinition(content, window.start, window.end);
+      window.content = content.slice(window.start, window.end).trim();
+    }
+    if (!window.content) continue;
+    const key = `${window.start}:${window.end}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const chunk = {
+      id: crypto
+        .createHash("sha256")
+        .update(`${file.relativePath}:${window.start}:${window.content}`)
+        .digest("hex")
+        .slice(0, 24),
+      contentHash: crypto.createHash("sha256").update(window.content).digest("hex"),
+      relativePath: file.relativePath,
+      extension: file.extension,
+      startLine: lineForOffsetFromIndex(lineOffsets, window.start),
+      endLine: lineForOffsetFromIndex(lineOffsets, window.end),
+      content: window.content,
+    };
+    if (primaryOnly) {
+      const score = hotspotMatchCount(window.content, hotspotTerms);
+      if (
+        !bestPrimaryChunk ||
+        index < bestPrimaryChunk.termIndex ||
+        (index === bestPrimaryChunk.termIndex && score > bestPrimaryChunk.score) ||
+        (index === bestPrimaryChunk.termIndex && score === bestPrimaryChunk.score && chunk.content.length < bestPrimaryChunk.chunk.content.length)
+      ) {
+        bestPrimaryChunk = { chunk, score, termIndex: index };
+      }
+      continue;
+    }
+    chunks.push(chunk);
+    if (chunks.length >= chunkCap) break;
+  }
+  if (primaryOnly) {
+    return bestPrimaryChunk ? [bestPrimaryChunk.chunk] : [];
+  }
+  return chunks;
+}

package/src/priority-ready-status.js

@@ -0,0 +1,30 @@
+export function formatPriorityReadyAnchorCoverage(anchorPaths, completedFineFiles) {
+  const anchors = Array.isArray(anchorPaths) ? anchorPaths : [];
+  const completed = completedFineFiles instanceof Set ? completedFineFiles : new Set();
+  const done = anchors.filter((item) => completed.has(item));
+  const pending = anchors.filter((item) => !completed.has(item));
+  return `anchor_targets=${done.length}/${anchors.length}; completed=[${done.join(",") || "none"}]; pending=[${pending.join(",") || "none"}]`;
+}
+
+export function buildPriorityReadyAnchorCoverageObject(anchorPaths, completedPaths) {
+  const anchors = Array.isArray(anchorPaths) ? anchorPaths.filter(Boolean) : [];
+  const completed = completedPaths instanceof Set
+    ? completedPaths
+    : new Set(Array.isArray(completedPaths) ? completedPaths.filter(Boolean) : []);
+  const done = anchors.filter((item) => completed.has(item));
+  const pending = anchors.filter((item) => !completed.has(item));
+  return {
+    total: anchors.length,
+    completed: done.length,
+    completed_paths: done,
+    pending_paths: pending,
+  };
+}
+
+export function formatPriorityReadyAnchorCoverageObject(coverage) {
+  const total = Number(coverage?.total || 0);
+  const completed = Number(coverage?.completed || 0);
+  const completedPaths = Array.isArray(coverage?.completed_paths) ? coverage.completed_paths : [];
+  const pendingPaths = Array.isArray(coverage?.pending_paths) ? coverage.pending_paths : [];
+  return `anchor_targets=${completed}/${total}; completed=[${completedPaths.join(",") || "none"}]; pending=[${pendingPaths.join(",") || "none"}]`;
+}

package/src/priority-ready-targets.js

@@ -0,0 +1,45 @@
+export function pickPriorityReadyTargetPaths({
+  files,
+  preferredPaths,
+  orderedFallbackPaths,
+  maxChunks = 0,
+  fallbackMaxFiles = 0,
+  fallbackMaxChunks = 0,
+  getChunkEstimate,
+  getScore,
+}) {
+  const normalizedFiles = Array.isArray(files) ? files : [];
+  const preferred = Array.isArray(preferredPaths) ? preferredPaths : [];
+  const fallback = Array.isArray(orderedFallbackPaths) ? orderedFallbackPaths : [];
+  const estimate = typeof getChunkEstimate === "function" ? getChunkEstimate : () => 1;
+  const score = typeof getScore === "function" ? getScore : () => 1;
+  const chunkBudget = Math.max(0, Number(maxChunks) || 0);
+  const fallbackFileBudget = Math.max(1, Number(fallbackMaxFiles) || 0);
+  const fallbackChunkBudget = Math.max(0, Number(fallbackMaxChunks) || 0);
+  const fileMap = new Map(normalizedFiles.map((file) => [file.relativePath, file]));
+  const selected = [];
+  let estimatedChunks = 0;
+
+  for (const relativePath of preferred) {
+    const file = fileMap.get(relativePath);
+    if (!file) continue;
+    const chunkEstimate = Math.max(1, Number(estimate(file)) || 1);
+    if (selected.length > 0 && chunkBudget > 0 && estimatedChunks + chunkEstimate > chunkBudget) continue;
+    selected.push(relativePath);
+    estimatedChunks += chunkEstimate;
+  }
+  if (selected.length > 0) return new Set(selected);
+
+  for (const relativePath of fallback) {
+    const file = fileMap.get(relativePath);
+    if (!file) continue;
+    if (Number(score(file)) <= 0 && selected.length > 0) break;
+    if (selected.length >= fallbackFileBudget) break;
+    const chunkEstimate = Math.max(1, Number(estimate(file)) || 1);
+    const activeFallbackChunkBudget = fallbackChunkBudget > 0 ? fallbackChunkBudget : chunkBudget;
+    if (selected.length > 0 && activeFallbackChunkBudget > 0 && estimatedChunks + chunkEstimate > activeFallbackChunkBudget) break;
+    selected.push(relativePath);
+    estimatedChunks += chunkEstimate;
+  }
+  return new Set(selected);
+}

package/src/priority-usable-attempt-plan.js

@@ -0,0 +1,44 @@
+export function buildPriorityUsableAttemptPlan({
+  source = "",
+  chunkCount = 0,
+  candidates = [],
+  preferredModel = "",
+  cachedHealthModel = "",
+  cachedHealthOk = true,
+  cachedHealthLatencyMs = 0,
+  primaryTimeoutMs = 0,
+  fallbackTimeoutMs = 0,
+}) {
+  const sourceText = String(source || "");
+  if (
+    !sourceText.startsWith("priority_usable_strategy") ||
+    sourceText.startsWith("priority_usable_strategy_fallback") ||
+    sourceText.startsWith("priority_usable_strategy_selection_timeout_fallback")
+  ) {
+    return [];
+  }
+  if (Number(chunkCount || 0) <= 1) return [];
+  const list = Array.isArray(candidates) ? candidates.filter(Boolean) : [];
+  if (list.length < 2) return [];
+  const primaryModel = preferredModel || list[0];
+  const fallbackModel = list.find((candidate) => candidate !== primaryModel);
+  if (!fallbackModel) return [];
+  if (String(cachedHealthModel || "").trim() !== fallbackModel) return [];
+  if (cachedHealthOk === false) return [];
+  if (Math.max(0, Number(cachedHealthLatencyMs || 0)) <= 0) return [];
+  return [
+    {
+      model: primaryModel,
+      timeoutMs: Math.max(1, Number(primaryTimeoutMs) || 0),
+      maxRetries: 0,
+    },
+    {
+      model: fallbackModel,
+      timeoutMs: Math.max(
+        Math.max(1, Number(fallbackTimeoutMs) || 0),
+        Math.max(1, Number(primaryTimeoutMs) || 0),
+      ),
+      maxRetries: 0,
+    },
+  ];
+}

package/src/priority-usable-attempt-timeout.js

@@ -0,0 +1,18 @@
+export function priorityUsableAttemptOuterTimeoutMs({
+  source = "",
+  attemptTimeoutMs = 0,
+  priorityTimeoutMs = 0,
+  priorityFallbackTimeoutMs = 0,
+}) {
+  const sourceText = String(source || "");
+  const attemptMs = Math.max(0, Number(attemptTimeoutMs || 0));
+  const priorityMs = Math.max(0, Number(priorityTimeoutMs || 0));
+  const fallbackMs = Math.max(0, Number(priorityFallbackTimeoutMs || 0));
+  if (sourceText.startsWith("priority_usable_strategy_fallback")) {
+    return Math.max(attemptMs, fallbackMs);
+  }
+  if (sourceText.startsWith("priority_usable_strategy")) {
+    return Math.max(attemptMs, Math.min(Math.max(priorityMs, fallbackMs), 8000));
+  }
+  return 0;
+}

package/src/priority-usable-fast-path.js

@@ -0,0 +1,11 @@
+export function shouldLockPriorityUsableProbeToPreferred({
+  force = false,
+  hasReusableFineVectors = false,
+  previousEmbeddingFailure = false,
+  preferredModel = "",
+}) {
+  if (force) return false;
+  if (hasReusableFineVectors) return false;
+  if (previousEmbeddingFailure) return false;
+  return String(preferredModel || "").trim() === "openai/text-embedding-3-small";
+}

package/src/priority-usable-probe-order.js

@@ -0,0 +1,34 @@
+export function priorityUsableProbeOrder({
+  preferredModel = "",
+  candidates = [],
+  allowFallbackCandidates = true,
+  penalizedModels = [],
+}) {
+  const ordered = [];
+  const seen = new Set();
+  const penalized = new Set((Array.isArray(penalizedModels) ? penalizedModels : []).map((value) => String(value || "").trim()).filter(Boolean));
+  const add = (value) => {
+    const text = String(value || "").trim();
+    if (!text || seen.has(text)) return;
+    seen.add(text);
+    ordered.push(text);
+  };
+
+  const preferred = String(preferredModel || "").trim();
+  const normalizedCandidates = Array.isArray(candidates) ? candidates : [];
+  const preferredPenalized = preferred && penalized.has(preferred);
+
+  if (preferred && normalizedCandidates.includes(preferred) && !preferredPenalized) {
+    add(preferred);
+    if (!allowFallbackCandidates) return ordered;
+  }
+
+  for (const candidate of normalizedCandidates) {
+    if (preferredPenalized && String(candidate || "").trim() === preferred) continue;
+    add(candidate);
+  }
+  if (preferredPenalized && preferred && normalizedCandidates.includes(preferred) && !seen.has(preferred)) {
+    add(preferred);
+  }
+  return ordered;
+}

package/src/remote-strategy-failure-cache.js

@@ -0,0 +1,55 @@
+export function recordRemoteStrategyFailure({
+  apiKey = "",
+  message = "",
+  nowMs = Date.now(),
+}) {
+  return {
+    apiKey: String(apiKey || ""),
+    message: String(message || "").trim(),
+    failedAt: Number(nowMs || 0),
+  };
+}
+
+export function shouldSkipRemoteStrategyFetch({
+  state = null,
+  apiKey = "",
+  nowMs = Date.now(),
+  cooldownMs = 0,
+}) {
+  const activeState = state && typeof state === "object" ? state : null;
+  const resolvedApiKey = String(apiKey || "");
+  if (!activeState || !resolvedApiKey || activeState.apiKey !== resolvedApiKey) {
+    return { skip: false, message: "" };
+  }
+  const failedAt = Number(activeState.failedAt || 0);
+  const cooldown = Math.max(0, Number(cooldownMs || 0));
+  if (!failedAt || !cooldown) {
+    return { skip: false, message: "" };
+  }
+  if (Number(nowMs || 0) - failedAt >= cooldown) {
+    return { skip: false, message: "" };
+  }
+  const detail = String(activeState.message || "").trim();
+  return {
+    skip: true,
+    message: detail ? `recent remote strategy failure: ${detail}` : "recent remote strategy failure",
+  };
+}
+
+export function isRemoteStrategyFailureStateActive({
+  state = null,
+  apiKey = "",
+  nowMs = Date.now(),
+  cooldownMs = 0,
+}) {
+  return shouldSkipRemoteStrategyFetch({
+    state,
+    apiKey,
+    nowMs,
+    cooldownMs,
+  }).skip;
+}
+
+export function clearRemoteStrategyFailureState() {
+  return null;
+}