openmerit 0.1.10 → 0.1.12

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

@@ -0,0 +1,5 @@
+import type { ScoutClient } from './scout-credentials.ts';
+export declare const rule = "# Application model decisions \u00B7 OpenMerit Scout\n\nBefore choosing, recommending, adding, downloading, replacing or configuring\nANY application inference model, load the `openmerit-scout` skill and consult\n`scout_models` on the `openmerit` MCP server before committing to a model.\nThis applies even when the user only asks you to build a feature, never mentions\nmodels or Scout, or names a model themselves (assess it; do not silently replace it).\n\nA pretrained model, local weights, browser inference, an SDK's default model,\nembeddings, OCR, speech, image classification, detection and segmentation all\ncount as model choices, not implementation details. Identify this decision before\nwriting model-specific code, installing a model package or downloading weights.\n\nFollow the skill's project access policy. If it is missing, ask and save it first.\nIf Scout is unavailable, fails or has no suitable evidence/candidate, disclose the\ngap and pause the model decision; do not fall back to a remembered or SDK-default\nmodel. You may continue work that does not commit to a model.\n\nDo not consult Scout for unrelated edits, normal inference calls using an unchanged\napproved model, or this coding agent's own model. Do not reselect approved models\nunless the task introduces or changes a model decision.\n\nWhen the user says \"update openmerit\", run\n`npx -y openmerit@latest update --scope user` (use `--scope project` if this\nrule is in the project's .claude/rules directory). Report the result, including\nany conflict or manual-upgrade requirement. Do not delete edited files, bypass\npermissions or rerun login automatically. A new session loads updated instructions.\n";
+export declare const skill = "---\nname: openmerit-scout\ndescription: 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.\n---\n\n# OpenMerit \u00B7 Scout\n\nBefore introducing, recommending, replacing or configuring an application\ninference model, call the `scout_models` tool on the `openmerit` MCP server.\nThis applies even when the user never mentions models or Scout. Downloading local\nweights, using a pretrained browser model or accepting an SDK default is a model\ndecision: consult Scout before model-specific code, installs or downloads.\nPreserve the user's explicit model choice; assess it rather than silently replacing\nit. Leave unchanged, approved application selections in place.\n\n## Project policy\n\nRead `.openmerit/scout.json` before searching. If it is absent, ask once whether this\nproject uses **existing-only** (only endpoints it can already reach) or\n**existing-first** (prefer them, ask before searching the whole catalogue), and\nwhich public catalogue endpoint IDs it can access. Save the answer:\n\n```sh\nnpx -y openmerit@latest project --policy existing-only --endpoint-id <id> ...\n```\n\nNever infer access from a model name, SDK or environment-variable name. Never\nrecord credentials, private URLs, prompts or customer data. An empty inventory\nis not permission to search all models.\n\n## Searching\n\nCall `scout_models` with a non-confidential task description and\n`endpointIds` set to the saved inventory, including `[]` when empty.\nExisting-only never broadens. For existing-first, if no existing candidate fits,\nexplain the gap and ask before a separate search without `endpointIds`. Send\nonly task requirements, never source files, secrets or real customer records.\n\nCompare model AND endpoint, evidence, reference cost/time, unknowns and\nwarnings. For multiple tasks read `tasks[].slots[0].recommendations`; the\ntop-level list is empty. Prefer the cheapest usable option the quality evidence\nsupports, without claiming benchmarks prove application accuracy. Use the\nreturned provider model ID and the project's actual SDK and protocol.\n\n## Boundaries\n\nAsk before adding providers or credentials, spending, deploying or external\nwrites. Report recommendation, endpoint connectivity and application checks as\nseparate results, each only after it succeeds. Do not switch this coding agent's\nown model.\n\nIf Scout fails or has no suitable candidate/evidence for the required deployment,\nsay so and pause the model decision; do not substitute a remembered recommendation\nor SDK default. Continue only model-independent work. Local/browser models are not\nexempt when the catalogue lacks coverage. If it reports that the device key is missing,\nexpired or revoked, run `npx -y openmerit@latest login` and then\n`npx -y openmerit@latest install` again. Never ask the user to paste a key.\n";
+export declare function scoutRule(client: ScoutClient): string;
+export declare function scoutSkill(client: ScoutClient): string;

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

