peaks-loop 4.0.9 → 4.0.11

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## 4.0.11 — 2026-08-05 (BDD test-style + statusline bugs)
+
+**BDD given-when-then test style** (rid-2026-08-05-bdd-test-style, 5 slice / 19 commit):
+- `scripts/migrate-to-bdd.mjs` — TS Compiler API-based AST migrator that rewrites every `it()` / `test()` / `describe()` to the given-when-then contract (it description with `when X` or `should Y` + 3-line `// given:` / `// when:` / `// then:` body comment). Idempotent.
+- `src/services/qa/bdd-test-style-verifier.ts` — peaks-qa verification-time verifier that scans `git diff HEAD~1 -- '*.test.ts'` and rejects non-BDD slices (LLM-only enforcement, since callerId from `process.env.CLAUDE_CODE_SESSION_ID` cannot distinguish LLM vs human in Claude Code).
+- `src/reporters/bdd-reporter.ts` — vitest custom reporter (flag-enabled via `--reporter ./src/reporters/bdd-reporter.ts`) emitting `Feature: <file>` / `Scenario: <describe>` / `Given|When|Then` document view.
+- `skills/bee/peaks-rd/references/rd-sub-agent-dispatch.md` + `peaks-qa/references/qa-sub-agent-dispatch.md` — `## BDD Test Style Contract` / `## BDD Test Style Verification` soft-constraint sections added.
+- `docs/test-style-contract.md` — LLM test-style guide included in npm `files` array (downstream opt-in).
+- 26 test files migrated across 11 commits (one per top-level directory); 12 files already BDD-form (idempotent migrator skipped silently); 49 unit-test files total now in BDD shape.
+- 49/49 unit tests behaviour-preserved (488 passed / 25 skipped / 0 introduced failures).
+
+**Statusline bug fixes** (3 rid this release):
+- `skill-statusline-service.ts` `readActiveLeaf`: stale `queued` dispatch entries no longer pollute statusline as in-flight leaves. `terminalStatuses` set extended.
+- `presence-lease-service.ts` `setPresenceLease`: lease object now persists `mode` (was being silently dropped — regression from 4.0.8 Presence Lease Graph introduction). `[full-auto]` / `[assisted]` / `[swarm]` / `[strict]` tags now render.
+- `audit/enforcers/active-skill-resolver.ts` legacy fall-back: per-caller `active-skill-*.json` legacy walk now reads and propagates `mode` (was hard-coded `mode: null`).
+
+**Build-chain repair** (silences `npx tsc -p tsconfig.build.json` regression):
+- `src/reporters/bdd-reporter.ts` no longer imports the un-exported `TestModule` / `TestCase` from `vitest/reporters`. Local minimal interfaces (`BddTestModuleLike` / `BddTestCaseLike`) match the runtime shape vitest passes to reporter hooks.
+- Build now succeeds end-to-end; the `dist/` artifacts (which `bin/peaks.js` actually loads) reflect the source-level fixes.
+
+**Cleanup tail** (5 rid carried over from b1 sweep):
+- 63 request artifacts re-staged to terminal state (handed-off / verdict-issued / complete / sc-handoff → done).
+- 8 OpenSpec proposal drift detected and routed through `peaks request transition`.
+- One envelope-test-output log dropped from project root (was orphan inside `.gitignore:5 *.log` but never deleted).
+
+**Lockstep bump.** peaks-loop-shared `0.0.40 → 0.0.41` (CLI_VERSION re-stamped to 4.0.11).
+
+## 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/config/eslint/.peaks-rules.cjs

