peaks-loop 4.0.0-beta.5 → 4.0.0-beta.7

package/dist/src/cli/commands/runtime-commands.js

@@ -0,0 +1,150 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { fail, ok } from '../../shared/result.js';
+import { getErrorMessage } from '../../shared/result.js';
+import { detectRuntime } from '../../services/runtime/runtime-detector.js';
+import { RuntimeService } from '../../services/runtime/runtime-service.js';
+import { AdapterRegistry } from '../../services/adapter/adapter-registry.js';
+function resolveProjectRoot(explicit) {
+    if (explicit !== undefined && explicit.length > 0)
+        return explicit;
+    return process.cwd();
+}
+export function registerRuntimeCommands(program, io) {
+    const runtime = program
+        .command('runtime')
+        .description('Vendor runtime detection + compact via adapter (--via <vendor-id>)');
+    // -----------------------------------------------------------------
+    // 1. peaks runtime detect [--json]
+    // -----------------------------------------------------------------
+    addJsonOption(runtime
+        .command('detect')
+        .description('Print the active AI runtime vendor (claude-code / codex / copilot / unknown)')).action((options) => {
+        try {
+            const result = detectRuntime();
+            printResult(io, ok('runtime.detect', result, [], [
+                result.vendor === 'unknown'
+                    ? 'No vendor sentinel detected. Use `peaks adapter register --id <vendor> --binary <cmd>` to wire a custom one.'
+                    : `Run \`peaks runtime compact --via ${result.vendor}\` to invoke its compact verb.`
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('runtime.detect', 'RUNTIME_DETECT_FAILED', getErrorMessage(error), {}, ['Retry with a clean env']), options.json);
+            process.exitCode = 1;
+        }
+    });
+    // -----------------------------------------------------------------
+    // 2. peaks runtime list [--json]
+    // -----------------------------------------------------------------
+    addJsonOption(runtime
+        .command('list')
+        .description('List the built-in vendor adapters registered by RuntimeService')).action((options) => {
+        try {
+            const svc = new RuntimeService();
+            const adapters = svc.listBuiltInAdapters().map((a) => ({ id: a.id, displayName: a.displayName }));
+            printResult(io, ok('runtime.list', { builtIn: adapters }, [], [
+                `Run \`peaks adapter register --id <vendor> --binary <cmd>\` to add a custom adapter (persists to .peaks/runtime/adapters.json).`
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('runtime.list', 'RUNTIME_LIST_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        }
+    });
+    // -----------------------------------------------------------------
+    // 3. peaks runtime compact [--via <id>] [--force] [--json] [--project <root>]
+    // -----------------------------------------------------------------
+    addJsonOption(runtime
+        .command('compact')
+        .description('Compact the active vendor via the chosen adapter (--via <vendor-id>); vendor verbs live ONLY in adapter files')
+        .option('--via <id>', 'vendor adapter id (built-in or user-registered)')
+        .option('--force', 'ask the vendor to compact unconditionally')
+        .option('--project <path>', 'project root (defaults to cwd)')).action(async (options) => {
+        try {
+            const projectRoot = resolveProjectRoot(options.project);
+            const requested = options.via;
+            if (requested === undefined || requested.length === 0) {
+                // No explicit --via: try to detect first, then fall back.
+                const detected = detectRuntime();
+                if (detected.vendor === 'unknown') {
+                    printResult(io, fail('runtime.compact', 'NO_VENDOR_SPECIFIED', 'No --via <id> provided and no vendor detected.', { detected }, [
+                        'Pass --via <vendor-id>, or run `peaks runtime detect` to see what was detected.'
+                    ]), options.json);
+                    process.exitCode = 1;
+                    return;
+                }
+                await runCompact(projectRoot, detected.vendor, options.force === true, io, options.json);
+                return;
+            }
+            await runCompact(projectRoot, requested, options.force === true, io, options.json);
+        }
+        catch (error) {
+            printResult(io, fail('runtime.compact', 'RUNTIME_COMPACT_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        }
+    });
+}
+async function runCompact(projectRoot, viaId, force, io, asJson) {
+    // Layer 1: user-registered adapter (via AdapterRegistry).
+    const registryFile = AdapterRegistry.defaultFile(projectRoot);
+    const registry = new AdapterRegistry();
+    if (existsSync(registryFile)) {
+        try {
+            registry.load(registryFile);
+        }
+        catch {
+            // Treat corrupt registry as empty — vendor-neutrality: a corrupt
+            // .peaks/runtime/adapters.json must NOT block peaks runtime.
+            // We still try the built-in path below.
+        }
+    }
+    const registered = registry.resolve(viaId);
+    if (registered !== undefined) {
+        const r = await registered.compact({ force });
+        const warnings = [];
+        if (r.exitCode === 127) {
+            warnings.push(`binary for adapter "${viaId}" not found on PATH; compact is a no-op`);
+        }
+        printResult(io, ok('runtime.compact', { via: viaId, source: 'registry', compact: r }, warnings, [
+            r.exitCode === 0
+                ? 'Compact completed.'
+                : `Compact exited with code ${r.exitCode}. Check stderr above.`
+        ]), asJson);
+        if (r.exitCode !== 0)
+            process.exitCode = 1;
+        return;
+    }
+    // Layer 2: built-in adapter (via RuntimeService).
+    const svc = new RuntimeService();
+    const r = await svc.compactVia(viaId, force);
+    const warnings = [];
+    if (r.warning !== undefined)
+        warnings.push(r.warning);
+    if (r.exitCode === 127) {
+        warnings.push(`built-in adapter "${viaId}" binary not found on PATH; compact is a no-op`);
+    }
+    printResult(io, ok('runtime.compact', { via: viaId, source: 'built-in', compact: { exitCode: r.exitCode, stdout: r.stdout, stderr: r.stderr } }, warnings, [
+        r.exitCode === 0
+            ? 'Compact completed.'
+            : `Compact exited with code ${r.exitCode}. Check stderr above.`
+    ]), asJson);
+    if (r.exitCode !== 0)
+        process.exitCode = 1;
+}
+/** Internal helper exposed for tests + future programmatic callers:
+ *  resolve the registry file location, ensuring the parent dir
+ *  exists. Idempotent. */
+export function ensureRegistryDir(registryFile) {
+    mkdirSync(dirname(registryFile), { recursive: true });
+}
+/** Internal helper for tests: locate the registry file under the
+ *  given project root. Thin wrapper so tests can stub the resolution. */
+export function registryFileFor(projectRoot) {
+    const f = AdapterRegistry.defaultFile(projectRoot);
+    ensureRegistryDir(f);
+    return f;
+}
+/** Re-export the path join helper for completeness; not strictly
+ *  needed by callers but keeps the module self-contained. */
+export { join };

package/dist/src/cli/program.js

@@ -73,6 +73,10 @@ import { registerMutCommands } from './commands/mut-commands.js';
 import { registerFixtureCommands } from './commands/fixture-commands.js';
 import { registerReviewerCommands } from './commands/reviewer-commands.js';
 import { registerObservabilityCommands } from './commands/observability-commands.js';
+// Slice 2026-07-09 add-zcode-adapter (Slice C): `peaks ide model --current` —
+// read-only runtime model probe surfaced via the registered IDE adapter
+// chain. See src/services/ide/current-model-detector.ts.
+import { registerIdeCommands } from './commands/ide-commands.js';
 // Slice 2026-07-01-strategic-compact-cli: peaks compact
 // (suggest | recommend | survival | dry-run | force) — strategic-compact
 // CLI primitives. See src/services/compact/ and
@@ -85,6 +89,15 @@ import { registerJobCommands } from './commands/job-commands.js';
 // 15b / 15c / 15d will extend sediment-commands.ts with the remaining 14 verbs.
 import { registerSedimentCommands } from './commands/sediment-commands.js';
 import { registerAdapterCommands } from './commands/adapter-commands.js';
+// Slice RD-2 S2-a: `peaks runtime *` (detect / list / compact) +
+// `peaks adapter *` (list / register). See src/services/runtime/ and
+// src/services/adapter/adapter-registry.ts. Coexists with the older
+// `peaks skill adapter` surface (slice 2026-07-04-cli-15a) which is
+// for skill materialization, not vendor-adapter registry.
+import { registerRuntimeCommands } from './commands/runtime-commands.js';
+import { registerAdapterS2ACommands } from './commands/adapter-commands-s2a.js';
+// Slice RD-2 S2-b: `peaks polyrepo *` (init / status / dispatch).
+import { registerPolyrepoCommands } from './commands/polyrepo-commands.js';
 import { registerSkillVisibilityCommand } from './commands/skill-visibility.js';
 import { applyRetention } from '../services/log/retention.js';
 import { writeLogEntry, maybeWriteStderr } from '../services/log/logger.js';
@@ -361,6 +374,9 @@ Run peaks (no arguments) for a quickstart. You likely want one of:
     // Slice B of v2.11.1: `peaks observability status|slices|fanout|repair-cycles`
     // (read-only queries over the JSONL metrics emitted from the
     // peaks request transition hook in Slice A).
+    // Slice 2026-07-09 add-zcode-adapter (C.6): `peaks ide model --current`
+    // (read-only runtime model probe via the registered IDE adapter chain).
+    registerIdeCommands(program, io);
     registerObservabilityCommands(program, io);
     // Slice 2026-07-01-strategic-compact-cli: `peaks compact
     // suggest|recommend|survival|dry-run|force` — strategic-compact CLI
@@ -375,6 +391,13 @@ Run peaks (no arguments) for a quickstart. You likely want one of:
     registerSedimentCommands(program, io);
     // Slice 2026-07-04-cli-15a: `peaks skill adapter <verb>` — adapter list / set-active.
     registerAdapterCommands(program, io);
+    // Slice RD-2 S2-a: `peaks runtime *` (detect / list / compact) +
+    // `peaks adapter *` (list / register). Vendor verbs live ONLY in
+    // src/services/runtime/vendors/<vendor>.ts (AC-1 enforcement).
+    registerRuntimeCommands(program, io);
+    registerAdapterS2ACommands(program, io);
+    // Slice RD-2 S2-b: `peaks polyrepo *` (init / status / dispatch).
+    registerPolyrepoCommands(program, io);
     // Slice 2026-07-05-peaks-code-to-peaks-code (Task 1): `peaks skill:visibility --list --json`
     // — read .claude-plugin/marketplace.json and report each skill's
     // visibility (public vs internal). Used to surface which skills are

package/dist/src/services/adapter/adapter-registry.d.ts

@@ -0,0 +1,48 @@
+import type { VendorAdapter } from '../runtime/vendor-adapter.js';
+/** Serializable adapter record (the on-disk shape). */
+export interface AdapterRecord {
+    readonly id: string;
+    readonly displayName: string;
+    /** Binary name or absolute path to invoke for compact. */
+    readonly binary: string;
+    /** Extra args appended after the compact verb. */
+    readonly args?: string[];
+}
+export interface PersistedAdapterRegistry {
+    readonly version: 1;
+    readonly adapters: AdapterRecord[];
+}
+export interface RegisterOptions {
+    /** Overwrite an existing record with the same id. Defaults to false
+     *  to prevent silent overwrites of user customizations. */
+    readonly force?: boolean;
+}
+/** In-memory + on-disk adapter registry. The registry holds USER
+ *  adapters (those registered via `peaks adapter register`); built-in
+ *  adapters live in RuntimeService and are NOT registered here. */
+export declare class AdapterRegistry {
+    private readonly records;
+    /** Register a new adapter. When an adapter with the same id already
+     *  exists, returns the existing record unless `force: true`. */
+    register(record: AdapterRecord, opts?: RegisterOptions): {
+        record: AdapterRecord;
+        created: boolean;
+    };
+    /** Resolve a registered adapter by id, materializing it as a
+     *  runnable VendorAdapter. Returns undefined when not registered. */
+    resolve(id: string): VendorAdapter | undefined;
+    /** List registered adapter records (serializable form). */
+    list(): AdapterRecord[];
+    /** Remove a registered adapter. Returns true if it existed. */
+    unregister(id: string): boolean;
+    /** Persist the current registry to disk as JSON. Writes atomically
+     *  (write to `<file>.tmp` then rename) so a crash mid-write does
+     *  not corrupt the registry file. */
+    persist(file: string): void;
+    /** Load a registry from disk. Missing file = empty registry.
+     *  Corrupt file = throw (caller decides whether to bail or
+     *  fall back to empty). */
+    load(file: string): void;
+    /** Default location for the on-disk registry file. */
+    static defaultFile(projectRoot: string): string;
+}

package/dist/src/services/adapter/adapter-registry.js

@@ -0,0 +1,186 @@
+/**
+ * Adapter registry — slice S2-a of RD-2.
+ *
+ * Persists user-registered vendor adapters to
+ * `.peaks/runtime/adapters.json` and resolves them by id. The
+ * registry is layered on top of `RuntimeService` (built-in adapters
+ * live there); a caller asks "do you have an adapter for id=X?" by
+ * first asking the registry, then falling back to built-ins. The
+ * runtime service itself does NOT consult the registry (kept
+ * decoupled so the registry can be swapped for a different
+ * persistence backend without touching runtime-service).
+ *
+ * Design notes:
+ *  - Persistence uses atomic write (write to tmp + rename) so a
+ *    crash mid-write does not corrupt the registry file.
+ *  - `register()` defaults to fail-if-exists to prevent silent
+ *    overwrites of user customizations; pass `force: true` to
+ *    overwrite (matches the CLI surface from PRD §4.4).
+ *  - VendorAdapter implementations are NOT directly serializable
+ *    (they hold closures over `home`, child_process handles, etc.).
+ *    Instead the registry persists a minimal JSON shape:
+ *    `{id, displayName, binary, args}` and reconstructs a
+ *    ProcessVendorAdapter wrapper on load. This keeps the JSON
+ *    file human-readable + diff-friendly.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { spawn } from 'node:child_process';
+/** A registry-built adapter: wraps a persisted record + invokes the
+ *  recorded binary with the recorded args. Used so `peaks runtime
+ *  compact --via <id>` works against user-registered adapters without
+ *  peaks-loop needing to ship a vendor-specific implementation. */
+class ProcessVendorAdapter {
+    id;
+    displayName;
+    binary;
+    extraArgs;
+    constructor(record) {
+        this.id = record.id;
+        this.displayName = record.displayName;
+        this.binary = record.binary;
+        this.extraArgs = record.args ?? [];
+    }
+    async detect() {
+        // Heuristic: process-spawned adapters are always "detectable" once
+        // registered; their actual availability is checked at compact()
+        // time. This avoids probing every registered binary on every
+        // detect() call.
+        return true;
+    }
+    async compact(args = {}) {
+        const argv = [...this.extraArgs];
+        if (args.force === true)
+            argv.push('--force');
+        return new Promise((resolveRun) => {
+            const proc = spawn(this.binary, argv, { stdio: ['ignore', 'pipe', 'pipe'] });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });
+            proc.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); });
+            proc.on('error', (err) => {
+                resolveRun({ exitCode: 127, stdout, stderr: stderr + (stderr.length > 0 ? '\n' : '') + err.message });
+            });
+            proc.on('close', (code) => {
+                resolveRun({ exitCode: code ?? 0, stdout, stderr });
+            });
+        });
+    }
+}
+/** Validate an adapter record. Used by register() to fail fast on
+ *  malformed CLI input. Returns an error message or undefined. */
+function validateRecord(record) {
+    if (record.id.length === 0)
+        return 'adapter id must be non-empty';
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(record.id)) {
+        return `adapter id "${record.id}" must match /^[a-z0-9][a-z0-9._-]*$/`;
+    }
+    if (record.displayName.length === 0)
+        return 'adapter displayName must be non-empty';
+    if (record.binary.length === 0)
+        return 'adapter binary must be non-empty';
+    if (record.binary.includes('/') || record.binary.includes('\\')) {
+        return `adapter binary "${record.binary}" must be a name, not a path`;
+    }
+    return undefined;
+}
+/** In-memory + on-disk adapter registry. The registry holds USER
+ *  adapters (those registered via `peaks adapter register`); built-in
+ *  adapters live in RuntimeService and are NOT registered here. */
+export class AdapterRegistry {
+    records = new Map();
+    /** Register a new adapter. When an adapter with the same id already
+     *  exists, returns the existing record unless `force: true`. */
+    register(record, opts = {}) {
+        const validationError = validateRecord(record);
+        if (validationError !== undefined) {
+            throw new Error(`invalid adapter record: ${validationError}`);
+        }
+        const existed = this.records.has(record.id);
+        if (existed && opts.force !== true) {
+            return { record: this.records.get(record.id), created: false };
+        }
+        this.records.set(record.id, record);
+        return { record, created: !existed };
+    }
+    /** Resolve a registered adapter by id, materializing it as a
+     *  runnable VendorAdapter. Returns undefined when not registered. */
+    resolve(id) {
+        const rec = this.records.get(id);
+        if (rec === undefined)
+            return undefined;
+        return new ProcessVendorAdapter(rec);
+    }
+    /** List registered adapter records (serializable form). */
+    list() {
+        return Array.from(this.records.values());
+    }
+    /** Remove a registered adapter. Returns true if it existed. */
+    unregister(id) {
+        return this.records.delete(id);
+    }
+    /** Persist the current registry to disk as JSON. Writes atomically
+     *  (write to `<file>.tmp` then rename) so a crash mid-write does
+     *  not corrupt the registry file. */
+    persist(file) {
+        const payload = {
+            version: 1,
+            adapters: this.list()
+        };
+        mkdirSync(dirname(file), { recursive: true });
+        const tmp = `${file}.tmp`;
+        writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
+        renameSync(tmp, file);
+    }
+    /** Load a registry from disk. Missing file = empty registry.
+     *  Corrupt file = throw (caller decides whether to bail or
+     *  fall back to empty). */
+    load(file) {
+        if (!existsSync(file))
+            return;
+        const raw = readFileSync(file, 'utf8');
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (err) {
+            throw new Error(`adapter registry at ${file} is not valid JSON: ${err.message}`);
+        }
+        if (!isPersistedRegistry(parsed)) {
+            throw new Error(`adapter registry at ${file} has unexpected shape (expected version=1 + adapters[])`);
+        }
+        this.records.clear();
+        for (const rec of parsed.adapters) {
+            const validationError = validateRecord(rec);
+            if (validationError !== undefined) {
+                // Skip + continue — partial recovery is better than throwing on
+                // a single bad row. The CLI surfaces the count of skipped
+                // records via the load() return value below.
+                continue;
+            }
+            this.records.set(rec.id, rec);
+        }
+    }
+    /** Default location for the on-disk registry file. */
+    static defaultFile(projectRoot) {
+        return join(projectRoot, '.peaks', 'runtime', 'adapters.json');
+    }
+}
+function isPersistedRegistry(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const v = value;
+    if (v.version !== 1)
+        return false;
+    if (!Array.isArray(v.adapters))
+        return false;
+    return v.adapters.every((a) => {
+        if (typeof a !== 'object' || a === null)
+            return false;
+        const r = a;
+        return typeof r.id === 'string'
+            && typeof r.displayName === 'string'
+            && typeof r.binary === 'string'
+            && (r.args === undefined || (Array.isArray(r.args) && r.args.every((x) => typeof x === 'string')));
+    });
+}

package/dist/src/services/config/model-routing.d.ts

@@ -1,4 +1,57 @@
 import { type ModelProviderConfig, type PeaksConfig } from './config-types.js';
-export declare const STRONGEST_MODEL_ID: "claude-opus-4-7";
+/**
+ * Slice 2026-07-09 add-zcode-adapter (A.3): replaces the legacy
+ * `STRONGEST_MODEL_ID = 'claude-opus-4-7'` constant (removed) with a dynamic
+ * resolver. The strongest planner/reviewer model is now derived
+ * from the active config instead of being hardcoded to a specific
+ * vendor. This unlocks running peaks-loop under non-Claude IDEs
+ * (z-code, Cursor, Trae, ...).
+ *
+ * Resolution order:
+ *   1. Explicit `config.model` (user override via `peaks config set model ...`)
+ *   2. Stable fallback for back-compat (env-var override; defaults to
+ *      `claude-opus-4-7` so legacy fixtures keep compiling per
+ *      SC §3.4 strategy A)
+ *
+ * Vendor-neutrality note: the default `'claude-opus-4-7'` is a
+ * *back-compat fallback*, NOT a hardcoded "the strongest model is
+ * always Claude" assumption. Production callers should set
+ * `config.model` (or override the env var) to declare their strongest
+ * model. Adapter-level runtime probing is wired in Slice C
+ * (`getStrongestModelIdAsync` below).
+ */
+export declare function getStrongestModelId(config?: {
+    model?: unknown;
+}): string;
+/**
+ * Slice 2026-07-09 add-zcode-adapter (Slice C, C.4): async variant
+ * of `getStrongestModelId`. Same precedence for layers 1 + 2, but
+ * layer 2.5 is the IDE's runtime probe (`detectCurrentIdeModel`)
+ * which is consulted BEFORE the env-var back-compat fallback.
+ *
+ * Why this exists:
+ *   - `rd-service.buildPlan` (and other sync callers) still call the
+ *     sync `getStrongestModelId` — we do NOT change those signatures.
+ *   - New async callers (the future Slice C-extension of
+ *     `workflow-router-service`, plus any LLM-inside-z-code path)
+ *     resolve the strongest model from the IDE's actual state,
+ *     without forcing the user to set `config.model`.
+ *
+ * Resolution order:
+ *   1. Explicit `config.model`.
+ *   2. `PEAKS_STRONGEST_MODEL_DEFAULT` env var override.
+ *   3. Runtime probe via `detectCurrentIdeModel()` (only when the
+ *      registered IDE adapter opts in via `detectCurrentModel?` —
+ *      only `zcode` does in Slice C; other IDEs skip this layer).
+ *   4. Hardcoded back-compat default `'claude-opus-4-7'`.
+ *
+ * Each layer is isolated so a failure in the probe does not break
+ * the resolver.
+ */
+export declare function getStrongestModelIdAsync(config?: {
+    model?: unknown;
+}, runtimeProbeDisabled?: boolean): Promise<string>;
 export declare function getConfiguredExecutionModelId(providers: ModelProviderConfig | undefined): string;
-export declare function getEconomyAwareExecutionModelId(config: Pick<PeaksConfig, 'economyMode' | 'providers'>): string;
+export declare function getEconomyAwareExecutionModelId(config: Pick<PeaksConfig, 'economyMode' | 'providers'> & {
+    model?: string;
+}): string;

package/dist/src/services/config/model-routing.js

@@ -1,4 +1,79 @@
-export const STRONGEST_MODEL_ID = 'claude-opus-4-7';
+import { detectCurrentIdeModel } from '../ide/current-model-detector.js';
+/**
+ * Slice 2026-07-09 add-zcode-adapter (A.3): replaces the legacy
+ * `STRONGEST_MODEL_ID = 'claude-opus-4-7'` constant (removed) with a dynamic
+ * resolver. The strongest planner/reviewer model is now derived
+ * from the active config instead of being hardcoded to a specific
+ * vendor. This unlocks running peaks-loop under non-Claude IDEs
+ * (z-code, Cursor, Trae, ...).
+ *
+ * Resolution order:
+ *   1. Explicit `config.model` (user override via `peaks config set model ...`)
+ *   2. Stable fallback for back-compat (env-var override; defaults to
+ *      `claude-opus-4-7` so legacy fixtures keep compiling per
+ *      SC §3.4 strategy A)
+ *
+ * Vendor-neutrality note: the default `'claude-opus-4-7'` is a
+ * *back-compat fallback*, NOT a hardcoded "the strongest model is
+ * always Claude" assumption. Production callers should set
+ * `config.model` (or override the env var) to declare their strongest
+ * model. Adapter-level runtime probing is wired in Slice C
+ * (`getStrongestModelIdAsync` below).
+ */
+export function getStrongestModelId(config) {
+    const raw = config?.model;
+    const fromConfig = typeof raw === 'string' ? raw.trim() : undefined;
+    if (fromConfig)
+        return fromConfig;
+    // Slice 2026-07-09: back-compat fallback for test fixtures that
+    // pre-date this slice (SC §3.4 strategy A env-var override).
+    return process.env.PEAKS_STRONGEST_MODEL_DEFAULT ?? 'claude-opus-4-7';
+}
+/**
+ * Slice 2026-07-09 add-zcode-adapter (Slice C, C.4): async variant
+ * of `getStrongestModelId`. Same precedence for layers 1 + 2, but
+ * layer 2.5 is the IDE's runtime probe (`detectCurrentIdeModel`)
+ * which is consulted BEFORE the env-var back-compat fallback.
+ *
+ * Why this exists:
+ *   - `rd-service.buildPlan` (and other sync callers) still call the
+ *     sync `getStrongestModelId` — we do NOT change those signatures.
+ *   - New async callers (the future Slice C-extension of
+ *     `workflow-router-service`, plus any LLM-inside-z-code path)
+ *     resolve the strongest model from the IDE's actual state,
+ *     without forcing the user to set `config.model`.
+ *
+ * Resolution order:
+ *   1. Explicit `config.model`.
+ *   2. `PEAKS_STRONGEST_MODEL_DEFAULT` env var override.
+ *   3. Runtime probe via `detectCurrentIdeModel()` (only when the
+ *      registered IDE adapter opts in via `detectCurrentModel?` —
+ *      only `zcode` does in Slice C; other IDEs skip this layer).
+ *   4. Hardcoded back-compat default `'claude-opus-4-7'`.
+ *
+ * Each layer is isolated so a failure in the probe does not break
+ * the resolver.
+ */
+export async function getStrongestModelIdAsync(config, runtimeProbeDisabled = false) {
+    const raw = config?.model;
+    const fromConfig = typeof raw === 'string' ? raw.trim() : undefined;
+    if (fromConfig)
+        return fromConfig;
+    const envDefault = process.env.PEAKS_STRONGEST_MODEL_DEFAULT;
+    if (envDefault && envDefault.length > 0)
+        return envDefault;
+    if (!runtimeProbeDisabled) {
+        try {
+            const probed = await detectCurrentIdeModel();
+            if (probed && probed.length > 0)
+                return probed;
+        }
+        catch {
+            // best-effort — fall through to back-compat default
+        }
+    }
+    return 'claude-opus-4-7';
+}
 export function getConfiguredExecutionModelId(providers) {
     const providerConfigs = Object.values(providers ?? {});
     const configuredModel = providerConfigs
@@ -12,6 +87,7 @@ export function getConfiguredExecutionModelId(providers) {
 export function getEconomyAwareExecutionModelId(config) {
     // Slice 2.0.1-bug1 round 3: economy is the project default. Treat undefined as enabled
     // (matches the pre-slice implicit default from DEFAULT_CONFIG.economyMode = true). Only an
-    // explicit `economyMode === false` switches execution to STRONGEST_MODEL_ID.
-    return config.economyMode !== false ? getConfiguredExecutionModelId(config.providers) : STRONGEST_MODEL_ID;
+    // explicit `economyMode === false` switches execution to the strongest planner/reviewer
+    // model (resolved dynamically per Slice 2026-07-09 add-zcode-adapter A.3).
+    return config.economyMode !== false ? getConfiguredExecutionModelId(config.providers) : getStrongestModelId(config);
 }

package/dist/src/services/ide/adapters/zcode-adapter.d.ts

@@ -0,0 +1,40 @@
+import type { IdeAdapter } from '../ide-types.js';
+/**
+ * Helper exported for tests + internal use: the default location of the
+ * z-code v2 config file on the host filesystem.
+ */
+export declare function defaultZcodeConfigPath(): string;
+/**
+ * Resolve the active model id from a parsed z-code config payload
+ * (the `~/.zcode/v2/config.json` root object). Pure / exported for
+ * unit tests so the file-IO seam and the resolution seam are
+ * independently verifiable.
+ *
+ * Resolution order (Slice C §"z-code config 解析路径"):
+ *   P1. env var `PEAKS_ZCODE_ACTIVE_PROVIDER_UUID` (test seam +
+ *       manual pin for the user).
+ *   P2. The provider whose top-level UUID key is NOT prefixed
+ *       `builtin:` — this matches the user-installed provider
+ *       pattern. Within that provider, prefer its `models` first
+ *       key (insertion order — z-code writes the active model
+ *       first in the picker).
+ *   P3. The first provider with `enabled: true`.
+ *   P4. The first provider in the object (insertion order) — last
+ *       resort. Returns undefined if there are zero providers.
+ *
+ * Returns `undefined` when nothing matches.
+ */
+export declare function resolveZcodeCurrentModel(config: unknown, envOverride?: string | undefined): string | undefined;
+/**
+ * The async adapter method that `detectCurrentIdeModel()` calls.
+ *
+ * Resolution order:
+ *   1. `PEAKS_ZCODE_ACTIVE_PROVIDER_UUID` env var override (test seam
+ *      + manual pin).
+ *   2. `PEAKS_ZCODE_CONFIG_PATH` env var override (test seam for a
+ *      fixture file). Falls back to `~/.zcode/v2/config.json`.
+ *   3. Returns `undefined` when the file is missing / malformed
+ *      (consistent with the cross-IDE contract).
+ */
+export declare function detectZcodeCurrentModel(): Promise<string | undefined>;
+export declare const ZCODE_ADAPTER: IdeAdapter;