peaks-loop 4.0.54 → 4.1.0

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',

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

@@ -47,10 +47,7 @@ const LEGACY_DOTFILES = ['.session.json'];
 // specific issue ("stale single-slot presence") and the operator
 // can delete the file. The canonical sid-scoped lease at
 // `.peaks/_runtime/<sid>/leases/presence-*.json` is the source of truth.
-const STALE_SINGLE_SLOT_FILES = [
-    'active-skill.json',
-    '.active-skill.json'
-];
+const STALE_SINGLE_SLOT_FILES = ['active-skill.json', '.active-skill.json'];
 /**
  * Pure helper that inspects the on-disk workspace layout for
  * post-F3-canonical violations. Exported so tests can drive the
@@ -190,7 +187,12 @@ function defaultPerChangeIdDirScanner(projectRoot) {
 function defaultWorkspaceLayoutProbe(projectRootResolver) {
     const projectRoot = projectRootResolver();
     if (projectRoot === null) {
-        return { topLevelSessionDirs: [], legacyDotfiles: [], perChangeIdDirs: [], staleSingleSlotFiles: [] };
+        return {
+            topLevelSessionDirs: [],
+            legacyDotfiles: [],
+            perChangeIdDirs: [],
+            staleSingleSlotFiles: []
+        };
     }
     return inspectWorkspaceLayout({ projectRoot });
 }
@@ -209,11 +211,13 @@ function run({ options, projectRootResolver }) {
             layout.legacyDotfiles.length === 0 &&
             perChangeIdDirs.length === 0 &&
             staleSingleSlotFiles.length === 0) {
-            return [{
+            return [
+                {
                     id: 'build:workspace-layout-canonical',
                     ok: true,
                     message: 'Workspace layout is canonical: no top-level session dirs, no legacy runtime dotfiles, no per-change-id top-level dirs, no stale single-slot presence files'
-                }];
+                }
+            ];
         }
         const offenders = [
             ...layout.topLevelSessionDirs.map((p) => `top-level session dir: ${p}`),
@@ -221,18 +225,22 @@ function run({ options, projectRootResolver }) {
             ...perChangeIdDirs.map((p) => `per-change-id top-level dir: ${p}`),
             ...staleSingleSlotFiles.map((p) => `stale single-slot presence: ${p}`)
         ];
-        return [{
+        return [
+            {
                 id: 'build:workspace-layout-canonical',
                 ok: false,
                 message: `Workspace layout is not canonical. Offenders: ${offenders.join('; ')}. Run \`peaks workspace migrate --to-runtime --project <repo> --apply\` to consolidate; delete stale single-slot presence files manually after migration.`
-            }];
+            }
+        ];
     }
     catch (error) {
-        return [{
+        return [
+            {
                 id: 'build:workspace-layout-canonical',
                 ok: false,
                 message: `Workspace layout check failed: ${getErrorMessage(error)}`
-            }];
+            }
+        ];
     }
 }
 export const check = {

package/dist/services/doctor/doctor-service/index.js

@@ -190,7 +190,8 @@ export async function runDoctor(options = {}) {
     const listDirectoriesImpl = (target) => fsModule.listDirectories(target);
     const pathExistsImpl = (target) => fsModule.pathExists(target);
     const readTextImpl = (target) => fsModule.readText(target);
-    const loadSkills = options.loadSkills ?? ((baseDir) => defaultLoadSkills(baseDir, listDirectoriesImpl, pathExistsImpl, readTextImpl));
+    const loadSkills = options.loadSkills ??
+        ((baseDir) => defaultLoadSkills(baseDir, listDirectoriesImpl, pathExistsImpl, readTextImpl));
     const registry = await loadSkills(options.skillsBaseDir);
     const skills = registry.skills;
     const schemaRoot = options.schemasBaseDir ?? schemasDir;
@@ -205,7 +206,8 @@ export async function runDoctor(options = {}) {
         }
     }
     // Workspace initialized: probe once up front, swallowing probe errors.
-    const workspaceProbe = options.workspaceInitializedProbe ?? (() => defaultWorkspaceInitializedProbe(projectRootResolver));
+    const workspaceProbe = options.workspaceInitializedProbe ??
+        (() => defaultWorkspaceInitializedProbe(projectRootResolver));
     let workspaceInitialized = false;
     try {
         workspaceInitialized = workspaceProbe();

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

@@ -0,0 +1,40 @@
+/**
+ * multi-binary-drift-helpers — the pure PATH-probing primitives behind the
+ * `build:multi-binary-drift` doctor check (`multi-binary-drift.ts`).
+ *
+ * These are declarations + small pure helpers only: the record shape, the
+ * cross-platform candidate names, the read-only `exists` probe, and the
+ * version dedupe. `multi-binary-drift.ts` imports them and re-exports
+ * `PeaksBinaryRecord`, so the check's public surface is unchanged.
+ */
+/**
+ * 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;
+};
+/**
+ * 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.
+ */
+export declare function candidateBinaryNames(dir: string): ReadonlyArray<string>;
+export declare function existsSafe(p: string): boolean;
+/**
+ * `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.
+ */
+export declare function dedupeVersions(versions: ReadonlyArray<string | null>): ReadonlyArray<string>;

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

@@ -0,0 +1,49 @@
+/**
+ * multi-binary-drift-helpers — the pure PATH-probing primitives behind the
+ * `build:multi-binary-drift` doctor check (`multi-binary-drift.ts`).
+ *
+ * These are declarations + small pure helpers only: the record shape, the
+ * cross-platform candidate names, the read-only `exists` probe, and the
+ * version dedupe. `multi-binary-drift.ts` imports them and re-exports
+ * `PeaksBinaryRecord`, so the check's public surface is unchanged.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * 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.
+ */
+export function candidateBinaryNames(dir) {
+    return [join(dir, 'peaks'), join(dir, 'peaks.cmd'), join(dir, 'peaks.ps1')];
+}
+export function existsSafe(p) {
+    try {
+        return existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * `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.
+ */
+export 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;
+}

package/dist/services/doctor/doctor-service/plugin-registry.js

@@ -81,5 +81,5 @@ export const PLUGINS = [
     eccHooksSchemaDrift, // id "integration:ecc-hooks-schema-drift"
     checkIdSchema, // id "doctor-self:check-id-pattern"
     l3OrphanSessions, // id "L3:l3-orphan-sessions"
-    l3MemoryHealth, // id "L3:l3-memory-health"
+    l3MemoryHealth // id "L3:l3-memory-health"
 ];