peaks-loop 4.0.54 → 4.1.0

package/dist/services/scan/file-size-policy.d.ts

@@ -0,0 +1,86 @@
+/** Raw-line cap for `src/`, `scripts/` and `packages/` — including a `tests` directory inside a package. */
+export declare const FILE_SIZE_CAP_DEFAULT = 300;
+/** Raw-line cap for the root `tests/` tree. A `tests/` dir inside a package keeps the 300 cap. */
+export declare const FILE_SIZE_CAP_TESTS = 500;
+/** Directories the policy measures, relative to the project root. */
+export declare const FILE_SIZE_SCOPE_DIRS: readonly ["src", "tests", "packages", "scripts"];
+/** The extensions it measures. The same seven the lint scope admits. */
+export declare const FILE_SIZE_SCOPE_EXTENSIONS: readonly ["ts", "tsx", "mts", "cts", "mjs", "cjs", "js"];
+/** The unit, stated in the artifact that carries the number rather than in prose. */
+export declare const FILE_SIZE_LINE_CONVENTION = "readFileSync(f,'utf8').split('\\n').length";
+/** The two caps, as the census reports them. */
+export type FileSizeCaps = {
+    readonly defaultCap: number;
+    readonly testsCap: number;
+};
+/** The caps this policy defines right now. */
+export declare function fileSizeCaps(): FileSizeCaps;
+/** Forward slashes, so a Windows-native path matches the same rule as a POSIX one. */
+export declare function normalizePolicyPath(file: string): string;
+/** True when `file` ends in an extension the policy measures. */
+export declare function hasPolicyExtension(file: string): boolean;
+/** True when `file` sits under one of the directories the policy measures. */
+export declare function inFileSizeScope(file: string): boolean;
+/**
+ * THE one definition of "a file the policy measures": under a scope directory AND
+ * of a scope extension. Both consumers read this instead of each carrying its own
+ * half of the rule.
+ *
+ * WHY IT MATTERS (F3 of the repair cycle, rid `2026-09-30-cap-unify-01`). The
+ * census enumerated its scope with `git ls-files <dirs>` plus the extension test,
+ * while the scan measured EVERY changed non-exempt file at `fileSizeCapFor`'s
+ * else-branch 300 — including paths in neither list. The two disagreed about the
+ * same policy, and the disagreement was not harmless: an out-of-scope file (e.g.
+ * under `.husky/`, or a `.json`) could redden a `request transition` at 300 lines
+ * while contributing nothing to `fileSizeOverCap`, so there was no ratchet row to
+ * descend and no split campaign that would ever clear it. Enforcement wider than
+ * the declared scope is enforcement nobody can satisfy.
+ */
+export declare function isPolicyMeasuredFile(file: string): boolean;
+/**
+ * The cap a path is measured against: 500 for the root `tests/` tree, 300 for
+ * everything else in scope — including a `tests` directory inside a package,
+ * which keeps its parent scope's cap by the reading decided 2026-09-30.
+ *
+ * PRECONDITION: `isPolicyMeasuredFile(file)`. The else-branch is `src`,
+ * `packages` and `scripts` ONLY because that is what the policy decided; handed a
+ * path outside the scope it would invent a cap for a file the row cannot see, so
+ * callers must gate on the predicate above first (`file-size-scan.ts` does).
+ */
+export declare function fileSizeCapFor(file: string): number;
+/**
+ * The policy's unit: raw lines counted by splitting on newlines. NOT `wc -l` —
+ * see the header. A file with no trailing newline still counts its last line;
+ * an empty file counts as one.
+ */
+export declare function countRawLines(content: string): number;
+/** The top-level directory a scoped path belongs to, as the census buckets it. */
+export declare function fileSizeScopeBucket(file: string): string;
+/** The second scope's directories, relative to the project root. */
+export declare const HOOKS_FILE_SIZE_SCOPE_DIRS: readonly [".husky"];
+/**
+ * The cap the hooks scope is measured against. It ALIASES `FILE_SIZE_CAP_DEFAULT`
+ * rather than restating 300: the 300 is one decision ("may this file be committed
+ * at this size?"), and a second literal here would be the second copy
+ * `tests/unit/standards/file-size-cap.test.ts` exists to report. Aliasing does NOT
+ * mean the hooks ceiling is unbound — the artifact records `hooksCap` as its own
+ * input and `.husky/peaks-gate-file-size.mjs` re-derives it from a live census, so
+ * re-deciding the default cap trips the hooks row's binding too, as a refusal
+ * rather than as a silent re-baseline.
+ */
+export declare const FILE_SIZE_CAP_HOOKS = 300;
+/** The hooks scope's cap, in the shape the census reports it. */
+export type HooksFileSizeCaps = {
+    readonly hooksCap: number;
+};
+/** The cap the hooks scope is measured against right now. */
+export declare function hooksFileSizeCaps(): HooksFileSizeCaps;
+/** True when `file` sits under one of the hooks scope's directories. */
+export declare function inHooksFileSizeScope(file: string): boolean;
+/**
+ * A file the hooks rows measure: under a hooks directory AND of a scope extension.
+ * The extension universe is the SAME seven as the main scope — it is one decision
+ * about what counts as code, and the hooks binding reports it as its own field so a
+ * change to it is named against both scopes.
+ */
+export declare function isHooksMeasuredFile(file: string): boolean;