@@ -0,0 +1,123 @@
+/**
+ * peaks-loop ESLint rules bundle (npm-package exports)
+ *
+ * rid-2026-08-05-jsts-lint-bundle — LLM auto-fix loop trigger.
+ *
+ * This file is a JSON-shape glue config. It does NOT define custom
+ * rules. It composes upstream packages only:
+ *
+ *   - eslint:recommended
+ *   - plugin:@typescript-eslint/recommended-type-checked
+ *   - plugin:import/recommended
+ *   - plugin:import/typescript
+ *
+ * Framework-specific rules (eslint-plugin-react, eslint-plugin-vue,
+ * eslint-plugin-svelte, eslint-plugin-nestjs, etc.) are LAYER 3 and
+ * loaded dynamically by `peaks code lint` via `npx --package <pkg>
+ * -- eslint`. They are NOT installed in this package's devDependencies
+ * (sediment §二 G-lint-1 turn-5 red line).
+ *
+ * --fix / --write / prettier are FORBIDDEN at the peaks code lint
+ * wrapper entry; the wrapper is a read-only verifier, not a formatter
+ * (sediment §二 G-lint-2). The thresholds below are intentionally
+ * permissive (warn, not error) so peaks-loop 4.0.10 baseline can adopt
+ * the bundle without auto-failing.
+ */
+'use strict';
+
+/** @type {import('eslint').Linter.Config} */
+module.exports = {
+  root: false,
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    ecmaVersion: 2022,
+    sourceType: 'module',
+    project: ['./tsconfig.json', './tsconfig.build.json'],
+    tsconfigRootDir: __dirname + '/..'
+  },
+  env: {
+    node: true,
+    es2022: true
+  },
+  plugins: ['@typescript-eslint', 'import'],
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended-type-checked',
+    'plugin:import/recommended',
+    'plugin:import/typescript'
+  ],
+  settings: {
+    'import/resolver': {
+      typescript: {
+        alwaysTryTypes: true,
+        project: ['./tsconfig.json', './tsconfig.build.json']
+      },
+      node: {
+        extensions: ['.js', '.ts', '.tsx', '.jsx']
+      }
+    }
+  },
+  ignorePatterns: [
+    'node_modules/',
+    'dist/',
+    'coverage/',
+    'output-styles/',
+    'skills/',
+    'agents/',
+    'bin/',
+    'scratch/',
+    'examples/'
+  ],
+  rules: {
+    // L1 (eslint built-in) — always on, no plugin package required.
+    complexity: ['warn', { max: 10 }],
+    'max-lines-per-function': [
+      'warn',
+      { max: 50, skipComments: true, skipBlankLines: true }
+    ],
+    'max-params': ['warn', { max: 4 }],
+    'no-magic-numbers': [
+      'warn',
+      { ignore: [0, 1, -1, 100, 1000] }
+    ],
+    'no-explicit-any': 'warn',
+    'prefer-const': 'warn',
+    'no-var': 'error',
+    eqeqeq: ['warn', 'always', { null: 'ignore' }],
+
+    // L2 (@typescript-eslint) — type-aware; requires the
+    // recommended-type-checked base. configured via the extends above.
+    '@typescript-eslint/consistent-type-imports': [
+      'warn',
+      { prefer: 'type-imports' }
+    ],
+    '@typescript-eslint/no-non-null-assertion': 'warn',
+    '@typescript-eslint/no-implicit-any': 'warn',
+    // G-lint-1 §二 enum → as const: warn-only (escape hatch preserved).
+    '@typescript-eslint/no-restricted-syntax': [
+      'warn',
+      {
+        selector: 'TSEnumDeclaration',
+        message: 'Use "as const" union instead of TS enum.'
+      }
+    ],
+
+    // L2 (eslint-plugin-import) — boundary hygiene.
+    'import/no-duplicates': 'warn',
+    'import/no-unresolved': 'off',
+    'import/named': 'off',
+    'import/default': 'off',
+    'import/namespace': 'off'
+  },
+  overrides: [
+    {
+      files: ['*.test.ts', '*.test.tsx', 'tests/**/*.ts', 'tests/**/*.tsx'],
+      rules: {
+        'no-magic-numbers': 'off',
+        complexity: 'off',
+        'max-lines-per-function': 'off',
+        '@typescript-eslint/no-explicit-any': 'off'
+      }
+    }
+  ]
+};

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/reporters/bdd-reporter.d.ts

