peaks-loop 4.0.0-beta → 4.0.0-beta.10

package/dist/src/services/dispatch/test-tool-detection.js

@@ -1,46 +0,0 @@
-/**
- * Slice 2026-06-24-test-tool-detection-injection.
- *
- * The Test Tool Detection block is prepended to every sub-agent prompt
- * dispatched by peaks-loop (both the single-dispatch chokepoint in
- * `src/cli/commands/dispatch-commands.ts` and the DAG-dispatch chokepoint
- * in `src/services/solo/dag-orchestrator.ts`). It tells the sub-agent
- * to read `package.json#scripts.test` first and use the project-local
- * runner — never `npx <runner>` — so it cannot bypass the lockfile or
- * spawn a network-bound tool call.
- *
- * Why a static constant (not a per-call detector):
- *  1. Predictable byte budget — the block is part of PROMPT_LIMIT_BYTES
- *     accounting (see dispatch-commands.ts line 113), and the size must
- *     be stable across calls.
- *  2. I/O-free — dispatch is a hot path; reading package.json here would
- *     add a filesystem hit per dispatch and run before the LLM has any
- *     context to act on the result.
- *  3. LLM does runtime lookup — the block itself instructs the sub-agent
- *     to introspect `package.json#scripts.test` (or `peaks test --json`)
- *     at run time, so the LLM gets the resolved framework + argv with
- *     its full context. The dispatch CLI just primes the instruction.
- *
- * Why every sub-agent gets the block (Karpathy #2 Simplicity First):
- *  the rule is machine-injected, not a prompt ritual. The LLM cannot
- *  "remove the redundancy" of a test-tool-detection instruction because
- *  the dispatch CLI always prepends it. This is a guarantee, not a
- *  suggestion.
- */
-export const TEST_TOOL_DETECTION_BLOCK = `## Test Tool Detection (mandatory)
-
-Before running any test, read \`package.json#scripts.test\` to identify the project's test framework. Use the project-local runner — do NOT invoke \`npx <runner>\`:
-
-- **vitest** → \`./node_modules/.bin/vitest run <file>\` (or \`pnpm test -- <file>\`)
-- **jest**   → \`./node_modules/.bin/jest <file>\`   (or \`pnpm test -- <file>\`)
-- **mocha**  → \`./node_modules/.bin/mocha <file>\`  (or \`pnpm test -- <file>\`)
-
-If unsure which framework the consumer project uses, run \`peaks test --json\` first to introspect the resolved framework + argv. Only as a last resort, ask the user before assuming a runner. The CLI command \`peaks test <file>\` already resolves the local binary for you (Windows-aware).`;
-/**
- * Pure helper that returns the block. Exists as a function (not just an
- * exported constant) so future variants can take a runtime parameter
- * (e.g. projectRoot for context) without churning every call site.
- */
-export function formatTestToolDetection() {
-    return TEST_TOOL_DETECTION_BLOCK;
-}

package/dist/src/services/feedback/feedback-promotion-service.js

