peaks-loop 4.0.54 → 4.1.0

package/dist/services/dispatch/sub-agent-dispatcher.js

@@ -27,13 +27,8 @@
  * Cross-reference: PRD #002 G1 (AC-1..AC-5); RD tech-doc-002 §2.
  */
 import { existsSync, readFileSync } from 'node:fs';
-// Slice 2026-07-29-dispatch-stall-governance / S4 — the two near-
-// identical poll loops in this file are now thin wrappers around
-// `awaitBatch` (the unified implementation in ./await-batch.ts). The
-// back-compat envelopes are preserved so the pre-S4 S3 character-
-// ization tests + the existing call sites do not have to migrate in
-// the same slice.
-import { awaitBatch as awaitBatchUnified } from './await-batch.js';
+import { awaitClaudeCodeBatch, pollDispatchRecords } from './sub-agent-batch-await.js';
+export { awaitClaudeCodeBatch, pollDispatchRecords } from './sub-agent-batch-await.js';
 /**
  * Claude Code dispatcher. Real, byte-level implementation.
  *
@@ -51,18 +46,18 @@ export const claudeCodeSubAgentDispatcher = {
         args: {
             subagent_type: 'general-purpose',
             description: `${role} for rid=${requestId}`,
-            prompt,
+            prompt
         },
         // Slice 2026-06-23-audit-4th #C2: stamp the IDE-arg shape
         // version. When Claude Code changes the Task args shape (e.g.
         // a new subagent_type value), bump this and the dispatch record
         // propagates it so a future reader can detect a stale record.
-        toolCallVersion: '2.0.0',
+        toolCallVersion: '2.0.0'
     }),
     // 2.7.0 slice-dag-dispatcher MVP: real join barrier for claude-code.
     // The MVP harness uses an in-process promise queue keyed by batchId.
     // (1.2 阶段进程内 hold 即可;1.3 / 1.4 阶段若多进程 sub-agent 走共享文件 / heartbeat 轮询。)
-    awaitBatch: async (input) => awaitClaudeCodeBatch(input),
+    awaitBatch: async (input) => awaitClaudeCodeBatch(input)
 };
 /**
  * Trae dispatcher. UNVERIFIED — Trae sub-agent tool name TBD on real
@@ -92,9 +87,9 @@ export const traeSubAgentDispatcher = {
         args: {
             subagent_type: 'general-purpose',
             description: `${role} for rid=${requestId}`,
-            prompt,
+            prompt
         },
-        toolCallVersion: '2.0.0',
+        toolCallVersion: '2.0.0'
     }),
     // 2.7.0 slice-dag-dispatcher (slice 1.3): real file-polling awaitBatch
     // for Trae. Per-IDE wrapper around `pollDispatchRecords` with the
@@ -123,9 +118,9 @@ export const codexSubAgentDispatcher = {
         args: {
             subagent_type: 'general-purpose',
             description: `${role} for rid=${requestId}`,
-            prompt,
+            prompt
         },
-        toolCallVersion: '2.0.0',
+        toolCallVersion: '2.0.0'
     }),
     awaitBatch: async (input) => pollDispatchRecords(input, {
         defaultTimeoutMs: 45_000,
@@ -148,9 +143,9 @@ export const cursorSubAgentDispatcher = {
         args: {
             subagent_type: 'general-purpose',
             description: `${role} for rid=${requestId}`,
-            prompt,
+            prompt
         },
-        toolCallVersion: '2.0.0',
+        toolCallVersion: '2.0.0'
     }),
     awaitBatch: async (input) => pollDispatchRecords(input, {
         defaultTimeoutMs: 30_000,
@@ -173,7 +168,7 @@ export const nullSubAgentDispatcher = {
     // 2.7.0 slice-dag-dispatcher MVP: null dispatcher never supports await either.
     awaitBatch: async ({ batchId }) => {
         throw new SubAgentNotSupportedError(`awaitBatch on batch ${batchId}`);
-    },
+    }
 };
 /**
  * Thrown by `nullSubAgentDispatcher.buildToolCall` and any future
@@ -189,50 +184,12 @@ export class SubAgentNotSupportedError extends Error {
         this.name = 'SubAgentNotSupportedError';
     }
 }
-/* ──────────────────────────────────────────────────────────────────────────
- * 2.7.0 slice-dag-dispatcher MVP (slice 1.2.a) — awaitBatch implementation
- * ────────────────────────────────────────────────────────────────────────── */
 /**
  * In-process LRU promise queue for claude-code. Keyed by batchId.
  * Populated by `awaitClaudeCodeBatch` callers; consumed by the same.
  * MVP-scope only: 1.3 / 1.4 may replace with cross-process heartbeat polling.
  */
 const claudeCodeBatchAwaiters = new Map();
