openmerit 0.1.12 → 0.3.0

package/dist/terminal/src/scout-pi.d.ts

@@ -1,44 +0,0 @@
-import type { ScoutScope } from './scout-credentials.ts';
-export declare const piVersion = "1.5.0";
-type RecordValue = Record<string, unknown>;
-export declare function piPaths(root: string, scope: ScoutScope): {
-    skill: string;
-    rule: string;
-    connection: string;
-    record: string;
-    legacyRule: string;
-    mcpFile: string;
-    mcpScope: ScoutScope;
-    agentDir: string;
-};
-export declare function inspectPi(root: string, scope: ScoutScope): Promise<{
-    paths: {
-        skill: string;
-        rule: string;
-        connection: string;
-        record: string;
-        legacyRule: string;
-        mcpFile: string;
-        mcpScope: ScoutScope;
-        agentDir: string;
-    };
-    record: RecordValue;
-    owned: boolean;
-    current: string | null;
-    installedSkill: string | null;
-    installedRule: string | null;
-    serverOwned: boolean;
-    skillOwned: boolean;
-    ruleOwned: boolean;
-    updates: {
-        saved: null;
-        active: boolean;
-        conflicts: string[];
-    };
-    legacyRule: string;
-    shadowed: boolean;
-}>;
-export declare function piConflicts(state: Awaited<ReturnType<typeof inspectPi>>): string[];
-export declare function configurePi(root: string, scope: ScoutScope, credentialsPath: string, ids: RecordValue): Promise<void>;
-export declare function removePi(state: Awaited<ReturnType<typeof inspectPi>>): Promise<void>;
-export {};

package/dist/terminal/src/scout-pi.ts

