peaks-loop 4.0.16 → 4.0.18

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[];

package/dist/services/compact-statusline/compact-statusline-service.js

@@ -56,17 +56,24 @@ const DEFAULT_STALE_AFTER_MS = 120_000;
 export const COMPLETED_EXPIRY_MS = 10_000;
 /** Legacy mtime window for the "just compacted" indicator. */
 const LEGACY_JUST_COMPACTED_WINDOW_MS = 30_000;
+// PRD-002b slice 2 — extract cell-table magic numbers (4/6/8) into named
+// consts so the no-magic-numbers lint rule stops flagging the typed
+// literal-union cell-table values. Values match the documented contract.
+const STAGE_CELL_COMPACTING = 4;
+const STAGE_CELL_VERIFYING = 6;
+const STAGE_CELL_COMPLETED = 8;
+/* eslint-disable no-magic-numbers -- cell-table contract uses literal-type unions (`0 | 2 | 4 | 6 | 8`); these are type-position discriminators, not runtime values. Magic-number extraction is done at the runtime call sites via STAGE_CELL_* constants above. */
 const CELL_BY_STAGE = new Map([
     ['queued', 0],
     ['preparing', 2],
-    ['compacting', 4],
-    ['verifying', 6],
-    ['completed', 8],
-    ['failed', 4],
+    ['compacting', STAGE_CELL_COMPACTING],
+    ['verifying', STAGE_CELL_VERIFYING],
+    ['completed', STAGE_CELL_COMPLETED],
+    ['failed', STAGE_CELL_COMPACTING],
 ]);
 const FILLED = '█';
 const EMPTY = '░';
