peaks-loop 4.1.2 → 4.1.4

package/dist/services/ide/adapters/claude-code-adapter.js

@@ -1,7 +1,16 @@
-import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from 'node:fs';
+import { closeSync, openSync, readSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { claudeCodeSubAgentDispatcher } from '../../dispatch/sub-agent-dispatcher.js';
+import { findTranscriptJsonl, readClaudeStatuslinePercent, resolveClaudeTranscriptPath } from './claude-code-local-state.js';
+import { DEFAULT_CONTEXT_WINDOW_TOKENS, ONE_MILLION_CONTEXT_TOKENS, modelContextWindowTokens, resolveClaudeModelFromEnv } from './claude-code-model-window.js';
+// Re-exported so the public surface of this module is unchanged by the split:
+// the readers live in `claude-code-local-state.ts` now, but every existing
+// importer keeps resolving them from here.
+export { resolveClaudeTranscriptPath };
+// Likewise the model-id / window-size pair, which moved into
+// `claude-code-model-window.ts` to make room for `mcpInstall` below.
+export { modelContextWindowTokens, resolveClaudeModelFromEnv };
 /**
  * Claude Code adapter —— peaks-loop 的"起源 IDE"。
  *
@@ -17,178 +26,8 @@ import { claudeCodeSubAgentDispatcher } from '../../dispatch/sub-agent-dispatche
  *
  * 不可消除的 per-IDE 字段(见 tech-doc.md §1.3)。
  */
-/**
- * Read Claude Code's statusline state file
- * (`~/.claude/statusline-state.json`) and parse a context-percent key.
- * Moved from the generic reader in slice
- * only in the Claude Code adapter.
- */
-function readClaudeStatuslinePercent() {
-    const path = join(homedir(), '.claude', 'statusline-state.json');
-    if (!existsSync(path))
-        return null;
-    try {
-        const json = JSON.parse(readFileSync(path, 'utf8'));
-        const candidates = ['contextPercent', 'context_usage_percent', 'contextPercentUsed'];
-        for (const key of candidates) {
-            const raw = json[key];
-            if (typeof raw === 'number' && Number.isFinite(raw)) {
-                return raw > 1.5 ? raw / 100 : Math.max(0, Math.min(1, raw));
-            }
-        }
-    }
-    catch (err) {
-        // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
-        if (err instanceof ReferenceError)
-            throw err; // surface module-load bugs
-        if (err instanceof SyntaxError)
-            throw err; // surface parse bugs (e.g. broken statusline JSON)
-        return null; // only swallow IO errors
-    }
-    return null;
-}
-/**
- * Recursive search for `<outerSessionId>.jsonl` under `projectsDir`. The
- * Mac layout encodes the cwd as a single hash directory; on Mac Claude Code
- * nests the transcript under that hash with an extra level of subdirectory we
- * cannot predict ahead of time. A flat readdir misses that branch and returns
- * null — the silent-failure mode this recursion closes.
- *
- * Moved from the generic reader in slice
- * session id (Claude Code names its transcript by the outer session UUID),
- * NOT the peaks session id.
- */
-function findTranscriptJsonl(projectsDir, outerSessionId) {
-    if (!existsSync(projectsDir))
-        return null;
-    try {
-        const stack = [projectsDir];
-        while (stack.length > 0) {
-            const dir = stack.pop();
-            if (dir === undefined)
-                break;
-            const entries = readdirSync(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const full = join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    stack.push(full);
-                }
-                else if (entry.isFile() && entry.name === `${outerSessionId}.jsonl`) {
-                    return full;
-                }
-            }
-        }
-    }
-    catch (err) {
-        // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
-        if (err instanceof ReferenceError)
-            throw err; // surface module-load bugs
-        if (err instanceof SyntaxError)
-            throw err; // surface parse bugs
-        return null; // only swallow IO errors
-    }
-    return null;
-}
-/**
- * Resolve the absolute path of a Claude Code transcript jsonl by OUTER
- * session id, searching `~/.claude/projects/**` recursively.
- *
- * `peaks code context-audit` reuses THIS locator instead of re-implementing
- * the recursive find. Returns `null` when the transcript does not exist —
- * callers MUST treat that as "unavailable", never as an error.
- */
-export function resolveClaudeTranscriptPath(outerSessionId, projectsDir = join(homedir(), '.claude', 'projects')) {
-    if (typeof outerSessionId !== 'string' || outerSessionId.length === 0)
-        return null;
-    return findTranscriptJsonl(projectsDir, outerSessionId);
-}
-/** 1M-context window size in tokens (documented single choice: 1,000,000). */
-const ONE_MILLION_CONTEXT_TOKENS = 1_000_000;
-/** Safe-default (non-1M) context window size in tokens. */
-const DEFAULT_CONTEXT_WINDOW_TOKENS = 200_000;
 /** Reverse-scan chunk size in bytes (keeps memory bounded on multi-MB transcripts). */
 const TRANSCRIPT_SCAN_CHUNK_BYTES = 64 * 1024;
