peaks-loop 4.0.12 → 4.0.13

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 4.0.13 — 2026-08-06 (statusline empty-render fix + sid-only marker + multi-binary drift guard)
+
+**Statusline callerId fallback + active `[short-sid]` suffix** (slice `2026-08-05-statusline-empty-render-and-short-sid-suffix`, commit `4be37d08`):
+- `src/services/skills/skill-statusline-service.ts` `readPresenceReadOnly` now retries with `callerId: null` when callerId-filtered resolution returns `source: 'none'`. Multi-tenant isolation invariant preserved (slice 4-B Case A regression test stays green).
+- `src/services/skills/skill-statusline-renderer.ts` introduces `formatShortSid(sessionId) = sessionId.split('-').pop()` helper. Active state now renders `Peaks ● peaks-code → peaks-loop [3fe1be]`.
+- New tests: `tests/unit/skills/skill-statusline-empty-render-and-short-sid-suffix.test.ts` (8 cases). Existing dual-skill test updated to accept the `[aaaa]` suffix.
+- Fixes the "new session statusline empty despite active peaks-code lease" bug (root cause: outerSessionId drift between caller shell and lease's callerId).
+
+**Statusline sid-only marker (idle/stale) + multi-binary drift guard** (slice `2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard`, commits `95654d48` + `34de6c22` repair):
+- `skill-statusline-service.ts` adds `sessionId: string | null` to `StatusLineModel`. `skill-statusline-sid-suffix.ts` (new, 78 LOC) holds `computeRootSuffix` + `formatShortSid` (extracted from renderer for LOC cap; renderer 806 → 776).
+- Idle and stale states now append ` [3fe1be]` after `peaks-loop` when session.json is bound. Invalid-presence stays unchanged (G2 — read-error signal must remain loud).
+- New `peaks doctor check` plugin `build:multi-binary-drift` scans `process.env.PATH` for `peaks` binaries (cross-platform: `peaks` / `peaks.cmd` / `peaks.ps1`), resolves each to its `node_modules/peaks-loop/package.json`, dedupes by realpath, and emits `PEAKS_MULTI_BINARY_DRIFT` warning when ≥ 2 distinct versions coexist. Caught the `/c/nvm4w/nodejs 4.0.12 + /c/Users/smallMark/AppData/Roaming/npm 3.1.2` case that produced "Hook JSON output validation failed" on fresh IDE sessions.
+- **Severity-aware `buildReport`** (the canonical reference for warn-only doctor checks): `DoctorCheck` now carries `severity: 'error' | 'warning'`. `buildReport` separates errors from warnings; `summary.ok = errors === 0`. Multi-binary drift emits `severity: 'warning'`. CLI exit code only flips on errors.
+- Tests: `tests/unit/skills/skill-statusline-sid-only-marker.test.ts` (8 cases) + `tests/unit/doctor/multi-binary-drift-check.test.ts` (13 cases) + `tests/unit/doctor/final-summary-severity.test.ts` (7 cases) + `tests/unit/doctor/doctor-exit-code-warn-only.test.ts` (5 cases). 170/170 green on slice surface.
+
+**Lockstep bump.** peaks-loop-shared `0.0.42 → 0.0.43` (CLI_VERSION re-stamped to 4.0.13); peaks-loop-mut `0.1.15 → 0.1.16`; peaks-loop-shared-channel `0.0.19 → 0.0.20`.
+
 ## 4.0.12 — 2026-08-05 (5-slice optimization bundle)
 
 **publish.yml strict tag gate** (slice 1, commit `f60f7597`):

package/dist/cli/commands/core/doctor-command.js

@@ -212,6 +212,10 @@ export function registerDoctorCommand(program, io) {
         const data = logsSection === null
             ? { ...report, staleBinding: staleBindingSection }
             : { ...report, logs: logsSection, staleBinding: staleBindingSection };
+        // Slice 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+        // repair cycle: `report.summary.ok` already factors in the
+        // severity-aware aggregation in `buildReport` (warnings do NOT
+        // flip `ok`). Stale-binding is independent and still escalates.
         const result = report.summary.ok && staleInstances.length === 0
             ? ok('doctor', data)
             : fail('doctor', 'DOCTOR_FAILED', staleInstances.length > 0
@@ -224,9 +228,20 @@ export function registerDoctorCommand(program, io) {
         }
         else {
             // Human-readable: one line per check, green/red indicators, no JSON.
+            // Slice 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+            // repair cycle: warn-only findings (severity: 'warning') surface
+            // as `! check.ok` with the `! ` (warning) glyph so the operator
+            // can tell them apart from real errors without reading JSON.
             for (const check of report.checks) {
-                const icon = check.ok ? '+' : '×';
-                io.stdout(`  ${icon}  ${check.message}`);
+                if (check.ok) {
+                    io.stdout(`  +  ${check.message}`);
+                }
+                else if (check.severity === 'warning') {
+                    io.stdout(`  !  ${check.message}`);
+                }
+                else {
+                    io.stdout(`  ×  ${check.message}`);
+                }
             }
             if (logsSection !== null) {
                 io.stdout('\n  logs:');
@@ -252,11 +267,19 @@ export function registerDoctorCommand(program, io) {
                     io.stdout('    rerun with --cleanup-stale to drop them');
                 }
             }
-            io.stdout(`\n  ${report.summary.passed} passed, ${report.summary.failed} failed`);
+            io.stdout(`\n  ${report.summary.passed} passed, ${report.summary.failed} failed${report.summary.warnings > 0 ? `, ${report.summary.warnings} warning(s)` : ''}`);
             if (!report.summary.ok || staleInstances.length > 0) {
                 io.stderr(`\nDOCTOR_FAILED: ${staleInstances.length > 0 ? 'stale binding present' : `${report.summary.failed} check(s) failed`}.`);
             }
+            else if (report.summary.warnings > 0) {
+                io.stdout(`\n  ${report.summary.warnings} warning(s) present — exit code 0 (warn-only).`);
+            }
         }
+        // Slice 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+        // repair cycle: `report.summary.ok` already factors in the
+        // severity-aware aggregation in `buildReport` (warnings do NOT
+        // flip `ok`). The exit-code gate remains `summary.ok &&
+        // !staleInstances` — no separate warning special-case needed here.
         if (!report.summary.ok || staleInstances.length > 0) {
             process.exitCode = 1;
         }

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

@@ -0,0 +1,61 @@
+/**
+ * Check: PATH-scoped `peaks-loop` binary drift
+ * (`build:multi-binary-drift`).
+ *
+ * Slice 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * (G3/G4). When more than one `peaks-loop` binary is discoverable on
+ * `process.env.PATH` AND the discovered versions disagree, the doctor
+ * emits a `PEAKS_MULTI_BINARY_DRIFT` warning. The user-reported
+ * production symptom — `peaks` resolving to an old version (e.g.
+ * 3.1.2 on `%AppData%\Roaming\npm`) while the freshly installed
+ * binary on another PATH entry (e.g. `C:\nvm4w\nodejs\peaks` 4.0.12)
+ * is what the user just bumped — produces "Hook JSON output
+ * validation failed" when the IDE statusline hook inherits the older
+ * binary via PATH ordering.
+ *
+ * Behavior contract (PRD AC6 / AC7 / AC8 / AC9):
+ *   - AC6: ≥ 2 peaks-loop binaries with different versions → warning
+ *   - AC7: warning severity only, doctor exit 0 (no other check
+ *          flipped to error)
+ *   - AC8: drift is scoped to peaks-loop (`package.json#name ===
+ *          'peaks-loop'`); sibling npm tools are NOT flagged
+ *   - AC9: cross-platform — uses `process.env.PATH` + `path.delimiter`
+ *          + binary naming `peaks` / `peaks.cmd` / `peaks.ps1`
+ *
+ * Pure `inspectMultiBinaryDrift` helper is exported so tests can drive
+ * the filesystem walk without monkey-patching `process.env.PATH` or
+ * `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;
+};
+/**
+ * Pure helper. Inspects `process.env.PATH` (or the injected
+ * `pathEnv`) for `peaks-loop` binaries. Each found binary is walked
+ * to its package.json via `realpathSync` so symlinks / npm shims /
+ * `peaks.cmd` / `peaks.ps1` all collapse to the same dedupe key.
+ *
+ * Exported so tests can drive the filesystem walk without monkey-
+ * patching `process.env.PATH` or `realpathSync`.
+ */
+export declare function inspectMultiBinaryDrift(opts?: {
+    pathEnv?: string;
+    envReader?: (key: string) => string | undefined;
+    binaryExists?: (candidate: string) => boolean;
+    binaryRealpath?: (candidate: string) => string;
+    packageJsonReader?: (path: string) => Buffer | string | null;
+}): MultiBinaryDriftInspection;
+export declare const check: DoctorCheckPlugin;

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

@@ -0,0 +1,268 @@
+/**
+ * Check: PATH-scoped `peaks-loop` binary drift
+ * (`build:multi-binary-drift`).
+ *
+ * Slice 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * (G3/G4). When more than one `peaks-loop` binary is discoverable on
+ * `process.env.PATH` AND the discovered versions disagree, the doctor
+ * emits a `PEAKS_MULTI_BINARY_DRIFT` warning. The user-reported
+ * production symptom — `peaks` resolving to an old version (e.g.
+ * 3.1.2 on `%AppData%\Roaming\npm`) while the freshly installed
+ * binary on another PATH entry (e.g. `C:\nvm4w\nodejs\peaks` 4.0.12)
+ * is what the user just bumped — produces "Hook JSON output
+ * validation failed" when the IDE statusline hook inherits the older
+ * binary via PATH ordering.
+ *
+ * Behavior contract (PRD AC6 / AC7 / AC8 / AC9):
+ *   - AC6: ≥ 2 peaks-loop binaries with different versions → warning
+ *   - AC7: warning severity only, doctor exit 0 (no other check
+ *          flipped to error)
+ *   - AC8: drift is scoped to peaks-loop (`package.json#name ===
+ *          'peaks-loop'`); sibling npm tools are NOT flagged
+ *   - AC9: cross-platform — uses `process.env.PATH` + `path.delimiter`
+ *          + binary naming `peaks` / `peaks.cmd` / `peaks.ps1`
+ *
+ * Pure `inspectMultiBinaryDrift` helper is exported so tests can drive
+ * the filesystem walk without monkey-patching `process.env.PATH` or
+ * `realpathSync`. Every probe call is wrapped in try/catch (read-only,
+ * must not throw across the doctor boundary).
+ */
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { delimiter as pathDelimiter, join } from 'node:path';
+import { getErrorMessage } from 'peaks-loop-shared/result';
+/**
+ * Pure helper. Inspects `process.env.PATH` (or the injected
+ * `pathEnv`) for `peaks-loop` binaries. Each found binary is walked
+ * to its package.json via `realpathSync` so symlinks / npm shims /
+ * `peaks.cmd` / `peaks.ps1` all collapse to the same dedupe key.
+ *
+ * Exported so tests can drive the filesystem walk without monkey-
+ * patching `process.env.PATH` or `realpathSync`.
+ */
+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 pathEnv = opts?.pathEnv ?? envReader('PATH') ?? '';
+    if (pathEnv.length === 0) {
+        return { binaries: [], driftDetected: false, uniqueVersions: [] };
+    }
+    const dirs = pathEnv.split(pathDelimiter).filter((d) => d.length > 0);
+    const seen = new Map();
+    for (const dir of dirs) {
+        const candidates = candidateBinaryNames(dir);
+        for (const candidate of candidates) {
+            if (!exists(candidate))
+                continue;
+            const rp = realpath(candidate);
+            if (seen.has(rp))
+                continue;
+            const pkgPath = locatePackageJson(rp, candidate);
+            const record = readBinaryRecord(candidate, rp, pkgPath, reader);
+            seen.set(rp, record);
+        }
+    }
+    const binaries = Array.from(seen.values());
+    const uniqueVersions = dedupeVersions(binaries.map((b) => b.version));
+    return {
+        binaries,
+        driftDetected: uniqueVersions.length >= 2,
+        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`.
+ *
+ * Common layouts handled:
+ *
+ *   A. `<root>/bin/peaks` (POSIX npm global / nvm) → parent is
+ *      `<root>/bin/`, parent's parent is `<root>/`. package.json at
+ *      `<root>/package.json`.
+ *   B. `<root>/peaks` or `<root>/peaks.cmd` (Windows npm global shim)
+ *      → parent is `<root>/`. package.json at `<root>/package.json`,
+ *      OR `<root>/../node_modules/peaks-loop/package.json`.
+ *   C. `<root>/node_modules/.bin/peaks` (local install) → parent is
+ *      `node_modules/.bin/`, parent's parent is `node_modules/`.
+ *      package.json at `<root>/node_modules/peaks-loop/package.json`.
+ *
+ * The locator walks up from the binary path (realpathPath first,
+ * then originalCandidate) and checks for the canonical
+ * `node_modules/peaks-loop/package.json` and a `package.json` at each
+ * ancestor. The probe is read-only and stops at the first hit. We do
+ * NOT trust `package.json` without verifying its `name === 'peaks-loop'`
+ * later (see {@link readBinaryRecord}) — a sibling package's
+ * `package.json` is filtered out at read time.
+ */
+function locatePackageJson(realpathPath, originalCandidate) {
+    const ancestors = new Set();
+    for (const start of [realpathPath, originalCandidate]) {
+        let current = start;
+        for (let depth = 0; depth < 8; depth++) {
+            const parent = join(current, '..');
+            if (parent === current)
+                break;
+            ancestors.add(parent);
+            current = parent;
+        }
+    }
+    for (const ancestor of ancestors) {
+        const nmPkg = join(ancestor, 'node_modules', 'peaks-loop', 'package.json');
+        if (existsSafe(nmPkg))
+            return nmPkg;
+    }
+    for (const ancestor of ancestors) {
+        const pkg = join(ancestor, 'package.json');
+        if (existsSafe(pkg))
+            return pkg;
+    }
+    return null;
+}
+function existsSafe(p) {
+    try {
+        return existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+function readBinaryRecord(candidate, realpathPath, pkgPath, reader) {
+    if (pkgPath === null) {
+        return {
+            path: candidate,
+            version: null,
+            installDate: null,
+            realpath: realpathPath
+        };
+    }
+    let version = null;
+    try {
+        const raw = reader(pkgPath);
+        if (raw !== null) {
+            const text = Buffer.isBuffer(raw) ? raw.toString('utf8') : raw;
+            const parsed = JSON.parse(text);
+            if (parsed.name === 'peaks-loop' && typeof parsed.version === 'string') {
+                version = parsed.version;
+            }
+        }
+    }
+    catch {
+        version = null;
+    }
+    let installDate = null;
+    try {
+        const stat = statSync(pkgPath);
+        installDate = stat.mtime.toISOString();
+    }
+    catch {
+        installDate = null;
+    }
+    return {
+        path: candidate,
+        version,
+        installDate,
+        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 [{
+                    id: 'build:multi-binary-drift',
+                    ok: true,
+                    message: 'no peaks-loop binary on PATH (statusLine may be unavailable)'
+                }];
+        }
+        if (!result.driftDetected) {
+            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
+        // sees the finding in the JSON report AND the check carries
+        // `severity: 'warning'` so `buildReport` does NOT count it as a
+        // failure when computing `summary.ok`. Slice
+        // 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+        // repair cycle landed the severity-aware summary so the
+        // previously-handwaved "future severity-aware summary can
+        // downgrade the doctor exit code" actually fires.
+        const binaryTable = result.binaries
+            .map((b) => `  ${b.path} version=${b.version ?? 'unknown'} date=${b.installDate ?? 'unknown'}`)
+            .join('\n');
+        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 [{
+                id: 'build:multi-binary-drift',
+                ok: false,
+                message: `multi-binary drift check failed: ${getErrorMessage(error)}`
+            }];
+    }
+}
+export const check = {
+    name: 'multi-binary-drift',
+    run
+};

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

@@ -43,6 +43,7 @@ import { check as statuslineInstall } from './checks/statusline-install.js';
 import { check as statuslineRuntime } from './checks/statusline-runtime.js';
 import { check as codegraphCapability } from './checks/codegraph-capability.js';
 import { check as distSourceVersion } from './checks/dist-source-version.js';
+import { check as multiBinaryDrift } from './checks/multi-binary-drift.js';
 import { check as workspaceLayout } from './checks/workspace-layout.js';
 import { check as gateguardConflict } from './checks/gateguard-conflict.js';
 import { check as checkIdSchema } from './checks/check-id-schema.js';
@@ -69,6 +70,7 @@ export const PLUGINS = [
     statuslineRuntime, // id "statusline:runtime"
     codegraphCapability, // id "capability:codegraph"
     distSourceVersion, // id "build:dist-version-matches-source"
+    multiBinaryDrift, // id "build:multi-binary-drift"
     workspaceLayout, // id "build:workspace-layout-canonical"
     gateguardConflict, // id "integration:gateguard-peaks-conflict"
     checkIdSchema, // id "doctor-self:check-id-pattern"

package/dist/services/doctor/doctor-service/report/final-summary.d.ts

@@ -2,11 +2,19 @@
  * Report aggregator: convert the accumulated `DoctorCheck[]` into the
  * public `DoctorReport` shape (checks + summary).
  *
- * The summary is a pure reduction over the checks — it counts the
- * passing and failing rows, derives `ok = failed === 0`, and
- * returns the `{ checks, summary }` tuple. Kept in its own module
- * so the dispatcher (`index.ts`) stays a thin orchestration loop
- * and the aggregation rule has a single test surface.
+ * The summary is a pure reduction over the checks — it separates
+ * `error`-severity findings from `warning`-severity findings, derives
+ * `ok = errors === 0`, and returns the `{ checks, summary }` tuple.
+ * Kept in its own module so the dispatcher (`index.ts`) stays a thin
+ * orchestration loop and the aggregation rule has a single test surface.
+ *
+ * Severity-aware aggregation (slice
+ * 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * repair cycle): a check with `severity: 'warning'` reports `ok: false`
+ * (so operators see the finding in the JSON envelope) but does NOT
+ * flip `summary.ok` and therefore does NOT flip the doctor exit code.
+ * Genuine failures (severity omitted, or `severity: 'error'`) behave
+ * the same as the pre-slice `failed === 0` rule.
  */
 import type { DoctorCheck, DoctorReport } from '../types.js';
 /**

package/dist/services/doctor/doctor-service/report/final-summary.js

@@ -2,11 +2,19 @@
  * Report aggregator: convert the accumulated `DoctorCheck[]` into the
  * public `DoctorReport` shape (checks + summary).
  *
- * The summary is a pure reduction over the checks — it counts the
- * passing and failing rows, derives `ok = failed === 0`, and
- * returns the `{ checks, summary }` tuple. Kept in its own module
- * so the dispatcher (`index.ts`) stays a thin orchestration loop
- * and the aggregation rule has a single test surface.
+ * The summary is a pure reduction over the checks — it separates
+ * `error`-severity findings from `warning`-severity findings, derives
+ * `ok = errors === 0`, and returns the `{ checks, summary }` tuple.
+ * Kept in its own module so the dispatcher (`index.ts`) stays a thin
+ * orchestration loop and the aggregation rule has a single test surface.
+ *
+ * Severity-aware aggregation (slice
+ * 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * repair cycle): a check with `severity: 'warning'` reports `ok: false`
+ * (so operators see the finding in the JSON envelope) but does NOT
+ * flip `summary.ok` and therefore does NOT flip the doctor exit code.
+ * Genuine failures (severity omitted, or `severity: 'error'`) behave
+ * the same as the pre-slice `failed === 0` rule.
  */
 /**
  * Build the final report from the accumulated checks.
@@ -17,13 +25,15 @@
  * report shape the public API exposes.
  */
 export function buildReport(checks) {
-    const failed = checks.filter((check) => !check.ok).length;
+    const errors = checks.filter((check) => !check.ok && check.severity !== 'warning').length;
+    const warnings = checks.filter((check) => !check.ok && check.severity === 'warning').length;
     return {
         checks: [...checks],
         summary: {
-            ok: failed === 0,
-            passed: checks.length - failed,
-            failed
+            ok: errors === 0,
+            passed: checks.length - errors - warnings,
+            failed: errors,
+            warnings
         }
     };
 }

package/dist/services/doctor/doctor-service/types.d.ts

@@ -12,10 +12,32 @@
  * flow through the same names so the main package's `import { runDoctor }`
  * keeps working unchanged.
  */
+/**
+ * Severity for a single doctor check. `'error'` flips the exit code
+ * (via `buildReport` and the CLI dispatcher); `'warning'` surfaces
+ * the finding in the JSON envelope (`ok: false` + `severity: 'warning'`)
+ * but does NOT escalate the doctor exit code to 1.
+ *
+ * Optional in the type for back-compat with older check plugins that
+ * pre-date the severity-aware summary (slice
+ * 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * repair cycle). When omitted, the dispatcher treats the check as
+ * `'error'` — i.e. `ok: false` escalates the exit code the same way
+ * it did before this slice.
+ */
+export type DoctorCheckSeverity = 'error' | 'warning';
 export type DoctorCheck = {
     id: string;
     ok: boolean;
     message: string;
+    /**
+     * Optional severity tag. When `'warning'`, the check still reports
+     * `ok: false` (so operators see the finding in the JSON envelope)
+     * but `buildReport` does NOT count it as a failure for the
+     * `summary.ok` exit-code calculation. Default-omitted checks
+     * behave as `'error'`.
+     */
+    severity?: DoctorCheckSeverity;
 };
 export type DoctorReport = {
     checks: DoctorCheck[];
@@ -23,6 +45,15 @@ export type DoctorReport = {
         ok: boolean;
         passed: number;
         failed: number;
+        /**
+         * Severity-aware summary (slice
+         * 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+         * repair cycle): count of findings tagged
+         * `severity: 'warning'`. Warnings surface in the JSON envelope
+         * (`ok: false`) but do NOT flip `summary.ok` and therefore do
+         * NOT flip the doctor exit code.
+         */
+        warnings: number;
     };
 };
 export type CodegraphCapabilityProbe = {
@@ -38,6 +69,24 @@ export type DistVersionComparison = {
     distReadable: boolean;
 };
 export type DistVersionProbe = () => DistVersionComparison;
+/**
+ * Slice 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * (G3/G4) — probe for the multi-binary drift check. The probe returns
+ * the discovered peaks-loop binaries on PATH (with their resolved
+ * version + install date) and a `driftDetected` flag. Injected so tests
+ * can drive the filesystem walk without monkey-patching
+ * `process.env.PATH` or `realpathSync`.
+ */
+export type MultiBinaryDriftInspection = {
+    readonly binaries: ReadonlyArray<{
+        readonly path: string;
+        readonly version: string | null;
+        readonly installDate: string | null;
+    }>;
+    readonly driftDetected: boolean;
+    readonly uniqueVersions: ReadonlyArray<string>;
+};
+export type MultiBinaryDriftProbe = () => MultiBinaryDriftInspection;
 export type WorkspaceLayoutInspection = {
     topLevelSessionDirs: string[];
     legacyDotfiles: string[];
@@ -150,6 +199,12 @@ export type DoctorOptions = {
     platform?: NodeJS.Platform;
     /** Injected for the build:dist-version-matches-source check (defaults to compareDistVersion on disk). */
     distVersionProbe?: DistVersionProbe;
+    /**
+     * Slice 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+     * (G3/G4) — injected for the build:multi-binary-drift check (defaults
+     * to inspectMultiBinaryDrift against `process.env.PATH`).
+     */
+    multiBinaryDriftProbe?: MultiBinaryDriftProbe;
     /** Injected for the build:workspace-layout-canonical check (defaults to inspectWorkspaceLayout on disk). */
     workspaceLayoutProbe?: WorkspaceLayoutProbe;
     /** Injected for the integration:gateguard-peaks-conflict check (defaults to defaultGateguardProbe on disk). */

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

@@ -14,5 +14,6 @@ export * from './doctor-service/index.js';
 export { compareDistVersion } from './doctor-service/checks/dist-source-version.js';
 export { inspectWorkspaceLayout } from './doctor-service/checks/workspace-layout.js';
 export { collectGateguardEntries } from './doctor-service/checks/gateguard-conflict.js';
+export { inspectMultiBinaryDrift, type PeaksBinaryRecord } from './doctor-service/checks/multi-binary-drift.js';
 export { PLUGINS } from './doctor-service/plugin-registry.js';
-export type { DoctorCheck, DoctorReport, DoctorOptions, DoctorCheckPlugin, DoctorContext, DoctorSkillEntry, DoctorSkillLoadFailure, DoctorSkillsResult, DoctorSkillPresence, CodegraphCapabilityProbe, DistVersionComparison, DistVersionProbe, WorkspaceLayoutInspection, WorkspaceLayoutProbe, GateguardHookLocation, GateguardProbeResult, GateguardProbe } from './doctor-service/types.js';
+export type { DoctorCheck, DoctorReport, DoctorOptions, DoctorCheckPlugin, DoctorContext, DoctorSkillEntry, DoctorSkillLoadFailure, DoctorSkillsResult, DoctorSkillPresence, CodegraphCapabilityProbe, DistVersionComparison, DistVersionProbe, MultiBinaryDriftInspection, MultiBinaryDriftProbe, WorkspaceLayoutInspection, WorkspaceLayoutProbe, GateguardHookLocation, GateguardProbeResult, GateguardProbe } from './doctor-service/types.js';

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

@@ -19,6 +19,7 @@ export * from './doctor-service/index.js';
 export { compareDistVersion } from './doctor-service/checks/dist-source-version.js';
 export { inspectWorkspaceLayout } from './doctor-service/checks/workspace-layout.js';
 export { collectGateguardEntries } from './doctor-service/checks/gateguard-conflict.js';
+export { inspectMultiBinaryDrift } from './doctor-service/checks/multi-binary-drift.js';
 // Re-export the fixed plugin registry so characterization tests and
 // future CLI surfaces (e.g. `peaks doctor --list-checks`) can enumerate
 // the check pipeline without reaching into a private module path.

package/dist/services/doctor/index.d.ts

@@ -19,4 +19,4 @@
  * See .peaks/_runtime/2026-07-17-session-1d5ac0/rd/slice-3b-doctor.md
  * for the slice-3b Option C decision rationale.
  */
-export { runDoctor, isWorkspaceInitializedAt, compareDistVersion, inspectWorkspaceLayout, collectGateguardEntries, type DoctorCheck, type DoctorReport, type DoctorOptions, type CodegraphCapabilityProbe, type DistVersionComparison, type DistVersionProbe, type WorkspaceLayoutInspection, type WorkspaceLayoutProbe, type GateguardHookLocation, type GateguardProbeResult, type GateguardProbe, } from './doctor-service.js';
+export { runDoctor, isWorkspaceInitializedAt, compareDistVersion, inspectWorkspaceLayout, inspectMultiBinaryDrift, collectGateguardEntries, type DoctorCheck, type DoctorReport, type DoctorOptions, type CodegraphCapabilityProbe, type DistVersionComparison, type DistVersionProbe, type MultiBinaryDriftInspection, type MultiBinaryDriftProbe, type PeaksBinaryRecord, type WorkspaceLayoutInspection, type WorkspaceLayoutProbe, type GateguardHookLocation, type GateguardProbeResult, type GateguardProbe, } from './doctor-service.js';

package/dist/services/doctor/index.js

@@ -19,4 +19,4 @@
  * See .peaks/_runtime/2026-07-17-session-1d5ac0/rd/slice-3b-doctor.md
  * for the slice-3b Option C decision rationale.
  */
-export { runDoctor, isWorkspaceInitializedAt, compareDistVersion, inspectWorkspaceLayout, collectGateguardEntries, } from './doctor-service.js';
+export { runDoctor, isWorkspaceInitializedAt, compareDistVersion, inspectWorkspaceLayout, inspectMultiBinaryDrift, collectGateguardEntries, } from './doctor-service.js';

package/dist/services/skills/skill-statusline-renderer.d.ts

@@ -1,4 +1,7 @@
 import type { StatusLineModel } from './skill-statusline-service.js';
+import { computeRootSuffix as computeRootSuffixImpl } from './skill-statusline-sid-suffix.js';
+export { formatShortSid } from './skill-statusline-sid-suffix.js';
+export declare const computeRootSuffix: typeof computeRootSuffixImpl;
 /**
  * Pure formatting layer for the Peaks statusLine. Takes the read-only status
  * model and produces the single line Claude Code paints at the bottom of the
@@ -76,4 +79,3 @@ export declare function applyMarquee(s: string, nowMs: number, capability: Statu
  * states all keep the marquee.
  */
 export declare function renderStatusLine(model: StatusLineModel, options?: StatusLineRenderOptions, env?: NodeJS.ProcessEnv): string;
-export {};

package/dist/services/skills/skill-statusline-renderer.js

@@ -1,4 +1,12 @@
 import { basename } from 'node:path';
+import { computeRootSuffix as computeRootSuffixImpl, } from './skill-statusline-sid-suffix.js';
+// Re-export so existing test imports
+// (`import { formatShortSid, computeRootSuffix } from '.../skill-statusline-renderer'`)
+// keep working byte-identically after the helper extraction in slice
+// 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+// repair cycle.
+export { formatShortSid } from './skill-statusline-sid-suffix.js';
+export const computeRootSuffix = computeRootSuffixImpl;
 /**
  * Internal: the brand prefix is plain ASCII so a tiny terminal without
  * monospaced UTF-8 still sees a recognizable string. The mountain glyphs
@@ -186,6 +194,14 @@ function rootLabel(projectRoot) {
         return '';
     return basename(projectRoot);
 }
+/**
+ * `formatShortSid` + `computeRootSuffix` were extracted to
+ * `./skill-statusline-sid-suffix.ts` in the slice
+ * 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * repair cycle so the renderer file stays under the Karpathy
+ * 800-line cap. Both helpers are re-exported above for back-compat
+ * with existing test imports.
+ */
 /**
  * Build the "middle" of the status line — everything between the brand
  * prefix and the project root label. Kept separate so the token layout
@@ -568,7 +584,27 @@ export function renderStatusLine(model, options, env) {
     const noColor = env !== undefined ? isNoColor(env) : false;
     const palette = paletteFor(capability, noColor);
     const root = rootLabel(model.projectRoot);
-    const rootSuffix = root ? `${palette.trailSeparator}${root}` : '';
+    // short-sid suffix (slices
+    //   - 2026-08-05-statusline-empty-render-and-short-sid-suffix (active only)
+    //   - 2026-08-05-statusline-sid-only-marker (idle + stale also)
+    // ):
+    // the project root cell carries ` [shortSid]` after `peaks-loop` whenever
+    // a canonical session id resolves. Per-state matrix:
+    //
+    //   active             → append sid when sessionId !== null          (AC5/PB1)
+    //   idle               → append sid when sessionId !== null          (AC1)
+    //   stale              → append sid when sessionId !== null          (AC2)
+    //   invalid-presence   → NEVER append sid (G2 — read-error signal must
+    //                        stay loud; showing sid would mask the warning)
+    //                                                                         (AC4)
+    //
+    // Compact state with presence is still rendered with the active sid logic
+    // (the active branch already covered this in the prior slice). Compact state
+    // without presence is the same as the underlying idle / invalid-presence /
+    // stale branch; the helper inherits that. Pure ASCII (no narrow space /
+    // smart quotes), so Windows PowerShell + Git Bash + zsh render byte-
+    // identical (AC7 of the prior slice + AC10 of this slice).
+    const rootSuffix = computeRootSuffix(model, root, palette);
     const brand = brandText(capability, noColor);
     // Breathing pulse: key off a single wall-clock read at the start of
     // render so the output is deterministic for a given invocation. The

package/dist/services/skills/skill-statusline-service.d.ts

@@ -27,6 +27,20 @@ export type StatusLineModel = {
     ageMs: number | null;
     compact: CompactStatuslineState;
     activeLeaf: StatusLineActiveLeaf | null;
+    /**
+     * Slice 2026-08-05-statusline-sid-only-marker: the canonical session
+     * id resolved for the project root (`getSessionIdCanonical`), or
+     * `null` when no project root is bound or no `.peaks/_runtime/<sid>/`
+     * session is on disk. The renderer reads this to append ` [shortSid]`
+     * to the project name cell for idle / stale states (G1); invalid-
+     * presence still suppresses the suffix (G2).
+     *
+     * Carry-forward for AC1/AC2/AC3: the value is `null` whenever
+     * `projectRoot === null` — the renderer relies on this to skip the
+     * suffix without re-running `getSessionIdCanonical` against a non-
+     * existent root.
+     */
+    sessionId: string | null;
 };
 export declare function parseStatusLineStdin(raw: string): StatusLineStdin | null;
 export declare function buildStatusLineModel(stdin: StatusLineStdin | null, nowMs: number): StatusLineModel;

package/dist/services/skills/skill-statusline-service.js

@@ -122,7 +122,13 @@ function readActiveLeaf(projectRoot, sessionId) {
  * Both branches now route through the canonical sid-scoped lease projection
  * (slice 2026-08-05-statusline-sid-scoped-lease-B):
  *   - `callerId !== null` → `resolveActiveSkillForCaller` with the canonical
- *     (non-legacy) lease projection, filtered to this callerId.
+ *     (non-legacy) lease projection, filtered to this callerId. When the
+ *     callerId-filtered resolution returns `source: 'none'` (no lease under
+ *     this callerId), retry once with `callerId: null` so the read falls back
+ *     to the session's most-recent in-flight lease. AC4 multi-tenant isolation
+ *     is preserved: when callerId A DOES have a lease, the first call returns
+ *     it and the fallback never fires — callerId B's lease is never surfaced
+ *     to callerId A. (Slice 2026-08-05-statusline-empty-render-and-short-sid-suffix.)
  *   - `callerId === null` → enumerate `listPresenceLeases` for the
  *     canonical session and pick the most recent in-flight lease. Back-compat
  *     for non-IDE callers (e.g. legacy CLI invocations) that have no callerId.
@@ -134,22 +140,28 @@ function readActiveLeaf(projectRoot, sessionId) {
  */
 function readPresenceReadOnly(projectRoot, callerId) {
     if (callerId !== null) {
+        let firstResolution = null;
         try {
-            const resolution = resolveActiveSkillForCaller(projectRoot, { callerId });
-            if (resolution.source === 'none' || resolution.skill === null) {
-                return { presence: null, invalid: false };
-            }
+            firstResolution = resolveActiveSkillForCaller(projectRoot, { callerId });
+        }
+        catch {
+            return { presence: null, invalid: true };
+        }
+        if (firstResolution.source !== 'none' && firstResolution.skill !== null) {
             return {
                 presence: {
-                    skill: resolution.skill,
-                    ...(resolution.mode !== null ? { mode: resolution.mode } : {}),
+                    skill: firstResolution.skill,
+                    ...(firstResolution.mode !== null ? { mode: firstResolution.mode } : {}),
                 },
                 invalid: false,
             };
         }
-        catch {
-            return { presence: null, invalid: true };
-        }
+        // callerId didn't match any lease — fall back to the session's most
+        // recent in-flight lease (the callerId === null branch below). This
+        // rescues the case where the harness pipes a `CLAUDE_CODE_SESSION_ID`
+        // that differs from the active lease's callerId (peaks-code sessions
+        // started from a different outer session id, etc.).
+        return readPresenceReadOnly(projectRoot, null);
     }
     // callerId === null branch: enumerate the canonical session dir's leases
     // and pick the most recent in-flight lease. This is the back-compat path
@@ -208,17 +220,30 @@ export function buildStatusLineModel(stdin, nowMs) {
     // and reads `.peaks/_runtime/<sid>/compact-lifecycle.json` (or its legacy
     // fallbacks). It replaces the active skill content when kind != 'none'.
     const compact = readCompactState(projectRoot, nowMs);
+    // Slice 2026-08-05-statusline-sid-only-marker: resolve the canonical
+    // session id once, up front, so the renderer can read it from the model
+    // without re-running `getSessionIdCanonical`. `null` when the project
+    // root is unbound OR when no `.peaks/_runtime/<sid>/` session exists.
+    let sessionId = null;
+    if (projectRoot !== null) {
+        try {
+            sessionId = getSessionIdCanonical(projectRoot);
+        }
+        catch {
+            sessionId = null;
+        }
+    }
     if (projectRoot === null) {
-        return { state: 'idle', projectRoot: null, presence: null, ageMs: null, compact, activeLeaf: null };
+        return { state: 'idle', projectRoot: null, presence: null, ageMs: null, compact, activeLeaf: null, sessionId: null };
     }
     // callerId resolves the read-side isolation; back-compat is `null`.
     const callerId = resolveCallerId(stdin);
     const { presence, invalid } = readPresenceReadOnly(projectRoot, callerId);
     if (invalid) {
-        return { state: 'invalid-presence', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null };
+        return { state: 'invalid-presence', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId };
     }
     if (presence === null) {
-        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null };
+        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId };
     }
     // Session binding: when the presence was stamped with a Claude session id and
     // the live session (from stdin) is a different one, the recorded skill belongs
@@ -227,7 +252,7 @@ export function buildStatusLineModel(stdin, nowMs) {
     // fall back to the time-based behavior below for backward compatibility.
     const liveSessionId = typeof stdin?.session_id === 'string' && stdin.session_id.length > 0 ? stdin.session_id : null;
     if (presence.claudeSessionId && liveSessionId && presence.claudeSessionId !== liveSessionId) {
-        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null };
+        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId };
     }
     const setAtMs = presence.setAt ? Date.parse(presence.setAt) : Number.NaN;
     const ageMs = Number.isNaN(setAtMs) ? null : nowMs - setAtMs;
@@ -238,13 +263,12 @@ export function buildStatusLineModel(stdin, nowMs) {
     // bee skill (e.g. `peaks-rd`) alongside the orchestrator (e.g. `peaks-code`).
     let activeLeaf = null;
     try {
-        const sessionId = getSessionIdCanonical(projectRoot);
         activeLeaf = readActiveLeaf(projectRoot, sessionId);
     }
     catch {
         activeLeaf = null;
     }
-    return { state, projectRoot, presence, ageMs, compact, activeLeaf };
+    return { state, projectRoot, presence, ageMs, compact, activeLeaf, sessionId };
 }
 /**
  * Read-only compact state resolver. Resolves the canonical session id for the

package/dist/services/skills/skill-statusline-sid-suffix.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Pure short-sid suffix helpers for the Peaks statusLine.
+ *
+ * Extracted from `skill-statusline-renderer.ts` (slice
+ * 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * repair cycle) to keep the renderer under the Karpathy 800-line cap.
+ * The module is I/O-free and only depends on the read-only
+ * `StatusLineModel` shape from `skill-statusline-service.ts` plus the
+ * `StatusPalette` interface still owned by the renderer. Re-exports
+ * both helpers so the existing test surface (`formatShortSid` direct
+ * tests + `computeRootSuffix` helper-level tests in
+ * `tests/unit/skills/skill-statusline-sid-only-marker.test.ts`) keeps
+ * importing from the renderer for back-compat.
+ *
+ * Pure module — no I/O, no clock dependency, no side effects.
+ */
+import type { StatusLineModel } from './skill-statusline-service.js';
+/**
+ * Minimal palette slice consumed by {@link computeRootSuffix}. The full
+ * `StatusPalette` is defined as a module-private interface inside the
+ * renderer; the suffix helper only needs `trailSeparator`. Re-declared
+ * structurally so the helper has no upward import on the renderer.
+ */
+export interface SidSuffixPalette {
+    readonly trailSeparator: string;
+}
+/**
+ * Format a session id as a short, terminal-friendly tag.
+ *
+ * Returns the last kebab-segment of `sessionId` (e.g.
+ * `2026-08-04-session-3fe1be` → `3fe1be`), or the empty string when
+ * the input is empty. Pure; safe for ASCII rendering across
+ * PowerShell, Git Bash, and zsh (AC7).
+ *
+ * Slice 2026-08-05-statusline-empty-render-and-short-sid-suffix.
+ */
+export declare function formatShortSid(sessionId: string): string;
+/**
+ * Compute the project-root cell of the status line. Returns the
+ * `<trailSep><root>` portion (and optionally the ` [shortSid]` suffix).
+ *
+ * Pure helper — no I/O. The `sessionId` is read from the model that the
+ * service already resolved once via `getSessionIdCanonical`. Per-state
+ * matrix (see the docstring inside `renderStatusLine` in
+ * `skill-statusline-renderer.ts` for the AC/PB references):
+ *
+ *   - state === 'invalid-presence'           → no sid (G2 invariant)
+ *   - state === 'idle' | 'stale' | 'active'   → sid iff model.sessionId resolves
+ *     to a non-empty shortSid string
+ *   - rootLabelText === ''                   → empty string
+ *
+ * Exported so tests can drive the helper without spinning up the full
+ * renderer (marquee, palette, etc.).
+ */
+export declare function computeRootSuffix(model: StatusLineModel, rootLabelText: string, palette: SidSuffixPalette): string;

package/dist/services/skills/skill-statusline-sid-suffix.js

@@ -0,0 +1,65 @@
+/**
+ * Pure short-sid suffix helpers for the Peaks statusLine.
+ *
+ * Extracted from `skill-statusline-renderer.ts` (slice
+ * 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
+ * repair cycle) to keep the renderer under the Karpathy 800-line cap.
+ * The module is I/O-free and only depends on the read-only
+ * `StatusLineModel` shape from `skill-statusline-service.ts` plus the
+ * `StatusPalette` interface still owned by the renderer. Re-exports
+ * both helpers so the existing test surface (`formatShortSid` direct
+ * tests + `computeRootSuffix` helper-level tests in
+ * `tests/unit/skills/skill-statusline-sid-only-marker.test.ts`) keeps
+ * importing from the renderer for back-compat.
+ *
+ * Pure module — no I/O, no clock dependency, no side effects.
+ */
+/**
+ * Format a session id as a short, terminal-friendly tag.
+ *
+ * Returns the last kebab-segment of `sessionId` (e.g.
+ * `2026-08-04-session-3fe1be` → `3fe1be`), or the empty string when
+ * the input is empty. Pure; safe for ASCII rendering across
+ * PowerShell, Git Bash, and zsh (AC7).
+ *
+ * Slice 2026-08-05-statusline-empty-render-and-short-sid-suffix.
+ */
+export function formatShortSid(sessionId) {
+    if (sessionId.length === 0)
+        return '';
+    const last = sessionId.split('-').pop();
+    return last ?? sessionId;
+}
+/**
+ * Compute the project-root cell of the status line. Returns the
+ * `<trailSep><root>` portion (and optionally the ` [shortSid]` suffix).
+ *
+ * Pure helper — no I/O. The `sessionId` is read from the model that the
+ * service already resolved once via `getSessionIdCanonical`. Per-state
+ * matrix (see the docstring inside `renderStatusLine` in
+ * `skill-statusline-renderer.ts` for the AC/PB references):
+ *
+ *   - state === 'invalid-presence'           → no sid (G2 invariant)
+ *   - state === 'idle' | 'stale' | 'active'   → sid iff model.sessionId resolves
+ *     to a non-empty shortSid string
+ *   - rootLabelText === ''                   → empty string
+ *
+ * Exported so tests can drive the helper without spinning up the full
+ * renderer (marquee, palette, etc.).
+ */
+export function computeRootSuffix(model, rootLabelText, palette) {
+    if (!rootLabelText)
+        return '';
+    let suffix = `${palette.trailSeparator}${rootLabelText}`;
+    if (model.state === 'invalid-presence')
+        return suffix;
+    // Defensive: older callers may build a model without `sessionId`
+    // (the field is optional in some test fixtures predating the
+    // sid-only-marker slice). Treat undefined the same as null.
+    if (model.sessionId === null || model.sessionId === undefined)
+        return suffix;
+    const short = formatShortSid(model.sessionId);
+    if (short.length === 0)
+        return suffix;
+    return `${suffix} [${short}]`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.12",
+  "version": "4.0.13",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -100,9 +100,9 @@
     "headroom-ai": "0.22.4",
     "yaml": "^2.9.0",
     "zod": "^3.25.76",
-    "peaks-loop-mut": "0.1.16",
-    "peaks-loop-shared-channel": "0.0.20",
-    "peaks-loop-shared": "0.0.43"
+    "peaks-loop-shared": "0.0.44",
+    "peaks-loop-mut": "0.1.17",
+    "peaks-loop-shared-channel": "0.0.21"
   },
   "peerDependencies": {
     "@alibaba-group/open-code-review": "1.3.1"