openmerit 0.2.0 → 0.3.0

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

@@ -1,119 +0,0 @@
-import type { ScoutClient } from './scout-credentials.ts';
-
-export const rule = `# Application model decisions · OpenMerit Scout
-
-Before choosing, recommending, adding, downloading, replacing or configuring
-ANY application inference model, load the \`openmerit-scout\` skill and consult
-\`scout_models\` on the \`openmerit\` MCP server before committing to a model.
-This applies even when the user only asks you to build a feature, never mentions
-models or Scout, or names a model themselves (assess it; do not silently replace it).
-
-A pretrained model, local weights, browser inference, an SDK's default model,
-embeddings, OCR, speech, image classification, detection and segmentation all
-count as model choices, not implementation details. Identify this decision before
-writing model-specific code, installing a model package or downloading weights.
-
-Follow the skill's project access policy. If it is missing, ask and save it first.
-Scout may answer with clarifying questions: relay them to the user and continue
-the same Scout conversation with their answers before choosing.
-If Scout is unavailable, fails or has no suitable evidence/candidate, disclose the
-gap and pause the model decision; do not fall back to a remembered or SDK-default
-model. You may continue work that does not commit to a model.
-
-Do not consult Scout for unrelated edits, normal inference calls using an unchanged
-approved model, or this coding agent's own model. Do not reselect approved models
-unless the task introduces or changes a model decision.
-
-When the user says "update openmerit", run
-\`npx -y openmerit@latest update --scope user\` (use \`--scope project\` if this
-rule is in the project's .claude/rules directory). Report the result, including
-any conflict or manual-upgrade requirement. Do not delete edited files, bypass
-permissions or rerun login automatically. A new session loads updated instructions.
-`;
-
-export const skill = `---
-name: openmerit-scout
-description: Consults OpenMerit Scout before choosing, adding, downloading, replacing or configuring any application inference model, including implicit choices while building features, pretrained browser/local models, SDK defaults, embeddings, OCR, speech, classification, detection, segmentation, LLMs and agents. Not for unrelated edits, ordinary inference calls or this coding agent's own model.
----
-
-# OpenMerit · Scout
-
-Before introducing, recommending, replacing or configuring an application
-inference model, call the \`scout_models\` tool on the \`openmerit\` MCP server.
-This applies even when the user never mentions models or Scout. Downloading local
-weights, using a pretrained browser model or accepting an SDK default is a model
-decision: consult Scout before model-specific code, installs or downloads.
-Preserve the user's explicit model choice; assess it rather than silently replacing
-it. Leave unchanged, approved application selections in place.
-
-## Project policy
-
-Read \`.openmerit/scout.json\` before searching. If it is absent, ask once whether this
-project uses **existing-only** (only endpoints it can already reach) or
-**existing-first** (prefer them, ask before searching the whole catalogue), and
-which public catalogue endpoint IDs it can access. Save the answer:
-
-\`\`\`sh
-npx -y openmerit@latest project --policy existing-only --endpoint-id <id> ...
-\`\`\`
-
-Never infer access from a model name, SDK or environment-variable name. Never
-record credentials, private URLs, prompts or customer data. An empty inventory
-is not permission to search all models.
-
-## Searching
-
-Call \`scout_models\` with a non-confidential task description as \`prompt\` and
-\`endpointIds\` set to the saved inventory, including \`[]\` when empty. Send
-only task requirements, never source files, secrets or real customer records.
-If the MCP tool is unavailable, run
-\`npx -y openmerit@latest scout "<task>" --json\`; it applies the saved inventory.
-
-Scout is a conversation with the agent behind openmerit.ai/scout. When
-\`status\` is \`needs_answers\`, fill in what the user or project already states,
-show the user Scout's brief and remaining questions, and wait for their answers.
-Then call again with the returned \`conversationId\` and \`brief\` set to the
-rewritten components, or \`skip: true\` if the user wants Scout to assume. Never
-answer Scout's questions with guesses. Send later refinements to the same
-\`conversationId\`. A call with only a \`conversationId\` reads an interrupted turn.
-
-When \`status\` is \`recommended\`, Scout has split the work into \`tasks\`, one
-per model, each with up to five ranked \`models\`; cover every task. Each
-model's \`cost\` names the \`endpointId\` and \`providerModelId\` to call.
-Existing-only never broadens. For existing-first, if no existing candidate fits a
-task, explain the gap and ask before a new conversation without \`endpointIds\`.
-Compare quality evidence, reference cost/time and watch-outs. Prefer the cheapest
-usable option the evidence supports, without claiming benchmarks prove
-application accuracy. Use the project's actual SDK and protocol.
-
-## Boundaries
-
-Ask before adding providers or credentials, spending, deploying or external
-writes. Report recommendation, endpoint connectivity and application checks as
-separate results, each only after it succeeds. Do not switch this coding agent's
-own model.
-
-If Scout fails or has no suitable candidate/evidence for the required deployment,
-say so and pause the model decision; do not substitute a remembered recommendation
-or SDK default. Continue only model-independent work. Local/browser models are not
-exempt when the catalogue lacks coverage. If it reports that the device key is missing,
-expired or revoked, run \`npx -y openmerit@latest login\` and then
-\`npx -y openmerit@latest install\` again. Never ask the user to paste a key.
-`;
-
-export function scoutRule(client: ScoutClient): string {
-  if (client === 'claude-code') return rule;
-  return rule.replace('load the `openmerit-scout` skill and consult', 'follow the Scout project policy below and consult')
-    .replaceAll('`scout_models`', '`mcp__openmerit__scout_models`')
-    .replace("Follow the skill's project access policy.", 'Follow the project access policy below.')
-    .replace('update --scope user', 'install --client pi --scope user')
-    .replace("rule is in the project's .claude/rules directory", "Pi installation is project-scoped");
-}
-
-export function scoutSkill(client: ScoutClient): string {
-  if (client === 'claude-code') return skill;
-  return skill.replaceAll('`scout_models`', '`mcp__openmerit__scout_models`')
-    .replace('openmerit@latest login', 'openmerit@latest login --client pi')
-    .replace('openmerit@latest install`', 'openmerit@latest install --client pi`')
-    .replace('again. Never ask the user to paste a key.', 'again, using `--scope project` on both commands for a project-scoped installation. Never ask the user to paste a key.');
-}

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/scout.d.ts