-/**
- * Known 1M-context Claude model id prefixes whose ids do NOT carry a `1m`
- * suffix (e.g. `claude-sonnet-4-5-20250929`). The substring match is
- * intentionally generous — every `claude-sonnet-4*` / `claude-opus-4*`
- * variant is 1M-context.
- */
-const ONE_MILLION_CONTEXT_MODELS = ['claude-opus-4', 'claude-sonnet-4'];
-/**
- * Claude Code runtime env vars that may carry the currently-active model id,
- * in documented precedence order (first non-empty value wins):
- *   1. ANTHROPIC_MODEL                — explicit per-run model override
- *   2. ANTHROPIC_DEFAULT_OPUS_MODEL   — default Opus fallback
- *   3. ANTHROPIC_DEFAULT_SONNET_MODEL — default Sonnet fallback
- *   4. ANTHROPIC_DEFAULT_HAIKU_MODEL  — default Haiku fallback
- *   5. ANTHROPIC_DEFAULT_FABLE_MODEL  — default Fable fallback
- *   6. CLAUDE_CODE_SUBAGENT_MODEL     — sub-agent model (used when the others
- *                                       are absent, e.g. a sub-agent-only env)
- *
- * Why env-first: the transcript's `message.model` often drops Claude Code's
- * `[1M]` / `[200K]` suffix marker (observed: `deepseek-v4-flash`), while the
- * runtime env vars above carry it (`deepseek-v4-flash[1M]`). Reading them
- * first lets the window resolver see the true context window. This family is
- * vendor-specific, so it lives ONLY in the claude-code adapter.
- */
-const CLAUDE_CODE_MODEL_ENV_VARS = [
-    'ANTHROPIC_MODEL',
-    'ANTHROPIC_DEFAULT_OPUS_MODEL',
-    'ANTHROPIC_DEFAULT_SONNET_MODEL',
-    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
-    'ANTHROPIC_DEFAULT_FABLE_MODEL',
-    'CLAUDE_CODE_SUBAGENT_MODEL'
-];
-/**
- * Resolve the currently-active Claude Code model id from a runtime env map.
- * Returns the first non-empty `CLAUDE_CODE_MODEL_ENV_VARS` value (trimmed), or
- * `undefined` when none is present. Pure + exported for tests; the caller falls
- * back to the transcript `message.model` when this returns undefined.
- */
-export function resolveClaudeModelFromEnv(env) {
-    if (!env)
-        return undefined;
-    for (const name of CLAUDE_CODE_MODEL_ENV_VARS) {
-        const value = env[name];
-        if (typeof value === 'string') {
-            const trimmed = value.trim();
-            if (trimmed.length > 0)
-                return trimmed;
-        }
-    }
-    return undefined;
-}
-/**
- * Model-aware context-window size in tokens.
- *
- * Detection rule (documented):
- *   1. Empty / unknown model → DEFAULT_CONTEXT_WINDOW_TOKENS (200_000).
- *   2. Suffix heuristic — a model id containing `1m` (case-insensitive) is
- *      treated as 1M-context.
- *   3. Explicit allowlist — known 1M Claude model ids
- *      (ONE_MILLION_CONTEXT_MODELS).
- *   4. Everything else → 200_000 (the safe default).
- *
- * Callers MAY additionally infer ≥1M from the observed token count: if
- * `contextTokens > DEFAULT_CONTEXT_WINDOW_TOKENS`, the model cannot be a
- * 200K model and must be ≥1M (see `readClaudeTranscriptEstimate`).
- *
- * This is the HEURISTIC layer only. Explicit user overrides sit ABOVE it —
- * see `resolveContextWindow`, which is what the probe actually calls.
- */
-export function modelContextWindowTokens(model) {
-    const m = model.trim().toLowerCase();
-    if (m.length === 0)
-        return DEFAULT_CONTEXT_WINDOW_TOKENS;
-    if (m.includes('1m'))
-        return ONE_MILLION_CONTEXT_TOKENS;
-    for (const known of ONE_MILLION_CONTEXT_MODELS) {
-        if (m.includes(known))
-            return ONE_MILLION_CONTEXT_TOKENS;
-    }
-    return DEFAULT_CONTEXT_WINDOW_TOKENS;
-}
 /**
  * the context-window size in tokens. Third-party / proxied models whose id
  * carries no `[1M]` suffix (and is absent from the hardcoded allowlist) are
@@ -602,6 +441,44 @@ export const CLAUDE_CODE_ADAPTER = {
     envVar: 'CLAUDE_PROJECT_DIR',
     hookEvent: 'PreToolUse',
     toolMatcher: 'Bash',
+    // BOTH channels a peaks MCP server can reach this harness through. The hook
+    // entry installed below covers the pair, and the pre-tool branch matches
+    // against the pair; one template would leave the other channel unenforced and
+    // nobody would notice, because a matcher that never fires looks like a clean
+    // call.
+    mcp: {
+        toolNameTemplates: ['mcp__peaks__*', 'mcp__plugin_peaks-loop_peaks__*']
+    },
+    // How this harness REGISTERS a peaks MCP server. The entry
+    // is the harness's OWN verb, not a hand-edit of its config file, which is
+    // full of the user's state (spec §8.3). The shape is recorded in spec §13 —
+    // it is read off that table, not invented here:
+    //   - the `--` before the server argv is LOAD-BEARING: everything after it is
+    //     passed to the server verbatim, otherwise the harness reads the server's
+    //     own flags as its own;
+    //   - the verb is NOT idempotent — same name, same scope fails, with no
+    //     `--force` and no `update` — which is why the engine removes first.
+    // `scopes` is `user` alone: that is the scope a peaks install writes (spec
+    // §8.4), and sweeping a scope peaks never wrote would delete a user's own
+    // entry under the same name.
+    mcpInstall: {
+        serverName: 'peaks',
+        scopes: ['user'],
+        targetScope: 'user',
+        addArgv: [
+            'claude',
+            'mcp',
+            'add',
+            '--scope',
+            '<scope>',
+            '--transport',
+            'stdio',
+            '<name>',
+            '--',
+            '<server-argv>'
+        ],
+        removeArgv: ['claude', 'mcp', 'remove', '<name>', '--scope', '<scope>']
+    },
     // Slice #009: Claude Code uses the `Task` tool for sub-agent dispatch.
     // The CLI calls `claudeCodeSubAgentDispatcher.buildToolCall` to construct
     // the exact args shape the `Task` tool expects.

package/dist/services/ide/adapters/claude-code-local-state.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Read Claude Code's statusline state file
+ * (`~/.claude/statusline-state.json`) and parse a context-percent key.
+ * Moved from the generic reader in slice
+ * only in the Claude Code adapter.
+ */
+export declare function readClaudeStatuslinePercent(): number | null;
+/**
+ * Recursive search for `<outerSessionId>.jsonl` under `projectsDir`. The
+ * Mac layout encodes the cwd as a single hash directory; on Mac Claude Code
+ * nests the transcript under that hash with an extra level of subdirectory we
+ * cannot predict ahead of time. A flat readdir misses that branch and returns
+ * null — the silent-failure mode this recursion closes.
+ *
+ * Moved from the generic reader in slice
+ * session id (Claude Code names its transcript by the outer session UUID),
+ * NOT the peaks session id.
+ */
+export declare function findTranscriptJsonl(projectsDir: string, outerSessionId: string): string | null;
+/**
+ * Resolve the absolute path of a Claude Code transcript jsonl by OUTER
+ * session id, searching `~/.claude/projects/**` recursively.
+ *
+ * `peaks code context-audit` reuses THIS locator instead of re-implementing
+ * the recursive find. Returns `null` when the transcript does not exist —
+ * callers MUST treat that as "unavailable", never as an error.
+ */
+export declare function resolveClaudeTranscriptPath(outerSessionId: string, projectsDir?: string): string | null;

