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

package/dist/src/cli/commands/adapter-commands-s2a.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `peaks adapter *` — vendor adapter registry CLI surface.
+ *
+ * Slice S2-a of RD-2 (2026-07-08 session). Two subcommands:
+ *
+ *   list     — list registered user adapters (persisted at
+ *              `.peaks/runtime/adapters.json`).
+ *   register — register a new adapter. Vendor verb strings live in
+ *              the binary the user picks, NOT in peaks-loop source.
+ *
+ * This file coexists with the older `adapter-commands.ts` (slice
+ * 2026-07-04-cli-15a) which exposes `peaks skill adapter <verb>` —
+ * a different surface for skill materialization (resolveScratchDir /
+ * materialize / publish). The two surfaces do NOT collide because
+ * one is `peaks skill adapter` and the other is `peaks adapter`.
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export interface AdapterListOptions {
+    json?: boolean;
+    project?: string;
+}
+export interface AdapterRegisterOptions {
+    json?: boolean;
+    id?: string;
+    /** Display name override (defaults to the id). */
+    name?: string;
+    binary?: string;
+    /** Repeated --arg values. */
+    arg?: string[];
+    force?: boolean;
+    project?: string;
+}
+export declare function registerAdapterS2ACommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/adapter-commands-s2a.js

@@ -0,0 +1,92 @@
+import { existsSync } from 'node:fs';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { fail, ok, getErrorMessage } from '../../shared/result.js';
+import { AdapterRegistry } from '../../services/adapter/adapter-registry.js';
+import { registryFileFor } from './runtime-commands.js';
+function resolveProjectRoot(explicit) {
+    if (explicit !== undefined && explicit.length > 0)
+        return explicit;
+    return process.cwd();
+}
+export function registerAdapterS2ACommands(program, io) {
+    const adapter = program
+        .command('adapter')
+        .description('Vendor adapter registry (user-registered, persisted to .peaks/runtime/adapters.json)');
+    // -----------------------------------------------------------------
+    // 1. peaks adapter list [--json] [--project <root>]
+    // -----------------------------------------------------------------
+    addJsonOption(adapter
+        .command('list')
+        .description('List user-registered vendor adapters')
+        .option('--project <path>', 'project root (defaults to cwd)')).action((options) => {
+        try {
+            const projectRoot = resolveProjectRoot(options.project);
+            const file = registryFileFor(projectRoot);
+            const reg = new AdapterRegistry();
+            if (existsSync(file))
+                reg.load(file);
+            const records = reg.list();
+            printResult(io, ok('adapter.list', { projectRoot, file, records, count: records.length }, [], [
+                records.length === 0
+                    ? 'No adapters registered yet. Run `peaks adapter register --id <vendor> --binary <cmd>` to add one.'
+                    : `Run \`peaks runtime compact --via <id>\` to invoke a registered adapter.`
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('adapter.list', 'ADAPTER_LIST_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        }
+    });
+    // -----------------------------------------------------------------
+    // 2. peaks adapter register --id <id> --binary <cmd> [--arg <a>]... [--force]
+    // -----------------------------------------------------------------
+    addJsonOption(adapter
+        .command('register')
+        .description('Register a new vendor adapter; persists to .peaks/runtime/adapters.json')
+        .requiredOption('--id <id>', 'vendor adapter id (lowercase, e.g. my-cli)')
+        .option('--name <name>', 'human-readable display name (defaults to <id>)')
+        .requiredOption('--binary <cmd>', 'binary name to invoke for compact (e.g. my-cli)')
+        .option('--arg <value>', 'extra arg appended before --force (repeatable)', (value, previous = []) => [...previous, value])
+        .option('--force', 'overwrite an existing adapter with the same id')
+        .option('--project <path>', 'project root (defaults to cwd)')).action((options) => {
+        try {
+            const projectRoot = resolveProjectRoot(options.project);
+            const file = registryFileFor(projectRoot);
+            const reg = new AdapterRegistry();
+            if (existsSync(file))
+                reg.load(file);
+            const id = options.id ?? '';
+            const record = options.arg !== undefined
+                ? { id, displayName: options.name ?? id, binary: options.binary ?? '', args: options.arg }
+                : { id, displayName: options.name ?? id, binary: options.binary ?? '' };
+            let result;
+            try {
+                result = reg.register(record, { force: options.force === true });
+            }
+            catch (validationError) {
+                printResult(io, fail('adapter.register', 'INVALID_ADAPTER_RECORD', getErrorMessage(validationError), { id }, [
+                    'Use --id with /^[a-z0-9][a-z0-9._-]*$/, --binary as a binary name (no path separators).'
+                ]), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            reg.persist(file);
+            const warnings = [];
+            if (!result.created && options.force !== true) {
+                warnings.push(`adapter "${id}" already registered; pass --force to overwrite`);
+            }
+            printResult(io, ok('adapter.register', {
+                projectRoot,
+                file,
+                adapter: result.record,
+                created: result.created
+            }, warnings, [
+                `Run \`peaks runtime compact --via ${id}\` to invoke it.`
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('adapter.register', 'ADAPTER_REGISTER_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/cli/commands/polyrepo-commands.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `peaks polyrepo *` — polyrepo workflow CLI surface.
+ *
+ * Slice S2-b of RD-2 (2026-07-08 session). Three subcommands:
+ *
+ *   init      — scan the parent dir for child git repos + write a
+ *               polyrepo manifest to `.peaks/polyrepo.json`.
+ *   status    — read the persisted manifest + report children.
+ *   dispatch  — mirror a PRD/RD/QA artifact from the parent into
+ *               each target child's
+ *               `.peaks/_runtime/<sid>/<role>/` directory.
+ *
+ * Per the project's two-axis convention, all reviewable artifacts
+ * live under `.peaks/_runtime/<sid>/<role>/` — never as top-level
+ * siblings of `.peaks/_runtime/`.
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export interface PolyrepoInitOptions {
+    json?: boolean;
+    root?: string;
+    children?: string;
+}
+export interface PolyrepoStatusOptions {
+    json?: boolean;
+    root?: string;
+}
+export interface PolyrepoDispatchOptions {
+    json?: boolean;
+    root?: string;
+    rid?: string;
+    to?: string;
+    role?: 'prd' | 'rd' | 'qa';
+    artifact?: string;
+    sid?: string;
+}
+export declare function registerPolyrepoCommands(program: Command, io: ProgramIO): void;

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

@@ -0,0 +1,155 @@
+import { existsSync } from 'node:fs';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { fail, ok, getErrorMessage } from '../../shared/result.js';
+import { PolyrepoService } from '../../services/polyrepo/polyrepo-service.js';
+function parseChildren(raw) {
+    if (raw === undefined || raw.length === 0)
+        return undefined;
+    return raw.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function resolveRoot(explicit) {
+    if (explicit !== undefined && explicit.length > 0)
+        return explicit;
+    return process.cwd();
+}
+export function registerPolyrepoCommands(program, io) {
+    const polyrepo = program
+        .command('polyrepo')
+        .description('Polyrepo workflow (parent dir + child git repos with their own .peaks/ subsets)');
+    // -----------------------------------------------------------------
+    // 1. peaks polyrepo init [--children <dir1,dir2>] [--root <dir>]
+    // -----------------------------------------------------------------
+    addJsonOption(polyrepo
+        .command('init')
+        .description('Scan the parent dir for child git repos and write .peaks/polyrepo.json')
+        .option('--children <list>', 'comma-separated child directory names (defaults to auto-discovery)')
+        .option('--root <path>', 'parent root (defaults to cwd)')).action((options) => {
+        try {
+            const root = resolveRoot(options.root);
+            const svc = new PolyrepoService();
+            const children = parseChildren(options.children);
+            const result = children === undefined
+                ? svc.init({ root })
+                : svc.init({ root, children });
+            printResult(io, ok('polyrepo.init', {
+                root: result.manifest.root,
+                detectedAt: result.manifest.detectedAt,
+                children: result.manifest.children,
+                manifestPath: `${result.manifest.root}/.peaks/polyrepo.json`,
+                created: result.created
+            }, [], [
+                result.manifest.children.length === 0
+                    ? 'No child git repos detected. Pass --children <dir1,dir2> to override.'
+                    : `Run \`peaks polyrepo dispatch --rid <rid> --to <child-id>\` to mirror an artifact into one or more children.`
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('polyrepo.init', 'POLYREPO_INIT_FAILED', getErrorMessage(error), {}, ['Verify --root exists and is a directory']), options.json);
+            process.exitCode = 1;
+        }
+    });
+    // -----------------------------------------------------------------
+    // 2. peaks polyrepo status [--root <dir>]
+    // -----------------------------------------------------------------
+    addJsonOption(polyrepo
+        .command('status')
+        .description('Report the persisted polyrepo manifest + children')
+        .option('--root <path>', 'parent root (defaults to cwd)')).action((options) => {
+        try {
+            const root = resolveRoot(options.root);
+            const svc = new PolyrepoService();
+            const result = svc.status(root);
+            if (!result.manifestExists) {
+                printResult(io, ok('polyrepo.status', { ...result, initialized: false }, [], [
+                    'No polyrepo manifest found. Run `peaks polyrepo init [--children <list>]` first.'
+                ]), options.json);
+                return;
+            }
+            printResult(io, ok('polyrepo.status', { ...result, initialized: true }, [], [
+                result.children.length === 0
+                    ? 'Manifest exists but has no children. Re-run `peaks polyrepo init --children <list>`.'
+                    : `Run \`peaks polyrepo dispatch --rid <rid> --to <child-id>\` to mirror an artifact.`
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('polyrepo.status', 'POLYREPO_STATUS_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        }
+    });
+    // -----------------------------------------------------------------
+    // 3. peaks polyrepo dispatch --rid <rid> [--to <child-id>] --role <prd|rd|qa> --artifact <path>
+    // -----------------------------------------------------------------
+    addJsonOption(polyrepo
+        .command('dispatch')
+        .description('Mirror a PRD/RD/QA artifact from the parent into one or more children')
+        .requiredOption('--rid <rid>', 'request id (used in the on-disk filename)')
+        .option('--to <list>', 'comma-separated child ids (defaults to all children in the manifest)')
+        .requiredOption('--role <role>', 'artifact role: prd | rd | qa')
+        .requiredOption('--artifact <path>', 'source artifact path (relative to --root or absolute)')
+        .option('--sid <sid>', 'session id override (defaults to the canonical binding)')
+        .option('--root <path>', 'parent root (defaults to cwd)')).action((options) => {
+        try {
+            const root = resolveRoot(options.root);
+            const sid = options.sid ?? 'default';
+            const rid = options.rid ?? '';
+            const role = options.role;
+            if (role !== 'prd' && role !== 'rd' && role !== 'qa') {
+                printResult(io, fail('polyrepo.dispatch', 'INVALID_ROLE', `--role must be prd | rd | qa (got "${role}")`, {}, [
+                    'Re-run with --role prd (or rd / qa).'
+                ]), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            const artifact = options.artifact ?? '';
+            if (!existsSync(artifact)) {
+                printResult(io, fail('polyrepo.dispatch', 'ARTIFACT_NOT_FOUND', `source artifact does not exist: ${artifact}`, {}, [
+                    'Verify the path or pass an absolute path.'
+                ]), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            // Resolve targets from the manifest first so we can default to
+            // "all children" when --to is omitted.
+            const svc = new PolyrepoService();
+            const status = svc.status(root);
+            if (!status.manifestExists) {
+                printResult(io, fail('polyrepo.dispatch', 'NO_MANIFEST', `no polyrepo manifest at ${root}/.peaks/polyrepo.json`, {}, [
+                    'Run `peaks polyrepo init` first.'
+                ]), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            let targets;
+            if (options.to !== undefined && options.to.length > 0) {
+                targets = options.to.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+            }
+            else {
+                targets = status.children.map((c) => c.id);
+            }
+            const result = svc.dispatch(root, {
+                sid, rid, targets, role, artifactPath: artifact
+            });
+            const allOk = result.perChild.every((c) => c.ok);
+            printResult(io, ok('polyrepo.dispatch', {
+                root,
+                sid,
+                rid,
+                role,
+                artifact,
+                dispatch: result.dispatch,
+                perChild: result.perChild,
+                allOk
+            }, result.warnings, [
+                allOk
+                    ? `Mirrored artifact to ${result.perChild.length} child(ren).`
+                    : `One or more child mirrors failed; inspect perChild[].ok.`
+            ]), options.json);
+            if (!allOk)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            printResult(io, fail('polyrepo.dispatch', 'POLYREPO_DISPATCH_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/cli/commands/runtime-commands.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `peaks runtime *` — vendor-runtime detection + compact CLI surface.
+ *
+ * Slice S2-a of RD-2 (2026-07-08 session). Four subcommands:
+ *
+ *   detect    — print which vendor is the active AI runtime
+ *               (claude-code / codex / copilot / unknown).
+ *   list      — list the built-in vendor adapters registered by
+ *               RuntimeService (Claude Code / Codex / Copilot).
+ *   compact   — invoke a vendor's compact verb via the adapter. The
+ *               adapter (NOT this file) chooses the vendor verb;
+ *               see src/services/runtime/vendors/<vendor>.ts.
+ *
+ * Vendor verb strings (`claude --compact`, `codex --compact`,
+ * `copilot compact`) MUST live ONLY in `src/services/runtime/vendors/`
+ * — verified by AC-1: `rg -n "claude --compact|codex --compact|copilot
+ * compact" src/services/code/` returns 0 matches.
+ *
+ * `peaks runtime compact --via <id>` first consults the user
+ * adapter registry (`.peaks/runtime/adapters.json`) for the id, then
+ * falls back to the built-in adapter list. Missing vendor CLI
+ * surfaces as exitCode=127 + warning, NOT as a fatal error — vendor
+ * neutrality demands peaks-loop stay alive.
+ */
+import type { Command } from 'commander';
+import { join } from 'node:path';
+import { type ProgramIO } from '../cli-helpers.js';
+export interface RuntimeDetectOptions {
+    json?: boolean;
+}
+export interface RuntimeListOptions {
+    json?: boolean;
+}
+export interface RuntimeCompactOptions {
+    json?: boolean;
+    /** Vendor adapter id (built-in or registered). */
+    via?: string;
+    force?: boolean;
+    /** Override the project root (defaults to .peaks runtime lookup). */
+    project?: string;
+}
+export declare function registerRuntimeCommands(program: Command, io: ProgramIO): void;
+/** Internal helper exposed for tests + future programmatic callers:
+ *  resolve the registry file location, ensuring the parent dir
+ *  exists. Idempotent. */
+export declare function ensureRegistryDir(registryFile: string): void;
+/** Internal helper for tests: locate the registry file under the
+ *  given project root. Thin wrapper so tests can stub the resolution. */
+export declare function registryFileFor(projectRoot: string): string;
+/** 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/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

@@ -85,6 +85,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';
@@ -375,6 +384,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;
+}