peaks-loop 4.0.0-beta.9 → 4.0.3

package/dist/services/24h-mode/decider.js

@@ -0,0 +1,144 @@
+/**
+ * 24h mode B3 trigger evaluation + attempts counter.
+ *
+ * Rid-020a (state-only slice). `fireB3` is the single mutating
+ * primitive: it increments the per-key counter and escalates with a
+ * `B3Escalation` when the count reaches `B3_THRESHOLD` (3). The
+ * counter is **per-key** — AC-T3 mandates B1 and B2 retries do not
+ * share a global counter. The T3/T4 auto-24H_ACTIVE path is encoded
+ * in `isAutoEngageTrigger` (BRAINSTORM is bypassed for these
+ * triggers so an offline-resumed session does not deadlock in
+ * WAITING_USER — proposal §1 T3/T4 exception).
+ */
+import { B3_THRESHOLD, isDecisionKey } from './state.js';
+import { read24hState } from './store.js';
+export const B3_TRIGGER_REASONS = [
+    'prd_direction_change',
+    'blocker_3_consecutive_slices',
+    'registry_affecting_failure',
+    'destructive_irreversible_op',
+    'any_B1_B2_failure_3x_non_converging',
+    'runtime_or_shared_version_mismatch',
+    'sub-agent_stale_5min_x3'
+];
+export class B3Escalation extends Error {
+    reason;
+    attempts;
+    constructor(reason, attempts) {
+        super(`B3 escalation: reason=${reason}, attempts=${attempts}`);
+        this.name = 'B3Escalation';
+        this.reason = reason;
+        this.attempts = attempts;
+    }
+}
+export function isB3Reason(value) {
+    return B3_TRIGGER_REASONS.includes(value);
+}
+export function isValidReason(value) {
+    return isDecisionKey(value);
+}
+export function freshAttempts() {
+    const out = {};
+    for (const key of B3_TRIGGER_REASONS)
+        out[key] = 0;
+    return out;
+}
+/**
+ * Per AC-T1 (attempts=1 continue, no B3) and AC-T2 (attempts=3
+ * escalate), the 3rd call escalates. The threshold is intentionally
+ * NOT configurable — the proposal pins the constant so QA v3 can
+ * assert it. Returns a FireB3Result instead of throwing so test
+ * code can read the `attempts` field via plain property access
+ * (Error-subclass property access through vitest 4.1.10 matchers
+ * is unreliable; the discriminated union sidesteps that).
+ */
+export function fireB3(reason, attempts) {
+    const cur = attempts[reason] ?? 0;
+    const next = cur + 1;
+    attempts[reason] = next;
+    if (next >= B3_THRESHOLD) {
+        return { kind: 'escalate', reason, attempts: next };
+    }
+    return { kind: 'continue', reason, attempts: next };
+}
+/**
+ * T3 (runaway recovery) and T4 (offline resume) auto-engage
+ * `24H_ACTIVE` without forcing `USER_CONFIRM` — the deferred
+ * AskUserQuestion fires at the first 10min checkpoint instead, so
+ * a T4 session does not deadlock in `WAITING_USER` while the
+ * user is offline (proposal §1 T3/T4 exception).
+ */
+export const AUTO_ENGAGE_TRIGGERS = ['T3', 'T4'];
+export function isAutoEngageTrigger(t) {
+    return AUTO_ENGAGE_TRIGGERS.includes(t);
+}
+export const T1_KEYWORDS = ['24h', '通宵跑', '通宵', '夜跑', '夜机', '不计成本', '不停机'];
+export const T2_MIN_SLICES = 30;
+export const T2_MIN_WALL_HOURS = 6;
+export const T3_MIN_MONOTONIC_GUARDS = 3;
+export const T3_MIN_REMAINING_SLICES = 10;
+export const T4_SESSION_GAP_HOURS = 4;
+export const T5_MIN_ACTIVE_SLICES = 3;
+export function checkTriggers(input) {
+    if (T1_KEYWORDS.some((kw) => input.userMessage.includes(kw))) {
+        return { triggered: true, trigger: 'T1', reason: `T1 keyword match in user message` };
+    }
+    if (input.sliceListSize >= T2_MIN_SLICES || input.estimatedWallHours >= T2_MIN_WALL_HOURS) {
+        return {
+            triggered: true,
+            trigger: 'T2',
+            reason: `T2 scale: sliceList=${input.sliceListSize} OR wallHours=${input.estimatedWallHours}`
+        };
+    }
+    if (input.monotonicGuards >= T3_MIN_MONOTONIC_GUARDS &&
+        input.remainingSlices >= T3_MIN_REMAINING_SLICES) {
+        return {
+            triggered: true,
+            trigger: 'T3',
+            reason: `T3 runaway recovery: monotonicGuards=${input.monotonicGuards} remaining=${input.remainingSlices}`
+        };
+    }
+    if (input.sessionGapHours >= T4_SESSION_GAP_HOURS && input.remainingSlices > 0) {
+        return {
+            triggered: true,
+            trigger: 'T4',
+            reason: `T4 offline resume: gapHours=${input.sessionGapHours} remaining=${input.remainingSlices}`
+        };
+    }
+    if (input.activeSlicesAcrossServices >= T5_MIN_ACTIVE_SLICES) {
+        return {
+            triggered: true,
+            trigger: 'T5',
+            reason: `T5 multi-business: activeAcrossServices=${input.activeSlicesAcrossServices}`
+        };
+    }
+    return { triggered: false, trigger: null, reason: 'no trigger' };
+}
+/**
+ * HANDOFF is reachable via three exit conditions per proposal §1:
+ *   - user abort
+ *   - all-trigger-resolved
+ *   - B3 unresolvable (B3Escalation that the user dismisses)
+ */
+export const HANDOFF_EXIT_CONDITIONS = ['user_abort', 'all_triggers_resolved', 'b3_unresolvable'];
+export function isHandoffExitCondition(s) {
+    return HANDOFF_EXIT_CONDITIONS.includes(s);
+}
+export function isHandoffState(s) {
+    return s === 'HANDOFF';
+}
+/**
+ * Slice 2026-07-28 (rid-027): resolve the auto-compact mode from
+ * 24h-mode awareness. Returns `'partial'` when the session is
+ * `24H_ACTIVE`, otherwise `'standard'`. This is the CLI-side default;
+ * the explicit `--mode` flag in `peaks compact auto` overrides it.
+ */
+export function getAutoCompactMode(projectRoot, sessionId) {
+    try {
+        const snap = read24hState(projectRoot, sessionId);
+        return snap.state === '24H_ACTIVE' ? 'partial' : 'standard';
+    }
+    catch {
+        return 'standard';
+    }
+}