package/dist/services/ide/adapters/claude-code-local-state.js

@@ -0,0 +1,112 @@
+// src/services/ide/adapters/claude-code-local-state.ts
+//
+// The readers for Claude Code's OWN on-disk state — its statusline state file and
+// its transcript directory layout. Split out of `claude-code-adapter.ts`,
+// verbatim and with one import apiece, because that file sits far past the
+// 300-line cap and the repo's size ratchet only ever goes down: the adapter
+// needs room for new declared surface, and a self-contained reader leaving is
+// how a file earns that room instead of raising the ceiling.
+//
+// Nothing here is peaks-loop state. Every path below belongs to the harness, and
+// every function tolerates its absence by answering `null` — a machine without a
+// statusline file is not a broken machine.
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Above this, a stored value is a percentage rather than a 0–1 fraction. Both
+ * spellings occur in the wild, and nothing needs to know which one the harness
+ * picked.
+ */
+const PERCENT_VERSUS_FRACTION = 1.5;
+/**
+ * Read Claude Code's statusline state file
+ * (`~/.claude/statusline-state.json`) and parse a context-percent key.
+ * Moved from the generic reader in slice
+ * only in the Claude Code adapter.
+ */
+export function readClaudeStatuslinePercent() {
+    const path = join(homedir(), '.claude', 'statusline-state.json');
+    if (!existsSync(path))
+        return null;
+    try {
+        const json = JSON.parse(readFileSync(path, 'utf8'));
+        const candidates = ['contextPercent', 'context_usage_percent', 'contextPercentUsed'];
+        for (const key of candidates) {
+            const raw = json[key];
+            if (typeof raw === 'number' && Number.isFinite(raw)) {
+                return raw > PERCENT_VERSUS_FRACTION ? raw / 100 : Math.max(0, Math.min(1, raw));
+            }
+        }
+    }
+    catch (err) {
+        // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
+        if (err instanceof ReferenceError)
+            throw err; // surface module-load bugs
+        if (err instanceof SyntaxError)
+            throw err; // surface parse bugs (e.g. broken statusline JSON)
+        return null; // only swallow IO errors
+    }
+    return null;
+}
+/** One directory's worth of the walk: recurse into directories, return a matching file. */
+function scanForFile(dir, fileName, pending) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            pending.push(full);
+        }
+        else if (entry.isFile() && entry.name === fileName) {
+            return full;
+        }
+    }
+    return null;
+}
+/**
+ * Recursive search for `<outerSessionId>.jsonl` under `projectsDir`. The
+ * Mac layout encodes the cwd as a single hash directory; on Mac Claude Code
+ * nests the transcript under that hash with an extra level of subdirectory we
+ * cannot predict ahead of time. A flat readdir misses that branch and returns
+ * null — the silent-failure mode this recursion closes.
+ *
+ * Moved from the generic reader in slice
+ * session id (Claude Code names its transcript by the outer session UUID),
+ * NOT the peaks session id.
+ */
+export function findTranscriptJsonl(projectsDir, outerSessionId) {
+    if (!existsSync(projectsDir))
+        return null;
+    const pending = [projectsDir];
+    try {
+        while (pending.length > 0) {
+            const dir = pending.pop();
+            if (dir === undefined)
+                continue;
+            const found = scanForFile(dir, `${outerSessionId}.jsonl`, pending);
+            if (found !== null)
+                return found;
+        }
+    }
+    catch (err) {
+        // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
+        if (err instanceof ReferenceError)
+            throw err; // surface module-load bugs
+        if (err instanceof SyntaxError)
+            throw err; // surface parse bugs
+        return null; // only swallow IO errors
+    }
+    return null;
+}
+/**
+ * Resolve the absolute path of a Claude Code transcript jsonl by OUTER
+ * session id, searching `~/.claude/projects/**` recursively.
+ *
+ * `peaks code context-audit` reuses THIS locator instead of re-implementing
+ * the recursive find. Returns `null` when the transcript does not exist —
+ * callers MUST treat that as "unavailable", never as an error.
+ */
+export function resolveClaudeTranscriptPath(outerSessionId, projectsDir = join(homedir(), '.claude', 'projects')) {
+    if (typeof outerSessionId !== 'string' || outerSessionId.length === 0)
+        return null;
+    return findTranscriptJsonl(projectsDir, outerSessionId);
+}

