peaks-loop 4.0.0-beta.8 → 4.0.1

package/dist/services/code/user-touchpoint-classifier.d.ts

@@ -0,0 +1,44 @@
+/**
+ * v2.15.0 follow-up — G4: user touchpoint classifier.
+ *
+ * 12 Gaps positioning memory: "user 介入 = 业务/产品审阅,不是技术决策".
+ * This service classifies every Code gate by the kind of decision it
+ * represents, so the CLI / status line can show user which gates
+ * actually need their attention vs which are technical defaults
+ * (AI auto-decides in full-auto).
+ *
+ *   - `business`         — user MUST be present (business / product decisions)
+ *   - `tech`             — AI auto-decides in full-auto (tech choices)
+ *   - `mode-selection`   — the gate IS the mode / context selection
+ *                          itself (always prompts the user, even in
+ *                          full-auto)
+ *   - `commit-boundary`  — hard-floor: push / tag / publish / global
+ *                          install (always prompts, even in full-auto)
+ *   - `commit-floor`     — other hard-floor categories
+ *                          (irreversible-external / auth / multi-day
+ *                          investment)
+ *
+ * Pure functions. No I/O.
+ */
+export type GateKind = 'business' | 'tech' | 'mode-selection' | 'commit-boundary' | 'commit-floor';
+export interface GateClassification {
+    readonly step: string;
+    readonly kind: GateKind;
+    /** Short description of what the user / AI is deciding. */
+    readonly description: string;
+    /** Whether full-auto can auto-proceed this gate. */
+    readonly fullAutoCanProceed: boolean;
+    /** When user should pay attention (always / business-only / never). */
+    readonly userShouldReview: 'always' | 'business-only' | 'never';
+}
+export declare function classifyAllGates(): readonly GateClassification[];
+/** Look up a single gate's classification. Returns null when the step is not in the table. */
+export declare function classifyGate(step: string): GateClassification | null;
+/** List all gates the user must review (per the 12 Gaps positioning). */
+export declare function userMustReviewGates(): readonly GateClassification[];
+/** List all gates AI auto-decides in full-auto. */
+export declare function aiAutoDecidesGates(): readonly GateClassification[];
+export declare const COMMIT_BOUNDARY_ACTIONS_LIST: readonly {
+    id: string;
+    description: string;
+}[];

package/dist/services/code/user-touchpoint-classifier.js