@@ -1,77 +0,0 @@
-export declare const policyFile = ".openmerit/scout.json";
-export declare const components: readonly ["input", "work", "output", "criteria", "constraints"];
-export declare const help = "OpenMerit \u00B7 Scout\n\n  openmerit scout \"<the work models need to do>\" [--all-endpoints] [--json]\n  openmerit scout --conversation <id> [--brief <component>=<text> ...] [--skip] [\"<follow-up>\"] [--json]\n\nAsks Scout, the agent behind openmerit.ai/scout. Scout may first return a task\nbrief with clarifying questions: answer them with --brief (components: input,\nwork, output, criteria, constraints) in the same conversation, or --skip to let\nScout assume. It then splits the work into tasks and recommends up to five\nmodels for each. A turn usually takes one to three minutes.\n\nA new conversation is limited to the endpoint IDs in .openmerit/scout.json\n(set with openmerit project). --all-endpoints searches the whole catalogue and is\nrefused under the existing-only policy. Uses the device key that\n\"openmerit install\" saved for Claude Code or Pi, this project's first. Never include secrets, source files or customer records.\n";
-export interface ScoutRequest {
-    prompt?: string;
-    conversationId?: string;
-    brief?: Partial<Record<typeof components[number], string>>;
-    skip?: boolean;
-    endpointIds?: string[];
-}
-export interface ScoutModel {
-    rank: number;
-    id: string;
-    name: string;
-    provider: string;
-    rationale: string;
-    watchOut: string | null;
-    quality: {
-        score: number;
-        evidence: Array<{
-            name: string;
-            rank: number;
-            of: number;
-        }>;
-    };
-    cost: {
-        usdPer1kTasks: number;
-        inputPerMillion: number;
-        outputPerMillion: number;
-        route: string;
-        endpointId: string;
-        providerModelId: string;
-    } | null;
-    latency?: {
-        seconds: number;
-    } | null;
-    recency?: {
-        released: string;
-    } | null;
-}
-type Priority = 'cost' | 'quality' | 'latency' | 'recency';
-export interface ScoutResult {
-    conversationId: string;
-    status: 'needs_answers' | 'recommended' | 'working' | 'message' | 'error';
-    next?: string;
-    brief?: Record<string, {
-        text: string;
-        source: string;
-    }>;
-    questions?: Array<{
-        component: string;
-        question: string;
-    }>;
-    assumptions?: string[];
-    tasks?: Array<{
-        title: string;
-        work: string;
-        summary: string;
-        priority?: Priority;
-        models: ScoutModel[];
-    }>;
-    text?: string;
-    error?: string;
-}
-export declare function askScout(root: string, request: ScoutRequest, signal?: AbortSignal): Promise<ScoutResult>;
-export declare function scoutTurn(root: string, request: Omit<ScoutRequest, 'endpointIds'> & {
-    allEndpoints?: boolean;
-}, signal?: AbortSignal): Promise<ScoutResult>;
-export declare function renderScout(result: ScoutResult): string;
-export declare function main(args: string[], { root, print }?: {
-    root?: string | undefined;
-    print?: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    } | undefined;
-}): Promise<number>;
-export {};