package/dist/services/ide/adapters/claude-code-model-window.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 1M-context window size in tokens (documented single choice: 1,000,000).
+ * EXPORTED because the adapter's late 1M rescue (`resolveContextWindowTokens`)
+ * names it too — one number, one declaration, rather than a copy that can drift.
+ */
+export declare const ONE_MILLION_CONTEXT_TOKENS = 1000000;
+/**
+ * Safe-default (non-1M) context window size in tokens. Exported for the same
+ * reason: `resolveContextWindow` compares the heuristic against it.
+ */
+export declare const DEFAULT_CONTEXT_WINDOW_TOKENS = 200000;
+/**
+ * Resolve the currently-active Claude Code model id from a runtime env map.
+ * Returns the first non-empty `CLAUDE_CODE_MODEL_ENV_VARS` value (trimmed), or
+ * `undefined` when none is present. Pure + exported for tests; the caller falls
+ * back to the transcript `message.model` when this returns undefined.
+ */
+export declare function resolveClaudeModelFromEnv(env: NodeJS.ProcessEnv | undefined): string | undefined;
+/**
+ * Model-aware context-window size in tokens.
+ *
+ * Detection rule (documented):
+ *   1. Empty / unknown model → DEFAULT_CONTEXT_WINDOW_TOKENS (200_000).
+ *   2. Suffix heuristic — a model id containing `1m` (case-insensitive) is
+ *      treated as 1M-context.
+ *   3. Explicit allowlist — known 1M Claude model ids
+ *      (ONE_MILLION_CONTEXT_MODELS).
+ *   4. Everything else → 200_000 (the safe default).
+ *
+ * Callers MAY additionally infer ≥1M from the observed token count: if
+ * `contextTokens > DEFAULT_CONTEXT_WINDOW_TOKENS`, the model cannot be a
+ * 200K model and must be ≥1M (see `readClaudeTranscriptEstimate`).
+ *
+ * This is the HEURISTIC layer only. Explicit user overrides sit ABOVE it —
+ * see `resolveContextWindow`, which is what the probe actually calls.
+ */
+export declare function modelContextWindowTokens(model: string): number;