package/dist/services/24h-mode/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Public barrel for 24h-mode service module.
+ *
+ * Rid-020a (state-only slice). Exports the 6-state enum, the
+ * DecisionKey enum, the persistence API, and the B3 decider API
+ * so that the `peaks session 24h-mode` CLI (and future rid-020b
+ * `peaks code run --24h`) can consume them without reaching into
+ * the internal file layout.
+ */
+export { B3_THRESHOLD, DECISION_KEYS, STATES, emptyAttempts, isDecisionKey, isState, type DecisionKey, type State, type State24hSnapshot } from './state.js';
+export { STATE_STORE_CONSTANTS, emptySnapshot, read24hState, write24hState } from './store.js';
+export { AUTO_ENGAGE_TRIGGERS, B3_TRIGGER_REASONS, B3Escalation, HANDOFF_EXIT_CONDITIONS, T1_KEYWORDS, T2_MIN_SLICES, T2_MIN_WALL_HOURS, T3_MIN_MONOTONIC_GUARDS, T3_MIN_REMAINING_SLICES, T4_SESSION_GAP_HOURS, T5_MIN_ACTIVE_SLICES, checkTriggers, fireB3, freshAttempts, isAutoEngageTrigger, isB3Reason, isHandoffExitCondition, isHandoffState, isValidReason, type AttemptsMap, type AutoEngageTrigger, type B3Reason, type FireB3Result, type HandoffExitCondition, type TriggerCheck } from './decider.js';

package/dist/services/24h-mode/index.js