@@ -0,0 +1,103 @@
+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.
+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 and
+\`endpointIds\` set to the saved inventory, including \`[]\` when empty.
+Existing-only never broadens. For existing-first, if no existing candidate fits,
+explain the gap and ask before a separate search without \`endpointIds\`. Send
+only task requirements, never source files, secrets or real customer records.
+
+Compare model AND endpoint, evidence, reference cost/time, unknowns and
+warnings. For multiple tasks read \`tasks[].slots[0].recommendations\`; the
+top-level list is empty. Prefer the cheapest usable option the quality evidence
+supports, without claiming benchmarks prove application accuracy. Use the
+returned provider model ID and 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,106 @@
+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.
+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 and
+\`endpointIds\` set to the saved inventory, including \`[]\` when empty.
+Existing-only never broadens. For existing-first, if no existing candidate fits,
+explain the gap and ask before a separate search without \`endpointIds\`. Send
+only task requirements, never source files, secrets or real customer records.
+
+Compare model AND endpoint, evidence, reference cost/time, unknowns and
+warnings. For multiple tasks read \`tasks[].slots[0].recommendations\`; the
+top-level list is empty. Prefer the cheapest usable option the quality evidence
+supports, without claiming benchmarks prove application accuracy. Use the
+returned provider model ID and 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/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/dist/terminal/src/updates.js

@@ -2,6 +2,7 @@
 // built-ins: it must survive the npx cache disappearing, without installing or
 // executing code from the release it downloads.
 import { createHash, randomUUID } from 'node:crypto';
+import { realpathSync } from 'node:fs';
 import { mkdir, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -381,7 +382,7 @@ export async function runUpdate(base, scope, options = {}) {
 }
 // Hooks deliberately never ask Claude to continue, read transcripts or emit
 // blocking decisions. Offline and concurrent-hook failures exit successfully.
-if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+if (process.argv[1] && realpathSync(resolve(process.argv[1])) === fileURLToPath(import.meta.url)) {
     const args = process.argv.slice(2), base = args[args.indexOf('--base') + 1], scope = args[args.indexOf('--scope') + 1];
     if (base && ['user', 'project'].includes(scope ?? '')) {
         process.stdin.resume();

package/dist/terminal/src/updates.ts

@@ -2,6 +2,7 @@
 // built-ins: it must survive the npx cache disappearing, without installing or
 // executing code from the release it downloads.
 import { createHash, randomUUID } from 'node:crypto';
+import { realpathSync } from 'node:fs';
 import { mkdir, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -300,7 +301,7 @@ export async function runUpdate(base: string, scope: string, options: { hook?: b
 
 // Hooks deliberately never ask Claude to continue, read transcripts or emit
 // blocking decisions. Offline and concurrent-hook failures exit successfully.
-if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+if (process.argv[1] && realpathSync(resolve(process.argv[1])) === fileURLToPath(import.meta.url)) {
   const args = process.argv.slice(2), base = args[args.indexOf('--base') + 1], scope = args[args.indexOf('--scope') + 1];
   if (base && ['user', 'project'].includes(scope ?? '')) {
     process.stdin.resume();

package/docs/adapter-guide.md

@@ -1,5 +1,7 @@
 # Building a harness adapter
 
+**Evaluation coordinator boundary:** this guide remains applicable to custom harnesses. Pi-specific examples refer to the historical Pi 0.87 evaluation adapter. The unreleased Pi 1.5.0 `openmerit/pi` export is instead a thin Scout adapter and does not implement `HarnessAdapter`; see [native MCP and SDK embedding](pi-extension.md#sdk-embedding).
+
 OpenMerit adapters are transport bridges. They do not reproduce OpenMerit's lifecycle, validation, persistence, or Pareto rules, and OpenMerit does not reproduce the harness's intelligence.
 
 ## Required components

package/docs/architecture.md

@@ -1,5 +1,7 @@
 # Architecture
 
+**Source status:** the Pi 1.5.0 native Scout replacement is unreleased and unpublished. The protocol/core evaluation coordinator described here remains available for custom harnesses; it is not invoked by the new Pi adapter. The standalone evaluation CLI and Inference Terminal are unchanged.
+
 ## Design principle
 
 OpenMerit is an orchestrator, not an intelligence layer. The product application LLM call is the system under test; the coding harness is the evaluator and execution environment.
@@ -12,7 +14,7 @@ OpenMerit deterministic orchestration
         |
         | typed intent: outcome, constraints, evidence
         v
-Coding harness such as Pi
+Custom evaluation harness
         |
         | intelligent work, tools, evals, calculation
         v
@@ -38,13 +40,13 @@ Contains deterministic behavior: choosing the next lifecycle intent according to
 
 `OpenMeritCoordinator` is the reusable adapter boundary. It constructs canonical intents, negotiates capabilities, records lifecycle progress and observations, validates results, and advances durable state. `OpenMeritStore` makes persistence replaceable; `ProjectStore` is the bundled filesystem backend.
 
-The coordinator also accepts idempotent application-target automation signals and evaluates the user-confirmed `AutomationCheckPolicy`. `buildAutomationPlan` tells an adapter which signals and wakeups are required and reports unsupported persistent scheduling honestly. Provisioning belongs to the adapter: Pi can install an authorized macOS user LaunchAgent; the coordinator itself does not create operating-system schedulers or paid cloud workers.
+The coordinator also accepts idempotent application-target automation signals and evaluates the user-confirmed `AutomationCheckPolicy`. `buildAutomationPlan` tells an adapter which signals and wakeups are required and reports unsupported persistent scheduling honestly. Provisioning belongs to a custom adapter; the coordinator itself does not create operating-system schedulers or paid cloud workers. The removed Pi 0.87 adapter's LaunchAgent is historical functionality, not part of the new Scout connection.
 
 ### `openmerit/pi`
 
-Exposes the command surface, supplies private typed intent context, triggers Pi, accepts one structured completion for the active intent, records evidence, advances the lifecycle, and detects model-catalog changes.
+Exports `createScoutPiExtension` and a default native Scout extension for Pi 1.5.0. It registers the authenticated Scout HTTP MCP server through Pi and adds shared rule/skill prompt sections. Pi owns discovery, tools, permissions, model and sessions; SDK hosts must load Pi's `createMcpExtension()` explicitly alongside it.
 
-The Pi package implements `HarnessAdapter`. It does not define canonical intents, per-intent result contracts, stage transitions, or validation rules.
+The package no longer implements `HarnessAdapter`, exposes lifecycle commands, or schedules evaluation work. It shares credential and instruction code with the installer instead of duplicating an MCP client or evaluation coordinator. See [Pi installation and migration](pi-extension.md).
 
 ### Inference Terminal
 
@@ -52,7 +54,7 @@ The Pi package implements `HarnessAdapter`. It does not define canonical intents
 
 ## Intelligence resources
 
-Models, web research, tools, evaluators, and fast decision systems such as Jev System One are harness resources. They are configured and invoked by Pi. This keeps OpenMerit provider-neutral and lets future adapters choose their own implementation.
+Models, web research, tools, evaluators, and fast decision systems such as Jev System One are harness resources. They are configured and invoked by the host harness. This keeps the coordinator provider-neutral and lets custom adapters choose their own implementation.
 
 ## Trust boundary
 

package/docs/automation.md

@@ -1,5 +1,7 @@
 # Harness-neutral automation
 
+**Core reference / historical Pi workflow:** the unreleased Pi 1.5.0 Scout adapter replaces the Pi 0.87 lifecycle adapter. It has no signals, `/openmerit` commands, scheduler, headless wakeups, or LaunchAgent. Pi-specific provisioning instructions below are historical, not available in the replacement. The coordinator's policy and signal APIs remain available to custom harnesses. See [current Pi setup and migration](pi-extension.md); the standalone [evaluation watcher](agent-evaluations.md) is unchanged.
+
 The user defines cadence, thresholds, budget, scheduling mode, and automation permission. OpenMerit stores that policy, evaluates durable signals, and decides whether a bounded intent is due. A harness adapter arranges native wakeups and reports events. The coding harness performs the resulting intelligent work.
 
 ```text