@@ -0,0 +1,36 @@
+import type { Reporter } from 'vitest/reporters';
+/** Minimal shape of vitest's TestModule tree node. Vitest 4.1.10 does
+ * not export these types publicly; this mirrors the runtime shape
+ * the reporter hooks actually receive. */
+interface BddTestModuleLike {
+    moduleId?: string;
+    relativeModuleId?: string;
+    children: {
+        tests(): Iterable<BddTestCaseLike>;
+        suites(): Iterable<BddTestModuleLike>;
+    };
+}
+interface BddTestCaseLike {
+    name: string;
+    fullName?: string;
+    state?: 'passed' | 'failed' | 'skipped';
+    result?: () => unknown;
+}
+declare class BddReporter implements Reporter {
+    /** Key: relative module id; Value: per-feature rendered scenarios. */
+    private readonly features;
+    /**
+     * Vitest calls `onTestModuleEnd` after a module finishes. We use it
+     * to drain the per-module scenarios into the document map and
+     * mark the file's pass/fail status.
+     */
+    onTestModuleEnd(testModule: BddTestModuleLike): void;
+    /**
+     * Final emit. We deliberately print to stdout with `console.log`
+     * (vitest captures stdout when needed) and never call `process.exit`
+     * — that is the orchestrator's job. Failure reasons surface as plain
+     * text so a downstream LLM prompt can grep for `FAILED:`.
+     */
+    onTestRunEnd(): void;
+}
+export default BddReporter;

package/dist/reporters/bdd-reporter.js