@@ -0,0 +1,12 @@
+/**
+ * Public barrel for 24h-mode service module.
+ *
+ * Rid-020a (state-only slice). Exports the 6-state enum, the
+ * DecisionKey enum, the persistence API, and the B3 decider API
+ * so that the `peaks session 24h-mode` CLI (and future rid-020b
+ * `peaks code run --24h`) can consume them without reaching into
+ * the internal file layout.
+ */
+export { B3_THRESHOLD, DECISION_KEYS, STATES, emptyAttempts, isDecisionKey, isState } from './state.js';
+export { STATE_STORE_CONSTANTS, emptySnapshot, read24hState, write24hState } from './store.js';
+export { AUTO_ENGAGE_TRIGGERS, B3_TRIGGER_REASONS, B3Escalation, HANDOFF_EXIT_CONDITIONS, T1_KEYWORDS, T2_MIN_SLICES, T2_MIN_WALL_HOURS, T3_MIN_MONOTONIC_GUARDS, T3_MIN_REMAINING_SLICES, T4_SESSION_GAP_HOURS, T5_MIN_ACTIVE_SLICES, checkTriggers, fireB3, freshAttempts, isAutoEngageTrigger, isB3Reason, isHandoffExitCondition, isHandoffState, isValidReason } from './decider.js';

package/dist/services/24h-mode/state.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 24h mode state machine — state types + DecisionKey enum.
+ *
+ * Rid-020a (state-only slice). The proposal defines six states that
+ * capture the lifecycle of a 24h code run; the DecisionKey enum is the
+ * enumeration of B1/B2 decision keys whose retry counter lives in
+ * `AttemptsMap`. Persistence and trigger evaluation live in sibling
+ * files; this module is pure data so the persistence tests can
+ * round-trip without pulling in IO and the decider tests can be
+ * exercised on an in-memory map.
+ */
+export declare const STATES: readonly ["IDLE", "BRAINSTORM", "USER_CONFIRM", "24H_ACTIVE", "WAITING_USER", "HANDOFF"];
+export type State = (typeof STATES)[number];
+/**
+ * Reasons recorded in the persisted `attempts` map. Mirrors the
+ * 7 B3 trigger rows in the v2 proposal §1 (B3 trigger table) plus
+ * generic B1/B2 retry keys (per-key independence in AC-T3).
+ */
+export declare const DECISION_KEYS: readonly ["prd_direction_change", "blocker_3_consecutive_slices", "registry_affecting_failure", "destructive_irreversible_op", "any_B1_B2_failure_3x_non_converging", "runtime_or_shared_version_mismatch", "sub-agent_stale_5min_x3"];
+export type DecisionKey = (typeof DECISION_KEYS)[number];
+/**
+ * B3 trigger threshold: per decision key, the 3rd consecutive fire
+ * escalates. Lower thresholds are not configurable here — proposal
+ * pins the constant so QA v3 can verify.
+ */
+export declare const B3_THRESHOLD = 3;
+/**
+ * The persisted shape for `.peaks/_runtime/<sessionId>/24h-state.json`.
+ * `enteredAt` is the ISO timestamp of the most recent state
+ * transition; `enteredFrom` is the previous state (or `null` for the
+ * IDLE bootstrap). `attempts` is keyed by `DecisionKey` and
+ * monotonically incremented by `fireB3`.
+ */
+export interface State24hSnapshot {
+    state: State;
+    enteredAt: string;
+    enteredFrom: State | null;
+    activeSlices: string[];
+    monotonicGuards: number;
+    autoCompactCount: number;
+    checkpoints: number;
+    lastCheckpointAt: string | null;
+    attempts: Record<DecisionKey, number>;
+    exitCondition: string | null;
+}
+export declare function isState(value: string): value is State;
+export declare function isDecisionKey(value: string): value is DecisionKey;
+export declare function emptyAttempts(): Record<DecisionKey, number>;

package/dist/services/24h-mode/state.js