@@ -1,300 +0,0 @@
-/**
- * v2.15.0 slice 002 — AC-3: feedback-promotion service.
- *
- * `.peaks/memory/<name>.md` memories with `metadata.type === 'feedback'`
- * are user-given rules. They are advisory (LLM-readable) until promoted
- * to at least one enforcement layer (peaks-sop gate / peaks-hooks
- * PreToolUse / mode-gate hardFloorCategory). This service is the
- * primitive behind the `peaks feedback promote` and
- * `peaks feedback check-unpromoted` CLI commands.
- *
- * Promotion tracking convention: a feedback memory is considered
- * "promoted" when one of the following is true:
- *
- *   (a) The memory file contains an HTML comment near the top of the
- *       body: `<!-- peaks-feedback-promoted: layer=<A|B|C> -->`.
- *       Written by `peaks feedback promote` so a single read of the
- *       memory file is enough to determine promotion state.
- *
- *   (b) A sibling `.peaks/memory/<name>.promotion.json` exists with
- *       `{ layer: "A" | "B" | "C", ... }`. Written as a sidecar for
- *       tooling that prefers machine-readable state over embedded
- *       comments (e.g. `verify-pipeline` Gate H).
- *
- * The comment marker is the SOURCE OF TRUTH for human review; the
- * sidecar is the source of truth for the scanner. Either is enough
- * to mark a feedback memory as promoted.
- */
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-export const PROMOTION_LAYERS = ['A', 'B', 'C'];
-export const PROMOTION_LAYER_DETAILS = [
-    { layer: 'A', label: 'peaks-sop gate', description: 'Append to sops/*.md and reference from a peaks-sop check. Procedural rules.' },
-    { layer: 'B', label: 'peaks-hooks PreToolUse', description: 'Append a matcher to .peaks/.claude-settings-template.json. Tool-call interception.' },
-    { layer: 'C', label: 'mode-gate hardFloorCategory', description: 'Extend HardFloorCategory + shouldPauseAtGate. Always pauses regardless of mode.' }
-];
-const COMMENT_MARKER_RE = /<!--\s*peaks-feedback-promoted:\s*layer=([ABC])\s*-->/;
-/**
- * Parse a single `.peaks/memory/<file>.md` into a FeedbackMemory, or
- * `null` when the file is missing / unreadable / not a feedback memory.
- *
- * The "is this a feedback memory?" check is intentionally narrow: only
- * frontmatter with `metadata.type === 'feedback'` OR top-level
- * `type: feedback` qualifies. Other memory kinds (project / rule /
- * decision / reference / convention / module / lesson) are skipped.
- */
-export function parseFeedbackMemory(filePath) {
-    if (!existsSync(filePath))
-        return null;
-    let raw;
-    try {
-        raw = readFileSync(filePath, 'utf8');
-    }
-    catch (err) {
-        throw new Error(`failed to read feedback memory at ${filePath}: ${err.message}`, { cause: err });
-    }
-    const normalized = raw.replace(/\r\n/g, '\n');
-    if (!normalized.startsWith('---\n'))
-        return null;
-    const endIndex = normalized.indexOf('\n---\n', 4);
-    if (endIndex < 0)
-        return null;
-    const frontmatterRaw = normalized.slice(4, endIndex);
-    const body = normalized.slice(endIndex + '\n---\n'.length).trim();
-    let name;
-    let description;
-    let kind;
-    for (const rawLine of frontmatterRaw.split('\n')) {
-        const line = rawLine.trim();
-        if (line.startsWith('name:'))
-            name = line.slice('name:'.length).trim();
-        else if (line.startsWith('description:'))
-            description = line.slice('description:'.length).trim();
-        else if (line.startsWith('type:'))
-            kind = line.slice('type:'.length).trim();
-        else if (line.startsWith('  type:'))
-            kind = line.slice('  type:'.length).trim();
-    }
-    if (kind !== 'feedback')
-        return null;
-    // Comment marker (preferred — embedded in the file itself).
-    let promotion = null;
-    const commentMatch = COMMENT_MARKER_RE.exec(body);
-    if (commentMatch) {
-        const layer = commentMatch[1];
-        const detail = PROMOTION_LAYER_DETAILS.find((l) => l.layer === layer);
-        promotion = {
-            layer,
-            source: 'comment',
-            detail: detail?.label ?? layer
-        };
-    }
-    else {
-        // Sidecar fallback: `<basename>.promotion.json`.
-        const sidecarPath = filePath.replace(/\.md$/, '.promotion.json');
-        if (existsSync(sidecarPath)) {
-            try {
-                const sidecar = JSON.parse(readFileSync(sidecarPath, 'utf8'));
-                if (sidecar.layer === 'A' || sidecar.layer === 'B' || sidecar.layer === 'C') {
-                    const detail = PROMOTION_LAYER_DETAILS.find((l) => l.layer === sidecar.layer);
-                    promotion = {
-                        layer: sidecar.layer,
-                        source: 'sidecar',
-                        detail: detail?.label ?? sidecar.layer
-                    };
-                }
-            }
-            catch (err) {
-                // malformed sidecar — warn but do not fail the whole parse
-                console.warn(`parseFeedbackMemory: malformed sidecar at ${sidecarPath}: ${err.message}`);
-            }
-        }
-    }
-    return {
-        name: name ?? basename(filePath),
-        path: filePath,
-        frontmatter: {
-            ...(name !== undefined ? { name } : {}),
-            ...(description !== undefined ? { description } : {}),
-            ...(kind !== undefined ? { kind } : {})
-        },
-        body,
-        promotion
-    };
-}
-function basename(p) {
-    const lastSlash = Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'));
-    const base = lastSlash >= 0 ? p.slice(lastSlash + 1) : p;
-    return base.endsWith('.md') ? base.slice(0, -3) : base;
-}
-/**
- * Scan `.peaks/memory/*.md` for feedback memories and return those
- * that are NOT promoted to any enforcement layer. Pure read; the
- * CLI command emits the warning list + (with `--strict`) a non-zero
- * exit code.
- */
-export function listUnpromotedFeedback(opts) {
-    const memoryDir = resolve(opts.projectRoot, '.peaks', 'memory');
-    if (!existsSync(memoryDir))
-        return [];
-    const out = [];
-    for (const entry of readdirSync(memoryDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-        if (!entry.isFile() || !entry.name.endsWith('.md'))
-            continue;
-        if (entry.name.startsWith('.'))
-            continue; // skip dotfiles (e.g. .index.json)
-        const parsed = parseFeedbackMemory(join(memoryDir, entry.name));
-        if (parsed === null)
-            continue;
-        // v2.18.4 fix: skip closed feedback memories (frontmatter `closedAt: <iso>`).
-        // Closed memories declare their own "Do not re-introduce this memory as a
-        // live blocker" in the body; counting them as unpromoted would (a) force
-        // operators to promote or delete a deliberately archived record and (b)
-        // contradict the memory's own lifecycle. Verify-pipeline Gate H now
-        // honours the closed state and reports `0 unpromoted` for closed records.
-        if (isClosedMemory(join(memoryDir, entry.name)))
-            continue;
-        if (parsed.promotion === null) {
-            out.push({
-                name: parsed.name,
-                path: parsed.path,
-                reason: 'no promotion marker (comment or sidecar) found — see `peaks feedback promote`'
-            });
-        }
-    }
-    return out;
-}
-/**
- * v2.18.4 helper: detect a closed feedback memory by reading the raw
- * frontmatter and checking for a non-empty `closedAt:` field. The check
- * is intentionally narrow (top-level `closedAt:` only, not `metadata.closedAt`)
- * because that is the documented convention — memories archived in the
- * `[[review-memories-extract-and-memory-index]]` family all use top-level.
- *
- * Returns `true` when the file is unreadable or has no frontmatter (the
- * conservative answer; such files fall through to the normal unpromoted scan).
- */
-function isClosedMemory(filePath) {
-    if (!existsSync(filePath))
-        return false;
-    let raw;
-    try {
-        raw = readFileSync(filePath, 'utf8');
-    }
-    catch {
-        return false;
-    }
-    const normalized = raw.replace(/\r\n/g, '\n');
-    if (!normalized.startsWith('---\n'))
-        return false;
-    const endIndex = normalized.indexOf('\n---\n', 4);
-    if (endIndex < 0)
-        return false;
-    const frontmatter = normalized.slice(4, endIndex);
-    for (const rawLine of frontmatter.split('\n')) {
-        const line = rawLine.trim();
-        if (line.startsWith('closedAt:')) {
-            const value = line.slice('closedAt:'.length).trim();
-            if (value.length > 0 && value !== '""' && value !== "''")
-                return true;
-        }
-    }
-    return false;
-}
-/**
- * Generate the code stub for a given layer. Returns a Markdown
- * snippet the LLM / human can paste into the appropriate file. Pure
- * function — does NOT touch disk. The CLI command wraps this with
- * the disk write / envelope emission.
- */
-export function generatePromotionStub(opts) {
-    const { layer, feedbackName } = opts;
-    if (layer === 'A') {
-        return {
-            snippet: `# SOP entry for feedback "${feedbackName}"\n\n<!-- Append the rule + acceptance criteria below. Reference from a new peaks-sop gate. -->\n\n## Rule\n\n${opts.feedbackBody.split('\n').slice(0, 5).join('\n')}\n\n## Enforcement\n\nAdd a check to sops/<name>.md and reference from .claude/rules/.`,
-            targetFiles: [`sops/${feedbackName}.md`]
-        };
-    }
-    if (layer === 'B') {
-        return {
-            snippet: `{\n  "matcher": "Bash",\n  "hooks": [\n    {\n      "type": "command",\n      "command": "node -e \\"process.exit(0)\\""\n    }\n  ]\n}\n<!-- Append the rule-specific matcher to .peaks/.claude-settings-template.json -->`,
-            targetFiles: ['.peaks/.claude-settings-template.json']
-        };
-    }
-    // layer === 'C'
-    return {
-        snippet: `// src/services/solo/mode-gate.ts\n// 1. Add to HardFloorCategory union: '${feedbackName}-rule'\n// 2. Add to HARD_FLOOR_CATEGORIES\n// 3. Wire shouldPauseAtGate to recognise the new category\n// Tests: tests/unit/services/solo/<name>-hard-floor.test.ts (≥6 cases per AC-4)`,
-        targetFiles: ['src/services/solo/mode-gate.ts', `tests/unit/services/solo/${feedbackName}-hard-floor.test.ts`]
-    };
-}
-/**
- * Write the promotion marker + sidecar. Also writes the envelope to
- * `.peaks/_runtime/<sid>/rd/feedback-promote-<name>.json` for QA
- * auditing. Returns the envelope so the CLI can emit it.
- *
- * The promotion marker is embedded in the memory file (so it
- * travels with the file across git history); the sidecar is a
- * machine-readable mirror. Both are written; either alone is
- * enough for the scanner.
- */
-export function promoteFeedback(opts) {
-    const parsed = parseFeedbackMemory(opts.feedbackPath);
-    if (parsed === null) {
-        throw new Error(`Not a feedback memory: ${opts.feedbackPath}`);
-    }
-    const stub = generatePromotionStub({
-        layer: opts.layer,
-        feedbackName: parsed.name,
-        feedbackBody: parsed.body
-    });
-    const now = new Date().toISOString();
-    const envelope = {
-        name: parsed.name,
-        feedbackPath: parsed.path,
-        layer: opts.layer,
-        layerDetail: PROMOTION_LAYER_DETAILS.find((l) => l.layer === opts.layer)?.label ?? opts.layer,
-        generatedFiles: stub.targetFiles,
-        snippet: stub.snippet,
-        promotedAt: now,
-        promotedBy: opts.promotedBy
-    };
-    if (opts.dryRun === true) {
-        return envelope;
-    }
-    // 1. Embed comment marker in the memory file.
-    const raw = readFileSync(opts.feedbackPath, 'utf8');
-    const normalized = raw.replace(/\r\n/g, '\n');
-    const endIndex = normalized.indexOf('\n---\n', 4);
-    if (endIndex >= 0) {
-        const body = normalized.slice(endIndex + '\n---\n'.length);
-        // If a marker already exists, replace it. Otherwise insert one
-        // at the top of the body.
-        const marker = `<!-- peaks-feedback-promoted: layer=${opts.layer} -->`;
-        const newBody = COMMENT_MARKER_RE.test(body)
-            ? body.replace(COMMENT_MARKER_RE, marker)
-            : `${marker}\n${body}`;
-        const newContent = normalized.slice(0, endIndex + '\n---\n'.length) + newBody;
-        writeFileSync(opts.feedbackPath, newContent, 'utf8');
-    }
-    // 2. Sidecar (machine-readable mirror).
-    const sidecarPath = opts.feedbackPath.replace(/\.md$/, '.promotion.json');
-    writeFileSync(sidecarPath, JSON.stringify({
-        name: parsed.name,
-        layer: opts.layer,
-        layerDetail: envelope.layerDetail,
-        generatedFiles: stub.targetFiles,
-        promotedAt: now,
-        promotedBy: opts.promotedBy
-    }, null, 2), 'utf8');
-    // 3. Envelope to `.peaks/_runtime/<sid>/rd/`.
-    const envelopePath = join(opts.projectRoot, '.peaks', '_runtime', opts.sessionId, 'rd', `feedback-promote-${parsed.name}.json`);
-    const envelopeDir = dirname(envelopePath);
-    if (!existsSync(envelopeDir)) {
-        mkdirSync(envelopeDir, { recursive: true });
-    }
-    writeFileSync(envelopePath, JSON.stringify(envelope, null, 2), 'utf8');
-    return envelope;
-}
-export function isPromotionLayer(value) {
-    return value === 'A' || value === 'B' || value === 'C';
-}

package/dist/src/services/filesystem/file-lock.js

@@ -1,129 +0,0 @@
-/**
- * Cross-process file lock — sync, atomic, no third-party deps.
- *
- * Used by writeSharedEntry (shared-channel.ts) and appendHeartbeat /
- * markCompleted (dispatch-record-writer.ts) to guard the
- * read-modify-write sequence against lost updates from concurrent
- * writers (slice 2026-06-23-audit-3rd finding #2 + #3).
- *
- * Mechanism: write a sidecar `.lock` file next to the target via
- * `fs.openSync(path, 'wx')`. The `wx` flag maps to O_CREAT|O_EXCL on
- * POSIX (atomic) and `CreateFileW(... CREATE_NEW)` on Windows (also
- * atomic). The second opener fails with EEXIST. We retry with capped
- * exponential backoff up to MAX_LOCK_RETRIES, falling through to
- * LOCK_TIMEOUT if the lock cannot be acquired.
- *
- * Stale-lock reaping: a crashed previous holder leaves a `.lock` file
- * behind. We reap locks older than LOCK_STALE_MS by unlinking before
- * retrying. This trades a one-time stale-lock window for bounded
- * recovery without leaking orphan locks.
- *
- * Why not fs.flock? Node's `fs.flock` is POSIX-only; on Windows it
- * throws ERR_FEATURE_UNAVAILABLE_ON_PLATFORM. The `.lock` file
- * pattern works uniformly across platforms and survives process
- * crashes (the file remains; the next acquirer reaps it).
- */
-import { closeSync, existsSync, mkdirSync, openSync, statSync, unlinkSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-const MAX_LOCK_RETRIES = 100;
-const LOCK_RETRY_BASE_MS = 5;
-const LOCK_RETRY_MAX_MS = 50;
-const LOCK_STALE_MS = 30_000;
-export class LockTimeoutError extends Error {
-    code = 'LOCK_TIMEOUT';
-    lockPath;
-    constructor(lockPath, attempts) {
-        super(`LOCK_TIMEOUT: failed to acquire ${lockPath} after ${attempts} retries ` +
-            `(a prior holder may be alive or the lock is stale; it will be reaped ` +
-            `after ${LOCK_STALE_MS}ms of inactivity)`);
-        this.lockPath = lockPath;
-    }
-}
-/**
- * Run `fn` while holding an exclusive lock on a sidecar file at
- * `<filePath>.lock`. The lock is released in `finally` (close fd +
- * unlink lock file). Throws LockTimeoutError after MAX_LOCK_RETRIES.
- */
-export function withFileLockSync(filePath, fn) {
-    const target = resolve(filePath);
-    const lockPath = `${target}.lock`;
-    // Ensure the parent dir exists before openSync('wx') — first-write
-    // callers (e.g. writeSharedEntry on a fresh batch) reach the lock
-    // BEFORE writeAtomic's mkdirSync(dir, { recursive: true }) runs.
-    const dir = dirname(target);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    let attempts = 0;
-    let fd = null;
-    while (attempts < MAX_LOCK_RETRIES) {
-        // Stale-lock reap: if the lock file is older than LOCK_STALE_MS, the
-        // previous holder must have crashed. Unlink and retry without
-        // counting this attempt against MAX_LOCK_RETRIES (only EEXIST from
-        // a non-stale holder consumes a retry).
-        if (isStaleLock(lockPath)) {
-            try {
-                unlinkSync(lockPath);
-            }
-            catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-                // race: another process reaped it; loop and try to acquire.
-            }
-            continue;
-        }
-        try {
-            fd = openSync(lockPath, 'wx');
-            break;
-        }
-        catch (err) {
-            const code = err.code;
-            if (code !== 'EEXIST')
-                throw err;
-            attempts += 1;
-            // Exponential backoff capped at LOCK_RETRY_MAX_MS.
-            const wait = Math.min(LOCK_RETRY_BASE_MS * 2 ** Math.min(attempts, 6), LOCK_RETRY_MAX_MS);
-            spinSleep(wait);
-        }
-    }
-    if (fd === null) {
-        throw new LockTimeoutError(lockPath, attempts);
-    }
-    try {
-        return fn();
-    }
-    finally {
-        try {
-            closeSync(fd);
-        }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-            // fd may already be closed by the OS on a crash; ignore.
-        }
-        try {
-            unlinkSync(lockPath);
-        }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-            // Best-effort: stale .lock is harmless; the next acquirer reaps.
-        }
-    }
-}
-function isStaleLock(lockPath) {
-    try {
-        const s = statSync(lockPath);
-        return Date.now() - s.mtimeMs > LOCK_STALE_MS;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Synchronous sleep via busy-wait. Bounded by MAX_LOCK_RETRIES *
- * LOCK_RETRY_MAX_MS = 5s worst case. The alternative — async sleep —
- * would force every lock consumer to become async, which is a much
- * larger refactor for a slice whose lock contention is rare (concurrent
- * `peaks sub-agent share` for the same batch).
- */
-function spinSleep(ms) {
-    const end = Date.now() + ms;
-    while (Date.now() < end) {
-        /* intentional spin */
-    }
-}

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

@@ -1,60 +0,0 @@
-import { CLAUDE_CODE_ADAPTER } from './adapters/claude-code-adapter.js';
-import { TRAE_ADAPTER } from './adapters/trae-adapter.js';
-import { CURSOR_ADAPTER } from './adapters/cursor-adapter.js';
-import { CODEX_ADAPTER } from './adapters/codex-adapter.js';
-import { HERMES_ADAPTER } from './adapters/hermes-adapter.js';
-import { OPENCLAW_ADAPTER } from './adapters/openclaw-adapter.js';
-/**
- * Built-in IDE adapter registry。Map<IdeId, IdeAdapter> 是单一来源。
- *
- * Slice #1 注册 claude-code。
- * Slice #2 注册 trae —— 这是 slice #1 抽出的 IdeAdapter 形状的
- * 第一个真实客户,验证"填表"承诺。
- * 后续 slice 注入 codex / cursor / qoder / tongyi-lingma 时,只需在此
- * Map 加条目 —— 所有 adapter 使用方(hook-translator、hooks install、statusline
- * install、mcp apply)通过 `getAdapter(ide)` 拿取,无需修改。
- * Slice #0.7 注入 hermes + openclaw。
- * Slice #12 (2.4.0) 注册 cursor。
- * Slice #13 (2.4.0) 注册 codex。
- */
-const ADAPTERS = new Map([
-    ['claude-code', CLAUDE_CODE_ADAPTER],
-    ['trae', TRAE_ADAPTER],
-    ['cursor', CURSOR_ADAPTER],
-    ['codex', CODEX_ADAPTER],
-    ['hermes', HERMES_ADAPTER],
-    ['openclaw', OPENCLAW_ADAPTER],
-]);
-/** Get the adapter for a given IDE id. Throws on unsupported IDE. */
-export function getAdapter(ide) {
-    const adapter = ADAPTERS.get(ide);
-    if (!adapter) {
-        throw new Error(`Unsupported IDE: ${ide}. Registered: ${listAdapterIds().join(', ') || '(none)'}`);
-    }
-    return adapter;
-}
-/** All registered adapter ids (insertion order). */
-export function listAdapterIds() {
-    return Array.from(ADAPTERS.keys());
-}
-/** All registered adapters (insertion order). */
-export function listAdapters() {
-    return Array.from(ADAPTERS.values());
-}
-/**
- * Test seam: register or replace an adapter. Used by future slices when adding
- * a new IDE. Caller is responsible for ensuring the adapter is well-formed.
- */
-export function _setAdapterForTesting(ide, adapter) {
-    ADAPTERS.set(ide, adapter);
-}
-/** Test seam: reset to built-in defaults. */
-export function _resetAdaptersForTesting() {
-    ADAPTERS.clear();
-    ADAPTERS.set('claude-code', CLAUDE_CODE_ADAPTER);
-    ADAPTERS.set('trae', TRAE_ADAPTER);
-    ADAPTERS.set('cursor', CURSOR_ADAPTER);
-    ADAPTERS.set('codex', CODEX_ADAPTER);
-    ADAPTERS.set('hermes', HERMES_ADAPTER);
-    ADAPTERS.set('openclaw', OPENCLAW_ADAPTER);
-}