package/dist/services/scan/file-size-policy.js

@@ -0,0 +1,184 @@
+// src/services/scan/file-size-policy.ts
+//
+// THE ONE SOURCE OF TRUTH for the repo's file-size cap policy: the two caps,
+// the directories they cover, the extensions in scope, and the unit a "line" is
+// measured in. Everything that enforces the cap reads it from here —
+// `src/services/scan/file-size-scan.ts` (the diff-scoped CLI scan) and
+// `scripts/lint/file-size-census.ts` (the whole-tree count the husky gate
+// ratchets). Neither may restate a number.
+//
+// WHY ONE MODULE (rid 2026-09-30-cap-unify-01). The policy was written twice,
+// in two units: `max-lines: [error, {max: 400, skipBlankLines, skipComments}]`
+// in `config/eslint/.peaks-rules.cjs` and a raw `DEFAULT_FILE_SIZE_THRESHOLD`
+// of 800 here. Two spellings of one decision drift by construction, and the only
+// number anyone ratcheted was the eslint finding count — which measures a
+// DIFFERENT population (98 `max-lines` findings under 400-effective vs 174 files
+// over the decided 300/500 raw cap). The eslint rule value is deliberately
+// unchanged until the splits land; see `.peaks/docs/lint-gate.md` §4 slice 5.
+//
+// THE UNIT IS PART OF THE POLICY. A line is
+// `readFileSync(f, 'utf8').split('\n').length` — a split-newline count, which is
+// `wc -l` plus one per file. That is not a detail: on the same 174 files the
+// campaign recorded 60,982 excess lines with this convention and 60,808 with
+// `wc -l`, and a ratchet seeded from the other convention is off by exactly the
+// file count. `countRawLines` below is the only implementation of the word
+// "line" in this policy, and the census reports it in its envelope so a reader
+// of the number can see which unit produced it.
+//
+// `scripts/` IS IN SCOPE. The decided cap text named only `src`, `packages` and
+// `tests`, but the 174 the ceiling was seeded from counts 5 `scripts/` files.
+// A row that silently excluded them would not equal its own measurement — the
+// same class of hole as lint-gate §4b (a surface asserted but never counted).
+//
+// NUMBERS THIS MODULE DOES NOT OWN, DECIDED 2026-09-30 (F6 of the repair cycle).
+// A line-count constant elsewhere in the repo is a second copy of THIS policy only
+// if it decides the same question — "may this file be committed at this size?".
+// Three that do not, recorded here so the next reader does not re-litigate them:
+//   - `config/eslint/.peaks-rules.cjs` `max-lines: 400` EFFECTIVE lines: the same
+//     question in a different unit, deliberately left at 400 until the splits land
+//     (lint-gate §4 slice 5; 98 findings ≠ 174 files).
+//   - `src/services/legacy/legacy-detector.ts` `LARGE_FILE_LINES = 500`: a smell
+//     DETECTOR's "is this file big enough to look legacy?" threshold. It reports a
+//     suspicion, blocks nothing, and descends no ceiling, so it is NOT a copy of
+//     this cap and is NOT folded into it — folding it in would silently change what
+//     the legacy report says. Its name does not match the census's `CAP_NAME`
+//     second-copy rule on purpose; see lint-gate §4b row 7.
+//   - `src/services/skills/lint-reference-shape.ts` 800: the shape of an
+//     example lint report, not a cap.
+/** Raw-line cap for `src/`, `scripts/` and `packages/` — including a `tests` directory inside a package. */
+export const FILE_SIZE_CAP_DEFAULT = 300;
+/** Raw-line cap for the root `tests/` tree. A `tests/` dir inside a package keeps the 300 cap. */
+export const FILE_SIZE_CAP_TESTS = 500;
+/** Directories the policy measures, relative to the project root. */
+export const FILE_SIZE_SCOPE_DIRS = ['src', 'tests', 'packages', 'scripts'];
+/** The extensions it measures. The same seven the lint scope admits. */
+export const FILE_SIZE_SCOPE_EXTENSIONS = ['ts', 'tsx', 'mts', 'cts', 'mjs', 'cjs', 'js'];
+/** The unit, stated in the artifact that carries the number rather than in prose. */
+export const FILE_SIZE_LINE_CONVENTION = "readFileSync(f,'utf8').split('\\n').length";
+/** The caps this policy defines right now. */
+export function fileSizeCaps() {
+    return {
+        defaultCap: FILE_SIZE_CAP_DEFAULT,
+        testsCap: FILE_SIZE_CAP_TESTS
+    };
+}
+/** Forward slashes, so a Windows-native path matches the same rule as a POSIX one. */
+export function normalizePolicyPath(file) {
+    return file.split('\\').join('/');
+}
+/** True when `file` ends in an extension the policy measures. */
+export function hasPolicyExtension(file) {
+    const path = normalizePolicyPath(file);
+    const dot = path.lastIndexOf('.');
+    if (dot < 0)
+        return false;
+    return FILE_SIZE_SCOPE_EXTENSIONS.includes(path.slice(dot + 1));
+}
+/** True when `file` sits under one of the directories the policy measures. */
+export function inFileSizeScope(file) {
+    const path = normalizePolicyPath(file);
+    return FILE_SIZE_SCOPE_DIRS.some((dir) => path.startsWith(`${dir}/`));
+}
+/**
+ * THE one definition of "a file the policy measures": under a scope directory AND
+ * of a scope extension. Both consumers read this instead of each carrying its own
+ * half of the rule.
+ *
+ * WHY IT MATTERS (F3 of the repair cycle, rid `2026-09-30-cap-unify-01`). The
+ * census enumerated its scope with `git ls-files <dirs>` plus the extension test,
+ * while the scan measured EVERY changed non-exempt file at `fileSizeCapFor`'s
+ * else-branch 300 — including paths in neither list. The two disagreed about the
+ * same policy, and the disagreement was not harmless: an out-of-scope file (e.g.
+ * under `.husky/`, or a `.json`) could redden a `request transition` at 300 lines
+ * while contributing nothing to `fileSizeOverCap`, so there was no ratchet row to
+ * descend and no split campaign that would ever clear it. Enforcement wider than
+ * the declared scope is enforcement nobody can satisfy.
+ */
+export function isPolicyMeasuredFile(file) {
+    return inFileSizeScope(file) && hasPolicyExtension(file);
+}
+/**
+ * The cap a path is measured against: 500 for the root `tests/` tree, 300 for
+ * everything else in scope — including a `tests` directory inside a package,
+ * which keeps its parent scope's cap by the reading decided 2026-09-30.
+ *
+ * PRECONDITION: `isPolicyMeasuredFile(file)`. The else-branch is `src`,
+ * `packages` and `scripts` ONLY because that is what the policy decided; handed a
+ * path outside the scope it would invent a cap for a file the row cannot see, so
+ * callers must gate on the predicate above first (`file-size-scan.ts` does).
+ */
+export function fileSizeCapFor(file) {
+    return normalizePolicyPath(file).startsWith('tests/')
+        ? FILE_SIZE_CAP_TESTS
+        : FILE_SIZE_CAP_DEFAULT;
+}
+/**
+ * The policy's unit: raw lines counted by splitting on newlines. NOT `wc -l` —
+ * see the header. A file with no trailing newline still counts its last line;
+ * an empty file counts as one.
+ */
+export function countRawLines(content) {
+    return content.split('\n').length;
+}
+/** The top-level directory a scoped path belongs to, as the census buckets it. */
+export function fileSizeScopeBucket(file) {
+    const path = normalizePolicyPath(file);
+    const slash = path.indexOf('/');
+    return slash < 0 ? path : path.slice(0, slash);
+}
+// ---------------------------------------------------------------------------
+// THE SECOND SCOPE — `.husky/`, the directory the ratchet itself lives in
+// (backlog §2.32, rid 2026-10-02-hooks-size-rows)
+// ---------------------------------------------------------------------------
+//
+// WHAT WAS INVISIBLE. `FILE_SIZE_SCOPE_DIRS` names four directories, and `.husky`
+// is not one of them, so the files that IMPLEMENT this policy were measured by
+// nothing: `scanFileSize()` put them in `outOfScopeFiles`, the artifact's `files`
+// table has no entry for them, and the prettier leg never receives them. The guard
+// grew 456 → 750 and 265 → 662 raw lines in a single day with no ceiling watching
+// it — the exact shape of the hole this repo keeps closing (a surface asserted but
+// never counted).
+//
+// WHY A SECOND SCOPE AND NOT A FIFTH DIRECTORY IN THE FIRST ONE. Joining `.husky`
+// to `FILE_SIZE_SCOPE_DIRS` at the decided cap of 300 raises `fileSizeOverCap`
+// 162 → 165 and `fileSizeExcessLines` 54,318 → 55,834 (+1,516), and the monotonicity
+// guard refuses a raised ceiling by design — correctly, because that is a policy
+// re-decision wearing the clothes of a measurement. So the invisible set gets its
+// OWN two rows (`fileSizeHooksOverCap`, `fileSizeHooksExcessLines`), seeded from its
+// own measurement, ratcheted by the same leg off the same census run.
+//
+// DISJOINT BY CONSTRUCTION, and that is the property the disjointness arms test: no
+// directory is in both lists, so `isPolicyMeasuredFile` and `isHooksMeasuredFile`
+// cannot both answer true for one path, and growth under `.husky/` moves the hooks
+// rows and leaves the two main rows at their own numbers.
+/** The second scope's directories, relative to the project root. */
+export const HOOKS_FILE_SIZE_SCOPE_DIRS = ['.husky'];
+/**
+ * The cap the hooks scope is measured against. It ALIASES `FILE_SIZE_CAP_DEFAULT`
+ * rather than restating 300: the 300 is one decision ("may this file be committed
+ * at this size?"), and a second literal here would be the second copy
+ * `tests/unit/standards/file-size-cap.test.ts` exists to report. Aliasing does NOT
+ * mean the hooks ceiling is unbound — the artifact records `hooksCap` as its own
+ * input and `.husky/peaks-gate-file-size.mjs` re-derives it from a live census, so
+ * re-deciding the default cap trips the hooks row's binding too, as a refusal
+ * rather than as a silent re-baseline.
+ */
+export const FILE_SIZE_CAP_HOOKS = FILE_SIZE_CAP_DEFAULT;
+/** The cap the hooks scope is measured against right now. */
+export function hooksFileSizeCaps() {
+    return { hooksCap: FILE_SIZE_CAP_HOOKS };
+}
+/** True when `file` sits under one of the hooks scope's directories. */
+export function inHooksFileSizeScope(file) {
+    const path = normalizePolicyPath(file);
+    return HOOKS_FILE_SIZE_SCOPE_DIRS.some((dir) => path.startsWith(`${dir}/`));
+}
+/**
+ * A file the hooks rows measure: under a hooks directory AND of a scope extension.
+ * The extension universe is the SAME seven as the main scope — it is one decision
+ * about what counts as code, and the hooks binding reports it as its own field so a
+ * change to it is named against both scopes.
+ */
+export function isHooksMeasuredFile(file) {
+    return inHooksFileSizeScope(file) && hasPolicyExtension(file);
+}

