peaks-loop 4.1.2 → 4.1.4

package/dist/services/distribution/mcp-install.js

@@ -0,0 +1,179 @@
+// src/services/distribution/mcp-install.ts
+//
+// The vendor-neutral MCP registration engine (spec §8.3). It owns the SHAPE of
+// an install — delete every scope, then add — and owns no harness's spelling of
+// anything: the server key, the scopes and the argv come from the adapter's
+// `mcpInstall` profile, and the process that runs the argv is an injected
+// runner.
+//
+// WHY DELETE-THEN-ADD AND NOT "CHECK, THEN ADD IF ABSENT". The harness's own
+// register verb is not idempotent: the same name in the same scope fails, and
+// there is no `--force` and no `update` to reach for. A conditional add would
+// therefore have to be right about a state it cannot see — so the engine does
+// the one thing that is right in both states: it removes what is there (a
+// removal that finds nothing is tolerated) and then adds. That is also what
+// makes the install SEMANTICALLY idempotent: two runs produce the same argv in
+// the same order, so the registration left behind has the same CONTENT, even
+// though the second run performed operations the first one did too.
+//
+// WHY THE DELETE SWEEPS EVERY SCOPE. The entry can already exist in a scope the
+// install is not writing to — an earlier install, or a user who moved it. The
+// removal names a scope, and the harness fails on the wrong or empty one, so a
+// targeted delete would leave the old entry behind and the add would then fail
+// on the duplicate it left. Sweeping all declared scopes is the only version of
+// this that is correct for a state the engine cannot enumerate.
+//
+// WHAT "ONLY OURS" MEANS HERE. The engine never reads or writes the
+// harness's configuration file. It runs the harness's own removal and addition,
+// and the only key either of them names is the adapter's `serverName` — so no
+// other entry can be touched by construction. The honest limit of that
+// guarantee is the name itself: an entry the USER named the same thing is
+// indistinguishable from ours, and is the one case this cannot tell apart.
+//
+// NO HARNESS BRANCH, NO PLATFORM BRANCH. Every value is either the caller's or
+// the adapter's. `resolveMcpServerArgv` returns an interpreter and an entry path
+// for the same reason `cli-executor.ts` does: a shipped CLI name is a shim on
+// some platforms, and choosing between the two spellings would be the platform
+// branch this module is forbidden to contain.
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { assertMcpInstallProfile, expandMcpArgv } from '../ide/ide-mcp-install-types.js';
+/** `<packageRoot>` — this file's tree is `<root>/src/services/distribution` or `<root>/dist/…`. */
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
+/**
+ * The argv that launches THIS installation's read-only MCP server.
+ *
+ * An interpreter and an entry path, in array form: the same shape `mcp serve`
+ * spawns and the same one the read-only executor uses. A bare CLI name would be
+ * a `.cmd` shim on some platforms, and picking a spelling per platform is the
+ * branch this tree forbids — resolving the pair needs none.
+ */
+export function resolveMcpServerArgv() {
+    return [process.execPath, join(PACKAGE_ROOT, 'bin', 'peaks.js'), 'mcp', 'serve'];
+}
+/** The plan: one removal per declared scope, then the addition. Order is the contract. */
+export function buildMcpInstallPlan(profile, serverArgv) {
+    assertMcpInstallProfile(profile);
+    const removals = profile.scopes.map((scope) => ({
+        operation: 'remove',
+        scope,
+        command: {
+            command: profile.removeArgv[0] ?? '',
+            args: expandMcpArgv(profile.removeArgv.slice(1), {
+                serverName: profile.serverName,
+                scope,
+                serverArgv
+            })
+        }
+    }));
+    const addition = {
+        operation: 'add',
+        scope: profile.targetScope,
+        command: {
+            command: profile.addArgv[0] ?? '',
+            args: expandMcpArgv(profile.addArgv.slice(1), {
+                serverName: profile.serverName,
+                scope: profile.targetScope,
+                serverArgv
+            })
+        }
+    };
+    return [...removals, addition];
+}
+/** Every removal, then the addition. A failed removal is a fact, not a failure. */
+export function runMcpInstallPlan(profile, serverArgv, runner) {
+    const plan = buildMcpInstallPlan(profile, serverArgv);
+    const removed = [];
+    const absent = [];
+    let detail = '';
+    for (const step of plan) {
+        const outcome = runner(step.command);
+        if (step.operation === 'remove') {
+            if (outcome.ok)
+                removed.push(step.scope);
+            else
+                absent.push(step.scope);
+            continue;
+        }
+        if (!outcome.ok) {
+            return {
+                serverName: profile.serverName,
+                removed,
+                absent,
+                added: false,
+                ok: false,
+                detail: `the registration was not written: ${outcome.detail}`
+            };
+        }
+        detail = `registered in scope '${step.scope}'`;
+    }
+    return { serverName: profile.serverName, removed, absent, added: true, ok: true, detail };
+}
+/**
+ * The removal sweep on its own — what `uninstall` is, and all that it is.
+ *
+ * `exit 0` removed it, `exit != 0` answered "no" (absent, unchanged) — but a run the
+ * deadline killed, or one that never launched, ANSWERED NOTHING, and calling that
+ * "nothing was there" is the lie this sweep used to tell. Those scopes are `unknown`,
+ * and `ok` is false whenever any scope is unknown: with a scope the harness never
+ * spoke for, the removal is unconfirmed and the state is not known.
+ */
+export function runMcpUninstallPlan(profile, serverArgv, runner) {
+    const plan = buildMcpInstallPlan(profile, serverArgv).filter((step) => step.operation === 'remove');
+    const removed = [];
+    const absent = [];
+    const unknown = [];
+    for (const step of plan) {
+        const outcome = runner(step.command);
+        if (outcome.ok)
+            removed.push(step.scope);
+        else if (outcome.answered === false)
+            unknown.push(step.scope);
+        else
+            absent.push(step.scope);
+    }
+    return {
+        serverName: profile.serverName,
+        removed,
+        absent,
+        unknown,
+        added: false,
+        ok: unknown.length === 0,
+        detail: unknown.length > 0
+            ? `the '${profile.serverName}' removal is unconfirmed: ${unknown.length} scope(s) never answered`
+            : removed.length === 0
+                ? `no '${profile.serverName}' registration was present in any declared scope`
+                : `removed '${profile.serverName}' from ${removed.length} scope(s)`
+    };
+}
+export const NO_MCP_INSTALL_REASON = 'adapter declares no mcpInstall profile';
+/** Register this adapter's harness, or report that there is nothing to register. */
+export function installMcpForAdapter(adapter, serverArgv, runner) {
+    const profile = adapter.mcpInstall;
+    if (profile === undefined) {
+        return { ideId: adapter.id, skipped: true, reason: NO_MCP_INSTALL_REASON };
+    }
+    return {
+        ideId: adapter.id,
+        skipped: false,
+        report: runMcpInstallPlan(profile, serverArgv, runner)
+    };
+}
+/** The same, for the removal side. */
+export function uninstallMcpForAdapter(adapter, serverArgv, runner) {
+    const profile = adapter.mcpInstall;
+    if (profile === undefined) {
+        return { ideId: adapter.id, skipped: true, reason: NO_MCP_INSTALL_REASON };
+    }
+    return {
+        ideId: adapter.id,
+        skipped: false,
+        report: runMcpUninstallPlan(profile, serverArgv, runner)
+    };
+}
+/**
+ * The production runner and its deadline live in `mcp-install-runner.ts` — split
+ * out only to keep this engine within the file-size cap. They are re-exported, so
+ * the boundary is invisible: every caller still imports them from here.
+ */
+export { MCP_INSTALL_TIMEOUT_MS, spawnMcpInstallCommand, spawnMcpInstallRunner } from './mcp-install-runner.js';

