openmerit 0.1.11 → 0.2.0

package/dist/terminal/src/scout.js

@@ -0,0 +1,181 @@
+// `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 } from "./scout-credentials.js";
+export const policyFile = '.openmerit/scout.json';
+export const components = ['input', 'work', 'output', 'criteria', 'constraints'];
+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.
+`;
+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.
+export 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.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, { 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.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/scout.ts

@@ -0,0 +1,164 @@
+// `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

@@ -6,7 +6,7 @@ import { createCollector, loadConfig } from './collect.mjs';
 import { sampleSnapshot } from './sample.mjs';
 import { telemetryEnabled, terminalProperties, sendTerminalEvent, errorProperties } from './telemetry.mjs';
 
-const assets = new Map([['/', ['index.html', 'text/html']], ['/app.js', ['app.js', 'text/javascript']], ['/flow.js', ['flow.js', 'text/javascript']], ['/flow.css', ['flow.css', 'text/css']], ['/styles.css', ['styles.css', 'text/css']], ['/favicon.svg', ['favicon.svg', 'image/svg+xml']]]);
+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 } = {}) {

package/dist/terminal/src/telemetry.mjs

@@ -38,7 +38,7 @@ export const setupUUID = value => typeof value === 'string' && /^[0-9a-f]{8}-[0-
 export function setupHeaders(ids = {}, client = 'cli') {
   return {
     'X-Scout-Client': client,
-    'X-Scout-Agent': 'claude-code',
+    'X-Scout-Agent': ids.agent === 'pi' ? 'pi' : 'claude-code',
     ...(clientVersion ? { 'X-Scout-Client-Version': clientVersion } : {}),
     'X-Scout-Analytics-Content': 'off',
     ...(client === 'cli' ? { 'X-Scout-Analytics': telemetryEnabled(true) ? 'on' : 'off' } : !telemetryEnabled(true) ? { 'X-Scout-Analytics': 'off' } : {}),
@@ -54,7 +54,7 @@ export function installationProperties(input) {
     stage: ['started', 'preflight', 'login', 'browser_open', 'configuration', 'verification', 'status', 'remove', 'completed'],
     outcome: ['started', 'ok', 'error', 'pending', 'denied', 'conflict', 'not_installed'],
     command: ['install', 'status', 'remove', 'login', 'logout', 'project', 'doctor', 'unknown'],
-    agent: ['claude-code'], scope: ['user', 'project'],
+    agent: ['claude-code', 'pi'], scope: ['user', 'project'],
     rule_status: ['matches', 'missing', 'modified_or_unowned'],
     skill_status: ['matches', 'missing', 'modified_or_unowned'],
     server_status: ['matches', 'missing', 'modified_or_unowned'],

package/docs/commands.md

@@ -1,6 +1,8 @@
 # Commands
 
-The standalone `openmerit dash` command runs in your shell. The `/openmerit` slash commands run inside Pi with the extension loaded.
+**Pi adapter — npm 0.1.12 and later:** Pi 1.5.0 uses only native Scout MCP and shared guidance. Run `npx -y openmerit@latest install --client pi [--scope user|project]` and approve in the browser. Shell `login`, `logout`, `status`, `remove`, and `doctor` accept the same target flags. Updates require explicit reinstall; no Pi update hooks or scheduler are installed. See [Pi setup](pi-extension.md).
+
+The standalone `openmerit dash` and `openmerit eval` commands are unchanged. The Pi 0.87 `/openmerit` slash commands were removed with that adapter and have no replacement.
 
 Stable npm `openmerit@0.1.7` provides `openmerit eval init`, `doctor`, `plan`, `run`, `watch` and `report`. See [agent evaluations](agent-evaluations.md) for scope selection, repeated task checks and budgets. These are shell commands, separate from Pi commands. The same release includes [Scout setup commands](scout.md#commands), beginning with `npx -y openmerit@latest install --client claude-code`.
 
@@ -11,79 +13,3 @@ Since `0.1.7-preview.2`, `openmerit eval plan [--scope existing|all] [--budget <
 Install with `npm install -g openmerit` to use `openmerit dash [path]` for a passive local view of models, connections, usage, and compute. From this checkout, use `npm run dash -- [path]`. It is independent of Pi setup and does not run model comparisons or inference.
 
 See the [Inference Terminal guide](inference-terminal.md) for local installation, automatic discovery, `--no-discovery`, `--json`, `--demo`, collection intervals, and data limitations. Discovery is part of `dash` and is scoped to application evidence. Coding-harness histories are not collected.
-
-## Inspect status
-
-```text
-/openmerit
-/openmerit status
-```
-
-Both show the task profile, metric readiness, evaluation status, active work, next assessment, lifecycle stage, incumbent candidate, candidate and assessment counts, challenger spend, proposed candidate, and pause flag. A readiness label is based on the harness’s structured reports; inspect the evidence for the underlying measurements.
-
-## Start or recover setup
-
-```text
-/openmerit setup
-```
-
-Requests setup explicitly or reopens setup to correct stale target/incumbent state. Accepted replacement setup clears prior candidate, assessment, frontier, and baseline handoffs while retaining the audit log.
-
-Request setup explicitly only when recovering, rerunning, or configuring a custom integration. An unconfigured project starts setup when bounded source detection finds an application LLM call at session start or after a settled Pi build turn. OpenMerit refuses another intent while work is active.
-
-## Cancel interrupted work
-
-```text
-/openmerit cancel
-```
-
-Record the active intent as cancelled after an interrupted or abandoned harness run. This clears durable active-work state without claiming success and releases any interactive request that was queued behind setup.
-
-## Request an assessment
-
-```text
-/openmerit assess
-```
-
-Ask OpenMerit core to check stored baseline metric windows now. It reports missing or immature required metrics without starting Pi, or starts candidate discovery when they pass. It does not create missing measurements or override sample requirements.
-
-## Request a frontier
-
-```text
-/openmerit frontier
-```
-
-Ask the harness to calculate a model comparison now. OpenMerit validates the returned frontier against the confirmed profile and supplied assessments. The command does not itself authorize a model change.
-
-## Approve a proposal
-
-```text
-/openmerit approve
-```
-
-Approve the current proposal after its frontier result has passed validation. If there is no proposal in the expected lifecycle stage, the command reports that no verified proposal is awaiting approval. See [comparisons and swaps](lifecycle.md) for automatic-swap policy.
-
-## Pause and resume
-
-```text
-/openmerit pause
-/openmerit resume
-```
-
-Pause is persisted in `.openmerit/state.json`, blocks automatic due decisions and lifecycle follow-ups, and unloads the project's managed macOS LaunchAgent. Incoming signals can still be recorded. Resume clears pause and restores scheduling only when the confirmed policy authorizes it. Neither command cancels an already-active intent; explicit commands remain available. The standalone Inference Terminal is independent and keeps collecting until its CLI process exits.
-
-## Locate logs and evidence
-
-```text
-/openmerit logs
-```
-
-Show the local audit, exporter-error, evidence-manifest, and state paths. See [project files and logs](operations.md) for their contents.
-
-## Check the installation
-
-```text
-/openmerit doctor
-```
-
-Show adapter diagnostics, UI availability, and scheduling support. This checks extension wiring; it does not prove provider authentication, successful evaluations, or a completed model swap.

package/docs/getting-started.md

@@ -1,6 +1,6 @@
 # Getting started
 
-Stable npm 0.1.7 includes a separate [agent-evaluation CLI-change loop](agent-evaluations.md) for Claude Code, Codex and OpenCode, plus [Scout device setup for Claude Code](scout.md#connect-a-coding-agent). Neither is part of the Pi setup below.
+OpenMerit provides a passive Inference Terminal, Scout model-selection guidance, and a separate [agent-evaluation CLI](agent-evaluations.md). Pi Scout setup requires OpenMerit **0.1.12** or newer and Pi **1.5.0**. Package publication and website deployment are independent releases.
 
 ## Open your inference environment
 
@@ -12,65 +12,40 @@ cd /path/to/your/application
 openmerit dash
 ```
 
-The Inference Terminal is included in stable `openmerit@0.1.7`. It opens a local, read-only view of the selected application's services, models, recorded requests, and linked compute. It does not require Pi or a provider API key, make inference calls, or change model assignments. Supported code/configuration declarations identify inventory; request history requires existing supported logs or exports. See [the terminal guide](inference-terminal.md) for collection, privacy, configuration, and diagnostics.
+The Inference Terminal opens a local, read-only view of the selected application's services, models, recorded requests, and linked compute. It does not require Pi or a provider API key, make inference calls, or change model assignments. Supported code/configuration declarations identify inventory; request history requires existing supported logs or exports. See [the terminal guide](inference-terminal.md) for collection, privacy, configuration, and diagnostics.
 
-To inspect fictional data without installation, open the [hosted dashboard](https://dash.openmerit.ai/) or its [before/after comparison](https://dash.openmerit.ai/demo). Neither connects to your machine.
+To inspect fictional data, run `openmerit dash --demo` or choose the sample from the environment selector. Sample data never enters the real snapshot or project files.
 
-## Set up model comparisons with Pi
+## Connect Scout to a coding agent
 
-The Pi integration is a separate workflow for evaluations and authorized model changes. It requires Pi 0.87 with a model provider configured, and a product repository where Pi can create and verify evaluation and observability artifacts. Provider credentials belong to Pi or its environment; OpenMerit does not accept them.
-
-Install the extension in Pi:
-
-```sh
-pi install npm:openmerit
-pi list
-```
-
-Run `/openmerit doctor` inside Pi to confirm that the extension is available.
-
-## Install from source
+Claude Code setup is described in [the Scout guide](scout.md#connect-a-coding-agent). For the new Pi integration, use Pi **1.5.0**, Node.js 22.19 or newer, and npm. Run the intended command in your shell:
 
 ```sh
-git clone https://github.com/laz-aslam/openmerit.git
-cd openmerit
-npm ci
+npx -y openmerit@latest install --client pi --scope user
 ```
 
-Start Pi with the extension:
+Approve the matching device code in the browser, then start a **new Pi session**. Only approve a request you initiated. User scope is the default and applies across projects. For one project, run this from that project's root instead:
 
 ```sh
-./node_modules/.bin/pi --no-extensions -e ./packages/pi/src/index.ts
+npx -y openmerit@latest install --client pi --scope project
 ```
 
-`--no-extensions` prevents a globally installed npm copy from conflicting with the source extension. Run `/openmerit doctor` inside Pi to confirm that the adapter and intent executor are available.
-
-## Establish a product profile
-
-Open the product repository in interactive Pi with the extension loaded. If the project has no OpenMerit state, the Pi adapter performs a bounded source preflight. It also scans after a settled Pi build turn, so an application created from an initially empty directory can enter setup without a slash command. A repository without such a target remains idle; use `/openmerit setup` only to recover or configure a custom integration explicitly.
+Each client/scope installation has its own private Scout key; project keys are stored outside the repository. Do not install overlapping Pi user/project adapters or a duplicate `openmerit` MCP entry. The installer reports conflicts rather than overwriting edited or unowned files.
 
-OpenMerit sends Pi a private, typed `establish_evals` intent. Pi must identify the application LLM call or shared route under evaluation and its exact incumbent application model. It inspects the application's outputs, tools, and failure modes to infer task-relevant metrics instead of asking you to invent them. Before running setup, Pi shows the proposed metrics, why each matters, the representative case and repetition counts, aggregation, any actual performance threshold, and estimated evaluation cost. You confirm or edit that plan together with the stable target ID, call sites, route key, budget, check cadence, scheduling mode, and automation permissions. Pi's own model is never an application target.
+The adapter connects Scout through Pi's native MCP and supplies the shared Scout rule and skill. Pi owns tool discovery, tool execution, model choice, permissions, and sessions. Scout recommends application-model candidates; it does not execute those candidates or change Pi's own model. There are no `/openmerit` lifecycle commands, automatic evaluation setup, scheduler, or LaunchAgent in this adapter.
 
-For an active-session demo, Pi defaults the baseline and post-swap verification cadence to one completed evaluation task unless you change it. OpenMerit rejects empty baseline or post-swap cadences.
+## Check, update, or remove Pi setup
 
-Pi is also asked to research preliminary model leads during setup. Each reported lead has a current price estimate and reputation summary with sources and check times. OpenMerit stores these leads with the project profile. The field is optional for compatibility with existing protocol-0.1 harnesses, and an empty list means no credible leads were found. It does not change the application model or count as a measurement.
-
-OpenMerit rejects successful setup without a confirmed task profile, at least one valid objective with an explicit sampling plan, a supervised-graduation policy, non-empty baseline and post-swap cadences, a budget, and evidence.
-
-The setup instruction asks Pi to run the application path with working provider authentication, execute each required collector and grader, inspect the resulting metric values, and retain verification artifacts. A metric that cannot be produced must be marked missing. This smoke run verifies the pipeline; it is not counted as a production baseline sample. OpenMerit still checks the reported coverage and evidence references, not the authenticity of a grader run itself.
-
-## Collect the baseline
-
-After setup, instrument the confirmed application target and use the product normally. Report application-task completions and cumulative metric windows through Pi's typed signal tool, including the application model where applicable, sample counts, and durable evidence. Pi's own model, tokens, cost, and latency are orchestration telemetry and do not satisfy product metrics. OpenMerit core checks the stored baseline windows at the approved cadence without calling Pi; missing evidence stays insufficient.
-
-## Find the frontier
-
-When the baseline meets every required metric threshold, OpenMerit issues the next approved nudges: discover candidates, run controlled challenger trials, and calculate the Pareto frontier. Pi performs that work. OpenMerit checks the returned result against the [Pareto specification](pareto-spec.md).
+```sh
+npx -y openmerit@latest status --client pi --scope user --check
+npx -y openmerit@latest doctor --client pi --scope user
+npx -y openmerit@latest remove --client pi --scope user
+```
 
-Candidate discovery uses current price, capability, availability, reputation, and benchmark signals to shortlist models worth testing. These are starting clues, not evidence that a model performs well on your application. OpenMerit collects preliminary leads at setup, then refreshes them, probes availability, and freezes the incumbent plus challengers. Pi must use the same cases, application revision, prompt, tools, grader, and run count, with a recorded shuffle seed. It preserves one experiment manifest and reports measured quality, cost, latency, tokens, and other required metrics. OpenMerit durably carries the accepted candidate set and assessments into later intents rather than relying on Pi conversation history. A model proposal must come from the verified frontier of those measured candidate results, not from price or reputation alone.
+Use `--scope project` from the original project root for a project installation. `login` and `logout` accept the same `--client` and `--scope` flags. These commands target that installation, not another client's connection. Updating Pi setup requires explicitly rerunning `install` and starting a new session; no Pi auto-update hooks are installed. Installing or updating the npm package alone does not reconfigure Pi.
 
-## Approve an early swap
+See [the Pi extension guide](pi-extension.md) for installed paths, migration from Pi 0.87, and SDK embedding. Use [troubleshooting](troubleshooting.md) for setup failures.
 
-With automatic swaps disabled, a model proposal that passes frontier validation waits for `/openmerit approve`. That authorizes Pi to apply only the proposed change. OpenMerit then requires post-swap evaluation; the approved policy determines rollback behavior. Automatic swaps may bypass per-proposal approval when enabled and the configured verified-swap threshold is reached, including when that threshold is zero.
+## Evaluate application changes
 
-Continue with [your first supervised trial](first-trial.md) for a practical walkthrough.
+The standalone `openmerit eval` CLI is unchanged by the new Pi adapter. It evaluates Claude Code, Codex and OpenCode through explicit task, scope, budget and grader configuration; see [agent evaluations](agent-evaluations.md).

package/docs/index.md

@@ -1,6 +1,6 @@
 # OpenMerit documentation
 
-These guides describe the implementation on **main**. Stable npm `openmerit@0.1.7` includes the Inference Terminal, agent-evaluation CLI and Scout device setup for Claude Code. The website, hosted samples, Scout service and npm package are deployed independently; dated receipts describe the versions actually tested.
+These guides distinguish current source work from published behavior. OpenMerit **0.1.12** adds native Scout support for Pi **1.5.0**, replacing the old Pi 0.87 evaluation extension. The Inference Terminal and standalone agent-evaluation CLI are separate products and are unchanged by that replacement. The website, Scout service and npm package are deployed independently; dated receipts describe the versions actually tested.
 
 ## See your inference environment
 
@@ -14,27 +14,22 @@ openmerit dash
 
 The terminal shows application services, model declarations, recorded requests, and linked compute. It reads supported local evidence, needs no Pi installation or provider API key, and makes no inference calls or model changes. Configuration can identify declared services; actual activity requires existing supported logs or exports.
 
-Start with [installation and setup](getting-started.md) or the [Inference Terminal guide](inference-terminal.md). Explore the [hosted sample](https://dash.openmerit.ai/) and [before/after dashboard demo](https://dash.openmerit.ai/demo) without connecting your machine. The [demo guide](demo.md) explains their fictional data and comparison limits.
+Start with [installation and setup](getting-started.md) or the [Inference Terminal guide](inference-terminal.md).
 
 ## Discover model candidates
 
 For a shortlist before building an integration, the separate [Scout beta](scout.md) accepts a task description and returns up to five evidence-backed model candidates. It is available at [openmerit.ai/scout/](https://openmerit.ai/scout/), with a prompt-only JSON API and MCP tool for coding agents.
 
-## Evaluate model changes with Pi
+## Connect Scout to Pi
 
-The separate Pi 0.87 integration asks a coding harness to establish evaluations, gather application measurements, and test candidates. OpenMerit coordinates the approved lifecycle, records evidence references, validates structured results and frontier conformance, and requests authorized changes. The harness executes the work; the terminal does not perform this workflow.
+The thin Pi 1.5.0 adapter uses native MCP and shared Scout guidance. Pi owns tools, models, permissions and sessions; the adapter has no `/openmerit` lifecycle commands, evaluation scheduling, LaunchAgent or automatic updates.
 
-Follow [Pi setup](getting-started.md#set-up-model-comparisons-with-pi), then [your first supervised trial](first-trial.md).
+Follow [setup](getting-started.md#connect-scout-to-a-coding-agent) and [the Pi guide](pi-extension.md), including browser approval, per-client/scope credentials, explicit reinstall updates and SDK requirements. Registry setup requires OpenMerit 0.1.12 or newer.
 
-- [Metrics and evidence](metrics-and-evidence.md): measurements, sample requirements, and readiness.
-- [Comparisons and swaps](lifecycle.md): baseline, challenger trials, approval, verification, and rollback.
-- [Budgets and permissions](budgets.md): challenger accounting and provider-spend limits.
-- [Automatic checks](automation.md): durable signals, cadence, and authorized macOS scheduling.
+## Evaluate application changes
 
-## Operate and troubleshoot
-
-[Commands](commands.md) and [project files and logs](operations.md) explain status, pause, diagnostics, and recovery. [Troubleshooting](troubleshooting.md), [security and data](security.md), and [current limitations](roadmap.md) describe the boundaries to check before relying on automation.
+Use [the standalone evaluation CLI](agent-evaluations.md) to compare CLI revisions across Claude Code, Codex and OpenCode with explicit tasks, model scope, budgets and graders.
 
-## Build an integration
+## Operate and troubleshoot
 
-Pi is the implemented coding-harness adapter. Other harnesses can implement the protocol and coordinator boundary described in [architecture](architecture.md) and [the adapter guide](adapter-guide.md). The [Pareto specification](pareto-spec.md) defines comparison rules; [testing and validation](testing.md) distinguishes automated coverage from product evidence.
+[Commands](commands.md) lists the terminal, Scout setup and evaluation commands. [Troubleshooting](troubleshooting.md), [security and data](security.md), and [current limitations](roadmap.md) explain setup failures and product boundaries. [Testing and validation](testing.md) distinguishes automated coverage from product evidence.