package/dist/services/scan/file-size-scan.d.ts

@@ -1,4 +1,3 @@
-export declare const DEFAULT_FILE_SIZE_THRESHOLD = 800;
 /**
  * Paths exempt from the file-size cap. The cap is Karpathy's "Simplicity
  * First": it exists to make a human *simplify* an over-long file. A path is
@@ -27,10 +26,16 @@ export declare function isSizeCapExempt(file: string): boolean;
 export type FileSizeViolation = {
     file: string;
     lines: number;
+    /** The cap this file was measured against, resolved per path by the policy
+     *  module (300 raw lines; 500 under root `tests/`), or the caller's override. */
+    cap: number;
 };
 export type FileSizeScanResult = {
     ok: boolean;
-    threshold: number;
+    /** The caller's `threshold` override, or `null` when every file was measured
+     *  against its own policy cap. One number cannot describe a two-cap policy,
+     *  so the number that decided a file travels on that file's violation. */
+    threshold: number | null;
     checkedFiles: number;
     /** Paths skipped by SIZE_CAP_EXEMPT_PATTERNS (tool output + append-only
      *  records). Reported so the exemption is auditable rather than a silent
@@ -40,13 +45,35 @@ export type FileSizeScanResult = {
      *  deleted in the working tree). Pre-#015 the scan crashed on these via
      *  ENOENT; now they are reported here as informational data. */
     deletedFiles: string[];
+    /** Changed files the file-size policy does not measure at all: outside its
+     *  four scope directories, or with an extension it does not count. Reported
+     *  rather than silently skipped, for the same reason `exemptFiles` is.
+     *
+     *  WHY THEY ARE NOT VIOLATIONS (F3, rid 2026-09-30-cap-unify-01). Every file
+     *  the scan checked used to be measured against `fileSizeCapFor`, whose
+     *  else-branch is 300 — a number that is only defined for `src`/`packages`/
+     *  `scripts`. So an out-of-scope path (a `.md`, a file under `.husky/`) could
+     *  redden `request transition` at 301 lines while contributing nothing to the
+     *  `fileSizeOverCap` row that ratchets the policy: no ceiling to descend, no
+     *  split campaign with a duty to clear it, and no verdict a contributor could
+     *  act on. Enforcing the cap wider than the declared scope is not a stricter
+     *  gate, it is an unauditable one.
+     *
+     *  A caller that names `threshold` explicitly opts out of the scope rule —
+     *  "apply this number to every changed file" is the documented meaning of the
+     *  flag — and then nothing is out of scope. */
+    outOfScopeFiles: string[];
     violations: FileSizeViolation[];
 };
 export type FileSizeScanOptions = {
     projectRoot: string;
     /** Compare working tree against this ref. Default 'HEAD'. */
     baseRef?: string;
-    /** Line count threshold. Default 800. */
+    /**
+     * Line count threshold applied to EVERY file. When omitted, each file is
+     * measured against the cap `file-size-policy.ts` defines for its directory —
+     * the policy is the default, this option only overrides it.
+     */
     threshold?: number;
 };
 export declare function scanFileSize(options: FileSizeScanOptions): FileSizeScanResult;

