peaks-loop 4.0.12 → 4.0.14

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/session/session-binding-bridge.js

@@ -23,11 +23,18 @@ import { dirname, join } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { initWorkspace } from '../workspace/workspace-service.js';
 import { projectRootsMatch, stableRealPath } from '../../shared/path-utils.js';
-import { getSessionId, getSessionIdCanonical, getSessionMeta, rotateSessionBinding } from './session-manager.js';
+import { getSessionId, getSessionIdCanonical, getSessionMeta, rotateSessionBinding, setSessionMeta } from './session-manager.js';
 // --- Lower-level helpers the bridge needs (moved verbatim) ---
 const SESSION_FILE = join('_runtime', 'session.json');
 const LEGACY_SESSION_FILE = '.session.json';
 const META_FILE = 'session.json';
+// Slice 2026-08-06-session-outer-cache: per-project file cache for the
+// outer (Claude Code / Trae / IDE) session id. Written by the
+// SessionStart hook via `peaks outer-cache write` so that peaks CLI
+// sub-processes (which do NOT inherit CLAUDE_CODE_SESSION_ID) can still
+// resolve the current outer session. Lives under the gitignored
+// `.peaks/_runtime/` tree, so no .gitignore change is required.
+const OUTER_SESSION_CACHE_FILE = join('_runtime', '.outer-session-cache.json');
 function getLegacySessionFilePath(projectRoot) {
     return join(projectRoot, '.peaks', LEGACY_SESSION_FILE);
 }
@@ -124,18 +131,58 @@ function writeSessionMeta(projectRoot, sessionId, meta) {
     }
     writeFileSync(metaPath, JSON.stringify(meta, null, 2), 'utf8');
 }
