peaks-loop 4.0.9 → 4.0.10

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 4.0.10 — 2026-08-04 (path-canonicalize + statusline-read-isolation)
+
+**Windows statusline fixed.** `peaks-loop@4.0.9` always rendered `peaks empty` on Windows Git Bash. Root cause: the session-binding reader used strict `===` to compare `projectRoot`; the binding had been written with backslashes (`C:\Users\...`) but `peaks skill presence:set --project C:/Users/...` arrived with forward slashes, and Node treats them as distinct strings. The 4.0.8 fail-closed `PEAKS_SESSION_NOT_BOUND` gate then blocked the presence marker write, and the statusline never had a real skill to display.
+
+**Cross-platform path canonicalization** (5 rid: `5ae2fa6d` / `e8b467d8` / `4e22ce39` / `033df6f6` / `8da617de`):
+- `src/services/session/session-manager.ts` + `src/services/session/session-binding-bridge.ts` — `readSessionFile` / `writeSessionFile` use the canonical `projectRootsMatch` (stableRealPath + normalizePath + isWindows case-fold).
+- `src/shared/path-utils.ts` — `projectRootsMatch` lifted from session-manager to be the single source of truth for cross-platform path comparison.
+- 17 out-of-scope `replace(/\\/g, '/')` sites consolidated to `path-utils.normalizePath`. The remaining 1 site (`karpathy-service.ts:222`) is a reverse escape (`\\` → `\\\\`) and is intentionally out of scope.
+- Hard rule entered `.peaks/standards/common/coding-style.md`: no strict `===` on filesystem paths, no hand-rolled `realpathSync` in non-`path-utils` modules, no `path.replace(/\\/g, '/')` in new code. Sediment at `.peaks/memory/2026-08-04-cross-platform-path-utility-rule.md`.
+
+**Statusline read-side isolation** (1 rid: `8da617de`):
+- `peaks statusline` now reads from `active-skill-resolver.resolveActiveSkillForCaller` (canonical lease walk) instead of the project-level single file. callerId extracted from `stdin.caller_id` → `CLAUDE_CODE_SESSION_ID` env → null fallback.
+- Multi-session isolation: `peaks skill presence:set` in session A no longer leaks into session B's statusline.
+- Active leaf display: statusline now shows `${leaf} (+N-1) | peaks-code [mode]` when sub-agents are in flight (e.g. `peaks-rd | peaks-code [full-auto]`). The 14→1 bee skill → `peaks-code` mapping in the renderer is removed.
+- **Bug fix discovered and closed during rid-005**: `active-skill-resolver.ts` was reading from the session directory root expecting `presence-*.json` files, but `presence-lease-service.ts` actually writes under `leases/` subdir. Option A fix: resolver now reads from the canonical `leases/` subdir via `listPresenceLeases`.
+
+**Shorter animation periods** (2 rid: `52a968f7` / `532bd1b1`):
+- `MARQUEE_PERIOD_MS` 2000 → 800 → 400 (statusline scan band round trip)
+- `BREATHING_PERIOD_MS` 2400 → 1200 → 600 (breathing glyph rotation)
+- `MARQUEE_BAND_WIDTH` 5 → 3 → 2 (highlight band width)
+- At 400ms / 600ms periods, 0.5-1s turn intervals produce visibly different breathing glyph + band position on every statusline render.
+
+**Tests.** 88/88 statusline vitest green; 47 path-canonicalize test cases green across 4 test files. ESM repros validate 0.5-1.5s turn-interval phase difference at the production level.
+
+**Lockstep bump.** peaks-loop-shared `0.0.39 → 0.0.40` (CLI_VERSION re-stamped to 4.0.10).
+
 ## 4.0.9 — 2026-08-04 (statusline-marquee)
 
 **statusline: brand purple + scan-band marquee + NO_COLOR support.**

package/dist/cli/commands/container-commands.js

@@ -30,6 +30,7 @@ import { addJsonOption, printResult } from '../cli-helpers.js';
 import { findProjectRoot } from '../../services/config/config-safety.js';
 import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
 import { atomicWriteJson } from '../../services/ide/shared/atomic-json.js';