-const BAR_WIDTH = 8;
+const BAR_WIDTH = STAGE_CELL_COMPLETED;
 const NO_AFTER_RATIO_HINT = 'after-ratio not recorded';
 function renderBar(filledCells) {
     return `[${FILLED.repeat(filledCells)}${EMPTY.repeat(BAR_WIDTH - filledCells)}]`;
@@ -74,6 +81,7 @@ function renderBar(filledCells) {
 function renderLegacyBar(filledCells) {
     return renderBar(filledCells);
 }
+/* eslint-enable no-magic-numbers */
 export function decideCompactStatusline(input) {
     const staleAfterMs = input.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
     const completedExpiryMs = input.completedExpiryMs ?? COMPLETED_EXPIRY_MS;
@@ -137,7 +145,7 @@ function stateFromLifecycle(record) {
         const failedAt = record.failedAt ?? 'compacting';
         const state = {
             kind: 'failed',
-            filledCells: CELL_BY_STAGE.get(failedAt) ?? 4,
+            filledCells: CELL_BY_STAGE.get(failedAt) ?? STAGE_CELL_COMPACTING,
             triggerRatio: record.triggerRatio,
             redLine: record.redLine,
             failedAt,
@@ -160,7 +168,7 @@ function stateFromLifecycle(record) {
     return base;
 }
 function stateFromStalled(record) {
-    const filledCells = CELL_BY_STAGE.get(record.stage) ?? 4;
+    const filledCells = CELL_BY_STAGE.get(record.stage) ?? STAGE_CELL_COMPACTING;
     const detailText = record.stage === 'failed'
         ? record.errorSummary
         : `no heartbeat for ${record.stage} stage`;
@@ -236,9 +244,9 @@ export function renderCompactStatusline(state) {
         case 'preparing':
             return `compact ${renderBar(2)}`;
         case 'compacting':
-            return `compact ${renderBar(4)}`;
+            return `compact ${renderBar(STAGE_CELL_COMPACTING)}`;
         case 'verifying':
-            return `compact ${renderBar(6)}`;
+            return `compact ${renderBar(STAGE_CELL_VERIFYING)}`;
         case 'completed':
             return formatCompleted(state);
         case 'failed':
@@ -250,7 +258,7 @@ export function renderCompactStatusline(state) {
     }
 }
 function formatCompleted(state) {
-    const bar = renderBar(8);
+    const bar = renderBar(STAGE_CELL_COMPLETED);
     if (typeof state.afterRatio === 'number') {
         return `compact ${bar} → ${state.afterRatio.toFixed(2)}`;
     }
@@ -258,7 +266,7 @@ function formatCompleted(state) {
 }
 function formatFailed(state) {
     const filledAt = state.failedAt ?? 'compacting';
-    const cells = CELL_BY_STAGE.get(filledAt) ?? 4;
+    const cells = CELL_BY_STAGE.get(filledAt) ?? STAGE_CELL_COMPACTING;
     const bar = renderBar(cells);
     const detail = state.detail ? ` — ${state.detail}` : '';
     return `compact ${bar} failed at ${filledAt}${detail}`;

package/dist/services/config/config-safety.d.ts

@@ -28,6 +28,29 @@ export declare function resolveProjectRootForConfig(startPath: string): string;
  * `git rev-parse` exit; both fall through to the heuristic.
  */
 export declare function resolveCanonicalProjectRoot(startPath: string): string;
+/**
+ * Slice rid-statusline-stale-ux AC-2 + P1 H1 option A: strict
+ * canonicalization for use in trust-boundary paths (e.g.
+ * `peaks session primer`).
+ *
+ * Unlike `resolveCanonicalProjectRoot` (fail-open, returns `start`
+ * on any resolution failure), this helper THROWS on:
+ *   - empty / whitespace-only input
+ *   - NUL byte in input
+ *   - non-existent path (realpathSync ENOENT)
+ *   - non-canonical (symlink) input (when the input path and its
+ *     realpath differ in a way that suggests the user passed a
+ *     symlinked path through a security-sensitive surface)
+ *
+ * Existing fail-open `resolveCanonicalProjectRoot` is retained for
+ * back-compat — many callers depend on the fail-open behavior
+ * (e.g. `init-command.ts:32`). The strict variant is opt-in.
+ */
+export declare class InvalidProjectRootError extends Error {
+    readonly reason: 'empty' | 'nul-byte' | 'non-existent' | 'non-canonical';
+    constructor(reason: 'empty' | 'nul-byte' | 'non-existent' | 'non-canonical', input: string);
+}
+export declare function resolveCanonicalProjectRootStrict(startPath: string): string;
 export declare function getProjectConfigPath(projectRoot: string | null): string | null;
 export declare function getProjectBootstrapConfigPath(projectRoot: string): string;
 export declare function validateProjectBootstrapConfigPathForWrite(projectRoot: string, configPath: string): void;

package/dist/services/config/config-safety.js

@@ -131,6 +131,68 @@ export function resolveCanonicalProjectRoot(startPath) {
     }
     return start;
 }
+/**
+ * Slice rid-statusline-stale-ux AC-2 + P1 H1 option A: strict
+ * canonicalization for use in trust-boundary paths (e.g.
+ * `peaks session primer`).
+ *
+ * Unlike `resolveCanonicalProjectRoot` (fail-open, returns `start`
+ * on any resolution failure), this helper THROWS on:
+ *   - empty / whitespace-only input
+ *   - NUL byte in input
+ *   - non-existent path (realpathSync ENOENT)
+ *   - non-canonical (symlink) input (when the input path and its
+ *     realpath differ in a way that suggests the user passed a
+ *     symlinked path through a security-sensitive surface)
+ *
+ * Existing fail-open `resolveCanonicalProjectRoot` is retained for
+ * back-compat — many callers depend on the fail-open behavior
+ * (e.g. `init-command.ts:32`). The strict variant is opt-in.
+ */
+export class InvalidProjectRootError extends Error {
+    reason;
+    constructor(reason, input) {
+        super(`Invalid project root (${reason}): "${input}"`);
+        this.reason = reason;
+        this.name = 'InvalidProjectRootError';
+    }
+}
+export function resolveCanonicalProjectRootStrict(startPath) {
+    if (!startPath || startPath.trim() === '') {
+        throw new InvalidProjectRootError('empty', startPath);
+    }
+    if (startPath.indexOf('\0') !== -1) {
+        throw new InvalidProjectRootError('nul-byte', startPath);
+    }
+    const start = resolve(startPath);
+    let realStart;
+    try {
+        realStart = realpathSync(start);
+    }
+    catch {
+        throw new InvalidProjectRootError('non-existent', startPath);
+    }
+    if (realStart !== start) {
+        // User passed a path through a symlink; reject as non-canonical
+        // for trust-boundary entry points.
+        throw new InvalidProjectRootError('non-canonical', startPath);
+    }
+    // Delegate to the existing canonicalization (git root → heuristic)
+    // AFTER the strict pre-checks pass.
+    const canonical = resolveCanonicalProjectRoot(startPath);
+    if (canonical === startPath || canonical === realStart) {
+        return canonical;
+    }
+    // Canonicalization moved the path (e.g. to a git root) — accept it
+    // but ensure it also exists.
+    try {
+        realpathSync(canonical);
+        return canonical;
+    }
+    catch {
+        throw new InvalidProjectRootError('non-existent', startPath);
+    }
+}
 function resolveProjectRootFromGit(startPath) {
     // execFileSync (not execSync) so a malicious `startPath` cannot
     // inject argv into the spawned git invocation. The child only

package/dist/services/config/config-service.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigGetOptions, ConfigLayer, ConfigSetOptions, ConfigV2, PeaksConfig, TokenRef, WorkspaceConfig } from './config-types.js';
+import { type ConfigGetOptions, type ConfigLayer, type ConfigSetOptions, type ConfigV2, type PeaksConfig, type TokenRef, type WorkspaceConfig } from './config-types.js';
 export { resolveProjectRootForConfig, resolveCanonicalProjectRoot } from './config-safety.js';
 /**
  * Load the slim 2.0 `~/.peaks/config.json` file. Returns the parsed

package/dist/services/config/config-service.js

@@ -1,12 +1,10 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { dirname, isAbsolute, resolve } from 'node:path';
-import { DEFAULT_CONFIG } from './config-types.js';
+import { DEFAULT_CONFIG, isConfigV2 } from './config-types.js';
 import { stablePath } from '../../shared/path-utils.js';
 import { findProjectRoot, getProjectBootstrapConfigPath, getProjectConfigPath, getUserConfigPath, isInsidePath, readConfigFileSafely, resolveProjectRootForConfig, validateArtifactWorkspaceMarkerPath, validateArtifactWorkspaceRoot, validateProjectBootstrapConfigPathForWrite, validateUserConfigPathForWrite, writeConfigFileSafely, writeProjectConfigFile, writeUserConfigFile } from './config-safety.js';
 import { globalConfigPath, CONFIG_SCHEMA_VERSION_V2 } from './config-migration.js';
-import { isConfigV2 } from './config-types.js';
-import { providersConfigPath, proxyConfigPath, readSidecarJson, sidecarExists, workspacesConfigPath, writeSidecarJson } from './sidecar-store.js';
-import { SIDECAR_SCHEMA_VERSION } from './sidecar-store.js';
+import { SIDECAR_SCHEMA_VERSION, providersConfigPath, proxyConfigPath, readSidecarJson, sidecarExists, workspacesConfigPath, writeSidecarJson } from './sidecar-store.js';
 // Re-export resolveProjectRootForConfig and resolveCanonicalProjectRoot for external consumers
 export { resolveProjectRootForConfig, resolveCanonicalProjectRoot } from './config-safety.js';
 /**

package/dist/services/container/container-lease.js

@@ -30,13 +30,26 @@
 import { randomBytes } from 'node:crypto';
 import { posix as path } from 'node:path';
 import { normalizePath } from '../../shared/path-utils.js';
+/**
+ * PRD-002b slice 2 — lease-TTL primitives extracted so the
+ * no-magic-numbers rule stops flagging the minute/ms math.
+ */
+const MINUTES_PER_HOUR = 60;
+const MS_PER_MINUTE = MINUTES_PER_HOUR * 1_000;
+const LEASE_RD_TTL_MINUTES = 30;
+const LEASE_QA_TTL_MINUTES = 15;
+const LEASE_UI_TTL_MINUTES = MINUTES_PER_HOUR;
+const LEASE_SC_TTL_MINUTES = 30;
+const LEASE_PRD_TTL_MINUTES = 15;
+const LEASE_GENERAL_TTL_MINUTES = 30;
+const LEASE_ID_RANDOM_BYTES = 8;
 export const DEFAULT_TTL_BY_ROLE = Object.freeze({
-    rd: 30 * 60 * 1_000,
-    qa: 15 * 60 * 1_000,
-    ui: 60 * 60 * 1_000,
-    sc: 30 * 60 * 1_000,
-    prd: 15 * 60 * 1_000,
-    general: 30 * 60 * 1_000
+    rd: LEASE_RD_TTL_MINUTES * MS_PER_MINUTE,
+    qa: LEASE_QA_TTL_MINUTES * MS_PER_MINUTE,
+    ui: LEASE_UI_TTL_MINUTES * MS_PER_MINUTE,
+    sc: LEASE_SC_TTL_MINUTES * MS_PER_MINUTE,
+    prd: LEASE_PRD_TTL_MINUTES * MS_PER_MINUTE,
+    general: LEASE_GENERAL_TTL_MINUTES * MS_PER_MINUTE
 });
 export const DEFAULT_TTL_MS = DEFAULT_TTL_BY_ROLE.rd;
 export function containerLeaseStoreDir(sessionRuntimeDir) {
@@ -47,12 +60,12 @@ export function containerLeaseFilePath(sessionRuntimeDir, leaseId) {
 }
 /** Pure: generate a 16-hex lease id (8 random bytes, hex-encoded). */
 export function generateContainerLeaseId() {
-    return randomBytes(8).toString('hex');
+    return randomBytes(LEASE_ID_RANDOM_BYTES).toString('hex');
 }
 export function ttlForContainerRole(role) {
     const normalized = role.toLowerCase();
     const candidate = DEFAULT_TTL_BY_ROLE[normalized];
-    const fallback = DEFAULT_TTL_BY_ROLE['rd'] ?? 30 * 60 * 1_000;
+    const fallback = DEFAULT_TTL_BY_ROLE['rd'] ?? LEASE_RD_TTL_MINUTES * MS_PER_MINUTE;
     return candidate ?? fallback;
 }
 export function finalizeContainerLease(draft) {

package/dist/services/context/spillover-store.d.ts

@@ -1,4 +1,4 @@
-import type { SpillId, SpillOptions, SpillRecord, SpillState } from './spillover-types.js';
+import { type SpillId, type SpillOptions, type SpillRecord, type SpillState } from './spillover-types.js';
 /**
  * Defense-in-depth: assert the given path is NOT a symbolic link.
  *

package/dist/services/crystallization/crystallization-types.js

@@ -1,4 +1,16 @@
 import { z } from "zod";
+/* ---------------------------------------------------------------------- */
+/* PRD-002b slice 2 — schema-limit constants extracted from inline         */
+/* `.max(N)` / `.length(N)` calls so the no-magic-numbers rule stops     */
+/* flagging the constraint values. Names describe the field, not the     */
+/* number. Bytewise-identical to the original literals.                  */
+/* ---------------------------------------------------------------------- */
+const CRYS_BRIEF_SECTION_MAX = 4000;
+const CRYS_EVIDENCE_BULLET_MAX = 1000;
+const CRYS_TRACE_POINTER_MAX = 256;
+const CRYS_LOOP_ID_MAX = 64;
+const CRYS_BEE_ID_MAX_I32 = 2 ** 31 - 1;
+const CRYS_EVENT_ID_MAX = 128;
 /**
  * CrystallizationEvent — spec §4.5 / §4.7 / §5.
  *
@@ -71,7 +83,7 @@ const BriefSectionSchema = z
     .string()
     .trim()
     .min(1, "brief section must be non-empty natural language")
-    .max(4000);
+    .max(CRYS_BRIEF_SECTION_MAX);
 /**
  * EvidenceBrief — the 4-section brief (spec §4.7).
  *
@@ -138,7 +150,7 @@ export function hasAllFourBriefSections(brief) {
 const OptionalLoopId = z
     .string()
     .min(1)
-    .max(64)
+    .max(CRYS_LOOP_ID_MAX)
     .regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, {
     message: "loop_release_id must be kebab-case starting with a lowercase letter",
 })
@@ -147,7 +159,7 @@ const OptionalBeeId = z
     .number()
     .int()
     .positive()
-    .max(2 ** 31 - 1, "bee_release_id out of 32-bit range")
+    .max(CRYS_BEE_ID_MAX_I32, "bee_release_id out of 32-bit range")
     .optional();
 /**
  * Zod schema for the create payload (CrystallizationEventInput).
@@ -161,20 +173,20 @@ export const CrystallizationEventInputSchema = z.object({
     trigger: CrystallizationTriggerSchema,
     evidence_brief: EvidenceBriefSchema,
     evidence_bullets: z
-        .array(z.string().trim().min(1).max(1000))
+        .array(z.string().trim().min(1).max(CRYS_EVIDENCE_BULLET_MAX))
         .default([]),
     source_trace_pointers: z
-        .array(z.string().trim().min(1).max(256))
+        .array(z.string().trim().min(1).max(CRYS_TRACE_POINTER_MAX))
         .default([]),
     evaluator_summary: z
         .string()
         .trim()
-        .max(4000)
+        .max(CRYS_BRIEF_SECTION_MAX)
         .default(""),
     user_decision_summary: z
         .string()
         .trim()
-        .max(4000)
+        .max(CRYS_BRIEF_SECTION_MAX)
         .default(""),
     created_loop_release_id: OptionalLoopId,
     updated_loop_release_id: OptionalLoopId,
@@ -195,7 +207,7 @@ export const CrystallizationEventSchema = CrystallizationEventInputSchema.extend
     id: z
         .string()
         .min(1)
-        .max(128)
+        .max(CRYS_EVENT_ID_MAX)
         .regex(/^crys-[0-9a-f]{8,}$/, {
         message: "id must start with 'crys-' followed by a hex suffix (spec §4.5)",
     }),

package/dist/services/crystallization/evidence-brief-builder.js

@@ -1,5 +1,16 @@
 import { z } from "zod";
 import { EvidenceBriefSchema, } from "./crystallization-types.js";
+/* ---------------------------------------------------------------------- */
+/* PRD-002b slice 2 — schema-limit constants extracted from inline         */
+/* `.max(N)` calls so the no-magic-numbers rule stops flagging the        */
+/* constraint values. Bytewise-identical to the original literals.       */
+/* ---------------------------------------------------------------------- */
+const BRIEF_TRACE_ID_MAX = 256;
+const BRIEF_SECTION_TEXT_MAX = 4000;
+const BRIEF_BULLET_MAX = 1000;
+const BRIEF_TRACE_POINTER_MAX = 256;
+const BRIEF_EVALUATOR_ONE_LINER_MAX = 1000;
+const BRIEF_EVALUATOR_RISK_TAG_MAX = 200;
 /**
  * EvidenceBriefBuilder — spec §4.7 / §10 RL-7.
  *
@@ -45,40 +56,40 @@ import { EvidenceBriefSchema, } from "./crystallization-types.js";
  * editing every caller.
  */
 export const BriefTraceInputSchema = z.object({
-    trace_id: z.string().trim().min(1).max(256),
+    trace_id: z.string().trim().min(1).max(BRIEF_TRACE_ID_MAX),
     /**
      * The full NL recap of the run. Required for what_happened.
      * 1-2 sentences is the spec guidance; the builder does not
      * truncate, but tests passing multi-paragraph input will be
      * warned at the Zod boundary (max 4000 chars per section).
      */
-    what_happened: z.string().trim().min(1).max(4000),
+    what_happened: z.string().trim().min(1).max(BRIEF_SECTION_TEXT_MAX),
     /**
      * The "why this matters" recap. Required for why_it_matters.
      */
-    why_it_matters: z.string().trim().min(1).max(4000),
+    why_it_matters: z.string().trim().min(1).max(BRIEF_SECTION_TEXT_MAX),
     /**
      * Failure-mode and preference-extraction recap. Required for
      * what_learned.
      */
-    what_learned: z.string().trim().min(1).max(4000),
+    what_learned: z.string().trim().min(1).max(BRIEF_SECTION_TEXT_MAX),
     /**
      * The recommended action. Required for what_action (1
      * sentence per spec).
      */
-    what_action: z.string().trim().min(1).max(4000),
+    what_action: z.string().trim().min(1).max(BRIEF_SECTION_TEXT_MAX),
     /**
      * Optional structured bullets (e.g. "4 phases, 3 gates passed,
      * 1 evaluator verdict"). Counts are allowed at this layer; the
      * brief section is the NL primary (RL-7).
      */
-    bullets: z.array(z.string().trim().min(1).max(1000)).default([]),
+    bullets: z.array(z.string().trim().min(1).max(BRIEF_BULLET_MAX)).default([]),
     /**
      * Source trace ids backing the brief (the column on
      * crystallization_event spec §4.5).
      */
     source_trace_pointers: z
-        .array(z.string().trim().min(1).max(256))
+        .array(z.string().trim().min(1).max(BRIEF_TRACE_POINTER_MAX))
         .default([]),
 });
 /**
@@ -88,17 +99,17 @@ export const BriefTraceInputSchema = z.object({
  * flows into the recommendation envelope.
  */
 export const EvaluatorSummarySchema = z.object({
-    one_liner: z.string().trim().max(1000).default(""),
-    risk_tags: z.array(z.string().trim().min(1).max(200)).default([]),
+    one_liner: z.string().trim().max(BRIEF_EVALUATOR_ONE_LINER_MAX).default(""),
+    risk_tags: z.array(z.string().trim().min(1).max(BRIEF_EVALUATOR_RISK_TAG_MAX)).default([]),
 });
 /* ---------------------------------------------------------------------- */
 /* Recommendation envelope — the CLI renders this.                       */
 /* ---------------------------------------------------------------------- */
 export const RecommendationPayloadSchema = z.object({
     brief: EvidenceBriefSchema,
-    bullets: z.array(z.string().trim().min(1).max(1000)).default([]),
+    bullets: z.array(z.string().trim().min(1).max(BRIEF_BULLET_MAX)).default([]),
     source_trace_pointers: z
-        .array(z.string().trim().min(1).max(256))
+        .array(z.string().trim().min(1).max(BRIEF_TRACE_POINTER_MAX))
         .default([]),
     evaluator_summary: EvaluatorSummarySchema.default({
         one_liner: "",