peaks-loop 4.0.15 → 4.0.17

package/dist/cli/commands/statusline-commands.js

@@ -74,7 +74,14 @@ export async function runDefaultStatuslineRender(options, io) {
     const seeded = options.project
         ? { ...(stdin ?? {}), workspace: { current_dir: options.project } }
         : stdin;
-    const model = buildStatusLineModel(seeded, Date.now());
+    // Slice 2026-08-07-statusline-flake: accept `--now <epoch-ms>` to pin
+    // `Date.now()` for deterministic lifecycle-window checks under full-
+    // suite concurrency. The integration test passes a test-time `now`
+    // pinned at the moment `seedLifecycle` was called so the completed-
+    // expiry window stays in-range regardless of how long the spawned
+    // subprocess sat descheduled. Production callers omit the flag.
+    const now = options.now !== undefined ? Number(options.now) : Date.now();
+    const model = buildStatusLineModel(seeded, now);
     const capability = resolveStatusLineCapability({
         env: process.env,
         isTTY: Boolean(process.stdout.isTTY),
@@ -98,7 +105,8 @@ export function registerStatusLineCommands(program, io) {
     const statusline = addJsonOption(program
         .command('statusline')
         .description('Render the Peaks skill status line for the current session, or manage the adapter-driven statusLine entry. Run with no subcommand to render; with a subcommand (install | uninstall | status) to manage.')
-        .option('--project <path>', 'project root path (used to label the status line when stdin is absent; applies to the default render path)'));
+        .option('--project <path>', 'project root path (used to label the status line when stdin is absent; applies to the default render path)')
+        .option('--now <ms>', 'override current time (epoch ms) — for testing / deterministic rendering of the lifecycle expiry window'));
     // Default behavior: when the user types `peaks statusline` with no
     // subcommand, render the status line. Without this default action,
     // commander falls back to printing usage (Bug-02, ice-cola surface check
@@ -225,6 +233,7 @@ export function registerStatusLineCommands(program, io) {
         '--session-id to target a non-canonical session explicitly.')
         .option('--project <path>', 'project root (auto-detected from cwd when omitted)')
         .option('--session-id <sid>', 'override the active session id (defaults to the canonical binding; supported for QA / internal tooling)')
+        .option('--now <ms>', 'override current time (epoch ms) — for testing / deterministic rendering of the lifecycle expiry window')
         .action((options, command) => {
         // Re-resolve options via `command.optsWithGlobals()` (Commander 12.x
         // compatibility): when the parent `statusline` command has its own
@@ -243,10 +252,15 @@ export function registerStatusLineCommands(program, io) {
                 ? merged.project
                 : (findProjectRoot(process.cwd()) ?? process.cwd());
             const sid = merged.sessionId ?? getSessionIdCanonical(projectRoot) ?? null;
+            // Slice 2026-08-07-statusline-flake: honor `--now` (epoch ms)
+            // when present so deterministic lifecycle-window checks stay
+            // in-range under full-suite concurrency. See `--now` doc on
+            // the parent `statusline` command.
+            const now = merged.now !== undefined ? Number(merged.now) : Date.now();
             const state = decideCompactStatusline({
                 projectRoot,
                 sessionId: sid,
-                now: Date.now(),
+                now,
             });
             const label = renderCompactStatusline(state);
             // For non-JSON mode we print the LABEL DIRECTLY to stdout

package/dist/cli/commands/tech-commands.d.ts

@@ -18,7 +18,7 @@
  *     (B2 contract preservation rule from the rid-009 closure record).
  */
 import type { Command } from 'commander';
-import type { ProgramIO } from '../cli-helpers.js';
+import { type ProgramIO } from '../cli-helpers.js';
 import type { WorkspaceConfig } from '../../services/config/config-types.js';
 import { type TechChangeStatus, type WorkspaceConfig as _WorkspaceConfig } from '../../services/tech/tech-change-id-service.js';
 export type { WorkspaceConfig };

package/dist/services/artifacts/request-artifact-service.d.ts

@@ -1,6 +1,6 @@
 import { DEFAULT_REQUEST_TYPE, isRequestType, VALID_REQUEST_TYPES, type PrerequisiteCheckResult, type RequestType } from './artifact-prerequisites.js';
 export { VALID_REQUEST_TYPES, DEFAULT_REQUEST_TYPE, isRequestType, type RequestType };
-import type { RequestArtifactRole } from './artifact-templates.js';
+import { type RequestArtifactRole } from './artifact-templates.js';
 export type { RequestArtifactRole } from './artifact-templates.js';
 export { formatHandoffPath, formatCommitBoundaryPath, formatSkillUsageLessonsPath } from './artifact-templates.js';
 export type CreateRequestArtifactOptions = {
@@ -110,7 +110,7 @@ export type TransitionRequestArtifactResult = RequestArtifactSummary & {
     content: string;
     bypassedPrerequisites?: PrerequisiteCheckResult;
 };
-import type { RequestArtifactState } from './request-artifact-state-helpers.js';
+import { type RequestArtifactState } from './request-artifact-state-helpers.js';
 export { allowedStatesForRole, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, TypeSanityViolationError, updateStatusBlock } from './request-artifact-state-helpers.js';
 export type { RequestArtifactState } from './request-artifact-state-helpers.js';
 export declare function transitionRequestArtifact(options: TransitionRequestArtifactOptions): Promise<TransitionRequestArtifactResult | null>;

package/dist/services/artifacts/request-artifact-service.js

@@ -16,6 +16,15 @@ import { requireUserConfirmation } from '../mode/mode-enforcement.js';
 import { scanFileSize } from '../scan/file-size-scan.js';
 import { emitObservabilityEvent } from '../observability/observability-service.js';
 export { VALID_REQUEST_TYPES, DEFAULT_REQUEST_TYPE, isRequestType };
+// Re-export the pure-function template surface so external callers (CLI,
+// tests) keep importing from this module unchanged. The render templates,
+// handoff-path helpers, and `RequestArtifactRole` type all live in the
+// sibling `artifact-templates.ts` module — see slice
+// 2026-06-24-handoff-path-canonicalization for the rationale.
+//
+// `import type` is required so the type is in scope as a bare identifier
+// within this file (the value re-export alone does not bring types into
+// the local namespace under `isolatedModules`).
 import { renderTemplate } from './artifact-templates.js';
 export { formatHandoffPath, formatCommitBoundaryPath, formatSkillUsageLessonsPath } from './artifact-templates.js';
 const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
@@ -324,7 +333,7 @@ async function readRequestArtifact(projectRoot, scope, role, found) {
 // the sibling `request-artifact-state-helpers.ts` module — see
 // v2.18.3 file-split for the rationale. Function signatures and
 // behaviour are unchanged (verbatim move).
-import { ALLOWED_STATES_PER_ROLE, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, TypeSanityViolationError, updateStatusBlock } from './request-artifact-state-helpers.js';
+import { ALLOWED_STATES_PER_ROLE, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, TypeSanityViolationError, updateStatusBlock, } from './request-artifact-state-helpers.js';
 export { allowedStatesForRole, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, TypeSanityViolationError, updateStatusBlock } from './request-artifact-state-helpers.js';
 export async function transitionRequestArtifact(options) {
     if (!VALID_ROLES.has(options.role)) {

package/dist/services/audit/enforcers/lint-reference-shape.js

@@ -35,6 +35,20 @@ const ABSOLUTE_PATH_WINDOWS = /[A-Z]:\\[\w\\]/;
 const ABSOLUTE_PATH_UNIX = /\/usr\/(?:local|bin|opt)\b/;
 const MAGIC_NUMBER = /\b(\d{3,})\b/;
 const LOAD_STRATEGY_PATTERN = /loadStrategy:\s*(always|on-demand)/i;
+/**
+ * PRD-002b slice 2 — extract cross-cutting thresholds used by
+ * multiple enforcers (file-size cap, magic-number digit floor).
+ * Per-rule spec literals (≤800 lines, ≤12 H2 headings, ≤10 magic
+ * digits, top-N aggregation cap) are kept inline because they ARE
+ * the rule spec; extracting them would change the rule semantics to
+ * depend on a constant with no semantic gain. Names here describe
+ * the role only.
+ */
+const KB_PER_FILE = 1024;
+const LOAD_STRATEGY_FILE_SIZE_KB = 5;
+const OVERVIEW_TOP_SEARCH_LINES = 30;
+const OVERVIEW_MIN_LINE_COUNT = 200;
+const LOAD_STRATEGY_PROBE_LINES = 20;
 function findLine(lines, pattern) {
     for (let i = 0; i < lines.length; i += 1) {
         if (pattern.test(lines[i] ?? ''))
@@ -129,9 +143,9 @@ export function lintH2CountLe12(ref) {
     return [hit('rl-ref-h2-count-le-12-001', 'at most 12 `## <heading>` per reference', ref.path, 1, `(h2 count ${matches.length} > 12)`)];
 }
 export function lintOverviewNearTop(ref) {
-    if (ref.lines.length <= 200)
+    if (ref.lines.length <= OVERVIEW_MIN_LINE_COUNT)
         return [];
-    if (findLine(ref.lines.slice(0, 30), OVERVIEW_HEADING) !== -1)
+    if (findLine(ref.lines.slice(0, OVERVIEW_TOP_SEARCH_LINES), OVERVIEW_HEADING) !== -1)
         return [];
     return [hit('rl-ref-overview-section-near-top-001', 'long references (>200 lines) must have `## Overview` within the first 30 lines', ref.path, 1, '(missing `## Overview` near top of long reference)')];
 }
@@ -149,7 +163,7 @@ export function lintLoadStrategyAlwaysCacheable(ref) {
     // Heuristic: a loadStrategy: always reference must not have a
     // top-level shell command. This is a soft check — we look at
     // the first 10 non-frontmatter lines for I/O patterns.
-    const lines = ref.lines.slice(0, 20);
+    const lines = ref.lines.slice(0, LOAD_STRATEGY_PROBE_LINES);
     for (const line of lines) {
         if (/^\s*(npm|pnpm|yarn|npx|git|curl|wget|docker)\s+/.test(line)) {
             return [hit('rl-ref-loadstrategy-always-cacheable-001', 'loadStrategy: always references must not run I/O at top of file', ref.path, 1, `(I/O pattern at top of file: ${line.trim()})`)];
@@ -249,7 +263,7 @@ export function lintSkillCitesEveryReference(ref, skill) {
 }
 export function lintLoadStrategyMatchesSize(ref) {
     const sizeBytes = Buffer.byteLength(ref.body, 'utf8');
-    if (sizeBytes <= 5 * 1024)
+    if (sizeBytes <= LOAD_STRATEGY_FILE_SIZE_KB * KB_PER_FILE)
         return [];
     // >5KB file should declare loadStrategy: on-demand (always
     // is a context-budget bug).

package/dist/services/code/auto-compact-orchestrator.js

@@ -36,6 +36,14 @@ import { describeMode, thresholdFor } from './auto-compact-modes.js';
 import { read24hState } from '../24h-mode/store.js';
 import { readCompactLifecycle, writeCompactLifecycle } from '../compact-statusline/compact-lifecycle-store.js';
 const PRE_COMPACT_REASON = 'pre-compact-auto';
+/**
+ * PRD-002b slice 2 — extract the few cross-cutting magic numbers
+ * that actually appear at runtime call sites in this orchestrator.
+ * Threshold ratios (0.85 / 0.95) live in `auto-compact-types.ts`
+ * and are NOT extracted here because they ARE the contract; comment
+ * + spec prose references must keep the literal value visible.
+ */
+const COLLAPSED_ERROR_MAX_CHARS = 160;
 /**
  * Map a context ratio to a `CompactTrigger` action. Pure; the side
  * effects (checkpoint + IDE dispatch) live in `runAutoCompact`. Two
@@ -409,7 +417,7 @@ function summarizeLifecycleError(error) {
         raw = 'unknown error';
     const firstLine = raw.split('\n')[0] ?? '';
     const collapsed = firstLine.replace(/\s+/g, ' ').trim();
-    return collapsed.length === 0 ? 'unknown error' : (collapsed.length > 160 ? collapsed.slice(0, 160) : collapsed);
+    return collapsed.length === 0 ? 'unknown error' : (collapsed.length > COLLAPSED_ERROR_MAX_CHARS ? collapsed.slice(0, COLLAPSED_ERROR_MAX_CHARS) : collapsed);
 }
 /**
  * Slice 2026-08-01-compact-lifecycle (Task 5, Step 4): close out an

package/dist/services/code/batch-heartbeat-poller.js

@@ -1,3 +1,29 @@
+/**
+ * G6 — in-process batch heartbeat poller.
+ *
+ * The Dispatcher (peaks-code main loop) starts one poller per batch.
+ * The poller ticks every 10 s, reads `heartbeats[]` + `lastBeatAt` from
+ * each record in the batch, and emits:
+ *
+ *   - a `dispatcherStatus` envelope to the renderer's `onStatus` callback
+ *     (which formats the single-line status per G6.5)
+ *   - a `stale` envelope to `onStale` if a record crosses the 5-min
+ *     threshold (G6.2 / AC-35)
+ *
+ * The poller does **not**:
+ *   - cancel, kill, or send SIGTERM to a sub-agent (RL-15)
+ *   - modify `outcome` (only the aggregate `status` is flipped to 'stale')
+ *   - block the LLM call (it is fire-and-forget; the parent batch-sync
+ *     wait is governed by the LLM platform, not by this poller)
+ *
+ * The poller stops when:
+ *   - the parent calls `stop()` (batch finished)
+ *   - all records are terminal (`done` / `failed` / `cancelled` / `no-execution`)
+ *
+ * Pure JS event loop — no native deps, no IPC. Designed to be replaced
+ * by a real OS-level watcher in a future slice without changing the
+ * callback contract.
+ */
 import { readRecords } from '../dispatch/dispatch-record-writer.js';
 import { renderStatusLine, summarize, viewSubAgent } from './status-line-renderer.js';
 export const DEFAULT_POLL_INTERVAL_MS = 10_000;

package/dist/services/code/orchestrator-can-do.d.ts

@@ -38,6 +38,19 @@ export declare const ORCHESTRATOR_REDLINE_RATIO = 0.95;
 export declare const ORCHESTRATOR_PRECOMPACT_RATIO = 0.85;
 /** Source-code keywords that signal "do NOT Edit/Write directly". */
 export declare const SOURCE_CODE_KEYWORDS: readonly string[];
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — hard-blocked path families.
+ * When ANY of these substrings appears in the slice-spec, the orchestrator
+ * MUST NOT Edit/Write directly; the probe returns `canDoInSession: false`
+ * with `blockers: ["requires-sub-agent-dispatch"]` to force
+ * `peaks sub-agent dispatch rd`. The hook (`pre-tool-code-gate.sh`)
+ * enforces the same deny at the PreToolUse layer.
+ *
+ * The allow-list (.peaks/**, .peaks/_runtime/**, skill files, docs/**)
+ * is checked by the hook, NOT by this probe — the probe is content-side
+ * (slice-spec text) and the hook is file-side (resolved path on Edit/Write).
+ */
+export declare const HARD_BLOCKED_PATH_FAMILIES: readonly string[];
 /** Decision-marker keywords that signal "needs user AskUserQuestion". */
 export declare const DECISION_KEYWORDS: readonly string[];
 export interface ContextProbe {
@@ -67,6 +80,8 @@ export interface OrchestratorCanDoResult {
     readonly subAgentAvailable: boolean;
     /** Diagnostic — which of the 4 boundary questions fired. */
     readonly q1SourceCodeTouched: boolean;
+    /** Slice 2026-08-06-codegate-vendor-neutral: did the slice-spec mention a hard-blocked path family (src/, tests/unit/, ...)? When true the probe refuses direct execution. */
+    readonly q1HardBlockedPath: boolean;
     readonly q2SubAgentAvailable: boolean;
     readonly q3RequiresUserDecision: boolean;
     readonly q4ContextRatio: number;
@@ -80,6 +95,14 @@ export declare class OrchestratorCanDoError extends Error {
  * the slice-spec string. Case-insensitive substring match.
  */
 export declare function detectSourceCodeTouched(sliceSpec: string): boolean;
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — does the slice-spec mention
+ * any hard-blocked path family? Pure substring match. When true, the
+ * probe returns `canDoInSession: false` with `requires-sub-agent-dispatch`.
+ * This is the LLM-side complement to the `pre-tool-code-gate.sh` hook
+ * (which checks the actual Edit/Write/MultiEdit target path).
+ */
+export declare function detectHardBlockedPath(sliceSpec: string): boolean;
 /**
  * Q3: does the slice require user decisions? Pure keyword scan
  * over the slice-spec string.
@@ -103,6 +126,7 @@ export declare function probeContextRatio(projectRoot: string, peaksBin?: string
  */
 export declare function buildOrchestratorCanDoResult(input: OrchestratorCanDoInput, signals: {
     q1SourceCodeTouched: boolean;
+    q1HardBlockedPath: boolean;
     q2SubAgentAvailable: boolean;
     q3RequiresUserDecision: boolean;
     q4ContextRatio: number;

package/dist/services/code/orchestrator-can-do.js

@@ -55,6 +55,26 @@ export const SOURCE_CODE_KEYWORDS = [
     '.go',
     '.rs',
 ];
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — hard-blocked path families.
+ * When ANY of these substrings appears in the slice-spec, the orchestrator
+ * MUST NOT Edit/Write directly; the probe returns `canDoInSession: false`
+ * with `blockers: ["requires-sub-agent-dispatch"]` to force
+ * `peaks sub-agent dispatch rd`. The hook (`pre-tool-code-gate.sh`)
+ * enforces the same deny at the PreToolUse layer.
+ *
+ * The allow-list (.peaks/**, .peaks/_runtime/**, skill files, docs/**)
+ * is checked by the hook, NOT by this probe — the probe is content-side
+ * (slice-spec text) and the hook is file-side (resolved path on Edit/Write).
+ */
+export const HARD_BLOCKED_PATH_FAMILIES = [
+    'src/',
+    'tests/unit/',
+    'tests/integration/',
+    'config/',
+    'bin/',
+    'scripts/',
+];
 /** Decision-marker keywords that signal "needs user AskUserQuestion". */
 export const DECISION_KEYWORDS = [
     'design',
@@ -82,6 +102,17 @@ export function detectSourceCodeTouched(sliceSpec) {
     const lower = sliceSpec.toLowerCase();
     return SOURCE_CODE_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
 }
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — does the slice-spec mention
+ * any hard-blocked path family? Pure substring match. When true, the
+ * probe returns `canDoInSession: false` with `requires-sub-agent-dispatch`.
+ * This is the LLM-side complement to the `pre-tool-code-gate.sh` hook
+ * (which checks the actual Edit/Write/MultiEdit target path).
+ */
+export function detectHardBlockedPath(sliceSpec) {
+    const lower = sliceSpec.toLowerCase();
+    return HARD_BLOCKED_PATH_FAMILIES.some((fam) => lower.includes(fam.toLowerCase()));
+}
 /**
  * Q3: does the slice require user decisions? Pure keyword scan
  * over the slice-spec string.
@@ -135,6 +166,17 @@ export function buildOrchestratorCanDoResult(input, signals) {
     const blockers = [];
     const warnings = [];
     const suggestions = [];
+    // Slice 2026-08-06-codegate-vendor-neutral — Q1 HARD BLOCKER. When
+    // the slice-spec mentions any hard-blocked path family
+    // (src/, tests/unit/, tests/integration/, config/, bin/, scripts/),
+    // the orchestrator MUST refuse direct execution and force sub-agent
+    // dispatch. This is the LLM-side complement to the
+    // `pre-tool-code-gate.sh` PreToolUse hook.
+    if (signals.q1HardBlockedPath) {
+        blockers.push('requires-sub-agent-dispatch: slice-spec mentions a hard-blocked path family ' +
+            '(src/, tests/unit/, tests/integration/, config/, bin/, scripts/); ' +
+            'orchestrator MUST NOT Edit/Write these directly. Use peaks sub-agent dispatch rd.');
+    }
     // Q2 — sub-agent availability is a hard precondition.
     if (!signals.q2SubAgentAvailable) {
         blockers.push('sub-agent dispatch unavailable (peaks sub-agent dispatch --help failed)');
@@ -154,8 +196,9 @@ export function buildOrchestratorCanDoResult(input, signals) {
     if (signals.q3RequiresUserDecision) {
         warnings.push('slice-spec contains decision keywords; AskUserQuestion before proceeding');
     }
-    // Q1 — source-code touched is NOT a blocker. The orchestrator
-    // delegates via sub-agent dispatch.
+    // Q1 (soft) — source-code touched is a sub-agent-dispatch hint. When
+    // not already hard-blocked (above), surface the dispatch verb. When
+    // already hard-blocked the blocker line carries the same instruction.
     if (signals.q1SourceCodeTouched && signals.q2SubAgentAvailable) {
         const batchId = randomUUID();
         const rid = 'rid-' + Date.now().toString(36);
@@ -175,6 +218,7 @@ export function buildOrchestratorCanDoResult(input, signals) {
         contextRatio: signals.q4ContextRatio,
         subAgentAvailable: signals.q2SubAgentAvailable,
         q1SourceCodeTouched: signals.q1SourceCodeTouched,
+        q1HardBlockedPath: signals.q1HardBlockedPath,
         q2SubAgentAvailable: signals.q2SubAgentAvailable,
         q3RequiresUserDecision: signals.q3RequiresUserDecision,
         q4ContextRatio: signals.q4ContextRatio,
@@ -189,6 +233,7 @@ export async function evaluateOrchestratorCanDo(input) {
         throw new OrchestratorCanDoError('--slice-spec is required', 'MISSING_SLICE_SPEC');
     }
     const q1SourceCodeTouched = detectSourceCodeTouched(input.sliceSpec);
+    const q1HardBlockedPath = detectHardBlockedPath(input.sliceSpec);
     const q3RequiresUserDecision = detectRequiresUserDecision(input.sliceSpec);
     const probeSubAgent = input.probeSubAgentAvailable ?? (() => probeSubAgentAvailable(input.projectRoot));
     const probeContext = input.probeContextRatio ?? (() => probeContextRatio(input.projectRoot));
@@ -198,6 +243,7 @@ export async function evaluateOrchestratorCanDo(input) {
     ]);
     return buildOrchestratorCanDoResult(input, {
         q1SourceCodeTouched,
+        q1HardBlockedPath,
         q2SubAgentAvailable: subAgentAvailable,
         q3RequiresUserDecision,
         q4ContextRatio: ctxProbe.ratio,

package/dist/services/code/post-compact-detector.d.ts

@@ -21,7 +21,7 @@
  * IO: readdir + readFile on `.peaks/_runtime/<sid>/checkpoints/`.
  * No writes (caller logs the decision via the auto-decisions channel).
  */
-import type { SkillPresenceMode } from '../skills/skill-presence-service.js';
+import { type SkillPresenceMode } from '../skills/skill-presence-service.js';
 import { type CodeMode } from './mode-gate.js';
 export type PostCompactResumeReason = 'post-compact-match' | 'sid-unbound' | 'runtime-dir-missing' | 'no-checkpoint-today' | 'no-mode-field' | 'stale-checkpoint' | 'multiple-checkpoints-ambiguous' | 'active-skill-mismatch' | 'checkpoint-read-failed';
 export declare const POST_COMPACT_RESUME_REASONS: readonly PostCompactResumeReason[];

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

@@ -5,10 +5,7 @@
  * `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.
+ * ECC is the in-skill agent option and the production Gate B3 path.
  *
  * === Why a bridge (not a direct swap) ===
  *
@@ -54,9 +51,7 @@ export interface EccEnvelope {
     readonly gateAction: EccGateAction;
 }
 /**
- * 5-state detect result — mirrors `ocr-service.ts` `OcrDetectState`
- * (ready / package-missing / binary-missing / config-missing /
- * detection-failed). ECC's analogue:
+ * 5-state ECC detection result:
  *   - `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

package/dist/services/compact-statusline/compact-statusline-service.js

@@ -56,17 +56,24 @@ const DEFAULT_STALE_AFTER_MS = 120_000;
 export const COMPLETED_EXPIRY_MS = 10_000;
 /** Legacy mtime window for the "just compacted" indicator. */
 const LEGACY_JUST_COMPACTED_WINDOW_MS = 30_000;
+// PRD-002b slice 2 — extract cell-table magic numbers (4/6/8) into named
+// consts so the no-magic-numbers lint rule stops flagging the typed
+// literal-union cell-table values. Values match the documented contract.
+const STAGE_CELL_COMPACTING = 4;
+const STAGE_CELL_VERIFYING = 6;
+const STAGE_CELL_COMPLETED = 8;
+/* eslint-disable no-magic-numbers -- cell-table contract uses literal-type unions (`0 | 2 | 4 | 6 | 8`); these are type-position discriminators, not runtime values. Magic-number extraction is done at the runtime call sites via STAGE_CELL_* constants above. */
 const CELL_BY_STAGE = new Map([
     ['queued', 0],
     ['preparing', 2],
-    ['compacting', 4],
-    ['verifying', 6],
-    ['completed', 8],
-    ['failed', 4],
+    ['compacting', STAGE_CELL_COMPACTING],
+    ['verifying', STAGE_CELL_VERIFYING],
+    ['completed', STAGE_CELL_COMPLETED],
+    ['failed', STAGE_CELL_COMPACTING],
 ]);
 const FILLED = '█';
 const EMPTY = '░';
-const BAR_WIDTH = 8;
+const BAR_WIDTH = STAGE_CELL_COMPLETED;
 const NO_AFTER_RATIO_HINT = 'after-ratio not recorded';
 function renderBar(filledCells) {
     return `[${FILLED.repeat(filledCells)}${EMPTY.repeat(BAR_WIDTH - filledCells)}]`;
@@ -74,6 +81,7 @@ function renderBar(filledCells) {
 function renderLegacyBar(filledCells) {
     return renderBar(filledCells);
 }
+/* eslint-enable no-magic-numbers */
 export function decideCompactStatusline(input) {
     const staleAfterMs = input.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
     const completedExpiryMs = input.completedExpiryMs ?? COMPLETED_EXPIRY_MS;
@@ -137,7 +145,7 @@ function stateFromLifecycle(record) {
         const failedAt = record.failedAt ?? 'compacting';
         const state = {
             kind: 'failed',
-            filledCells: CELL_BY_STAGE.get(failedAt) ?? 4,
+            filledCells: CELL_BY_STAGE.get(failedAt) ?? STAGE_CELL_COMPACTING,
             triggerRatio: record.triggerRatio,
             redLine: record.redLine,
             failedAt,
@@ -160,7 +168,7 @@ function stateFromLifecycle(record) {
     return base;
 }
 function stateFromStalled(record) {
-    const filledCells = CELL_BY_STAGE.get(record.stage) ?? 4;
+    const filledCells = CELL_BY_STAGE.get(record.stage) ?? STAGE_CELL_COMPACTING;
     const detailText = record.stage === 'failed'
         ? record.errorSummary
         : `no heartbeat for ${record.stage} stage`;
@@ -236,9 +244,9 @@ export function renderCompactStatusline(state) {
         case 'preparing':
             return `compact ${renderBar(2)}`;
         case 'compacting':
-            return `compact ${renderBar(4)}`;
+            return `compact ${renderBar(STAGE_CELL_COMPACTING)}`;
         case 'verifying':
-            return `compact ${renderBar(6)}`;
+            return `compact ${renderBar(STAGE_CELL_VERIFYING)}`;
         case 'completed':
             return formatCompleted(state);
         case 'failed':
@@ -250,7 +258,7 @@ export function renderCompactStatusline(state) {
     }
 }
 function formatCompleted(state) {
-    const bar = renderBar(8);
+    const bar = renderBar(STAGE_CELL_COMPLETED);
     if (typeof state.afterRatio === 'number') {
         return `compact ${bar} → ${state.afterRatio.toFixed(2)}`;
     }
@@ -258,7 +266,7 @@ function formatCompleted(state) {
 }
 function formatFailed(state) {
     const filledAt = state.failedAt ?? 'compacting';
-    const cells = CELL_BY_STAGE.get(filledAt) ?? 4;
+    const cells = CELL_BY_STAGE.get(filledAt) ?? STAGE_CELL_COMPACTING;
     const bar = renderBar(cells);
     const detail = state.detail ? ` — ${state.detail}` : '';
     return `compact ${bar} failed at ${filledAt}${detail}`;

package/dist/services/config/config-service.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigGetOptions, ConfigLayer, ConfigSetOptions, ConfigV2, OcrAuthHeader, OcrConfig, OcrLlmConfig, PeaksConfig, TokenRef, WorkspaceConfig } from './config-types.js';
+import { type ConfigGetOptions, type ConfigLayer, type ConfigSetOptions, type ConfigV2, type PeaksConfig, type TokenRef, type WorkspaceConfig } from './config-types.js';
 export { resolveProjectRootForConfig, resolveCanonicalProjectRoot } from './config-safety.js';
 /**
  * Load the slim 2.0 `~/.peaks/config.json` file. Returns the parsed
@@ -22,23 +22,6 @@ export type RedactedConfigValue = string | number | boolean | null | RedactedCon
     [key: string]: RedactedConfigValue;
 };
 export declare function redactConfigSecrets(value: unknown, path?: string): RedactedConfigValue;
-/**
- * Read the ocr LLM endpoint config from the user-layer
- * `~/.peaks/config.json`. The user populates this themselves by
- * pasting the `peaks code-review config-template` output (or by
- * running `peaks config set --key ocr.llm.url --value '...'`).
- * peaks-loop never auto-writes these values.
- */
-export declare function getOcrConfig(): OcrConfig;
-/**
- * Return the resolved `OcrLlmConfig` block (`peaksConfig.ocr.llm`)
- * or `null` when the user has not populated the user config. The
- * 5-state OCR detector uses this as the source of truth; when the
- * returned block is missing required fields it produces a
- * `config-missing` state with a templated `nextActions` payload
- * the user can paste into their config.
- */
-export declare function getOcrLlmConfig(): OcrLlmConfig | null;
 export declare function bootstrapProjectLanguageConfig(projectRoot: string, language: string): void;
 export declare function readConfig(projectRoot?: string | null): PeaksConfig;
 export declare function writeConfig(partial: Partial<PeaksConfig>, layer?: ConfigLayer): void;
@@ -53,6 +36,6 @@ export declare function getWorkspaceConfigForPath(path?: string): WorkspaceConfi
 export declare function ensureWorkspaceConfigForPath(path?: string): WorkspaceConfig | null;
 export declare function getWorkspaceConfigForCurrentPath(): WorkspaceConfig | null;
 export declare function ensureWorkspaceConfigForCurrentPath(): WorkspaceConfig | null;
-export type { OcrAuthHeader, OcrConfig, OcrLlmConfig, TokenRef, WorkspaceConfig, PeaksConfig, ConfigLayer };
+export type { TokenRef, WorkspaceConfig, PeaksConfig, ConfigLayer };
 export { getUserConfigPath } from './config-safety.js';
 export { globalConfigPath } from './config-migration.js';

package/dist/services/config/config-service.js

@@ -1,12 +1,10 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { dirname, isAbsolute, resolve } from 'node:path';
-import { DEFAULT_CONFIG } from './config-types.js';
+import { DEFAULT_CONFIG, isConfigV2 } from './config-types.js';
 import { stablePath } from '../../shared/path-utils.js';
 import { findProjectRoot, getProjectBootstrapConfigPath, getProjectConfigPath, getUserConfigPath, isInsidePath, readConfigFileSafely, resolveProjectRootForConfig, validateArtifactWorkspaceMarkerPath, validateArtifactWorkspaceRoot, validateProjectBootstrapConfigPathForWrite, validateUserConfigPathForWrite, writeConfigFileSafely, writeProjectConfigFile, writeUserConfigFile } from './config-safety.js';
 import { globalConfigPath, CONFIG_SCHEMA_VERSION_V2 } from './config-migration.js';
-import { isConfigV2 } from './config-types.js';
-import { providersConfigPath, proxyConfigPath, readSidecarJson, sidecarExists, workspacesConfigPath, writeSidecarJson } from './sidecar-store.js';
-import { SIDECAR_SCHEMA_VERSION } from './sidecar-store.js';
+import { SIDECAR_SCHEMA_VERSION, providersConfigPath, proxyConfigPath, readSidecarJson, sidecarExists, workspacesConfigPath, writeSidecarJson } from './sidecar-store.js';
 // Re-export resolveProjectRootForConfig and resolveCanonicalProjectRoot for external consumers
 export { resolveProjectRootForConfig, resolveCanonicalProjectRoot } from './config-safety.js';
 /**
@@ -412,58 +410,6 @@ export function redactConfigSecrets(value, path = '') {
         return [key, redactConfigSecrets(entry, nextPath)];
     }));
 }
-const OCR_AUTH_HEADERS = new Set(['authorization', 'x-api-key', 'bearer']);
-function toOcrLlmConfig(value) {
-    if (!isRecord(value))
-        return {};
-    const url = typeof value.url === 'string' && value.url.trim().length > 0 ? value.url.trim() : undefined;
-    const authToken = typeof value.authToken === 'string' && value.authToken.length > 0 ? value.authToken : undefined;
-    const model = typeof value.model === 'string' && value.model.trim().length > 0 ? value.model.trim() : undefined;
-    const useAnthropic = typeof value.useAnthropic === 'boolean' ? value.useAnthropic : undefined;
-    const rawAuthHeader = typeof value.authHeader === 'string' ? value.authHeader : undefined;
-    const authHeader = rawAuthHeader !== undefined && OCR_AUTH_HEADERS.has(rawAuthHeader)
-        ? rawAuthHeader
-        : undefined;
-    return {
-        ...(url !== undefined ? { url } : {}),
-        ...(authToken !== undefined ? { authToken } : {}),
-        ...(model !== undefined ? { model } : {}),
-        ...(useAnthropic !== undefined ? { useAnthropic } : {}),
-        ...(authHeader !== undefined ? { authHeader } : {})
-    };
-}
-function toOcrConfig(value) {
-    if (!isRecord(value))
-        return {};
-    return {
-        ...(isRecord(value.llm) ? { llm: toOcrLlmConfig(value.llm) } : {})
-    };
-}
-/**
- * Read the ocr LLM endpoint config from the user-layer
- * `~/.peaks/config.json`. The user populates this themselves by
- * pasting the `peaks code-review config-template` output (or by
- * running `peaks config set --key ocr.llm.url --value '...'`).
- * peaks-loop never auto-writes these values.
- */
-export function getOcrConfig() {
-    const userConfig = readUserJsonFile() ?? {};
-    return toOcrConfig(userConfig.ocr);
-}
-/**
- * Return the resolved `OcrLlmConfig` block (`peaksConfig.ocr.llm`)
- * or `null` when the user has not populated the user config. The
- * 5-state OCR detector uses this as the source of truth; when the
- * returned block is missing required fields it produces a
- * `config-missing` state with a templated `nextActions` payload
- * the user can paste into their config.
- */
-export function getOcrLlmConfig() {
-    const ocr = getOcrConfig();
-    if (!ocr.llm)
-        return null;
-    return ocr.llm;
-}
 function inferHumanLanguage(value) {
     const normalized = value.trim();
     if (!normalized) {

package/dist/services/config/config-types.d.ts

@@ -47,38 +47,18 @@ export type WorkspaceConfig = {
     artifactStorage?: ArtifactStorageConfig;
     installedCapabilityIds: string[];
 };
-export type OcrAuthHeader = 'authorization' | 'x-api-key' | 'bearer';
-export type OcrLlmConfig = {
-    url?: string;
-    authToken?: string;
-    model?: string;
-    useAnthropic?: boolean;
-    authHeader?: OcrAuthHeader;
-};
-export type OcrConfig = {
-    llm?: OcrLlmConfig;
-};
 /**
- * 2.0.1 slim `~/.peaks/config.json` schema. The on-disk file holds
- * ONLY `version` + `ocr.llm.*` placeholders. All other settings
- * (providers, proxy, workspaces, language/model/economy/swarm
- * toggles) live in sidecar files under the same `~/.peaks/`
- * directory or in per-project `preferences.json`.
- *
- * The slim shape is enforced on disk by `loadGlobalConfig`; any
- * unknown field on read is silently stripped and the file is
- * rewritten with the slim shape, so a hand-written or partially-
- * migrated file cannot grow stale fields.
+ * 2.0.1 slim `~/.peaks/config.json` schema. Runtime settings live in
+ * sidecar files under the same `~/.peaks/` directory or in per-project
+ * `preferences.json`.
  *
  * NOTE: legacy fields below are kept on the type as `@deprecated`
  * so existing consumers (`config-service.ts`, `workflow-commands.ts`,
  * etc.) continue to compile during the migration window. They are
- * written to / read from sidecar files at runtime; the slim
- * `~/.peaks/config.json` only persists `version` + `ocr`.
+ * written to / read from sidecar files at runtime.
  */
 export type PeaksConfig = {
     version: string;
-    ocr?: OcrConfig;
     /** @deprecated Moved to `~/.peaks/providers.json` (provider-service.ts) */
     providers?: ModelProviderConfig;
     /** @deprecated Moved to `~/.peaks/proxy.json` (proxy-service.ts) */