@@ -0,0 +1,145 @@
+/**
+ * v2.15.0 follow-up — G4: user touchpoint classifier.
+ *
+ * 12 Gaps positioning memory: "user 介入 = 业务/产品审阅,不是技术决策".
+ * This service classifies every Code gate by the kind of decision it
+ * represents, so the CLI / status line can show user which gates
+ * actually need their attention vs which are technical defaults
+ * (AI auto-decides in full-auto).
+ *
+ *   - `business`         — user MUST be present (business / product decisions)
+ *   - `tech`             — AI auto-decides in full-auto (tech choices)
+ *   - `mode-selection`   — the gate IS the mode / context selection
+ *                          itself (always prompts the user, even in
+ *                          full-auto)
+ *   - `commit-boundary`  — hard-floor: push / tag / publish / global
+ *                          install (always prompts, even in full-auto)
+ *   - `commit-floor`     — other hard-floor categories
+ *                          (irreversible-external / auth / multi-day
+ *                          investment)
+ *
+ * Pure functions. No I/O.
+ */
+const RAW_CLASSIFICATION = [
+    {
+        step: 'step-0.5-openspec-opt-in',
+        kind: 'mode-selection',
+        description: 'OpenSpec 一次性 opt-in(使用 OpenSpec spec-first 流程)。这是 context 选择门,user 必答。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-0.6-audit-goal',
+        kind: 'business',
+        description: 'Audit + Goal 确认。goal 必须明确区分业务/产品(user 写)与技术(AI 拍板)。user 必审。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-0.7-resume-detection',
+        kind: 'mode-selection',
+        description: '未完工作续做 vs 重开。context 选择门,user 必答。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-0.55-1x-upgrade',
+        kind: 'commit-floor',
+        description: '1.x → 2.0 升级检测。不可逆外部副作用(改写 config + cache schema),所有 mode 都必须 AskUserQuestion。full-auto 也暂停。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-0.75-checkpoint-resume',
+        kind: 'tech',
+        description: '同 session 当日重入 + checkpoint 续做。技术恢复逻辑,user 不参与。',
+        fullAutoCanProceed: true,
+        userShouldReview: 'never'
+    },
+    {
+        step: 'step-1-mode-select',
+        kind: 'mode-selection',
+        description: 'Mode 选择(全自动化 / 半自动 / 蜂群 / 严格)。context 选择门,user 必答。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-2.5-session-title',
+        kind: 'tech',
+        description: 'Session 标题生成(从用户首次请求抽取)。技术性 metadata,AI 自决。',
+        fullAutoCanProceed: true,
+        userShouldReview: 'never'
+    },
+    {
+        step: 'phase-2-prd-confirm',
+        kind: 'business',
+        description: 'PRD 确认。user 必审业务/产品意图(4 必填块见 prd check-blocks)。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'phase-3-swarm-gate-b',
+        kind: 'tech',
+        description: '蜂群 gate B(并行 fan-out 决策)。技术调度,AI 在 full-auto 自决。',
+        fullAutoCanProceed: true,
+        userShouldReview: 'never'
+    },
+    {
+        step: 'phase-6-qa-gate-d',
+        kind: 'business',
+        description: 'QA gate D(业务验收)。user 必审业务/产品视角 6 项清单(不是技术指标)。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'phase-10-txt-memory-extract',
+        kind: 'business',
+        description: 'TXT handoff + memory 提取。user 必审(决定哪些 peaks-memory 块落 .peaks/memory/)。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-n+1-final-review',
+        kind: 'business',
+        description: '4 维终审。user 必审业务交付完整性。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'frontend-only-mismatch',
+        kind: 'tech',
+        description: '前端-only 模式不匹配检测。技术模式判断,AI 在 full-auto 自决。',
+        fullAutoCanProceed: true,
+        userShouldReview: 'never'
+    },
+    {
+        step: 'standards-preflight',
+        kind: 'tech',
+        description: '项目标准预检(standards init/update dry-run)。技术 preflight,AI 自决 apply。',
+        fullAutoCanProceed: true,
+        userShouldReview: 'never'
+    }
+];
+export function classifyAllGates() {
+    return RAW_CLASSIFICATION.slice();
+}
+/** Look up a single gate's classification. Returns null when the step is not in the table. */
+export function classifyGate(step) {
+    const raw = RAW_CLASSIFICATION.find((g) => g.step === step);
+    return raw === undefined ? null : raw;
+}
+/** List all gates the user must review (per the 12 Gaps positioning). */
+export function userMustReviewGates() {
+    return RAW_CLASSIFICATION.filter((g) => g.userShouldReview !== 'never');
+}
+/** List all gates AI auto-decides in full-auto. */
+export function aiAutoDecidesGates() {
+    return RAW_CLASSIFICATION.filter((g) => g.fullAutoCanProceed);
+}
+export const COMMIT_BOUNDARY_ACTIONS_LIST = [
+    { id: 'git-push', description: 'git push / git push origin / git push --tags' },
+    { id: 'git-tag', description: 'git tag v2.15.0 / git tag -a ...' },
+    { id: 'npm-publish', description: 'npm publish / npm pub' },
+    { id: 'npm-install-global', description: 'npm install -g / npm i -g / npm add -g' },
+    { id: 'peaks-global-install', description: 'peaks-loop 全局安装 / npm install -g peaks-loop' }
+];