@@ -1,76 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFile, mkdir, writeFile, rm } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import type { ScoutScope } from './scout-credentials.ts';
-import { scoutSkill } from './scout-instructions.ts';
-
-export const piVersion = '1.5.0';
-type RecordValue = Record<string, unknown>;
-const hash = (value: string) => createHash('sha256').update(value).digest('hex');
-const optional = async (path: string): Promise<string | null> => {
-  try { return await readFile(path, 'utf8'); }
-  catch (error) { if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return null; throw error; }
-};
-async function object(path: string): Promise<RecordValue> {
-  const value: unknown = JSON.parse(await optional(path) ?? '{}');
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`Invalid Scout installation metadata at ${path}; nothing changed.`);
-  return value as RecordValue;
-}
-export function piPaths(root: string, scope: ScoutScope) {
-  const agentDir = resolve(process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi/agent'));
-  const base = scope === 'user' ? agentDir : join(root, '.pi');
-  return { skill: join(base, 'skills/openmerit-scout/SKILL.md'), rule: join(base, 'extensions/openmerit-scout.ts'),
-    connection: join(base, 'extensions/openmerit-scout.json'), record: join(base, 'openmerit-install.json'),
-    legacyRule: join(base, 'rules/openmerit.md'), mcpFile: join(base, 'mcp.json'), mcpScope: scope, agentDir };
-}
-export async function inspectPi(root: string, scope: ScoutScope) {
-  const paths = piPaths(root, scope);
-  const otherPaths = piPaths(root, scope === 'user' ? 'project' : 'user');
-  const [record, connection, installedSkill, installedRule, mcp, otherMcp, other] = await Promise.all([
-    object(paths.record), optional(paths.connection), optional(paths.skill), optional(paths.rule), object(paths.mcpFile),
-    object(otherPaths.mcpFile), optional(otherPaths.rule),
-  ]);
-  const owned = record.version === 1 && record.client === 'pi' && record.scope === scope;
-  const matches = (value: string | null, field: string) => value === null || owned && [record[field], record[`pending${field[0]!.toUpperCase()}${field.slice(1)}`]].includes(hash(value));
-  return { paths, record, owned, current: connection, installedSkill, installedRule,
-    serverOwned: matches(connection, 'serverHash'), skillOwned: matches(installedSkill, 'skillHash'), ruleOwned: matches(installedRule, 'ruleHash'),
-    updates: { saved: null, active: false, conflicts: [] as string[] }, legacyRule: 'none',
-    shadowed: other !== null || [mcp, otherMcp].some(config => config.mcpServers && typeof config.mcpServers === 'object' && 'openmerit' in config.mcpServers),
-  };
-}
-export function piConflicts(state: Awaited<ReturnType<typeof inspectPi>>): string[] {
-  return [
-    ...(!state.serverOwned ? [`${state.paths.connection} was edited or is unowned.`] : []),
-    ...(!state.skillOwned ? [`${state.paths.skill} was edited or is unowned.`] : []),
-    ...(!state.ruleOwned ? [`${state.paths.rule} was edited or is unowned.`] : []),
-    ...(state.shadowed ? ['Another Pi Scout installation or an openmerit MCP entry shadows this installation. Resolve the duplicate before installing.'] : []),
-  ];
-}
-export async function configurePi(root: string, scope: ScoutScope, credentialsPath: string, ids: RecordValue) {
-  const state = await inspectPi(root, scope);
-  const conflicts = piConflicts(state);
-  if (conflicts.length) throw new Error(conflicts.join('\n'));
-  const extension = await readFile(new URL('../../../dist/pi/scout-extension.mjs', import.meta.url), 'utf8');
-  const connection = `${JSON.stringify({ credentialsPath }, null, 2)}\n`;
-  const skill = scoutSkill('pi');
-  const next = { version: 1, client: 'pi', scope, ...ids, serverHash: hash(connection), skillHash: hash(skill), ruleHash: hash(extension), installedAt: new Date().toISOString() };
-  const save = async (path: string, value: string | RecordValue) => {
-    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    await writeFile(path, typeof value === 'string' ? value : `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
-  };
-  // Record intent before writing files, so interrupted installs are recoverable.
-  await save(state.paths.record, { ...state.record, version: 1, client: 'pi', scope,
-    pendingServerHash: next.serverHash, pendingSkillHash: next.skillHash, pendingRuleHash: next.ruleHash });
-  await save(state.paths.connection, connection);
-  await save(state.paths.skill, skill);
-  await save(state.paths.rule, extension);
-  await save(state.paths.record, next);
-}
-export async function removePi(state: Awaited<ReturnType<typeof inspectPi>>) {
-  if (state.current !== null && state.serverOwned) await rm(state.paths.connection, { force: true });
-  if (state.installedRule !== null && state.ruleOwned) await rm(state.paths.rule, { force: true });
-  if (state.installedSkill !== null && state.skillOwned) await rm(state.paths.skill, { force: true });
-  // Keep ownership of edited files, so a future install does not adopt them.
-  if (state.serverOwned && state.ruleOwned && state.skillOwned) await rm(state.paths.record, { force: true });
-}

package/dist/terminal/src/server.mjs

@@ -1,95 +0,0 @@
-import { createServer } from 'node:http';
-import { readFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import { basename } from 'node:path';
-import { createCollector, loadConfig } from './collect.mjs';
-import { sampleSnapshot } from './sample.mjs';
-import { telemetryEnabled, terminalProperties, sendTerminalEvent, errorProperties } from './telemetry.mjs';
-
-const assets = new Map([['/', ['index.html', 'text/html']], ['/app.js', ['app.js', 'text/javascript']], ['/flow.js', ['flow.js', 'text/javascript']], ['/flow.css', ['flow.css', 'text/css']], ['/styles.css', ['styles.css', 'text/css']], ['/favicon.svg', ['favicon.svg', 'image/svg+xml']]]);
-for (const file of ['baseten.png', 'groq.ico', 'cerebras.png', 'qwen.png', 'meta.ico', 'nomic.png', 'baai.png', 'ollama.png', 'lm-studio.png', 'vllm.png', 'anthropic.png', 'google.png', 'deepseek.ico', 'cohere.png', 'openai.png', 'mistral.png', 'openrouter.png', 'huggingface.svg']) assets.set(`/brands/${file}`, [`brands/${file}`, file.endsWith('.svg') ? 'image/svg+xml' : file.endsWith('.ico') ? 'image/x-icon' : 'image/png']);
-
-export async function startTerminal({ root = process.cwd(), port = 4310, interval = 15, demo = false, collect: customCollect, config, fallbackPort = false } = {}) {
-  const collect = customCollect ?? (demo ? async () => sampleSnapshot() : createCollector(root, config ?? await loadConfig(root), interval, {backgroundIndex:true}));
-  let snapshot={schemaVersion:1,mode:demo?'sample':'live',loading:true,observedAt:null,interval,project:{name:basename(root),scope:'Current project'},models:[],records:[],sources:[],inventory:[],hosts:[],deployments:[],capacityPools:[],taskSummaries:[]};
-  let busy=false,closed=false,timer;
-  const update=async()=>{
-    if(busy||closed)return;
-    busy=true;
-    try {const next=await collect();if(!closed)snapshot=next;}
-    catch (error) {if(snapshot.loading)snapshot={...snapshot,loadError:true};sendTerminalEvent('terminal_error',{code:'collection_error',...errorProperties(error)});}
-    finally {busy=false;}
-  };
-  const server = createServer(async (request, response) => {
-    const address = server.address();
-    const validHosts = [`127.0.0.1:${address.port}`, `localhost:${address.port}`];
-    const host = request.headers.host;
-    const headers = { 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer', 'Content-Security-Policy': "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self'; img-src 'self' data:; font-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'" };
-    const send = (code, body, type = 'application/json') => { response.writeHead(code, { ...headers, 'Content-Type': `${type}; charset=utf-8` }); response.end(body); };
-    if (!validHosts.includes(host) || (request.headers.origin && request.headers.origin !== `http://${host}`) || request.headers['sec-fetch-site'] === 'cross-site') return send(403, '{"error":"Local access only"}');
-    let path;
-    try { path = new URL(request.url, `http://${host}`).pathname; }
-    catch { return send(400, '{"error":"Invalid request URL"}'); }
-    if (path === '/api/analytics' && request.method === 'POST') {
-      if (!telemetryEnabled() || request.headers.dnt === '1' || request.headers['sec-gpc'] === '1' || request.headers['x-scout-analytics'] === 'off') return send(204, '');
-      if (request.headers['content-type'] !== 'application/json') return send(415, '{}');
-      if (Number(request.headers['content-length']) > 2048) return send(413, '{}');
-      let size = 0, body = '', done = false;
-      const timeout = setTimeout(() => { if (!done) { done = true; send(408, '{}'); request.destroy(); } }, 1000);
-      request.on('data', chunk => {
-        if (done) return;
-        size += chunk.length;
-        if (size > 2048) { done = true; clearTimeout(timeout); send(413, '{}'); request.resume(); return; }
-        body += chunk.toString('utf8');
-      });
-      request.on('error', () => { done = true; clearTimeout(timeout); });
-      request.on('end', () => {
-        clearTimeout(timeout); if (done) return; done = true;
-        try {
-          const value = JSON.parse(body), properties = terminalProperties(value.event, value.properties);
-          if (!properties) return send(400, '{}');
-          sendTerminalEvent(value.event, properties);
-          return send(204, '');
-        } catch { return send(400, '{}'); }
-      });
-      return;
-    }
-    if (request.method !== 'GET') return send(405, '{"error":"Read-only terminal"}');
-    if (path === '/api/snapshot') {
-      const data=collect.current?.(snapshot)??snapshot;
-      const revision=new URL(request.url,`http://${host}`).searchParams.get('repositoryRevision');
-      // Browser refreshes can reuse the unchanged reference catalog. The plain
-      // API still returns a self-contained snapshot for agents and scripts.
-      if(data.repository&&revision!==null&&String(data.repository.revision)===revision) {
-        const {references,...repository}=data.repository;
-        return send(200,JSON.stringify({...data,repository}));
-      }
-      return send(200,JSON.stringify(data));
-    }
-    if (path === '/api/sample') return send(200, JSON.stringify(sampleSnapshot()));
-    if (path === '/api/info') return send(200, JSON.stringify({ version: 1, defaultMode: demo ? 'sample' : 'live', interval, telemetry: telemetryEnabled() }));
-    const asset = assets.get(path);
-    if (!asset) return send(404, '{"error":"Not found"}');
-    try { return send(200, await readFile(fileURLToPath(new URL(`../public/${asset[0]}`, import.meta.url))), asset[1]); }
-    catch { return send(500, '{"error":"Terminal assets unavailable. Run npm run build."}'); }
-  });
-  server.on('close', () => { closed=true;clearInterval(timer);void collect.close?.(); });
-  const listen = selectedPort => new Promise((resolve, reject) => {
-    const onError = error => { server.off('listening', onListening); reject(error); };
-    const onListening = () => { server.off('error', onError); resolve(); };
-    server.once('error', onError); server.once('listening', onListening);
-    server.listen(selectedPort, '127.0.0.1');
-  });
-  try {
-    try { await listen(port); }
-    catch (error) {
-      if (!fallbackPort || error.code !== 'EADDRINUSE') throw error;
-      await listen(0);
-    }
-  }
-  catch (error) { closed=true;clearInterval(timer);await collect.close?.();throw error; }
-  // Listen first. The browser can paint while collection and indexing proceed.
-  void update();
-  timer=setInterval(update,interval*1000);timer.unref();
-  return { server, url: `http://127.0.0.1:${server.address().port}`, close: async () => { closed=true;clearInterval(timer);await collect.close?.();await new Promise(resolve=>{server.close(resolve);server.closeIdleConnections();}); } };
-}

package/dist/terminal/src/service-registry.mjs

@@ -1,78 +0,0 @@
-// Shared, dependency-free service identities for passive discovery and the UI.
-// Endpoint formats checked against official API docs on 2026-10-10; see the guide.
-// A match identifies configuration, never connectivity, usage, a model, or a host.
-const define = (key, name, type, options = {}) => Object.freeze({ key, name, type, aliases: [], credentials: [], endpoints: [], hosts: [], ...options });
-const label = '[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?';
-const subdomains = suffix => new RegExp(`^(?:${label}\\.)+${suffix.replaceAll('.', '\\.')}$`);
-const resource = suffix => new RegExp(`^${label}\\.${suffix.replaceAll('.', '\\.')}$`);
-const region = '[a-z]{2}(?:-[a-z]+)+-\\d+';
-const hf = subdomains('endpoints.huggingface.cloud');
-const azureOpenAI = resource('openai.azure.com');
-const azureFoundry = resource('services.ai.azure.com');
-const bedrock = new RegExp(`^bedrock-runtime(?:-fips)?\\.${region}\\.amazonaws\\.com(?:\\.cn)?$`);
-const sagemaker = new RegExp(`^runtime(?:-fips)?\\.sagemaker\\.${region}\\.amazonaws\\.com(?:\\.cn)?$`);
-const vertex = /^(?:[a-z]+(?:-[a-z]+)*\d+-)?aiplatform\.googleapis\.com$/;
-const maas = new RegExp(`^${label}\\.(?:cn-beijing|cn-hongkong|ap-southeast-1|ap-northeast-1)\\.maas\\.aliyuncs\\.com$`);
-
-export const SERVICE_REGISTRY = Object.freeze([
-  define('openai', 'OpenAI', 'model-api', { aliases: ['openai api'], credentials: ['OPENAI_API_KEY'], endpoints: ['OPENAI_BASE_URL', 'OPENAI_API_BASE'], hosts: ['api.openai.com'] }),
-  define('anthropic', 'Anthropic', 'model-api', { aliases: ['anthropic api'], credentials: ['ANTHROPIC_API_KEY'], endpoints: ['ANTHROPIC_BASE_URL'], hosts: ['api.anthropic.com'] }),
-  define('openrouter', 'OpenRouter', 'gateway', { credentials: ['OPENROUTER_API_KEY'], endpoints: ['OPENROUTER_BASE_URL'], hosts: ['openrouter.ai'] }),
-  define('google', 'Google', 'model-api', { aliases: ['google ai', 'google api', 'gemini api'], credentials: ['GOOGLE_GENERATIVE_AI_API_KEY', 'GEMINI_API_KEY'], endpoints: ['GOOGLE_GEMINI_BASE_URL', 'GEMINI_BASE_URL'], hosts: ['generativelanguage.googleapis.com'] }),
-  define('groq', 'Groq', 'inference-cloud', { aliases: ['groq api', 'groqcloud'], credentials: ['GROQ_API_KEY'], endpoints: ['GROQ_BASE_URL'], hosts: ['api.groq.com'] }),
-  define('cerebras', 'Cerebras', 'inference-cloud', { aliases: ['cerebras api'], credentials: ['CEREBRAS_API_KEY'], endpoints: ['CEREBRAS_BASE_URL'], hosts: ['api.cerebras.ai'] }),
-  define('baseten', 'Baseten', 'inference-cloud', { aliases: ['baseten api'], credentials: ['BASETEN_API_KEY'], endpoints: ['BASETEN_BASE_URL'], hosts: ['inference.baseten.co'], match: url => /^model-[a-z0-9-]+\.api\.baseten\.co$/.test(url.hostname), redact: host => host.replace(/^model-[a-z0-9-]+(?=\.api\.baseten\.co$)/, 'model-…') }),
-  // Hub and general cloud tokens can authorize unrelated products or downloads.
-  define('huggingface-endpoints', 'Hugging Face Endpoints', 'inference-cloud', { aliases: ['hugging face inference endpoints'], endpoints: ['HF_INFERENCE_ENDPOINT', 'HF_ENDPOINT_URL', 'HUGGINGFACE_ENDPOINT_URL'], match: url => hf.test(url.hostname), redact: () => '….endpoints.huggingface.cloud' }),
-  define('huggingface-router', 'Hugging Face Router', 'router', { aliases: ['hugging face inference providers'], hosts: ['router.huggingface.co'] }),
-  define('mistral', 'Mistral', 'model-api', { aliases: ['mistral ai', 'mistral api'], credentials: ['MISTRAL_API_KEY'], endpoints: ['MISTRAL_BASE_URL', 'MISTRAL_SERVER_URL'], hosts: ['api.mistral.ai'] }),
-  define('deepseek', 'DeepSeek', 'model-api', { aliases: ['deepseek api'], credentials: ['DEEPSEEK_API_KEY'], endpoints: ['DEEPSEEK_BASE_URL'], hosts: ['api.deepseek.com'] }),
-  define('cohere', 'Cohere', 'model-api', { aliases: ['cohere api'], credentials: ['COHERE_API_KEY', 'CO_API_KEY'], endpoints: ['COHERE_BASE_URL'], hosts: ['api.cohere.ai', 'api.cohere.com'] }),
-  define('xai', 'xAI', 'model-api', { aliases: ['xai api'], credentials: ['XAI_API_KEY'], endpoints: ['XAI_BASE_URL'], hosts: ['api.x.ai'] }),
-  define('voyage', 'Voyage AI', 'model-api', { aliases: ['voyage', 'voyageai'], credentials: ['VOYAGE_API_KEY'], endpoints: ['VOYAGE_BASE_URL'], hosts: ['api.voyageai.com'] }),
-  define('jina', 'Jina AI', 'model-api', { aliases: ['jina'], endpoints: ['JINA_BASE_URL'], hosts: ['api.jina.ai'] }),
-  define('together', 'Together AI', 'inference-cloud', { aliases: ['together'], credentials: ['TOGETHER_API_KEY'], endpoints: ['TOGETHER_BASE_URL'], hosts: ['api.together.ai', 'api.together.xyz'] }),
-  define('fireworks', 'Fireworks AI', 'inference-cloud', { aliases: ['fireworks'], credentials: ['FIREWORKS_API_KEY'], endpoints: ['FIREWORKS_BASE_URL'], hosts: ['api.fireworks.ai'] }),
-  define('deepinfra', 'DeepInfra', 'inference-cloud', { credentials: ['DEEPINFRA_API_KEY', 'DEEPINFRA_API_TOKEN'], endpoints: ['DEEPINFRA_BASE_URL'], hosts: ['api.deepinfra.com'] }),
-  define('replicate', 'Replicate', 'inference-cloud', { credentials: ['REPLICATE_API_TOKEN'], endpoints: ['REPLICATE_BASE_URL'], hosts: ['api.replicate.com'] }),
-  define('nvidia-api', 'NVIDIA API Catalog', 'inference-cloud', { endpoints: ['NVIDIA_BASE_URL', 'NVIDIA_NIM_BASE_URL'], hosts: ['integrate.api.nvidia.com'] }),
-  define('sambanova', 'SambaNova', 'inference-cloud', { credentials: ['SAMBANOVA_API_KEY'], endpoints: ['SAMBANOVA_BASE_URL'], hosts: ['api.sambanova.ai'] }),
-  define('novita', 'Novita AI', 'inference-cloud', { aliases: ['novita'], credentials: ['NOVITA_API_KEY'], endpoints: ['NOVITA_BASE_URL'], hosts: ['api.novita.ai'] }),
-  define('nebius', 'Nebius Token Factory', 'inference-cloud', { aliases: ['nebius ai studio'], endpoints: ['NEBIUS_BASE_URL'], hosts: ['api.studio.nebius.ai', 'api.studio.nebius.com'] }),
-  define('siliconflow', 'SiliconFlow', 'inference-cloud', { credentials: ['SILICONFLOW_API_KEY'], endpoints: ['SILICONFLOW_BASE_URL'], hosts: ['api.siliconflow.com', 'api.siliconflow.cn'] }),
-  define('azure-openai', 'Azure OpenAI', 'inference-cloud', { endpoints: ['AZURE_OPENAI_ENDPOINT', 'AZURE_OPENAI_BASE_URL', 'AZURE_OPENAI_API_BASE'], match: url => azureOpenAI.test(url.hostname), redact: () => '….openai.azure.com' }),
-  define('azure-foundry', 'Azure AI Foundry', 'inference-cloud', { aliases: ['microsoft foundry'], endpoints: ['AZURE_AI_ENDPOINT', 'AZURE_AI_INFERENCE_ENDPOINT', 'AZURE_INFERENCE_ENDPOINT'], match: url => azureFoundry.test(url.hostname) && /^\/(?:$|(?:openai|models)(?:\/|$))/.test(url.pathname), redact: () => '….services.ai.azure.com' }),
-  define('bedrock', 'Amazon Bedrock', 'inference-cloud', { aliases: ['aws bedrock', 'bedrock'], credentials: ['AWS_BEARER_TOKEN_BEDROCK'], endpoints: ['AWS_ENDPOINT_URL_BEDROCK_RUNTIME', 'BEDROCK_ENDPOINT_URL', 'BEDROCK_BASE_URL'], match: url => bedrock.test(url.hostname) }),
-  define('sagemaker', 'Amazon SageMaker', 'inference-cloud', { aliases: ['aws sagemaker', 'sagemaker'], endpoints: ['AWS_ENDPOINT_URL_SAGEMAKER_RUNTIME', 'SAGEMAKER_ENDPOINT_URL', 'SAGEMAKER_BASE_URL'], match: url => sagemaker.test(url.hostname) }),
-  define('vertex', 'Google Vertex AI', 'inference-cloud', { aliases: ['vertex ai', 'vertex'], endpoints: ['VERTEX_AI_ENDPOINT', 'VERTEX_AI_BASE_URL'], match: url => vertex.test(url.hostname) }),
-  define('cloudflare-workers-ai', 'Cloudflare Workers AI', 'inference-cloud', { aliases: ['workers ai'], endpoints: ['CLOUDFLARE_WORKERS_AI_BASE_URL'], match: url => url.hostname === 'api.cloudflare.com' && /^\/client\/v4\/accounts\/[a-zA-Z0-9_-]+\/ai(?:\/|$)/.test(url.pathname) }),
-  define('cloudflare-ai-gateway', 'Cloudflare AI Gateway', 'gateway', { endpoints: ['CLOUDFLARE_AI_GATEWAY_URL'], hosts: ['gateway.ai.cloudflare.com'] }),
-  define('portkey', 'Portkey', 'gateway', { credentials: ['PORTKEY_API_KEY'], endpoints: ['PORTKEY_BASE_URL', 'PORTKEY_GATEWAY_URL'], hosts: ['api.portkey.ai'] }),
-  // The generic AI_GATEWAY_API_KEY name is shared by applications; require the URL.
-  define('vercel-ai-gateway', 'Vercel AI Gateway', 'gateway', { endpoints: ['AI_GATEWAY_BASE_URL', 'VERCEL_AI_GATEWAY_BASE_URL'], hosts: ['ai-gateway.vercel.sh'] }),
-  define('dashscope', 'Alibaba Cloud Model Studio', 'inference-cloud', { aliases: ['dashscope', 'alibaba model studio'], credentials: ['DASHSCOPE_API_KEY'], endpoints: ['DASHSCOPE_BASE_URL', 'DASHSCOPE_API_BASE'], hosts: ['dashscope.aliyuncs.com', 'dashscope-intl.aliyuncs.com', 'dashscope-us.aliyuncs.com', 'cn-hongkong.dashscope.aliyuncs.com'], match: url => maas.test(url.hostname), redact: host => maas.test(host) ? '….maas.aliyuncs.com' : host }),
-  define('minimax', 'MiniMax', 'model-api', { credentials: ['MINIMAX_API_KEY'], endpoints: ['MINIMAX_BASE_URL'], hosts: ['api.minimax.io'] }),
-  define('moonshot', 'Moonshot AI', 'model-api', { aliases: ['moonshot', 'kimi api'], credentials: ['MOONSHOT_API_KEY'], endpoints: ['MOONSHOT_BASE_URL'], hosts: ['api.moonshot.ai'] }),
-  define('zai', 'Z.AI', 'model-api', { aliases: ['zai'], credentials: ['ZAI_API_KEY'], endpoints: ['ZAI_BASE_URL'], hosts: ['api.z.ai'] }),
-  // Perplexity shares a host across products. Never turn a Search URL into Sonar.
-  define('perplexity-sonar', 'Perplexity Sonar', 'model-api', { endpoints: ['PERPLEXITY_BASE_URL'], match: url => url.hostname === 'api.perplexity.ai' && /^(?:\/?|\/chat\/completions\/?|\/v1\/?)$/.test(url.pathname) }),
-  define('perplexity-router', 'Perplexity Router', 'router', { match: url => url.hostname === 'api.perplexity.ai' && /^\/router(?:\/|$)/.test(url.pathname) }),
-  define('ollama', 'Ollama', 'runtime'),
-  define('vllm', 'vLLM', 'runtime'),
-  define('lm-studio', 'LM Studio', 'runtime'),
-]);
-const names = new Map(SERVICE_REGISTRY.flatMap(service => [service.name, ...service.aliases].map(name => [name.toLowerCase(), service])));
-export const registeredService = name => names.get(String(name ?? '').trim().toLowerCase()) ?? null;
-export const SERVICE_GROUPS = Object.freeze(SERVICE_REGISTRY.filter(service => service.credentials.length || service.endpoints.length));
-export const SERVICE_CREDENTIAL_FIELDS = Object.freeze(SERVICE_GROUPS.flatMap(service => service.credentials));
-export const SERVICE_ENDPOINT_FIELDS = Object.freeze(SERVICE_GROUPS.flatMap(service => service.endpoints));
-
-export function endpointService(value) {
-  if (typeof value !== 'string' || value.length > 2048 || /[\x00-\x20\x7f\\]/.test(value)) return null;
-  try {
-    const url = new URL(value);
-    if (url.protocol !== 'https:' || url.username || url.password || url.port) return null;
-    const service = SERVICE_REGISTRY.find(service => service.hosts.includes(url.hostname) || service.match?.(url));
-    return service ? { service, endpointHost: service.redact?.(url.hostname) ?? url.hostname } : null;
-  } catch { return null; }
-}

package/dist/terminal/src/services.mjs

@@ -1,44 +0,0 @@
-// Configuration evidence only. Never call services or return credentials or raw URLs.
-import { SERVICE_GROUPS, endpointService } from './service-registry.mjs';
-
-export const serviceFromEndpoint = value => endpointService(value)?.service.name ?? null;
-export function configuredServices(env = {}) {
-  const found = new Map(), unrecognizedEndpoints = [];
-  const present = key => typeof env[key] === 'string' && env[key].trim().length > 0;
-  const add = (service, field, basis, endpointHost) => {
-    const { name, type } = service;
-    const kind = ['router', 'gateway'].includes(type) ? type : 'provider';
-    const item = found.get(name) ?? { name, kind, ...(['model-api', 'inference-cloud'].includes(type) ? { serviceType: type } : {}), location: 'cloud', state: 'configured', sourceId: 'environment', evidence: [] };
-    item.evidence.push({ field, basis, ...(endpointHost ? { endpointHost } : {}) }); found.set(name, item);
-  };
-  for (const group of SERVICE_GROUPS) {
-    const overrides = group.endpoints.filter(present);
-    if (overrides.length) {
-      for (const field of overrides) {
-        const match = endpointService(env[field]);
-        if (match) add(match.service, field, 'endpoint-host', match.endpointHost);
-        else unrecognizedEndpoints.push(field);
-      }
-      // An override can repurpose the SDK credential. Unknown/local overrides
-      // must suppress the vendor fallback too; the key name is not enough.
-    } else for (const field of group.credentials.filter(present)) add(group, field, 'credential-name');
-  }
-  return { services: [...found.values()], unrecognizedEndpoints };
-}
-
-// Multiple reports for one model/service may disagree. Preserve the gap rather
-// than choosing whichever file or record happened to be processed first.
-export function modelCreators(models, reports) {
-  const evidence = new Map();
-  for (const item of [...models, ...reports]) {
-    if (!item.modelCreator) continue;
-    const key = JSON.stringify([item.provider, item.model ?? item.name]);
-    const entry = evidence.get(key) ?? { names: new Set(), sources: new Set() };
-    entry.names.add(item.modelCreator); if (item.sourceId) entry.sources.add(item.sourceId);
-    evidence.set(key, entry);
-  }
-  return models.map(model => {
-    const entry = evidence.get(JSON.stringify([model.provider, model.name]));
-    return { ...model, modelCreator: entry?.names.size === 1 ? [...entry.names][0] : null, creatorConflict: (entry?.names.size ?? 0) > 1, creatorSources: [...(entry?.sources ?? [])] };
-  });
-}

package/dist/terminal/src/topology.mjs

@@ -1,30 +0,0 @@
-// Bounded metadata contracts. Never retain endpoints, credentials, or payloads.
-const label = value => typeof value === 'string' ? value.slice(0, 160).replace(/[\x00-\x1f]/g, '') : '';
-const count = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
-const timestamp = value => typeof value === 'string' && Number.isFinite(Date.parse(value)) ? new Date(value).toISOString() : null;
-const list = (value, limit) => Array.isArray(value) ? value.slice(0, limit).filter(item => item && typeof item === 'object') : [];
-export const poolIds = value => Array.isArray(value) ? [...new Set(value.slice(0, 16).map(label).filter(Boolean))] : [];
-export function normalizePath(value) {
-  // Do not turn a broken path into an apparently complete chain by dropping hops.
-  if (!Array.isArray(value) || !value.length || value.length > 8 || value.some(hop => !hop || !label(hop.name))) return [];
-  return value.map(hop => ({ name: label(hop.name), kind: ['direct', 'local', 'router', 'gateway'].includes(hop.kind) ? hop.kind : 'unknown' }));
-}
-function unique(items) {
-  const counts = new Map();
-  for (const item of items) counts.set(item.id, (counts.get(item.id) ?? 0) + 1);
-  return items.filter(item => item.id && counts.get(item.id) === 1);
-}
-export function normalizeDeployments(value) {
-  return unique(list(value, 200).map(item => ({ id: label(item.id), name: label(item.name) || label(item.id), model: label(item.model), modelCreator: label(item.modelCreator) || null, servingMode: ['shared', 'dedicated', 'self-hosted'].includes(item.servingMode) ? item.servingMode : 'unknown', provider: label(item.provider) || 'Unattributed', location: ['local', 'private', 'cloud'].includes(item.location) ? item.location : 'unknown', poolIds: poolIds(item.poolIds), hostId: label(item.hostId) || null, sourceId: 'inventory', state: 'configured' })).filter(item => item.model && !item.id.startsWith('runtime:')));
-}
-export function normalizePools(value) {
-  return unique(list(value, 100).map(item => ({ id: label(item.id), name: label(item.name) || label(item.id), kind: ['quota', 'runtime', 'gateway'].includes(item.kind) ? item.kind : 'unknown', windowSeconds: count(item.windowSeconds), sourceId: 'capacity', observedAt: null, metrics: {} })).filter(item => !item.id.startsWith('runtime:')));
-}
-export function normalizeCapacity(value, now = Date.now()) {
-  return unique(list(value?.pools, 100).map(item => {
-    const observedAt = timestamp(item.observedAt);
-    const metrics = Object.fromEntries(['running', 'waiting', 'concurrencyLimit', 'requestsUsed', 'requestsLimit', 'tokensUsed', 'tokensLimit', 'cachePercent', 'memoryUsedBytes', 'memoryTotalBytes'].map(key => [key, count(item.metrics?.[key])]).filter(([, value]) => value !== null));
-    if (metrics.cachePercent > 100) delete metrics.cachePercent;
-    return { id: label(item.id), observedAt, resetAt: timestamp(item.resetAt), metrics };
-  }).filter(item => item.observedAt && Date.parse(item.observedAt) <= now));
-}

package/dist/terminal/src/updates.d.ts

@@ -1,62 +0,0 @@
-type ObjectValue = Record<string, unknown>;
-interface UpdateRecord {
-    enabled: boolean;
-    version: string;
-    runnerHash: string;
-    hook: ObjectValue;
-}
-export declare const updateContract = "scout-recommend-v1";
-export declare function updatePaths(base: string, scope: string): {
-    record: string;
-    runner: string;
-    settings: string;
-    state: string;
-    backup: string;
-    skill: string;
-    rule: string;
-};
-export declare function withUpdateLock<T>(base: string, work: () => Promise<T>): Promise<T>;
-export declare function inspectUpdates(base: string, scope: string, record: ObjectValue): Promise<{
-    paths: {
-        record: string;
-        runner: string;
-        settings: string;
-        state: string;
-        backup: string;
-        skill: string;
-        rule: string;
-    };
-    saved: UpdateRecord | null;
-    runner: string | null;
-    settings: ObjectValue;
-    hooks: ObjectValue;
-    conflicts: string[];
-    active: boolean;
-}>;
-export declare function configureUpdates(base: string, scope: string, record: ObjectValue, version: string, enabled: boolean): Promise<{
-    enabled: boolean;
-    version: string;
-    runnerHash: string;
-    hook: {
-        hooks: {
-            type: string;
-            command: string;
-            async: boolean;
-            timeout: number;
-        }[];
-    };
-}>;
-export declare function removeUpdates(base: string, scope: string, record: ObjectValue): Promise<void>;
-export declare function recoverUpdates(base: string, scope: string): Promise<void>;
-export interface UpdateResult {
-    status: string;
-    message: string;
-    version?: string;
-}
-export declare function runUpdate(base: string, scope: string, options?: {
-    hook?: boolean;
-    enabled?: boolean;
-    fetcher?: typeof fetch;
-    now?: number;
-}): Promise<UpdateResult>;
-export {};