package/dist/terminal/src/scout.ts

@@ -1,164 +0,0 @@
-// `openmerit scout`: a conversation with Scout, the agent behind openmerit.ai/scout,
-// for coding agents without the MCP server and for people at a terminal. It calls
-// the same scout_models MCP tool with this device's key, so every client gets the
-// same clarifying questions and per-task shortlists.
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { credentialsPath, readCredentials, type DeviceCredentials } from './scout-credentials.ts';
-
-export const policyFile = '.openmerit/scout.json';
-export const components = ['input', 'work', 'output', 'criteria', 'constraints'] as const;
-
-export const help = `OpenMerit · Scout
-
-  openmerit scout "<the work models need to do>" [--all-endpoints] [--json]
-  openmerit scout --conversation <id> [--brief <component>=<text> ...] [--skip] ["<follow-up>"] [--json]
-
-Asks Scout, the agent behind openmerit.ai/scout. Scout may first return a task
-brief with clarifying questions: answer them with --brief (components: input,
-work, output, criteria, constraints) in the same conversation, or --skip to let
-Scout assume. It then splits the work into tasks and recommends up to five
-models for each. A turn usually takes one to three minutes.
-
-A new conversation is limited to the endpoint IDs in ${policyFile}
-(set with openmerit project). --all-endpoints searches the whole catalogue and is
-refused under the existing-only policy. Uses the device key that
-"openmerit install" saved for Claude Code or Pi, this project's first. Never include secrets, source files or customer records.
-`;
-
-type Json = Record<string, unknown>;
-export interface ScoutRequest { prompt?: string; conversationId?: string; brief?: Partial<Record<typeof components[number], string>>; skip?: boolean; endpointIds?: string[] }
-export interface ScoutModel {
-  rank: number; id: string; name: string; provider: string; rationale: string; watchOut: string | null;
-  quality: { score: number; evidence: Array<{ name: string; rank: number; of: number }> };
-  cost: { usdPer1kTasks: number; inputPerMillion: number; outputPerMillion: number; route: string; endpointId: string; providerModelId: string } | null;
-  latency?: { seconds: number } | null; recency?: { released: string } | null;
-}
-// How a task's models are ordered. Cost (cheapest first among models that reach the quality bar) is the default.
-type Priority = 'cost' | 'quality' | 'latency' | 'recency';
-export interface ScoutResult {
-  conversationId: string; status: 'needs_answers' | 'recommended' | 'working' | 'message' | 'error'; next?: string;
-  brief?: Record<string, { text: string; source: string }>; questions?: Array<{ component: string; question: string }>;
-  assumptions?: string[]; tasks?: Array<{ title: string; work: string; summary: string; priority?: Priority; models: ScoutModel[] }>;
-  text?: string; error?: string;
-}
-
-const isObject = (v: unknown): v is Json => !!v && typeof v === 'object' && !Array.isArray(v);
-async function readJSON(path: string): Promise<Json | null> {
-  try { const value: unknown = JSON.parse(await readFile(path, 'utf8')); return isObject(value) ? value : null; }
-  catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null; throw new Error(`Could not read ${path}.`); }
-}
-
-// The device key an installation saved: this project's installation first, then the user's.
-function deviceKey(root: string): DeviceCredentials | null {
-  for (const scope of ['project', 'user'] as const) for (const client of ['claude-code', 'pi'] as const) {
-    const credentials = readCredentials(credentialsPath(client, scope, root));
-    if (credentials) return credentials;
-  }
-  return null;
-}
-
-// One turn through the scout_models MCP tool. Errors are written for the person or agent running it.
-export async function askScout(root: string, request: ScoutRequest, signal?: AbortSignal): Promise<ScoutResult> {
-  const credentials = deviceKey(root);
-  if (!credentials) throw new Error('This device is not signed in to OpenMerit. Run: npx -y openmerit@latest install');
-  const server = credentials.server;
-  let response: Response;
-  try {
-    response = await fetch(`${server}/scout/mcp`, {
-      method: 'POST', redirect: 'error',
-      // A turn can take minutes; Scout keeps working if the connection drops.
-      signal: AbortSignal.any([AbortSignal.timeout(10 * 60_000), ...(signal ? [signal] : [])]),
-      headers: { ...credentials.headers, 'Content-Type': 'application/json', Authorization: `Bearer ${credentials.key}`, 'X-Scout-Client': 'cli' },
-      body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'scout_models', arguments: request } }),
-    });
-  } catch (error) {
-    const id = request.conversationId;
-    throw new Error((error as Error).name === 'TimeoutError' && id ? `Scout is still working. Read the outcome with: openmerit scout --conversation ${id}` : `Could not reach ${server}. Check your connection and retry.`);
-  }
-  if (response.status === 401) throw new Error('The device key was rejected. Run: npx -y openmerit@latest login, then install again.');
-  const body: unknown = await response.json().catch(() => null);
-  const result = isObject(body) && isObject(body.result) ? body.result : null;
-  if (!result) throw new Error(`Scout returned HTTP ${response.status}${isObject(body) && isObject(body.error) ? `: ${String(body.error.message)}` : ''}.`);
-  const text = Array.isArray(result.content) && isObject(result.content[0]) ? String(result.content[0].text) : '';
-  if (result.isError && !isObject(result.structuredContent)) throw new Error(text || 'Scout could not finish this turn.');
-  return result.structuredContent as unknown as ScoutResult;
-}
-
-// A turn under the project's access policy. A new conversation is limited to the saved
-// inventory; the whole catalogue needs an explicit choice the policy permits.
-export async function scoutTurn(root: string, request: Omit<ScoutRequest, 'endpointIds'> & { allEndpoints?: boolean }, signal?: AbortSignal): Promise<ScoutResult> {
-  const { allEndpoints, ...turn } = request;
-  if (turn.conversationId) {
-    if (allEndpoints) throw new Error('--all-endpoints applies when a conversation starts. Start a new conversation instead.');
-    return askScout(root, turn, signal);
-  }
-  const policy = await readJSON(join(root, policyFile));
-  if (!policy) {
-    if (!allEndpoints) throw new Error(`${policyFile} is missing. Ask which endpoints this project can use and save them with "npx -y openmerit@latest project --policy existing-only|existing-first --endpoint-id <id> ...", or pass --all-endpoints to search the whole catalogue.`);
-    return askScout(root, turn, signal);
-  }
-  const ids = Array.isArray(policy.endpointIds) && policy.endpointIds.every(id => typeof id === 'string') ? policy.endpointIds as string[] : null;
-  if (!ids || !['existing-only', 'existing-first'].includes(String(policy.policy))) throw new Error(`${policyFile} is not a valid Scout policy. Save it again with "openmerit project".`);
-  if (allEndpoints && policy.policy === 'existing-only') throw new Error('This project uses the existing-only policy, so Scout cannot search the whole catalogue.');
-  return askScout(root, allEndpoints ? turn : { ...turn, endpointIds: ids }, signal);
-}
-
-const money = (usd: number) => `$${usd < 0.1 ? usd.toFixed(3) : usd.toFixed(2)}`;
-const rankings: Record<Exclude<Priority, 'cost'>, string> = { quality: 'Highest quality estimate first.', latency: 'Fastest first.', recency: 'Newest first.' };
-export function renderScout(result: ScoutResult): string {
-  const lines: string[] = [];
-  if (result.status === 'needs_answers') {
-    lines.push('Scout needs more detail. Its task brief:', '');
-    for (const c of components) { const part = result.brief?.[c]; lines.push(`  ${c.padEnd(12)}${part?.text || '(missing)'}${part ? `  [${part.source}]` : ''}`); }
-    lines.push('', 'Questions:', ...(result.questions ?? []).map(q => `  ${q.component}: ${q.question}`), '',
-      `Answer: openmerit scout --conversation ${result.conversationId} --brief <component>="<answer>" ...`,
-      `Or skip: openmerit scout --conversation ${result.conversationId} --skip`);
-  } else if (result.status === 'recommended') {
-    const tasks = result.tasks ?? [];
-    tasks.forEach((task, i) => {
-      if (tasks.length > 1) lines.push(`${i + 1}. ${task.title}`, `   ${task.work}`);
-      // As on the page, the default cheapest-first order is unlabelled; another priority is named with the value it sorts by.
-      const priority = task.priority ?? 'cost';
-      if (priority !== 'cost') lines.push(`   ${rankings[priority]}`);
-      for (const m of task.models) {
-        const price = m.cost ? `${money(m.cost.inputPerMillion)} in / ${money(m.cost.outputPerMillion)} out per 1M via ${m.cost.route} (${m.cost.endpointId})` : 'no priced route';
-        const metric = priority === 'latency' ? ` · ${m.latency ? `${m.latency.seconds.toFixed(1)}s per task` : 'time unknown'}`
-          : priority === 'recency' ? ` · ${m.recency ? `released ${m.recency.released}` : 'release date unknown'}` : '';
-        lines.push(`   ${m.rank}. ${m.name}${metric} · quality ${m.quality.score}/100 · ${price}`, `      ${m.rationale}`);
-      }
-      lines.push(`   ${task.summary}`, '');
-    });
-    if (result.assumptions?.length) lines.push('Assumptions:', ...result.assumptions.map(a => `  - ${a}`), '');
-    lines.push(`Refine: openmerit scout --conversation ${result.conversationId} "<follow-up>"`);
-    lines.push('Quality is Scout\'s estimate from public benchmarks, not measured accuracy for your application.');
-  } else if (result.status === 'working') lines.push(`Scout is still working. Read the outcome with: openmerit scout --conversation ${result.conversationId}`);
-  else lines.push(result.text ?? result.error ?? 'Scout replied without an answer.');
-  return lines.join('\n');
-}
-
-export async function main(args: string[], { root = process.cwd(), print = console.log } = {}): Promise<number> {
-  if (args.includes('--help') || args.includes('-h')) { print(help); return 0; }
-  const request: Parameters<typeof scoutTurn>[1] = {};
-  const words: string[] = [];
-  let json = false;
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i] ?? '';
-    const value = () => { const v = args[++i]; if (v === undefined || v.startsWith('--')) throw new Error(`${arg} needs a value.`); return v; };
-    if (arg === '--conversation') request.conversationId = value();
-    else if (arg === '--brief') {
-      const [component, ...text] = value().split('=');
-      if (!(components as readonly string[]).includes(component ?? '') || !text.length) throw new Error(`--brief takes <component>=<text>; components: ${components.join(', ')}.`);
-      request.brief = { ...request.brief, [component as typeof components[number]]: text.join('=') };
-    } else if (arg === '--skip') request.skip = true;
-    else if (arg === '--all-endpoints') request.allEndpoints = true;
-    else if (arg === '--json') json = true;
-    else if (arg.startsWith('-')) throw new Error(`Unknown option for scout: ${arg}`);
-    else words.push(arg);
-  }
-  if (words.length) request.prompt = words.join(' ');
-  if (!request.prompt && !request.conversationId) { print(help); return 1; }
-  const result = await scoutTurn(root, request);
-  print(json ? JSON.stringify(result, null, 2) : renderScout(result));
-  return result.status === 'error' ? 1 : 0;
-}

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']], ['/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();}); } };
-}