package/docs/budgets.md

@@ -1,5 +1,7 @@
 # Budgets and permissions
 
+**Core reference / historical Pi workflow:** these coordinator policies are available to custom evaluation harnesses. Pi-specific setup and automation references describe the removed Pi 0.87 adapter, not the unreleased Pi 1.5.0 Scout connection. The new adapter grants only Scout MCP access and shared guidance; it does not run evaluations or authorize swaps. See [Pi setup](pi-extension.md). The standalone CLI has its own [budget controls](agent-evaluations.md#budget-selection), unchanged by this replacement.
+
 Setup asks you to confirm the limits and permissions for evaluation work. OpenMerit stores the policy and passes its constraints to the harness.
 
 ## Evaluation costs

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 replacement — unreleased, unpublished source:** Pi 1.5.0 uses only native Scout MCP and shared guidance. Run `npx -y openmerit@latest install --client pi [--scope user|project]` after publication 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. All `/openmerit` slash commands below are **historical Pi 0.87 references**, not commands in the new Scout adapter. Core lifecycle APIs remain available for custom harnesses.
 
 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`.
 

package/docs/demo.md

@@ -13,7 +13,7 @@ The separately deployed [delivery-resolution experiment](https://openmerit.ai/de
 
 ## Run your own supervised trial
 
-Use [Pi setup](getting-started.md#set-up-model-comparisons-with-pi) and [your first trial](first-trial.md) for real application measurements. The repository's separate `npm run demo` sandbox makes live provider calls; its requirements and spend boundaries are in [testing](testing.md#experimental-sandbox).
+Use [the standalone evaluation CLI](agent-evaluations.md) or a [custom coordinator harness](adapter-guide.md) for real application measurements. [Your first trial](first-trial.md) retains the historical Pi 0.87 lifecycle walkthrough; the unreleased [Pi 1.5.0 Scout adapter](pi-extension.md) does not provide it. The repository's separate `npm run demo` sandbox makes live provider calls; its requirements and spend boundaries are in [testing](testing.md#experimental-sandbox).
 
 ## Recorded player
 

package/docs/first-trial.md

@@ -1,5 +1,7 @@
 # Your first supervised trial
 
+**Historical Pi 0.87 walkthrough / core evaluation reference:** the unreleased Pi 1.5.0 replacement is a native Scout adapter, not an evaluation lifecycle adapter. It has none of the `/openmerit` commands or setup flow below. Retain this walkthrough for custom harness/coordinator work; for current setup use [Scout for Pi](pi-extension.md), and for standalone comparisons use [agent evaluations](agent-evaluations.md). This page is not a receipt of a successful trial.
+
 Use one representative product task to learn whether OpenMerit and your harness can collect useful evidence. This guide describes a trial to perform; it does not claim that a trial has already succeeded for your product.
 
 ## Choose a bounded task