peaks-cli 1.2.9 → 1.3.1

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

@@ -2,11 +2,33 @@ import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readF
 import { randomUUID } from 'node:crypto';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { homedir } from 'node:os';
-/** The hook command written into settings. `${CLAUDE_PROJECT_DIR}` is injected by Claude Code. */
+/** The hook command written into settings for the gate-enforce PreToolUse hook. `${CLAUDE_PROJECT_DIR}` is injected by Claude Code. */
 export const HOOK_ENFORCE_COMMAND = 'peaks gate enforce --project "${CLAUDE_PROJECT_DIR}"';
-/** Substring that identifies a Peaks-managed PreToolUse hook entry. */
-export const HOOK_SENTINEL = 'peaks gate enforce';
-const HOOK_MATCHER = 'Bash';
+/**
+ * Hook command for the sub-agent progress auto-spawn. Fires on every Task
+ * tool call (the harness-enforced mechanism for "sub-agent dispatch"). The
+ * command itself is non-blocking: `peaks progress start` is idempotent
+ * (5-minute TTL on the spawn record) so the LLM does not see a fresh
+ * terminal per Task. The `--quiet` flag keeps the LLM context clean — the
+ * hook output otherwise adds ~500 tokens per Task call.
+ */
+export const HOOK_PROGRESS_COMMAND = 'peaks progress start --project "${CLAUDE_PROJECT_DIR}" --reason "auto-spawn for sub-agent Task" --quiet';
+/** Substring that identifies a Peaks-managed PreToolUse gate-enforce hook entry. */
+export const HOOK_ENFORCE_SENTINEL = 'peaks gate enforce';
+/** Substring that identifies a Peaks-managed PreToolUse sub-agent-progress hook entry. */
+export const HOOK_PROGRESS_SENTINEL = 'peaks progress start';
+const HOOK_GATE_MATCHER = 'Bash';
+const HOOK_PROGRESS_MATCHER = 'Task';
+/**
+ * Substring sentinels that identify a Peaks-managed PreToolUse hook entry.
+ * Used to keep `uninstall` and `isInstalled` checks tight: we only touch
+ * entries we wrote, never third-party hooks.
+ */
+const PEAKS_HOOK_SENTINELS = [HOOK_ENFORCE_SENTINEL, HOOK_PROGRESS_SENTINEL];
+export const PEAKS_HOOK_ENTRIES = [
+    { sentinel: HOOK_ENFORCE_SENTINEL, matcher: HOOK_GATE_MATCHER, command: HOOK_ENFORCE_COMMAND },
+    { sentinel: HOOK_PROGRESS_SENTINEL, matcher: HOOK_PROGRESS_MATCHER, command: HOOK_PROGRESS_COMMAND }
+];
 function isInsidePath(childPath, parentPath) {
     const rel = relative(parentPath, childPath);
     return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
@@ -87,9 +109,17 @@ function readPreToolUse(settings) {
     const pre = hooks.PreToolUse;
     return Array.isArray(pre) ? pre : [];
 }
+/** True when every command handler in the entry matches a known peaks sentinel. */
 function entryIsPeaksManaged(entry) {
     const handlers = Array.isArray(entry?.hooks) ? entry.hooks : [];
-    return handlers.length > 0 && handlers.every((h) => typeof h?.command === 'string' && h.command.includes(HOOK_SENTINEL));
+    if (handlers.length === 0)
+        return false;
+    return handlers.every((h) => {
+        if (typeof h?.command !== 'string')
+            return false;
+        const cmd = h.command;
+        return PEAKS_HOOK_SENTINELS.some((sentinel) => cmd.includes(sentinel));
+    });
 }
 function isInstalled(settings) {
     return readPreToolUse(settings).some(entryIsPeaksManaged);
@@ -100,18 +130,32 @@ export function planHookInstall(scope, projectRoot) {
     assertSafeSettingsPath(scope, root, settingsPath);
     const exists = existsSync(settingsPath);
     const settings = readSettings(settingsPath);
-    return { scope, settingsPath, exists, alreadyInstalled: isInstalled(settings), desiredCommand: HOOK_ENFORCE_COMMAND };
+    return {
+        scope,
+        settingsPath,
+        exists,
+        alreadyInstalled: isInstalled(settings),
+        desiredCommand: HOOK_ENFORCE_COMMAND,
+        sentinel: HOOK_ENFORCE_SENTINEL,
+        matcher: HOOK_GATE_MATCHER
+    };
 }
-/** Merge our PreToolUse entry into settings, preserving all other keys and hooks. */
-function withHookInstalled(settings) {
+/** Merge all peaks-managed PreToolUse entries into settings, preserving all other keys and hooks. */
+function withHooksInstalled(settings) {
     const existingHooks = (settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks))
         ? settings.hooks
         : {};
     const preToolUse = readPreToolUse(settings);
-    const ourEntry = { matcher: HOOK_MATCHER, hooks: [{ type: 'command', command: HOOK_ENFORCE_COMMAND }] };
+    // Drop any existing peaks-managed entries first so re-runs are idempotent
+    // even if the command string changed (e.g. a bug fix in the command).
+    const nonPeaks = preToolUse.filter((entry) => !entryIsPeaksManaged(entry));
+    const ourEntries = PEAKS_HOOK_ENTRIES.map((spec) => ({
+        matcher: spec.matcher,
+        hooks: [{ type: 'command', command: spec.command }]
+    }));
     return {
         ...settings,
-        hooks: { ...existingHooks, PreToolUse: [...preToolUse, ourEntry] }
+        hooks: { ...existingHooks, PreToolUse: [...nonPeaks, ...ourEntries] }
     };
 }
 export function applyHookInstall(scope, projectRoot) {
@@ -121,10 +165,10 @@ export function applyHookInstall(scope, projectRoot) {
     const exists = existsSync(settingsPath);
     const settings = readSettings(settingsPath);
     if (isInstalled(settings)) {
-        return { scope, settingsPath, exists, alreadyInstalled: true, desiredCommand: HOOK_ENFORCE_COMMAND, applied: false };
+        return { scope, settingsPath, exists, alreadyInstalled: true, desiredCommand: HOOK_ENFORCE_COMMAND, applied: false, sentinel: HOOK_ENFORCE_SENTINEL, matcher: HOOK_GATE_MATCHER };
     }
-    atomicWriteJson(settingsPath, withHookInstalled(settings));
-    return { scope, settingsPath, exists, alreadyInstalled: false, desiredCommand: HOOK_ENFORCE_COMMAND, applied: true };
+    atomicWriteJson(settingsPath, withHooksInstalled(settings));
+    return { scope, settingsPath, exists, alreadyInstalled: false, desiredCommand: HOOK_ENFORCE_COMMAND, applied: true, sentinel: HOOK_ENFORCE_SENTINEL, matcher: HOOK_GATE_MATCHER };
 }
 export function removeHookInstall(scope, projectRoot) {
     const root = resolveSettingsRoot(scope, projectRoot);

package/dist/src/services/skills/skill-presence-service.js

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { findProjectRoot } from '../config/config-safety.js';
 import { ensureMemoryBootstrap } from '../memory/project-memory-service.js';
 import { getSessionMeta } from '../session/session-manager.js';
@@ -31,8 +31,16 @@ function getCurrentOuterSessionId() {
         return claude;
     return undefined;
 }
-const PRESENCE_FILE = '.peaks/.active-skill.json';
-const SESSION_FILE = '.peaks/.session.json';
+// As of slice 2026-06-05-peaks-runtime-layer the orchestrator's
+// active-skill marker lives under `.peaks/_runtime/active-skill.json`.
+// The legacy `.peaks/.active-skill.json` path is preserved as a
+// read-only fallback for one minor release so older CLI versions (or
+// trees that have not been migrated by `peaks workspace reconcile`)
+// keep working without a forced re-init.
+const PRESENCE_FILE = join('.peaks', '_runtime', 'active-skill.json');
+const PRESENCE_FILE_LEGACY = '.peaks/.active-skill.json';
+const SESSION_FILE = join('.peaks', '_runtime', 'session.json');
+const SESSION_FILE_LEGACY = '.peaks/.session.json';
 function resolveProjectRoot(override) {
     if (override)
         return resolve(override);
@@ -41,12 +49,44 @@ function resolveProjectRoot(override) {
 function resolvePresencePath(projectRootOverride) {
     return resolve(resolveProjectRoot(projectRootOverride), PRESENCE_FILE);
 }
+/**
+ * Back-compat read for the active-skill marker. Prefers the new
+ * canonical `.peaks/_runtime/active-skill.json`; falls back to the
+ * legacy `.peaks/.active-skill.json` for one minor release.
+ *
+ * Returns the parsed SkillPresence object, or null when neither
+ * file is present / valid. The legacy file is never written by
+ * current code — only the new path receives writes.
+ */
+function readSkillPresenceBackCompat(projectRootOverride) {
+    const presencePath = resolvePresencePath(projectRootOverride);
+    const legacyPath = resolve(resolveProjectRoot(projectRootOverride), PRESENCE_FILE_LEGACY);
+    const pathToRead = existsSync(presencePath) ? presencePath : legacyPath;
+    if (!existsSync(pathToRead))
+        return null;
+    try {
+        const raw = readFileSync(pathToRead, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.skill !== 'string' || parsed.skill.length === 0) {
+            return null;
+        }
+        return { presence: parsed, path: pathToRead };
+    }
+    catch {
+        return null;
+    }
+}
 function getCurrentSessionId(projectRootOverride) {
-    const sessionPath = resolve(resolveProjectRoot(projectRootOverride), SESSION_FILE);
-    if (!existsSync(sessionPath))
+    const projectRoot = resolveProjectRoot(projectRootOverride);
+    const sessionPath = resolve(projectRoot, SESSION_FILE);
+    const legacyPath = resolve(projectRoot, SESSION_FILE_LEGACY);
+    // Back-compat window: prefer the new canonical path; fall back to the
+    // legacy `.peaks/.session.json` for one minor release.
+    const pathToRead = existsSync(sessionPath) ? sessionPath : legacyPath;
+    if (!existsSync(pathToRead))
         return null;
     try {
-        const data = JSON.parse(readFileSync(sessionPath, 'utf8'));
+        const data = JSON.parse(readFileSync(pathToRead, 'utf8'));
         return typeof data.sessionId === 'string' && data.sessionId.length > 0
             ? data.sessionId
             : null;
@@ -80,7 +120,7 @@ function getBoundOuterSessionId(projectRootOverride) {
 }
 /**
  * Snapshot of the previous peaks session's outer session id, read
- * straight off `.peaks/.active-skill.json` *before* we overwrite it.
+ * straight off the active-skill marker *before* we overwrite it.
  * Used to detect "the LLM just opened a fresh outer session" — if
  * the previously-recorded outer session id differs from the one we
  * are about to stamp, the user probably closed the previous outer
@@ -93,27 +133,24 @@ function getBoundOuterSessionId(projectRootOverride) {
  * (most common when the swap is a no-op reconnect) or to roll a
  * fresh session (when the new outer session is genuinely a new
  * task).
+ *
+ * Reads from `.peaks/_runtime/active-skill.json` first; falls back to
+ * the legacy `.peaks/.active-skill.json` for one minor release.
  */
 function getPreviousOuterSessionId(projectRootOverride) {
-    const presencePath = resolvePresencePath(projectRootOverride);
-    if (!existsSync(presencePath))
-        return undefined;
-    try {
-        const raw = readFileSync(presencePath, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.outerSessionId === 'string' && parsed.outerSessionId.length > 0) {
-            return parsed.outerSessionId;
-        }
-        // Legacy field name. Honour it on the read side so v1.2.x
-        // presence files do not show as a false mismatch.
-        if (typeof parsed.claudeSessionId === 'string' && parsed.claudeSessionId.length > 0) {
-            return parsed.claudeSessionId;
-        }
+    const result = readSkillPresenceBackCompat(projectRootOverride);
+    if (result === null)
         return undefined;
+    const parsed = result.presence;
+    if (typeof parsed.outerSessionId === 'string' && parsed.outerSessionId.length > 0) {
+        return parsed.outerSessionId;
     }
-    catch {
-        return undefined;
+    // Legacy field name. Honour it on the read side so v1.2.x
+    // presence files do not show as a false mismatch.
+    if (typeof parsed.claudeSessionId === 'string' && parsed.claudeSessionId.length > 0) {
+        return parsed.claudeSessionId;
     }
+    return undefined;
 }
 export function exportSkillPresence(projectRootOverride) {
     return resolvePresencePath(projectRootOverride);
@@ -184,65 +221,62 @@ export function setSkillPresence(skill, mode, gate, projectRootOverride) {
     return presence;
 }
 export function getSkillPresence(projectRootOverride) {
-    const presencePath = resolvePresencePath(projectRootOverride);
-    if (!existsSync(presencePath)) {
+    const result = readSkillPresenceBackCompat(projectRootOverride);
+    if (result === null)
         return null;
-    }
-    try {
-        const raw = readFileSync(presencePath, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed?.skill !== 'string' || parsed.skill.length === 0) {
-            return null;
-        }
-        if (typeof parsed.sessionId === 'string' && parsed.sessionId.length > 0) {
-            const currentSessionId = getCurrentSessionId(projectRootOverride);
-            if (currentSessionId && parsed.sessionId !== currentSessionId) {
+    const { presence, path: presencePath } = result;
+    if (typeof presence.sessionId === 'string' && presence.sessionId.length > 0) {
+        const currentSessionId = getCurrentSessionId(projectRootOverride);
+        if (currentSessionId && presence.sessionId !== currentSessionId) {
+            try {
                 unlinkSync(presencePath);
-                return null;
             }
+            catch {
+                // best effort
+            }
+            return null;
         }
-        return parsed;
-    }
-    catch {
-        return null;
     }
+    return presence;
 }
 export function touchSkillHeartbeat(projectRootOverride) {
-    const presencePath = resolvePresencePath(projectRootOverride);
-    if (!existsSync(presencePath)) {
+    const result = readSkillPresenceBackCompat(projectRootOverride);
+    if (result === null)
         return null;
-    }
-    try {
-        const raw = readFileSync(presencePath, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed?.skill !== 'string' || parsed.skill.length === 0) {
-            return null;
-        }
-        if (typeof parsed.sessionId === 'string' && parsed.sessionId.length > 0) {
-            const currentSessionId = getCurrentSessionId(projectRootOverride);
-            if (currentSessionId && parsed.sessionId !== currentSessionId) {
+    const { presence, path: presencePath } = result;
+    if (typeof presence.sessionId === 'string' && presence.sessionId.length > 0) {
+        const currentSessionId = getCurrentSessionId(projectRootOverride);
+        if (currentSessionId && presence.sessionId !== currentSessionId) {
+            try {
                 unlinkSync(presencePath);
-                return null;
             }
+            catch {
+                // best effort
+            }
+            return null;
         }
-        parsed.lastHeartbeat = new Date().toISOString();
-        writeFileSync(presencePath, JSON.stringify(parsed, null, 2), 'utf8');
-        return parsed;
-    }
-    catch {
-        return null;
     }
+    presence.lastHeartbeat = new Date().toISOString();
+    writeFileSync(presencePath, JSON.stringify(presence, null, 2), 'utf8');
+    return presence;
 }
 export function clearSkillPresence(projectRootOverride) {
+    // Clear both the new canonical path and the legacy path, so a stale
+    // presence marker from a prior CLI version cannot resurrect after
+    // a fresh `clear`.
     const presencePath = resolvePresencePath(projectRootOverride);
-    if (!existsSync(presencePath)) {
-        return false;
-    }
-    try {
-        unlinkSync(presencePath);
-        return true;
-    }
-    catch {
-        return false;
+    const legacyPath = resolve(resolveProjectRoot(projectRootOverride), PRESENCE_FILE_LEGACY);
+    let cleared = false;
+    for (const p of [presencePath, legacyPath]) {
+        if (!existsSync(p))
+            continue;
+        try {
+            unlinkSync(p);
+            cleared = true;
+        }
+        catch {
+            // best effort
+        }
     }
+    return cleared;
 }

package/dist/src/services/skills/skill-runbook-service.js

@@ -6,7 +6,8 @@ const DESTRUCTIVE_APPLY_PATTERNS = [
     /peaks\s+memory\s+extract[^\n]*--apply/,
     /peaks\s+artifacts\s+sync[^\n]*--apply/,
     /peaks\s+openspec\s+archive[^\n]*--apply/,
-    /peaks\s+standards\s+(?:init|update)[^\n]*--apply/
+    /peaks\s+standards\s+(?:init|update)[^\n]*--apply/,
+    /peaks\s+workspace\s+reconcile[^\n]*--apply/
 ];
 const AUTHORIZATION_KEYWORDS_PATTERN = /authoriz|explicit|--dry-run|approv|only after|only when/i;
 const PEAKS_COMMAND_LINE_PATTERN = /^\s*peaks\s+\w/;

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

@@ -6,16 +6,19 @@ import { findProjectRoot } from '../config/config-safety.js';
  *
  * Claude Code invokes the configured statusLine command on every turn and pipes
  * a JSON session payload on stdin. This renderer reads the durable presence file
- * (.peaks/.active-skill.json) and prints a single line that Claude Code paints at
- * the bottom of the terminal. Because it is rendered by the harness — not emitted
- * as LLM tokens — the signal cannot be forgotten by the model, cannot be confused
- * with normal output, and survives context compaction.
+ * (`.peaks/_runtime/active-skill.json`, with a one-minor-release back-compat
+ * fallback to `.peaks/.active-skill.json`) and prints a single line that
+ * Claude Code paints at the bottom of the terminal. Because it is rendered
+ * by the harness — not emitted as LLM tokens — the signal cannot be forgotten
+ * by the model, cannot be confused with normal output, and survives context
+ * compaction.
  *
  * This module is intentionally READ-ONLY. Unlike getSkillPresence in
  * skill-presence-service.ts, it never deletes or rewrites the presence file:
  * the statusLine runs on every turn and must have zero side effects.
  */
-const PRESENCE_FILE = '.peaks/.active-skill.json';
+const PRESENCE_FILE = '.peaks/_runtime/active-skill.json';
+const PRESENCE_FILE_LEGACY = '.peaks/.active-skill.json';
 const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
 function resolveCwdFromStdin(stdin) {
     const fromWorkspace = stdin?.workspace?.current_dir ?? stdin?.workspace?.project_dir;
@@ -48,11 +51,14 @@ export function parseStatusLineStdin(raw) {
  */
 function readPresenceReadOnly(projectRoot) {
     const presencePath = resolve(projectRoot, PRESENCE_FILE);
-    if (!existsSync(presencePath)) {
+    // Back-compat: prefer the new canonical path; fall back to the legacy
+    // `.peaks/.active-skill.json` for one minor release.
+    const pathToRead = existsSync(presencePath) ? presencePath : resolve(projectRoot, PRESENCE_FILE_LEGACY);
+    if (!existsSync(pathToRead)) {
         return { presence: null, invalid: false };
     }
     try {
-        const parsed = JSON.parse(readFileSync(presencePath, 'utf8'));
+        const parsed = JSON.parse(readFileSync(pathToRead, 'utf8'));
         if (!parsed || typeof parsed !== 'object') {
             return { presence: null, invalid: true };
         }

package/dist/src/services/slice/slice-check-service.d.ts

@@ -0,0 +1,2 @@
+import type { SliceCheckOptions, SliceCheckResult } from './slice-check-types.js';
+export declare function sliceCheck(options: SliceCheckOptions): Promise<SliceCheckResult>;

package/dist/src/services/slice/slice-check-service.js

@@ -0,0 +1,248 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { isDirectory } from '../../shared/fs.js';
+import { getCurrentChangeId } from '../../shared/change-id.js';
+import { verifyPipeline } from '../workflow/pipeline-verify-service.js';
+function runCommand(command, args, cwd, timeoutMs) {
+    const start = Date.now();
+    try {
+        const stdout = execFileSync(command, args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+            maxBuffer: 32 * 1024 * 1024
+        }).toString('utf8');
+        return {
+            status: 'pass',
+            stdout,
+            stderr: '',
+            exitCode: 0,
+            durationMs: Date.now() - start
+        };
+    }
+    catch (error) {
+        const stdout = (error?.stdout ?? '').toString('utf8');
+        const stderr = (error?.stderr ?? '').toString('utf8');
+        return {
+            status: 'fail',
+            stdout,
+            stderr,
+            exitCode: typeof error?.status === 'number' ? error.status : 1,
+            durationMs: Date.now() - start
+        };
+    }
+}
+function tailLines(text, max) {
+    const lines = text.split('\n').filter((l) => l.trim().length > 0);
+    if (lines.length <= max)
+        return lines.join('\n');
+    return [...lines.slice(0, 3), `... (${lines.length - max} more lines) ...`, ...lines.slice(-max + 3)].join('\n');
+}
+async function runTypecheck(projectRoot) {
+    const start = Date.now();
+    const result = runCommand('npx', ['tsc', '--noEmit'], projectRoot, 180_000);
+    const testFiles = result.stdout.match(/(tests?\/.*\.test\.ts)/g) ?? [];
+    return {
+        name: 'typecheck',
+        description: 'npx tsc --noEmit (no JS emit, type-only check)',
+        status: result.status,
+        durationMs: result.durationMs,
+        detail: result.status === 'pass'
+            ? `Typecheck passed in ${result.durationMs}ms.`
+            : tailLines(result.stdout + result.stderr, 10) || `tsc exited with code ${result.exitCode}.`,
+        data: { exitCode: result.exitCode }
+    };
+}
+function parseVitestSummary(stdout, fallbackDuration) {
+    // Vitest 2.x prints e.g. "Test Files  1 passed (1)" and "Tests  1 passed (1)"
+    // and "Duration  0.50s" or "Duration  1.23s". Be lenient with regex.
+    const testsMatch = /Tests?\s+(\d+)\s+(?:passed|run)/.exec(stdout);
+    const failedMatch = /Tests?\s+(\d+)\s+failed/.exec(stdout);
+    const skippedMatch = /Tests?\s+(\d+)\s+skipped/.exec(stdout);
+    const durationMatch = /Duration[^\d]*(\d+(?:\.\d+)?)\s*s/.exec(stdout);
+    return {
+        tests: testsMatch ? parseInt(testsMatch[1], 10) : 0,
+        passed: 0,
+        failed: failedMatch ? parseInt(failedMatch[1], 10) : 0,
+        skipped: skippedMatch ? parseInt(skippedMatch[1], 10) : 0,
+        durationMs: durationMatch ? Math.round(parseFloat(durationMatch[1]) * 1000) : fallbackDuration
+    };
+}
+async function runUnitTests(projectRoot) {
+    const start = Date.now();
+    const result = runCommand('npx', ['vitest', 'run', '--reporter=default', '--coverage=false'], projectRoot, 600_000);
+    const summary = parseVitestSummary(result.stdout, result.durationMs);
+    // Vitest doesn't always print the per-bucket counts cleanly; infer "passed"
+    // as total - failed - skipped when failed/skipped buckets are present.
+    const passed = Math.max(summary.tests - summary.failed - summary.skipped, 0);
+    return {
+        name: 'unit-tests',
+        description: 'npx vitest run (full test suite, coverage off)',
+        status: result.status,
+        durationMs: result.durationMs,
+        detail: result.status === 'pass'
+            ? `All tests passed in ${result.durationMs}ms.`
+            : tailLines(result.stdout + result.stderr, 12) || `vitest exited with code ${result.exitCode}.`,
+        data: {
+            tests: summary.tests,
+            passed,
+            failed: summary.failed,
+            skipped: summary.skipped,
+            exitCode: result.exitCode
+        }
+    };
+}
+const REVIEW_FILES = [
+    { name: 'code-review', path: 'rd/code-review.md', label: 'code-review' },
+    { name: 'security-review', path: 'rd/security-review.md', label: 'security-review' },
+    { name: 'perf-baseline', path: 'rd/perf-baseline.md', label: 'perf-baseline' }
+];
+async function runReviewFanout(projectRoot, rid, refresh) {
+    const start = Date.now();
+    if (refresh) {
+        // `peaks-rd` does the 3-way fan-out when the slice is in `spec-locked` or
+        // `implemented` state. The actual fan-out is invoked via the `peaks-rd`
+        // skill body, not via a CLI subcommand (each sub-agent is invoked with
+        // its own prompt). When `--refresh-fanout` is set, we emit a
+        // nextAction that tells the caller to invoke `Skill(skill="peaks-rd")`
+        // (the role skill owns the 3 review artifact writes).
+        return {
+            name: 'review-fanout',
+            description: '3-way review fan-out (code-review + security-review + perf baseline)',
+            status: 'skipped',
+            durationMs: Date.now() - start,
+            detail: '3-way fan-out is dispatched via Skill(skill="peaks-rd"); invoke it to regenerate the review artifacts.',
+            data: { refresh: true, rid }
+        };
+    }
+    // Default: verify all 3 review files exist with non-empty content. The
+    // files can live under EITHER `.peaks/<rid>/rd/` (active change-id) or
+    // `.peaks/retrospective/<rid>/rd/` (shipped). The boundary check
+    // accepts either — the LLM may be at a slice that's still active
+    // (not yet archived) or one that just shipped.
+    const scopes = [rid, `retrospective/${rid}`];
+    const missing = [];
+    const found = [];
+    for (const review of REVIEW_FILES) {
+        let hit = null;
+        for (const scope of scopes) {
+            const abs = join(projectRoot, '.peaks', scope, review.path);
+            if (existsSync(abs)) {
+                const bytes = statSync(abs).size;
+                if (bytes >= 20) {
+                    hit = { abs, scope, bytes };
+                    break;
+                }
+            }
+        }
+        if (hit === null) {
+            missing.push(review.label);
+            continue;
+        }
+        found.push({ name: review.name, path: hit.abs, bytes: hit.bytes, scope: hit.scope });
+    }
+    const status = missing.length === 0 ? 'pass' : 'fail';
+    return {
+        name: 'review-fanout',
+        description: '3-way review fan-out (code-review + security-review + perf baseline)',
+        status,
+        durationMs: Date.now() - start,
+        detail: status === 'pass'
+            ? `All 3 review artifacts present (${found.map((f) => f.name).join(', ')}; scope: ${found[0]?.scope}).`
+            : `Missing or empty: ${missing.join(', ')}. Re-run with --refresh-fanout or invoke Skill(skill="peaks-rd") to regenerate.`,
+        data: { found, missing }
+    };
+}
+async function runGateVerifyPipeline(projectRoot, rid, changeId) {
+    const start = Date.now();
+    try {
+        const result = await verifyPipeline({ projectRoot, rid, changeId });
+        const duration = Date.now() - start;
+        return {
+            name: 'gate-verify-pipeline',
+            description: 'peaks workflow verify-pipeline (RD/QA gate checks against .peaks/<changeId>/)',
+            status: result.complete ? 'pass' : 'fail',
+            durationMs: duration,
+            detail: result.complete
+                ? `All gates passed in ${duration}ms.`
+                : `${result.violations.length} violation(s): ${result.violations.join('; ')}`,
+            data: {
+                rdGates: result.rdPhase.gates.length,
+                qaGates: result.qaPhase.gates.length,
+                rdState: result.rdPhase.state,
+                qaState: result.qaPhase.state,
+                violations: result.violations,
+                nextActions: result.nextActions
+            }
+        };
+    }
+    catch (error) {
+        return {
+            name: 'gate-verify-pipeline',
+            description: 'peaks workflow verify-pipeline (RD/QA gate checks against .peaks/<changeId>/)',
+            status: 'fail',
+            durationMs: Date.now() - start,
+            detail: error?.message ?? 'verify-pipeline threw',
+            data: {}
+        };
+    }
+}
+export async function sliceCheck(options) {
+    const peaksRoot = join(options.projectRoot, '.peaks');
+    if (!(await isDirectory(peaksRoot))) {
+        throw new Error(`.peaks/ not found at ${options.projectRoot}. Run peaks workspace init first.`);
+    }
+    // Resolve rid: explicit > current-change binding > null
+    let rid = options.rid;
+    if (rid === undefined) {
+        const bound = getCurrentChangeId(options.projectRoot);
+        if (bound !== null) {
+            rid = bound;
+        }
+    }
+    if (rid === undefined) {
+        throw new Error('No --rid and no current-change binding. Pass --rid <id> or run peaks workspace init --change-id <id> first.');
+    }
+    const totalStart = Date.now();
+    const stages = [];
+    // Stage 1: typecheck
+    stages.push(await runTypecheck(options.projectRoot));
+    // Stage 2: full vitest
+    if (!options.skipTests) {
+        stages.push(await runUnitTests(options.projectRoot));
+    }
+    else {
+        stages.push({
+            name: 'unit-tests',
+            description: 'npx vitest run (skipped per --skip-tests)',
+            status: 'skipped',
+            durationMs: 0,
+            detail: 'Skipped: --skip-tests was set.'
+        });
+    }
+    // Stage 3: 3-way review fanout check
+    stages.push(await runReviewFanout(options.projectRoot, rid, options.refreshFanout));
+    // Stage 4: gate verify-pipeline
+    stages.push(await runGateVerifyPipeline(options.projectRoot, rid, rid));
+    const boundaryReady = stages.every((s) => s.status === 'pass' || s.status === 'skipped');
+    const nextActions = [];
+    if (!boundaryReady) {
+        const failed = stages.filter((s) => s.status === 'fail');
+        for (const f of failed) {
+            nextActions.push(`Fix ${f.name}: ${f.detail.split('\n')[0]}`);
+        }
+    }
+    else {
+        nextActions.push(`peaks request transition ${rid} --role rd --state qa-handoff --confirm --project <path>`);
+        nextActions.push(`peaks request transition ${rid} --role qa --state verdict-issued --confirm --project <path>`);
+    }
+    return {
+        projectRoot: options.projectRoot,
+        rid,
+        stages,
+        boundaryReady,
+        totalDurationMs: Date.now() - totalStart,
+        nextActions
+    };
+}