peaks-loop 4.0.16 → 4.0.17

package/dist/cli/commands/hooks-commands.js

@@ -43,7 +43,16 @@ function listExpectedEntriesForIde(ide, _skipProgress = false) {
     if (ide === 'trae') {
         return [{ matcher: adapter.toolMatcher, sentinel: 'peaks hook handle' }];
     }
-    return [{ matcher: adapter.toolMatcher, sentinel: 'peaks gate enforce' }];
+    // Slice 2026-08-06-codegate-vendor-neutral: Claude Code install
+    // also emits the Edit|Write|MultiEdit code-gate entry. The summary
+    // mirrors the install shape, NOT a hardcoded expected list. The
+    // hook source of truth is `src/services/hooks/pre-tool-code-gate.sh`
+    // (vendor-neutral); the runtime adapter is `peaks code-gate --json`
+    // registered as a PreToolUse entry.
+    return [
+        { matcher: adapter.toolMatcher, sentinel: 'peaks gate enforce' },
+        { matcher: 'Edit|Write|MultiEdit', sentinel: 'peaks code-gate' }
+    ];
 }
 /**
  * Slice 2026-07-24-peaks-code-bridge-002-rootcause (G6b / G10): copy the
@@ -98,6 +107,26 @@ function copyBridgeHookIfPresent(userHome) {
     copyFileSync(source, target);
     return { copied: true, source, target };
 }
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral: copy the code-gate hook
+ * source (`src/services/hooks/pre-tool-code-gate.sh`) into the user-
+ * global peaks-code hooks dir, mirroring the bridge-hook copy. The
+ * hook itself is vendor-neutral (no `claude` / `anthropic` strings in
+ * the script) — this installer is the vendor adapter that decides
+ * where the file lands. The CLI command `peaks code-gate` is the
+ * runtime entry; the shell script is the canonical artifact distributed
+ * alongside the bridge hook.
+ */
+function copyCodeGateHookIfPresent(userHome) {
+    const source = resolve(__dirname, '..', '..', 'services', 'hooks', 'pre-tool-code-gate.sh');
+    const target = resolve(userHome, '.claude', 'skills', 'peaks-code', 'hooks', 'pre-tool-code-gate.sh');
+    if (!existsSync(source)) {
+        return { copied: false, source, target };
+    }
+    mkdirSync(dirname(target), { recursive: true });
+    copyFileSync(source, target);
+    return { copied: true, source, target };
+}
 export function registerHooksCommands(program, io) {
     const hooks = program
         .command('hooks')
@@ -121,6 +150,14 @@ export function registerHooksCommands(program, io) {
                 const bridgeCopy = scope === 'global'
                     ? copyBridgeHookIfPresent(process.env.USERPROFILE ?? process.env.HOME ?? '')
                     : { copied: false, source: '', target: '' };
+                // Slice 2026-08-06-codegate-vendor-neutral: also copy the
+                // code-gate hook script. The runtime gate lives at
+                // `peaks code-gate --json` (registered as a PreToolUse entry
+                // in the install output); the script is the build artifact
+                // distributed alongside the bridge hook.
+                const codeGateCopy = scope === 'global'
+                    ? copyCodeGateHookIfPresent(process.env.USERPROFILE ?? process.env.HOME ?? '')
+                    : { copied: false, source: '', target: '' };
                 printResult(io, ok('hooks.install', {
                     ...plan,
                     ide,
@@ -129,6 +166,7 @@ export function registerHooksCommands(program, io) {
                     skipProgress,
                     entries: dryRunEntries,
                     bridgeHookCopy: bridgeCopy,
+                    codeGateHookCopy: codeGateCopy,
                     // Slice 2026-07-29-worktree-layer3-deny: surface the
                     // Layer 3 deny entries the install WOULD write. The
                     // dry-run branch never actually invokes
@@ -141,7 +179,10 @@ export function registerHooksCommands(program, io) {
                     `would write ${listSuperpowersDenyEntries().length} permissions.deny entries (Layer 3 worktree governance)`,
                     bridgeCopy.copied
                         ? `would copy bridge hook from ${bridgeCopy.source} to ${bridgeCopy.target}`
-                        : 'would not copy bridge hook (source missing or non-global scope)'
+                        : 'would not copy bridge hook (source missing or non-global scope)',
+                    codeGateCopy.copied
+                        ? `would copy code-gate hook from ${codeGateCopy.source} to ${codeGateCopy.target}`
+                        : 'would not copy code-gate hook (source missing or non-global scope)'
                 ]), options.json);
                 return;
             }
@@ -161,6 +202,14 @@ export function registerHooksCommands(program, io) {
             const bridgeCopy = scope === 'global'
                 ? copyBridgeHookIfPresent(process.env.USERPROFILE ?? process.env.HOME ?? '')
                 : { copied: false, source: '', target: '' };
+            // Slice 2026-08-06-codegate-vendor-neutral: also copy the
+            // code-gate hook script. The runtime gate lives at
+            // `peaks code-gate --json` (registered as a PreToolUse entry
+            // in the install output); the script is the build artifact
+            // distributed alongside the bridge hook.
+            const codeGateCopy = scope === 'global'
+                ? copyCodeGateHookIfPresent(process.env.USERPROFILE ?? process.env.HOME ?? '')
+                : { copied: false, source: '', target: '' };
             const nextActions = result.applied
                 ? [
                     'Restart the IDE (or reload the workspace) so the hook entries take effect',
@@ -170,7 +219,10 @@ export function registerHooksCommands(program, io) {
                     `Layer 3 deny: wrote ${listSuperpowersDenyEntries().length} permissions.deny entries (worktree governance)`,
                     bridgeCopy.copied
                         ? `Copied bridge hook: ${bridgeCopy.target}`
-                        : 'Bridge hook not copied (source missing or non-global scope)'
+                        : 'Bridge hook not copied (source missing or non-global scope)',
+                    codeGateCopy.copied
+                        ? `Copied code-gate hook: ${codeGateCopy.target}`
+                        : 'Code-gate hook not copied (source missing or non-global scope)'
                 ]
                 : (bridgeCopy.copied
                     ? [`Bridge hook copied: ${bridgeCopy.target}`]
@@ -189,6 +241,7 @@ export function registerHooksCommands(program, io) {
                 skipProgress,
                 entries: installedEntries.map((e) => ({ matcher: e.matcher, sentinel: e.sentinel })),
                 bridgeHookCopy: bridgeCopy,
+                codeGateHookCopy: codeGateCopy,
                 permissionsDenyApplied: result.applied,
                 permissionsDenyEntries: denyEntries
             }, [], nextActions), options.json);

package/dist/cli/commands/qa-commands.js

@@ -25,8 +25,7 @@
  * with reason `--no-browser`. This is a slice-level opt-out for
  * backend-only or already-covered-by-unit-tests work.
  */
-import { join } from 'node:path';
-import { resolve } from 'node:path';
+import { join, resolve } from 'node:path';
 import { addJsonOption, printResult } from '../cli-helpers.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { archiveScreenshots } from '../../services/qa/screenshot-archive-service.js';

package/dist/cli/commands/sediment-commands.d.ts

@@ -1,5 +1,5 @@
 import type { Command } from "commander";
-import type { ProgramIO } from "../cli-helpers.js";
+import { type ProgramIO } from "../cli-helpers.js";
 export interface CliResult {
     ok: boolean;
     error?: string;

package/dist/cli/commands/slice-commands.js

@@ -9,6 +9,17 @@ import { decompose as multiPassDecompose } from '../../services/slice/multi-pass
 import { readResult as readDecompositionResult, writeResult as writeSchemaResult } from '../../services/slice/schema-router.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+/**
+ * PRD-002b slice 2 — extract CLI listing-pagination + table-format
+ * constants. Values are bytewise-identical to the original literals.
+ */
+const SLICE_LIST_DEFAULT_LIMIT = 50;
+const SLICE_LIST_MAX_LIMIT = 500;
+const SLICE_LIST_RID_COL_WIDTH = 34;
+const SLICE_LIST_MTIME_COL_WIDTH = 22;
+const SLICE_LIST_SIZE_COL_WIDTH = 8;
+const SLICE_LIST_PICKED_COL_WIDTH = 6;
+const SLICE_LIST_SEPARATOR_WIDTH = 76;
 export function registerSliceCommands(program, io) {
     const slice = program.command('slice').description('Slice lifecycle: check (boundary), decompose (PRD -> 6-stage algorithm), ' +
         'pick (fzf multi-select), plan (apply via peaks request init). ' +
@@ -67,12 +78,12 @@ export function registerSliceCommands(program, io) {
         '(mtime > 30d). Use --stale-only to filter, --rid <substring> to narrow, ' +
         '--limit <n> to cap. To remove stale entries, use `peaks slice cleanup` (separate slice).')
         .option('--project <path>', 'target project root', '.')
-        .option('--limit <n>', 'cap result count (default 50, max 500)', (v) => parseInt(v, 10), 50)
+        .option('--limit <n>', 'cap result count (default 50, max 500)', (v) => parseInt(v, 10), SLICE_LIST_DEFAULT_LIMIT)
         .option('--stale-only', 'only include rids older than the stale threshold', false)
         .option('--rid <substring>', 'case-insensitive substring filter on rid', '')).action((options) => {
         try {
             const projectRoot = resolveCanonicalProjectRoot(options.project);
-            const limit = Math.max(1, Math.min(500, options.limit ?? 50));
+            const limit = Math.max(1, Math.min(SLICE_LIST_MAX_LIMIT, options.limit ?? SLICE_LIST_DEFAULT_LIMIT));
             const all = listDecompositions(projectRoot);
             let filtered = all;
             const ridSub = (options.rid ?? '').toLowerCase();
@@ -97,13 +108,13 @@ export function registerSliceCommands(program, io) {
             }
             // Plaintext mode: header + table
             const lines = [];
-            lines.push('RID'.padEnd(34) + 'MTIME'.padEnd(22) + 'SIZE'.padEnd(8) + 'PICKED'.padEnd(6) + 'STALE');
-            lines.push('-'.repeat(76));
+            lines.push('RID'.padEnd(SLICE_LIST_RID_COL_WIDTH) + 'MTIME'.padEnd(SLICE_LIST_MTIME_COL_WIDTH) + 'SIZE'.padEnd(SLICE_LIST_SIZE_COL_WIDTH) + 'PICKED'.padEnd(SLICE_LIST_PICKED_COL_WIDTH) + 'STALE');
+            lines.push('-'.repeat(SLICE_LIST_SEPARATOR_WIDTH));
             for (const r of page) {
-                lines.push(r.rid.padEnd(34) +
-                    r.mtime.padEnd(22) +
-                    String(r.sizeBytes).padEnd(8) +
-                    (r.pickedPath ? 'yes' : 'no').padEnd(6) +
+                lines.push(r.rid.padEnd(SLICE_LIST_RID_COL_WIDTH) +
+                    r.mtime.padEnd(SLICE_LIST_MTIME_COL_WIDTH) +
+                    String(r.sizeBytes).padEnd(SLICE_LIST_SIZE_COL_WIDTH) +
+                    (r.pickedPath ? 'yes' : 'no').padEnd(SLICE_LIST_PICKED_COL_WIDTH) +
                     (r.isStale ? 'yes' : 'no'));
             }
             if (truncated) {
@@ -365,6 +376,7 @@ function writeDecompositionFile(rid, result, projectRoot) {
  * recorded in .peaks/memory/ for follow-up). If that slice ships with a
  * different default, both must update here.
  */
+// eslint-disable-next-line no-magic-numbers -- canonical 30-day-in-ms math
 const STALE_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1000;
 /**
  * Enumerate every slice decomposition artifact under

package/dist/cli/commands/statusline-commands.d.ts

@@ -3,6 +3,7 @@ import { type ProgramIO } from '../cli-helpers.js';
 type RenderOptions = {
     project?: string;
     json?: boolean;
+    now?: number | string;
 };
 /**
  * Default-statusline render body. Reused by both the top-level default

package/dist/cli/commands/statusline-commands.js

@@ -74,7 +74,14 @@ export async function runDefaultStatuslineRender(options, io) {
     const seeded = options.project
         ? { ...(stdin ?? {}), workspace: { current_dir: options.project } }
         : stdin;
-    const model = buildStatusLineModel(seeded, Date.now());
+    // Slice 2026-08-07-statusline-flake: accept `--now <epoch-ms>` to pin
+    // `Date.now()` for deterministic lifecycle-window checks under full-
+    // suite concurrency. The integration test passes a test-time `now`
+    // pinned at the moment `seedLifecycle` was called so the completed-
+    // expiry window stays in-range regardless of how long the spawned
+    // subprocess sat descheduled. Production callers omit the flag.
+    const now = options.now !== undefined ? Number(options.now) : Date.now();
+    const model = buildStatusLineModel(seeded, now);
     const capability = resolveStatusLineCapability({
         env: process.env,
         isTTY: Boolean(process.stdout.isTTY),
@@ -98,7 +105,8 @@ export function registerStatusLineCommands(program, io) {
     const statusline = addJsonOption(program
         .command('statusline')
         .description('Render the Peaks skill status line for the current session, or manage the adapter-driven statusLine entry. Run with no subcommand to render; with a subcommand (install | uninstall | status) to manage.')
-        .option('--project <path>', 'project root path (used to label the status line when stdin is absent; applies to the default render path)'));
+        .option('--project <path>', 'project root path (used to label the status line when stdin is absent; applies to the default render path)')
+        .option('--now <ms>', 'override current time (epoch ms) — for testing / deterministic rendering of the lifecycle expiry window'));
     // Default behavior: when the user types `peaks statusline` with no
     // subcommand, render the status line. Without this default action,
     // commander falls back to printing usage (Bug-02, ice-cola surface check
@@ -225,6 +233,7 @@ export function registerStatusLineCommands(program, io) {
         '--session-id to target a non-canonical session explicitly.')
         .option('--project <path>', 'project root (auto-detected from cwd when omitted)')
         .option('--session-id <sid>', 'override the active session id (defaults to the canonical binding; supported for QA / internal tooling)')
+        .option('--now <ms>', 'override current time (epoch ms) — for testing / deterministic rendering of the lifecycle expiry window')
         .action((options, command) => {
         // Re-resolve options via `command.optsWithGlobals()` (Commander 12.x
         // compatibility): when the parent `statusline` command has its own
@@ -243,10 +252,15 @@ export function registerStatusLineCommands(program, io) {
                 ? merged.project
                 : (findProjectRoot(process.cwd()) ?? process.cwd());
             const sid = merged.sessionId ?? getSessionIdCanonical(projectRoot) ?? null;
+            // Slice 2026-08-07-statusline-flake: honor `--now` (epoch ms)
+            // when present so deterministic lifecycle-window checks stay
+            // in-range under full-suite concurrency. See `--now` doc on
+            // the parent `statusline` command.
+            const now = merged.now !== undefined ? Number(merged.now) : Date.now();
             const state = decideCompactStatusline({
                 projectRoot,
                 sessionId: sid,
-                now: Date.now(),
+                now,
             });
             const label = renderCompactStatusline(state);
             // For non-JSON mode we print the LABEL DIRECTLY to stdout

package/dist/cli/commands/tech-commands.d.ts

@@ -18,7 +18,7 @@
  *     (B2 contract preservation rule from the rid-009 closure record).
  */
 import type { Command } from 'commander';
-import type { ProgramIO } from '../cli-helpers.js';
+import { type ProgramIO } from '../cli-helpers.js';
 import type { WorkspaceConfig } from '../../services/config/config-types.js';
 import { type TechChangeStatus, type WorkspaceConfig as _WorkspaceConfig } from '../../services/tech/tech-change-id-service.js';
 export type { WorkspaceConfig };

package/dist/services/artifacts/request-artifact-service.d.ts

@@ -1,6 +1,6 @@
 import { DEFAULT_REQUEST_TYPE, isRequestType, VALID_REQUEST_TYPES, type PrerequisiteCheckResult, type RequestType } from './artifact-prerequisites.js';
 export { VALID_REQUEST_TYPES, DEFAULT_REQUEST_TYPE, isRequestType, type RequestType };
-import type { RequestArtifactRole } from './artifact-templates.js';
+import { type RequestArtifactRole } from './artifact-templates.js';
 export type { RequestArtifactRole } from './artifact-templates.js';
 export { formatHandoffPath, formatCommitBoundaryPath, formatSkillUsageLessonsPath } from './artifact-templates.js';
 export type CreateRequestArtifactOptions = {
@@ -110,7 +110,7 @@ export type TransitionRequestArtifactResult = RequestArtifactSummary & {
     content: string;
     bypassedPrerequisites?: PrerequisiteCheckResult;
 };
-import type { RequestArtifactState } from './request-artifact-state-helpers.js';
+import { type RequestArtifactState } from './request-artifact-state-helpers.js';
 export { allowedStatesForRole, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, TypeSanityViolationError, updateStatusBlock } from './request-artifact-state-helpers.js';
 export type { RequestArtifactState } from './request-artifact-state-helpers.js';
 export declare function transitionRequestArtifact(options: TransitionRequestArtifactOptions): Promise<TransitionRequestArtifactResult | null>;

package/dist/services/artifacts/request-artifact-service.js

@@ -16,6 +16,15 @@ import { requireUserConfirmation } from '../mode/mode-enforcement.js';
 import { scanFileSize } from '../scan/file-size-scan.js';
 import { emitObservabilityEvent } from '../observability/observability-service.js';
 export { VALID_REQUEST_TYPES, DEFAULT_REQUEST_TYPE, isRequestType };
+// Re-export the pure-function template surface so external callers (CLI,
+// tests) keep importing from this module unchanged. The render templates,
+// handoff-path helpers, and `RequestArtifactRole` type all live in the
+// sibling `artifact-templates.ts` module — see slice
+// 2026-06-24-handoff-path-canonicalization for the rationale.
+//
+// `import type` is required so the type is in scope as a bare identifier
+// within this file (the value re-export alone does not bring types into
+// the local namespace under `isolatedModules`).
 import { renderTemplate } from './artifact-templates.js';
 export { formatHandoffPath, formatCommitBoundaryPath, formatSkillUsageLessonsPath } from './artifact-templates.js';
 const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
@@ -324,7 +333,7 @@ async function readRequestArtifact(projectRoot, scope, role, found) {
 // the sibling `request-artifact-state-helpers.ts` module — see
 // v2.18.3 file-split for the rationale. Function signatures and
 // behaviour are unchanged (verbatim move).
-import { ALLOWED_STATES_PER_ROLE, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, TypeSanityViolationError, updateStatusBlock } from './request-artifact-state-helpers.js';
+import { ALLOWED_STATES_PER_ROLE, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, TypeSanityViolationError, updateStatusBlock, } from './request-artifact-state-helpers.js';
 export { allowedStatesForRole, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, TypeSanityViolationError, updateStatusBlock } from './request-artifact-state-helpers.js';
 export async function transitionRequestArtifact(options) {
     if (!VALID_ROLES.has(options.role)) {

package/dist/services/audit/enforcers/lint-reference-shape.js

@@ -35,6 +35,20 @@ const ABSOLUTE_PATH_WINDOWS = /[A-Z]:\\[\w\\]/;
 const ABSOLUTE_PATH_UNIX = /\/usr\/(?:local|bin|opt)\b/;
 const MAGIC_NUMBER = /\b(\d{3,})\b/;
 const LOAD_STRATEGY_PATTERN = /loadStrategy:\s*(always|on-demand)/i;
+/**
+ * PRD-002b slice 2 — extract cross-cutting thresholds used by
+ * multiple enforcers (file-size cap, magic-number digit floor).
+ * Per-rule spec literals (≤800 lines, ≤12 H2 headings, ≤10 magic
+ * digits, top-N aggregation cap) are kept inline because they ARE
+ * the rule spec; extracting them would change the rule semantics to
+ * depend on a constant with no semantic gain. Names here describe
+ * the role only.
+ */
+const KB_PER_FILE = 1024;
+const LOAD_STRATEGY_FILE_SIZE_KB = 5;
+const OVERVIEW_TOP_SEARCH_LINES = 30;
+const OVERVIEW_MIN_LINE_COUNT = 200;
+const LOAD_STRATEGY_PROBE_LINES = 20;
 function findLine(lines, pattern) {
     for (let i = 0; i < lines.length; i += 1) {
         if (pattern.test(lines[i] ?? ''))
@@ -129,9 +143,9 @@ export function lintH2CountLe12(ref) {
     return [hit('rl-ref-h2-count-le-12-001', 'at most 12 `## <heading>` per reference', ref.path, 1, `(h2 count ${matches.length} > 12)`)];
 }
 export function lintOverviewNearTop(ref) {
-    if (ref.lines.length <= 200)
+    if (ref.lines.length <= OVERVIEW_MIN_LINE_COUNT)
         return [];
-    if (findLine(ref.lines.slice(0, 30), OVERVIEW_HEADING) !== -1)
+    if (findLine(ref.lines.slice(0, OVERVIEW_TOP_SEARCH_LINES), OVERVIEW_HEADING) !== -1)
         return [];
     return [hit('rl-ref-overview-section-near-top-001', 'long references (>200 lines) must have `## Overview` within the first 30 lines', ref.path, 1, '(missing `## Overview` near top of long reference)')];
 }
@@ -149,7 +163,7 @@ export function lintLoadStrategyAlwaysCacheable(ref) {
     // Heuristic: a loadStrategy: always reference must not have a
     // top-level shell command. This is a soft check — we look at
     // the first 10 non-frontmatter lines for I/O patterns.
-    const lines = ref.lines.slice(0, 20);
+    const lines = ref.lines.slice(0, LOAD_STRATEGY_PROBE_LINES);
     for (const line of lines) {
         if (/^\s*(npm|pnpm|yarn|npx|git|curl|wget|docker)\s+/.test(line)) {
             return [hit('rl-ref-loadstrategy-always-cacheable-001', 'loadStrategy: always references must not run I/O at top of file', ref.path, 1, `(I/O pattern at top of file: ${line.trim()})`)];
@@ -249,7 +263,7 @@ export function lintSkillCitesEveryReference(ref, skill) {
 }
 export function lintLoadStrategyMatchesSize(ref) {
     const sizeBytes = Buffer.byteLength(ref.body, 'utf8');
-    if (sizeBytes <= 5 * 1024)
+    if (sizeBytes <= LOAD_STRATEGY_FILE_SIZE_KB * KB_PER_FILE)
         return [];
     // >5KB file should declare loadStrategy: on-demand (always
     // is a context-budget bug).

package/dist/services/code/auto-compact-orchestrator.js

@@ -36,6 +36,14 @@ import { describeMode, thresholdFor } from './auto-compact-modes.js';
 import { read24hState } from '../24h-mode/store.js';
 import { readCompactLifecycle, writeCompactLifecycle } from '../compact-statusline/compact-lifecycle-store.js';
 const PRE_COMPACT_REASON = 'pre-compact-auto';
+/**
+ * PRD-002b slice 2 — extract the few cross-cutting magic numbers
+ * that actually appear at runtime call sites in this orchestrator.
+ * Threshold ratios (0.85 / 0.95) live in `auto-compact-types.ts`
+ * and are NOT extracted here because they ARE the contract; comment
+ * + spec prose references must keep the literal value visible.
+ */
+const COLLAPSED_ERROR_MAX_CHARS = 160;
 /**
  * Map a context ratio to a `CompactTrigger` action. Pure; the side
  * effects (checkpoint + IDE dispatch) live in `runAutoCompact`. Two
@@ -409,7 +417,7 @@ function summarizeLifecycleError(error) {
         raw = 'unknown error';
     const firstLine = raw.split('\n')[0] ?? '';
     const collapsed = firstLine.replace(/\s+/g, ' ').trim();
-    return collapsed.length === 0 ? 'unknown error' : (collapsed.length > 160 ? collapsed.slice(0, 160) : collapsed);
+    return collapsed.length === 0 ? 'unknown error' : (collapsed.length > COLLAPSED_ERROR_MAX_CHARS ? collapsed.slice(0, COLLAPSED_ERROR_MAX_CHARS) : collapsed);
 }
 /**
  * Slice 2026-08-01-compact-lifecycle (Task 5, Step 4): close out an

package/dist/services/code/batch-heartbeat-poller.js

@@ -1,3 +1,29 @@
+/**
+ * G6 — in-process batch heartbeat poller.
+ *
+ * The Dispatcher (peaks-code main loop) starts one poller per batch.
+ * The poller ticks every 10 s, reads `heartbeats[]` + `lastBeatAt` from
+ * each record in the batch, and emits:
+ *
+ *   - a `dispatcherStatus` envelope to the renderer's `onStatus` callback
+ *     (which formats the single-line status per G6.5)
+ *   - a `stale` envelope to `onStale` if a record crosses the 5-min
+ *     threshold (G6.2 / AC-35)
+ *
+ * The poller does **not**:
+ *   - cancel, kill, or send SIGTERM to a sub-agent (RL-15)
+ *   - modify `outcome` (only the aggregate `status` is flipped to 'stale')
+ *   - block the LLM call (it is fire-and-forget; the parent batch-sync
+ *     wait is governed by the LLM platform, not by this poller)
+ *
+ * The poller stops when:
+ *   - the parent calls `stop()` (batch finished)
+ *   - all records are terminal (`done` / `failed` / `cancelled` / `no-execution`)
+ *
+ * Pure JS event loop — no native deps, no IPC. Designed to be replaced
+ * by a real OS-level watcher in a future slice without changing the
+ * callback contract.
+ */
 import { readRecords } from '../dispatch/dispatch-record-writer.js';
 import { renderStatusLine, summarize, viewSubAgent } from './status-line-renderer.js';
 export const DEFAULT_POLL_INTERVAL_MS = 10_000;

package/dist/services/code/orchestrator-can-do.d.ts

@@ -38,6 +38,19 @@ export declare const ORCHESTRATOR_REDLINE_RATIO = 0.95;
 export declare const ORCHESTRATOR_PRECOMPACT_RATIO = 0.85;
 /** Source-code keywords that signal "do NOT Edit/Write directly". */
 export declare const SOURCE_CODE_KEYWORDS: readonly string[];
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — hard-blocked path families.
+ * When ANY of these substrings appears in the slice-spec, the orchestrator
+ * MUST NOT Edit/Write directly; the probe returns `canDoInSession: false`
+ * with `blockers: ["requires-sub-agent-dispatch"]` to force
+ * `peaks sub-agent dispatch rd`. The hook (`pre-tool-code-gate.sh`)
+ * enforces the same deny at the PreToolUse layer.
+ *
+ * The allow-list (.peaks/**, .peaks/_runtime/**, skill files, docs/**)
+ * is checked by the hook, NOT by this probe — the probe is content-side
+ * (slice-spec text) and the hook is file-side (resolved path on Edit/Write).
+ */
+export declare const HARD_BLOCKED_PATH_FAMILIES: readonly string[];
 /** Decision-marker keywords that signal "needs user AskUserQuestion". */
 export declare const DECISION_KEYWORDS: readonly string[];
 export interface ContextProbe {
@@ -67,6 +80,8 @@ export interface OrchestratorCanDoResult {
     readonly subAgentAvailable: boolean;
     /** Diagnostic — which of the 4 boundary questions fired. */
     readonly q1SourceCodeTouched: boolean;
+    /** Slice 2026-08-06-codegate-vendor-neutral: did the slice-spec mention a hard-blocked path family (src/, tests/unit/, ...)? When true the probe refuses direct execution. */
+    readonly q1HardBlockedPath: boolean;
     readonly q2SubAgentAvailable: boolean;
     readonly q3RequiresUserDecision: boolean;
     readonly q4ContextRatio: number;
@@ -80,6 +95,14 @@ export declare class OrchestratorCanDoError extends Error {
  * the slice-spec string. Case-insensitive substring match.
  */
 export declare function detectSourceCodeTouched(sliceSpec: string): boolean;
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — does the slice-spec mention
+ * any hard-blocked path family? Pure substring match. When true, the
+ * probe returns `canDoInSession: false` with `requires-sub-agent-dispatch`.
+ * This is the LLM-side complement to the `pre-tool-code-gate.sh` hook
+ * (which checks the actual Edit/Write/MultiEdit target path).
+ */
+export declare function detectHardBlockedPath(sliceSpec: string): boolean;
 /**
  * Q3: does the slice require user decisions? Pure keyword scan
  * over the slice-spec string.
@@ -103,6 +126,7 @@ export declare function probeContextRatio(projectRoot: string, peaksBin?: string
  */
 export declare function buildOrchestratorCanDoResult(input: OrchestratorCanDoInput, signals: {
     q1SourceCodeTouched: boolean;
+    q1HardBlockedPath: boolean;
     q2SubAgentAvailable: boolean;
     q3RequiresUserDecision: boolean;
     q4ContextRatio: number;

package/dist/services/code/orchestrator-can-do.js

@@ -55,6 +55,26 @@ export const SOURCE_CODE_KEYWORDS = [
     '.go',
     '.rs',
 ];
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — hard-blocked path families.
+ * When ANY of these substrings appears in the slice-spec, the orchestrator
+ * MUST NOT Edit/Write directly; the probe returns `canDoInSession: false`
+ * with `blockers: ["requires-sub-agent-dispatch"]` to force
+ * `peaks sub-agent dispatch rd`. The hook (`pre-tool-code-gate.sh`)
+ * enforces the same deny at the PreToolUse layer.
+ *
+ * The allow-list (.peaks/**, .peaks/_runtime/**, skill files, docs/**)
+ * is checked by the hook, NOT by this probe — the probe is content-side
+ * (slice-spec text) and the hook is file-side (resolved path on Edit/Write).
+ */
+export const HARD_BLOCKED_PATH_FAMILIES = [
+    'src/',
+    'tests/unit/',
+    'tests/integration/',
+    'config/',
+    'bin/',
+    'scripts/',
+];
 /** Decision-marker keywords that signal "needs user AskUserQuestion". */
 export const DECISION_KEYWORDS = [
     'design',
@@ -82,6 +102,17 @@ export function detectSourceCodeTouched(sliceSpec) {
     const lower = sliceSpec.toLowerCase();
     return SOURCE_CODE_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
 }
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — does the slice-spec mention
+ * any hard-blocked path family? Pure substring match. When true, the
+ * probe returns `canDoInSession: false` with `requires-sub-agent-dispatch`.
+ * This is the LLM-side complement to the `pre-tool-code-gate.sh` hook
+ * (which checks the actual Edit/Write/MultiEdit target path).
+ */
+export function detectHardBlockedPath(sliceSpec) {
+    const lower = sliceSpec.toLowerCase();
+    return HARD_BLOCKED_PATH_FAMILIES.some((fam) => lower.includes(fam.toLowerCase()));
+}
 /**
  * Q3: does the slice require user decisions? Pure keyword scan
  * over the slice-spec string.
@@ -135,6 +166,17 @@ export function buildOrchestratorCanDoResult(input, signals) {
     const blockers = [];
     const warnings = [];
     const suggestions = [];
+    // Slice 2026-08-06-codegate-vendor-neutral — Q1 HARD BLOCKER. When
+    // the slice-spec mentions any hard-blocked path family
+    // (src/, tests/unit/, tests/integration/, config/, bin/, scripts/),
+    // the orchestrator MUST refuse direct execution and force sub-agent
+    // dispatch. This is the LLM-side complement to the
+    // `pre-tool-code-gate.sh` PreToolUse hook.
+    if (signals.q1HardBlockedPath) {
+        blockers.push('requires-sub-agent-dispatch: slice-spec mentions a hard-blocked path family ' +
+            '(src/, tests/unit/, tests/integration/, config/, bin/, scripts/); ' +
+            'orchestrator MUST NOT Edit/Write these directly. Use peaks sub-agent dispatch rd.');
+    }
     // Q2 — sub-agent availability is a hard precondition.
     if (!signals.q2SubAgentAvailable) {
         blockers.push('sub-agent dispatch unavailable (peaks sub-agent dispatch --help failed)');
@@ -154,8 +196,9 @@ export function buildOrchestratorCanDoResult(input, signals) {
     if (signals.q3RequiresUserDecision) {
         warnings.push('slice-spec contains decision keywords; AskUserQuestion before proceeding');
     }
-    // Q1 — source-code touched is NOT a blocker. The orchestrator
-    // delegates via sub-agent dispatch.
+    // Q1 (soft) — source-code touched is a sub-agent-dispatch hint. When
+    // not already hard-blocked (above), surface the dispatch verb. When
+    // already hard-blocked the blocker line carries the same instruction.
     if (signals.q1SourceCodeTouched && signals.q2SubAgentAvailable) {
         const batchId = randomUUID();
         const rid = 'rid-' + Date.now().toString(36);
@@ -175,6 +218,7 @@ export function buildOrchestratorCanDoResult(input, signals) {
         contextRatio: signals.q4ContextRatio,
         subAgentAvailable: signals.q2SubAgentAvailable,
         q1SourceCodeTouched: signals.q1SourceCodeTouched,
+        q1HardBlockedPath: signals.q1HardBlockedPath,
         q2SubAgentAvailable: signals.q2SubAgentAvailable,
         q3RequiresUserDecision: signals.q3RequiresUserDecision,
         q4ContextRatio: signals.q4ContextRatio,
@@ -189,6 +233,7 @@ export async function evaluateOrchestratorCanDo(input) {
         throw new OrchestratorCanDoError('--slice-spec is required', 'MISSING_SLICE_SPEC');
     }
     const q1SourceCodeTouched = detectSourceCodeTouched(input.sliceSpec);
+    const q1HardBlockedPath = detectHardBlockedPath(input.sliceSpec);
     const q3RequiresUserDecision = detectRequiresUserDecision(input.sliceSpec);
     const probeSubAgent = input.probeSubAgentAvailable ?? (() => probeSubAgentAvailable(input.projectRoot));
     const probeContext = input.probeContextRatio ?? (() => probeContextRatio(input.projectRoot));
@@ -198,6 +243,7 @@ export async function evaluateOrchestratorCanDo(input) {
     ]);
     return buildOrchestratorCanDoResult(input, {
         q1SourceCodeTouched,
+        q1HardBlockedPath,
         q2SubAgentAvailable: subAgentAvailable,
         q3RequiresUserDecision,
         q4ContextRatio: ctxProbe.ratio,

package/dist/services/code/post-compact-detector.d.ts

@@ -21,7 +21,7 @@
  * IO: readdir + readFile on `.peaks/_runtime/<sid>/checkpoints/`.
  * No writes (caller logs the decision via the auto-decisions channel).
  */
-import type { SkillPresenceMode } from '../skills/skill-presence-service.js';
+import { type SkillPresenceMode } from '../skills/skill-presence-service.js';
 import { type CodeMode } from './mode-gate.js';
 export type PostCompactResumeReason = 'post-compact-match' | 'sid-unbound' | 'runtime-dir-missing' | 'no-checkpoint-today' | 'no-mode-field' | 'stale-checkpoint' | 'multiple-checkpoints-ambiguous' | 'active-skill-mismatch' | 'checkpoint-read-failed';
 export declare const POST_COMPACT_RESUME_REASONS: readonly PostCompactResumeReason[];