@@ -0,0 +1,51 @@
+/**
+ * 24h mode state machine — state types + DecisionKey enum.
+ *
+ * Rid-020a (state-only slice). The proposal defines six states that
+ * capture the lifecycle of a 24h code run; the DecisionKey enum is the
+ * enumeration of B1/B2 decision keys whose retry counter lives in
+ * `AttemptsMap`. Persistence and trigger evaluation live in sibling
+ * files; this module is pure data so the persistence tests can
+ * round-trip without pulling in IO and the decider tests can be
+ * exercised on an in-memory map.
+ */
+export const STATES = [
+    'IDLE',
+    'BRAINSTORM',
+    'USER_CONFIRM',
+    '24H_ACTIVE',
+    'WAITING_USER',
+    'HANDOFF'
+];
+/**
+ * Reasons recorded in the persisted `attempts` map. Mirrors the
+ * 7 B3 trigger rows in the v2 proposal §1 (B3 trigger table) plus
+ * generic B1/B2 retry keys (per-key independence in AC-T3).
+ */
+export const DECISION_KEYS = [
+    'prd_direction_change',
+    'blocker_3_consecutive_slices',
+    'registry_affecting_failure',
+    'destructive_irreversible_op',
+    'any_B1_B2_failure_3x_non_converging',
+    'runtime_or_shared_version_mismatch',
+    'sub-agent_stale_5min_x3'
+];
+/**
+ * B3 trigger threshold: per decision key, the 3rd consecutive fire
+ * escalates. Lower thresholds are not configurable here — proposal
+ * pins the constant so QA v3 can verify.
+ */
+export const B3_THRESHOLD = 3;
+export function isState(value) {
+    return STATES.includes(value);
+}
+export function isDecisionKey(value) {
+    return DECISION_KEYS.includes(value);
+}
+export function emptyAttempts() {
+    const out = {};
+    for (const key of DECISION_KEYS)
+        out[key] = 0;
+    return out;
+}

package/dist/services/24h-mode/store.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 24h mode persistence — atomic JSON snapshot under
+ * `.peaks/_runtime/<sessionId>/24h-state.json`.
+ *
+ * Rid-020a (state-only slice). The store never invents a session id:
+ * the caller passes one (the CLI resolves it from `.peaks/_runtime/session.json`).
+ * Writes use the temp-file + rename pattern so a crash mid-write never
+ * leaves a half-written state file (atomic on POSIX, near-atomic on
+ * Windows — same approach used by `session-checkpoint-service.ts`).
+ */
+import { type State24hSnapshot } from './state.js';
+export declare function emptySnapshot(now?: Date): State24hSnapshot;
+export declare function read24hState(projectRoot: string, sessionId: string): State24hSnapshot;
+/**
+ * Atomic write: temp file in the same directory, then rename. The
+ * rename is a single syscall on POSIX and a single MoveFile on
+ * Windows — a crash in between leaves the previous valid snapshot
+ * intact. `fsync` on the temp file is omitted (we accept the
+ * same weaker contract that `session-checkpoint-service.ts` uses)
+ * because the state is reconstructible from the B3 attempt log.
+ */
+export declare function write24hState(projectRoot: string, sessionId: string, snapshot: State24hSnapshot): {
+    path: string;
+};
+export declare const STATE_STORE_CONSTANTS: {
+    readonly STATE_FILENAME: "24h-state.json";
+};

package/dist/services/24h-mode/store.js