package/dist/services/ide/adapters/claude-code-model-window.js

@@ -0,0 +1,113 @@
+// src/services/ide/adapters/claude-code-model-window.ts
+//
+// Which Claude Code model is active, and how many tokens its context window
+// holds. Those are the two questions `resolveClaudeModelFromEnv` and
+// `modelContextWindowTokens` answer, and they are the pair that left
+// `claude-code-adapter.ts`: that file is far past the
+// 300-line cap, the repo's size ratchet only ever goes down, and the adapter
+// needed room for its `mcpInstall` declaration. Same technique, and the same
+// reason, as the `claude-code-local-state.ts` split before it — a self-contained
+// responsibility leaves, instead of the ceiling going up.
+//
+// WHY THIS BLOCK AND NOT ANOTHER. Both functions are PURE: the env map is an
+// argument, and nothing here reads a file, an env var or a process global. So
+// the move needs no rewiring in either direction — the adapter imports both
+// back and nothing here reaches for the adapter — which is what keeps the move
+// a move. It is also the one block in that file whose eslint findings are zero,
+// which a receiving file with no baseline row must be.
+//
+// The vendor spellings below (`ANTHROPIC_*`, `claude-opus-4`) are Claude Code's
+// own. An adapter is the only place they belong (spec §13), which is why this is
+// a second adapter module and not a shared one.
+/**
+ * 1M-context window size in tokens (documented single choice: 1,000,000).
+ * EXPORTED because the adapter's late 1M rescue (`resolveContextWindowTokens`)
+ * names it too — one number, one declaration, rather than a copy that can drift.
+ */
+export const ONE_MILLION_CONTEXT_TOKENS = 1_000_000;
+/**
+ * Safe-default (non-1M) context window size in tokens. Exported for the same
+ * reason: `resolveContextWindow` compares the heuristic against it.
+ */
+export const DEFAULT_CONTEXT_WINDOW_TOKENS = 200_000;
+/**
+ * Known 1M-context Claude model id prefixes whose ids do NOT carry a `1m`
+ * suffix (e.g. `claude-sonnet-4-5-20250929`). The substring match is
+ * intentionally generous — every `claude-sonnet-4*` / `claude-opus-4*`
+ * variant is 1M-context.
+ */
+const ONE_MILLION_CONTEXT_MODELS = ['claude-opus-4', 'claude-sonnet-4'];
+/**
+ * Claude Code runtime env vars that may carry the currently-active model id,
+ * in documented precedence order (first non-empty value wins):
+ *   1. ANTHROPIC_MODEL                — explicit per-run model override
+ *   2. ANTHROPIC_DEFAULT_OPUS_MODEL   — default Opus fallback
+ *   3. ANTHROPIC_DEFAULT_SONNET_MODEL — default Sonnet fallback
+ *   4. ANTHROPIC_DEFAULT_HAIKU_MODEL  — default Haiku fallback
+ *   5. ANTHROPIC_DEFAULT_FABLE_MODEL  — default Fable fallback
+ *   6. CLAUDE_CODE_SUBAGENT_MODEL     — sub-agent model (used when the others
+ *                                       are absent, e.g. a sub-agent-only env)
+ *
+ * Why env-first: the transcript's `message.model` often drops Claude Code's
+ * `[1M]` / `[200K]` suffix marker (observed: `deepseek-v4-flash`), while the
+ * runtime env vars above carry it (`deepseek-v4-flash[1M]`). Reading them
+ * first lets the window resolver see the true context window. This family is
+ * vendor-specific, so it lives ONLY in the claude-code adapter.
+ */
+const CLAUDE_CODE_MODEL_ENV_VARS = [
+    'ANTHROPIC_MODEL',
+    'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    'ANTHROPIC_DEFAULT_FABLE_MODEL',
+    'CLAUDE_CODE_SUBAGENT_MODEL'
+];
+/**
+ * Resolve the currently-active Claude Code model id from a runtime env map.
+ * Returns the first non-empty `CLAUDE_CODE_MODEL_ENV_VARS` value (trimmed), or
+ * `undefined` when none is present. Pure + exported for tests; the caller falls
+ * back to the transcript `message.model` when this returns undefined.
+ */
+export function resolveClaudeModelFromEnv(env) {
+    if (!env)
+        return undefined;
+    for (const name of CLAUDE_CODE_MODEL_ENV_VARS) {
+        const value = env[name];
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (trimmed.length > 0)
+                return trimmed;
+        }
+    }
+    return undefined;
+}
+/**
+ * Model-aware context-window size in tokens.
+ *
+ * Detection rule (documented):
+ *   1. Empty / unknown model → DEFAULT_CONTEXT_WINDOW_TOKENS (200_000).
+ *   2. Suffix heuristic — a model id containing `1m` (case-insensitive) is
+ *      treated as 1M-context.
+ *   3. Explicit allowlist — known 1M Claude model ids
+ *      (ONE_MILLION_CONTEXT_MODELS).
+ *   4. Everything else → 200_000 (the safe default).
+ *
+ * Callers MAY additionally infer ≥1M from the observed token count: if
+ * `contextTokens > DEFAULT_CONTEXT_WINDOW_TOKENS`, the model cannot be a
+ * 200K model and must be ≥1M (see `readClaudeTranscriptEstimate`).
+ *
+ * This is the HEURISTIC layer only. Explicit user overrides sit ABOVE it —
+ * see `resolveContextWindow`, which is what the probe actually calls.
+ */
+export function modelContextWindowTokens(model) {
+    const m = model.trim().toLowerCase();
+    if (m.length === 0)
+        return DEFAULT_CONTEXT_WINDOW_TOKENS;
+    if (m.includes('1m'))
+        return ONE_MILLION_CONTEXT_TOKENS;
+    for (const known of ONE_MILLION_CONTEXT_MODELS) {
+        if (m.includes(known))
+            return ONE_MILLION_CONTEXT_TOKENS;
+    }
+    return DEFAULT_CONTEXT_WINDOW_TOKENS;
+}

