peaks-loop 4.0.6 → 4.0.7

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

@@ -38,12 +38,23 @@ function resolveIdeForCommand(options, projectRoot) {
  * the install shape so the JSON envelope doesn't claim a hook the
  * service did not write.
  */
-function listExpectedEntriesForIde(ide, _skipProgress = false) {
+function listExpectedEntriesForIde(ide, options = {}) {
     const adapter = getAdapter(ide);
+    const out = [];
     if (ide === 'trae') {
-        return [{ matcher: adapter.toolMatcher, sentinel: 'peaks hook handle' }];
+        out.push({ matcher: adapter.toolMatcher, sentinel: 'peaks hook handle' });
     }
-    return [{ matcher: adapter.toolMatcher, sentinel: 'peaks gate enforce' }];
+    else {
+        out.push({ matcher: adapter.toolMatcher, sentinel: 'peaks gate enforce' });
+    }
+    // Slice 4.0.7-PR-meta-5: opt-in meta-1 / meta-3 hook entries.
+    if (options.withEditEnforcement === true) {
+        out.push({ matcher: 'Edit|Write|MultiEdit|NotebookEdit', sentinel: 'peaks edit enforcement' });
+    }
+    if (options.withScopeCounter === true) {
+        out.push({ matcher: 'Edit|Write|MultiEdit|NotebookEdit', sentinel: 'peaks scope counter' });
+    }
+    return out;
 }
 /**
  * Slice 2026-07-24-peaks-code-bridge-002-rootcause (G6b / G10): copy the
@@ -104,20 +115,24 @@ export function registerHooksCommands(program, io) {
         .description("Manage the Peaks-managed hook entry in the adapter's settings.json (default: .claude/settings.json for Claude, .trae/settings.json for Trae). Slice #014: the only installed entry is the gate-enforce hook (SOP gate). The legacy progress-start hook (auto-spawn sub-agent progress terminal) is no longer installed — sub-agent progress is now surfaced via the dispatch + heartbeat flow (`peaks sub-agent dispatch` / `peaks sub-agent heartbeat`). The IDE is auto-detected from env / cwd; override with --ide <id>.");
     addJsonOption(hooks
         .command('install')
-        .description(`Install the peaks-managed gate-enforce hook entry into the adapter's settings.json. Slice #014: only the gate-enforce entry is installed; the legacy progress-start entry is no longer installed. Idempotent: re-runs are no-ops. Project scope by default.`)
+        .description(`Install the peaks-managed gate-enforce hook entry into the adapter's settings.json. Slice #014: only the gate-enforce entry is installed by default; the legacy progress-start entry is no longer installed. Idempotent: re-runs are no-ops. Project scope by default. Slice 4.0.7-PR-meta-5: --with-edit-enforcement and --with-scope-counter opt-in flags add the corresponding PreToolUse hook entries (off by default to preserve the existing install behavior).`)
         .option('--global', 'install into the user-level ~/.claude/settings.json instead of the project')
         .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')
         .option('--ide <id>', "target adapter id (claude-code | trae); default: auto-detect from env/cwd")
         .option('--dry-run', 'show what would change without writing')
-        .option('--no-progress', 'skip the progress-start PreToolUse hook entry; install ONLY the gate-enforce entry')).action((options) => {
+        .option('--no-progress', 'skip the progress-start PreToolUse hook entry; install ONLY the gate-enforce entry')
+        .option('--with-edit-enforcement', 'Slice 4.0.7-PR-meta-5: opt-in. Add the Edit-enforcement PreToolUse hook entry (pre-tool-edit-enforcement.sh). Default false to preserve the existing install behavior. Once installed, the hook blocks src/** edits without an RD artifact on disk.')
+        .option('--with-scope-counter', 'Slice 4.0.7-PR-meta-5: opt-in. Add the scope-counter PreToolUse hook entry (pre-tool-scope-counter.sh). Default false. The hook counts cumulative application-source edits and emits a fail-LOUD reflection reminder at thresholds 5, 10, 20.')).action((options) => {
         const scope = resolveScope(options);
         const projectRoot = resolveProjectRoot(scope, options.project);
         const ide = resolveIdeForCommand(options, projectRoot);
         const skipProgress = options.progress === false;
+        const withEditEnforcement = options.withEditEnforcement === true;
+        const withScopeCounter = options.withScopeCounter === true;
         try {
             if (options.dryRun === true) {
                 const plan = planHookInstall(scope, projectRoot, { ide, skipProgress });
-                const dryRunEntries = listExpectedEntriesForIde(ide, skipProgress);
+                const dryRunEntries = listExpectedEntriesForIde(ide, { skipProgress, withEditEnforcement, withScopeCounter });
                 const bridgeCopy = scope === 'global'
                     ? copyBridgeHookIfPresent(process.env.USERPROFILE ?? process.env.HOME ?? '')
                     : { copied: false, source: '', target: '' };
@@ -145,14 +160,16 @@ export function registerHooksCommands(program, io) {
                 ]), options.json);
                 return;
             }
-            const result = applyHookInstall(scope, projectRoot, { ide, skipProgress });
+            const result = applyHookInstall(scope, projectRoot, { ide, skipProgress, withEditEnforcement, withScopeCounter });
             // Slice #3: build the per-IDE entries summary from the actual installed
             // entries, not the slice #1 PEAKS_HOOK_ENTRIES constant (which is the
             // claude-code default). The user's JSON envelope must reflect the IDE
             // they targeted. Slice #014: the install only emits the gate-enforce
             // entry; the summary mirrors the install shape, NOT a hardcoded
-            // expected list.
-            const installedEntries = listExpectedEntriesForIde(ide, skipProgress);
+            // expected list. Slice 4.0.7-PR-meta-5: the summary now also
+            // includes the opt-in Edit-enforcement + scope-counter entries
+            // when the user passed --with-edit-enforcement / --with-scope-counter.
+            const installedEntries = listExpectedEntriesForIde(ide, { skipProgress, withEditEnforcement, withScopeCounter });
             // Slice 2026-07-24-peaks-code-bridge-002-rootcause (G6b / G10): when
             // the install targets global scope, also copy the superpowers-bridge
             // hook script from src/services/hooks/ to the user-global hooks

package/dist/cli/commands/sub-agent-commands.js

@@ -1,4 +1,5 @@
 import { registerDispatchCommand } from './dispatch-commands.js';
+import { registerSubAgentExecCommand } from './sub-agent-exec-command.js';
 import { registerHeartbeatCommand } from './heartbeat-commands.js';
 import { registerShareCommand, registerSharedReadCommand, registerAwaitCommand, registerFinalizeCommand } from './share-commands.js';
 // Re-export `validateRole` for backward compat — the integration test
@@ -12,6 +13,7 @@ export function registerSubAgentCommands(program, io) {
         'These commands are the primitives that peaks-code / peaks-rd / ' +
         'peaks-qa SKILL.md compose. Users do not invoke this directly.');
     registerDispatchCommand(subAgent, io);
+    registerSubAgentExecCommand(subAgent, io); // 4.0.7-PR-meta-6
     registerHeartbeatCommand(subAgent, io);
     registerShareCommand(subAgent, io);
     registerSharedReadCommand(subAgent, io);

package/dist/cli/commands/sub-agent-exec-command.d.ts

@@ -0,0 +1,25 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+/**
+ * Shape of a dispatch record on disk (slice 2026-06-07 +
+ * dispatch-record metadata). We only read the fields `exec` needs
+ * to re-emit the toolCall envelope; everything else (heartbeat,
+ * artifacts, lease, isolation) is preserved by the dispatch record
+ * itself and surfaced in the re-emitted envelope.
+ */
+interface DispatchRecordToolCall {
+    name: string;
+    args: Record<string, unknown>;
+}
+interface DispatchRecord {
+    toolCall?: DispatchRecordToolCall;
+    promptSize?: number;
+    originalPromptSize?: number;
+    batchId?: string;
+    rid?: string;
+    role?: string;
+    sessionId?: string;
+}
+export declare function registerSubAgentExecCommand(parent: Command, io: ProgramIO): void;
+export declare function readDispatchRecordForExec(dispatchRecordPath: string): DispatchRecord;
+export {};

package/dist/cli/commands/sub-agent-exec-command.js

@@ -0,0 +1,132 @@
+/**
+ * `peaks sub-agent exec` — slice 4.0.7-PR-meta-6.
+ *
+ * Companion to `peaks sub-agent dispatch` (slice 2026-06-07). The
+ * dispatch CLI is dry-run by design (per skill-first / CLI-auxiliary
+ * red line PB-4): it returns a `toolCall` envelope that the LLM
+ * extracts args from and re-executes via the Agent tool. The 4.0.7
+ * ice-cola dogfood pass surfaced the friction: the LLM often
+ * skipped the dispatch altogether instead of paying the parse
+ * cost, and routed `Edit` calls directly. PR-meta-4 lowered the
+ * friction by adding `--emit-bash-script`, which prints a
+ * ready-to-exec bash script alongside the JSON envelope. PR-meta-6
+ * ships the actual surface the script invokes: this `exec`
+ * sub-command reads the dispatch record from disk (the same
+ * record the dispatch CLI wrote) and re-emits the canonical
+ * toolCall envelope so the LLM does not have to hand-parse the
+ * JSON to retry a dispatch.
+ *
+ * Architecture (PR-meta-6):
+ *   1. The user (or the LLM via Bash tool) runs the script
+ *      emitted by `peaks sub-agent dispatch --emit-bash-script`.
+ *   2. The script invokes `peaks sub-agent exec --session-id ...
+ *      --request-id ... --role ... --batch-id ... --dispatch-record ...
+ *      --project ...`.
+ *   3. `exec` reads the dispatch record from disk, re-emits the
+ *      same toolCall envelope, and prints a single next-action
+ *      line: "Run this Task tool call to dispatch."
+ *
+ * The dry-run architecture is preserved: the LLM still has the
+ * final say on whether to actually spawn the Task tool. The
+ * script + exec pair is a transparent retry path, not a side-step.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+function failExec(command, message, options, hint) {
+    printResult(undefined, // io is plumbed below
+    fail(command, 'SUB_AGENT_EXEC_FAILED', message, null, [hint]), options.json);
+    // The above `printResult` expects io — the real call site passes
+    // io explicitly. This helper is only used for type-level
+    // documentation; the actual printing is inline in the action.
+    throw new Error(message);
+}
+export function registerSubAgentExecCommand(parent, io) {
+    addJsonOption(parent
+        .command('exec')
+        .description('Slice 4.0.7-PR-meta-6. Re-emit a stored dispatch envelope. Companion to `peaks sub-agent dispatch --emit-bash-script`. Reads the dispatch record from `--dispatch-record` and prints the canonical toolCall envelope so the LLM does not have to hand-parse the JSON to retry. Dry-run: the LLM still owns the actual Agent tool invocation.')
+        .requiredOption('--session-id <sid>', 'session id the dispatch was created in')
+        .requiredOption('--request-id <rid>', 'request id the dispatch was created for')
+        .requiredOption('--role <role>', 'sub-agent role (rd | qa | ui | sc | txt | qa-business | qa-business-api)')
+        .requiredOption('--batch-id <uuid>', 'batch id the dispatch was created in')
+        .requiredOption('--dispatch-record <path>', 'path to the dispatch record JSON (the same file the dispatch CLI wrote under .peaks/_sub_agents/<sid>/)')
+        .requiredOption('--project <path>', 'target project root (echoed back in the envelope; not used to read files)')).action((options) => {
+        if (options.dispatchRecord === undefined || !existsSync(options.dispatchRecord)) {
+            printResult(io, fail('sub-agent.exec', 'DISPATCH_RECORD_MISSING', `Dispatch record not found at ${options.dispatchRecord ?? '(unset)'}`, null, [
+                'Re-run `peaks sub-agent dispatch <role> --prompt <text> --request-id <rid> --json` to create the record.',
+                'Then pass the emitted `dispatchRecordPath` to `peaks sub-agent exec --dispatch-record <path>`.'
+            ]), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        let record;
+        try {
+            record = JSON.parse(readFileSync(options.dispatchRecord, 'utf8'));
+        }
+        catch (err) {
+            printResult(io, fail('sub-agent.exec', 'DISPATCH_RECORD_INVALID', `Failed to parse dispatch record: ${err instanceof Error ? err.message : String(err)}`, { dispatchRecord: options.dispatchRecord }, [
+                'The dispatch record may be truncated. Re-run `peaks sub-agent dispatch` to create a fresh record.'
+            ]), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        if (record.toolCall === undefined) {
+            printResult(io, fail('sub-agent.exec', 'DISPATCH_RECORD_NO_TOOL_CALL', 'Dispatch record has no `toolCall` field. The record may be from a pre-toolCall era; re-run `peaks sub-agent dispatch` to create a fresh record.', { dispatchRecord: options.dispatchRecord }, [
+                'Re-run `peaks sub-agent dispatch` to create a fresh record with a `toolCall` envelope.'
+            ]), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        // Sanity check: the record's sessionId / rid / batchId / role
+        // should match the CLI flags (if the caller passed them). This
+        // is defensive: a mismatch usually means the operator is
+        // running the wrong script. We surface a warning but still
+        // re-emit the envelope (do not block — the dispatch record
+        // is the canonical source of truth).
+        const warnings = [];
+        if (options.sessionId !== undefined && record.sessionId !== undefined && record.sessionId !== options.sessionId) {
+            warnings.push(`session-id mismatch: record=${record.sessionId} vs --session-id=${options.sessionId}; using the record's value as the canonical source.`);
+        }
+        if (options.requestId !== undefined && record.rid !== undefined && record.rid !== options.requestId) {
+            warnings.push(`request-id mismatch: record=${record.rid} vs --request-id=${options.requestId}; using the record's value.`);
+        }
+        if (options.batchId !== undefined && record.batchId !== undefined && record.batchId !== options.batchId) {
+            warnings.push(`batch-id mismatch: record=${record.batchId} vs --batch-id=${options.batchId}; using the record's value.`);
+        }
+        if (options.role !== undefined && record.role !== undefined && record.role !== options.role) {
+            warnings.push(`role mismatch: record=${record.role} vs --role=${options.role}; using the record's value.`);
+        }
+        const nextActions = [
+            'This is a dry-run re-emit. Run the Task tool with the printed `toolCall.args` to actually dispatch the sub-agent.',
+            `After dispatching, the sub-agent should call \`peaks sub-agent heartbeat --record ${options.dispatchRecord}\` periodically.`
+        ];
+        // Re-emit the same envelope shape as `peaks sub-agent dispatch`
+        // so consumers (LLM or downstream tooling) can treat both CLIs
+        // as the same surface. Slice 4.0.7-PR-meta-6: the envelope
+        // version is bumped to 2.4.0 to mark the new `viaExec` field
+        // (true here; false in dispatch CLI output).
+        printResult(io, ok('sub-agent.exec', {
+            envelopeVersion: '2.4.0',
+            viaExec: true,
+            sourceDispatchRecord: options.dispatchRecord,
+            role: record.role ?? options.role,
+            sessionId: record.sessionId ?? options.sessionId,
+            rid: record.rid ?? options.requestId,
+            batchId: record.batchId ?? options.batchId,
+            promptSize: record.promptSize ?? 0,
+            originalPromptSize: record.originalPromptSize ?? 0,
+            toolCall: record.toolCall
+        }, warnings, nextActions), options.json);
+    });
+}
+// Helper export so tests can drive the underlying logic without
+// invoking the action handler. The action handler is the
+// integration path; the helper is the unit path.
+export function readDispatchRecordForExec(dispatchRecordPath) {
+    if (!existsSync(dispatchRecordPath)) {
+        throw new Error(`DISPATCH_RECORD_MISSING: ${dispatchRecordPath}`);
+    }
+    return JSON.parse(readFileSync(dispatchRecordPath, 'utf8'));
+}
+void dirname;

package/dist/cli/commands/sub-agent-shared.d.ts

@@ -40,6 +40,17 @@ export type DispatchOptions = {
      * worktree without needing a separate `peaks worktree auth grant`.
      */
     isolation?: string;
+    /**
+     * Slice 4.0.7-PR-meta-4: when true, the dispatch CLI also emits a
+     * ready-to-exec bash script to stdout (in addition to the JSON
+     * envelope) so the LLM can run the script via the Bash tool
+     * instead of having to parse toolCall args and re-execute them
+     * via the Agent tool. Lowers the dispatch friction documented
+     * in `.peaks/memory/2026-07-28-sub-agent-visibility-issue.md`.
+     * The dry-run architecture is preserved: the script invokes
+     * the canonical `peaks sub-agent exec` surface, not a side-step.
+     */
+    emitBashScript?: boolean;
     json?: boolean;
 };
 export type HeartbeatOptions = {

package/dist/services/audit/backing-detector.d.ts

@@ -5,20 +5,37 @@
  * handle the post-classification nuance: heuristics for the "partial" tier
  * (a gate exists but the LLM can bypass it) and verification that the
  * enforcer file actually exists on disk.
+ *
+ * Slice 4.0.7-dogfood-PR-1 (ice-cola surface probe 2026-08-02): the
+ * `enforcerRef` paths in the catalog are written relative to the
+ * peaks-loop source root (every `enforcerRef` is `src/services/audit/...`
+ * and the catalog itself is at `src/services/audit/red-line-catalog.ts`).
+ * Resolving them against the audited `--project` root produces false
+ * orphans on every downstream project. Fix: resolve against the
+ * peaks-loop install root by default, with an explicit
+ * `peaksLoopRoot` override for tests.
  */
 import type { RedLineEntry } from './types.js';
 export interface BackingResult {
     readonly entry: RedLineEntry;
     readonly enforcerExists: boolean;
 }
+export declare function resolvePeaksLoopRoot(): string;
+/** Test-only: clear the cached peaks-loop root. */
+export declare function _resetPeaksLoopRootCache(): void;
 /**
  * Re-classify a single RedLineEntry. Returns a new entry with the
  * `backing` field updated and `enforcerRef` possibly nulled if the
  * referenced file does not exist on disk.
+ *
+ * `projectRoot` is the audited project (kept for callers that still
+ * pass it for context, but no longer used to resolve `enforcerRef`).
+ * `peaksLoopRoot` is the peaks-loop source root; defaults to
+ * `resolvePeaksLoopRoot()`.
  */
-export declare function classifyBacking(entry: RedLineEntry, projectRoot: string): BackingResult;
+export declare function classifyBacking(entry: RedLineEntry, projectRoot: string, peaksLoopRoot?: string): BackingResult;
 export interface BackingBatchResult {
     readonly entries: readonly RedLineEntry[];
     readonly warnings: readonly string[];
 }
-export declare function classifyBackingBatch(entries: readonly RedLineEntry[], projectRoot: string): BackingBatchResult;
+export declare function classifyBackingBatch(entries: readonly RedLineEntry[], projectRoot: string, peaksLoopRoot?: string): BackingBatchResult;

package/dist/services/audit/backing-detector.js

@@ -5,9 +5,19 @@
  * handle the post-classification nuance: heuristics for the "partial" tier
  * (a gate exists but the LLM can bypass it) and verification that the
  * enforcer file actually exists on disk.
+ *
+ * Slice 4.0.7-dogfood-PR-1 (ice-cola surface probe 2026-08-02): the
+ * `enforcerRef` paths in the catalog are written relative to the
+ * peaks-loop source root (every `enforcerRef` is `src/services/audit/...`
+ * and the catalog itself is at `src/services/audit/red-line-catalog.ts`).
+ * Resolving them against the audited `--project` root produces false
+ * orphans on every downstream project. Fix: resolve against the
+ * peaks-loop install root by default, with an explicit
+ * `peaksLoopRoot` override for tests.
  */
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 const PARTIAL_PHRASES = [
     'if llm cooperates',
     'llm-cooperation',
@@ -21,33 +31,82 @@ function detectPartial(context) {
     const lower = context.toLowerCase();
     return PARTIAL_PHRASES.some((phrase) => lower.includes(phrase));
 }
+/**
+ * Resolve the peaks-loop source root (where the catalog itself lives).
+ * Walks upward from this very file until a `package.json` with
+ * `name === 'peaks-loop'` is found. Cached after the first call.
+ * Exported so tests can reset the cache between cases.
+ */
+let cachedPeaksLoopRoot = null;
+export function resolvePeaksLoopRoot() {
+    if (cachedPeaksLoopRoot !== null)
+        return cachedPeaksLoopRoot;
+    // This file lives at <root>/src/services/audit/backing-detector.ts.
+    // Walk up to find peaks-loop's package.json.
+    const here = dirname(fileURLToPath(import.meta.url));
+    let dir = here;
+    for (let i = 0; i < 8; i++) {
+        const candidate = resolve(dir, 'package.json');
+        if (existsSync(candidate)) {
+            try {
+                const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (pkg.name === 'peaks-loop') {
+                    cachedPeaksLoopRoot = dir;
+                    return dir;
+                }
+            }
+            catch {
+                // malformed package.json; keep walking up
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Fallback: assume 4 levels up from this file (catalog + enforcers
+    // share the same depth). Keeps the unit test that constructs a fake
+    // projectRoot working when no real package.json is in the walk.
+    cachedPeaksLoopRoot = resolve(here, '..', '..', '..', '..');
+    return cachedPeaksLoopRoot;
+}
+/** Test-only: clear the cached peaks-loop root. */
+export function _resetPeaksLoopRootCache() {
+    cachedPeaksLoopRoot = null;
+}
 /**
  * Re-classify a single RedLineEntry. Returns a new entry with the
  * `backing` field updated and `enforcerRef` possibly nulled if the
  * referenced file does not exist on disk.
+ *
+ * `projectRoot` is the audited project (kept for callers that still
+ * pass it for context, but no longer used to resolve `enforcerRef`).
+ * `peaksLoopRoot` is the peaks-loop source root; defaults to
+ * `resolvePeaksLoopRoot()`.
  */
-export function classifyBacking(entry, projectRoot) {
+export function classifyBacking(entry, projectRoot, peaksLoopRoot = resolvePeaksLoopRoot()) {
+    void projectRoot; // intentionally unused; preserved for API stability
     if (detectPartial(entry.source.context)) {
         return {
             entry: { ...entry, backing: 'partial' },
-            enforcerExists: entry.enforcerRef !== null && existsSync(resolve(projectRoot, entry.enforcerRef)),
+            enforcerExists: entry.enforcerRef !== null && existsSync(resolve(peaksLoopRoot, entry.enforcerRef)),
         };
     }
     if (entry.enforcerRef === null) {
         return { entry, enforcerExists: false };
     }
-    const enforcerPath = resolve(projectRoot, entry.enforcerRef);
+    const enforcerPath = resolve(peaksLoopRoot, entry.enforcerRef);
     const exists = existsSync(enforcerPath);
     return {
         entry: { ...entry, backing: exists ? 'cli-backed' : 'prose-only' },
         enforcerExists: exists,
     };
 }
-export function classifyBackingBatch(entries, projectRoot) {
+export function classifyBackingBatch(entries, projectRoot, peaksLoopRoot = resolvePeaksLoopRoot()) {
     const updated = [];
     const warnings = [];
     for (const entry of entries) {
-        const { entry: reclassified, enforcerExists } = classifyBacking(entry, projectRoot);
+        const { entry: reclassified, enforcerExists } = classifyBacking(entry, projectRoot, peaksLoopRoot);
         updated.push(reclassified);
         if (reclassified.backing === 'cli-backed' && !enforcerExists) {
             // Defensive: should not happen because classifyBacking downgrades to

package/dist/services/audit/enforcers/lint-audit-regression.js

@@ -15,6 +15,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { RED_LINE_CATALOG } from '../red-line-catalog.js';
+import { resolvePeaksLoopRoot } from '../backing-detector.js';
 export const CATALOG_STABILITY_GROWTH_CAP = 0.20;
 export const CATALOG_STABILITY_WINDOW_DAYS = 90;
 export const RUNTIME_BUDGET_MS = 2000;
@@ -41,11 +42,19 @@ export function lintCatalogStability(input) {
     return [syntheticHit('rl-audit-catalog-stability-001', 'catalog size has not grown > 20% in the last 90 days', `(growth ${(growth * 100).toFixed(1)}% over 90 days; currentSize=${input.currentSize}, priorSize=${input.sizeNinetyDaysAgo})`)];
 }
 export function lintNoOrphanEnforcer(projectRoot) {
+    // Slice 4.0.7-dogfood-PR-1: catalog enforcerRef paths are written
+    // relative to the peaks-loop source root (catalog + enforcers both
+    // live at <root>/src/services/audit/...). Resolving against the
+    // audited --project root produces false orphans on every downstream
+    // project. Use resolvePeaksLoopRoot() and keep `projectRoot` for
+    // test/legacy callers (the parameter is intentionally ignored here).
+    void projectRoot;
+    const peaksLoopRoot = resolvePeaksLoopRoot();
     const hits = [];
     for (const entry of RED_LINE_CATALOG) {
         if (!entry.enforcerRef)
             continue;
-        const absPath = join(projectRoot, entry.enforcerRef);
+        const absPath = join(peaksLoopRoot, entry.enforcerRef);
         if (!existsSync(absPath)) {
             hits.push(syntheticHit('rl-audit-no-orphan-enforcer-001', 'every enforcerRef points to a real file', `(enforcerRef "${entry.enforcerRef}" for ${entry.id} does not exist on disk)`));
         }

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

@@ -123,6 +123,24 @@ function renderContextBlock(probe) {
     if (probe !== null && probe !== undefined) {
         const usedPct = (probe.ratio * 100).toFixed(1);
         const freePct = ((1 - probe.ratio) * 100).toFixed(1);
+        // Slice 4.0.7-dogfood-PR-11 (ice-cola surface probe 2026-08-02):
+        // when the source is conservative-fallback, the ratio is
+        // hard-coded to 0 (no signal available). The pre-rid prompt
+        // rendered "0.0% used (100.0% free)" without flagging that
+        // this is a fallback, so the sub-agent thought it had 100%
+        // free and never re-checked. The fix short-circuits to the
+        // "no probe available" message when the source is not one of
+        // the trusted values emitted by peaks-loop's own readers.
+        const KNOWN_SOURCES = new Set(['token-counted', 'transcript-estimate', 'statusline']);
+        if (!KNOWN_SOURCES.has(probe.source)) {
+            return `## Context window (no probe available)
+
+The orchestrator captured a probe with source: \`${probe.source}\` (ratio ${usedPct}%) but the dispatch layer does not trust this source. The pre-rid dispatch prompt rendered this as "0.0% used (100.0% free)" without flagging the fallback, which caused sub-agents to think they had 100% free and never re-check. **Treat the displayed ratio as unverified.**
+
+If you need to evaluate context pressure, run \`peaks code context-now --project <root>\` and trust its \`ratio\` field. Do not estimate from message length.
+
+`;
+        }
         const action = probe.ratio >= 0.95
             ? 'RED-LINE — call `peaks compact auto --execute` immediately.'
             : probe.ratio >= 0.85

package/dist/services/dispatch/test-tool-detection.d.ts

@@ -34,6 +34,20 @@ export declare const TEST_TOOL_DETECTION_BLOCK = "## Test Tool Detection (mandat
  * (e.g. projectRoot for context) without churning every call site.
  */
 export declare function formatTestToolDetection(): string;
+/**
+ * Slice 4.0.7-dogfood-PR-9: optional monorepo block prepended when
+ * `<projectRoot>/pnpm-workspace.yaml` exists. The pre-rid static
+ * template did not mention monorepos at all, so sub-agents on a
+ * monorepo project (e.g. ice-cola, 4 packages) ran `pnpm test` which
+ * fanned out to every sub-package — a 36-minute wall clock for what
+ * was a single-slice change. The block tells the sub-agent to scope
+ * to a single sub-package via `pnpm -r --filter @scope/name test`
+ * and to detect the layout via `peaks test --json` first.
+ *
+ * The block is empty when the project is not a monorepo, so the
+ * single-package case is byte-identical to the pre-rid prompt.
+ */
+export declare const MONOREPO_TEST_TOOL_BLOCK = "## Monorepo Test Tool Detection (only when pnpm-workspace.yaml exists)\n\nWhen `<projectRoot>/pnpm-workspace.yaml` is present, the project is a pnpm monorepo. The root `package.json#scripts.test` is typically `pnpm -r test` (recursive across all packages) and `pnpm test` from the root will fan out to every sub-package. **Do not run that.** Scope to a single sub-package:\n\n- detect the active sub-package by looking for `packages/<name>/package.json` (or via `pnpm -r --filter ${YOUR_PACKAGE_NAME} test`)\n- run `pnpm --filter @<scope>/<name> test <pattern>` for one sub-package only\n- if a top-level test script is genuinely needed across multiple packages, prefix with `PEAKS_FULL_TEST=1` AND justify in the final report\n\nA repo without `pnpm-workspace.yaml` has no monorepo block; the pre-rid static template applies unchanged.";
 /**
  * Slice 2026-07-29-dispatch-stall-governance / S5 (AC-4.1 / AC-4.2) —
  * pure scope classifier. Returns a typed result so callers (the

package/dist/services/dispatch/test-tool-detection.js

@@ -54,6 +54,28 @@ If unsure which framework the consumer project uses, run \`peaks test --json\` f
 export function formatTestToolDetection() {
     return TEST_TOOL_DETECTION_BLOCK;
 }
+/**
+ * Slice 4.0.7-dogfood-PR-9: optional monorepo block prepended when
+ * `<projectRoot>/pnpm-workspace.yaml` exists. The pre-rid static
+ * template did not mention monorepos at all, so sub-agents on a
+ * monorepo project (e.g. ice-cola, 4 packages) ran `pnpm test` which
+ * fanned out to every sub-package — a 36-minute wall clock for what
+ * was a single-slice change. The block tells the sub-agent to scope
+ * to a single sub-package via `pnpm -r --filter @scope/name test`
+ * and to detect the layout via `peaks test --json` first.
+ *
+ * The block is empty when the project is not a monorepo, so the
+ * single-package case is byte-identical to the pre-rid prompt.
+ */
+export const MONOREPO_TEST_TOOL_BLOCK = `## Monorepo Test Tool Detection (only when pnpm-workspace.yaml exists)
+
+When \`<projectRoot>/pnpm-workspace.yaml\` is present, the project is a pnpm monorepo. The root \`package.json#scripts.test\` is typically \`pnpm -r test\` (recursive across all packages) and \`pnpm test\` from the root will fan out to every sub-package. **Do not run that.** Scope to a single sub-package:
+
+- detect the active sub-package by looking for \`packages/<name>/package.json\` (or via \`pnpm -r --filter \${YOUR_PACKAGE_NAME} test\`)
+- run \`pnpm --filter @<scope>/<name> test <pattern>\` for one sub-package only
+- if a top-level test script is genuinely needed across multiple packages, prefix with \`PEAKS_FULL_TEST=1\` AND justify in the final report
+
+A repo without \`pnpm-workspace.yaml\` has no monorepo block; the pre-rid static template applies unchanged.`;
 export function classifyTestCommand(command, env = process.env) {
     if (typeof command !== 'string') {
         return {

package/dist/services/scan/archetype-service.js

@@ -44,6 +44,46 @@ async function readPackageJsonDeps(projectRoot) {
         return { exists: true, deps: {} };
     }
 }
+/**
+ * Slice 4.0.7-dogfood-PR-8: walk packages/[name]/package.json one
+ * level deep and merge each sub-package's deps into a single map
+ * (later sub-packages win on key collision; this is the conservative
+ * "first detected framework" behavior). Returns empty when the
+ * project is not a monorepo or has no packages dir. Deliberately
+ * does NOT recurse into nested workspaces.
+ */
+async function readMonorepoSubPackageDeps(projectRoot) {
+    const packagesDir = join(projectRoot, 'packages');
+    if (!(await pathExists(packagesDir)))
+        return {};
+    let entries;
+    try {
+        entries = await readdir(packagesDir);
+    }
+    catch {
+        return {};
+    }
+    const merged = {};
+    for (const entry of entries) {
+        if (entry === '.' || entry === '..')
+            continue;
+        const subPkgPath = join(packagesDir, entry, 'package.json');
+        if (!(await pathExists(subPkgPath)))
+            continue;
+        try {
+            const raw = await readText(subPkgPath);
+            const parsed = JSON.parse(raw);
+            Object.assign(merged, parsed.dependencies ?? {});
+            Object.assign(merged, parsed.devDependencies ?? {});
+            Object.assign(merged, parsed.peerDependencies ?? {});
+            Object.assign(merged, parsed.optionalDependencies ?? {});
+        }
+        catch {
+            // skip malformed sub-package; keep walking
+        }
+    }
+    return merged;
+}
 async function detectBackendFrameworks(deps) {
     return BACKEND_DEP_NAMES.filter((name) => name !== 'next' && Object.prototype.hasOwnProperty.call(deps, name));
 }
@@ -226,8 +266,18 @@ function decideFrontendOnly(report) {
 export async function scanArchetype(options) {
     const { projectRoot } = options;
     const { exists: hasPackageJson, deps } = await readPackageJsonDeps(projectRoot);
-    const backendFrameworks = await detectBackendFrameworks(deps);
-    const hasNext = Object.prototype.hasOwnProperty.call(deps, 'next');
+    // Slice 4.0.7-dogfood-PR-8 (ice-cola surface probe 2026-08-02): a
+    // monorepo root often carries only a thin workspace manifest (no
+    // framework deps). Ice-cola root has peaks-loop only, and the
+    // @nestjs/core dep lives in packages[server].package.json. Pre-rid
+    // this reported `hasBackendFramework: false` for a NestJS monorepo
+    // because the dep scan only looked at the root. The fix adds a
+    // 1-level-deep walk into the packages dir and merges each
+    // sub-package's deps into the dedup result.
+    const monorepoSubDeps = await readMonorepoSubPackageDeps(projectRoot);
+    const mergedDeps = { ...deps, ...monorepoSubDeps };
+    const backendFrameworks = await detectBackendFrameworks(mergedDeps);
+    const hasNext = Object.prototype.hasOwnProperty.call(mergedDeps, 'next');
     const hasNextApiRoutes = await detectNextApiRoutes(projectRoot, hasNext);
     const backendDirsPresent = await detectBackendDirs(projectRoot);
     const swaggerPaths = await detectSwagger(projectRoot);

package/dist/services/session/index.d.ts

@@ -1,4 +1,4 @@
-export { ensureSession, getSessionId, getCurrentSessionDir, listSessions, getSessionMeta, setSessionMeta, setSessionTitle, listSessionMetas, getProjectScanPath, hasProjectScan, setCurrentSessionBinding, rotateSessionBinding, type SessionInfo, type SessionMeta } from './session-manager.js';
+export { ensureSession, getSessionId, getSessionIdCanonical, resolveActiveSessionId, getCurrentSessionDir, listSessions, getSessionMeta, setSessionMeta, setSessionTitle, listSessionMetas, getProjectScanPath, hasProjectScan, setCurrentSessionBinding, rotateSessionBinding, type SessionInfo, type SessionMeta } from './session-manager.js';
 export { getSessionDir } from './getSessionDir.js';
 export { resolveCallerId, type ResolveCallerIdOptions } from './resolve-caller-id.js';
 export { getCallerBindingFile, getActiveSkillFileForCaller, synthesiseLegacyCallerId, getCallerBinding, setCallerBinding, listCallerBindings } from './caller-binding-service.js';

package/dist/services/session/index.js

@@ -1,4 +1,4 @@
-export { ensureSession, getSessionId, getCurrentSessionDir, listSessions, getSessionMeta, setSessionMeta, setSessionTitle, listSessionMetas, getProjectScanPath, hasProjectScan, setCurrentSessionBinding, rotateSessionBinding } from './session-manager.js';
+export { ensureSession, getSessionId, getSessionIdCanonical, resolveActiveSessionId, getCurrentSessionDir, listSessions, getSessionMeta, setSessionMeta, setSessionTitle, listSessionMetas, getProjectScanPath, hasProjectScan, setCurrentSessionBinding, rotateSessionBinding } from './session-manager.js';
 export { getSessionDir } from './getSessionDir.js';
 // Slice 020 — caller-keyed session binding. The new canonical path.
 export { resolveCallerId } from './resolve-caller-id.js';