@@ -0,0 +1,119 @@
+/**
+ * 24h mode persistence — atomic JSON snapshot under
+ * `.peaks/_runtime/<sessionId>/24h-state.json`.
+ *
+ * Rid-020a (state-only slice). The store never invents a session id:
+ * the caller passes one (the CLI resolves it from `.peaks/_runtime/session.json`).
+ * Writes use the temp-file + rename pattern so a crash mid-write never
+ * leaves a half-written state file (atomic on POSIX, near-atomic on
+ * Windows — same approach used by `session-checkpoint-service.ts`).
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { getSessionDir } from '../session/getSessionDir.js';
+import { emptyAttempts, isDecisionKey, isState } from './state.js';
+const STATE_FILENAME = '24h-state.json';
+function statePath(projectRoot, sessionId) {
+    return join(getSessionDir(projectRoot, sessionId), STATE_FILENAME);
+}
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function coerceSnapshot(raw) {
+    if (!isPlainObject(raw)) {
+        throw new Error('24H_STATE_INVALID: root must be an object');
+    }
+    if (typeof raw['state'] !== 'string' || !isState(raw['state'])) {
+        throw new Error(`24H_STATE_INVALID: state must be one of IDLE|BRAINSTORM|USER_CONFIRM|24H_ACTIVE|WAITING_USER|HANDOFF (got ${JSON.stringify(raw['state'])})`);
+    }
+    if (typeof raw['enteredAt'] !== 'string') {
+        throw new Error('24H_STATE_INVALID: enteredAt must be an ISO string');
+    }
+    if (raw['enteredFrom'] !== null && (typeof raw['enteredFrom'] !== 'string' || !isState(raw['enteredFrom']))) {
+        throw new Error('24H_STATE_INVALID: enteredFrom must be a State or null');
+    }
+    if (!Array.isArray(raw['activeSlices']) || !raw['activeSlices'].every((s) => typeof s === 'string')) {
+        throw new Error('24H_STATE_INVALID: activeSlices must be string[]');
+    }
+    if (typeof raw['monotonicGuards'] !== 'number' || !Number.isInteger(raw['monotonicGuards'])) {
+        throw new Error('24H_STATE_INVALID: monotonicGuards must be a non-negative integer');
+    }
+    if (typeof raw['autoCompactCount'] !== 'number' || !Number.isInteger(raw['autoCompactCount'])) {
+        throw new Error('24H_STATE_INVALID: autoCompactCount must be a non-negative integer');
+    }
+    if (typeof raw['checkpoints'] !== 'number' || !Number.isInteger(raw['checkpoints'])) {
+        throw new Error('24H_STATE_INVALID: checkpoints must be a non-negative integer');
+    }
+    if (raw['lastCheckpointAt'] !== null && typeof raw['lastCheckpointAt'] !== 'string') {
+        throw new Error('24H_STATE_INVALID: lastCheckpointAt must be ISO string or null');
+    }
+    if (raw['exitCondition'] !== null && typeof raw['exitCondition'] !== 'string') {
+        throw new Error('24H_STATE_INVALID: exitCondition must be string or null');
+    }
+    const rawAttempts = raw['attempts'];
+    if (!isPlainObject(rawAttempts)) {
+        throw new Error('24H_STATE_INVALID: attempts must be an object');
+    }
+    const attempts = emptyAttempts();
+    for (const [k, v] of Object.entries(rawAttempts)) {
+        if (!isDecisionKey(k)) {
+            throw new Error(`24H_STATE_INVALID: attempts has unknown key ${k}`);
+        }
+        if (typeof v !== 'number' || !Number.isInteger(v) || v < 0) {
+            throw new Error(`24H_STATE_INVALID: attempts.${k} must be a non-negative integer`);
+        }
+        attempts[k] = v;
+    }
+    return {
+        state: raw['state'],
+        enteredAt: raw['enteredAt'],
+        enteredFrom: raw['enteredFrom'],
+        activeSlices: raw['activeSlices'],
+        monotonicGuards: raw['monotonicGuards'],
+        autoCompactCount: raw['autoCompactCount'],
+        checkpoints: raw['checkpoints'],
+        lastCheckpointAt: raw['lastCheckpointAt'],
+        attempts,
+        exitCondition: raw['exitCondition']
+    };
+}
+export function emptySnapshot(now = new Date()) {
+    return {
+        state: 'IDLE',
+        enteredAt: now.toISOString(),
+        enteredFrom: null,
+        activeSlices: [],
+        monotonicGuards: 0,
+        autoCompactCount: 0,
+        checkpoints: 0,
+        lastCheckpointAt: null,
+        attempts: emptyAttempts(),
+        exitCondition: null
+    };
+}
+export function read24hState(projectRoot, sessionId) {
+    const path = statePath(projectRoot, sessionId);
+    if (!existsSync(path))
+        return emptySnapshot();
+    const raw = readFileSync(path, 'utf8');
+    return coerceSnapshot(JSON.parse(raw));
+}
+/**
+ * Atomic write: temp file in the same directory, then rename. The
+ * rename is a single syscall on POSIX and a single MoveFile on
+ * Windows — a crash in between leaves the previous valid snapshot
+ * intact. `fsync` on the temp file is omitted (we accept the
+ * same weaker contract that `session-checkpoint-service.ts` uses)
+ * because the state is reconstructible from the B3 attempt log.
+ */
+export function write24hState(projectRoot, sessionId, snapshot) {
+    const path = statePath(projectRoot, sessionId);
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tmp, JSON.stringify(snapshot, null, 2) + '\n', 'utf8');
+    renameSync(tmp, path);
+    return { path };
+}
+export const STATE_STORE_CONSTANTS = {
+    STATE_FILENAME
+};

