peaks-loop 4.0.9 → 4.0.11

package/dist/services/qa/bdd-test-style-verifier.js

@@ -0,0 +1,268 @@
+/**
+ * src/services/qa/bdd-test-style-verifier.ts
+ *
+ * rid-2026-08-05-bdd-test-style Slice B — peaks-qa verification-time
+ * BDD test-style verifier. This is the read-only, post-edit companion
+ * to the `scripts/migrate-to-bdd.mjs` AST migrator shipped in Slice A.
+ *
+ * Purpose:
+ *   When peaks-qa runs its verification gate, it picks up the git diff
+ *   for the slice and asks this module whether the new / modified test
+ *   files comply with the BDD given-when-then style. The verdict is
+ *   surfaced as either `ok` (and the slice can advance) or one of two
+ *   structured failure reasons (`missing-given-when-then` or
+ *   `description-no-should-when`) that the caller turns into a
+ *   `qa-handoff` rejection back to peaks-rd.
+ *
+ * Why a real AST and not a regex:
+ *   The Slice A migrator established the convention: test files have
+ *   multi-line `it(...)` calls, nested arrow bodies, and string
+ *   literals that often contain words like "when" inside the assertion
+ *   message (not in the description). A regex pass on the raw source
+ *   would false-positive on string internals. The TypeScript Compiler
+ *   API (already a dev dep via vitest) lets us:
+ *     1. Inspect the first `StringLiteral` argument of an `it` /
+ *        `test` / `describe` call without scanning comments or
+ *        string content inside the body.
+ *     2. Walk only the leading-comment ranges that sit before the
+ *        first statement of the callback block, so a `// when:`
+ *        inside an `expect(actual).toEqual('when X happens')` is
+ *        correctly ignored.
+ *
+ * No new dependencies. The verifier is intentionally synchronous and
+ * pure (input source + path list -> verdict) so peaks-qa can call it
+ * from a deterministic verification step without subprocess overhead.
+ *
+ * Anti-fake-green (CLI silent-catch rule):
+ *   This module throws on parse failure. It does NOT swallow parse
+ *   errors and return `{ ok: true }` — that would silently green-light
+ *   malformed test files. A parse error is a structural problem; the
+ *   caller must surface it.
+ */
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import ts from 'typescript';
+/** Test runners whose first string-arg is the test description. */
+const TEST_NAMES = new Set(['it', 'test']);
+/**
+ * Verify that every `it(...)` / `test(...)` call in the given test
+ * files follows the BDD given-when-then contract.
+ *
+ * Contract:
+ *   1. The first `StringLiteral` argument of every `it` / `test` call
+ *      MUST match `/(\bwhen\b|\bshould\b)/` (word-boundary anchored,
+ *      case-insensitive). A regex on the raw description is correct
+ *      here because the description itself is a literal — there is
+ *      no nested template literal to misread.
+ *   2. The callback body (the second argument when it is an arrow /
+ *      function expression with a block) MUST have a `// given:`,
+ *      `// when:`, `// then:` triple at the top, in that order,
+ *      within the first 3 leading-comment ranges before the first
+ *      statement. The `// arrange:` / `// act:` / `// assert:` AAA
+ *      legacy is NOT accepted — the contract is given-when-then
+ *      only.
+ *
+ * Returns the FIRST failure encountered (file order, then
+ * top-to-bottom line order). A structured `BddStyleFail` is what the
+ * caller maps to `qa-handoff` rejection.
+ */
+export function verifyBddStyle(input) {
+    let scanned = 0;
+    for (const rel of input.testFiles) {
+        const absPath = resolve(input.projectRoot, rel);
+        const source = readFileSync(absPath, 'utf8');
+        const sourceFile = ts.createSourceFile(rel, source, ts.ScriptTarget.ESNext, 
+        /* setParentNodes */ true, ts.ScriptKind.TS);
+        let earliestFail = null;
+        const recordFail = (fail) => {
+            if (earliestFail === null) {
+                earliestFail = fail;
+                return;
+            }
+            const { line: existingLine } = earliestFail;
+            if (fail.line < existingLine)
+                earliestFail = fail;
+        };
+        const visit = (node) => {
+            if (earliestFail !== null)
+                return;
+            if (ts.isCallExpression(node)) {
+                const callee = node.expression;
+                if (ts.isIdentifier(callee) && TEST_NAMES.has(callee.text)) {
+                    scanned += 1;
+                    const descCheck = checkDescription(node, sourceFile, rel);
+                    if (descCheck !== null) {
+                        recordFail(descCheck);
+                        return;
+                    }
+                    const bodyCheck = checkBody(node, sourceFile, rel);
+                    if (bodyCheck !== null) {
+                        recordFail(bodyCheck);
+                        return;
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        if (earliestFail !== null)
+            return earliestFail;
+    }
+    return { ok: true, scanned };
+}
+/**
+ * Inspect the first string-literal argument of an `it` / `test` call.
+ *
+ * - If the first argument is not a string literal, treat it as a
+ *   failure (the BDD contract requires a literal description).
+ * - If the literal text does not contain "when" or "should" as a
+ *   whole word, return a `description-no-should-when` failure.
+ */
+function checkDescription(call, sourceFile, relPath) {
+    const firstArg = call.arguments[0];
+    if (firstArg === undefined || !ts.isStringLiteralLike(firstArg)) {
+        const pos = call.getStart(sourceFile);
+        const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
+        return {
+            ok: false,
+            reason: 'description-no-should-when',
+            file: relPath,
+            line: line + 1,
+            description: '<non-literal first argument>',
+            expected: 'first argument must be a string literal containing "when" or "should"',
+        };
+    }
+    const description = firstArg.text;
+    if (!hasWhenOrShould(description)) {
+        const pos = firstArg.getStart(sourceFile);
+        const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
+        return {
+            ok: false,
+            reason: 'description-no-should-when',
+            file: relPath,
+            line: line + 1,
+            description,
+            expected: 'description must contain the word "when" or "should" (BDD style)',
+        };
+    }
+    return null;
+}
+/**
+ * Inspect the callback body of an `it` / `test` call for the
+ * `// given:` / `// when:` / `// then:` triple.
+ *
+ * Rules (Slice A migrator + design §4.B):
+ *   - The second argument must be an arrow / function expression
+ *     with a block body. If it is missing or not a block (e.g. an
+ *     expression-body arrow `it('x', () => expect(y).toBe(z))`),
+ *     we still need the comments — but expression-body arrows
+ *     cannot host them. In that case we fall back to inspecting
+ *     the leading comments before the entire call expression,
+ *     which matches the Slice A migrator's `isAlreadyMigrated`
+ *     check shape.
+ *   - The three comments must be the FIRST THREE leading-comment
+ *     ranges before the relevant body / first-statement anchor.
+ *   - The order must be `given` → `when` → `then`. A re-ordered
+ *     triple is rejected.
+ */
+function checkBody(call, sourceFile, relPath) {
+    const body = getCallbackBlock(call);
+    if (body !== null) {
+        return checkBlockLeadingComments(body, sourceFile, relPath);
+    }
+    // Expression-body arrow or non-block callback: comments cannot
+    // live inside the body. The Slice A migrator only inserts the
+    // triple on block bodies, so an expression-body form is by
+    // definition non-BDD and must fail. This keeps the contract
+    // symmetric with the migrator.
+    const pos = call.getStart(sourceFile);
+    const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
+    return {
+        ok: false,
+        reason: 'missing-given-when-then',
+        file: relPath,
+        line: line + 1,
+        expected: 'block-body callback with // given: / // when: / // then: comments at the top',
+    };
+}
+function getCallbackBlock(call) {
+    const callback = call.arguments[1];
+    if (callback === undefined)
+        return null;
+    if (!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback))
+        return null;
+    if (!callback.body || !ts.isBlock(callback.body))
+        return null;
+    return callback.body;
+}
+function checkBlockLeadingComments(block, sourceFile, relPath) {
+    // TypeScript's `getLeadingCommentRanges` API is unreliable for
+    // comment-only blocks: with `setParentNodes: true`, an empty
+    // block (no statements, only comments) has no anchor to attach
+    // the comments to, so the API returns zero ranges. To get a
+    // deterministic answer, we scan the block's text directly and
+    // pick the first three non-empty lines.
+    //
+    // The block's text spans `{` ... `}`. We extract the body,
+    // split on lines, and check the first three non-empty lines for
+    // the BDD triple. This is AST-driven (we use the block's source
+    // range from the SourceFile, not a global regex) and survives
+    // both empty-body and populated-body cases.
+    const blockStart = block.getStart(sourceFile) + 1; // skip `{`
+    const blockEnd = block.end - 1; // skip `}`
+    const body = sourceFile.text.slice(blockStart, blockEnd);
+    const lines = body.split(/\r?\n/);
+    const nonEmpty = [];
+    for (const line of lines) {
+        if (line.trim().length === 0)
+            continue;
+        nonEmpty.push(line);
+        if (nonEmpty.length === 3)
+            break;
+    }
+    if (nonEmpty.length < 3 || !matchesBddTriple(nonEmpty)) {
+        return makeMissingCommentFailure(block, sourceFile, relPath);
+    }
+    return null;
+}
+function makeMissingCommentFailure(block, sourceFile, relPath) {
+    // Report the line of the opening `{` + 1 — the line that should
+    // contain the first comment of the BDD triple. This gives the
+    // caller a stable pointer even when the block is empty.
+    const pos = block.getStart(sourceFile) + 1;
+    const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
+    return {
+        ok: false,
+        reason: 'missing-given-when-then',
+        file: relPath,
+        line: line + 1,
+        expected: '// given: / // when: / // then: triple at the top of the block body',
+    };
+}
+/**
+ * Match the three leading comments against the BDD triple. Each
+ * entry must be a `// <keyword>:` line (with optional trailing
+ * whitespace); the keywords must appear in `given`, `when`, `then`
+ * order, case-insensitive.
+ */
+function matchesBddTriple(triple) {
+    if (triple.length !== 3)
+        return false;
+    // Each entry must be a `// <keyword>:` line, optionally followed
+    // by descriptive text. The Slice A migrator's `buildCommentBlock`
+    // produces `// given: the test setup` / `// when:  the function
+    // under test is invoked` / `// then:  the result matches the
+    // expectation` — the `when` line uses two spaces after the colon
+    // for visual alignment with `given:` and `then:`, so the regex
+    // is intentionally permissive about trailing text.
+    const patterns = [
+        /^\s*\/\/\s*given\s*:/i,
+        /^\s*\/\/\s*when\s*:/i,
+        /^\s*\/\/\s*then\s*:/i,
+    ];
+    return patterns.every((pat, i) => pat.test(triple[i] ?? ''));
+}
+/** True when `text` contains `when` or `should` as a whole word. */
+function hasWhenOrShould(text) {
+    return /(\bwhen\b|\bshould\b)/i.test(text);
+}

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/presence-lease-service.js

@@ -142,6 +142,7 @@ export function setPresenceLease(input) {
         graphRef,
         skill: input.skill,
         ...(input.parentWorkflowId ? { parentWorkflowId: input.parentWorkflowId } : {}),
+        ...(input.mode ? { mode: input.mode } : {}),
         depth: input.depth ?? 0,
         startedAt: now,
         lastHeartbeat: now,

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;