-function getCurrentOuterSessionId() {
+function getCurrentOuterSessionId(projectRoot) {
     const peaks = process.env.PEAKS_OUTER_SESSION_ID;
     if (typeof peaks === 'string' && peaks.length > 0)
         return peaks;
     const claude = process.env.CLAUDE_CODE_SESSION_ID;
     if (typeof claude === 'string' && claude.length > 0)
         return claude;
+    // Slice 2026-08-06-session-outer-cache (G1): when the peaks CLI runs
+    // as a sub-process of Claude Code (or any IDE that does not export
+    // CLAUDE_CODE_SESSION_ID into the child env), the env vars above are
+    // undefined. Fall back to the per-project file cache written by the
+    // SessionStart hook via `peaks outer-cache write`. The file lives
+    // under `.peaks/_runtime/` (gitignored) so no .gitignore change is
+    // required. Any IO error or non-string `outerSessionId` field is
+    // treated as a cache miss — never throw.
+    if (projectRoot !== undefined) {
+        const cachePath = join(projectRoot, '.peaks', OUTER_SESSION_CACHE_FILE);
+        if (existsSync(cachePath)) {
+            try {
+                const raw = readFileSync(cachePath, 'utf8');
+                const parsed = JSON.parse(raw);
+                if (parsed !== null &&
+                    typeof parsed === 'object' &&
+                    typeof parsed.outerSessionId === 'string' &&
+                    (parsed.outerSessionId).length > 0) {
+                    return parsed.outerSessionId;
+                }
+            }
+            catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+                // fall through — file missing / malformed JSON / IO error → undefined
+            }
+        }
+    }
     return undefined;
 }
 export async function ensureSession(projectRoot) {
     const existing = readSessionFile(projectRoot);
     if (existing) {
+        // Slice 2026-08-06-session-outer-cache (G3 / AC8-AC11): on every
+        // already-bound invocation, stamp the current outer-session-id
+        // onto the bound session's meta so the on-disk
+        // `.peaks/_runtime/<sid>/session.json` always reflects the latest
+        // outer signal — not a stale value captured at session creation
+        // time. `setSessionMeta` is read-modify-write: every other field
+        // (title / skill / mode / gate / createdAt / lastActivity) is
+        // preserved. `getCurrentOuterSessionId(projectRoot)` reads env
+        // → file-cache → undefined; an undefined value is NOT written,
+        // so the previously-stamped outer (if any) survives.
+        const outerSessionId = getCurrentOuterSessionId(projectRoot);
+        if (outerSessionId !== undefined) {
+            setSessionMeta(projectRoot, existing.sessionId, { outerSessionId });
+        }
         return existing.sessionId;
     }
     // Slice 007 — sub-agent session sharing. When the strict-equality
@@ -165,8 +212,11 @@ export async function ensureSession(projectRoot) {
     };
     writeSessionFile(projectRoot, info);
     await initWorkspace({ projectRoot, sessionId });
-    // Initialize session metadata inside the session directory
-    const outerSessionId = getCurrentOuterSessionId();
+    // Initialize session metadata inside the session directory.
+    // Slice 2026-08-06-session-outer-cache (G1): pass `projectRoot` so
+    // the env → file-cache → undefined resolution chain also reads the
+    // SessionStart-written cache on first bind.
+    const outerSessionId = getCurrentOuterSessionId(projectRoot);
     writeSessionMeta(projectRoot, sessionId, {
         sessionId,
         projectRoot,
@@ -211,7 +261,10 @@ export async function ensureSession(projectRoot) {
  */
 export async function ensureSessionWithRotation(projectRoot, options) {
     const skipRotate = options?.skipRotateOnOuterMismatch === true;
-    const currentOuterSessionId = getCurrentOuterSessionId();
+    // Slice 2026-08-06-session-outer-cache (G1): pass `projectRoot` so
+    // the rotation-decision comparison sees the SessionStart cache
+    // when the env vars are unset (sub-process / nested invocation).
+    const currentOuterSessionId = getCurrentOuterSessionId(projectRoot);
     // Compute the rotation decision up front. We only rotate when ALL
     // three pre-conditions hold: (a) the current outer session id is
     // defined, (b) the bound session has a recorded outer session id,

package/dist/services/skills/hooks-settings-service.js

@@ -4,6 +4,7 @@ import { resolve } from 'node:path';
 import { assertSafeSettingsFile } from '../ide/shared/safe-path.js';
 import { atomicWriteJson, readJsonObjectFile } from '../ide/shared/atomic-json.js';
 import { getAdapter } from '../ide/ide-registry.js';
+import { HOOK_OUTER_CACHE_COMMAND, HOOK_OUTER_CACHE_EVENT, HOOK_OUTER_CACHE_SENTINEL } from './outer-cache-hook-constants.js';
 // --- Module-level defaults (claude-code) -----------------------------------
 // These exports remain for backward compat — tests and downstream callers
 // that only care about Claude Code can keep importing them. The per-IDE
@@ -181,12 +182,25 @@ export function readInstalledEntriesFromSettings(settings, ide) {
  * entry's sentinel is included in the legacy sentinel set so uninstall
  * can find + remove any stale progress-start entry that an older
  * `peaks hooks install` may have written before this slice.
+ *
+ * Slice 2026-08-06-session-outer-cache: a SessionStart outer-cache primer
+ * entry is appended for Claude Code only (SessionStart is a Claude-Code-
+ * specific event key today).
  */
 function resolveHookEntries(ide, _skipProgress = false) {
     const spec = resolveHookSpec(ide);
-    return [
+    const entries = [
         { sentinel: spec.hookEnforceSentinel, matcher: spec.hookEnforceMatcher, command: spec.hookEnforceCommand, event: spec.hookEnforceEvent }
     ];
+    if (ide === 'claude-code') {
+        entries.push({
+            sentinel: HOOK_OUTER_CACHE_SENTINEL,
+            matcher: '',
+            command: HOOK_OUTER_CACHE_COMMAND,
+            event: HOOK_OUTER_CACHE_EVENT
+        });
+    }
+    return entries;
 }
 /**
  * Legacy sentinel set used by uninstall + status to find and remove stale
@@ -198,7 +212,13 @@ function resolveLegacySentinels(ide) {
     if (ide === 'trae') {
         return ['peaks hook handle', LEGACY_PROGRESS_START_SENTINEL];
     }
-    return [HOOK_ENFORCE_SENTINEL, LEGACY_PROGRESS_START_SENTINEL];
+    // Slice 2026-08-06-session-outer-cache: include the SessionStart outer-cache
+    // sentinel so uninstall strips it alongside the gate-enforce entry.
+    const base = [HOOK_ENFORCE_SENTINEL, LEGACY_PROGRESS_START_SENTINEL];
+    if (ide === 'claude-code') {
+        return [...base, HOOK_OUTER_CACHE_SENTINEL];
+    }
+    return base;
 }
 // --- Slice 2026-07-29-worktree-layer3-deny -----------------------------------
 // Layer 3 of the Worktree Governance 3-layer design (see

package/dist/services/skills/outer-cache-hook-constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Slice 2026-08-06-session-outer-cache (G2): per-IDE SessionStart hook
+ * constants for the outer-session cache primer. Extracted from
+ * `hooks-settings-service.ts` to keep that file under the Karpathy
+ * 800 LOC cap.
+ *
+ * The SessionStart hook is fired by Claude Code (and any future IDE
+ * that ships a SessionStart-style event) every time a new outer
+ * session begins. It runs `peaks outer-cache write`, which reads
+ * PEAKS_OUTER_SESSION_ID ?? CLAUDE_CODE_SESSION_ID from env and
+ * persists it to `.peaks/_runtime/.outer-session-cache.json` so the
+ * next peaks CLI sub-process can resolve the current outer session
+ * via `getCurrentOuterSessionId(projectRoot)`.
+ *
+ * Only Claude Code supports SessionStart today; future adapters opt
+ * in by extending `resolveHookEntries` and adding an adapter-driven
+ * substitution for the `${...}` project-dir placeholder.
+ */
+/** Sentinel substring identifying a SessionStart outer-cache hook entry. */
+export declare const HOOK_OUTER_CACHE_SENTINEL = "peaks outer-cache write";
+/** Default (claude-code) SessionStart hook command. */
+export declare const HOOK_OUTER_CACHE_COMMAND = "peaks outer-cache write --project \"${CLAUDE_PROJECT_DIR}\"";
+/** SessionStart hook event key for Claude Code. */
+export declare const HOOK_OUTER_CACHE_EVENT = "SessionStart";

package/dist/services/skills/outer-cache-hook-constants.js

@@ -0,0 +1,24 @@
+/**
+ * Slice 2026-08-06-session-outer-cache (G2): per-IDE SessionStart hook
+ * constants for the outer-session cache primer. Extracted from
+ * `hooks-settings-service.ts` to keep that file under the Karpathy
+ * 800 LOC cap.
+ *
+ * The SessionStart hook is fired by Claude Code (and any future IDE
+ * that ships a SessionStart-style event) every time a new outer
+ * session begins. It runs `peaks outer-cache write`, which reads
+ * PEAKS_OUTER_SESSION_ID ?? CLAUDE_CODE_SESSION_ID from env and
+ * persists it to `.peaks/_runtime/.outer-session-cache.json` so the
+ * next peaks CLI sub-process can resolve the current outer session
+ * via `getCurrentOuterSessionId(projectRoot)`.
+ *
+ * Only Claude Code supports SessionStart today; future adapters opt
+ * in by extending `resolveHookEntries` and adding an adapter-driven
+ * substitution for the `${...}` project-dir placeholder.
+ */
+/** Sentinel substring identifying a SessionStart outer-cache hook entry. */
+export const HOOK_OUTER_CACHE_SENTINEL = 'peaks outer-cache write';
+/** Default (claude-code) SessionStart hook command. */
+export const HOOK_OUTER_CACHE_COMMAND = `peaks outer-cache write --project "\${CLAUDE_PROJECT_DIR}"`;
+/** SessionStart hook event key for Claude Code. */
+export const HOOK_OUTER_CACHE_EVENT = 'SessionStart';

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}]`;
+}