peaks-loop 4.0.16 → 4.0.18

package/dist/services/hooks/pre-tool-code-gate.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — Code-Gate core logic.
+ *
+ * Vendor-neutral PreToolUse gate. Reads the standard `{tool, input}`
+ * JSON hook payload (any IDE / harness using this protocol is
+ * supported; the implementation is host-agnostic) and decides
+ * whether the tool call is allowed:
+ *
+ *   Edit / Write / MultiEdit on hard-blocked path families
+ *   (src/, tests/unit/, tests/integration/, config/, bin/, scripts/)
+ *   → deny with `PEAKS_CODE_PROHIBITED_DIRECT_EDIT`.
+ *
+ *   All other tool calls, OR allow-listed paths
+ *   (.peaks/**, .peaks/_runtime/**, skills/**, docs/**, *.md)
+ *   → allow (silent exit 0).
+ *
+ * Pure function. The shell-script sibling
+ * (`pre-tool-code-gate.sh`) is the canonical source for the same
+ * logic, usable from any non-Node harness. Both share the same
+ * hard-blocked + allow-listed path families.
+ */
+export type GateToolName = 'Edit' | 'Write' | 'MultiEdit' | string;
+export type GatePathKey = 'file_path' | 'path' | 'notebook_path';
+export interface GateInput {
+    readonly tool: GateToolName;
+    readonly input: Readonly<Record<string, unknown>>;
+}
+/** Hard-blocked path families — orchestrator MUST NOT Edit/Write these. */
+export declare const HARD_BLOCKED_PATH_FAMILIES: readonly ["src/", "tests/unit/", "tests/integration/", "config/", "bin/", "scripts/"];
+/** Allow-listed path prefixes / suffixes — orchestrator may freely Edit/Write these. */
+export declare const ALLOW_LISTED_PATH_PATTERNS: readonly [".peaks/", ".peaks_", "skills/", "docs/", ".md", "CHANGELOG.md", "README.md"];
+export type GateVerdict = {
+    readonly action: 'allow';
+} | {
+    readonly action: 'deny';
+    readonly filePath: string;
+    readonly reason: string;
+    readonly message: string;
+};
+/** Pull the target file path from `input.file_path | input.path | input.notebook_path`. */
+export declare function extractFilePath(input: Readonly<Record<string, unknown>>): string;
+/**
+ * Pure decision function. Given the tool name + input object, return
+ * the gate verdict. Tolerates malformed payloads (allow).
+ */
+export declare function decideGateAction(tool: GateToolName, input: Readonly<Record<string, unknown>>): GateVerdict;

package/dist/services/hooks/pre-tool-code-gate.js

@@ -0,0 +1,91 @@
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — Code-Gate core logic.
+ *
+ * Vendor-neutral PreToolUse gate. Reads the standard `{tool, input}`
+ * JSON hook payload (any IDE / harness using this protocol is
+ * supported; the implementation is host-agnostic) and decides
+ * whether the tool call is allowed:
+ *
+ *   Edit / Write / MultiEdit on hard-blocked path families
+ *   (src/, tests/unit/, tests/integration/, config/, bin/, scripts/)
+ *   → deny with `PEAKS_CODE_PROHIBITED_DIRECT_EDIT`.
+ *
+ *   All other tool calls, OR allow-listed paths
+ *   (.peaks/**, .peaks/_runtime/**, skills/**, docs/**, *.md)
+ *   → allow (silent exit 0).
+ *
+ * Pure function. The shell-script sibling
+ * (`pre-tool-code-gate.sh`) is the canonical source for the same
+ * logic, usable from any non-Node harness. Both share the same
+ * hard-blocked + allow-listed path families.
+ */
+/** Hard-blocked path families — orchestrator MUST NOT Edit/Write these. */
+export const HARD_BLOCKED_PATH_FAMILIES = [
+    'src/',
+    'tests/unit/',
+    'tests/integration/',
+    'config/',
+    'bin/',
+    'scripts/',
+];
+/** Allow-listed path prefixes / suffixes — orchestrator may freely Edit/Write these. */
+export const ALLOW_LISTED_PATH_PATTERNS = [
+    '.peaks/',
+    '.peaks_',
+    'skills/',
+    'docs/',
+    '.md',
+    'CHANGELOG.md',
+    'README.md',
+];
+/** Pull the target file path from `input.file_path | input.path | input.notebook_path`. */
+export function extractFilePath(input) {
+    for (const key of ['file_path', 'path', 'notebook_path']) {
+        const v = input[key];
+        if (typeof v === 'string' && v.length > 0)
+            return v;
+    }
+    return '';
+}
+function matchesAny(path, families) {
+    for (const fam of families) {
+        if (path.startsWith(fam))
+            return fam;
+        // also handle ".md" suffix pattern
+        if (fam.startsWith('.') && path.endsWith(fam))
+            return fam;
+    }
+    return null;
+}
+/**
+ * Pure decision function. Given the tool name + input object, return
+ * the gate verdict. Tolerates malformed payloads (allow).
+ */
+export function decideGateAction(tool, input) {
+    // Only gate Edit / Write / MultiEdit.
+    if (tool !== 'Edit' && tool !== 'Write' && tool !== 'MultiEdit') {
+        return { action: 'allow' };
+    }
+    const filePath = extractFilePath(input);
+    if (filePath.length === 0) {
+        // No path → cannot decide; fail-open (allow). The probe side
+        // (`orchestrator-can-do`) handles slice-spec content; this hook
+        // handles file paths only.
+        return { action: 'allow' };
+    }
+    // Allow-list check first — short-circuits any deny.
+    const allowMatch = matchesAny(filePath, ALLOW_LISTED_PATH_PATTERNS);
+    if (allowMatch !== null) {
+        return { action: 'allow' };
+    }
+    // Hard-blocked family check.
+    const denyMatch = matchesAny(filePath, HARD_BLOCKED_PATH_FAMILIES);
+    if (denyMatch !== null) {
+        const reason = `${denyMatch} (orchestrator's hard-blocked path family)`;
+        const message = `PEAKS_CODE_PROHIBITED_DIRECT_EDIT: ${filePath} matches hard-blocked path family ${reason}; ` +
+            `orchestrator MUST NOT Edit/Write these directly. Use: peaks sub-agent dispatch rd --prompt '<your task>' --request-id <rid> --project . --batch-id <uuid>`;
+        return { action: 'deny', filePath, reason, message };
+    }
+    // Anything not in the deny list → allow (e.g. CHANGELOG, README, top-level files).
+    return { action: 'allow' };
+}

package/dist/services/ide/current-model-detector.js

@@ -24,8 +24,7 @@
  *   - It returns `undefined` when detection is unavailable; callers
  *     must fall back to the configured / hardcoded model.
  */
-import { getAdapter } from './ide-registry.js';
-import { listAdapterIds } from './ide-registry.js';
+import { getAdapter, listAdapterIds } from './ide-registry.js';
 /**
  * Probe every registered IDE adapter for its currently-active model
  * id. Returns the first non-empty value found in registration order,

package/dist/services/lint/detect-eslint.js

@@ -4,29 +4,32 @@
  * unified Gate B5 verdict.
  */
 import { spawnSync } from 'node:child_process';
+import { resolveNpxInvocation } from './npx-resolver.js';
 import { ESLINT_PACKAGE_PINS } from './eslint-runner.js';
 const PACKAGES_TO_PROBE = [
     'eslint',
     'typescriptEslintParser',
-    'typescriptEslintPlugin',
-    'importPlugin'
+    'typescriptEslintPlugin'
 ];
 function packageNameFor(key) {
     switch (key) {
         case 'eslint': return 'eslint';
         case 'typescriptEslintParser': return '@typescript-eslint/parser';
         case 'typescriptEslintPlugin': return '@typescript-eslint/eslint-plugin';
-        case 'importPlugin': return 'eslint-plugin-import';
     }
 }
 function probeNpx() {
-    const probe = spawnSync('npx', ['--version'], { encoding: 'utf8' });
+    const { command, args, baseEnv } = resolveNpxInvocation(['--version']);
+    const probe = spawnSync(command, args, { encoding: 'utf8', env: baseEnv });
     return probe.status === 0;
 }
 function probePackage(key) {
     const pkg = packageNameFor(key);
     const pin = ESLINT_PACKAGE_PINS[key];
-    const result = spawnSync('npm', ['view', `${pkg}@${pin}`, 'version'], { encoding: 'utf8' });
+    // shell:true required on Windows because `npm` (like npx) is a `.cmd`
+    // shim; Node 22 refuses to invoke it without shell wrapper.
+    // 2026-08-06 lint-dogfood cycle-2 follow-up.
+    const result = spawnSync('npm', ['view', `${pkg}@${pin}`, 'version'], { encoding: 'utf8', shell: true });
     return result.status === 0;
 }
 export function detectEslint() {

package/dist/services/lint/eslint-runner.d.ts

@@ -1,8 +1,7 @@
 export declare const ESLINT_PACKAGE_PINS: {
-    readonly eslint: "10.8.0";
+    readonly eslint: "8.57.1";
     readonly typescriptEslintParser: "8.66.0";
     readonly typescriptEslintPlugin: "8.66.0";
-    readonly importPlugin: "2.32.0";
 };
 export type RedLineMode = 'none' | 'baseline-aware';
 export type EslintState = 'ok' | 'eslint-missing' | 'npx-failed' | 'execution-failed' | 'baseline-missing';

package/dist/services/lint/eslint-runner.js

@@ -18,18 +18,34 @@
  *     red-line. Enforces D6 + supplementary S2.
  */
 import { spawnSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { resolveNpxInvocation } from './npx-resolver.js';
+/**
+ * PRD-002b slice 2 — extract runner-pipeline magic numbers (ESLint
+ * severity codes, buffer / timeout budgets, max project-root walk
+ * depth, red-line top-N aggregation cap, base severity defaults).
+ * Values are bytewise-identical to the original literals.
+ */
+const ESLINT_SEVERITY_ERROR = 2;
+const ESLINT_SEVERITY_WARN = 1;
+const ESLINT_DEFAULT_TIMEOUT_MS = 60_000;
+const KB_PER_MB = 1024;
+const BYTES_PER_KB = 1024;
+const MB_TO_BYTES = KB_PER_MB * BYTES_PER_KB;
+const DIFF_BUFFER_BYTES = 16 * MB_TO_BYTES;
+const OUTPUT_BUFFER_BYTES = 32 * MB_TO_BYTES;
+const PROJECT_ROOT_WALK_MAX_DEPTH = 8;
+const RED_LINE_TOP_FILES = 5;
 export const ESLINT_PACKAGE_PINS = {
-    eslint: '10.8.0',
+    eslint: '8.57.1',
     typescriptEslintParser: '8.66.0',
-    typescriptEslintPlugin: '8.66.0',
-    importPlugin: '2.32.0'
+    typescriptEslintPlugin: '8.66.0'
 };
 function severityFor(value) {
-    if (value === 2)
+    if (value === ESLINT_SEVERITY_ERROR)
         return 'error';
-    if (value === 1)
+    if (value === ESLINT_SEVERITY_WARN)
         return 'warn';
     return 'info';
 }
@@ -52,13 +68,30 @@ function summarize(findings) {
  * touched line number. Falls back to [] on any parse error so the
  * caller treats all findings as out-of-diff (no silent zero-result).
  */
+function resolveProjectRoot(cwd) {
+    // ESLint 8 auto-discovers `.eslintrc.*` from cwd upward. When the
+    // CLI is launched via `node bin/peaks.js`, cwd is the bin/ dir and
+    // ESLint fails to find the config. Walk up until we see
+    // `config/eslint/.peaks-rules.cjs` and use that as the project root.
+    const marker = join('config', 'eslint', '.peaks-rules.cjs');
+    let current = cwd;
+    for (let depth = 0; depth < PROJECT_ROOT_WALK_MAX_DEPTH; depth += 1) {
+        if (existsSync(join(current, marker)))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return cwd;
+}
 function loadDiffRanges(cwd) {
     const ranges = [];
     try {
         const result = spawnSync('git', ['diff', 'HEAD', '--unified=0', '--no-color'], {
             cwd,
             encoding: 'utf8',
-            maxBuffer: 16 * 1024 * 1024
+            maxBuffer: DIFF_BUFFER_BYTES
         });
         if (result.status !== 0 || typeof result.stdout !== 'string')
             return [];
@@ -168,7 +201,7 @@ function aggregateRedLine(baseline) {
         const topFiles = [...agg.fileCounts.entries()]
             .map(([file, count]) => ({ file, count }))
             .sort((a, b) => b.count - a.count)
-            .slice(0, 5);
+            .slice(0, RED_LINE_TOP_FILES);
         out.push({ ruleId, count: agg.count, topFiles });
     }
     out.sort((a, b) => b.count - a.count);
@@ -193,16 +226,19 @@ export function buildEslintArgs(options) {
             code: 'LINT_FIX_FORBIDDEN'
         });
     }
-    const args = [
-        '--package', `eslint@${ESLINT_PACKAGE_PINS.eslint}`,
-        '--package', `@typescript-eslint/parser@${ESLINT_PACKAGE_PINS.typescriptEslintParser}`,
-        '--package', `@typescript-eslint/eslint-plugin@${ESLINT_PACKAGE_PINS.typescriptEslintPlugin}`,
-        '--package', `eslint-plugin-import@${ESLINT_PACKAGE_PINS.importPlugin}`,
-        '--', 'eslint', '--no-warn-ignored', '--format', 'json'
-    ];
-    if (options.configPath !== undefined) {
-        args.push('--config', options.configPath);
-    }
+    // The runner now uses the locally-installed eslint binary
+    // (`./node_modules/eslint/bin/eslint.js`) instead of the npx
+    // --package wrapper, which is broken on Windows (npm 10.9.4 chdirs
+    // the child to its own cache bin, breaking config auto-discovery).
+    // The pin constants are kept for detect-eslint's npm-registry
+    // probe + for the npx-resolver fallback path.
+    const args = ['--format', 'json'];
+    // Always pass the legacy .peaks-rules.cjs path; ESLint 8
+    // auto-discovers only `.eslintrc.*` files and our config lives at
+    // `config/eslint/.peaks-rules.cjs`. Callers may override via
+    // `options.configPath`.
+    const effectiveConfigPath = options.configPath ?? join('config', 'eslint', '.peaks-rules.cjs');
+    args.push('--config', effectiveConfigPath);
     args.push(...(options.scope !== undefined && options.scope.length > 0 ? [options.scope] : ['.']));
     return args;
 }
@@ -215,13 +251,40 @@ export function runEslint(options) {
     catch (error) {
         return emptyResult('execution-failed', start, error instanceof Error ? error.message : String(error));
     }
+    const projectRoot = resolveProjectRoot(options.cwd);
+    // Invoke eslint via `node <node_modules/eslint/bin/eslint.js>` to bypass
+    // the Windows .cmd shim entirely (Node 22 spawnSync cannot run .cmd
+    // shims without shell:true, and shell:true mangles quoted args).
+    const localEslintJs = join(projectRoot, 'node_modules', 'eslint', 'bin', 'eslint.js');
+    const useLocal = existsSync(localEslintJs);
     const spawnOptions = {
-        cwd: options.cwd,
+        cwd: projectRoot,
         encoding: 'utf8',
-        timeout: options.timeoutMs ?? 60_000,
-        maxBuffer: 32 * 1024 * 1024
+        timeout: options.timeoutMs ?? ESLINT_DEFAULT_TIMEOUT_MS,
+        maxBuffer: OUTPUT_BUFFER_BYTES
     };
-    const result = spawnSync('npx', args, spawnOptions);
+    let command;
+    let invocationArgs;
+    let baseEnv;
+    if (useLocal) {
+        command = process.execPath;
+        invocationArgs = [localEslintJs, ...args];
+        baseEnv = process.env;
+    }
+    else {
+        // Fallback: resolve `npx` through the user's bundled npm install to
+        // bypass the Windows .cmd shim + shell-quoting issues.
+        const resolved = resolveNpxInvocation([
+            '--package', `eslint@${ESLINT_PACKAGE_PINS.eslint}`,
+            '--package', `@typescript-eslint/parser@${ESLINT_PACKAGE_PINS.typescriptEslintParser}`,
+            '--package', `@typescript-eslint/eslint-plugin@${ESLINT_PACKAGE_PINS.typescriptEslintPlugin}`,
+            '--', 'eslint', ...args
+        ]);
+        command = resolved.command;
+        invocationArgs = resolved.args;
+        baseEnv = resolved.baseEnv;
+    }
+    const result = spawnSync(command, invocationArgs, { ...spawnOptions, env: baseEnv });
     if (result.error !== undefined && result.error !== null) {
         const message = result.error.message;
         const state = /ENOENT/.test(message) ? 'npx-failed' : 'execution-failed';

package/dist/services/lint/npx-resolver.d.ts

@@ -0,0 +1,6 @@
+export type NpxInvocation = {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly baseEnv: NodeJS.ProcessEnv;
+};
+export declare function resolveNpxInvocation(npxArgs: readonly string[]): NpxInvocation;

package/dist/services/lint/npx-resolver.js

@@ -0,0 +1,47 @@
+/**
+ * Cross-platform `npx` resolver.
+ *
+ * On Windows, `npm` installs `npx` as a `.cmd` shim; Node 22's
+ * `child_process.spawnSync` refuses to invoke it unless `shell: true`
+ * is set, and `shell: true` corrupts quoted `--package` arguments.
+ * Rather than depend on shell quoting, this helper resolves the
+ * npx script bundled with the user's `npm` install and invokes it
+ * via `node <npx-cli.js>` with the same argv. macOS / Linux continue
+ * to use the regular `npx` binary.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+function locateNpxCliScript() {
+    const candidates = process.platform === 'win32'
+        ? [
+            join(process.execPath, '..', '..', 'node_modules', 'npm', 'bin', 'npx-cli.js'),
+            'C:/nvm4w/nodejs/node_modules/npm/bin/npx-cli.js',
+            'C:/Program Files/nodejs/node_modules/npm/bin/npx-cli.js'
+        ]
+        : [
+            join(process.execPath, '..', '..', 'lib', 'node_modules', 'npm', 'bin', 'npx-cli.js')
+        ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function resolveNpxInvocation(npxArgs) {
+    if (process.platform === 'win32') {
+        const cliScript = locateNpxCliScript();
+        if (cliScript !== null) {
+            return {
+                command: process.execPath,
+                args: [cliScript, ...npxArgs],
+                baseEnv: process.env
+            };
+        }
+    }
+    return {
+        command: 'npx',
+        args: npxArgs,
+        baseEnv: process.env
+    };
+}

package/dist/services/loop/loop-release-types.js

@@ -1,4 +1,23 @@
 import { z } from "zod";
+/* ---------------------------------------------------------------------- */
+/* PRD-002b slice 2 — schema-limit constants extracted from inline         */
+/* `.max(N)` calls so the no-magic-numbers rule stops flagging the        */
+/* constraint values. Names describe the field, not just the number.     */
+/* Bytewise-identical to the original literals (signaled in commit).     */
+/* ---------------------------------------------------------------------- */
+const LOOP_ID_MAX = 64;
+const LOOP_SHARE_EXCLUDED_PATH_MAX = 4096;
+const LOOP_NAME_MAX = 200;
+const LOOP_SCENARIO_MAX = 4000;
+const LOOP_TRIGGER_POLICY_MAX = 2000;
+const LOOP_SUCCESS_CRITERIA_ITEM_MAX = 1000;
+const LOOP_INTERACTION_POLICY_MAX = 2000;
+const LOOP_FEEDBACK_POLICY_MAX = 2000;
+const LOOP_EVOLUTION_POLICY_MAX = 2000;
+const LOOP_EVALUATOR_POLICY_ITEM_MAX = 1000;
+const LOOP_LINKED_BEE_MAX = 64;
+const LOOP_HISTORY_ITEM_MAX = 128;
+const LOOP_CRYSTALLIZATION_EVIDENCE_MAX = 128;
 /**
  * LoopRelease — spec §4.1 (Loop Engineering Asset).
  *
@@ -74,7 +93,7 @@ export const LOOP_RELEASE_M3_FIELDS = [
 export const LoopReleaseM3ExtensionSchema = z.object({
     shareable: z.boolean().default(true),
     share_excluded_paths: z
-        .array(z.string().min(1).max(4096))
+        .array(z.string().min(1).max(LOOP_SHARE_EXCLUDED_PATH_MAX))
         .default([]),
     desktop_visible: z.boolean().default(true),
     export_bundle_format: z
@@ -92,27 +111,27 @@ export const LoopReleaseInputSchema = z
     id: z
         .string()
         .min(1)
-        .max(64)
+        .max(LOOP_ID_MAX)
         .regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, {
         message: "id must be kebab-case starting with a lowercase letter (e.g. loop-onboarding-research)",
     }),
-    name: z.string().min(1).max(200),
-    scenario: z.string().trim().min(1).max(4000),
-    trigger_policy: z.string().trim().min(1).max(2000),
+    name: z.string().min(1).max(LOOP_NAME_MAX),
+    scenario: z.string().trim().min(1).max(LOOP_SCENARIO_MAX),
+    trigger_policy: z.string().trim().min(1).max(LOOP_TRIGGER_POLICY_MAX),
     success_criteria: z
-        .array(z.string().trim().min(1).max(1000))
+        .array(z.string().trim().min(1).max(LOOP_SUCCESS_CRITERIA_ITEM_MAX))
         .min(1, "success_criteria must list at least one declarative criterion"),
     interaction_policy: z
         .string()
         .trim()
         .min(1, "interaction_policy must declare human-NL-choice-only semantics")
-        .max(2000),
-    feedback_policy: z.string().trim().min(1).max(2000),
-    evolution_policy: z.string().trim().min(1).max(2000),
-    evaluator_policy: z.array(z.string().trim().min(1).max(1000)).min(1),
-    linked_bees: z.array(z.string().min(1).max(64)).default([]),
-    run_history: z.array(z.string().min(1).max(128)).default([]),
-    crystallization_evidence: z.array(z.string().min(1).max(128)).default([]),
+        .max(LOOP_INTERACTION_POLICY_MAX),
+    feedback_policy: z.string().trim().min(1).max(LOOP_FEEDBACK_POLICY_MAX),
+    evolution_policy: z.string().trim().min(1).max(LOOP_EVOLUTION_POLICY_MAX),
+    evaluator_policy: z.array(z.string().trim().min(1).max(LOOP_EVALUATOR_POLICY_ITEM_MAX)).min(1),
+    linked_bees: z.array(z.string().min(1).max(LOOP_LINKED_BEE_MAX)).default([]),
+    run_history: z.array(z.string().min(1).max(LOOP_HISTORY_ITEM_MAX)).default([]),
+    crystallization_evidence: z.array(z.string().min(1).max(LOOP_CRYSTALLIZATION_EVIDENCE_MAX)).default([]),
     lifecycle_status: LoopReleaseLifecycleStatusSchema,
     version: z
         .string()

package/dist/services/loop/spec-service.d.ts

@@ -57,7 +57,13 @@ export declare function resolveLoopSpec(projectRoot: string, sid: string, rid: s
  *  `buildSpec` preserves raw values so out-of-range entries surface in
  *  `lintLoopSpec` rather than being silently clamped. */
 export declare function buildSpec(input: Partial<LoopSpec>, expectedRid: string): LoopSpec;
-/** Lint a LoopSpec — returns a report with semantic errors / warnings. */
+/** Lint a LoopSpec — returns a report with semantic errors / warnings.
+ *
+ *  Refactored 2026-08-07 (PRD-002b slice 3 commit A — extract-method):
+ *  the original function had complexity 14. Each validation phase now lives
+ *  in its own helper, dropping the orchestrator to complexity ~5.
+ *  Behavior is byte-for-byte preserved: same error/warning strings, same
+ *  ordering, same return shape. */
 export declare function lintLoopSpec(spec: LoopSpec): SpecLintReport;
 /** Serialize a LoopSpec to a stable YAML representation. Pure. */
 export declare function serializeSpec(spec: LoopSpec): string;