-/**
- * Real awaitBatch for claude-code (MVP). In 1.2, dispatch + await are
- * both in the same process; we record the batch size and resolve after
- * `dispatchCount` heartbeats land for the given `recordPaths`, or after
- * `timeoutMs` elapses (per-dispatch `timeout` status).
- *
- * Implementation contract (MVP):
- *  - We poll each `recordPaths[i]` for an `outcome: success | failed` or
- *    `status: done | failed` field; if absent after `timeoutMs`, that
- *    dispatch is reported as `timeout`.
- *  - The poll interval is 50ms (fast enough for unit tests, cheap enough
- *    for the MVP; the real cross-process version uses heartbeat polling).
- */
-export async function awaitClaudeCodeBatch(input) {
-    // Slice 2026-07-29-dispatch-stall-governance / S4 (G8) — this
-    // function is now a thin wrapper around the unified `awaitBatch`
-    // service. The back-compat envelope shape is preserved (one
-    // `SubAgentBatchResult` per record path) so the S3 characterization
-    // test stays green; the underlying loop is identical to the trae /
-    // codex / cursor wrappers below. The new typed outcome
-    // lives on the unified service; the S4 fail-fast test pins it.
-    //
-    // Slice 2026-07-30-nightshift: claude-code does NOT use a
-    // per-IDE note prefix. The 1.4 dogfood contract says the done
-    // note is `null` (raw outcome) and the failed note is the raw
-    // `outcome` string with no prefix. The 3 non-Claude IDEs
-    // (trae / codex / cursor) prefix the note with their
-    // per-IDE label so cross-IDE attribution is visible to the LLM.
-    // Passing no `notePrefix` here keeps the legacy contract.
-    const unified = await awaitBatchUnified(input.dispatchCount, input.recordPaths, input.timeoutMs, { defaultTimeoutMs: 60_000 });
-    // Touch batchId so the parameter remains in scope for any future
-    // in-process queue wiring.
-    void input.batchId;
-    return unified.results;
-}
 /** Best-effort outcome read for a dispatch record. Returns null if pending. */
 function readDispatchOutcome(recordPath) {
     if (!recordPath)
@@ -253,24 +210,11 @@ function readDispatchOutcome(recordPath) {
             return { status: 'timeout', note: 'stale' };
         return null;
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }
-export async function pollDispatchRecords(input, opts) {
-    // Slice 2026-07-29-dispatch-stall-governance / S4 (G8) — this
-    // function is now a thin wrapper around the unified `awaitBatch`
-    // service. Pre-S4 it diverged from `awaitClaudeCodeBatch` in
-    // (a) the default-fallback source and (b) the `Math.max(deadline, 0)`
-    // step; the divergence is gone. The back-compat envelope (one
-    // `SubAgentBatchResult` per record path, with the IDE-prefixed
-    // note) is preserved.
-    const unified = await awaitBatchUnified(input.dispatchCount, input.recordPaths, input.timeoutMs, {
-        defaultTimeoutMs: opts.defaultTimeoutMs,
-        notePrefix: opts.notePrefix
-    });
-    return unified.results;
-}
 /**
  * In-process awaiter registration hook (used by `peaks sub-agent dispatch`
  * to attach a resolver; not part of the dispatcher public surface).

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

@@ -95,7 +95,18 @@ export function classifyTestCommand(command, env = process.env) {
     // Strip flags (e.g. --config, --reporter, --coverage). A flag is
     // any token starting with `-`. The path we care about is the first
     // non-flag, non-runner, non-keyword token after the runner.
-    const PATH_KEYWORDS = new Set(['run', 'watch', 'test', 'c', 'ci', 'r', 'reporter', 't', 'u', 'coverage']);
+    const PATH_KEYWORDS = new Set([
+        'run',
+        'watch',
+        'test',
+        'c',
+        'ci',
+        'r',
+        'reporter',
+        't',
+        'u',
+        'coverage'
+    ]);
     const pathTokens = [];
     for (const tok of after) {
         if (tok.startsWith('-'))

package/dist/services/doc/doc-generator.js

@@ -36,7 +36,9 @@ export function generateSkillFromCommands(skillName, commandsDir) {
         catch {
             continue;
         }
-        const commands = [...content.matchAll(COMMAND_PATTERN)].map((m) => m[1]).filter((c) => c.length > 0);
+        const commands = [...content.matchAll(COMMAND_PATTERN)]
+            .map((m) => m[1])
+            .filter((c) => c.length > 0);
         const descs = [...content.matchAll(DESC_PATTERN)].map((m) => m[1]);
         for (const cmd of commands) {
             if (!commandMap.has(cmd))
@@ -81,7 +83,11 @@ export function renderSkillMarkdown(doc) {
 export function parseCommitSubject(subject, file) {
     const conventionalMatch = /^(feat|fix|docs|refactor|chore)(?:\([^)]+\))?:\s*(.+)$/i.exec(subject);
     if (conventionalMatch) {
-        return { kind: conventionalMatch[1].toLowerCase(), subject: conventionalMatch[2].trim(), file };
+        return {
+            kind: conventionalMatch[1].toLowerCase(),
+            subject: conventionalMatch[2].trim(),
+            file
+        };
     }
     return { kind: 'chore', subject, file };
 }
@@ -96,7 +102,10 @@ export function gitLogSince(projectRoot, since) {
         });
         if (out.trim().length === 0)
             return [];
-        return out.split('\n').filter((s) => s.length > 0).map((s) => parseCommitSubject(s, 'git log'));
+        return out
+            .split('\n')
+            .filter((s) => s.length > 0)
+            .map((s) => parseCommitSubject(s, 'git log'));
     }
     catch {
         return [];
@@ -106,7 +115,13 @@ export function gitLogSince(projectRoot, since) {
 export function suggestChangelog(entries) {
     if (entries.length === 0)
         return '## [Unreleased]\n\n(no changes since the reference)';
-    const groups = { feat: [], fix: [], docs: [], refactor: [], chore: [] };
+    const groups = {
+        feat: [],
+        fix: [],
+        docs: [],
+        refactor: [],
+        chore: []
+    };
     for (const e of entries)
         groups[e.kind].push(e);
     const lines = ['## [Unreleased]', ''];

package/dist/services/doctor/doctor-service/checks/check-id-schema.js

@@ -20,39 +20,47 @@ import { getErrorMessage } from 'peaks-loop-shared/result';
 function runSelfCheck(schemaRoot, emittedIds) {
     const schemaPath = join(schemaRoot, 'doctor-report.schema.json');
     if (!existsSync(schemaPath)) {
-        return [{
+        return [
+            {
                 id: 'doctor-self:check-id-pattern',
                 ok: false,
                 message: `Failed to load doctor-report.schema.json for self-validation: ${getErrorMessage(new Error(`ENOENT: ${schemaPath}`))}`
-            }];
+            }
+        ];
     }
     try {
         const schemaText = readFileSync(schemaPath, 'utf8');
         const schema = JSON.parse(schemaText);
         const patternSource = schema.properties?.checks?.items?.properties?.id?.pattern;
         if (typeof patternSource !== 'string') {
-            return [{
+            return [
+                {
                     id: 'doctor-self:check-id-pattern',
                     ok: false,
                     message: 'doctor-report.schema.json does not declare a check.id pattern'
-                }];
+                }
+            ];
         }
         const pattern = new RegExp(patternSource);
         const mismatches = emittedIds.filter((id) => !pattern.test(id));
-        return [{
+        return [
+            {
                 id: 'doctor-self:check-id-pattern',
                 ok: mismatches.length === 0,
                 message: mismatches.length === 0
                     ? 'All doctor check IDs match the doctor-report schema pattern'
                     : `Doctor check IDs missing from schema pattern: ${mismatches.join(', ')}`
-            }];
+            }
+        ];
     }
     catch (error) {
-        return [{
+        return [
+            {
                 id: 'doctor-self:check-id-pattern',
                 ok: false,
                 message: `Failed to load doctor-report.schema.json for self-validation: ${getErrorMessage(error)}`
-            }];
+            }
+        ];
     }
 }
 function run({ schemaRoot, accumulatedChecks }) {

package/dist/services/doctor/doctor-service/checks/codegraph-capability.d.ts

@@ -16,5 +16,10 @@
  * `node_modules` resolution; the default probe uses
  * `createRequire(import.meta.url)` to find the package.
  */
-import type { DoctorCheckPlugin } from '../types.js';
-export declare const check: DoctorCheckPlugin;
+import type { DoctorCheck, DoctorContext } from '../types.js';
+declare function run({ options }: DoctorContext): readonly DoctorCheck[];
+export declare const check: {
+    name: string;
+    run: typeof run;
+};
+export {};

package/dist/services/doctor/doctor-service/checks/codegraph-capability.js

@@ -137,32 +137,40 @@ function runCheck(probe, managedPathProbe) {
             // the doctor exit code. Upstream 0.7.x binaries are wire-
             // compatible with 0.7.10 for the subset peaks-loop exercises
             // (status / init / index / query / files / context / affected).
-            return [{
+            return [
+                {
                     id: 'capability:codegraph',
                     ok: false,
                     severity: 'warning',
                     message: `@colbymchenry/codegraph version drift: expected ${CODEGRAPH_EXPECTED_VERSION}, resolved ${result.version} at ${result.packagePath} — peaks-loop uses an allow-list of subcommands and tolerates 0.7.x wire-compat. Run \`pnpm install @colbymchenry/codegraph@${CODEGRAPH_EXPECTED_VERSION}\` to pin.${managedPathSuffix}`
-                }];
+                }
+            ];
         }
         if (!result.binaryExists) {
-            return [{
+            return [
+                {
                     id: 'capability:codegraph',
                     ok: false,
                     message: `@colbymchenry/codegraph@${result.version} resolved at ${result.packagePath} but binary is missing at ${result.binaryPath}${managedPathSuffix}`
-                }];
+                }
+            ];
         }
-        return [{
+        return [
+            {
                 id: 'capability:codegraph',
                 ok: true,
                 message: `@colbymchenry/codegraph@${result.version} resolves with binary at ${result.binaryPath}${managedPathSuffix}`
-            }];
+            }
+        ];
     }
     catch (error) {
-        return [{
+        return [
+            {
                 id: 'capability:codegraph',
                 ok: false,
                 message: `@colbymchenry/codegraph not resolvable: ${getErrorMessage(error)}`
-            }];
+            }
+        ];
     }
 }
 function run({ options }) {
@@ -173,6 +181,16 @@ function run({ options }) {
 function defaultCodegraphManagedPathProbe() {
     return detectManagedCodegraphPath(process.cwd());
 }
+// Slice S3b (rid-s3b-doctor-check-typing): `satisfies` instead of a
+// `: DoctorCheckPlugin` annotation. The annotation widened this object
+// literal to the interface's `run` return type
+// (`readonly DoctorCheck[] | Promise<readonly DoctorCheck[]>`) — an
+// honest union, because three plugins in this directory really are
+// `async`. The widening leaked into every importer and produced 40
+// TS7053 errors at test call sites, where the runtime value is
+// measurably a plain array (this module's `run` is synchronous).
+// `satisfies` keeps the interface check AND the concrete narrow type,
+// so the compile error re-fires if `run` ever becomes async.
 export const check = {
     name: 'codegraph-capability',
     run

package/dist/services/doctor/doctor-service/checks/codegraph-exclude-integrity.js

@@ -70,32 +70,40 @@ function run({ options, resolvedL3Root }) {
         report = probe();
     }
     catch (error) {
-        return [{
+        return [
+            {
                 id: CHECK_ID,
                 ok: false,
                 severity: 'warning',
                 message: `codegraph exclude integrity could not be evaluated: ${getErrorMessage(error)}`
-            }];
+            }
+        ];
     }
     if (report === null) {
-        return [{
+        return [
+            {
                 id: CHECK_ID,
                 ok: true,
                 message: 'codegraph is not initialized in this project (no .codegraph/config.json); the exclude list is not in play yet'
-            }];
+            }
+        ];
     }
     if (!report.gap) {
-        return [{
+        return [
+            {
                 id: CHECK_ID,
                 ok: true,
                 message: `codegraph exclude list drops no tracked source file (${report.trackedSourceCount} tracked source file(s) admitted by include)`
-            }];
+            }
+        ];
     }
-    return [{
+    return [
+        {
             id: CHECK_ID,
             ok: false,
             message: renderGapMessage(report.excludedTrackedCount, report.trackedSourceCount, report.rulesToRemove, report.violations)
-        }];
+        }
+    ];
 }
 export const check = {
     name: 'codegraph-exclude-integrity',

package/dist/services/doctor/doctor-service/checks/codegraph-index-integrity.js

@@ -110,26 +110,32 @@ function run({ options, resolvedL3Root }) {
         report = probe();
     }
     catch (error) {
-        return [{
+        return [
+            {
                 id: CHECK_ID,
                 ok: false,
                 severity: 'warning',
                 message: `codegraph index integrity could not be evaluated: ${getErrorMessage(error)}`
-            }];
+            }
+        ];
     }
     if (report === null) {
-        return [{
+        return [
+            {
                 id: CHECK_ID,
                 ok: true,
                 message: 'codegraph is not initialized in this project (no .codegraph/codegraph.db); there is no index to be incomplete or stale'
-            }];
+            }
+        ];
     }
     if (!report.gap) {
-        return [{
+        return [
+            {
                 id: CHECK_ID,
                 ok: true,
                 message: `codegraph index covers the repository (${report.admittedTrackedCount} extractor-supported tracked file(s) admitted, ${report.indexedFileCount} indexed row(s), none stale)`
-            }];
+            }
+        ];
     }
     const gapMessage = renderGapMessage(report.includeGap, report.admittedTrackedCount, report.trackedSourceCount, report.deadRows, report.indexedFileCount);
     // Option C: advisory by default, blocking on opt-in. `ok: false` in both
@@ -138,12 +144,14 @@ function run({ options, resolvedL3Root }) {
     // path for the switch, so an operator who wants blocking is told how.
     return strict
         ? [{ id: CHECK_ID, ok: false, message: `${gapMessage} ${remediation()}` }]
-        : [{
+        : [
+            {
                 id: CHECK_ID,
                 ok: false,
                 severity: 'warning',
                 message: `${gapMessage} ${remediation()} Advisory: set ${CODEGRAPH_INDEX_STRICT_ENV_VAR}=1 to make this blocking.`
-            }];
+            }
+        ];
 }
 export const check = {
     name: 'codegraph-index-integrity',

package/dist/services/doctor/doctor-service/checks/dist-source-version.js

@@ -43,7 +43,8 @@ function safeRead(reader) {
     try {
         return reader();
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }
@@ -77,31 +78,39 @@ function run({ options, projectRootResolver }) {
     try {
         const result = probe();
         if (!result.distReadable) {
-            return [{
+            return [
+                {
                     id: 'build:dist-version-matches-source',
                     ok: true,
                     message: `dist/ is not present; run \`pnpm build\` to populate dist/shared/version.js (source version ${result.source})`
-                }];
+                }
+            ];
         }
         if (result.match) {
-            return [{
+            return [
+                {
                     id: 'build:dist-version-matches-source',
                     ok: true,
                     message: `dist/shared/version.js ships CLI_VERSION ${result.dist} matching source ${result.source}`
-                }];
+                }
+            ];
         }
-        return [{
+        return [
+            {
                 id: 'build:dist-version-matches-source',
                 ok: false,
                 message: `dist/shared/version.js ships CLI_VERSION ${result.dist} but source ${result.source} is in src/shared/version.ts; run \`pnpm build\` to refresh dist/`
-            }];
+            }
+        ];
     }
     catch (error) {
-        return [{
+        return [
+            {
                 id: 'build:dist-version-matches-source',
                 ok: false,
                 message: `dist version check failed: ${getErrorMessage(error)}`
-            }];
+            }
+        ];
     }
 }
 export const check = {

package/dist/services/doctor/doctor-service/checks/ecc-hooks-schema-drift.js

@@ -143,41 +143,51 @@ function run({ options }) {
     try {
         const { hooksPath, hooks } = probe();
         if (hooksPath === null) {
-            return [{
+            return [
+                {
                     id: CHECK_ID,
                     ok: true,
                     message: 'ECC plugin not installed (no `ecc@*` entry in ~/.claude/plugins/installed_plugins.json); no plugin hook schema drift to report'
-                }];
+                }
+            ];
         }
         if (hooks === null) {
-            return [{
+            return [
+                {
                     id: CHECK_ID,
                     ok: true,
                     message: `No readable ECC plugin hooks.json at ${hooksPath}; no plugin hook schema drift to report`
-                }];
+                }
+            ];
         }
         const finding = findEccHooksSchemaDrift(hooks);
         if (finding.unknownKeyCount === 0) {
-            return [{
+            return [
+                {
                     id: CHECK_ID,
                     ok: true,
                     message: `ECC plugin hooks.json at ${hooksPath} carries only the keys Claude Code accepts (matcher/hooks per matcher group); the startup "unknown keys ... ignored" warning will not appear`
-                }];
+                }
+            ];
         }
         const rootPart = finding.rootKeys.length === 0 ? '' : `at the root: ${finding.rootKeys.join(', ')}; `;
-        return [{
+        return [
+            {
                 id: CHECK_ID,
                 ok: false,
                 severity: 'warning',
                 message: `ECC plugin hooks.json at ${hooksPath} carries ${finding.unknownKeyCount} key(s) that Claude Code's plugin hook schema ignores (${rootPart}on ${finding.entryCount} matcher group(s): ${finding.entryKeys.join(', ')}). Claude Code prints \`ecc: hooks.json: unknown keys ... ignored\` at startup; every hook still loads, so this warning is cosmetic. Source: the third-party ECC plugin (github.com/affaan-m/ECC) ships these keys in every release (v2.2.0 / v2.2.1 / main) — peaks-loop does NOT write this file. Fix: none inside peaks-loop; upstream ECC must drop them from its hooks/hooks.json (its scripts/ci/validate-hooks.js validates shape only, never a key allow-list, so ECC's own CI stays green). Upgrading ECC will not help.`
-            }];
+            }
+        ];
     }
     catch (error) {
-        return [{
+        return [
+            {
                 id: CHECK_ID,
                 ok: true,
                 message: `ECC hooks schema-drift probe failed (${getErrorMessage(error)}); skipping check`
-            }];
+            }
+        ];
     }
 }
 export const check = {

package/dist/services/doctor/doctor-service/checks/gateguard-conflict.js

@@ -95,7 +95,8 @@ function readSettingsJson(path) {
     try {
         return JSON.parse(readFileSync(path, 'utf8'));
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }
@@ -128,34 +129,42 @@ function run({ options, projectRootResolver }) {
         const probe = gateguardProbe();
         const offending = collectGateguardEntries(probe);
         if (offending.length === 0) {
-            return [{
+            return [
+                {
                     id: 'integration:gateguard-peaks-conflict',
                     ok: true,
                     message: 'No gateguard-fact-force PreToolUse hook detected in ~/.claude/settings.json or project .claude/settings.json; the Edit/Write fact-forcing flow will not interfere with peaks-qa .peaks/ artifact writes'
-                }];
+                }
+            ];
         }
         const unrouted = offending.filter((location) => !entrySkipsPeaks(location.entry));
         if (unrouted.length === 0) {
-            return [{
+            return [
+                {
                     id: 'integration:gateguard-peaks-conflict',
                     ok: true,
                     message: `gateguard-fact-force hook is installed in ${offending.map((l) => l.source).join(' + ')} but a .peaks/** skip pattern is configured; peaks-qa .peaks/ artifact writes are not blocked`
-                }];
+                }
+            ];
         }
         const sources = Array.from(new Set(unrouted.map((u) => u.sourcePath))).join(' + ');
         const matchers = unrouted.map((u) => u.entry.matcher ?? '*').join(', ');
-        return [{
+        return [
+            {
                 id: 'integration:gateguard-peaks-conflict',
                 ok: false,
                 message: `gateguard-fact-force PreToolUse hook is installed (${sources}, matcher: ${matchers}) with no .peaks/** skip pattern; every Edit/Write of a peaks-qa envelope (.peaks/_runtime/<sid>/qa/requests/*.md) will be intercepted and demand a 4-fact questionnaire that does not apply to QA templates. Workaround: set \`ECC_DISABLED_HOOKS=pre:edit-write:gateguard-fact-force\` for the session, OR add a paired PreToolUse entry whose matcher restricts the hook to non-.peaks paths. peaks-loop is NOT the source of this hook.`
-            }];
+            }
+        ];
     }
     catch (error) {
-        return [{
+        return [
+            {
                 id: 'integration:gateguard-peaks-conflict',
                 ok: true,
                 message: `gateguard probe failed (${getErrorMessage(error)}); skipping check`
-            }];
+            }
+        ];
     }
 }
 export const check = {