package/dist/services/scan/file-size-scan.js

@@ -1,7 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-export const DEFAULT_FILE_SIZE_THRESHOLD = 800;
+import { countRawLines, fileSizeCapFor, isPolicyMeasuredFile } from './file-size-policy.js';
 /**
  * Paths exempt from the file-size cap. The cap is Karpathy's "Simplicity
  * First": it exists to make a human *simplify* an over-long file. A path is
@@ -66,9 +66,15 @@ function getChangedFiles(projectRoot, baseRef) {
         // body to count, and a refactor that deletes large files is exactly
         // when the gate should NOT block. Slice #015 fix.
         const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', '--diff-filter=AM', baseRef], { encoding: 'utf8', windowsHide: true });
-        const tracked = trackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        const tracked = trackedRaw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
         const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8', windowsHide: true });
-        const untracked = untrackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        const untracked = untrackedRaw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
         return Array.from(new Set([...tracked, ...untracked]));
     }
     catch {
@@ -76,16 +82,38 @@ function getChangedFiles(projectRoot, baseRef) {
     }
 }
 function countLines(filePath) {
-    const content = readFileSync(filePath, 'utf8');
-    return content.split(/\r?\n/).length;
+    return countRawLines(readFileSync(filePath, 'utf8'));
+}
+/**
+ * The number a changed file is measured against, or `null` when the policy has no
+ * number for it.
+ *
+ * `null` is a VERDICT, not a missing value: the file is outside the policy's scope
+ * (a directory it does not cover, or an extension it does not count), so it is
+ * neither under the cap nor over it. Keeping the decision in one function is what
+ * stops the scan loop from asking `fileSizeCapFor` about a path that function was
+ * never defined for — the defect the repair cycle found (F3), where the
+ * else-branch's 300 was applied to `.husky/` and `docs/` alike.
+ *
+ * An explicit `threshold` is the caller's own number, so it wins over the scope
+ * rule: `--threshold 4` means "every changed file, at 4", which is what the flag
+ * has always promised.
+ */
+function policyCapFor(file, override) {
+    if (override !== null)
+        return override;
+    return isPolicyMeasuredFile(file) ? fileSizeCapFor(file) : null;
 }
 export function scanFileSize(options) {
     const baseRef = options.baseRef ?? 'HEAD';
-    const threshold = options.threshold ?? DEFAULT_FILE_SIZE_THRESHOLD;
+    // `null` here means "the policy decides, per file" — the cap is a property of
+    // the path (300 raw lines; 500 under root `tests/`), not of the run.
+    const override = options.threshold ?? null;
     const files = getChangedFiles(options.projectRoot, baseRef);
     const violations = [];
     const deletedFiles = [];
     const exemptFiles = [];
+    const outOfScopeFiles = [];
     let checkedFiles = 0;
     for (const file of files) {
         if (isSizeCapExempt(file)) {
@@ -114,18 +142,28 @@ export function scanFileSize(options) {
                 continue;
             }
         }
+        // The cap is decided BEFORE the file is counted, because for a path outside the
+        // policy there is no cap to decide: it is reported in `outOfScopeFiles` instead
+        // of being measured against a number the `fileSizeOverCap` row cannot see and
+        // no split campaign can descend. See `policyCapFor`.
+        const cap = policyCapFor(file, override);
+        if (cap === null) {
+            outOfScopeFiles.push(file);
+            continue;
+        }
         checkedFiles += 1;
         const lines = countLines(absolute);
-        if (lines > threshold) {
-            violations.push({ file, lines });
+        if (lines > cap) {
+            violations.push({ file, lines, cap });
         }
     }
     return {
         ok: violations.length === 0,
-        threshold,
+        threshold: override,
         checkedFiles,
         exemptFiles,
         deletedFiles,
+        outOfScopeFiles,
         violations
     };
 }

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

@@ -136,7 +136,12 @@ export async function scanKarpathy(options) {
             continue;
         for (const ap of ANTI_PATTERNS) {
             if (ap.re.test(line)) {
-                violations.push({ kind: ap.kind, line: i + 1, snippet: line.trim().slice(0, 120), hint: ap.hint });
+                violations.push({
+                    kind: ap.kind,
+                    line: i + 1,
+                    snippet: line.trim().slice(0, 120),
+                    hint: ap.hint
+                });
                 counts[ap.kind] += 1;
             }
         }

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

@@ -22,12 +22,45 @@ const DEFAULT_DIRS = ['src/cli', 'src/services', 'skills', 'tests'];
 // Skip orphan detection for them so sub-commands of these parents aren't
 // confused for top-level orphans.
 const PARENT_COMMANDS = new Set([
-    'scan', 'request', 'session', 'sub-agent', 'openspec', 'sop', 'workspace',
-    'qa', 'sc', 'txt', 'code-review', 'rd', 'sh', 'config', 'audit', 'codegraph',
-    'context', 'agent', 'capability', 'classify', 'gstack', 'gate',
-    'hook', 'hooks', 'log', 'loop', 'memory', 'perf', 'playwright', 'preferences',
-    'project', 'retrospective', 'slice', 'statusline', 'workflow',
-    'migrate', 'mcp', 'doctor', 'help'
+    'scan',
+    'request',
+    'session',
+    'sub-agent',
+    'openspec',
+    'sop',
+    'workspace',
+    'qa',
+    'sc',
+    'txt',
+    'code-review',
+    'rd',
+    'sh',
+    'config',
+    'audit',
+    'codegraph',
+    'context',
+    'agent',
+    'capability',
+    'classify',
+    'gstack',
+    'gate',
+    'hook',
+    'hooks',
+    'log',
+    'loop',
+    'memory',
+    'perf',
+    'playwright',
+    'preferences',
+    'project',
+    'retrospective',
+    'slice',
+    'statusline',
+    'workflow',
+    'migrate',
+    'mcp',
+    'doctor',
+    'help'
 ]);
 const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage']);
 const EXPORT_FUNCTION_RE = /^export\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/gm;
@@ -128,20 +161,37 @@ function dedupeDocEndpointOrphans(items) {
 }
 function scanExportsInFile(content, sourceFile) {
     const out = [];
-    for (const re of [EXPORT_FUNCTION_RE, EXPORT_CLASS_RE, EXPORT_CONST_RE,
-        EXPORT_INTERFACE_RE, EXPORT_TYPE_RE, EXPORT_ENUM_RE,
-        EXPORT_DEFAULT_FUNCTION_RE, EXPORT_DEFAULT_CLASS_RE]) {
+    for (const re of [
+        EXPORT_FUNCTION_RE,
+        EXPORT_CLASS_RE,
+        EXPORT_CONST_RE,
+        EXPORT_INTERFACE_RE,
+        EXPORT_TYPE_RE,
+        EXPORT_ENUM_RE,
+        EXPORT_DEFAULT_FUNCTION_RE,
+        EXPORT_DEFAULT_CLASS_RE
+    ]) {
         re.lastIndex = 0;
     }
     let m;
     while ((m = EXPORT_FUNCTION_RE.exec(content)) !== null) {
-        out.push({ name: m[1], kind: 'function', sourceFile, line: lineOf(content, m.index) });
+        out.push({
+            name: m[1],
+            kind: 'function',
+            sourceFile,
+            line: lineOf(content, m.index)
+        });
     }
     while ((m = EXPORT_CLASS_RE.exec(content)) !== null) {
         out.push({ name: m[1], kind: 'class', sourceFile, line: lineOf(content, m.index) });
     }
     while ((m = EXPORT_INTERFACE_RE.exec(content)) !== null) {
-        out.push({ name: m[1], kind: 'interface', sourceFile, line: lineOf(content, m.index) });
+        out.push({
+            name: m[1],
+            kind: 'interface',
+            sourceFile,
+            line: lineOf(content, m.index)
+        });
     }
     while ((m = EXPORT_TYPE_RE.exec(content)) !== null) {
         out.push({ name: m[1], kind: 'type', sourceFile, line: lineOf(content, m.index) });
@@ -154,7 +204,12 @@ function scanExportsInFile(content, sourceFile) {
     }
     // Slice 2.6.1.A.2: track named default exports.
     while ((m = EXPORT_DEFAULT_FUNCTION_RE.exec(content)) !== null) {
-        out.push({ name: m[1], kind: 'function', sourceFile, line: lineOf(content, m.index) });
+        out.push({
+            name: m[1],
+            kind: 'function',
+            sourceFile,
+            line: lineOf(content, m.index)
+        });
     }
     while ((m = EXPORT_DEFAULT_CLASS_RE.exec(content)) !== null) {
         out.push({ name: m[1], kind: 'class', sourceFile, line: lineOf(content, m.index) });
@@ -182,7 +237,10 @@ function scanNamedImportsInFile(content) {
         const from = m[2];
         const symbols = raw
             .split(',')
-            .map((s) => s.trim().split(/\s+as\s+/)[0]?.trim() ?? '')
+            .map((s) => s
+            .trim()
+            .split(/\s+as\s+/)[0]
+            ?.trim() ?? '')
             .filter((s) => s.length > 0);
         out.push({ symbols, from, line: lineOf(content, m.index) });
     }
@@ -227,9 +285,7 @@ function extractTechDocEndpoints(content) {
 function diffVsHead(projectRoot, baseRef) {
     // Slice 2.6.1.A.4: when a base ref is supplied, diff against that ref instead of HEAD.
     // Default behaviour (no baseRef) preserves backward compatibility.
-    const args = baseRef
-        ? ['diff', '--name-status', baseRef]
-        : ['diff', '--name-status', 'HEAD'];
+    const args = baseRef ? ['diff', '--name-status', baseRef] : ['diff', '--name-status', 'HEAD'];
     const res = spawnSync('git', args, {
         cwd: projectRoot,
         encoding: 'utf8',
@@ -249,7 +305,10 @@ function diffVsHead(projectRoot, baseRef) {
         if (tab < 0)
             continue;
         const status = line.slice(0, tab);
-        const path = line.slice(tab + 1).split('\t')[0]?.split(' ')[0] ?? '';
+        const path = line
+            .slice(tab + 1)
+            .split('\t')[0]
+            ?.split(' ')[0] ?? '';
         if (!path)
             continue;
         if (status.startsWith('A'))
@@ -277,10 +336,15 @@ function scanReExportsInFile(content, sourceFile, projectRoot) {
         while ((m = re.exec(content)) !== null) {
             const raw = m[1];
             const from = m[2];
-            const resolved = from.startsWith('.') ? resolveImportPath(sourceFile, from, projectRoot) : null;
+            const resolved = from.startsWith('.')
+                ? resolveImportPath(sourceFile, from, projectRoot)
+                : null;
             const symbols = raw
                 .split(',')
-                .map((s) => s.trim().split(/\s+as\s+/)[0]?.trim() ?? '')
+                .map((s) => s
+                .trim()
+                .split(/\s+as\s+/)[0]
+                ?.trim() ?? '')
                 .filter((s) => s.length > 0);
             for (const sym of symbols) {
                 out.push({ symbol: sym, from, line: lineOf(content, m.index), resolvedFrom: resolved });
@@ -308,7 +372,9 @@ export async function scanOrphans(options) {
             warnings.push(`unreadable: ${rel}: ${error.message}`);
         }
     }
-    const diff = scope === 'all' ? { added: files, removed: [], modified: files } : diffVsHead(options.projectRoot, options.baseRef);
+    const diff = scope === 'all'
+        ? { added: files, removed: [], modified: files }
+        : diffVsHead(options.projectRoot, options.baseRef);
     const changedSet = new Set([...diff.added, ...diff.modified]);
     const allExports = buildExportIndex(files, fileContents);
     const exportBySource = new Map();