openmerit 0.1.11 → 0.2.0

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

@@ -0,0 +1,116 @@
+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) {
+    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-instructions.ts

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,44 @@
+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.js

@@ -0,0 +1,84 @@
+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'),
+        legacyRule: join(base, 'rules/openmerit.md'), 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-pi.ts

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,77 @@
+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 {};