package/dist/services/distribution/plugin-manifest.d.ts

@@ -0,0 +1,97 @@
+import { type SkillMetadata } from '../skills/skill-registry.js';
+/** Where the generator writes, relative to the package root. */
+export declare const PLUGIN_MANIFEST_RELATIVE_PATH = ".claude-plugin/marketplace.json";
+/**
+ * The server key peaks registers itself under. It is OUR key, not a harness's —
+ * the adapter profiles that name it (`IdeMcpInstallProfile.serverName`) and the
+ * tool-name templates that match it (`IdeAdapter.mcp`) must agree with this one,
+ * which is why it is declared once.
+ */
+export declare const MCP_SERVER_KEY = "peaks";
+/** The subset of `package.json` this render reads. */
+interface PackageManifest {
+    readonly name: string;
+    readonly version: string;
+    readonly description?: string;
+    readonly author?: string;
+    readonly homepage?: string;
+    readonly repository?: {
+        readonly url?: string;
+    } | string;
+    readonly license?: string;
+    readonly keywords?: readonly string[];
+}
+/** One plugin entry's skill list item — the shape `peaks skill:visibility` reads. */
+interface PluginSkillEntry {
+    readonly name: string;
+    readonly path: string;
+    readonly description: string;
+    readonly userInvocable?: boolean;
+}
+interface GeneratedPluginManifest {
+    readonly metadata: {
+        readonly pluginRoot: string;
+        readonly version: string;
+    };
+    readonly plugins: readonly {
+        readonly name: string;
+        readonly description: string;
+        readonly version: string;
+        readonly author: {
+            readonly name: string;
+        };
+        readonly homepage: string;
+        readonly repository: string;
+        readonly license: string;
+        readonly keywords: readonly string[];
+        /**
+         * Declared, and deliberately not brought live: the plugin channel is not
+         * published by this slice (PRD non-goal), so this is the statement of what
+         * the channel WOULD run, kept true by generation rather than by memory.
+         *
+         * The command is the CLI's own name and subcommand, with no path in it: a
+         * manifest is built on one machine and read on another, so an absolute
+         * interpreter path resolved here would be the build host's. The RUNTIME
+         * registration is a different artefact with a different consumer and does
+         * resolve the pair — see `mcp-install.ts::resolveMcpServerArgv`.
+         */
+        readonly mcpServers: Record<string, {
+            readonly command: string;
+            readonly args: readonly string[];
+        }>;
+        readonly skills: readonly PluginSkillEntry[];
+    }[];
+}
+/** `package.json`, parsed. A missing version is a refusal, not a default. */
+export declare function loadPackageManifest(root?: string): PackageManifest;
+/**
+ * The skill entries, in the registry's order.
+ *
+ * `visibility: internal` is the skill's own declaration that it is an internal
+ * role rather than a front door, and it is the ONE source for `userInvocable` —
+ * the field is emitted only when it is `false`, which is the contract
+ * `skill:visibility` reads ("internal: userInvocable false; public: omitted").
+ */
+export declare function skillEntriesOf(skills: readonly SkillMetadata[]): readonly PluginSkillEntry[];
+/**
+ * Render the manifest. `skills` is passed in rather than loaded here so the one
+ * caller that must fail loudly on an unreadable SKILL.md can do so once.
+ */
+export declare function generatePluginManifest(manifest: PackageManifest, skills: readonly SkillMetadata[]): GeneratedPluginManifest;
+/** Pretty JSON, newline-terminated — the same serialization contract as the whitelist. */
+export declare function serializePluginManifest(manifest: GeneratedPluginManifest): string;
+/** Absolute path of the committed artifact for a package root. */
+export declare function pluginManifestPath(root?: string): string;
+/**
+ * The whole render for a package root: read the two sources, refuse a skill tree
+ * that did not fully parse, and serialize.
+ *
+ * The `failures` refusal is the load-bearing part. `loadSkillRegistry` reports an
+ * unreadable `SKILL.md` in a `failures` array instead of throwing, so a render
+ * that ignored it would DROP a skill from the manifest and still be
+ * byte-stable — a green CI over a manifest that had silently lost entries. A
+ * drift assertion cannot be stronger than its input, so the input is required to
+ * be complete.
+ */
+export declare function renderPluginManifest(root?: string): Promise<string>;
+export {};

