peaks-loop 4.0.54 → 4.1.1

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 = {

package/dist/services/doctor/doctor-service/checks/l3-memory-health.js

@@ -47,8 +47,12 @@ function previewNames(names) {
 }
 function readIndexSourcePaths(indexPath) {
     const parsed = JSON.parse(readFileSync(indexPath, 'utf8'));
-    const fromBucket = (bucket) => Object.values(bucket ?? {}).flatMap((arr) => (Array.isArray(arr) ? arr : []));
-    return [...fromBucket(parsed.hot), ...fromBucket(parsed.warm), ...(parsed.cold ?? [])];
+    const fromBucket = (bucket) => Object.values(bucket ?? {}).flatMap((arr) => Array.isArray(arr) ? arr : []);
+    return [
+        ...fromBucket(parsed.hot),
+        ...fromBucket(parsed.warm),
+        ...(parsed.cold ?? [])
+    ];
 }
 function inspectDrift(memoryDir, memoryIndexPath, indexedCount) {
     const checks = [];
@@ -75,7 +79,9 @@ function inspectDrift(memoryDir, memoryIndexPath, indexedCount) {
     }
     // --- orphans (both directions) ---------------------------------------
     const missingSources = readIndexSourcePaths(memoryIndexPath)
-        .filter((entry) => typeof entry.sourcePath !== 'string' || entry.sourcePath.length === 0 || !existsSync(entry.sourcePath))
+        .filter((entry) => typeof entry.sourcePath !== 'string' ||
+        entry.sourcePath.length === 0 ||
+        !existsSync(entry.sourcePath))
         .map((entry) => entry.name ?? entry.sourcePath ?? '<unnamed>')
         .sort((left, right) => left.localeCompare(right));
     if (missingSources.length > 0) {
@@ -127,11 +133,13 @@ function run({ resolvedL3Root }) {
     const memoryDir = join(resolvedL3Root, '.peaks/memory');
     const memoryIndexPath = join(memoryDir, 'index.json');
     if (!existsSync(memoryIndexPath)) {
-        return [{
+        return [
+            {
                 id: 'L3:l3-memory-health',
                 ok: true,
                 message: 'No .peaks/memory/index.json yet (no memories extracted)'
-            }];
+            }
+        ];
     }
     let parsed;
     try {
@@ -139,27 +147,33 @@ function run({ resolvedL3Root }) {
         parsed = JSON.parse(raw);
     }
     catch (parseError) {
-        return [{
+        return [
+            {
                 id: 'L3:l3-memory-health',
                 ok: false,
                 message: `.peaks/memory/index.json is not valid JSON: ${getErrorMessage(parseError)}`
-            }];
+            }
+        ];
     }
     const schemaMarker = parsed.schema_version ?? parsed.version;
     if (schemaMarker === undefined) {
-        return [{
+        return [
+            {
                 id: 'L3:l3-memory-health',
                 ok: false,
                 message: '.peaks/memory/index.json missing schema_version / version field'
-            }];
+            }
+        ];
     }
     const hotCount = countEntries(parsed.hot);
     const warmCount = countEntries(parsed.warm);
-    const checks = [{
+    const checks = [
+        {
             id: 'L3:l3-memory-health',
             ok: true,
             message: `.peaks/memory/index.json is well-formed JSON; version=${schemaMarker}; ${hotCount} hot + ${warmCount} warm memory entries`
-        }];
+        }
+    ];
     // Drift inspection is best-effort: a scan failure must not turn a
     // well-formed index into a hard failure.
     try {

package/dist/services/doctor/doctor-service/checks/l3-orphan-sessions.js

@@ -32,11 +32,13 @@ function run({ resolvedL3Root, isValidSessionId }) {
     try {
         const runtimeDir = join(resolvedL3Root, '.peaks/_runtime');
         if (!existsSync(runtimeDir)) {
-            return [{
+            return [
+                {
                     id: 'L3:l3-orphan-sessions',
                     ok: true,
                     message: 'No .peaks/_runtime/ directory; nothing to check.'
-                }];
+                }
+            ];
         }
         const entries = readdirSync(runtimeDir, { withFileTypes: true })
             .filter((e) => e.isDirectory())
@@ -44,20 +46,24 @@ function run({ resolvedL3Root, isValidSessionId }) {
             .filter((name) => !RUNTIME_SYSTEM_SUBDIRS.has(name));
         const validSids = entries.filter((sid) => isValidSessionId(sid));
         const invalidSids = entries.filter((sid) => !isValidSessionId(sid));
-        return [{
+        return [
+            {
                 id: 'L3:l3-orphan-sessions',
                 ok: invalidSids.length === 0,
                 message: invalidSids.length === 0
                     ? `All ${validSids.length} session(s) under .peaks/_runtime/ are valid (isValidSessionId)`
                     : `${invalidSids.length} orphan session(s) under .peaks/_runtime/ fail isValidSessionId: ${invalidSids.slice(0, 5).join(', ')}${invalidSids.length > 5 ? '...' : ''}. Run \`peaks workspace clean --project <repo>\` to archive.`
-            }];
+            }
+        ];
     }
     catch (error) {
-        return [{
+        return [
+            {
                 id: 'L3:l3-orphan-sessions',
                 ok: true,
                 message: `L3:l3-orphan-sessions probe failed (${getErrorMessage(error)}); skipping check`
-            }];
+            }
+        ];
     }
 }
 export const check = {

package/dist/services/doctor/doctor-service/checks/multi-binary-drift.d.ts

@@ -27,21 +27,8 @@
  * `realpathSync`. Every probe call is wrapped in try/catch (read-only,
  * must not throw across the doctor boundary).
  */
-import type { DoctorCheckPlugin, MultiBinaryDriftInspection } from '../types.js';
-/**
- * Local record shape — same as the canonical
- * `MultiBinaryDriftInspection.binaries[number]`. Re-declared so the
- * helper signature carries the concrete shape (the canonical
- * `MultiBinaryDriftInspection` widens `version` + `installDate` to
- * `string | null` so external consumers do not depend on the
- * field being nullable).
- */
-export type PeaksBinaryRecord = {
-    readonly path: string;
-    readonly version: string | null;
-    readonly installDate: string | null;
-    readonly realpath: string;
-};
+import type { DoctorCheck, DoctorContext, MultiBinaryDriftInspection } from '../types.js';
+export type { PeaksBinaryRecord } from '../multi-binary-drift-helpers.js';
 /**
  * Pure helper. Inspects `process.env.PATH` (or the injected
  * `pathEnv`) for `peaks-loop` binaries. Each found binary is walked
@@ -58,4 +45,8 @@ export declare function inspectMultiBinaryDrift(opts?: {
     binaryRealpath?: (candidate: string) => string;
     packageJsonReader?: (path: string) => Buffer | string | null;
 }): MultiBinaryDriftInspection;
-export declare const check: DoctorCheckPlugin;
+declare function run({ options }: DoctorContext): readonly DoctorCheck[];
+export declare const check: {
+    name: string;
+    run: typeof run;
+};

package/dist/services/doctor/doctor-service/checks/multi-binary-drift.js

@@ -30,6 +30,7 @@
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { delimiter as pathDelimiter, join } from 'node:path';
 import { getErrorMessage } from 'peaks-loop-shared/result';
+import { candidateBinaryNames, dedupeVersions, existsSafe } from '../multi-binary-drift-helpers.js';
 /**
  * Pure helper. Inspects `process.env.PATH` (or the injected
  * `pathEnv`) for `peaks-loop` binaries. Each found binary is walked
@@ -41,30 +42,33 @@ import { getErrorMessage } from 'peaks-loop-shared/result';
  */
 export function inspectMultiBinaryDrift(opts) {
     const envReader = opts?.envReader ?? ((k) => process.env[k]);
-    const exists = opts?.binaryExists ?? ((p) => {
-        try {
-            return existsSync(p);
-        }
-        catch {
-            return false;
-        }
-    });
-    const realpath = opts?.binaryRealpath ?? ((p) => {
-        try {
-            return realpathSync(p);
-        }
-        catch {
-            return p;
-        }
-    });
-    const reader = opts?.packageJsonReader ?? ((p) => {
-        try {
-            return readFileSync(p);
-        }
-        catch {
-            return null;
-        }
-    });
+    const exists = opts?.binaryExists ??
+        ((p) => {
+            try {
+                return existsSync(p);
+            }
+            catch {
+                return false;
+            }
+        });
+    const realpath = opts?.binaryRealpath ??
+        ((p) => {
+            try {
+                return realpathSync(p);
+            }
+            catch {
+                return p;
+            }
+        });
+    const reader = opts?.packageJsonReader ??
+        ((p) => {
+            try {
+                return readFileSync(p);
+            }
+            catch {
+                return null;
+            }
+        });
     const pathEnv = opts?.pathEnv ?? envReader('PATH') ?? '';
     if (pathEnv.length === 0) {
         return { binaries: [], driftDetected: false, uniqueVersions: [] };
@@ -92,16 +96,6 @@ export function inspectMultiBinaryDrift(opts) {
         uniqueVersions
     };
 }
-/**
- * Cross-platform candidate names. Windows shims the executable as
- * `peaks.cmd` and `peaks.ps1` (npm writes both); POSIX names the
- * binary `peaks`. We probe all three names on every platform —
- * probing a non-existent file is a no-op, so cross-list probing is
- * safe.
- */
-function candidateBinaryNames(dir) {
-    return [join(dir, 'peaks'), join(dir, 'peaks.cmd'), join(dir, 'peaks.ps1')];
-}
 /**
  * Walk from the binary to its `node_modules/peaks-loop/package.json`.
  *
@@ -149,14 +143,6 @@ function locatePackageJson(realpathPath, originalCandidate) {
     }
     return null;
 }
-function existsSafe(p) {
-    try {
-        return existsSync(p);
-    }
-    catch {
-        return false;
-    }
-}
 function readBinaryRecord(candidate, realpathPath, pkgPath, reader) {
     if (pkgPath === null) {
         return {
@@ -195,45 +181,29 @@ function readBinaryRecord(candidate, realpathPath, pkgPath, reader) {
         realpath: realpathPath
     };
 }
-/**
- * `version === null` means we could not read the package.json (or
- * its `name` did not equal `peaks-loop`). Those records stay in
- * `binaries` for the report but do NOT contribute to
- * `uniqueVersions` — including null would falsely trigger drift
- * detection when the only failures are unreadable binaries.
- */
-function dedupeVersions(versions) {
-    const seen = new Set();
-    const out = [];
-    for (const v of versions) {
-        if (typeof v !== 'string' || v.length === 0)
-            continue;
-        if (seen.has(v))
-            continue;
-        seen.add(v);
-        out.push(v);
-    }
-    return out;
-}
 function run({ options }) {
     const probe = options.multiBinaryDriftProbe ?? (() => inspectMultiBinaryDrift());
     try {
         const result = probe();
         if (result.binaries.length === 0) {
-            return [{
+            return [
+                {
                     id: 'build:multi-binary-drift',
                     ok: true,
                     message: 'no peaks-loop binary on PATH (statusLine may be unavailable)'
-                }];
+                }
+            ];
         }
         if (!result.driftDetected) {
-            return [{
+            return [
+                {
                     id: 'build:multi-binary-drift',
                     ok: true,
                     message: result.binaries.length === 1
                         ? `single peaks-loop binary on PATH at ${result.binaries[0].path} (version ${result.uniqueVersions[0] ?? 'unknown'})`
                         : `${result.binaries.length} peaks-loop binaries on PATH all at version ${result.uniqueVersions[0] ?? 'unknown'}`
-                }];
+                }
+            ];
         }
         // Drift detected — WARN-ONLY. AC7: doctor still exit 0 unless
         // another check escalates to error. `ok: false` so the operator
@@ -247,21 +217,31 @@ function run({ options }) {
         const binaryTable = result.binaries
             .map((b) => `  ${b.path} version=${b.version ?? 'unknown'} date=${b.installDate ?? 'unknown'}`)
             .join('\n');
-        return [{
+        return [
+            {
                 id: 'build:multi-binary-drift',
                 ok: false,
                 severity: 'warning',
                 message: `PEAKS_MULTI_BINARY_DRIFT: ${result.uniqueVersions.length} distinct peaks-loop versions on PATH (${result.uniqueVersions.join(', ')}). Run \`npm uninstall -g peaks-loop\` on the stale entries, or reorder PATH so the desired binary resolves first. Binaries:\n${binaryTable}`
-            }];
+            }
+        ];
     }
     catch (error) {
-        return [{
+        return [
+            {
                 id: 'build:multi-binary-drift',
                 ok: false,
                 message: `multi-binary drift check failed: ${getErrorMessage(error)}`
-            }];
+            }
+        ];
     }
 }
+// Slice S3b (rid-s3b-doctor-check-typing): `satisfies` instead of a
+// `: DoctorCheckPlugin` annotation — see the identical note in
+// `codegraph-capability.ts`. The annotation widened this object literal
+// to `readonly DoctorCheck[] | Promise<readonly DoctorCheck[]>`, which
+// leaked into importers as 4 TS7053 + 4 TS2339 errors even though this
+// module's `run` is synchronous and measurably returns an array.
 export const check = {
     name: 'multi-binary-drift',
     run

package/dist/services/doctor/doctor-service/checks/schema-validity.js

@@ -15,7 +15,11 @@ async function run({ schemaRoot }) {
     for (const schemaFile of requiredSchemaFiles) {
         try {
             JSON.parse(await readText(join(schemaRoot, schemaFile)));
-            checks.push({ id: `schema:${schemaFile}`, ok: true, message: `Schema ${schemaFile} is valid JSON` });
+            checks.push({
+                id: `schema:${schemaFile}`,
+                ok: true,
+                message: `Schema ${schemaFile} is valid JSON`
+            });
         }
         catch (error) {
             checks.push({

package/dist/services/doctor/doctor-service/checks/skill-presence.js

@@ -44,11 +44,13 @@ function run({ options, presence }) {
     }
     const modePart = presence.mode !== undefined ? `, mode ${presence.mode}` : '';
     const gatePart = presence.gate !== undefined ? `, gate ${presence.gate}` : '';
-    const checks = [{
+    const checks = [
+        {
             id: 'skill-presence:current',
             ok: true,
             message: `Active Peaks skill presence: ${presence.skill}${modePart}${gatePart} (set ${presence.setAt})`
-        }];
+        }
+    ];
     const setAtMs = Date.parse(presence.setAt);
     if (Number.isNaN(setAtMs)) {
         checks.push({

package/dist/services/doctor/doctor-service/checks/statusline-install.js

@@ -12,19 +12,23 @@
  */
 function run({ presence, statusLineInstalled }) {
     if (presence !== null && !statusLineInstalled) {
-        return [{
+        return [
+            {
                 id: 'statusline:install',
                 ok: true,
                 message: 'A Peaks skill is active but the statusLine is not installed; run `peaks statusline install` so the active skill shows in the terminal status bar'
-            }];
+            }
+        ];
     }
-    return [{
+    return [
+        {
             id: 'statusline:install',
             ok: true,
             message: statusLineInstalled
                 ? 'Peaks statusLine is installed'
                 : 'Peaks statusLine not installed (no active skill; install optional)'
-        }];
+        }
+    ];
 }
 export const check = {
     name: 'statusline-install',

package/dist/services/doctor/doctor-service/checks/statusline-runtime.js

@@ -12,17 +12,21 @@
 import { CLI_VERSION } from 'peaks-loop-shared/version';
 function run({ platform }) {
     if (platform === 'win32') {
-        return [{
+        return [
+            {
                 id: 'statusline:runtime',
                 ok: true,
                 message: `peaks ${CLI_VERSION} (win32): if the statusLine shows nothing in git bash, verify \`peaks\` resolves on PATH in the shell Claude Code uses (run \`peaks -v\` there), reinstall globally with \`npm i -g peaks-loop@latest\` if the version is older than ${CLI_VERSION}, then re-run \`peaks statusline install\` and reload Claude Code`
-            }];
+            }
+        ];
     }
-    return [{
+    return [
+        {
             id: 'statusline:runtime',
             ok: true,
             message: `peaks ${CLI_VERSION} (${platform}): statusLine command is \`peaks statusline\``
-        }];
+        }
+    ];
 }
 export const check = {
     name: 'statusline-runtime',

package/dist/services/doctor/doctor-service/checks/user-config.js

@@ -13,13 +13,15 @@ import { join } from 'node:path';
 function run() {
     const userConfigPath = join(homedir(), '.peaks', 'config.json');
     const hasUserConfig = existsSync(userConfigPath);
-    return [{
+    return [
+        {
             id: 'config:user',
             ok: true,
             message: hasUserConfig
                 ? 'User config exists at ~/.peaks/config.json'
                 : 'Optional user config not found at ~/.peaks/config.json'
-        }];
+        }
+    ];
 }
 export const check = {
     name: 'user-config',

package/dist/services/doctor/doctor-service/checks/workspace-init.js

@@ -14,19 +14,23 @@
  */
 function run({ presence, workspaceInitialized }) {
     if (presence !== null && !workspaceInitialized) {
-        return [{
+        return [
+            {
                 id: 'skill-presence:workspace',
                 ok: false,
                 message: `Skill ${presence.skill} is active but no workspace session exists (.peaks/_runtime/session.json missing); run \`peaks workspace init --project <repo>\` — peaks-code Step 0 must anchor the workspace before any work`
-            }];
+            }
+        ];
     }
-    return [{
+    return [
+        {
             id: 'skill-presence:workspace',
             ok: true,
             message: presence === null
                 ? 'No active skill presence; workspace guard not applicable'
                 : `Workspace session present for active skill ${presence.skill}`
-        }];
+        }
+    ];
 }
 export const check = {
     name: 'workspace-init',