@geraldmaron/construct 1.2.2 → 1.3.0

package/lib/chat/model-picker.mjs

@@ -1,356 +0,0 @@
-/**
- * lib/chat/model-picker.mjs — model list data for the construct chat picker.
- *
- * Curates a short list: free-router auto-pick, live OpenRouter free models,
- * configured provider tier defaults, and the active session model. Persistence
- * reuses saveChatConfig from lib/chat/config.mjs.
- */
-
-import { saveChatConfig } from './config.mjs';
-import { hasAnySecret } from '../providers/secret-resolver.mjs';
-import { getProviderModelCatalog, isChatModelAvailable } from '../model-router.mjs';
-import {
-  pollConfiguredProviders,
-  readProviderCatalogCache,
-} from '../models/provider-poll.mjs';
-import { resolveFreeOpenRouterModel } from '../../apps/chat/engine/models.mjs';
-import { filterPickerItems, pickerStartIndex, windowPickerItems } from './list-picker.mjs';
-
-export { filterPickerItems, pickerStartIndex, windowPickerItems };
-
-export const FREE_ROUTER_ITEM_ID = '__free_router__';
-
-export function sortModelsForPicker(models = []) {
-  return [...models].sort(
-    (a, b) => Number(Boolean(b.action === 'free-router')) - Number(Boolean(a.action === 'free-router'))
-      || Number(Boolean(b.isFree)) - Number(Boolean(a.isFree))
-      || Number(b.suitable !== false) - Number(a.suitable !== false)
-      || Number(Boolean(b.isProviderDefault)) - Number(Boolean(a.isProviderDefault))
-      || String(a.label || a.id).localeCompare(String(b.label || b.id)),
-  );
-}
-
-function shortModelLabel(id) {
-  if (!id) return id;
-  const name = id.replace(/^openrouter\//, '');
-  const slash = name.lastIndexOf('/');
-  return slash >= 0 ? name.slice(slash + 1) : name;
-}
-
-function catalogItem(model) {
-  const id = model.id;
-  const isFree = id.includes(':free') || model.isFree === true;
-  return {
-    id,
-    label: model.label || (isFree ? shortModelLabel(id) : id),
-    tag: model.action === 'free-router' ? 'router' : isFree ? 'free' : model.local ? 'local' : model.tier || null,
-    detail: model.detail || model.name || (model.configured === false ? 'not configured' : null),
-    isFree,
-    action: model.action || null,
-    suitable: model.suitable,
-    disabled: model.disabled === true,
-  };
-}
-
-export function configuredTierPickerItems({ env = process.env } = {}) {
-  const { providers } = getProviderModelCatalog({ env });
-  const items = [];
-  const seen = new Set();
-  for (const provider of providers) {
-    if (!provider.configured) continue;
-    for (const tier of ['reasoning', 'standard', 'fast']) {
-      const id = provider.tiers?.[tier];
-      if (!id || seen.has(id)) continue;
-      seen.add(id);
-      const availability = isChatModelAvailable(id, { env });
-      const notPulled = availability.reason === 'model_not_pulled';
-      items.push(catalogItem({
-        id,
-        label: id,
-        name: `${provider.label} · ${tier}`,
-        tier,
-        configured: availability.ok,
-        suitable: availability.ok,
-        isProviderDefault: tier === 'standard',
-        disabled: !availability.ok,
-        detail: notPulled
-          ? `not installed — run ollama pull ${availability.nativeModel || id.replace(/^ollama\//, '')}`
-          : availability.ok ? null : availability.reason?.replace(/_/g, ' ') || 'unavailable',
-      }));
-    }
-  }
-  return { items, seen };
-}
-
-function capabilityBadges(model) {
-  const badges = [];
-  if (model.reasoning) badges.push('reasoning');
-  if (model.vision) badges.push('vision');
-  if (model.tools) badges.push('tools');
-  return badges;
-}
-
-function priceLabel(pricing) {
-  if (!pricing) return null;
-  if (pricing.input === 0 && pricing.output === 0) return null;
-  const fmt = (n) => (n >= 1 ? n.toFixed(2) : n.toFixed(3));
-  return `$${fmt(pricing.input)} in · $${fmt(pricing.output)} out / 1M`;
-}
-
-function contextLabel(context) {
-  if (!context) return null;
-  if (context >= 1_000_000) return `${(context / 1_000_000).toFixed(1).replace(/\.0$/, '')}M ctx`;
-  if (context >= 1000) return `${Math.round(context / 1000)}K ctx`;
-  return `${context} ctx`;
-}
-
-function pickerItemFromModel(model, groupLabel) {
-  if (model.source === 'hint' || model.disabled) {
-    return {
-      id: model.id,
-      label: model.label || model.id,
-      group: groupLabel,
-      tag: null,
-      badges: [],
-      detail: null,
-      isFree: false,
-      suitable: false,
-      disabled: true,
-      source: model.source || 'hint',
-    };
-  }
-  const badges = capabilityBadges(model);
-  const price = priceLabel(model.pricing);
-  const detailParts = [];
-  if (model.free) detailParts.push(model.provider === 'ollama' ? 'free · runs locally' : 'free');
-  else if (price) detailParts.push(price);
-  const ctx = contextLabel(model.context);
-  if (ctx) detailParts.push(ctx);
-  if (model.source === 'cached') detailParts.push('cached — provider offline');
-
-  // The OpenRouter free router answers from whatever free model is available, so
-  // quality and behavior vary turn to turn — say so before it is selected.
-  if (/^openrouter\/openrouter\/(free|auto)\b/.test(String(model.id))) {
-    detailParts.push('variable quality — routes to a random free model');
-  }
-  return {
-    id: model.id,
-    label: model.label || shortModelLabel(model.id),
-    group: groupLabel,
-    tag: model.free ? 'free' : null,
-    badges,
-    price: model.free ? null : price,
-    context: model.context || null,
-    detail: detailParts.join(' · ') || null,
-    isFree: Boolean(model.free),
-    suitable: true,
-    disabled: false,
-    source: model.source || 'live',
-  };
-}
-
-// One picker payload: the free-router auto-pick on top, then every configured
-// provider's live catalog grouped under its label. Polling is best-effort; on a
-// total failure the cached groups (or nothing beyond free-router) are used so the
-// picker still opens.
-export async function loadModelPickerItems(_driver, { env = process.env, cwd = process.cwd(), currentModel = null, modelMode = 'pinned', pollProviders = pollConfiguredProviders } = {}) {
-  const items = [];
-  const seen = new Set();
-
-  const hasOpenRouter = hasAnySecret(['OPENROUTER_API_KEY', 'OPEN_ROUTER_API_KEY'], { env });
-  items.push({
-    id: FREE_ROUTER_ITEM_ID,
-    label: 'OpenRouter free router — auto-pick best standard model',
-    group: 'Smart routing',
-    tag: 'router',
-    badges: [],
-    detail: hasOpenRouter
-      ? 'auto-picks a free model + retries on failure; not pinned — quality varies'
-      : 'needs OPENROUTER_API_KEY in ~/.construct/config.env',
-    action: 'free-router',
-    configured: hasOpenRouter,
-    disabled: !hasOpenRouter,
-  });
-  seen.add(FREE_ROUTER_ITEM_ID);
-
-  let groups = [];
-  try {
-    groups = await pollProviders({ env, cwd });
-  } catch {
-    groups = readProviderCatalogCache() || [];
-  }
-
-  for (const group of groups) {
-    const sorted = [...group.models].sort(
-      (a, b) => Number(Boolean(b.free)) - Number(Boolean(a.free))
-        || String(a.label || a.id).localeCompare(String(b.label || b.id)),
-    );
-    for (const model of sorted) {
-      if (seen.has(model.id)) continue;
-
-      // The chat loop always dispatches tools, so a model the provider reports as
-      // tool-incapable can only ever error out — drop it from the picker. Only
-      // filter when the provider actually told us (toolsKnown); an unknown
-      // capability (e.g. a local Ollama tag) stays selectable.
-      if (!model.disabled && model.source !== 'hint' && model.toolsKnown === true && !model.tools) {
-        seen.add(model.id);
-        continue;
-      }
-
-      seen.add(model.id);
-      items.push(pickerItemFromModel(model, group.label));
-    }
-  }
-
-  if (currentModel && modelMode !== 'free-router' && !seen.has(currentModel)) {
-    seen.add(currentModel);
-    items.push(pickerItemFromModel(
-      { id: currentModel, label: currentModel, free: false, source: 'live' },
-      'Current session',
-    ));
-  }
-
-  return items;
-}
-
-export async function resolveModelPickerSelection(item, { env = process.env } = {}) {
-  if (!item) return null;
-  if (item.action === 'free-router' || item.id === FREE_ROUTER_ITEM_ID) {
-    const modelId = await resolveFreeOpenRouterModel({ env, tier: 'standard' });
-    return modelId ? { mode: 'free-router', modelId } : null;
-  }
-  return { mode: 'pinned', modelId: item.id };
-}
-
-export function commitPickerModel(session, selection, { cwd, hostId = 'construct', layers = null } = {}) {
-  const normalized = typeof selection === 'string'
-    ? { mode: 'pinned', modelId: selection }
-    : selection;
-  if (!normalized?.modelId && normalized?.mode !== 'free-router') return null;
-
-  session.modelMode = normalized.mode || 'pinned';
-  session.model = normalized.modelId;
-  session.savedModel = session.modelMode === 'pinned' ? normalized.modelId : null;
-  session.modelNotice = null;
-
-  try {
-    saveChatConfig({
-      host: hostId,
-      model: session.modelMode === 'pinned' ? session.model : null,
-      modelMode: session.modelMode,
-      layers: layers || session.layers,
-      thinking: (layers || session.layers)?.thinking,
-      permissionMode: session.permissionMode,
-      sandbox: session.sandbox,
-      ui: session.ui,
-    }, { cwd });
-  } catch { /* persistence is best-effort */ }
-  return normalized;
-}
-
-export function pickerSelectedId(session) {
-  if (session?.modelMode === 'free-router') return FREE_ROUTER_ITEM_ID;
-  return session?.savedModel || session?.model || null;
-}
-
-export function formatModelHeader(session) {
-  if (session?.modelMode === 'free-router') {
-    const slug = session.model ? session.model.replace(/^openrouter\//, '') : '(resolving…)';
-    return { label: `free router → ${slug}`, isRouter: true };
-  }
-  const active = session?.model || '(no model)';
-  const saved = session?.savedModel;
-  if (saved && saved !== session?.model) {
-    return { label: active, savedPin: saved, isRouter: false };
-  }
-  return { label: active, isRouter: false };
-}
-
-function formatPickerLine(item, colors, { selected = false } = {}) {
-  const marker = selected ? `${colors.green}●${colors.reset}` : ' ';
-  const tag = item.tag ? `${colors.dim} [${item.tag}]${colors.reset}` : '';
-  const badges = item.badges?.length ? `${colors.dim} ${item.badges.map((b) => `·${b}`).join(' ')}${colors.reset}` : '';
-  const disabled = item.disabled ? `${colors.dim} (unavailable)${colors.reset}` : '';
-  const detail = item.detail ? `\n      ${colors.dim}${item.detail}${colors.reset}` : '';
-  return `  ${marker} ${item.label || item.id}${tag}${badges}${disabled}${detail}`;
-}
-
-export async function promptModelPickerTerminal({
-  output,
-  colors,
-  session,
-  rl = null,
-  askFn = null,
-  env = process.env,
-  cwd = process.cwd(),
-  hostId = 'construct',
-  layers = session?.layers,
-  pollProviders = pollConfiguredProviders,
-} = {}) {
-  const items = await loadModelPickerItems(null, {
-    env,
-    cwd,
-    currentModel: session?.model,
-    modelMode: session?.modelMode || 'pinned',
-    pollProviders,
-  });
-  if (!items.length) {
-    output.write(`${colors.dim}no models to pick from — set a provider key in ~/.construct/config.env or use /model <id>${colors.reset}\n`);
-    return null;
-  }
-
-  const selectedId = pickerSelectedId(session);
-  output.write(`${colors.bold}select a model${colors.reset}\n`);
-  output.write(`${colors.dim}enter a number, or press enter to cancel${colors.reset}\n`);
-  const groupCounts = new Map();
-  for (const item of items) {
-    if (!item.group || item.disabled) continue;
-    groupCounts.set(item.group, (groupCounts.get(item.group) || 0) + 1);
-  }
-  let lastGroup = null;
-  items.forEach((item, i) => {
-    if (item.group && item.group !== lastGroup) {
-      lastGroup = item.group;
-      const count = groupCounts.get(item.group);
-      const suffix = count ? ` (${count})` : '';
-      output.write(`\n${colors.dim}── ${item.group}${suffix} ──${colors.reset}\n`);
-    }
-    output.write(`${String(i + 1).padStart(2)}.${formatPickerLine(item, colors, { selected: item.id === selectedId })}\n`);
-  });
-
-  const prompt = `${colors.green}model #${colors.reset} `;
-  const answer = rl
-    ? (await new Promise((resolve) => rl.question(prompt, resolve))).trim()
-    : askFn
-      ? String(await askFn(prompt)).trim()
-      : '';
-  if (!answer) {
-    output.write(`${colors.dim}${rl || askFn ? 'cancelled' : 'pick one with /model <id> or use the Ink UI for search'}${colors.reset}\n`);
-    return null;
-  }
-
-  const idx = Number(answer) - 1;
-  if (!Number.isInteger(idx) || idx < 0 || idx >= items.length) {
-    output.write(`${colors.red}invalid selection${colors.reset}\n`);
-    return null;
-  }
-
-  const item = items[idx];
-  if (item.disabled) {
-    output.write(`${colors.red}${item.detail || 'model not available'}${colors.reset}\n`);
-    return null;
-  }
-
-  const selection = await resolveModelPickerSelection(item, { env });
-  if (!selection?.modelId && selection?.mode !== 'free-router') {
-    output.write(`${colors.red}could not resolve model${colors.reset}\n`);
-    return null;
-  }
-
-  commitPickerModel(session, selection, { cwd, hostId, layers });
-  const label = selection.mode === 'free-router'
-    ? `free-router → ${selection.modelId}`
-    : selection.modelId;
-  output.write(`${colors.green}model set:${colors.reset} ${label} ${colors.dim}(saved)${colors.reset}\n`);
-  return selection;
-}

package/lib/chat/openrouter-fallback.mjs

@@ -1,151 +0,0 @@
-/**
- * lib/chat/openrouter-fallback.mjs — OpenRouter failure parsing and turn-time fallback.
- *
- * When a free slug returns 404/429 at call time, walks the live poll for the next
- * candidate. When an Ollama tag is pinned but not pulled, falls through to the
- * next configured provider for the same turn (mirroring session launch resolution).
- */
-
-import { classifyProviderFailure, resolveValidatedChatModel } from '../model-router.mjs';
-
-const MAX_FALLBACK_ATTEMPTS = 3;
-
-export function parseOpenRouterError(error) {
-  const text = typeof error === 'string' ? error : String(error?.message || error || '');
-  let raw = text;
-  try {
-    const jsonMatch = text.match(/\{[\s\S]*\}/);
-    if (jsonMatch) {
-      const body = JSON.parse(jsonMatch[0]);
-      raw = body?.error?.metadata?.raw || body?.error?.message || text;
-    }
-  } catch { /* not JSON */ }
-
-  let summary = raw;
-  const ollamaMissing = raw.match(/model ['"]([^'"]+)['"] not found/i);
-  if (ollamaMissing) {
-    const native = ollamaMissing[1];
-    summary = `Ollama model '${native}' is not installed locally. Pull it with: ollama pull ${native} (or: construct ollama pull ${native})`;
-  } else if (/rate[- ]?limit|429|temporarily rate-limited/i.test(raw)) {
-    summary = raw.replace(/^Provider returned error\.?\s*/i, '').trim() || 'rate-limited upstream';
-  } else if (/unavailable for free|paid version is available/i.test(raw)) {
-    summary = 'free tier retired — use a different free model or paid slug';
-  } else if (/Failed after \d+ attempts/i.test(text)) {
-    summary = raw || 'provider error after retries';
-  } else if (/OLLAMA_MODEL_NOT_PULLED|not installed locally/i.test(raw)) {
-    summary = raw;
-  }
-
-  return { raw, summary, text };
-}
-
-export function ensureFailedModels(session) {
-  if (!session.failedModels) session.failedModels = new Set();
-  return session.failedModels;
-}
-
-export function recordFailedModel(session, modelId) {
-  if (!modelId) return;
-  ensureFailedModels(session).add(modelId);
-}
-
-export function getExcludeList(session) {
-  return [...ensureFailedModels(session)];
-}
-
-export function shouldAttemptFreeFallback(session, modelId) {
-  if (session?.modelMode === 'free-router') return true;
-  return typeof modelId === 'string' && /:free$/i.test(modelId);
-}
-
-export function isOllamaNotPulledError(error) {
-  const text = typeof error === 'string' ? error : String(error?.message || error || '');
-  return error?.code === 'OLLAMA_MODEL_NOT_PULLED' || /not installed locally/i.test(text);
-}
-
-export async function handleOllamaNotPulledFailure({ session, error, env = process.env, currentModel }) {
-  if (!isOllamaNotPulledError(error)) return null;
-  if (typeof currentModel !== 'string' || !currentModel.startsWith('ollama/')) return null;
-
-  recordFailedModel(session, currentModel);
-  const excludeFamilies = typeof currentModel === 'string' && currentModel.startsWith('ollama/')
-    ? ['ollama']
-    : [];
-  const next = resolveValidatedChatModel({ env, requested: null, excludeFamilies });
-  if (!next?.id || next.id === currentModel) return null;
-
-  const parsed = parseOpenRouterError(error);
-  return {
-    modelId: next.id,
-    notice: `${parsed.summary} Switched to ${next.id} for this turn.`,
-  };
-}
-
-export async function handleModelFailure(opts) {
-  const openRouter = await handleOpenRouterFailure(opts);
-  if (openRouter) return openRouter;
-  return handleOllamaNotPulledFailure(opts);
-}
-
-export async function handleOpenRouterFailure({ session, error, env = process.env, currentModel }) {
-  const parsed = parseOpenRouterError(error);
-  const classified = classifyProviderFailure({ error: { message: parsed.text || parsed.raw } });
-  if (!classified?.retryable) return null;
-  if (!shouldAttemptFreeFallback(session, currentModel)) return null;
-
-  recordFailedModel(session, currentModel);
-  const exclude = getExcludeList(session);
-  const { resolveFreeOpenRouterModel } = await import('../../apps/chat/engine/models.mjs');
-  const next = await resolveFreeOpenRouterModel({ env, tier: 'standard', exclude });
-  if (!next || next === currentModel) return null;
-
-  const short = (id) => id.replace(/^openrouter\//, '');
-  return {
-    modelId: next,
-    notice: `${short(currentModel)} failed (${parsed.summary}). Switched to ${short(next)}. Retry or /model to pick manually.`,
-  };
-}
-
-export async function runTurnWithFallback({
-  driver,
-  text,
-  session,
-  layers,
-  env,
-  promptOptions = {},
-  runTurnInto,
-  onUpdate = () => {},
-}) {
-  let model = session.model;
-  let lastState = null;
-  let lastNotice = null;
-
-  for (let attempt = 0; attempt < MAX_FALLBACK_ATTEMPTS; attempt++) {
-    lastState = await runTurnInto(
-      driver,
-      text,
-      { ...promptOptions, model, turnOverlay: promptOptions.turnOverlay },
-      { session, layers, onUpdate },
-    );
-
-    if (!lastState.error) {
-      return { state: lastState, model, notice: lastNotice };
-    }
-
-    const fallback = await handleModelFailure({
-      session,
-      error: lastState.error,
-      env,
-      currentModel: model,
-    });
-    if (!fallback) break;
-
-    model = fallback.modelId;
-    session.model = model;
-    lastNotice = fallback.notice;
-  }
-
-  return { state: lastState, model, notice: lastNotice };
-}
-
-export { MAX_FALLBACK_ATTEMPTS };

package/lib/chat/permission-prompt.mjs

@@ -1,33 +0,0 @@
-/**
- * lib/chat/permission-prompt.mjs — interactive permission decisions for ask mode.
- *
- * Maps user keystrokes and readline answers to the host-agnostic decision
- * vocabulary (allow | allow_always | reject) shared by the permission gate
- * (apps/chat/engine/tools/permission.mjs). Both the Ink overlay and the linear
- * readline prompt use the same parser so behaviour stays identical.
- */
-
-export function formatPermissionQuestion({ tool = 'tool', input = null } = {}) {
-  const detail = input && typeof input === 'object'
-    ? Object.keys(input).slice(0, 3).join(', ')
-    : '';
-  const suffix = detail ? ` (${detail})` : '';
-  return `Allow "${tool}"${suffix}?  [y] once  [a] always  [n] reject`;
-}
-
-export function parsePermissionDecision(raw) {
-  const s = String(raw ?? '').trim().toLowerCase();
-  if (['a', 'always', 'allow_always', 'all'].includes(s)) return 'allow_always';
-  if (['n', 'no', 'reject', 'r', 'deny', '0'].includes(s)) return 'reject';
-  if (['y', 'yes', 'allow', 'once', '1', ''].includes(s)) return 'allow';
-  return null;
-}
-
-export function parsePermissionKey(char) {
-  if (!char) return null;
-  const c = char.toLowerCase();
-  if (c === 'a') return 'allow_always';
-  if (c === 'n' || c === 'r') return 'reject';
-  if (c === 'y') return 'allow';
-  return null;
-}

package/lib/chat/picker-catalog.mjs

@@ -1,45 +0,0 @@
-/**
- * lib/chat/picker-catalog.mjs — predefined list-picker item sets for construct chat.
- */
-
-import { LAYER_KEYS, PERMISSION_MODES, SANDBOX_LEVELS, INSPECTOR_MODES } from './config.mjs';
-
-export const PERMISSION_PICKER_ITEMS = Object.freeze([
-  { id: 'allow', label: 'Allow once', detail: 'y' },
-  { id: 'allow_always', label: 'Allow always', detail: 'a' },
-  { id: 'reject', label: 'Reject', detail: 'n' },
-]);
-
-export const BOOL_PICKER_ITEMS = Object.freeze([
-  { id: 'on', label: 'on', detail: 'true' },
-  { id: 'off', label: 'off', detail: 'false' },
-]);
-
-export function settingKeyPickerItems() {
-  return [
-    { id: 'thinking', label: 'thinking', tag: 'bool' },
-    ...LAYER_KEYS.map((k) => ({ id: k, label: k, tag: 'layer' })),
-    { id: 'permission', label: 'permission mode', tag: 'enum' },
-    { id: 'sandbox', label: 'sandbox', tag: 'enum' },
-    { id: 'inspector', label: 'inspector panel', tag: 'enum' },
-    { id: 'ascii', label: 'ascii glyphs', tag: 'bool' },
-    { id: 'theme', label: 'color theme', tag: 'enum' },
-    { id: 'model', label: 'model', tag: 'model' },
-  ];
-}
-
-export function enumPickerItems(key) {
-  if (key === 'permission') return PERMISSION_MODES.map((v) => ({ id: v, label: v }));
-  if (key === 'sandbox') return SANDBOX_LEVELS.map((v) => ({ id: v, label: v }));
-  if (key === 'inspector') return INSPECTOR_MODES.map((v) => ({ id: v, label: v }));
-  if (key === 'theme') return ['auto', 'light', 'dark'].map((v) => ({ id: v, label: v }));
-  return [];
-}
-
-export function isBoolSetting(key) {
-  return key === 'thinking' || key === 'ascii' || LAYER_KEYS.includes(key);
-}
-
-export function isEnumSetting(key) {
-  return key === 'permission' || key === 'sandbox' || key === 'inspector' || key === 'theme';
-}

package/lib/chat/policy-telemetry.mjs

@@ -1,34 +0,0 @@
-/**
- * lib/chat/policy-telemetry.mjs — bounded sink for execution-policy degraded-mode
- * events (construct-6zga.1.2 / construct-rv2x).
- *
- * When the owned loop compiles a turn's execution policy from a missing, unknown,
- * or degraded capability profile, the policy collapses to the conservative
- * envelope. The engine records that fact here instead of printing to the chat
- * stream so the degradation is observable (dashboard, diagnostics) without
- * touching the renderer event union or the live transcript. The buffer is
- * in-process and bounded; it is a diagnostic signal, not durable state.
- */
-
-const RECENT = [];
-const MAX_EVENTS = 50;
-
-export function recordPolicyTelemetry(event = {}) {
-  const entry = {
-    kind: typeof event.kind === 'string' ? event.kind : 'execution-policy-degraded',
-    model: event.model ?? null,
-    capabilityClass: event.capabilityClass ?? 'unknown',
-    reasons: Array.isArray(event.reasons) ? [...event.reasons] : [],
-  };
-  RECENT.push(entry);
-  if (RECENT.length > MAX_EVENTS) RECENT.shift();
-  return entry;
-}
-
-export function recentPolicyTelemetry() {
-  return RECENT.map((e) => ({ ...e, reasons: [...e.reasons] }));
-}
-
-export function clearPolicyTelemetry() {
-  RECENT.length = 0;
-}