package/dist/services/distribution/plugin-manifest.js

@@ -0,0 +1,126 @@
+// src/services/distribution/plugin-manifest.ts
+//
+// The plugin/distribution manifest as a GENERATED artefact (spec §4.1). One
+// source, two renders: the whitelist artifact is what the read-only claim is
+// made of, and this file is what the distribution channel is told.
+//
+// WHY IT IS GENERATED. The hand-authored `.claude-plugin/marketplace.json` had
+// rotted in the only two fields anybody could check and nobody did: it declared
+// version `2.0.3` while the package was `4.1.2`, and 12 skills while the tree
+// held 22. Root cause is not carelessness — it is that the current distribution
+// channel is `npm i -g`, so nothing ever read the plugin manifest and no failure
+// could be observed from it. A file whose author is a human and whose reader is
+// nobody will drift; the fix is to remove the human from the loop, not to be
+// more careful.
+//
+// CHANGE THE SOURCE, NOT THIS FILE. Everything below is derived, and
+// `tests/unit/services/distribution/plugin-manifest.test.ts` fails the moment
+// the committed artefact differs from a fresh render. A hand edit is therefore
+// not merely overwritten, it is RED. To change the manifest, change
+// `package.json` (a plugin-level field) or the skill's own `SKILL.md`
+// (a skill entry) and re-run `pnpm plugin:manifest`.
+//
+// DETERMINISM. No timestamp, no `Date`, no unordered iteration: skills come back
+// from `loadSkillRegistry`, which sorts by name, and every plugin-level field is
+// copied from `package.json` in a fixed order. Two consecutive runs are
+// byte-identical, which is what makes the CI equality assertion mean something.
+import { readFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { repoRoot } from 'peaks-loop-shared/paths';
+import { loadSkillRegistry } from '../skills/skill-registry.js';
+/** Where the generator writes, relative to the package root. */
+export const PLUGIN_MANIFEST_RELATIVE_PATH = '.claude-plugin/marketplace.json';
+/**
+ * The server key peaks registers itself under. It is OUR key, not a harness's —
+ * the adapter profiles that name it (`IdeMcpInstallProfile.serverName`) and the
+ * tool-name templates that match it (`IdeAdapter.mcp`) must agree with this one,
+ * which is why it is declared once.
+ */
+export const MCP_SERVER_KEY = 'peaks';
+/** `package.json`, parsed. A missing version is a refusal, not a default. */
+export function loadPackageManifest(root = repoRoot) {
+    const parsed = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+    if (typeof parsed.version !== 'string' || parsed.version.length === 0) {
+        throw new Error('package.json version must be a non-empty string');
+    }
+    return parsed;
+}
+/** A repository URL as a manifest reads it: npm's `.git` suffix is not part of the link. */
+function repositoryUrl(manifest) {
+    const raw = typeof manifest.repository === 'string' ? manifest.repository : manifest.repository?.url;
+    return (raw ?? '').replace(/\.git$/, '');
+}
+/** POSIX-separated, so the artifact is byte-identical whichever OS generated it. */
+function posix(value) {
+    return value.split('\\').join('/');
+}
+/**
+ * The skill entries, in the registry's order.
+ *
+ * `visibility: internal` is the skill's own declaration that it is an internal
+ * role rather than a front door, and it is the ONE source for `userInvocable` —
+ * the field is emitted only when it is `false`, which is the contract
+ * `skill:visibility` reads ("internal: userInvocable false; public: omitted").
+ */
+export function skillEntriesOf(skills) {
+    return skills
+        .filter((skill) => skill.name.startsWith('peaks-'))
+        .map((skill) => ({
+        name: skill.name,
+        path: `./${posix(relative(repoRoot, dirname(skill.skillPath)))}`,
+        description: skill.description,
+        ...(skill.visibility === 'internal' ? { userInvocable: false } : {})
+    }));
+}
+/**
+ * Render the manifest. `skills` is passed in rather than loaded here so the one
+ * caller that must fail loudly on an unreadable SKILL.md can do so once.
+ */
+export function generatePluginManifest(manifest, skills) {
+    return {
+        metadata: { pluginRoot: '.', version: manifest.version },
+        plugins: [
+            {
+                name: manifest.name,
+                description: manifest.description ?? '',
+                version: manifest.version,
+                author: { name: manifest.author ?? '' },
+                homepage: manifest.homepage ?? '',
+                repository: repositoryUrl(manifest),
+                license: manifest.license ?? '',
+                keywords: [...(manifest.keywords ?? [])],
+                mcpServers: {
+                    [MCP_SERVER_KEY]: { command: MCP_SERVER_KEY, args: ['mcp', 'serve'] }
+                },
+                skills: skillEntriesOf(skills)
+            }
+        ]
+    };
+}
+/** Pretty JSON, newline-terminated — the same serialization contract as the whitelist. */
+export function serializePluginManifest(manifest) {
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+/** Absolute path of the committed artifact for a package root. */
+export function pluginManifestPath(root = repoRoot) {
+    return join(root, PLUGIN_MANIFEST_RELATIVE_PATH);
+}
+/**
+ * The whole render for a package root: read the two sources, refuse a skill tree
+ * that did not fully parse, and serialize.
+ *
+ * The `failures` refusal is the load-bearing part. `loadSkillRegistry` reports an
+ * unreadable `SKILL.md` in a `failures` array instead of throwing, so a render
+ * that ignored it would DROP a skill from the manifest and still be
+ * byte-stable — a green CI over a manifest that had silently lost entries. A
+ * drift assertion cannot be stronger than its input, so the input is required to
+ * be complete.
+ */
+export async function renderPluginManifest(root = repoRoot) {
+    const skills = await loadSkillRegistry(join(root, 'skills'));
+    if (skills.failures.length > 0) {
+        const named = skills.failures.map((failure) => failure.skillPath).join(', ');
+        throw new Error(`Refusing to render the plugin manifest: unreadable skill(s): ${named}`);
+    }
+    return serializePluginManifest(generatePluginManifest(loadPackageManifest(root), skills.skills));
+}

package/dist/services/hooks/mcp-surface-gate.d.ts

@@ -0,0 +1,19 @@
+import type { ProgramIO } from '../../cli/cli-helpers.js';
+import type { IdeAdapter } from '../ide/ide-types.js';
+/** The tool names the proven surface declares. */
+export type McpSurfaceLookup = () => readonly string[];
+/** The production lookup. Injectable so a test can make it throw and watch the refusal. */
+export declare function lookupAllowedMcpTools(): readonly string[];
+/** The adapter whose harness sent this payload. */
+export declare function detectAdapter(parsedStdin: unknown): IdeAdapter;
+/** The deny emission, in the shape the host already treats as a hard block. */
+export declare function emitMcpDeny(io: ProgramIO, code: string, reason: string): void;
+/**
+ * Run the MCP branch over one parsed hook payload.
+ *
+ * @returns `true` when the call was BLOCKED (a deny has already been emitted).
+ *          `false` means "this is not an MCP call for this surface" — every
+ *          other tool name, and every harness declaring no MCP naming, lands
+ *          there and keeps the allow/deny result it had before.
+ */
+export declare function handleMcpSurfaceGate(io: ProgramIO, parsedStdin: unknown, lookup?: McpSurfaceLookup, adapterOf?: (payload: unknown) => IdeAdapter): boolean;

package/dist/services/hooks/mcp-surface-gate.js

@@ -0,0 +1,87 @@
+// src/services/hooks/mcp-surface-gate.ts
+//
+// L3 for the read-only MCP surface: the pre-tool branch that covers MCP tool
+// calls (spec §6.1, §6.2, §6.3).
+//
+// WHY IT IS ITS OWN MODULE. It shares an entry point with the Bash and worktree
+// branches but nothing else: different surface (an MCP tool name, not a command
+// text), different failure direction (fail-CLOSED, where the others fail open),
+// and a different thing it polices. Keeping it beside them made the interceptor
+// file carry three unrelated decisions; it lives here so the file that owns the
+// hook's control flow stays the file that owns the hook's control flow.
+//
+// WHAT IT POLICES, AND WHAT IT DOES NOT. It does not second-guess what a tool
+// would return. It answers one question: "is this MCP tool call one the proven
+// surface declares?" It exists for DRIFT — a stale server process, a hand-edited
+// harness config pointing somewhere else, a tool added to a config that was
+// never proved read-only. The read-only proof itself is L2's job; this is the
+// belt over it.
+//
+// FAIL-CLOSED, AND THE ASYMMETRY WITH THE BASH BRANCH IS DELIBERATE. The Bash
+// branch guards command TEXT, where a false block interrupts real work, so it
+// fails open. This branch guards CONFIG CONSISTENCY, where a false block costs
+// one call that should have been consistent while a false allow costs a call
+// that bypassed the chain. The costs are not the same size, so they do not share
+// a direction — and they do not share a `catch` either.
+//
+// IT READS THE SURFACE AS DATA, NEVER AS CODE. The allowed tool names come from
+// the generated whitelist artifact through its loader, so this branch keeps
+// working when `src/services/mcp/` is deleted (spec §1) — which is also what
+// `tests/unit/standards/no-mcp-source-import.test.ts` enforces mechanically.
+import { getErrorMessage } from 'peaks-loop-shared/result';
+import { emitBlock } from './output.js';
+import { getAdapter } from '../ide/ide-registry.js';
+import { detectIdeFromContext, parseClaudeShapeStdin } from '../ide/hook-translator.js';
+import { matchMcpToolName } from '../ide/mcp-tool-matcher.js';
+import { loadReadOnlyWhitelist, toolIdsOf } from '../readonly-surface/readonly-whitelist.js';
+/** The production lookup. Injectable so a test can make it throw and watch the refusal. */
+export function lookupAllowedMcpTools() {
+    return toolIdsOf(loadReadOnlyWhitelist());
+}
+/** The adapter whose harness sent this payload. */
+export function detectAdapter(parsedStdin) {
+    const ide = detectIdeFromContext({ env: process.env, cwd: process.cwd(), parsedStdin });
+    return getAdapter(ide);
+}
+/** The deny emission, in the shape the host already treats as a hard block. */
+export function emitMcpDeny(io, code, reason) {
+    emitBlock(io, `[mcp-surface-gate:${code}] ${reason}. Blocked by fail-closed policy — ` +
+        'run the read-only command through the CLI instead, or add its argv to ' +
+        'contracts/readonly-surface.json and regenerate the whitelist.');
+}
+/**
+ * Run the MCP branch over one parsed hook payload.
+ *
+ * @returns `true` when the call was BLOCKED (a deny has already been emitted).
+ *          `false` means "this is not an MCP call for this surface" — every
+ *          other tool name, and every harness declaring no MCP naming, lands
+ *          there and keeps the allow/deny result it had before.
+ */
+export function handleMcpSurfaceGate(io, parsedStdin, lookup = lookupAllowedMcpTools, adapterOf = detectAdapter) {
+    let adapter;
+    try {
+        adapter = adapterOf(parsedStdin);
+    }
+    catch (error) {
+        // Detection itself failed. Falling through would let the call pass
+        // unchecked, which is the one outcome this branch exists to prevent.
+        emitMcpDeny(io, 'IDE_DETECTION_FAILED', `the harness could not be identified (${getErrorMessage(error)})`);
+        return true;
+    }
+    const { toolName } = parseClaudeShapeStdin(parsedStdin);
+    const match = toolName === undefined ? undefined : matchMcpToolName(adapter, toolName);
+    if (match === undefined)
+        return false;
+    let allowed;
+    try {
+        allowed = lookup();
+    }
+    catch (error) {
+        emitMcpDeny(io, 'SURFACE_UNREADABLE', `the read-only surface could not be read (${getErrorMessage(error)})`);
+        return true;
+    }
+    if (allowed.includes(match.toolId))
+        return false;
+    emitMcpDeny(io, 'NOT_IN_READONLY_SURFACE', `"${toolName}" is not one of the read-only tools this project declares (${allowed.join(', ') || 'none'})`);
+    return true;
+}

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

@@ -1,39 +1,8 @@
 import type { IdeAdapter } from '../ide-types.js';
-/**
- * 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;
-/**
- * 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;
+import { resolveClaudeTranscriptPath } from './claude-code-local-state.js';
+import { modelContextWindowTokens, resolveClaudeModelFromEnv } from './claude-code-model-window.js';
+export { resolveClaudeTranscriptPath };
+export { modelContextWindowTokens, resolveClaudeModelFromEnv };
 /**
  * the context-window size in tokens. Third-party / proxied models whose id
  * carries no `[1M]` suffix (and is absent from the hardcoded allowlist) are