package/dist/services/artifacts/artifact-prerequisites.js

@@ -1,6 +1,6 @@
 import { join, dirname, basename } from 'node:path';
 import { readFile, readdir } from 'node:fs/promises';
-import { pathExists } from '../../shared/fs.js';
+import { pathExists } from 'peaks-loop-shared/fs';
 import { emitObservabilityEvent } from '../observability/observability-service.js';
 export const VALID_REQUEST_TYPES = [
     'feature',

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

@@ -1,7 +1,7 @@
 import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { isDirectory, listDirectories } from '../../shared/fs.js';
+import { isDirectory, listDirectories } from 'peaks-loop-shared/fs';
 import { checkPrerequisites, DEFAULT_REQUEST_TYPE, isRequestType, VALID_REQUEST_TYPES } from './artifact-prerequisites.js';
 import { ensureSession, getSessionIdCanonical } from '../session/session-manager.js';
 // Slice 2026-06-29-change-id-root-removal: `getCurrentChangeId` was

package/dist/services/artifacts/workspace-service.js

@@ -3,7 +3,7 @@ import { Buffer } from 'node:buffer';
 import { resolve } from 'node:path';
 import { isInsidePath, stablePath } from '../../shared/path-utils.js';
 import { getWorkspaceConfig, getWorkspaceConfigForCurrentPath } from '../config/config-service.js';
-import { pathExists } from '../../shared/fs.js';
+import { pathExists } from 'peaks-loop-shared/fs';
 import { execCommand } from '../../shared/process.js';
 function canonicalPath(path) {
     return stablePath(path);

package/dist/services/audit/enforcers/lint-bee-runtime-contract.d.ts

@@ -0,0 +1,25 @@
+/**
+ * P2-b sweep 008 — peaks-rd / peaks-ui / peaks-txt / peaks-sc
+ * runtime contract enforcer. Closes six discovered lines:
+ *
+ *  - peaks-rd-skill-md-166 : OpenSpec usage (BLOCKING)
+ *  - peaks-rd-skill-md-184 : Frontend project generation (MUST NOT)
+ *  - peaks-sc-skill-md-150 : Transition verification gates (MANDATORY)
+ *  - peaks-txt-skill-md-266 : Memory block embedding rule (MANDATORY)
+ *  - peaks-txt-skill-md-277 : Transition verification gates (MANDATORY)
+ *  - peaks-ui-skill-md-188 : Transition verification gates (MANDATORY)
+ *
+ * The contract is a single enforcer per skill: each skill
+ * declares its own runtime contract markers. The sweep covers
+ * 3 marker classes (OpenSpec, FrontendGen, TransitionGates,
+ * MemoryBlock) by 4 skills (rd, ui, sc, txt).
+ *
+ * scope: each helper scopes to a specific skill via the
+ * `name` field on SkillFile; ui-363 + peaks-rd-58 (skill
+ * presence) are already closed by sweep 003.
+ */
+import type { LintHit, SkillFile } from './lint-style.js';
+export declare function lintRdRuntimeContract(skill: SkillFile): ReadonlyArray<LintHit>;
+export declare function lintUiTransitionGates(skill: SkillFile): ReadonlyArray<LintHit>;
+export declare function lintScTransitionGates(skill: SkillFile): ReadonlyArray<LintHit>;
+export declare function lintTxtRuntimeContract(skill: SkillFile): ReadonlyArray<LintHit>;

package/dist/services/audit/enforcers/lint-bee-runtime-contract.js

@@ -0,0 +1,91 @@
+const OPENSPEC_USAGE = /use openspec when the/i;
+const FRONTEND_PROJECT_GENERATION = /rd work creates a frontend application/i;
+const TRANSITION_GATES = /Transition verification gates/im;
+const MEMORY_BLOCK_EMBEDDING = /memory block embedding rule/i;
+function findContract(lines) {
+    let openspec = false;
+    let frontendGen = false;
+    let transitionGates = false;
+    let memoryBlock = false;
+    for (const line of lines) {
+        if (OPENSPEC_USAGE.test(line))
+            openspec = true;
+        if (FRONTEND_PROJECT_GENERATION.test(line))
+            frontendGen = true;
+        if (TRANSITION_GATES.test(line))
+            transitionGates = true;
+        if (MEMORY_BLOCK_EMBEDDING.test(line))
+            memoryBlock = true;
+    }
+    return { openspec, frontendGen, transitionGates, memoryBlock };
+}
+export function lintRdRuntimeContract(skill) {
+    if (skill.name !== 'peaks-rd')
+        return [];
+    const lines = skill.lines.length > 0 ? skill.lines : skill.body.split(/\r?\n/);
+    const { openspec, frontendGen } = findContract(lines);
+    if (openspec && frontendGen)
+        return [];
+    const missing = [];
+    if (!openspec)
+        missing.push('OpenSpec usage');
+    if (!frontendGen)
+        missing.push('Frontend project generation');
+    return [{
+            catalogId: 'rl-peaks-rd-runtime-contract-001',
+            rule: 'peaks-rd SKILL.md must declare the runtime contract (OpenSpec usage + Frontend project generation)',
+            file: skill.path,
+            line: 1,
+            matchedText: `missing markers: ${missing.join(', ')}`
+        }];
+}
+export function lintUiTransitionGates(skill) {
+    if (skill.name !== 'peaks-ui')
+        return [];
+    const lines = skill.lines.length > 0 ? skill.lines : skill.body.split(/\r?\n/);
+    const { transitionGates } = findContract(lines);
+    if (transitionGates)
+        return [];
+    return [{
+            catalogId: 'rl-peaks-ui-transition-gates-001',
+            rule: 'peaks-ui SKILL.md must declare the Transition verification gates section',
+            file: skill.path,
+            line: 1,
+            matchedText: 'missing "Transition verification gates" heading'
+        }];
+}
+export function lintScTransitionGates(skill) {
+    if (skill.name !== 'peaks-sc')
+        return [];
+    const lines = skill.lines.length > 0 ? skill.lines : skill.body.split(/\r?\n/);
+    const { transitionGates } = findContract(lines);
+    if (transitionGates)
+        return [];
+    return [{
+            catalogId: 'rl-peaks-sc-transition-gates-001',
+            rule: 'peaks-sc SKILL.md must declare the Transition verification gates section',
+            file: skill.path,
+            line: 1,
+            matchedText: 'missing "Transition verification gates" heading'
+        }];
+}
+export function lintTxtRuntimeContract(skill) {
+    if (skill.name !== 'peaks-txt')
+        return [];
+    const lines = skill.lines.length > 0 ? skill.lines : skill.body.split(/\r?\n/);
+    const { transitionGates, memoryBlock } = findContract(lines);
+    if (transitionGates && memoryBlock)
+        return [];
+    const missing = [];
+    if (!transitionGates)
+        missing.push('Transition verification gates');
+    if (!memoryBlock)
+        missing.push('Memory block embedding rule');
+    return [{
+            catalogId: 'rl-peaks-txt-runtime-contract-001',
+            rule: 'peaks-txt SKILL.md must declare the runtime contract (Transition verification gates + Memory block embedding rule)',
+            file: skill.path,
+            line: 1,
+            matchedText: `missing markers: ${missing.join(', ')}`
+        }];
+}

package/dist/services/audit/enforcers/lint-peaks-code-runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * P2-b sweep 009 — peaks-code SKILL.md runtime contract.
+ * Single enforcer closing 13 of the 33 remaining discovered
+ * lines (peaks-code-skill-md-6, 79, 93, 111, 119, 121, 123,
+ * 125, 153, 184, 188, 248).
+ *
+ * The contract is the section-marker skeleton that every
+ * peaks-code SKILL.md must declare. Each heading is one of
+ * the peaks-code runbook's red-line chapters; the enforcer
+ * checks the headings are present and emits a hit on each
+ * missing one.
+ *
+ * scope: peaks-code only.
+ */
+import type { LintHit, SkillFile } from './lint-style.js';
+export declare function lintPeaksCodeRuntimeContract(skill: SkillFile): ReadonlyArray<LintHit>;

package/dist/services/audit/enforcers/lint-peaks-code-runtime.js

@@ -0,0 +1,31 @@
+const REQUIRED_HEADINGS = Object.freeze([
+    { name: 'Scope (rl-8 red line)', pattern: /scope \(rl-8/i },
+    { name: 'No auto-compact prose ban', pattern: /no auto-compact prose ban/i },
+    { name: 'Superpowers 协作边界', pattern: /peaks-loop superpowers 协作边界/i },
+    { name: 'npm-contract boundary', pattern: /npm-contract boundary/i },
+    { name: 'Startup sequence', pattern: /peaks-loop startup sequence/i },
+    { name: 'Step 0.8 job-shape detection', pattern: /step 0\.8.*job-shape detection/i },
+    { name: 'Local intermediate artifact workspace', pattern: /peaks-loop local intermediate artifact workspace/i },
+    { name: 'Pre-rd project scan checklist', pattern: /peaks-loop pre-rd project scan checklist/i },
+    { name: 'Step 11 memory sediment', pattern: /step 11.*memory sediment/i },
+    { name: '--enforce-job-mode (v3.1.2)', pattern: /enforce-job-mode \(v3\.1\.2\)/i }
+]);
+export function lintPeaksCodeRuntimeContract(skill) {
+    if (skill.name !== 'peaks-code')
+        return [];
+    const lines = skill.lines.length > 0 ? skill.lines : skill.body.split(/\r?\n/);
+    const missing = [];
+    for (const h of REQUIRED_HEADINGS) {
+        if (!lines.some((l) => h.pattern.test(l)))
+            missing.push(h.name);
+    }
+    if (missing.length === 0)
+        return [];
+    return [{
+            catalogId: 'rl-peaks-code-runtime-contract-001',
+            rule: 'peaks-code SKILL.md must declare the runbook section markers (Scope, no auto-compact, superpowers bridge, npm-contract, startup sequence, step 0.8 job-shape, local intermediate artifact workspace, pre-rd project scan checklist, step 11 memory sediment, --enforce-job-mode v3.1.2).',
+            file: skill.path,
+            line: 1,
+            matchedText: `missing markers: ${missing.join(', ')}`
+        }];
+}

package/dist/services/audit/enforcers/lint-peaks-skill-runtime.d.ts

@@ -0,0 +1,23 @@
+/**
+ * P2-b sweep 010 — peaks-* runtime contract enforcer (excluding
+ * peaks-code which has its own sweep 009 enforcer; excluding
+ * peaks-prd / peaks-rd / peaks-qa / peaks-ui / peaks-sc / peaks-txt
+ * which have their own per-skill enforcers in earlier sweeps).
+ *
+ * Closes 8 of the remaining 22 discovered lines:
+ *  - peaks-audit-skill-md-52, 70, 125, 133
+ *  - peaks-content-skill-md-141, 235
+ *  - peaks-ide-skill-md-12, 114
+ *
+ * The contract is the section-marker skeleton that every
+ * peaks-* SKILL.md must declare. Single enforcer scopes per
+ * skill via the SkillFile.name field.
+ */
+import type { LintHit, SkillFile } from './lint-style.js';
+export declare const lintPeaksAuditRuntime: (skill: SkillFile) => ReadonlyArray<LintHit>;
+export declare const lintPeaksContentRuntime: (skill: SkillFile) => ReadonlyArray<LintHit>;
+export declare const lintPeaksIdeRuntime: (skill: SkillFile) => ReadonlyArray<LintHit>;
+export declare const lintPeaksDoctorRuntime: (skill: SkillFile) => ReadonlyArray<LintHit>;
+export declare const lintPeaksIssueFixOrchestratorRuntime: (skill: SkillFile) => ReadonlyArray<LintHit>;
+export declare const lintPeaksSopRuntime: (skill: SkillFile) => ReadonlyArray<LintHit>;
+export declare const lintPeaksSliceDecomposeRuntime: (skill: SkillFile) => ReadonlyArray<LintHit>;