@@ -0,0 +1,159 @@
+// src/reporters/bdd-reporter.ts
+//
+// rid-2026-08-05-bdd-test-style Slice C — vitest custom reporter that
+// emits a pure BDD document view of the run. Designed for business
+// reviewers and downstream LLM prompts; it is NOT a replacement for
+// the default reporter.
+//
+// Why a custom reporter:
+//   The default reporter focuses on pass/fail and timing. The BDD
+//   reporter transcribes `Feature: <file>` / `Scenario: <describe> ->
+//   it` into a single human-readable document so a non-engineer can
+//   scan what the suite actually exercises.
+//
+// Why no new dep:
+//   vitest 4.1.10 (frozen 2026-07-25) ships the `Reporter` interface
+//   in `vitest/reporters`. The custom reporter must have a `default`
+//   export — the CLI loads it via `runner.import(path)` and validates
+//   `customReporterModule.default` is defined (see vitest cli-api chunks
+//   line 11371). Importing the `Reporter` type from vitest does not add
+//   a runtime dep; tsc resolves it through vitest's dts shim.
+//
+// Why a flag-only reporter:
+//   Per rid design section 4 Slice C, the default vitest run is
+//   unchanged. This file is opt-in via:
+//
+//     pnpm vitest run --reporter ./src/reporters/bdd-reporter.ts <file>
+//
+// Anti-fake-green rule (CLI silent-catch):
+//   The reporter does not swallow vitest result shapes. Every state
+//   branch (`passed` / `failed` / `skipped`) is rendered explicitly so
+//   downstream reviewers cannot misread a hidden failure.
+//
+// Karpathy note:
+//   The reporter deliberately emits ONE document per file with the
+//   4-line Feature/Scenario/Given/When/Then shape — no extra layout
+//   metadata, no JSON sidecar. Anything beyond what the spec asked
+//   for is excluded by Simplicity First.
+class BddReporter {
+    /** Key: relative module id; Value: per-feature rendered scenarios. */
+    features = new Map();
+    /**
+     * Vitest calls `onTestModuleEnd` after a module finishes. We use it
+     * to drain the per-module scenarios into the document map and
+     * mark the file's pass/fail status.
+     */
+    onTestModuleEnd(testModule) {
+        const moduleId = testModule.relativeModuleId ?? testModule.moduleId ?? '';
+        const file = basename(moduleId);
+        const scenarios = [];
+        collectScenarios(testModule, file, scenarios);
+        this.features.set(file, scenarios);
+    }
+    /**
+     * Final emit. We deliberately print to stdout with `console.log`
+     * (vitest captures stdout when needed) and never call `process.exit`
+     * — that is the orchestrator's job. Failure reasons surface as plain
+     * text so a downstream LLM prompt can grep for `FAILED:`.
+     */
+    onTestRunEnd() {
+        const lines = [];
+        const features = [];
+        for (const [feature, scenarios] of this.features) {
+            const ok = scenarios.every((s) => s.state === 'passed' || s.state === 'skipped');
+            features.push({ feature, scenarios, ok });
+        }
+        // Deterministic order: alphabetical by file basename so two runs on
+        // the same diff produce byte-identical docs (avoids noisy diffs).
+        features.sort((a, b) => a.feature.localeCompare(b.feature));
+        for (const f of features) {
+            lines.push(`Feature: ${f.feature}`);
+            if (f.scenarios.length === 0) {
+                // Empty file still surfaces the Feature line so the document
+                // is a faithful list of files the runner touched.
+                lines.push('');
+                continue;
+            }
+            for (const s of f.scenarios) {
+                lines.push(`  Scenario: ${s.scenario || '<root>'}`);
+                lines.push(`    Given ${s.title}`);
+                lines.push(`    When  vitest runs this test`);
+                if (s.state === 'passed') {
+                    lines.push(`    Then  should pass`);
+                }
+                else if (s.state === 'skipped') {
+                    lines.push(`    Then  should skip`);
+                }
+                else {
+                    const reason = s.error ? ` (${truncate(s.error, 200)})` : '';
+                    lines.push(`    Then  FAILED: ${s.title}${reason}`);
+                }
+            }
+            lines.push('');
+        }
+        console.log(lines.join('\n'));
+    }
+}
+function basename(path) {
+    // vitest module ids are POSIX-style even on Windows; split on '/'
+    // then on '\\' as a defensive fallback.
+    const idx = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'));
+    return idx === -1 ? path : path.slice(idx + 1);
+}
+/**
+ * Walk a `TestModule` recursively and collect rendered scenarios.
+ * `describe` blocks contribute their name to the Scenario label;
+ * tests declared at module root produce a `<root>` Scenario so the
+ * structure is uniform.
+ */
+function collectScenarios(entity, file, out) {
+    const visited = new WeakSet();
+    const walk = (node, scenarioLabel) => {
+        if (node === null || typeof node !== 'object')
+            return;
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        const obj = node;
+        if (obj.type === 'test') {
+            const tc = node;
+            const result = tc.result ? tc.result() : undefined;
+            const resultObj = (result ?? {});
+            const state = (resultObj.state === 'passed' || resultObj.state === 'failed' || resultObj.state === 'skipped')
+                ? resultObj.state
+                : 'skipped';
+            const err = resultObj.state === 'failed' && resultObj.errors && resultObj.errors[0]
+                ? (resultObj.errors[0].message ?? 'unknown failure')
+                : undefined;
+            out.push({
+                scenario: scenarioLabel,
+                title: tc.name,
+                state,
+                error: err,
+            });
+            return;
+        }
+        // For a suite/module, descend with the suite's name pushed.
+        const suiteName = obj.name ?? '';
+        const childSuiteLabel = suiteName || scenarioLabel;
+        if (obj.children) {
+            try {
+                for (const t of obj.children.tests()) {
+                    walk(t, childSuiteLabel);
+                }
+                for (const s of obj.children.suites()) {
+                    walk(s, childSuiteLabel);
+                }
+            }
+            catch {
+                // Defensive: vitest internals may throw on teardown. We do not
+                // mask the document — we just stop collecting from this node.
+            }
+        }
+    };
+    walk(entity, '');
+}
+function truncate(s, n) {
+    return s.length <= n ? s : `${s.slice(0, n - 3)}...`;
+}
+export default BddReporter;

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;