openmerit 0.3.11 → 0.4.1

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

@@ -1,213 +0,0 @@
-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.
-
-## Measuring candidates
-
-Each task also has an \`evaluation\`: the checks (per model call, agent run or
-end-to-end outcome), labelled examples per candidate and when to stop a losing
-candidate. Offer to run it before the user commits to a model. First assess the
-project's readiness for this task:
-
-- **No eval setup:** propose a customer-owned setup. Langfuse is the default
-  suggestion for its supported aggregate connector, not a requirement: existing
-  local/custom eval scripts can report aggregates without a hosted platform.
-  Phoenix/Arize and Braintrust are alternatives, not supported Scout connectors.
-  Ask which system the user wants before creating accounts or resources.
-- **Setup exists but evidence is insufficient:** keep that system. Write a
-  task-specific eval plan in the project's local Markdown decision record for
-  the user or their coding agent to implement. Name exact candidates/endpoints,
-  quality floor and task/agent/outcome checks, labelled boundary cases and
-  controls, sample size, early-stop rule, spend cap, aggregate mappings and
-  temporary run retention. Explain what the current evidence cannot decide.
-- **Suitable evals exist:** reuse their fixtures and definitions; add only the
-  approved candidate runs. Do not build a second eval or copy their datasets.
-
-OpenMerit does not host or run these evals. The customer or their coding agent
-implements and maintains them with the customer's tools; Scout keeps Viewer-only
-access. Ask before model spend or any platform write. Without measured evidence,
-Scout may suggest candidates, but do not claim validated model quality.
-
-Report what you measured with \`scout_models\`: the same \`conversationId\` and
-\`results\`, one aggregate per model and metric (\`level\`, \`task\` title, \`scope\`,
-\`model\` endpoint or model ID, \`metric\`, \`value\`, \`higherIsBetter\`,
-\`samples\`, \`source\`). Set \`kind\` to \`usd\` or \`seconds\` for measured cost
-or time (per call at the task level, per run at the agent level), so Scout uses
-your cost instead of its estimate. Report each agent's own checks at the agent
-level: an end-to-end result also measures the agents you did not swap. Send
-aggregates only, never inputs, outputs or records.
-Scout ranks them above public benchmarks for this user only; models whose
-\`quality.measured\` is true rest on them.
-
-Swap one agent at a time, holding the other agents, prompts, fixtures and controls
-fixed. Use each agent's own checks to attribute failures. If all candidates score
-100%, the eval cannot separate their quality: add harder labelled cases before
-claiming equivalent quality. Cost may break the observed tie, not prove equality.
-
-## Preserve evidence before cleanup
-
-Before removing temporary comparison runs, save a local Markdown decision record
-with the package/service versions, date, task and policy, exact candidates,
-unchanged controls, metric definitions/directions, sample counts, aggregate
-quality/cost/time, failures and exclusions, chosen model, limitations and next
-review. Record regret against the cheapest measured candidate meeting the same
-quality floor; write "not measurable" when comparable evidence is missing.
-Exclude secrets, private record IDs, prompts, outputs and trace bodies.
-
-Temporary comparison traces/records are not permanent: after the record is saved
-and checked, propose the exact newly created comparison runs to remove. Obtain
-explicit scoped approval, including any cascading deletion, before the customer
-or their coding agent deletes them with customer-controlled write access. Scout's
-Viewer key cannot do this. Never delete pre-existing customer records, reusable
-fixtures, dataset definitions or eval definitions. Verify the approved cleanup
-and retained controls, then record the outcome locally. If not approved, leave
-records unchanged and state cleanup is pending; do not imply it happened.
-
-If the user has Langfuse, use \`openmerit connect langfuse --help\`: the web UI is
-optional. Headless setup requires a separate connection-manager approval with
-\`openmerit connect langfuse --authorize --no-open\`. Relay its approval link and
-expiry; after approval, rerun that command. Existing recommendation keys cannot
-manage connections. The user creates a separate Viewer key; receive it through
-protected stdin or a secret-manager-injected environment, never chat, tool
-arguments, shell literals, traced commands or tracked files. The CLI accepts
-non-secret settings via \`--config mappings.json\` and reads LANGFUSE_PUBLIC_KEY
-and LANGFUSE_SECRET_KEY from its environment, or reads full settings via --stdin.
-A separate trusted MCP connection with the management key exposes
-\`scout_connection\` (status/configure/sync/disconnect/clear). For configure, keys
-must come from client-controlled HTTP headers outside model context; if the
-client cannot do this securely, use protected CLI input or the web UI instead.
-Once the user has confirmed the connection and score/model mappings (including
-a connection already recorded in the project), call \`scout_models\` with
-\`sync: "langfuse"\` on the first consultation and before a final model decision.
-The CLI equivalent is \`openmerit scout --conversation <id> --sync langfuse\`.
-Refreshing that approved connection reads aggregates and updates Scout's cache;
-it does not run candidates or create/change records in Langfuse. Do not ask for
-new spend or platform-write approval just to refresh it. Do not reconstruct and
-re-report old measurements from project notes instead of using the connection.
-If connection status is unknown, check \`openmerit connect langfuse --status\`
-before proposing setup; application tracing keys alone do not prove a Scout
-connection. If sync fails, disclose the failure and any use of cached evidence;
-do not describe it as fresh. Never read trace bodies to work around missing
-mappings or untagged runs; use the aggregate report path for those gaps instead.
-Results are stored per user, used in new conversations and
-expire after 90 days. Disconnect deletes the Viewer key and imported aggregates;
-Delete all evaluation data also deletes manually reported aggregates. Obtain
-consent before deleting: headless CLI requires --yes, MCP requires confirm: true.
-Deleting the connection does not revoke the separate management device key.
-Past conversation text is not erased. Never put record IDs, emails or secrets in
-\`scope\` or \`source\`; use labels such as "coding agent" and "held-out eval".
-
-## 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. When an install or login waits for approval (exit code
-10), show the user the approval link and its UTC expiry in your reply, not only in
-command output, then rerun the same command once they approve. 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) {
-    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) {
-    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.js

@@ -1,84 +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 { scoutSkill } from "./scout-instructions.js";
-export const piVersion = '1.5.0';
-const hash = (value) => createHash('sha256').update(value).digest('hex');
-const optional = async (path) => {
-    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) {
-    const value = 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;
-}
-export function piPaths(root, scope) {
-    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'),
-        mcpFile: join(base, 'mcp.json'), mcpScope: scope, agentDir };
-}
-export async function inspectPi(root, scope) {
-    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, field) => 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: [] }, legacyRule: 'none',
-        shadowed: other !== null || [mcp, otherMcp].some(config => config.mcpServers && typeof config.mcpServers === 'object' && 'openmerit' in config.mcpServers), };
-}
-export function piConflicts(state) {
-    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, scope, credentialsPath, ids) {
-    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, value) => {
-        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) {
-    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.js

@@ -1,229 +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, resolve } from 'node:path';
-import { credentialsPath, readCredentials } from "./scout-credentials.js";
-const policyFile = '.openmerit/scout.json';
-export const components = ['input', 'work', 'output', 'criteria', 'constraints'];
-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]
-  openmerit scout --conversation <id> --results <file.json> [--json]
-  openmerit scout --conversation <id> --sync langfuse [--json]
-  openmerit connect langfuse
-  openmerit disconnect langfuse
-
-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, with an evaluation: how to measure the candidates with your
-own evals. Report what you measured with --results: a JSON list of aggregate
-results ({level, kind?, task?, scope, model, metric, value, higherIsBetter,
-samples, source}), never inputs or outputs. kind is quality (the default), usd
-or seconds; measured usd replaces Scout's cost estimate. Scout ranks them above
-public benchmarks, for your recommendations only. A turn usually takes one to three minutes.
-
-Connect a separate Langfuse Viewer key through CLI or the optional web UI (see
-openmerit connect langfuse --help), then --sync langfuse refreshes mapped, tagged
-experiment aggregates before recommending.
-Results are stored per user across conversations for 90 days. Disconnect deletes
-the key and imports; use Delete all evaluation data to remove reported results too.
-Past conversations remain. Never put record IDs or emails in source or scope.
-
-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.
-`;
-const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
-async function readJSON(path) {
-    try {
-        const value = JSON.parse(await readFile(path, 'utf8'));
-        return isObject(value) ? value : null;
-    }
-    catch (error) {
-        if (error.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) {
-    for (const scope of ['project', 'user'])
-        for (const client of ['claude-code', 'pi']) {
-            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.
-async function askScout(root, request, signal) {
-    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;
-    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.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 = 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;
-}
-// 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, request, signal) {
-    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 : 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) => `$${usd < 0.1 ? usd.toFixed(3) : usd.toFixed(2)}`;
-const rankings = { quality: 'Highest quality estimate first.', latency: 'Fastest first.', recency: 'Newest first.' };
-export function renderScout(result) {
-    const lines = [];
-    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.agent ? ` (${task.agent}${task.callsPerRun && task.callsPerRun > 1 ? `, ${task.callsPerRun} calls per run` : ''})` : ''}`, `   ${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 measuredCost = m.cost?.measured ? `measured ${money(m.cost.measured.usdPer1kAgentRuns ?? m.cost.measured.usdPer1kTasks)} per 1k ${m.cost.measured.usdPer1kAgentRuns === undefined ? 'tasks' : 'agent runs'}, ` : '';
-                const price = m.cost ? `${measuredCost}${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${m.quality.measured ? ' (measured)' : ''} · ${price}`, `      ${m.rationale}`);
-            }
-            lines.push(`   ${task.summary}`);
-            if (task.evaluation)
-                lines.push(`   Measure with your evals (${task.evaluation.samples} labelled examples per candidate; ${task.evaluation.stopEarly}):`, ...task.evaluation.checks.map(c => `     - ${c.level}: ${c.metric}. ${c.how}`));
-            lines.push('');
-        });
-        if (result.assumptions?.length)
-            lines.push('Assumptions:', ...result.assumptions.map(a => `  - ${a}`), '');
-        lines.push(`Refine: openmerit scout --conversation ${result.conversationId} "<follow-up>"`);
-        lines.push(`Report measured results: openmerit scout --conversation ${result.conversationId} --results <file.json>`);
-        lines.push(tasks.some(t => t.models.some(m => m.quality.measured))
-            ? 'Quality marked (measured) rests on the results you reported; the rest is Scout\'s estimate from public benchmarks.'
-            : '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, { root = process.cwd(), print = console.log } = {}) {
-    if (args.includes('--help') || args.includes('-h')) {
-        print(help);
-        return 0;
-    }
-    const request = {};
-    const words = [];
-    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.includes(component ?? '') || !text.length)
-                throw new Error(`--brief takes <component>=<text>; components: ${components.join(', ')}.`);
-            request.brief = { ...request.brief, [component]: 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 === '--sync') {
-            if (value() !== 'langfuse')
-                throw new Error('--sync supports langfuse.');
-            request.sync = 'langfuse';
-        }
-        else if (arg === '--results') {
-            const file = value();
-            let results;
-            try {
-                results = JSON.parse(await readFile(resolve(root, file), 'utf8'));
-            }
-            catch {
-                throw new Error(`Could not read results from ${file}: it must be a JSON list.`);
-            }
-            if (!Array.isArray(results))
-                throw new Error(`${file} must hold a JSON list of results.`);
-            // Scout accepts at most 50 per turn; each call is a turn that recommends again, so splitting is the caller's choice.
-            if (results.length > 50)
-                throw new Error(`${file} holds ${results.length} results; Scout accepts at most 50 per call. Split them into files of up to 50 and report each with --results in turn; Scout recommends again after each.`);
-            if (results.some(r => isObject(r) && [r.source, r.scope].some(v => typeof v === 'string' && /(?:\b(?:claim|patient|member|FICT|CLM)[-_ ]?\d|\b[0-9a-f]{8}-[0-9a-f-]{27,}\b|[^\s@]+@[^\s@]+\.[^\s@]+)/i.test(v))))
-                print('Warning: source or scope looks like a record ID or email. Send aggregate labels only; remove identifiers before sharing.');
-            request.results = results;
-        }
-        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;
-    }
-    if (request.results && !request.conversationId)
-        throw new Error('--results continues a conversation: pass --conversation <id> from the recommendation you measured.');
-    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/telemetry.d.mts

@@ -1,30 +0,0 @@
-export function safeFrames(error: any): {
-    filename: string | undefined;
-    lineno: number;
-    colno: number;
-}[];
-export function errorProperties(error: any): {
-    error_type: any;
-    frames: {
-        filename: string | undefined;
-        lineno: number;
-        colno: number;
-    }[];
-};
-export function setupHeaders(ids?: {}, client?: string): {
-    'X-Scout-Installation-Id'?: any;
-    'X-Scout-Setup-Id'?: any;
-    'X-Scout-Analytics-Account'?: string;
-    'X-Scout-Analytics'?: string;
-    'X-Scout-Analytics-Content': string;
-    'X-Scout-Client-Version'?: any;
-    'X-Scout-Client': string;
-    'X-Scout-Agent': string;
-};
-export function installationProperties(input: any): {} | null;
-export function sendInstallationEvent(input: any): Promise<void>;
-export function commandTelemetry(args: any): (outcome: any, error: any, code: any) => Promise<void>;
-export let clientVersion: any;
-export function telemetryEnabled(defaultEnabled?: boolean): boolean;
-export function setupCorrelationEnabled(): boolean;
-export function setupUUID(value: any): boolean;