package/dist/services/ide/ide-mcp-install-types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The REGISTRATION profile of one harness's MCP entry point (spec §8.3).
+ *
+ * WHY THIS IS NOT `IdeMcpProfile`. That profile (on `IdeAdapter.mcp`) answers
+ * "how does this harness SPELL a peaks tool name", which the pre-tool branch
+ * needs. This one answers "how does this harness register a server", which only
+ * the distribution path needs. One field would conflate two questions asked by
+ * two callers that never run together.
+ *
+ * WHY IT DECLARES ARGV AND NOT A COMMAND STRING. Registering is the HARNESS's
+ * own operation: `peaks mcp install` calls the harness's entry point rather than
+ * hand-editing the harness's config file, because that file is full of the
+ * user's state and hand-editing it is neither safe nor version-stable (§8.3).
+ * The entry is declared as an ARRAY with three placeholders, so the engine that
+ * consumes it substitutes values into an array and never builds a command line.
+ *
+ * WHY add AND remove ARE BOTH DECLARED. A harness's register verb is not
+ * idempotent — same name, same scope, and it fails, with no `--force` and no
+ * `update` — so the install is delete-then-add (§8.3). Both halves are therefore
+ * part of the contract, and `scopes` exists because the entry can already sit in
+ * more than one of them: the delete is a sweep, not a targeted call.
+ *
+ * WHAT IS DELIBERATELY ABSENT: any harness name, any platform name, and any
+ * branch on either. A vendor's own spellings belong in its adapter, which is the
+ * only module that fills this type in.
+ */
+/** Placeholder for the server key the harness files peaks under. */
+export declare const MCP_NAME_PLACEHOLDER = "<name>";
+/** Placeholder for one scope the entry can live in; substituted once per removal. */
+export declare const MCP_SCOPE_PLACEHOLDER = "<scope>";
+/** Placeholder for the launched server argv — the command and every token after it. */
+export declare const MCP_SERVER_ARGV_PLACEHOLDER = "<server-argv>";
+/** The placeholders an argv template may carry, and nothing else may look like one. */
+export declare const MCP_ARGV_PLACEHOLDERS: readonly ["<name>", "<scope>", "<server-argv>"];
+/**
+ * How one harness registers, and unregisters, a peaks MCP server.
+ *
+ * Optional on `IdeAdapter`, like `skillInstall?` / `standardsProfile?`: an
+ * adapter that omits it is declaring "this harness has no registration entry
+ * peaks may call", and every consumer reads that as "nothing to do" rather than
+ * as an error.
+ */
+export interface IdeMcpInstallProfile {
+    /** The server key this harness files peaks under. The install touches only this one. */
+    readonly serverName: string;
+    /**
+     * Every scope the entry can live in. The delete sweeps all of them, because a
+     * previous install may have written a different one and the harness's own
+     * removal fails on the scope that is empty.
+     */
+    readonly scopes: readonly string[];
+    /** The scope the entry is (re-)written to. Must be one of `scopes`. */
+    readonly targetScope: string;
+    /** argv template that registers the server. Carries `<name>` and `<server-argv>`. */
+    readonly addArgv: readonly string[];
+    /** argv template that unregisters it. Carries `<name>` and `<scope>`. */
+    readonly removeArgv: readonly string[];
+}
+/** The values an argv template is expanded with. */
+export interface McpArgvValues {
+    readonly serverName: string;
+    readonly scope: string;
+    readonly serverArgv: readonly string[];
+}
+/**
+ * A declaration that cannot drive an install is a defect in the adapter, and it
+ * is reported as one rather than silently producing an argv the harness will
+ * reject. That is the whole argument for throwing here: a profile missing its
+ * server-argv placeholder would install a registration that launches nothing,
+ * and nothing would say so.
+ */
+export declare function assertMcpInstallProfile(profile: IdeMcpInstallProfile): void;
+/**
+ * Expand one argv template. A placeholder that stands for SEVERAL tokens expands
+ * to all of them, which is why this returns an array and why the launched server
+ * argv is passed as one: the caller never joins and never splits.
+ */
+export declare function expandMcpArgv(argv: readonly string[], values: McpArgvValues): readonly string[];