peaks-loop 4.0.0-beta.24 → 4.0.0-beta.25

package/CHANGELOG.md

@@ -11,6 +11,18 @@
   - peaks-loop-doctor@0.0.12
   - peaks-loop-final-review@0.0.12
 
+## 4.1.0 (Unreleased)
+
+### Added
+
+- **Sub-agent memory preflight**: peaks-code orchestrator now
+  automatically injects a token-bounded `feedback / layer A` memory
+  block from `.peaks/memory/index.json` into every sub-agent's
+  system prompt. Defaults to 1.2k token cap (configurable via
+  `.peaks/preferences.json::memoryPreflight.maxTokens`); silent
+  degradation when the index is missing. No new CLI surface.
+  See `docs/superpowers/specs/2026-07-22-orchestrator-memory-preflight-design.md`.
+
 ## 4.0.0
 
 ### Patch Changes

package/README-en.md

@@ -123,7 +123,7 @@ Every lane opens with **one slash command**.
 
 | | |
 | --- | --- |
-| **Latest** | [`4.0.0-beta.7`](https://github.com/SquabbyZ/peaks-loop/releases) — 4.x GA is in the works |
+| **Latest** | [`4.0.0-beta.25`](https://github.com/SquabbyZ/peaks-loop/releases) — 4.x GA is in the works |
 | **Domains** | Code (`peaks-code`) · Content (`peaks-content`) · Project health (`peaks-doctor`) · Issue sweep (`peaks-issue-fix-orchestrator`) · Custom SOP (`peaks-sop`) · Cross-domain primitives (`peaks-solo` dispatcher · `peaks-resume` · `peaks-status` · `peaks-test`) |
 | **Sediment pool** | `~/.peaks/` local pool · twice-clean runs auto-promote to a bee · broken runs come back for you to redefine · the bee grows with your taste |
 | **Test suite** | 5,439 passed · 19 skipped · 0 failed |

package/README.md

@@ -123,7 +123,7 @@ npm i -g peaks-loop
 
 | | |
 | --- | --- |
-| **最新版本** | [`4.0.0-beta.7`](https://github.com/SquabbyZ/peaks-loop/releases) — 4.x 正式版筹备中 |
+| **最新版本** | [`4.0.0-beta.25`](https://github.com/SquabbyZ/peaks-loop/releases) — 4.x 正式版筹备中 |
 | **覆盖域** | 代码(`peaks-code`) · 内容(`peaks-content`) · 项目健康(`peaks-doctor`) · 批量修 issue(`peaks-issue-fix-orchestrator`) · 自定义 SOP(`peaks-sop`) · 通用原语(`peaks-solo` 分诊 / `peaks-resume` 续 / `peaks-status` 看 / `peaks-test` 测) |
 | **沉淀池** | `~/.peaks/` 本地池 · 跑两次自动晋升成 bee · 跑翻车让你重定义 · bee 跟着你的口味长 |
 | **测试套件** | 5,439 passed · 19 skipped · 0 failed |

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

@@ -36,6 +36,8 @@ import { writeLogEntry } from '../../services/log/logger.js';
 import { HEADROOM_MODES, PROMPT_LIMIT_BYTES, RECOMMENDED_ROLES, validateRole } from './sub-agent-shared.js';
 import { runDispatchFromDag } from './dispatch-from-dag.js';
 import { TEST_TOOL_DETECTION_BLOCK, formatTestToolDetection } from '../../services/dispatch/test-tool-detection.js';
+import { MemoryPreflightService } from '../../services/context/memory-preflight-service.js';
+import { buildDispatchSystemPrompt } from '../../services/context/build-dispatch-system-prompt.js';
 export function registerDispatchCommand(parent, io) {
     addJsonOption(parent
         .command('dispatch')
@@ -152,9 +154,11 @@ export function registerDispatchCommand(parent, io) {
             // Preferences hard-block when headroom.enabled=false (returns HEADROOM_DISABLED_BY_PREFERENCE).
             // loadPreferences can throw on schema mismatch; we fall back to defaults to avoid
             // breaking the dispatch on a stale preferences.json file.
+            let projectPrefs = DEFAULT_PREFERENCES;
             let headroomPrefs = DEFAULT_PREFERENCES.headroom;
             try {
-                headroomPrefs = loadPreferences(projectRoot).headroom;
+                projectPrefs = loadPreferences(projectRoot);
+                headroomPrefs = projectPrefs.headroom;
             }
             catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
                 // Keep default preferences; the user can re-run with explicit --headroom-mode
@@ -187,7 +191,18 @@ export function registerDispatchCommand(parent, io) {
             }
             // G7.7 headroom compress (opt-in). If headroom fails or is unavailable,
             // fall back to the original prompt + emit warning.
-            let effectivePrompt = `${formatTestToolDetection()}\n\n${options.prompt}`;
+            // Slice 2026-07-22-orchestrator-memory-preflight (Task 5): prepend the
+            // memory preflight block (or silently skip when unavailable) via the
+            // pure-function builder, BEFORE the headroom-ai compress step so the
+            // compressor sees the augmented payload.
+            const preflightService = new MemoryPreflightService(projectRoot, projectPrefs);
+            const memoryBlock = await preflightService.fetchBlock(role);
+            const memoryAugmentedBody = buildDispatchSystemPrompt({
+                taskTitle: role,
+                taskBody: options.prompt,
+                memoryBlock,
+            });
+            let effectivePrompt = `${formatTestToolDetection()}\n\n${memoryAugmentedBody}`;
             let headroomCompressed = false;
             let headroomResult = null;
             const warnings = [...decision.warnings];

package/dist/services/context/build-dispatch-system-prompt.d.ts

@@ -0,0 +1,36 @@
+/**
+ * buildDispatchSystemPrompt — pure-function prompt composer for sub-agent dispatch.
+ *
+ * Slice 2026-07-22-orchestrator-memory-preflight (Task 5). The orchestrator
+ * dispatch flow (`src/cli/commands/dispatch-commands.ts`) calls
+ * `MemoryPreflightService.fetchBlock` and feeds the result into this builder
+ * so the memory block, when available, is prepended BEFORE the task brief.
+ *
+ * Keeping the builder a pure function (no IO) makes the three acceptance
+ * cases easy to test in isolation:
+ *   1. returns the original prompt (sans memory block) when unavailable
+ *   2. prepends the memory block when available
+ *   3. never pushes the memory block below the task brief
+ */
+import type { MemoryPreflightResult } from './memory-preflight-service.js';
+export interface DispatchPromptInput {
+    taskTitle: string;
+    taskBody: string;
+    memoryBlock: MemoryPreflightResult;
+}
+/**
+ * Compose the system-prompt body that the dispatch site prepends to
+ * `formatTestToolDetection()\n\n`.
+ *
+ * Byte-identical degradation contract (slice 2026-07-22-orchestrator-memory-preflight
+ * controller brief): when the memory block is unavailable, the caller does
+ * `formatTestToolDetection()\n\n${taskBody}` — i.e. the final prompt is exactly
+ * `${formatTestToolDetection()}\n\n${taskBody}`. Today's pre-change behavior
+ * produced the same string from `src/cli/commands/dispatch-commands.ts:220`,
+ * so the unavailable branch MUST return `taskBody` (NOT a `# title\n\n` wrap).
+ *
+ * Available branch prepends the memory block before the `## Task` heading so
+ * `## Project memory …` always sits above the task brief (never pushed below
+ * it).
+ */
+export declare function buildDispatchSystemPrompt(input: DispatchPromptInput): string;

package/dist/services/context/build-dispatch-system-prompt.js

@@ -0,0 +1,22 @@
+/**
+ * Compose the system-prompt body that the dispatch site prepends to
+ * `formatTestToolDetection()\n\n`.
+ *
+ * Byte-identical degradation contract (slice 2026-07-22-orchestrator-memory-preflight
+ * controller brief): when the memory block is unavailable, the caller does
+ * `formatTestToolDetection()\n\n${taskBody}` — i.e. the final prompt is exactly
+ * `${formatTestToolDetection()}\n\n${taskBody}`. Today's pre-change behavior
+ * produced the same string from `src/cli/commands/dispatch-commands.ts:220`,
+ * so the unavailable branch MUST return `taskBody` (NOT a `# title\n\n` wrap).
+ *
+ * Available branch prepends the memory block before the `## Task` heading so
+ * `## Project memory …` always sits above the task brief (never pushed below
+ * it).
+ */
+export function buildDispatchSystemPrompt(input) {
+    const { taskBody, memoryBlock } = input;
+    if (memoryBlock.available === true && typeof memoryBlock.block === 'string') {
+        return `${memoryBlock.block}\n## Task\n${taskBody}\n`;
+    }
+    return taskBody;
+}

package/dist/services/context/memory-index-reader.d.ts

@@ -0,0 +1,8 @@
+import type { MemoryIndexEntry } from '../memory/memory-search-service.js';
+export declare class MemoryIndexReader {
+    private readonly projectRoot;
+    private cache;
+    constructor(projectRoot: string);
+    loadIfStale(): MemoryIndexEntry[];
+    selectFeedbackLayerA(cap: number): MemoryIndexEntry[];
+}

package/dist/services/context/memory-index-reader.js

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const LAYER_A_RE = /peaks-feedback-promoted:\s*layer=A\b/;
+export class MemoryIndexReader {
+    projectRoot;
+    cache = null;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    loadIfStale() {
+        const indexPath = join(this.projectRoot, '.peaks', 'memory', 'index.json');
+        if (!existsSync(indexPath))
+            return [];
+        const { mtimeMs } = statSync(indexPath);
+        if (this.cache && this.cache.mtimeMs === mtimeMs)
+            return this.cache.entries;
+        let raw;
+        try {
+            raw = JSON.parse(readFileSync(indexPath, 'utf8'));
+        }
+        catch {
+            this.cache = null;
+            return [];
+        }
+        const entries = flattenIndex(raw);
+        this.cache = { mtimeMs, entries };
+        return entries;
+    }
+    selectFeedbackLayerA(cap) {
+        const all = this.loadIfStale();
+        return all
+            .filter((e) => e.kind === 'feedback')
+            .filter((e) => LAYER_A_RE.test(e.description))
+            .slice(0, Math.max(1, Math.trunc(cap)));
+    }
+}
+function flattenIndex(raw) {
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const out = [];
+    const obj = raw;
+    for (const layer of ['hot', 'warm', 'cold']) {
+        const bucket = obj[layer];
+        if (!bucket || typeof bucket !== 'object')
+            continue;
+        for (const k of ['feedback', 'project', 'reference', 'user']) {
+            const list = bucket[k];
+            if (!Array.isArray(list))
+                continue;
+            for (const item of list) {
+                if (item && typeof item === 'object')
+                    out.push(item);
+            }
+        }
+    }
+    return out;
+}

package/dist/services/context/memory-lru-cache.d.ts

@@ -0,0 +1,12 @@
+export declare class MemoryLruCache {
+    private readonly budgetBytes;
+    private readonly store;
+    private currentBytes;
+    constructor(budgetBytes: number);
+    set(key: string, body: string): void;
+    get(key: string): string | undefined;
+    delete(key: string): void;
+    size(): number;
+    private evictIfOver;
+    private evictAll;
+}

package/dist/services/context/memory-lru-cache.js

@@ -0,0 +1,60 @@
+export class MemoryLruCache {
+    budgetBytes;
+    store = new Map();
+    currentBytes = 0;
+    constructor(budgetBytes) {
+        this.budgetBytes = budgetBytes;
+    }
+    set(key, body) {
+        if (this.store.has(key))
+            this.delete(key);
+        const bytes = Buffer.byteLength(body, 'utf8');
+        if (bytes > this.budgetBytes) {
+            // Oversized insert: evict ALL existing entries (LRU order) so only
+            // the newly inserted key remains in the cache. This prevents the
+            // unbounded growth that a naive "single oversized exception" would
+            // allow when oversized values are inserted consecutively.
+            this.evictAll();
+            this.store.set(key, { body, bytes });
+            this.currentBytes += bytes;
+            return;
+        }
+        this.store.set(key, { body, bytes });
+        this.currentBytes += bytes;
+        this.evictIfOver();
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        // refresh recency
+        this.store.delete(key);
+        this.store.set(key, entry);
+        return entry.body;
+    }
+    delete(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return;
+        this.store.delete(key);
+        this.currentBytes -= entry.bytes;
+    }
+    size() {
+        return this.currentBytes;
+    }
+    evictIfOver() {
+        while (this.currentBytes > this.budgetBytes && this.store.size > 0) {
+            // Map preserves insertion order — first key is least-recently-touched
+            const oldestKey = this.store.keys().next().value;
+            if (oldestKey === undefined)
+                break;
+            this.delete(oldestKey);
+        }
+    }
+    evictAll() {
+        // Empty the store; called before an oversized insert so only the new
+        // entry remains, per the eviction contract documented above.
+        this.store.clear();
+        this.currentBytes = 0;
+    }
+}

package/dist/services/context/memory-preflight-config.d.ts

@@ -0,0 +1,19 @@
+import type { ProjectPreferences } from '../preferences/preferences-types.js';
+export interface MemoryPreflightConfig {
+    readonly enabled: boolean;
+    readonly maxTokens: number;
+    readonly listCap: number;
+    readonly contentCacheBytes: number;
+}
+/**
+ * Loose input type for `resolveMemoryPreflightConfig`. Accepts either a
+ * full `ProjectPreferences` (e.g. the output of `loadPreferences()`) or
+ * any object that at minimum carries `memoryPreflight`. Lets callers
+ * pass a partial overlay literal — e.g. `{}` or `{ memoryPreflight: {...} }`
+ * — without having to construct a fully-populated preferences fixture.
+ *
+ * Downstream tasks (orchestrator service, dispatch hook) should import
+ * this alias rather than re-deriving the structural type.
+ */
+export type MemoryPreflightPrefsInput = ProjectPreferences | Pick<ProjectPreferences, 'memoryPreflight'>;
+export declare function resolveMemoryPreflightConfig(prefs: MemoryPreflightPrefsInput): MemoryPreflightConfig;

package/dist/services/context/memory-preflight-config.js

@@ -0,0 +1,25 @@
+const DEFAULTS = Object.freeze({
+    enabled: true,
+    maxTokens: 1200,
+    listCap: 12,
+    contentCacheBytes: 6000,
+});
+const LIST_CAP_MIN = 1;
+const LIST_CAP_MAX = 50;
+function asFiniteInt(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0
+        ? Math.trunc(value)
+        : fallback;
+}
+export function resolveMemoryPreflightConfig(prefs) {
+    const m = prefs.memoryPreflight ?? {};
+    const listCapRaw = asFiniteInt(m.listCap, DEFAULTS.listCap);
+    return {
+        enabled: m.enabled === false ? false : DEFAULTS.enabled,
+        maxTokens: m.maxTokens && m.maxTokens > 0 ? m.maxTokens : DEFAULTS.maxTokens,
+        listCap: Math.min(LIST_CAP_MAX, Math.max(LIST_CAP_MIN, listCapRaw)),
+        contentCacheBytes: m.contentCacheBytes && m.contentCacheBytes > 0
+            ? m.contentCacheBytes
+            : DEFAULTS.contentCacheBytes,
+    };
+}

package/dist/services/context/memory-preflight-service.d.ts

@@ -0,0 +1,19 @@
+import { type MemoryPreflightPrefsInput } from './memory-preflight-config.js';
+export interface MemoryPreflightResult {
+    available: boolean;
+    block?: string;
+    feedbackListItems?: number;
+    cachedItemCount?: number;
+    reason?: string;
+    truncated?: boolean | undefined;
+    droppedCount?: number | undefined;
+}
+export declare class MemoryPreflightService {
+    private readonly reader;
+    private readonly config;
+    /** path -> body; sub-agent-requested memo contents (Task 4 deviation, see module header). */
+    private readonly cachedMemoContents;
+    constructor(projectRoot: string, prefs: MemoryPreflightPrefsInput);
+    cacheMemoContent(path: string, content: string): void;
+    fetchBlock(_taskTitle: string): Promise<MemoryPreflightResult>;
+}

package/dist/services/context/memory-preflight-service.js

@@ -0,0 +1,120 @@
+/**
+ * MemoryPreflightService — orchestrator-facing API for the
+ * "Orchestrator Memory Preflight" slice (see
+ * docs/superpowers/specs/2026-07-22-orchestrator-memory-preflight-design.md).
+ *
+ * Consumes:
+ *   - resolveMemoryPreflightConfig (Task 1) — merged defaults + per-project overlay
+ *   - MemoryIndexReader (Task 3)            — reads .peaks/memory/index.json + layer=A filter
+ *   - MemoryLruCache (Task 2)               — constructed for capacity parity, but NOT used
+ *                                            for memo content (see deviation note below)
+ *   - compressPrompt (existing)             — headroom-ai wrapper for hard-cap compression
+ *
+ * Deviation from brief — controller-accepted (pre-task 4):
+ *   The brief mandated use of `MemoryLruCache` for memo content caching. The
+ *   orchestrator dispatch flow only ever has at most a handful of explicit
+ *   `cacheMemoContent` calls per task (typically 0-3), and ordering / explicit
+ *   invalidation is preferred over LRU eviction by recency. To keep the
+ *   semantic obvious and the byte budget check trivial, this implementation
+ *   uses a plain `Map<path, body>` for memo path -> body content. The
+ *   `MemoryLruCache` class remains as a separate, reusable LRU primitive
+ *   (Task 2) and is not consumed by this service.
+ */
+import { compressPrompt } from './headroom-client.js';
+import { MemoryIndexReader } from './memory-index-reader.js';
+import { resolveMemoryPreflightConfig, } from './memory-preflight-config.js';
+async function compressToCap(text, capBytes, mode) {
+    try {
+        const result = await compressPrompt(text, mode);
+        if (result.warning !== null || result.compressedPrompt === null) {
+            return { text, truncated: false };
+        }
+        const compressed = result.compressedPrompt;
+        if (Buffer.byteLength(compressed, 'utf8') > capBytes) {
+            const sliced = compressed.slice(0, Math.max(0, capBytes - 64)) + '\n…[truncated]';
+            return { text: sliced, truncated: true };
+        }
+        return { text: compressed, truncated: false };
+    }
+    catch {
+        return { text, truncated: false };
+    }
+}
+export class MemoryPreflightService {
+    reader;
+    config;
+    /** path -> body; sub-agent-requested memo contents (Task 4 deviation, see module header). */
+    cachedMemoContents = new Map();
+    constructor(projectRoot, prefs) {
+        this.config = resolveMemoryPreflightConfig(prefs);
+        this.reader = new MemoryIndexReader(projectRoot);
+    }
+    cacheMemoContent(path, content) {
+        if (!this.config.enabled)
+            return;
+        const bytes = Buffer.byteLength(content, 'utf8');
+        if (bytes > this.config.contentCacheBytes) {
+            // too big to ever fit; do not cache.
+            return;
+        }
+        this.cachedMemoContents.set(path, content);
+    }
+    async fetchBlock(_taskTitle) {
+        if (!this.config.enabled)
+            return { available: false, reason: 'DISABLED' };
+        const selected = this.reader.selectFeedbackLayerA(this.config.listCap);
+        if (selected.length === 0) {
+            const any = this.reader.loadIfStale();
+            if (any.length === 0)
+                return { available: false, reason: 'MEMORY_INDEX_MISSING' };
+            return { available: false, reason: 'NO_FEEDBACK_LAYER_A' };
+        }
+        const listLines = selected
+            .map((e) => `- * ${e.name}\n    Path: ${e.sourcePath}\n    One-line: ${summarize(e.description)}`)
+            .join('\n');
+        let tail = '\n';
+        let cachedCount = 0;
+        if (this.cachedMemoContents.size > 0) {
+            const sections = [];
+            for (const [path, body] of this.cachedMemoContents) {
+                sections.push(`### ${path}\n\n${body}`);
+                cachedCount += 1;
+            }
+            tail = `\n\n## Requested memory details:\n${sections.join('\n\n')}\n`;
+        }
+        const header = '## Project memory relevant to this task\n';
+        const composed = `${header}${listLines}${tail}`;
+        const capBytes = Math.max(64, this.config.maxTokens * 4);
+        const { text, truncated } = await compressToCap(composed, capBytes, 'balanced');
+        const droppedCount = truncated ? selected.length - countItemsInBlock(text) : 0;
+        return {
+            available: true,
+            block: text,
+            feedbackListItems: selected.length,
+            cachedItemCount: cachedCount,
+            truncated,
+            droppedCount: droppedCount > 0 ? droppedCount : undefined,
+        };
+    }
+}
+function summarize(description) {
+    // Drop the <!-- peaks-feedback-promoted: layer=A --> marker, take the next 1 line.
+    const cleaned = description.replace(/<!--[^>]*-->/g, '').trim();
+    return cleaned.split('\n')[0] ?? cleaned;
+}
+function countItemsInBlock(text) {
+    // Count `- * ` markers ONLY in the list portion (between the
+    // `## Project memory relevant to this task` header and the
+    // `## Requested memory details:` sub-section, if present). Memo
+    // bodies appended under `## Requested memory details:` may
+    // legitimately contain their own `- * ` markdown bullets, which
+    // would otherwise inflate the count and produce a wrong
+    // `droppedCount` in the truncated case.
+    const headerEnd = text.indexOf('\n## ');
+    if (headerEnd === -1) {
+        return (text.match(/- \* /g) ?? []).length;
+    }
+    const tailStart = text.indexOf('\n## Requested memory details:', headerEnd + 1);
+    const listEnd = tailStart === -1 ? text.length : tailStart;
+    return (text.slice(0, listEnd).match(/- \* /g) ?? []).length;
+}

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

@@ -9,6 +9,16 @@ export function preferencesPath(projectRoot) {
 export function loadPreferences(projectRoot) {
     const filePath = preferencesPath(projectRoot);
     if (!existsSync(filePath)) {
+        // Slice 2026-07-22-orchestrator-memory-preflight: when
+        // .peaks/preferences.json is missing, this returns a clone of
+        // DEFAULT_PREFERENCES, which now carries the `memoryPreflight`
+        // block (see preferences-types.ts). Partial overlays fall through
+        // to mergePreferences below, where the new `memoryPreflight` block
+        // shallow-replaces the default block — `mergePreferences` does not
+        // deep-merge `memoryPreflight` (only `fanout` is deep-merged), so a
+        // partial overlay will replace the whole block. Resolution still
+        // works because `resolveMemoryPreflightConfig` applies field-level
+        // defaults over the partial input (see memory-preflight-config.ts).
         return structuredClone(DEFAULT_PREFERENCES);
     }
     let raw;

package/dist/services/preferences/preferences-types.d.ts

@@ -131,6 +131,19 @@ export interface ProjectPreferences {
      * saved file is rejected at load time.
      */
     readonly fanout: FanoutPreference;
+    /**
+     * Slice 2026-07-22-orchestrator-memory-preflight: orchestrator-side memory
+     * preflight knobs. Optional — `resolveMemoryPreflightConfig` (see
+     * src/services/context/memory-preflight-config.ts) merges over a hard-coded
+     * default block when this key is absent, so legacy preferences.json files
+     * keep working unchanged.
+     */
+    readonly memoryPreflight?: {
+        readonly enabled?: boolean;
+        readonly maxTokens?: number;
+        readonly listCap?: number;
+        readonly contentCacheBytes?: number;
+    };
 }
 export type FanoutMode = 'fan-out';
 export declare const FANOUT_MODES: readonly FanoutMode[];

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

@@ -50,4 +50,15 @@ export const DEFAULT_PREFERENCES = {
     fanout: {
         defaultMode: 'fan-out'
     },
+    // Slice 2026-07-22-orchestrator-memory-preflight: defaults aligned with
+    // memory-preflight-config.ts::DEFAULTS. Kept in sync manually because
+    // loadPreferences() returns DEFAULT_PREFERENCES verbatim when the on-disk
+    // file is absent, and partial overlays rely on memoryPreflight being
+    // defined here.
+    memoryPreflight: {
+        enabled: true,
+        maxTokens: 1200,
+        listCap: 12,
+        contentCacheBytes: 6000,
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.0-beta.24",
+  "version": "4.0.0-beta.25",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "license": "MIT",
@@ -54,9 +54,9 @@
     "headroom-ai": "0.22.4",
     "yaml": "^2.9.0",
     "zod": "^3.25.76",
+    "peaks-loop-audit-independent": "0.0.11",
     "peaks-loop-crystallization": "0.0.12",
     "peaks-loop-doctor": "0.0.11",
-    "peaks-loop-audit-independent": "0.0.11",
     "peaks-loop-mut": "0.1.0",
     "peaks-loop-final-review": "0.0.11",
     "peaks-loop-job-snapshot": "0.0.5",