peaks-loop 4.0.32 → 4.0.34

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

@@ -185,11 +185,11 @@ export function buildOrchestratorCanDoResult(input, signals) {
     // Q4 — context ratio gate. ≥0.95 → red-line; ≥0.85 → pre-compact.
     if (signals.q4ContextRatio >= ORCHESTRATOR_REDLINE_RATIO) {
         blockers.push(`context red-line (ratio=${signals.q4ContextRatio.toFixed(2)} ≥ ${ORCHESTRATOR_REDLINE_RATIO}); auto-compact now or push to next session`);
-        suggestions.push('peaks compact auto --execute');
+        suggestions.push('peaks code auto-compact');
     }
     else if (signals.q4ContextRatio >= ORCHESTRATOR_PRECOMPACT_RATIO) {
         blockers.push(`context near limit (ratio=${signals.q4ContextRatio.toFixed(2)} ≥ ${ORCHESTRATOR_PRECOMPACT_RATIO}); auto-compact or push to next session`);
-        suggestions.push('peaks compact auto --execute');
+        suggestions.push('peaks code auto-compact');
     }
     // Q3 — user-decision keywords → soft warning, NOT a blocker. The
     // LLM should AskUserQuestion, which is cheap.

package/dist/services/code-review/ecc-bridge.d.ts

@@ -31,7 +31,7 @@
  * === Source: peaks-rd/references/parallel-review-fanout.md ===
  *
  * Sub-agent 1 contract (Tier 7 v2.11.0): the parent RD loop calls
- * `Agent({ subagent_type: 'everything-claude-code:code-review', ... })`
+ * `Agent({ subagent_type: 'ecc:code-reviewer', ... })`
  * with the diff + handoff in scope, receives the structured envelope,
  * then runs `adaptEccEnvelopeToRdCodeReview(env, { rid, generatedAt })`
  * and writes the resulting body to
@@ -51,18 +51,43 @@ export interface EccEnvelope {
     readonly gateAction: EccGateAction;
 }
 /**
- * 5-state ECC detection result:
+ * The real upstream ECC agent name for the code-review role:
+ * `~/.peaks/agents/ecc/code-reviewer.md`. Upstream ships `<lang>-reviewer`
+ * agents and has NO `code-review.md`, so this is the default the
+ * `ready-via-cache` nextActions name when the caller does not pass the
+ * output of `resolveMaterializedAgentName(['code-reviewer', 'code-review'])`.
+ */
+export declare const DEFAULT_CACHE_ECC_AGENT_NAME = "code-reviewer";
+/**
+ * The native (plugin) ECC agent id dispatched through the Agent tool.
+ * Verified upstream: the plugin is named `ecc` (`.claude-plugin/plugin.json`,
+ * `marketplace.json`) and the agent's frontmatter `name` is `code-reviewer`
+ * (`~/.peaks/agents/ecc/code-reviewer.md`), so the composed id is
+ * `ecc:code-reviewer`. The previous id composed the OLD repo name
+ * (`everything-claude-code`) with a non-existent `code-review` agent, so it
+ * matched no registry entry and the native path silently fell through to
+ * inline review.
+ */
+export declare const DEFAULT_NATIVE_ECC_AGENT_ID = "ecc:code-reviewer";
+/**
+ * 6-state ECC detection result:
  *   - `ready`               — ECC plugin is installed and reachable
- *   - `plugin-missing`      — `everything-claude-code` not in skill list
- *   - `agent-missing`       — plugin present but `code-review` agent absent
+ *   - `ready-via-cache`     — plugin/agent absent, but the materialized ECC
+ *                             review agent (real name `code-reviewer`, NOT
+ *                             `code-review`) exists under `~/.peaks/agents/ecc/`;
+ *                             dispatch a GENERIC sub-agent with that body
+ *   - `plugin-missing`      — `everything-claude-code` not in skill list and no materialized cache
+ *   - `agent-missing`       — plugin present but `code-review` agent absent and no materialized cache
  *   - `dispatch-failed`     — Agent tool call threw before returning envelope
  *   - `envelope-malformed`  — returned value failed `isEccEnvelope` validation
  *
- * The caller (peaks-rd's sub-agent 1 contract) inspects `state` and
- * either proceeds with the envelope or records a degradation note in
- * the request artifact body (`code-review-ecc-degraded-to-inline`).
+ * Fallback order (RD fan-out, 2026-09-09-ecc-dynamic): native plugin →
+ * cache-backed generic agent → inline. The caller (peaks-rd's sub-agent 1
+ * contract) inspects `state` and either proceeds with the envelope or records
+ * a degradation note in the request artifact body
+ * (`code-review-ecc-degraded-to-inline`).
  */
-export type EccDetectState = 'ready' | 'plugin-missing' | 'agent-missing' | 'dispatch-failed' | 'envelope-malformed';
+export type EccDetectState = 'ready' | 'ready-via-cache' | 'plugin-missing' | 'agent-missing' | 'dispatch-failed' | 'envelope-malformed';
 export interface EccDetectResult {
     readonly state: EccDetectState;
     readonly pluginInstalled: boolean;
@@ -105,39 +130,93 @@ export declare function adaptEccEnvelopeToRdCodeReview(env: EccEnvelope, opts: {
     generatedAt: string;
 }): RdCodeReviewDoc;
 /**
- * 5-state detector — mirrors `detectOcr`'s shape (state enum + warnings
+ * 6-state detector — mirrors `detectOcr`'s shape (state enum + warnings
  * + nextActions). The caller passes in the result of its own probe:
  *
  * - `pluginInstalled`: did the skill list scan find `everything-claude-code`?
  * - `agentAvailable`: did the Agent tool say `code-review` is registered?
+ * - `cacheAgentAvailable`: does the resolved materialized agent exist
+ *   (`~/.peaks/agents/ecc/<cacheAgentName>.md`, default `code-reviewer`)?
  * - `dispatchError`: optional — the Agent tool threw before returning.
  * - `envelope`: optional — what came back (if anything).
  *
- * The detector never blocks: when state !== `ready`, the parent RD
- * loop records a `code-review-ecc-degraded-to-inline` note and falls
- * back to inline review. This matches `detectOcr`'s soft-fail policy.
+ * The detector never blocks: when the state is not dispatchable
+ * (`ready` / `ready-via-cache`), the parent RD loop records a
+ * `code-review-ecc-degraded-to-inline` note and falls back to inline
+ * review. This matches `detectOcr`'s soft-fail policy.
+ *
+ * Backward compat: the native id is `DEFAULT_NATIVE_ECC_AGENT_ID`
+ * (`ecc:code-reviewer` — plugin `ecc`, agent `code-reviewer`). A registry
+ * that still exposes the OLD `everything-claude-code` plugin id will not
+ * match it, so the operator should pin the id explicitly. peaks-loop
+ * cannot enumerate the user's plugin registry: detection stays
+ * caller-supplied (`pluginInstalled` / `agentAvailable`), never probed here.
  */
 export declare function detectEcc(input: {
     readonly pluginInstalled: boolean;
     readonly agentAvailable: boolean;
+    /**
+     * Did the caller find the materialized review agent (written by
+     * `peaks ecc install` / `materializeEccAgents`) under `~/.peaks/agents/ecc/`?
+     * When true and the native plugin path is unavailable, `state` becomes
+     * `ready-via-cache` so the RD loop can dispatch a generic sub-agent with
+     * the materialized body.
+     */
+    readonly cacheAgentAvailable?: boolean;
+    /**
+     * Resolved materialized agent name — pass
+     * `resolveMaterializedAgentName(['code-reviewer', 'code-review'])` from
+     * `peaks-loop-mut`. Defaults to `code-reviewer` (the real upstream name);
+     * upstream has no `code-review.md`.
+     */
+    readonly cacheAgentName?: string;
     readonly dispatchError?: unknown;
     readonly envelope?: unknown;
 }): EccDetectResult;
 /**
  * Convenience: run `detectEcc` and `adaptEccEnvelopeToRdCodeReview`
  * in one call. The parent RD loop calls this after the Agent tool
- * returns. When `detectEcc` returns state !== 'ready', the caller
- * should NOT call `adaptEccEnvelopeToRdCodeReview` — fall back to
- * inline review instead.
+ * returns. When `detectEcc` returns a non-dispatchable state
+ * (`plugin-missing` / `agent-missing` / `dispatch-failed` /
+ * `envelope-malformed`), the caller should NOT call
+ * `adaptEccEnvelopeToRdCodeReview` — fall back to inline review instead.
+ *
+ * Both `ready` (native plugin) and `ready-via-cache` (materialized generic
+ * agent) adapt the envelope through the SAME bridge.
  */
 export declare function runEccCodeReview(input: {
     readonly rid: string;
     readonly generatedAt: string;
     readonly pluginInstalled: boolean;
     readonly agentAvailable: boolean;
+    readonly cacheAgentAvailable?: boolean;
+    /** Resolved materialized agent name (see `detectEcc`); defaults to `code-reviewer`. */
+    readonly cacheAgentName?: string;
     readonly dispatchError?: unknown;
     readonly envelope?: unknown;
 }): {
     detect: EccDetectResult;
     doc: RdCodeReviewDoc | null;
 };
+/**
+ * The exact JSON shape the generic (cache-backed) sub-agent MUST return.
+ * Kept as a const so the RD reference docs and the prompt builder cannot
+ * drift: `isEccEnvelope` is the authoritative validator.
+ */
+export declare const ECC_OUTPUT_CONTRACT: string;
+/**
+ * Compose the plugin-free dispatch prompt for sub-agent 1.
+ *
+ * `instructions` is the body of the materialized review agent
+ * (`~/.peaks/agents/ecc/code-reviewer.md` — resolve the real name with
+ * `resolveMaterializedAgentName`, never hardcode `code-review.md`);
+ * `diff` is the slice diff. The
+ * composed prompt is handed to a GENERIC sub-agent (no ECC plugin needed)
+ * and its reply is validated with `isEccEnvelope`, then rendered by
+ * `adaptEccEnvelopeToRdCodeReview` — the same bridge the native path uses.
+ */
+export declare function buildCacheBackedEccPrompt(input: {
+    readonly rid: string;
+    readonly instructions: string;
+    readonly diff: string;
+}): string;

package/dist/services/code-review/ecc-bridge.js

@@ -1,3 +1,27 @@
+/**
+ * The real upstream ECC agent name for the code-review role:
+ * `~/.peaks/agents/ecc/code-reviewer.md`. Upstream ships `<lang>-reviewer`
+ * agents and has NO `code-review.md`, so this is the default the
+ * `ready-via-cache` nextActions name when the caller does not pass the
+ * output of `resolveMaterializedAgentName(['code-reviewer', 'code-review'])`.
+ */
+export const DEFAULT_CACHE_ECC_AGENT_NAME = 'code-reviewer';
+/**
+ * The native (plugin) ECC agent id dispatched through the Agent tool.
+ * Verified upstream: the plugin is named `ecc` (`.claude-plugin/plugin.json`,
+ * `marketplace.json`) and the agent's frontmatter `name` is `code-reviewer`
+ * (`~/.peaks/agents/ecc/code-reviewer.md`), so the composed id is
+ * `ecc:code-reviewer`. The previous id composed the OLD repo name
+ * (`everything-claude-code`) with a non-existent `code-review` agent, so it
+ * matched no registry entry and the native path silently fell through to
+ * inline review.
+ */
+export const DEFAULT_NATIVE_ECC_AGENT_ID = 'ecc:code-reviewer';
+/** Materialized path hint for the cache-backed agent, e.g. `~/.peaks/agents/ecc/code-reviewer.md`. */
+function materializedAgentPath(name) {
+    const resolved = name !== undefined && name.length > 0 ? name : DEFAULT_CACHE_ECC_AGENT_NAME;
+    return `~/.peaks/agents/ecc/${resolved}.md`;
+}
 /**
  * Validate a raw value as an EccEnvelope. Accepts the strict shape
  * only — extra fields are tolerated (forward-compat for ECC adding
@@ -82,7 +106,7 @@ export function adaptEccEnvelopeToRdCodeReview(env, opts) {
         `## Summary`,
         '',
         `- generatedAt: ${opts.generatedAt}`,
-        `- source: everything-claude-code:code-review (Tier 7 bridge)`,
+        `- source: ${DEFAULT_NATIVE_ECC_AGENT_ID} (Tier 7 bridge)`,
         `- gateAction: ${env.gateAction}`,
         `- passed: ${env.passed}`,
         `- violations: ${env.violations.length}`,
@@ -146,43 +170,87 @@ function renderFindings(violations) {
     return ['## Findings', '', ...bullets, ''].join('\n');
 }
 /**
- * 5-state detector — mirrors `detectOcr`'s shape (state enum + warnings
+ * 6-state detector — mirrors `detectOcr`'s shape (state enum + warnings
  * + nextActions). The caller passes in the result of its own probe:
  *
  * - `pluginInstalled`: did the skill list scan find `everything-claude-code`?
  * - `agentAvailable`: did the Agent tool say `code-review` is registered?
+ * - `cacheAgentAvailable`: does the resolved materialized agent exist
+ *   (`~/.peaks/agents/ecc/<cacheAgentName>.md`, default `code-reviewer`)?
  * - `dispatchError`: optional — the Agent tool threw before returning.
  * - `envelope`: optional — what came back (if anything).
  *
- * The detector never blocks: when state !== `ready`, the parent RD
- * loop records a `code-review-ecc-degraded-to-inline` note and falls
- * back to inline review. This matches `detectOcr`'s soft-fail policy.
+ * The detector never blocks: when the state is not dispatchable
+ * (`ready` / `ready-via-cache`), the parent RD loop records a
+ * `code-review-ecc-degraded-to-inline` note and falls back to inline
+ * review. This matches `detectOcr`'s soft-fail policy.
+ *
+ * Backward compat: the native id is `DEFAULT_NATIVE_ECC_AGENT_ID`
+ * (`ecc:code-reviewer` — plugin `ecc`, agent `code-reviewer`). A registry
+ * that still exposes the OLD `everything-claude-code` plugin id will not
+ * match it, so the operator should pin the id explicitly. peaks-loop
+ * cannot enumerate the user's plugin registry: detection stays
+ * caller-supplied (`pluginInstalled` / `agentAvailable`), never probed here.
  */
 export function detectEcc(input) {
     const warnings = [];
     const nextActions = [];
+    const cacheAgentAvailable = input.cacheAgentAvailable === true;
+    const cacheAgentPath = materializedAgentPath(input.cacheAgentName);
     if (!input.pluginInstalled) {
+        if (cacheAgentAvailable) {
+            return {
+                state: 'ready-via-cache',
+                pluginInstalled: false,
+                agentAvailable: false,
+                warnings: [
+                    'ECC Claude Code plugin is not installed; using the cache-backed generic agent instead.'
+                ],
+                nextActions: [
+                    `Dispatch a generic sub-agent with the body of \`${cacheAgentPath}\` (see \`buildCacheBackedEccPrompt\`).`,
+                    'Refresh the materialized copy with `peaks ecc install`.',
+                    'Install the `ecc` plugin for the native path (optional; native plugin → cache-backed → inline).'
+                ]
+            };
+        }
         return {
             state: 'plugin-missing',
             pluginInstalled: false,
             agentAvailable: false,
             warnings,
             nextActions: [
-                'Install the `everything-claude-code` plugin (Claude Code marketplace).',
-                'Until installed, peaks-rd falls back to inline code review (degradation note: code-review-ecc-degraded-to-inline).'
+                'Install the `ecc` plugin (Claude Code marketplace).',
+                'Or run `peaks ecc install` to populate the cache-backed generic agent path.',
+                'Until one of the two is available, peaks-rd falls back to inline code review (degradation note: code-review-ecc-degraded-to-inline).'
             ]
         };
     }
     if (!input.agentAvailable) {
+        if (cacheAgentAvailable) {
+            return {
+                state: 'ready-via-cache',
+                pluginInstalled: true,
+                agentAvailable: false,
+                warnings: [
+                    '`ecc` is installed but its `code-reviewer` agent is not registered; using the cache-backed generic agent instead.'
+                ],
+                nextActions: [
+                    `Dispatch a generic sub-agent with the body of \`${cacheAgentPath}\` (see \`buildCacheBackedEccPrompt\`).`,
+                    'Verify the plugin is enabled in your Claude Code settings (MCP servers / agent registry) to restore the native path.'
+                ]
+            };
+        }
         return {
             state: 'agent-missing',
             pluginInstalled: true,
             agentAvailable: false,
             warnings: [
-                '`everything-claude-code` is installed but its `code-review` agent is not registered.'
+                '`ecc` is installed but its `code-reviewer` agent is not registered.'
             ],
             nextActions: [
                 'Verify the plugin is enabled in your Claude Code settings (MCP servers / agent registry).',
+                `If your registry still exposes the old \`everything-claude-code\` plugin id, pin the native agent id explicitly (\`${DEFAULT_NATIVE_ECC_AGENT_ID}\`) instead of relying on detection.`,
+                'Or run `peaks ecc install` to populate the cache-backed generic agent path.',
                 'Until resolved, peaks-rd falls back to inline code review.'
             ]
         };
@@ -226,17 +294,69 @@ export function detectEcc(input) {
 /**
  * Convenience: run `detectEcc` and `adaptEccEnvelopeToRdCodeReview`
  * in one call. The parent RD loop calls this after the Agent tool
- * returns. When `detectEcc` returns state !== 'ready', the caller
- * should NOT call `adaptEccEnvelopeToRdCodeReview` — fall back to
- * inline review instead.
+ * returns. When `detectEcc` returns a non-dispatchable state
+ * (`plugin-missing` / `agent-missing` / `dispatch-failed` /
+ * `envelope-malformed`), the caller should NOT call
+ * `adaptEccEnvelopeToRdCodeReview` — fall back to inline review instead.
+ *
+ * Both `ready` (native plugin) and `ready-via-cache` (materialized generic
+ * agent) adapt the envelope through the SAME bridge.
  */
 export function runEccCodeReview(input) {
     const detect = detectEcc(input);
-    if (detect.state !== 'ready' || input.envelope === undefined) {
+    const dispatchable = detect.state === 'ready' || detect.state === 'ready-via-cache';
+    if (!dispatchable || input.envelope === undefined) {
         return { detect, doc: null };
     }
-    // Detect.state === 'ready' implies input.envelope passed isEccEnvelope; the runtime
+    // A dispatchable state implies input.envelope passed isEccEnvelope; the runtime
     // type is therefore EccEnvelope, not `unknown`. Cast is justified by detect's contract.
     const env = input.envelope;
     return { detect, doc: adaptEccEnvelopeToRdCodeReview(env, { rid: input.rid, generatedAt: input.generatedAt }) };
 }
+/**
+ * The exact JSON shape the generic (cache-backed) sub-agent MUST return.
+ * Kept as a const so the RD reference docs and the prompt builder cannot
+ * drift: `isEccEnvelope` is the authoritative validator.
+ */
+export const ECC_OUTPUT_CONTRACT = [
+    'Return ONLY a single JSON object (no prose, no markdown fence) with this exact shape:',
+    '{',
+    '  "passed": boolean,',
+    '  "violations": [{ "kind": string, "line": number, "snippet": string, "hint": string }],',
+    '  "gateAction": "pass" | "warn" | "block"',
+    '}',
+    '`kind` is one of: correctness, type-safety, error-handling, mutation, file-size, naming, dead-code, regression, contract-drift, other.',
+    '`gateAction: "block"` requires at least one violation; `pass` requires an empty violations array.'
+].join('\n');
+/**
+ * Compose the plugin-free dispatch prompt for sub-agent 1.
+ *
+ * `instructions` is the body of the materialized review agent
+ * (`~/.peaks/agents/ecc/code-reviewer.md` — resolve the real name with
+ * `resolveMaterializedAgentName`, never hardcode `code-review.md`);
+ * `diff` is the slice diff. The
+ * composed prompt is handed to a GENERIC sub-agent (no ECC plugin needed)
+ * and its reply is validated with `isEccEnvelope`, then rendered by
+ * `adaptEccEnvelopeToRdCodeReview` — the same bridge the native path uses.
+ */
+export function buildCacheBackedEccPrompt(input) {
+    return [
+        '# Code review (ECC cache-backed generic agent)',
+        '',
+        `Request: ${input.rid}`,
+        '',
+        `## Agent instructions (materialized from ${DEFAULT_NATIVE_ECC_AGENT_ID})`,
+        '',
+        input.instructions.trim(),
+        '',
+        '## Diff under review',
+        '',
+        '```diff',
+        input.diff.trim(),
+        '```',
+        '',
+        '## Required output',
+        '',
+        ECC_OUTPUT_CONTRACT
+    ].join('\n');
+}

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

@@ -15,6 +15,23 @@ export { resolveProjectRootForConfig, resolveCanonicalProjectRoot } from './conf
  */
 export declare function loadGlobalConfig(): ConfigV2 | null;
 export declare function isConfigLayer(value: string): value is ConfigLayer;
+/**
+ * Machine-scoped context-window override key, the config twin of the
+ * `PEAKS_CONTEXT_WINDOW_TOKENS` env var (slice
+ * 2026-09-09-context-window-override). Written with
+ * `peaks config set --key context.windowTokens --value <positive-int>`
+ * (user layer) so the user pins it once instead of exporting an env var
+ * in every shell.
+ */
+export declare const CONTEXT_WINDOW_TOKENS_CONFIG_KEY = "context.windowTokens";
+/**
+ * Read the raw `context.windowTokens` value from the merged config, project
+ * layer over user layer (most specific wins). Returns the RAW value —
+ * validation lives in the context-window resolver so exactly one warning is
+ * emitted per bad value. Returns `undefined` when absent or unreadable;
+ * never throws (a corrupt config must not crash a context probe).
+ */
+export declare function readContextWindowTokensOverride(projectRoot?: string | null): unknown;
 export declare function isSensitiveConfigPath(path: string): boolean;
 export declare function isLegacyConfigKey(path: string): boolean;
 export declare function containsSensitiveConfigValue(value: unknown): boolean;

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

@@ -176,6 +176,40 @@ function removeProjectSensitiveConfig(config) {
 export function isConfigLayer(value) {
     return value === 'user' || value === 'project';
 }
+/**
+ * Machine-scoped context-window override key, the config twin of the
+ * `PEAKS_CONTEXT_WINDOW_TOKENS` env var (slice
+ * 2026-09-09-context-window-override). Written with
+ * `peaks config set --key context.windowTokens --value <positive-int>`
+ * (user layer) so the user pins it once instead of exporting an env var
+ * in every shell.
+ */
+export const CONTEXT_WINDOW_TOKENS_CONFIG_KEY = 'context.windowTokens';
+/**
+ * Read the raw `context.windowTokens` value from the merged config, project
+ * layer over user layer (most specific wins). Returns the RAW value —
+ * validation lives in the context-window resolver so exactly one warning is
+ * emitted per bad value. Returns `undefined` when absent or unreadable;
+ * never throws (a corrupt config must not crash a context probe).
+ */
+export function readContextWindowTokensOverride(projectRoot) {
+    try {
+        const projectRaw = readProjectJsonFile(projectRoot ?? null);
+        if (isRecord(projectRaw)) {
+            const fromProject = getNestedValue(projectRaw, CONTEXT_WINDOW_TOKENS_CONFIG_KEY);
+            if (fromProject !== undefined)
+                return fromProject;
+        }
+        const userRaw = readUserJsonFile();
+        if (isRecord(userRaw)) {
+            return getNestedValue(userRaw, CONTEXT_WINDOW_TOKENS_CONFIG_KEY);
+        }
+        return undefined;
+    }
+    catch { // TODO(g2): legacy silent catch — never let config IO break a probe (grace: 1 minor release, v2.14.0)
+        return undefined;
+    }
+}
 export function isSensitiveConfigPath(path) {
     const normalized = path.toLowerCase().replace(/[^a-z0-9]/g, '');
     return normalized.includes('apikey') || normalized.includes('accesskey') || normalized.includes('privatekey') || normalized.includes('token') || normalized.includes('secret') || normalized.includes('password') || normalized.includes('bearer') || normalized.includes('credential') || normalized.includes('auth');

package/dist/services/context/auto-compact-dispatcher.d.ts

@@ -45,7 +45,7 @@ export interface DispatchIdeCompactInput {
      * the compact should target. Default `'main'` — the orchestrator
      * (peaks-code body) runs in the main-session Claude Code window and
      * wants to compress *its* context, not a sub-agent's. Sub-agent
-     * shells that spawn their own `peaks compact auto` flow pass
+     * shells that spawn their own `peaks code auto-compact` flow pass
      * `'sub-agent'` to preserve the legacy shell-spawn behaviour.
      *
      * Behaviour matrix (claude-code MVP):
@@ -66,7 +66,7 @@ export interface DispatchIdeCompactInput {
  * when the dispatch path completed without error — for
  * `llm-self-compress` the LLM still has to do the actual summary,
  * so the orchestrator MUST NOT treat `ok: true` as proof that the
- * context actually shrunk; the next `peaks compact auto` probe
+ * context actually shrunk; the next `peaks code auto-compact` probe
  * confirms.
  */
 export declare function dispatchIdeCompact(input: DispatchIdeCompactInput): Promise<CompactDispatchResult>;

package/dist/services/context/auto-compact-dispatcher.js

@@ -7,7 +7,7 @@ import { getAdapter } from '../ide/ide-registry.js';
  * when the dispatch path completed without error — for
  * `llm-self-compress` the LLM still has to do the actual summary,
  * so the orchestrator MUST NOT treat `ok: true` as proof that the
- * context actually shrunk; the next `peaks compact auto` probe
+ * context actually shrunk; the next `peaks code auto-compact` probe
  * confirms.
  */
 export async function dispatchIdeCompact(input) {
@@ -77,7 +77,7 @@ export async function dispatchIdeCompact(input) {
         case 'ide-native':
             // Slice 2026-07-02-auto-compact-zero-pause: write the auto-compact
             // PreToolUse hook into `.claude/settings.local.json`. The hook
-            // command (`peaks compact auto`) reads
+            // command (`peaks code auto-compact`) reads
             // `CLAUDE_CONTEXT_USAGE_PERCENT` on every subsequent Bash/Task
             // tool call from the runner and, at ratio ≥ 0.95, in-band spawns
             // `claude --compact` against the CURRENT runner (not a child
@@ -106,7 +106,7 @@ export async function dispatchIdeCompact(input) {
                 };
             }
             // Lazy install: we only get here when the caller explicitly
-            // invokes `peaks compact auto --execute`, so the user has
+            // invokes `peaks code auto-compact`, so the user has
             // already opted in. No zero-touch surprise on workspace init.
             return await dispatchIdeNativeHook({
                 projectRoot: input.projectRoot,
@@ -144,7 +144,7 @@ export async function dispatchIdeCompact(input) {
  * into `.claude/settings.local.json` (idempotent; the install
  * service is a no-op if the hook is already present). On the next
  * Bash/Task tool call from the runner, the hook fires
- * `peaks compact auto` which in-band spawns
+ * `peaks code auto-compact` which in-band spawns
  * `claude --compact` against the CURRENT runner session.
  *
  * Returns `ok: true, pathway: 'ide-native'` regardless of install

package/dist/services/context/auto-compact-reader.js

@@ -1,5 +1,6 @@
 import { detectIdeFromEnv } from './ide-detect.js';
 import { getAdapter } from '../ide/ide-registry.js';
+import { readContextWindowTokensOverride } from '../config/config-service.js';
 /**
  * Read env-var-based context percentage. Returns `null` when the env
  * is absent or unparseable. Adapter-driven: the caller passes the
@@ -74,11 +75,17 @@ export function readContextPercent(input) {
         // Fallback: the adapter owns any vendor-specific statusline /
         // transcript probe. When it returns a probe, honor it; otherwise
         // fall through to conservative-fallback.
+        //
+        // Slice 2026-09-09-context-window-override: the generic reader also
+        // hands the adapter the raw `context.windowTokens` config override, so
+        // the adapter's window resolver can prefer an explicit user value over
+        // its model-name heuristics (the env override arrives via `env`).
         const fallback = adapter.compact.readContextPercentFallback?.({
             projectRoot: input.projectRoot,
             sessionId: input.sessionId,
             outerSessionId: input.outerSessionId,
-            env
+            env,
+            configWindowTokens: readContextWindowTokensOverride(input.projectRoot)
         });
         if (fallback)
             return fallback;

package/dist/services/context/auto-compact-types.d.ts

@@ -45,7 +45,7 @@ export type CompactTrigger = {
 }
 /**
  * Part 22: auto-fire zone (0.80 ≤ ratio < 0.85). peaks-loop
- * preempts and runs `peaks compact auto --execute` itself
+ * preempts and runs `peaks code auto-compact` itself
  * without LLM involvement. The LLM is not asked to "decide";
  * the toolkit is applied synchronously.
  */
@@ -186,6 +186,18 @@ export interface ContextPercentProbe {
      * percent sources.
      */
     readonly capacityTokens?: number;
+    /**
+     * Which layer produced `capacityTokens` (token-based sources only):
+     *   - `env-override`    — `PEAKS_CONTEXT_WINDOW_TOKENS`
+     *   - `config`          — `context.windowTokens` (`peaks config set`)
+     *   - `model-heuristic` — `[1M]` suffix / known-1M model allowlist
+     *   - `default`         — 200K safe default
+     * Undefined for byte / percent sources (`user-overridden`, `${ideId}-env`,
+     * `statusline-poll`), which have no token window. Slice
+     * 2026-09-09-context-window-override: lets a wrong window be diagnosed in
+     * one read instead of guessing which heuristic fired.
+     */
+    readonly capacitySource?: string;
     readonly ide: string;
     readonly capturedAt: string;
 }

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

@@ -191,9 +191,9 @@ function renderContextBlock(probe) {
         const usedPct = (probe.ratio * 100).toFixed(1);
         const freePct = ((1 - probe.ratio) * 100).toFixed(1);
         const action = probe.ratio >= 0.95
-            ? 'RED-LINE — call `peaks compact auto --execute` immediately.'
+            ? 'RED-LINE — call `peaks code auto-compact` immediately.'
             : probe.ratio >= 0.85
-                ? 'pre-compact zone — consider running `peaks compact auto --execute` proactively.'
+                ? 'pre-compact zone — consider running `peaks code auto-compact` proactively.'
                 : probe.ratio >= 0.5
                     ? 'soft-warn zone — continue working; the next dispatch will re-check.'
                     : 'plenty of room — continue without compacting.';

package/dist/services/context/context-schema.d.ts

@@ -13,8 +13,8 @@ export declare const ContextJsonSchema: z.ZodObject<{
             path: z.ZodString;
             kind: z.ZodEnum<{
                 doc: "doc";
-                source: "source";
                 config: "config";
+                source: "source";
                 test: "test";
             }>;
             lines: z.ZodNumber;

package/dist/services/dashboard/project-dashboard-service.d.ts

@@ -12,12 +12,6 @@ export type ProjectDashboardOpenSpec = {
     count: number;
     changes: OpenSpecChangeSummary[];
 };
-export type ProjectDashboardUnderstand = {
-    exists: boolean;
-    graphExists: boolean;
-    graphPath: string;
-    parseError?: string;
-};
 export type ProjectDashboardDoctor = {
     ok: boolean;
     passed: number;
@@ -69,7 +63,6 @@ export type ProjectDashboard = {
     okPolicy: DashboardOkPolicy;
     requests: ProjectDashboardRequests;
     openspec: ProjectDashboardOpenSpec;
-    understand: ProjectDashboardUnderstand;
     doctor: ProjectDashboardDoctor;
     runbookHealth: ProjectDashboardRunbookHealth;
     capabilities: ProjectDashboardCapabilities;

package/dist/services/dashboard/project-dashboard-service.js

@@ -1,6 +1,5 @@
 import { listRequestArtifacts } from '../artifacts/request-artifact-service.js';
 import { scanOpenSpec } from '../openspec/openspec-scan-service.js';
-import { scanUnderstandAnything } from '../understand/understand-scan-service.js';
 import { seedCapabilityItems } from '../recommendations/capability-seed-items.js';
 import { requiredSkillNames } from 'peaks-loop-shared/paths';
 import { getSkillPresence } from '../skills/skill-presence-service.js';
@@ -107,10 +106,9 @@ export async function loadProjectDashboard(options) {
     const clock = options.clock ?? defaultClock;
     const sampleSize = options.sampleCapabilities ?? 8;
     const okPolicy = options.okPolicy ?? 'workspace-only';
-    const [items, openspecReport, understandReport, doctorAndRunbook] = await Promise.all([
+    const [items, openspecReport, doctorAndRunbook] = await Promise.all([
         listRequestArtifacts({ projectRoot: options.projectRoot }),
         scanOpenSpec({ openspecRoot: `${options.projectRoot}/openspec` }),
-        scanUnderstandAnything({ projectRoot: options.projectRoot }),
         loadDoctorAndRunbookHealth(options.doctorReport, options.runbookHealth)
     ]);
     const okVerdict = resolveDashboardOk({
@@ -133,12 +131,6 @@ export async function loadProjectDashboard(options) {
             count: openspecReport.changes.length,
             changes: openspecReport.changes
         },
-        understand: {
-            exists: understandReport.exists,
-            graphExists: understandReport.graph.exists,
-            graphPath: understandReport.graph.path,
-            ...(understandReport.graph.parseError !== undefined ? { parseError: understandReport.graph.parseError } : {})
-        },
         doctor: doctorAndRunbook.doctor,
         runbookHealth: doctorAndRunbook.runbookHealth,
         capabilities: buildCapabilitiesSummary(sampleSize),