package/dist/services/code-review/ecc-bridge.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Everything-Claude-Code (ECC) code-review bridge — adapter that
+ * takes the ECC `code-review` agent's structured envelope
+ * (`{ passed, violations[], gateAction }`) and renders it into the
+ * `rd/code-review.md` markdown format that `peaks request transition`
+ * Gate B3 already reads (`mustContain: ['## Findings', 'CRITICAL']`).
+ *
+ * Companion to `ocr-service.ts`: ECC is the in-skill agent option
+ * (uses peaks-loop's own Agent tool surface), ocr is the external
+ * subprocess option. Both produce a second-opinion code review that
+ * the parent RD loop aggregates alongside its own inline review.
+ *
+ * === Why a bridge (not a direct swap) ===
+ *
+ * `peaks-rd/references/parallel-review-fanout.md` sub-agent 1 has a
+ * hard contract: write `rd/code-review.md` with sections
+ * `Summary / Findings / Required Fixes / Recommended / Verdict`.
+ * The CLI gate at `rd:qa-handoff` enforces `mustContain: ['## Findings',
+ * 'CRITICAL']` and refuses the transition otherwise. ECC's structured
+ * envelope does not match that shape — it returns `{ passed, violations,
+ * gateAction }`. Hence the bridge: render the envelope into the
+ * canonical markdown shape, so ECC and the legacy inline reviewer
+ * share the same downstream contract.
+ *
+ * === Why no `peaksConfig.ecc.*` block ===
+ *
+ * ECC is shipped via the `everything-claude-code` plugin, not as a
+ * separate npm package. The user installs the plugin (a one-time
+ * marketplace step); peaks-loop does not write or read any LLM
+ * endpoint config for ECC. If a future ECC release needs user-
+ * managed config (URL / token / model), add a `peaksConfig.ecc.*`
+ * block then — not speculatively now.
+ *
+ * === Source: peaks-rd/references/parallel-review-fanout.md ===
+ *
+ * Sub-agent 1 contract (Tier 7 v2.11.0): the parent RD loop calls
+ * `Agent({ subagent_type: 'everything-claude-code:code-review', ... })`
+ * with the diff + handoff in scope, receives the structured envelope,
+ * then runs `adaptEccEnvelopeToRdCodeReview(env, { rid, generatedAt })`
+ * and writes the resulting body to
+ * `.peaks/_runtime/<sessionId>/rd/code-review.md`.
+ */
+export type EccViolationKind = 'correctness' | 'type-safety' | 'error-handling' | 'mutation' | 'file-size' | 'naming' | 'dead-code' | 'regression' | 'contract-drift' | 'other';
+export interface EccViolation {
+    readonly kind: string;
+    readonly line: number;
+    readonly snippet: string;
+    readonly hint: string;
+}
+export type EccGateAction = 'pass' | 'warn' | 'block';
+export interface EccEnvelope {
+    readonly passed: boolean;
+    readonly violations: ReadonlyArray<EccViolation>;
+    readonly gateAction: EccGateAction;
+}
+/**
+ * 5-state detect result — mirrors `ocr-service.ts` `OcrDetectState`
+ * (ready / package-missing / binary-missing / config-missing /
+ * detection-failed). ECC's analogue:
+ *   - `ready`               — ECC plugin is installed and reachable
+ *   - `plugin-missing`      — `everything-claude-code` not in skill list
+ *   - `agent-missing`       — plugin present but `code-review` agent absent
+ *   - `dispatch-failed`     — Agent tool call threw before returning envelope
+ *   - `envelope-malformed`  — returned value failed `isEccEnvelope` validation
+ *
+ * The caller (peaks-rd's sub-agent 1 contract) inspects `state` and
+ * either proceeds with the envelope or records a degradation note in
+ * the request artifact body (`code-review-ecc-degraded-to-inline`).
+ */
+export type EccDetectState = 'ready' | 'plugin-missing' | 'agent-missing' | 'dispatch-failed' | 'envelope-malformed';
+export interface EccDetectResult {
+    readonly state: EccDetectState;
+    readonly pluginInstalled: boolean;
+    readonly agentAvailable: boolean;
+    readonly warnings: readonly string[];
+    readonly nextActions: readonly string[];
+}
+export type RdCodeReviewVerdict = 'pass' | 'warn' | 'block';
+export interface RdCodeReviewDoc {
+    /** Full markdown body, ready to write to `rd/code-review.md`. */
+    readonly body: string;
+    /** Mirror of `gateAction` for the parent RD loop to log/aggregate. */
+    readonly verdict: RdCodeReviewVerdict;
+    /** Counts per severity bucket — populated only when violations exist. */
+    readonly counts: {
+        readonly total: number;
+        readonly byKind: Readonly<Record<string, number>>;
+    };
+}
+/**
+ * Validate a raw value as an EccEnvelope. Accepts the strict shape
+ * only — extra fields are tolerated (forward-compat for ECC adding
+ * new top-level keys), but missing/typed-wrong fields reject.
+ *
+ * Defensive on purpose: ECC is external code, and a malformed envelope
+ * must not propagate into `rd/code-review.md` (would corrupt Gate B3).
+ */
+export declare function isEccEnvelope(value: unknown): value is EccEnvelope;
+/**
+ * Render an ECC envelope to the canonical `rd/code-review.md` shape.
+ * Verdict → sections:
+ *   - `pass`  → Summary + Findings (empty) + Verdict: pass
+ *   - `warn`  → Summary + Findings + Required Fixes + Recommended + Verdict: warn
+ *   - `block` → Summary + Findings + Required Fixes + Recommended + Verdict: block
+ *               + the `CRITICAL: <n>` marker that Gate B3's
+ *               `mustContain: ['## Findings', 'CRITICAL']` requires
+ */
+export declare function adaptEccEnvelopeToRdCodeReview(env: EccEnvelope, opts: {
+    rid: string;
+    generatedAt: string;
+}): RdCodeReviewDoc;
+/**
+ * 5-state detector — mirrors `detectOcr`'s shape (state enum + warnings
+ * + nextActions). The caller passes in the result of its own probe:
+ *
+ * - `pluginInstalled`: did the skill list scan find `everything-claude-code`?
+ * - `agentAvailable`: did the Agent tool say `code-review` is registered?
+ * - `dispatchError`: optional — the Agent tool threw before returning.
+ * - `envelope`: optional — what came back (if anything).
+ *
+ * The detector never blocks: when state !== `ready`, the parent RD
+ * loop records a `code-review-ecc-degraded-to-inline` note and falls
+ * back to inline review. This matches `detectOcr`'s soft-fail policy.
+ */
+export declare function detectEcc(input: {
+    readonly pluginInstalled: boolean;
+    readonly agentAvailable: boolean;
+    readonly dispatchError?: unknown;
+    readonly envelope?: unknown;
+}): EccDetectResult;
+/**
+ * Convenience: run `detectEcc` and `adaptEccEnvelopeToRdCodeReview`
+ * in one call. The parent RD loop calls this after the Agent tool
+ * returns. When `detectEcc` returns state !== 'ready', the caller
+ * should NOT call `adaptEccEnvelopeToRdCodeReview` — fall back to
+ * inline review instead.
+ */
+export declare function runEccCodeReview(input: {
+    readonly rid: string;
+    readonly generatedAt: string;
+    readonly pluginInstalled: boolean;
+    readonly agentAvailable: boolean;
+    readonly dispatchError?: unknown;
+    readonly envelope?: unknown;
+}): {
+    detect: EccDetectResult;
+    doc: RdCodeReviewDoc | null;
+};

package/dist/services/code-review/ecc-bridge.js

@@ -0,0 +1,242 @@
+/**
+ * Validate a raw value as an EccEnvelope. Accepts the strict shape
+ * only — extra fields are tolerated (forward-compat for ECC adding
+ * new top-level keys), but missing/typed-wrong fields reject.
+ *
+ * Defensive on purpose: ECC is external code, and a malformed envelope
+ * must not propagate into `rd/code-review.md` (would corrupt Gate B3).
+ */
+export function isEccEnvelope(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const obj = value;
+    if (typeof obj.passed !== 'boolean')
+        return false;
+    if (!Array.isArray(obj.violations))
+        return false;
+    if (typeof obj.gateAction !== 'string')
+        return false;
+    if (obj.gateAction !== 'pass' && obj.gateAction !== 'warn' && obj.gateAction !== 'block') {
+        return false;
+    }
+    for (const v of obj.violations) {
+        if (v === null || typeof v !== 'object')
+            return false;
+        const vo = v;
+        if (typeof vo.kind !== 'string')
+            return false;
+        if (typeof vo.line !== 'number' || !Number.isFinite(vo.line))
+            return false;
+        if (typeof vo.snippet !== 'string')
+            return false;
+        if (typeof vo.hint !== 'string')
+            return false;
+    }
+    return true;
+}
+function escapeMarkdownCell(value) {
+    // Defang characters that would break a markdown bullet or inject a
+    // code fence. We render violations as bullet items, so the only
+    // ones that matter are:
+    //   - newlines (turn into spaces so a violation cannot span rows),
+    //   - backtick runs (strip — three or more consecutive backticks
+    //     would open a fenced code block),
+    //   - the bullet marker `-` if it leads the cell.
+    return value
+        .replace(/\r?\n/g, ' ')
+        .replace(/`{3,}/g, '')
+        .replace(/^[-*+]\s+/, '')
+        .trim();
+}
+function severityLabel(gateAction) {
+    switch (gateAction) {
+        case 'pass':
+            return 'info';
+        case 'warn':
+            return 'warn';
+        case 'block':
+            return 'CRITICAL';
+    }
+}
+function countByKind(violations) {
+    const counts = {};
+    for (const v of violations) {
+        counts[v.kind] = (counts[v.kind] ?? 0) + 1;
+    }
+    return counts;
+}
+/**
+ * Render an ECC envelope to the canonical `rd/code-review.md` shape.
+ * Verdict → sections:
+ *   - `pass`  → Summary + Findings (empty) + Verdict: pass
+ *   - `warn`  → Summary + Findings + Required Fixes + Recommended + Verdict: warn
+ *   - `block` → Summary + Findings + Required Fixes + Recommended + Verdict: block
+ *               + the `CRITICAL: <n>` marker that Gate B3's
+ *               `mustContain: ['## Findings', 'CRITICAL']` requires
+ */
+export function adaptEccEnvelopeToRdCodeReview(env, opts) {
+    const counts = countByKind(env.violations);
+    const summary = [
+        `# Code review — ${opts.rid}`,
+        '',
+        `## Summary`,
+        '',
+        `- generatedAt: ${opts.generatedAt}`,
+        `- source: everything-claude-code:code-review (Tier 7 bridge)`,
+        `- gateAction: ${env.gateAction}`,
+        `- passed: ${env.passed}`,
+        `- violations: ${env.violations.length}`,
+        ''
+    ].join('\n');
+    const findingsSection = renderFindings(env.violations);
+    const requiredFixesSection = env.violations.length === 0
+        ? ''
+        : [
+            '## Required Fixes',
+            '',
+            ...env.violations.map((v, i) => {
+                const safeSnippet = escapeMarkdownCell(v.snippet);
+                const safeHint = escapeMarkdownCell(v.hint);
+                return `- [${v.kind} @ line ${v.line}] ${safeHint} (snippet: \`${safeSnippet}\`)`;
+            }),
+            ''
+        ].join('\n');
+    const recommendedSection = env.gateAction === 'pass'
+        ? ''
+        : [
+            '## Recommended',
+            '',
+            '- Address each Required Fix before transitioning to `qa-handoff`.',
+            '- For non-blocking (`gateAction: warn`) violations, fix or defer with a written rationale in `rd/requests/<rid>.md`.',
+            ''
+        ].join('\n');
+    // Gate B3 contract: the file MUST contain both `## Findings` and `CRITICAL`.
+    // `pass` envelope → emit `CRITICAL: 0` so the gate's substring check still
+    // hits even when there are no violations.
+    const criticalCount = env.gateAction === 'block' ? env.violations.length : 0;
+    const verdictBlock = [
+        '## Verdict',
+        '',
+        `verdict: ${env.gateAction}`,
+        `CRITICAL: ${criticalCount}`,
+        ''
+    ].join('\n');
+    const body = [
+        summary,
+        findingsSection,
+        requiredFixesSection,
+        recommendedSection,
+        verdictBlock
+    ].filter((s) => s.length > 0).join('\n');
+    return {
+        body,
+        verdict: env.gateAction,
+        counts: { total: env.violations.length, byKind: counts }
+    };
+}
+function renderFindings(violations) {
+    if (violations.length === 0) {
+        return ['## Findings', '', '- (none)', ''].join('\n');
+    }
+    const bullets = violations.map((v) => {
+        const safeSnippet = escapeMarkdownCell(v.snippet);
+        const safeHint = escapeMarkdownCell(v.hint);
+        return `- ${v.kind} @ line ${v.line}: ${safeHint} (snippet: \`${safeSnippet}\`)`;
+    });
+    return ['## Findings', '', ...bullets, ''].join('\n');
+}
+/**
+ * 5-state detector — mirrors `detectOcr`'s shape (state enum + warnings
+ * + nextActions). The caller passes in the result of its own probe:
+ *
+ * - `pluginInstalled`: did the skill list scan find `everything-claude-code`?
+ * - `agentAvailable`: did the Agent tool say `code-review` is registered?
+ * - `dispatchError`: optional — the Agent tool threw before returning.
+ * - `envelope`: optional — what came back (if anything).
+ *
+ * The detector never blocks: when state !== `ready`, the parent RD
+ * loop records a `code-review-ecc-degraded-to-inline` note and falls
+ * back to inline review. This matches `detectOcr`'s soft-fail policy.
+ */
+export function detectEcc(input) {
+    const warnings = [];
+    const nextActions = [];
+    if (!input.pluginInstalled) {
+        return {
+            state: 'plugin-missing',
+            pluginInstalled: false,
+            agentAvailable: false,
+            warnings,
+            nextActions: [
+                'Install the `everything-claude-code` plugin (Claude Code marketplace).',
+                'Until installed, peaks-rd falls back to inline code review (degradation note: code-review-ecc-degraded-to-inline).'
+            ]
+        };
+    }
+    if (!input.agentAvailable) {
+        return {
+            state: 'agent-missing',
+            pluginInstalled: true,
+            agentAvailable: false,
+            warnings: [
+                '`everything-claude-code` is installed but its `code-review` agent is not registered.'
+            ],
+            nextActions: [
+                'Verify the plugin is enabled in your Claude Code settings (MCP servers / agent registry).',
+                'Until resolved, peaks-rd falls back to inline code review.'
+            ]
+        };
+    }
+    if (input.dispatchError !== undefined) {
+        return {
+            state: 'dispatch-failed',
+            pluginInstalled: true,
+            agentAvailable: true,
+            warnings: [
+                `Agent dispatch failed: ${input.dispatchError instanceof Error ? input.dispatchError.message : String(input.dispatchError)}`
+            ],
+            nextActions: [
+                'Inspect the agent registry logs for the failure cause.',
+                'peaks-rd falls back to inline code review (degradation note: code-review-ecc-degraded-to-inline).'
+            ]
+        };
+    }
+    if (input.envelope !== undefined && !isEccEnvelope(input.envelope)) {
+        return {
+            state: 'envelope-malformed',
+            pluginInstalled: true,
+            agentAvailable: true,
+            warnings: [
+                'ECC `code-review` agent returned a value that failed envelope validation (expected { passed, violations, gateAction }).'
+            ],
+            nextActions: [
+                'Verify the ECC plugin version is compatible with peaks-loop 2.11.0+ (this bridge).',
+                'If the envelope shape is intentionally different, file a bug at the peaks-loop repo.'
+            ]
+        };
+    }
+    return {
+        state: 'ready',
+        pluginInstalled: true,
+        agentAvailable: true,
+        warnings,
+        nextActions
+    };
+}
+/**
+ * Convenience: run `detectEcc` and `adaptEccEnvelopeToRdCodeReview`
+ * in one call. The parent RD loop calls this after the Agent tool
+ * returns. When `detectEcc` returns state !== 'ready', the caller
+ * should NOT call `adaptEccEnvelopeToRdCodeReview` — fall back to
+ * inline review instead.
+ */
+export function runEccCodeReview(input) {
+    const detect = detectEcc(input);
+    if (detect.state !== 'ready' || input.envelope === undefined) {
+        return { detect, doc: null };
+    }
+    // Detect.state === 'ready' implies input.envelope passed isEccEnvelope; the runtime
+    // type is therefore EccEnvelope, not `unknown`. Cast is justified by detect's contract.
+    const env = input.envelope;
+    return { detect, doc: adaptEccEnvelopeToRdCodeReview(env, { rid: input.rid, generatedAt: input.generatedAt }) };
+}