+import { normalizePath } from '../../shared/path-utils.js';
 import { containerLeaseFilePath, deserializeContainerLease, finalizeContainerLease, generateContainerLeaseId, markContainerReleased, ttlForContainerRole } from '../../services/container/container-lease.js';
 const DEFAULT_DOCKER_IMAGE = 'node:22-slim';
 function detectContainerRuntime(explicit) {
@@ -114,7 +115,7 @@ export function registerContainerCommand(program, io) {
             // `--label peaks.leaseId=<id>` lets `peaks container
             // list` / `peaks container gc` find orphans by label
             // when the lease file is missing.
-            const cidFile = `${joinPathSession(projectRoot, sessionId).replace(/\\/g, '/')}/.${runtime.runtime}-cid-${leaseId}`;
+            const cidFile = `${normalizePath(joinPathSession(projectRoot, sessionId))}/.${runtime.runtime}-cid-${leaseId}`;
             try {
                 execSync(`${runtime.runtime} run --rm -d --cidfile "${cidFile}" --label "peaks.leaseId=${leaseId}" --label "peaks.rid=${options.rid}" -v "${mount}:/work" -w /work ${image} sleep infinity`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8' });
             }

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

@@ -10,6 +10,31 @@ import { getSessionId, setSessionMeta } from '../../../services/session/session-
 import { resolveCallerProjection } from '../../../services/session/resolve-caller-id.js';
 import { gcStalePresenceLeases } from '../../../services/skills/presence-lease-service.js';
 import { fail, ok } from 'peaks-loop-shared/result';
+import { stableRealPath } from '../../../shared/path-utils.js';
+/**
+ * Canonicalize a user-supplied `--project <path>` value.
+ *
+ * Git Bash on Windows hands us forward-slash paths
+ * (`C:/Users/.../peaks-loop`) while `peaks workspace init` writes the
+ * backslash form, and either side may carry a trailing separator or
+ * differing case. Resolving to the real path here means every
+ * downstream consumer (`getSessionId`, `setSessionMeta`,
+ * `setSkillPresence`) sees one stable form.
+ *
+ * Returns the input unchanged when it cannot be resolved (path does
+ * not exist yet, or is not readable) so a bad `--project` still
+ * reaches the existing error handling rather than throwing here.
+ */
+function canonicalizeProjectOption(project) {
+    if (project === undefined)
+        return undefined;
+    try {
+        return stableRealPath(project);
+    }
+    catch {
+        return project;
+    }
+}
 import { addJsonOption, getErrorMessage, printResult } from '../../cli-helpers.js';
 // Slice S0 (4.0.0-beta.5 peaks-solo dispatcher release):
 // `peaks skill search` is the CLI primitive that feeds the
@@ -143,7 +168,8 @@ export function registerSkillCommand(program, io) {
         .description('Show the currently active Peaks skill (alias: presence:get)')
         .option('--check-stale', 'slice 002 (v2.15.0): also report whether the recorded outer session id still matches the current one. Default false (back-compat).')
         .option('--project <path>', 'project root (default: cwd)')).action((options) => {
-        const presence = getSkillPresence(options.project);
+        const projectOption = canonicalizeProjectOption(options.project);
+        const presence = getSkillPresence(projectOption);
         if (presence === null) {
             printResult(io, ok('skill.presence', { active: false }), options.json);
             return;
@@ -154,7 +180,7 @@ export function registerSkillCommand(program, io) {
             // pieces of info from a single CLI invocation. The presence
             // is returned UNCHANGED — `--check-stale` is a read-only flag,
             // not a clear.
-            const staleness = checkStalePresence({ projectRootOverride: options.project });
+            const staleness = checkStalePresence({ projectRootOverride: projectOption });
             printResult(io, ok('skill.presence', {
                 active: true,
                 ...presence,
@@ -173,7 +199,8 @@ export function registerSkillCommand(program, io) {
         .option('--mode <mode>', 'execution mode')
         .option('--gate <gate>', 'current gate')
         .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')).action((name, options) => {
-        const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+        const projectOption = canonicalizeProjectOption(options.project);
+        const projectRoot = projectOption ?? findProjectRoot(process.cwd()) ?? process.cwd();
         if (options.mode !== undefined && !isSkillPresenceMode(options.mode)) {
             printResult(io, fail('skill.presence:set', 'INVALID_MODE', `Invalid mode: ${options.mode} (expected one of: full-auto, assisted, swarm, strict)`, { name, mode: options.mode }, ['Use a valid mode: full-auto, assisted, swarm, or strict']), options.json);
             process.exitCode = 1;
@@ -198,11 +225,11 @@ export function registerSkillCommand(program, io) {
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             printResult(io, fail('skill.presence:set', 'PEAKS_CALLER_NOT_RESOLVED', `Active IDE adapter could not resolve a callerId (RD §3 D1): ${message}`, { projectRoot, name }, ['Ensure the active IDE is detected by `peaks` and the IDE session variable is set.',
-                'Or pass PEAKS_CALLER_ID=<id> or --caller-id <id> for scripted usage.']), options.json);
+                'Or set PEAKS_CALLER_ID=<id> in the environment for scripted usage.']), options.json);
             process.exitCode = 1;
             return;
         }
-        const presence = setSkillPresence(name, options.mode, options.gate, options.project);
+        const presence = setSkillPresence(name, options.mode, options.gate, projectOption);
         // Session metadata is updated when a session is bound (read-only
         // path: `getSessionId`). We do not auto-spawn a session.
         if (boundSessionId !== null) {

package/dist/cli/commands/openspec-commands.js

@@ -9,11 +9,12 @@ import { proposeFromDoctor } from '../../services/openspec/openspec-propose-from
 import { runDoctor } from '../../services/doctor/index.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { normalizePath } from '../../shared/path-utils.js';
 function resolveScanOptions(project) {
     if (project === undefined) {
         return {};
     }
-    return { openspecRoot: `${project.replace(/\\/g, '/').replace(/\/$/, '')}/openspec` };
+    return { openspecRoot: `${normalizePath(project).replace(/\/$/, '')}/openspec` };
 }
 async function loadRenderRequest(requestPath) {
     const raw = await readFile(requestPath, 'utf8');

package/dist/services/audit/enforcers/active-skill-resolver.d.ts

@@ -28,6 +28,16 @@ export interface ActiveSkillResolution {
     readonly skill: string | null;
     readonly callerId: string | null;
     readonly sessionId: string | null;
+    /**
+     * Mode token recorded on the canonical lease (e.g. `full-auto`,
+     * `assisted`, `swarm`, `strict`). `null` when the source is not
+     * `canonical` (the legacy `active-skill-*.json` files do not
+     * surface a mode field, and the `env` / `none` cases are test
+     * overrides). Slice 2026-08-04-rid-005 surfaced this so the
+     * statusline can render the orchestrator's mode alongside the
+     * active leaf role.
+     */
+    readonly mode: string | null;
     /** `canonical` = presence-lease-service; `legacy` = per-caller active-skill file; `env` = test override; `none` = nothing wired. */
     readonly source: 'env' | 'file' | 'canonical' | 'none';
 }
@@ -42,4 +52,5 @@ export interface ActiveSkillResolution {
  */
 export declare function resolveActiveSkillForCaller(projectRoot: string, opts?: {
     legacyPresence?: boolean;
+    callerId?: string | null;
 }): ActiveSkillResolution;

package/dist/services/audit/enforcers/active-skill-resolver.js

@@ -24,11 +24,11 @@
  *      `legacyPresence === true` is passed by the caller
  *   4. null (caller did not set a skill; enforcers can decide to skip)
  */
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { getSessionIdCanonical } from '../../session/session-manager.js';
 import { getSessionDir } from '../../session/getSessionDir.js';
-import { readPresenceLease } from '../../skills/presence-lease-service.js';
+import { readPresenceLease, listPresenceLeases } from '../../skills/presence-lease-service.js';
 import { getCurrentSessionId } from '../../skills/skill-presence-service.js';
 const ACTIVE_SKILL_PREFIX = 'active-skill-';
 /**
@@ -43,71 +43,82 @@ const ACTIVE_SKILL_PREFIX = 'active-skill-';
 export function resolveActiveSkillForCaller(projectRoot, opts) {
     const envOverride = process.env.PEAKS_ACTIVE_SKILL;
     if (typeof envOverride === 'string' && envOverride.length > 0) {
-        return { skill: envOverride, callerId: null, sessionId: null, source: 'env' };
+        return { skill: envOverride, callerId: null, sessionId: null, mode: null, source: 'env' };
     }
     let sessionId = null;
     try {
         sessionId = getSessionIdCanonical(projectRoot);
     }
     catch {
-        return { skill: null, callerId: null, sessionId: null, source: 'none' };
+        return { skill: null, callerId: null, sessionId: null, mode: null, source: 'none' };
     }
     if (sessionId === null) {
-        return { skill: null, callerId: null, sessionId: null, source: 'none' };
+        return { skill: null, callerId: null, sessionId: null, mode: null, source: 'none' };
     }
     // 4.0.8 preferred: read the canonical lease projection. The lease
-    // service exposes `readPresenceLease({ projectRoot, sessionId,
-    // callerId, workflowId, graphRef })`; we need *some* callerId to
-    // point at a single lease. Hook enforcers don't have a callerId
-    // (they're per-IDE, per-window), so we walk the canonical
-    // presence-index to find any active lease. When the index is empty
-    // (e.g. ad-hoc / pre-migration projects) we fall through to the
-    // legacy walk below.
+    // service writes leases to `<sessionDir>/leases/presence-<caller>-<workflow>.json`
+    // (RD §4). We enumerate that directory via `listPresenceLeases`,
+    // which is the lease-service's own helper and knows the canonical
+    // layout. The first in-flight (status === 'preparing' | 'running')
+    // lease wins; this preserves the prior behaviour of returning a
+    // single skill per resolution. When the lease dir is empty (e.g.
+    // ad-hoc / pre-migration projects) we fall through to the legacy
+    // walk below.
     const sessionDir = getSessionDir(projectRoot, sessionId);
     if (!existsSync(sessionDir)) {
-        return { skill: null, callerId: null, sessionId, source: 'none' };
+        return { skill: null, callerId: null, sessionId, mode: null, source: 'none' };
     }
-    let entries = [];
+    let canonicalLeases = [];
     try {
-        entries = readdirSync(sessionDir);
+        canonicalLeases = listPresenceLeases(projectRoot, sessionId);
     }
     catch {
-        entries = [];
+        canonicalLeases = [];
     }
-    const indexEntries = entries.filter((e) => !e.startsWith(ACTIVE_SKILL_PREFIX) && e.endsWith('.json') && !e.includes('.tmp-'));
-    for (const entry of indexEntries) {
-        // The canonical presence-index lives at `<sessionDir>/presence-index/<callerId>.json`.
-        // We synthesise the read from any presence-* lease file we find;
-        // the readPresenceLease call surfaces a typed `PresenceProjection`
-        // and we map `lease.skill` → resolution.
-        if (!entry.startsWith('presence-'))
+    for (const lease of canonicalLeases) {
+        if (lease.status !== 'preparing' && lease.status !== 'running')
             continue;
-        const callerId = entry.slice('presence-'.length, -'.json'.length);
-        // Derive workflowId from the same file name (canonical
-        // leaseFilePath encodes `presence-<caller>-<workflow>.json`).
-        const lastDash = callerId.lastIndexOf('-');
-        if (lastDash < 0)
+        if (typeof lease.skill !== 'string' || lease.skill.length === 0)
+            continue;
+        // When a callerId is supplied, restrict the walk to that
+        // caller's lease. Slice 2026-08-04-rid-005 surfaces this for the
+        // statusline read so two concurrent sessions bound to the same
+        // project session do not see each other's skill.
+        if (typeof opts?.callerId === 'string' && opts.callerId.length > 0 && lease.callerId !== opts.callerId)
             continue;
-        const workflowId = callerId.slice(lastDash + 1);
-        const pureCaller = callerId.slice(0, lastDash);
         try {
             const projection = readPresenceLease({
                 projectRoot,
                 sessionId,
-                callerId: pureCaller,
-                workflowId,
-                graphRef: `graphs/${workflowId}.json`,
+                callerId: lease.callerId,
+                workflowId: lease.workflowId,
+                graphRef: lease.graphRef,
             });
             if (projection.lease !== null && typeof projection.lease.skill === 'string' && projection.lease.skill.length > 0) {
-                return { skill: projection.lease.skill, callerId: pureCaller, sessionId, source: 'canonical' };
+                return {
+                    skill: projection.lease.skill,
+                    callerId: lease.callerId,
+                    sessionId,
+                    mode: typeof projection.mode === 'string' && projection.mode.length > 0 ? projection.mode : null,
+                    source: 'canonical',
+                };
             }
         }
-        catch { /* fall through to legacy walk */ }
+        catch { /* fall through to next lease */ }
     }
     // Legacy fall-back (one minor release). Gated on `legacyPresence:
-    // true` so production hooks prefer the canonical projection.
+    // true` so production hooks prefer the canonical projection. Reads
+    // the session dir root for the per-caller `active-skill-*.json`
+    // marker files written by the 4.0.7 `setSkillPresenceForCaller`.
     if (opts?.legacyPresence === true) {
-        for (const entry of entries) {
+        let legacyEntries = [];
+        try {
+            legacyEntries = readdirSync(sessionDir);
+        }
+        catch {
+            legacyEntries = [];
+        }
+        for (const entry of legacyEntries) {
             if (!entry.startsWith(ACTIVE_SKILL_PREFIX) || !entry.endsWith('.json'))
                 continue;
             const callerId = entry.slice(ACTIVE_SKILL_PREFIX.length, -'.json'.length);
@@ -116,7 +127,7 @@ export function resolveActiveSkillForCaller(projectRoot, opts) {
                 const raw = readFileSync(filePath, 'utf8');
                 const parsed = JSON.parse(raw);
                 if (typeof parsed.skill === 'string' && parsed.skill.length > 0) {
-                    return { skill: parsed.skill, callerId, sessionId, source: 'file' };
+                    return { skill: parsed.skill, callerId, sessionId, mode: null, source: 'file' };
                 }
             }
             catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
@@ -129,5 +140,5 @@ export function resolveActiveSkillForCaller(projectRoot, opts) {
     // walk can still resolve a session id if the canonical resolver
     // returns null (e.g. ad-hoc projects without a `.peaks/_runtime/session.json`).
     void getCurrentSessionId;
-    return { skill: null, callerId: null, sessionId, source: 'none' };
+    return { skill: null, callerId: null, sessionId, mode: null, source: 'none' };
 }

package/dist/services/container/container-lease.js

@@ -29,6 +29,7 @@
  */
 import { randomBytes } from 'node:crypto';
 import { posix as path } from 'node:path';
+import { normalizePath } from '../../shared/path-utils.js';
 export const DEFAULT_TTL_BY_ROLE = Object.freeze({
     rd: 30 * 60 * 1_000,
     qa: 15 * 60 * 1_000,
@@ -126,7 +127,7 @@ export function deserializeContainerLease(raw) {
 function joinPath(...segments) {
     if (segments.length === 0)
         return '';
-    const normalized = segments.map((s) => s.replace(/\\/g, '/'));
+    const normalized = segments.map((s) => normalizePath(s));
     let acc = normalized[0];
     for (let i = 1; i < normalized.length; i++) {
         acc = path.join(acc, normalized[i]);

package/dist/services/impact/impact-scan-service.js

@@ -13,6 +13,7 @@
  * command; `peaks impact must-check` returns the must-check list
  * subset. Persistence is per-invocation (no state file).
  */
+import { normalizePath } from '../../shared/path-utils.js';
 /**
  * Default business flow map (covers the most common B-end
  * archetypes; users can override via --flows in the CLI).
@@ -34,7 +35,7 @@ export const DEFAULT_BUSINESS_FLOWS = new Map([
  * (the file itself, the parent dir, the project-wide pattern).
  */
 function pathToGlobs(path) {
-    const normalized = path.replace(/\\/g, '/');
+    const normalized = normalizePath(path);
     const parts = normalized.split('/');
     // Drop the filename → get the parent pattern: "src/foo/" → "src/**"
     const parent = parts.length > 1 ? parts.slice(0, -1).join('/') + '/**' : '**';
@@ -42,7 +43,7 @@ function pathToGlobs(path) {
 }
 /** Simple glob matcher supporting `**` and `*`. */
 export function matchGlob(pattern, path) {
-    const normalizedPath = path.replace(/\\/g, '/');
+    const normalizedPath = normalizePath(path);
     // Build regex by splitting on glob tokens, escaping the rest.
     // Order: ** (doublestar) → .* ; * → [^/]* ; other → escape
     let regexStr = '';
@@ -108,7 +109,7 @@ export function runImpactScan(opts) {
     // Predict other files that may be affected (siblings of changed files).
     const impactedFiles = [];
     for (const f of changed) {
-        const parts = f.replace(/\\/g, '/').split('/');
+        const parts = normalizePath(f).split('/');
         if (parts.length <= 1)
             continue;
         const parent = parts.slice(0, -1).join('/');

package/dist/services/migrate-skill-name/migrate.js

@@ -19,6 +19,7 @@
  */
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { join, relative } from 'node:path';
+import { normalizePath } from '../../shared/path-utils.js';
 /**
  * Skip-paths are matched against the path relative to `projectRoot`,
  * forward-slashed (Windows-friendly). Each entry is a SUBSTRING —
@@ -41,7 +42,7 @@ function escapeRe(input) {
 }
 /** True iff `absPath` falls under any skip-path (substring match). */
 export function shouldSkip(projectRoot, absPath) {
-    const rel = relative(projectRoot, absPath).replace(/\\/g, '/');
+    const rel = normalizePath(relative(projectRoot, absPath));
     return SKIP_DIRS.some((skip) => rel.includes(skip));
 }
 /**

package/dist/services/openspec/artifact-boundary.js

@@ -22,6 +22,7 @@
  */
 import { posix, relative, resolve, isAbsolute as nodeIsAbsolute } from 'node:path';
 import { isPathInsideArtifactRoot as _isPathInsideArtifactRoot } from '../../shared/path-safety.js';
+import { normalizePath } from '../../shared/path-utils.js';
 export function ok(value) {
     return { ok: true, value };
 }
@@ -111,7 +112,7 @@ export function planArtifactPath(input) {
     // Always normalize separators to forward-slashes for the JSON-safe output,
     // then run posix.normalize so empty segments (foo//bar) and `..` segments
     // collapse to canonical form.
-    const forwardSlashed = candidateRaw.replace(/\\/g, '/');
+    const forwardSlashed = normalizePath(candidateRaw);
     const normalized = posix.normalize(forwardSlashed);
     // Resolve against workspaceRoot. If the candidate is already absolute,
     // posix.normalize preserves the leading `/`; `resolve` keeps it absolute
@@ -129,7 +130,7 @@ export function planArtifactPath(input) {
         });
     }
     const relativePath = relative(workspaceRoot, absolutePath);
-    const jsonSafeRelativePath = relativePath.replace(/\\/g, '/');
+    const jsonSafeRelativePath = normalizePath(relativePath);
     return ok({ absolutePath, relativePath, jsonSafeRelativePath });
 }
 const WORKSPACE_UNAVAILABLE_NEXT_ACTIONS = [

package/dist/services/openspec/coverage-evidence-reader.js

@@ -24,6 +24,7 @@ import { posix, relative, resolve } from 'node:path';
 import { readFile, stat } from 'node:fs/promises';
 import { isDirectory } from 'peaks-loop-shared/fs';
 import { ok, err } from './artifact-boundary.js';
+import { normalizePath } from '../../shared/path-utils.js';
 // ---------------------------------------------------------------------------
 // Discovery
 // ---------------------------------------------------------------------------
@@ -63,7 +64,7 @@ export async function resolveCoverageSummaryPath(input) {
     return err({ code: 'missing', triedPaths });
 }
 function toPosix(p) {
-    return p.replace(/\\/g, '/').replace(/\/$/, '');
+    return normalizePath(p).replace(/\/$/, '');
 }
 async function isReadable(p) {
     try {
@@ -112,7 +113,7 @@ export async function readC8Summary(path) {
         if (lines === null || statements === null || functions === null || branches === null) {
             continue;
         }
-        const normalizedKey = posix.normalize(key.replace(/\\/g, '/'));
+        const normalizedKey = posix.normalize(normalizePath(key));
         files.set(normalizedKey, {
             path: normalizePathSep(normalizedKey),
             relativePath: normalizedKey,
@@ -141,7 +142,7 @@ function asMetric(input) {
     return { pct, covered, total };
 }
 function normalizePathSep(p) {
-    return p.replace(/\\/g, '/');
+    return normalizePath(p);
 }
 // ---------------------------------------------------------------------------
 // Capability Mapping block parser (proposal.md)
@@ -215,7 +216,7 @@ function parseCapabilityRow(line) {
         return null;
     const row = {
         capability,
-        source: source.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/$/, ''),
+        source: normalizePath(source).replace(/^\.\//, '').replace(/\/$/, ''),
     };
     if (testAnchor !== undefined && testAnchor !== '') {
         row.testAnchor = testAnchor;
@@ -236,7 +237,7 @@ function parseCapabilityRow(line) {
 export async function resolveCapabilityFiles(input) {
     const abs = resolve(input.projectRoot, input.row.source);
     if (!(await isDirectory(abs))) {
-        const rel = relative(input.projectRoot, abs).replace(/\\/g, '/');
+        const rel = normalizePath(relative(input.projectRoot, abs));
         return [rel];
     }
     return await walkTsFiles(abs, input.projectRoot);
@@ -261,7 +262,7 @@ async function walkTsFiles(absRoot, projectRoot) {
                 stack.push(full);
             }
             else if (entry.isFile() && entry.name.endsWith('.ts')) {
-                const rel = relative(projectRoot, full).replace(/\\/g, '/');
+                const rel = normalizePath(relative(projectRoot, full));
                 out.push(rel);
             }
         }
@@ -339,7 +340,7 @@ export async function validateCapabilityCoverage(input) {
 export async function findStaleChangeFiles(input) {
     const { stat: statFn } = await import('node:fs/promises');
     const summaryMtime = (await statFn(input.summary.path)).mtimeMs;
-    const changeRoot = `${input.openspecRoot.replace(/\\/g, '/').replace(/\/$/, '')}/changes/${input.changeId}`;
+    const changeRoot = `${normalizePath(input.openspecRoot).replace(/\/$/, '')}/changes/${input.changeId}`;
     const candidates = [
         `${changeRoot}/proposal.md`,
         `${changeRoot}/tasks.md`,
@@ -375,7 +376,7 @@ export async function findStaleChangeFiles(input) {
         try {
             const m = (await statFn(candidate)).mtimeMs;
             if (m > summaryMtime) {
-                stale.push(relative(input.projectRoot, candidate).replace(/\\/g, '/'));
+                stale.push(normalizePath(relative(input.projectRoot, candidate)));
             }
         }
         catch {

package/dist/services/prd/handoff-auto-regen.js

@@ -16,6 +16,7 @@ import { dirname, join } from 'node:path';
 import { createHash } from 'node:crypto';
 import { showRequestArtifact } from '../artifacts/request-artifact-service.js';
 import { sha256OfBody } from './handoff-service.js';
+import { normalizePath } from '../../shared/path-utils.js';
 /**
  * Auto-regen the prd/handoff.md under `.peaks/_runtime/<sid>/prd/`.
  * Returns the outcome; never throws.
@@ -58,7 +59,7 @@ export async function autoRegenPrdHandoff(opts) {
         'goals: []',
         'acceptanceCriteria: []',
         'preservedBehavior: []',
-        `handoffPath: ${handoffPath.replace(opts.projectRoot, '').replace(/\\/g, '/').replace(/^\//, '')}`,
+        `handoffPath: ${normalizePath(handoffPath.replace(opts.projectRoot, '')).replace(/^\//, '')}`,
         '---',
         ''
     ].join('\n');

package/dist/services/scan/type-sanity-service.js

@@ -1,5 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { extname, basename } from 'node:path';
+import { normalizePath } from '../../shared/path-utils.js';
 const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.vue', '.svelte', '.py', '.go', '.rs', '.java', '.kt', '.swift', '.cpp', '.c', '.h', '.cs', '.rb', '.php', '.scala', '.dart', '.less', '.scss', '.sass', '.css']);
 const DOCS_EXTENSIONS = new Set(['.md', '.mdx', '.rst', '.txt']);
 const LOCKFILE_NAMES = new Set(['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock', 'bun.lockb', 'Cargo.lock', 'Gemfile.lock', 'composer.lock', 'go.sum', 'poetry.lock']);
@@ -32,7 +33,7 @@ function classifyFile(filePath) {
  * wrote `.peaks/**` markdown would be misclassified as a docs change.
  */
 function isArtifactWorkspaceFile(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
+    const normalized = normalizePath(filePath);
     return normalized === '.peaks' || normalized.startsWith('.peaks/');
 }
 function tryGitDiffFiles(projectRoot, baseRef) {

package/dist/services/session/session-binding-bridge.js

@@ -18,10 +18,11 @@
  * Body of every function moved verbatim per Karpathy #3 (Surgical
  * Changes). No behavior change. The bridge adds nothing of its own.
  */
-import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+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';
 // --- Lower-level helpers the bridge needs (moved verbatim) ---
 const SESSION_FILE = join('_runtime', 'session.json');
@@ -30,18 +31,6 @@ const META_FILE = 'session.json';
 function getLegacySessionFilePath(projectRoot) {
     return join(projectRoot, '.peaks', LEGACY_SESSION_FILE);
 }
-function canonicalizeProjectRoot(p) {
-    try {
-        return realpathSync(p);
-    }
-    catch {
-        return resolve(p);
-    }
-}
-function resolveStoredAgainstCaller(stored, caller) {
-    const resolved = resolve(caller, stored);
-    return canonicalizeProjectRoot(resolved);
-}
 function generateSessionId() {
     const now = new Date();
     const year = now.getFullYear();
@@ -62,7 +51,9 @@ function readSessionFile(projectRoot) {
         return null;
     try {
         const data = JSON.parse(readFileSync(pathToRead, 'utf8'));
-        if (data.sessionId && data.projectRoot === projectRoot) {
+        if (data.sessionId &&
+            typeof data.projectRoot === 'string' &&
+            projectRootsMatch(data.projectRoot, projectRoot)) {
             return data;
         }
         return null;
@@ -79,10 +70,9 @@ function readSessionFileCanonical(projectRoot) {
         return null;
     try {
         const data = JSON.parse(readFileSync(pathToRead, 'utf8'));
-        const storedRaw = typeof data.projectRoot === 'string' ? data.projectRoot : null;
         if (data.sessionId &&
-            storedRaw !== null &&
-            resolveStoredAgainstCaller(storedRaw, projectRoot) === resolveStoredAgainstCaller(projectRoot, projectRoot)) {
+            typeof data.projectRoot === 'string' &&
+            projectRootsMatch(data.projectRoot, projectRoot)) {
             return data;
         }
         return null;
@@ -97,7 +87,15 @@ function writeSessionFile(projectRoot, info) {
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
-    writeFileSync(sessionFile, JSON.stringify(info, null, 2), 'utf8');
+    let canonicalProjectRoot;
+    try {
+        canonicalProjectRoot = stableRealPath(info.projectRoot);
+    }
+    catch {
+        canonicalProjectRoot = info.projectRoot;
+    }
+    const canonicalInfo = { ...info, projectRoot: canonicalProjectRoot };
+    writeFileSync(sessionFile, JSON.stringify(canonicalInfo, null, 2), 'utf8');
 }
 function getMetaFilePath(projectRoot, sessionId) {
     return join(projectRoot, '.peaks', '_runtime', sessionId, META_FILE);

package/dist/services/session/session-manager.js

@@ -9,6 +9,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, unlinkS
 import { mkdir as mkdirAsync } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { randomBytes } from 'node:crypto';
+import { projectRootsMatch, stableRealPath } from '../../shared/path-utils.js';
 import { ensureSession } from './session-binding-bridge.js';
 // As of slice 2026-06-05-peaks-runtime-layer the project-level session
 // binding lives under `.peaks/_runtime/session.json`. The legacy
@@ -89,17 +90,22 @@ function getSessionFilePath(projectRoot) {
  * Read existing session info from disk.
  * Returns null if no session file exists or if it's invalid.
  *
- * Strict equality on `data.projectRoot === projectRoot` is
- * preserved here on purpose: many other modules depend on
- * the strict-equality semantics to test the "no session bound"
- * code path. Changing the read semantics here would cascade
- * into many test failures — out of scope for the progress
- * rebind fix.
+ * The `projectRoot` comparison is canonicalized (separator, symlink,
+ * and — on Windows only — case) via `projectRootsMatch`. Before
+ * slice `2026-08-04-rid-001-path-canonicalize` this was a strict
+ * `===`, which returned null whenever the stored form differed
+ * cosmetically from the caller-passed form. On Windows Git Bash that
+ * is the common case: `peaks workspace init` stores
+ * `C:\Users\...\peaks-loop` while the caller passes
+ * `C:/Users/.../peaks-loop`, so every `getSessionId` returned null and
+ * `presence:set` failed closed with `PEAKS_SESSION_NOT_BOUND` —
+ * surfacing to the user as a permanent `peaks empty` statusline.
  *
- * The progress subcommands (which are the surface that
- * actually breaks on the rebind bug) use
- * `getSessionIdCanonical` instead, which does the
- * canonicalize-on-read resolution the bug fix needs.
+ * Canonicalization is a strict widening: paths that denote the same
+ * physical directory now match, and paths that denote different
+ * directories still do not (pinned by the Case 4 regression test in
+ * `tests/unit/session/session-manager-path-canonicalize.test.ts`), so
+ * the "no session bound" code path other modules depend on is intact.
  */
 function readSessionFile(projectRoot) {
     const sessionFile = getSessionFilePath(projectRoot);
@@ -112,7 +118,7 @@ function readSessionFile(projectRoot) {
         return null;
     try {
         const data = JSON.parse(readFileSync(pathToRead, 'utf8'));
-        if (data.sessionId && data.projectRoot === projectRoot) {
+        if (data.sessionId && typeof data.projectRoot === 'string' && projectRootsMatch(data.projectRoot, projectRoot)) {
             return data;
         }
         return null;
@@ -157,6 +163,13 @@ function readSessionFileCanonical(projectRoot) {
  * `.peaks/_runtime/session.json`. The `.peaks/_runtime/` directory is
  * created on demand. The legacy `.peaks/.session.json` is NOT written by
  * this slice; it is only read for back-compat.
+ *
+ * The persisted `projectRoot` is passed through `stableRealPath` so the
+ * stored form is symlink-resolved and stable across callers. We store
+ * the REAL path, not the `projectRootCompareKey` — the key is
+ * lossy (lower-cased on Windows) and is only ever a comparison
+ * artifact. Reads tolerate either form via `projectRootsMatch`, so
+ * bindings written by older versions keep resolving.
  */
 function writeSessionFile(projectRoot, info) {
     const sessionFile = getSessionFilePath(projectRoot);
@@ -164,7 +177,18 @@ function writeSessionFile(projectRoot, info) {
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
-    writeFileSync(sessionFile, JSON.stringify(info, null, 2), 'utf8');
+    let canonicalProjectRoot;
+    try {
+        canonicalProjectRoot = stableRealPath(info.projectRoot);
+    }
+    catch {
+        // Never block a write on canonicalization: if the path cannot be
+        // realpath'd, persist the caller's form unchanged. Reads canonicalize
+        // both sides anyway, so a non-canonical stored value still matches.
+        canonicalProjectRoot = info.projectRoot;
+    }
+    const canonicalInfo = { ...info, projectRoot: canonicalProjectRoot };
+    writeFileSync(sessionFile, JSON.stringify(canonicalInfo, null, 2), 'utf8');
 }
 /**
  * Drop the project-level session binding at the canonical

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

@@ -137,26 +137,7 @@ function buildPalette(capability, noColor) {
 }
 const BREATHING_GLYPHS_UNICODE = ['●', '◐', '◑', '◒', '◓'];
 const BREATHING_GLYPHS_ASCII = ['*', 'o', '+', '~', '|'];
-const BREATHING_PERIOD_MS = 2_400;
-/**
- * Bee-tier (1-level sub-role) skills and their full orchestrator
- * parent name. The terminal status line shows both layers when a bee
- * is active: the active bee name plus a `↑<parent-full>` marker
- * pointing at the dispatching orchestrator.
- */
-const BEE_TO_PARENT = {
-    'peaks-prd': 'peaks-code',
-    'peaks-rd': 'peaks-code',
-    'peaks-qa': 'peaks-code',
-    'peaks-ui': 'peaks-code',
-    'peaks-sc': 'peaks-code',
-    'peaks-txt': 'peaks-code',
-    'peaks-final-review': 'peaks-code',
-    'peaks-resume': 'peaks-code',
-    'peaks-status': 'peaks-code',
-    'peaks-test': 'peaks-code',
-    'peaks-reviewer': 'peaks-code',
-};
+const BREATHING_PERIOD_MS = 600;
 function pickBreathingGlyph(capability, nowMs) {
     const set = capability === 'ascii' ? BREATHING_GLYPHS_ASCII : BREATHING_GLYPHS_UNICODE;
     const index = Math.floor((nowMs % BREATHING_PERIOD_MS) / (BREATHING_PERIOD_MS / set.length)) % set.length;
@@ -210,8 +191,23 @@ function rootLabel(projectRoot) {
  * prefix and the project root label. Kept separate so the token layout
  * is obvious at the call site and so each state has a single
  * responsibility.
+ *
+ * Active-leaf rendering (slice 2026-08-04-rid-005-statusline-dual-skill):
+ * when the model carries an `activeLeaf` (an in-flight bee dispatch under
+ * the orchestrator), the line surfaces the leaf role alongside the
+ * orchestrator skill. The render priorities are:
+ *
+ *   - activeLeaf === null                       → `${skill}` (current behavior)
+ *   - activeLeaf.pendingCount === 1             → `${leaf} | ${skill}`
+ *   - activeLeaf.pendingCount > 1               → `${leaf} (+${N-1}) | ${skill}`
+ *
+ * The orchestrator skill itself is rendered with its mode token; the leaf
+ * role is rendered without a mode (the leaf does not own the mode state —
+ * the orchestrator does). The 14→1 bee skill mapping that previously
+ * forced every bee role to render with a `↑<parent>` marker was removed
+ * in this slice; the dual-skill layout above replaces it.
  */
-function renderActive(presence, palette, nowMs, capability, noColor) {
+function renderActive(presence, palette, nowMs, capability, noColor, activeLeaf) {
     if (!presence) {
         return `${palette.idle} ${palette.idleLabel}`;
     }
@@ -222,16 +218,17 @@ function renderActive(presence, palette, nowMs, capability, noColor) {
     }
     const skill = presence.skill;
     const dot = renderActiveDot(capability, nowMs, noColor);
-    const beeParent = BEE_TO_PARENT[skill];
     const modeToken = typeof presence.mode === 'string' && presence.mode.length > 0
         ? brandRun(` [${presence.mode}]`, noColor, capability)
         : '';
-    // Bee-tier skills surface both layers: the active bee name plus
-    // the full parent orchestrator name. Mode is shown for every
-    // active skill (not just peaks-code) so the line carries the same
-    // mode taxonomy for any bee in flight.
-    if (beeParent !== undefined) {
-        return `${dot} ${brandRun(skill, noColor, capability)} ${brandRun(`↑${beeParent}`, noColor, capability)}${modeToken}`;
+    // Dual-skill layout: leaf role (in-flight bee) + orchestrator skill.
+    if (activeLeaf !== null) {
+        const leaf = brandRun(activeLeaf.role, noColor, capability);
+        const tail = activeLeaf.pendingCount > 1
+            ? ` ${brandRun(`(+${activeLeaf.pendingCount - 1})`, noColor, capability)}`
+            : '';
+        const sep = brandRun(' | ', noColor, capability);
+        return `${dot} ${leaf}${tail}${sep}${brandRun(skill, noColor, capability)}${modeToken}`;
     }
     return `${dot} ${brandRun(skill, noColor, capability)}${modeToken}`;
 }
@@ -401,7 +398,7 @@ export function isNoColorEnv(env) {
 }
 /**
  * Marquee scan band — a single-pass light band that sweeps left ↔ right
- * across the entire status line on a 2 s round trip. The band's
+ * across the entire status line on a 0.4 s round trip. The band's
  * foreground color is `#E0E0E0` (off-white) with `1;` (bold) — see
  * {@link HIGHLIGHT_SGR_OPEN}. Cells OUTSIDE the band keep their
  * original SGR (brand purple or semantic warning/failed); only cells
@@ -430,8 +427,8 @@ export function isNoColorEnv(env) {
  *
  * ASCII tier: skipped — there are no SGR codes to inject.
  */
-const MARQUEE_PERIOD_MS = 2_000;
-const MARQUEE_BAND_WIDTH = 5;
+const MARQUEE_PERIOD_MS = 400;
+const MARQUEE_BAND_WIDTH = 2;
 /**
  * Visible-character width of an ANSI-bearing string. Skips every
  * `\x1b[...m` escape so the count reflects what the terminal paints,
@@ -590,7 +587,7 @@ export function renderStatusLine(model, options, env) {
     else {
         switch (model.state) {
             case 'active':
-                line = `${brand} ${renderActive(model.presence, palette, nowMs, capability, noColor)}${rootSuffix}`;
+                line = `${brand} ${renderActive(model.presence, palette, nowMs, capability, noColor, model.activeLeaf)}${rootSuffix}`;
                 break;
             case 'stale':
                 line = `${brand} ${renderStale(model.presence, model.ageMs, palette, capability, noColor)}${rootSuffix}`;

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

@@ -6,6 +6,7 @@ export type StatusLineStdin = {
     };
     cwd?: string;
     session_id?: string;
+    caller_id?: string;
 };
 export type StatusLineState = 'active' | 'idle' | 'stale' | 'invalid-presence';
 export type StatusLinePresence = {
@@ -15,12 +16,17 @@ export type StatusLinePresence = {
     setAt?: string;
     claudeSessionId?: string;
 };
+export type StatusLineActiveLeaf = {
+    role: string;
+    pendingCount: number;
+};
 export type StatusLineModel = {
     state: StatusLineState;
     projectRoot: string | null;
     presence: StatusLinePresence | null;
     ageMs: number | null;
     compact: CompactStatuslineState;
+    activeLeaf: StatusLineActiveLeaf | 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

@@ -3,6 +3,8 @@ import { resolve } from 'node:path';
 import { findProjectRoot } from '../config/config-safety.js';
 import { decideCompactStatusline } from '../compact-statusline/compact-statusline-service.js';
 import { getSessionIdCanonical } from '../session/session-manager.js';
+import { resolveActiveSkillForCaller } from '../audit/enforcers/active-skill-resolver.js';
+import { readActiveDispatchIndex } from '../dispatch/dispatch-record-writer.js';
 /**
  * Out-of-band Peaks skill status renderer for the Claude Code statusLine.
  *
@@ -47,11 +49,93 @@ export function parseStatusLineStdin(raw) {
         return null;
     }
 }
+/**
+ * Resolve the callerId for the read-side isolation. Order of resolution:
+ *   1. `stdin?.caller_id` (when the harness / IDE adapter forwards it)
+ *   2. `process.env.CLAUDE_CODE_SESSION_ID` (Claude Code's ambient session id;
+ *      used as a coarse callerId surrogate when stdin omits caller_id)
+ *   3. `null` (no callerId — caller falls back to the project-level
+ *      single-file read for back-compat)
+ */
+function resolveCallerId(stdin) {
+    const fromStdin = typeof stdin?.caller_id === 'string' && stdin.caller_id.length > 0
+        ? stdin.caller_id
+        : null;
+    if (fromStdin !== null)
+        return fromStdin;
+    const fromEnv = process.env['CLAUDE_CODE_SESSION_ID'];
+    if (typeof fromEnv === 'string' && fromEnv.length > 0)
+        return fromEnv;
+    return null;
+}
+/**
+ * Read the active-dispatch index for the canonical session, filter to
+ * in-flight entries (status NOT IN { done, failed, cancelled, no-execution,
+ * never-started, unreadable, stale }), and return the most-recent leaf role
+ * plus the total in-flight count. Returns `{ role: null, pendingCount: 0 }`
+ * when no session id resolves, the index is empty, or every entry is terminal.
+ *
+ * READ-ONLY: only reads `.peaks/_sub_agents/<sid>/active-dispatches.json`.
+ * Never mutates the on-disk record.
+ */
+function readActiveLeaf(projectRoot, sessionId) {
+    if (sessionId === null)
+        return null;
+    let index = {};
+    try {
+        index = readActiveDispatchIndex(projectRoot, sessionId);
+    }
+    catch {
+        return null;
+    }
+    const terminalStatuses = new Set([
+        'done',
+        'failed',
+        'cancelled',
+        'no-execution',
+        'never-started',
+        'unreadable',
+        'stale',
+    ]);
+    const inFlight = Object.values(index).filter((e) => !terminalStatuses.has(e.status));
+    if (inFlight.length === 0)
+        return null;
+    // Sort by createdAt descending — the most recently dispatched leaf wins.
+    const sorted = inFlight.slice().sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    const latest = sorted[0];
+    if (latest === undefined)
+        return null;
+    return { role: latest.role, pendingCount: inFlight.length };
+}
 /**
  * Read the presence file without any side effects. Returns null when the file is
  * absent (idle) and a sentinel object for malformed content (invalid-presence).
+ *
+ * When `callerId` is non-null, delegates to the canonical lease resolver
+ * (presence-lease-service via active-skill-resolver) so the read is
+ * session+caller-isolated. When `callerId` is null, falls back to the
+ * project-level single-file read (back-compat for callers that don't pass
+ * a callerId yet, e.g. legacy CLI invocations).
  */
-function readPresenceReadOnly(projectRoot) {
+function readPresenceReadOnly(projectRoot, callerId) {
+    if (callerId !== null) {
+        try {
+            const resolution = resolveActiveSkillForCaller(projectRoot, { legacyPresence: true, callerId });
+            if (resolution.source === 'none' || resolution.skill === null) {
+                return { presence: null, invalid: false };
+            }
+            return {
+                presence: {
+                    skill: resolution.skill,
+                    ...(resolution.mode !== null ? { mode: resolution.mode } : {}),
+                },
+                invalid: false,
+            };
+        }
+        catch {
+            return { presence: null, invalid: true };
+        }
+    }
     const presencePath = resolve(projectRoot, PRESENCE_FILE);
     // Back-compat: prefer the new canonical path; fall back to the legacy
     // `.peaks/.active-skill.json` for one minor release.
@@ -91,14 +175,16 @@ export function buildStatusLineModel(stdin, nowMs) {
     // fallbacks). It replaces the active skill content when kind != 'none'.
     const compact = readCompactState(projectRoot, nowMs);
     if (projectRoot === null) {
-        return { state: 'idle', projectRoot: null, presence: null, ageMs: null, compact };
+        return { state: 'idle', projectRoot: null, presence: null, ageMs: null, compact, activeLeaf: null };
     }
-    const { presence, invalid } = readPresenceReadOnly(projectRoot);
+    // 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 };
+        return { state: 'invalid-presence', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null };
     }
     if (presence === null) {
-        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact };
+        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null };
     }
     // 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
@@ -107,12 +193,24 @@ 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 };
+        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null };
     }
     const setAtMs = presence.setAt ? Date.parse(presence.setAt) : Number.NaN;
     const ageMs = Number.isNaN(setAtMs) ? null : nowMs - setAtMs;
     const state = ageMs !== null && ageMs > STALE_THRESHOLD_MS ? 'stale' : 'active';
-    return { state, projectRoot, presence, ageMs, compact };
+    // Active leaf resolution: read-only query against the per-session
+    // active-dispatches index. Filter to in-flight entries; pick the most
+    // recent by createdAt. The renderer uses this to surface the in-flight
+    // 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 };
 }
 /**
  * Read-only compact state resolver. Resolves the canonical session id for the

package/dist/services/vm/vm-lease.js

@@ -20,6 +20,7 @@
  */
 import { randomBytes } from 'node:crypto';
 import { posix as path } from 'node:path';
+import { normalizePath } from '../../shared/path-utils.js';
 export const VM_HYPERVISORS = Object.freeze([
     'kvm', 'hyperkit', 'hyperv'
 ]);
@@ -128,7 +129,7 @@ export function deserializeVmLease(raw) {
 function joinPath(...segments) {
     if (segments.length === 0)
         return '';
-    const normalized = segments.map((s) => s.replace(/\\/g, '/'));
+    const normalized = segments.map((s) => normalizePath(s));
     let acc = normalized[0];
     for (let i = 1; i < normalized.length; i++) {
         acc = path.join(acc, normalized[i]);

package/dist/services/workflow/workflow-autonomous-resume-helpers.js

@@ -20,6 +20,7 @@ import { isAbsolute, relative, resolve } from 'node:path';
 // `.peaks/_runtime/<sessionId>/<role>/...` string is no longer
 // pre-built.
 import { getSessionDir } from '../session/getSessionDir.js';
+import { normalizePath } from '../../shared/path-utils.js';
 const MAX_RESUME_ARTIFACT_BYTES = 256_000;
 // Slice 2026-06-29-change-id-root-removal: return the bare role-relative
 // sub-paths instead of `.peaks/_runtime/change/<id>/<role>/...` strings.
@@ -65,7 +66,7 @@ function normalizeRoleRelativePath(artifact, _sessionId) {
     // the path separators and strips any leading `/`; the `sessionId`
     // argument is preserved on the signature for backward call-site
     // compatibility but is no longer embedded in the path.
-    return artifact.replace(/\\/g, '/').replace(/^\/+/, '');
+    return normalizePath(artifact).replace(/^\/+/, '');
 }
 function readResumeArtifact(artifactWorkspacePath, sessionId, artifact) {
     // Slice 2026-06-29-change-id-root-removal: on-disk home now lives under
@@ -73,7 +74,7 @@ function readResumeArtifact(artifactWorkspacePath, sessionId, artifact) {
     // sub-path (e.g. `rd/swarm/checkpoints/checkpoint-1.json`) is
     // strictly a sub-root drill, not a top-level dir derivation.
     const sessionScopeRoot = getSessionDir(artifactWorkspacePath, sessionId);
-    const normalizedArtifact = artifact.replace(/\\/g, '/').replace(/^\/+/, '');
+    const normalizedArtifact = normalizePath(artifact).replace(/^\/+/, '');
     const artifactPath = resolve(sessionScopeRoot, normalizedArtifact);
     try {
         const artifactWorkspaceRealPath = realpathSync(artifactWorkspacePath);

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

@@ -3,6 +3,7 @@ import { existsSync, lstatSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { isDirectory } from 'peaks-loop-shared/fs';
 import { getSessionId, setCurrentSessionBinding, setSessionMeta } from '../session/session-manager.js';
+import { normalizePath } from '../../shared/path-utils.js';
 /**
  * Slice 2026-06-29-change-id-root-removal: list the immediate children of
  * `.peaks/` so the legacy sibling-dir guard can enumerate date-stamped
@@ -418,7 +419,7 @@ export function isWriterCreatedSiblingShape(siblingDir) {
             continue;
         }
         if (stat.isFile()) {
-            const rel = node.rel.replace(/\\/g, '/');
+            const rel = normalizePath(node.rel);
             const matches = WRITER_ALLOWED_RELATIVE_PATTERNS.some((re) => re.test(rel));
             if (!matches) {
                 return false;

package/dist/services/worktree/worktree-lease.js

@@ -26,6 +26,7 @@
  */
 import { randomBytes } from 'node:crypto';
 import { posix as path } from 'node:path';
+import { normalizePath } from '../../shared/path-utils.js';
 /**
  * Per-role default TTL. Sub-agent dispatch duration varies by role:
  * - rd (long planning + impl) → 30 min
@@ -233,7 +234,7 @@ export function deserializeLease(raw) {
 function joinPath(...segments) {
     if (segments.length === 0)
         return '';
-    const normalized = segments.map((s) => s.replace(/\\/g, '/'));
+    const normalized = segments.map((s) => normalizePath(s));
     let acc = normalized[0];
     for (let i = 1; i < normalized.length; i++) {
         acc = path.join(acc, normalized[i]);

package/dist/shared/path-safety.js

@@ -10,11 +10,9 @@
  * check without bringing in the change-id axis.
  */
 import { posix } from 'node:path';
-function normalizeForwardSlashes(input) {
-    return input.replace(/\\/g, '/');
-}
+import { normalizePath } from './path-utils.js';
 function hasUnsafePathShape(input) {
-    const normalized = normalizeForwardSlashes(input);
+    const normalized = normalizePath(input);
     if (input.includes('\\'))
         return true;
     if (!normalized || normalized === '.' || normalized === '..')
@@ -36,7 +34,7 @@ export function isUnsafeArtifactPath(path) {
     return isUnsafePathInput(path);
 }
 function normalizeArtifactPath(input) {
-    const normalized = posix.normalize(normalizeForwardSlashes(input));
+    const normalized = posix.normalize(normalizePath(input));
     return normalized.replace(/\/$/, '');
 }
 export { normalizeArtifactPath as _normalizeArtifactPath };

package/dist/shared/path-utils.d.ts

@@ -11,3 +11,51 @@ export declare function isWindowsAbsolutePath(path: string): boolean;
 export declare function resolveInputPath(path: string): string;
 export declare function stableRealPath(path: string): string;
 export declare function stablePath(path: string): string;
+/**
+ * Build the comparison key for a `projectRoot` value. Two paths that
+ * denote the same physical directory MUST produce the same key, and two
+ * paths that denote different directories MUST NOT.
+ *
+ * Composed from the existing `path-utils.ts` primitives; no new
+ * dependency. Three normalizations, in order:
+ *
+ *   1. **Symlink resolution** via `stableRealPath` — collapses macOS
+ *      `/var/folders/...` vs `/private/var/folders/...` (`/var` is a
+ *      symlink to `/private/var`). Falls back to `resolveInputPath`
+ *      when the path does not exist, so this never throws for callers
+ *      that pass a not-yet-created root (or a stale binding whose
+ *      directory has since been deleted).
+ *   2. **Separator folding** via `normalizePath` — collapses the
+ *      Windows `C:\Users\...` (written by `peaks workspace init`) vs
+ *      `C:/Users/...` (passed by a Git Bash caller) split that was the
+ *      original `PEAKS_SESSION_NOT_BOUND` trigger.
+ *   3. **Case folding, Windows only** — NTFS is case-insensitive, so
+ *      `C:\Foo` and `c:/foo` are the same directory. This step is
+ *      guarded on `isWindows` because POSIX filesystems are
+ *      case-SENSITIVE: folding case on Linux would make the genuinely
+ *      distinct `/tmp/Foo` and `/tmp/foo` compare equal.
+ *
+ * Note on step 3: `realpathSync` alone is NOT sufficient for the
+ * Windows case split. Verified empirically on Node 22 / win32 —
+ * `realpathSync('c:\\...\\foo')` echoes the caller's casing, while only
+ * `realpathSync.native` case-folds. We do not switch to `.native`
+ * because it also rewrites 8.3 short names (`SMALLM~1` → `smallMark`),
+ * which would change the on-disk form of every existing binding.
+ * Explicit `toLowerCase()` is the narrower, more predictable fix.
+ *
+ * This is a compare key ONLY — never persist it. The value written to
+ * disk stays the real path (see `writeSessionFile`).
+ *
+ * Lifted from `src/services/session/session-manager.ts` in slice
+ * `2026-08-04-rid-002-bridge-canonicalize` so both `session-manager.ts`
+ * and `session-binding-bridge.ts` share a single canonicalization
+ * authority.
+ */
+export declare function projectRootCompareKey(p: string): string;
+/**
+ * Compare two `projectRoot` values under the canonicalization rules
+ * documented on `projectRootCompareKey`. Returns true iff both paths
+ * canonicalize to the same key — covers symlink resolution, separator
+ * folding, and (Windows only) case folding.
+ */
+export declare function projectRootsMatch(a: string, b: string): boolean;

package/dist/shared/path-utils.js

@@ -1,7 +1,7 @@
 import { existsSync, realpathSync } from 'node:fs';
 import { isAbsolute, parse, relative, resolve, sep } from 'node:path';
 import { tmpdir } from 'node:os';
-import { platform } from './platform.js';
+import { isWindows, platform } from './platform.js';
 export const SEP = sep;
 const localPathConverters = {
     win32: (p) => p.replace(/\//g, '\\'),
@@ -54,3 +54,67 @@ export function stablePath(path) {
     const realExistingPath = existsSync(currentPath) ? stableRealPath(currentPath) : parsedPath.root;
     return resolve(realExistingPath, ...missingSegments);
 }
+/**
+ * Build the comparison key for a `projectRoot` value. Two paths that
+ * denote the same physical directory MUST produce the same key, and two
+ * paths that denote different directories MUST NOT.
+ *
+ * Composed from the existing `path-utils.ts` primitives; no new
+ * dependency. Three normalizations, in order:
+ *
+ *   1. **Symlink resolution** via `stableRealPath` — collapses macOS
+ *      `/var/folders/...` vs `/private/var/folders/...` (`/var` is a
+ *      symlink to `/private/var`). Falls back to `resolveInputPath`
+ *      when the path does not exist, so this never throws for callers
+ *      that pass a not-yet-created root (or a stale binding whose
+ *      directory has since been deleted).
+ *   2. **Separator folding** via `normalizePath` — collapses the
+ *      Windows `C:\Users\...` (written by `peaks workspace init`) vs
+ *      `C:/Users/...` (passed by a Git Bash caller) split that was the
+ *      original `PEAKS_SESSION_NOT_BOUND` trigger.
+ *   3. **Case folding, Windows only** — NTFS is case-insensitive, so
+ *      `C:\Foo` and `c:/foo` are the same directory. This step is
+ *      guarded on `isWindows` because POSIX filesystems are
+ *      case-SENSITIVE: folding case on Linux would make the genuinely
+ *      distinct `/tmp/Foo` and `/tmp/foo` compare equal.
+ *
+ * Note on step 3: `realpathSync` alone is NOT sufficient for the
+ * Windows case split. Verified empirically on Node 22 / win32 —
+ * `realpathSync('c:\\...\\foo')` echoes the caller's casing, while only
+ * `realpathSync.native` case-folds. We do not switch to `.native`
+ * because it also rewrites 8.3 short names (`SMALLM~1` → `smallMark`),
+ * which would change the on-disk form of every existing binding.
+ * Explicit `toLowerCase()` is the narrower, more predictable fix.
+ *
+ * This is a compare key ONLY — never persist it. The value written to
+ * disk stays the real path (see `writeSessionFile`).
+ *
+ * Lifted from `src/services/session/session-manager.ts` in slice
+ * `2026-08-04-rid-002-bridge-canonicalize` so both `session-manager.ts`
+ * and `session-binding-bridge.ts` share a single canonicalization
+ * authority.
+ */
+export function projectRootCompareKey(p) {
+    let canonical;
+    try {
+        canonical = stableRealPath(p);
+    }
+    catch {
+        // Path does not exist (yet). Fall back to the resolved absolute
+        // form so a binding written before its directory exists — and a
+        // binding whose directory was later deleted — still compares by
+        // separator + case rather than throwing.
+        canonical = resolveInputPath(p);
+    }
+    const separatorFolded = normalizePath(canonical);
+    return isWindows ? separatorFolded.toLowerCase() : separatorFolded;
+}
+/**
+ * Compare two `projectRoot` values under the canonicalization rules
+ * documented on `projectRootCompareKey`. Returns true iff both paths
+ * canonicalize to the same key — covers symlink resolution, separator
+ * folding, and (Windows only) case folding.
+ */
+export function projectRootsMatch(a, b) {
+    return projectRootCompareKey(a) === projectRootCompareKey(b);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.9",
+  "version": "4.0.10",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -98,9 +98,9 @@
     "headroom-ai": "0.22.4",
     "yaml": "^2.9.0",
     "zod": "^3.25.76",
-    "peaks-loop-mut": "0.1.15",
-    "peaks-loop-shared": "0.0.40",
-    "peaks-loop-shared-channel": "0.0.19"
+    "peaks-loop-shared": "0.0.41",
+    "peaks-loop-shared-channel": "0.0.19",
+    "peaks-loop-mut": "0.1.15"
   },
   "peerDependencies": {
     "@alibaba-group/open-code-review": "1.3.1"