peaks-loop 4.0.33 → 4.0.34

package/dist/services/code/mode-gate.d.ts

@@ -5,7 +5,7 @@
  * pause for an AskUserQuestion round-trip?" The D5 design (per
  * `.peaks/memory/2026-06-26-v2-11-full-auto-self-decision.md`) requires:
  *
- *   - `full-auto` and `swarm` modes → auto-proceed (recommended = chosen)
+ *   - `full-auto` and `24h` modes → auto-proceed (recommended = chosen)
  *   - `assisted` and `strict` modes → pause for confirmation
  *   - 3 hard-floor categories ALWAYS ask, regardless of mode:
  *     1. Irreversible external side effects (git push, npm publish, …)
@@ -77,7 +77,11 @@ export declare function isHardFloorCategory(value: string): value is HardFloorCa
 /**
  * `true` when the current mode should auto-proceed (skip the
  * AskUserQuestion round-trip). Mirrors D5.a: "recommended = chosen
- * in full-auto / swarm; always log, never silently skip".
+ * in full-auto / 24h; always log, never silently skip".
+ *
+ * Slice 2026-09-09-mode-consolidation: `swarm` was removed as a mode
+ * (parallel fan-out is now the default execution strategy in every
+ * mode); `24h` replaces it as the second auto-proceed peer.
  */
 export declare function shouldAutoProceed(mode: CodeMode): boolean;
 /**

package/dist/services/code/mode-gate.js

@@ -5,7 +5,7 @@
  * pause for an AskUserQuestion round-trip?" The D5 design (per
  * `.peaks/memory/2026-06-26-v2-11-full-auto-self-decision.md`) requires:
  *
- *   - `full-auto` and `swarm` modes → auto-proceed (recommended = chosen)
+ *   - `full-auto` and `24h` modes → auto-proceed (recommended = chosen)
  *   - `assisted` and `strict` modes → pause for confirmation
  *   - 3 hard-floor categories ALWAYS ask, regardless of mode:
  *     1. Irreversible external side effects (git push, npm publish, …)
@@ -22,8 +22,8 @@
 export const CODE_MODES = [
     'full-auto',
     'assisted',
-    'swarm',
-    'strict'
+    'strict',
+    '24h'
 ];
 export const HARD_FLOOR_CATEGORIES = [
     'irreversible-external-side-effect',
@@ -56,10 +56,14 @@ export function isHardFloorCategory(value) {
 /**
  * `true` when the current mode should auto-proceed (skip the
  * AskUserQuestion round-trip). Mirrors D5.a: "recommended = chosen
- * in full-auto / swarm; always log, never silently skip".
+ * in full-auto / 24h; always log, never silently skip".
+ *
+ * Slice 2026-09-09-mode-consolidation: `swarm` was removed as a mode
+ * (parallel fan-out is now the default execution strategy in every
+ * mode); `24h` replaces it as the second auto-proceed peer.
  */
 export function shouldAutoProceed(mode) {
-    return mode === 'full-auto' || mode === 'swarm';
+    return mode === 'full-auto' || mode === '24h';
 }
 export const COMMIT_BOUNDARY_ACTIONS = [
     'git-push',

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/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/hooks/auto-compact-hook-install.d.ts

@@ -37,7 +37,7 @@
  */
 export declare const AUTO_COMPACT_HOOK_MATCHER = "Bash|Task";
 /**
- * Stable command the hook fires. Wraps `peaks compact auto` so the
+ * Stable command the hook fires. Wraps `peaks code auto-compact` so the
  * heavy lifting (ratio probe + in-band `claude --compact` spawn)
  * lives in the CLI surface, not inlined into the hook.
  *
@@ -46,7 +46,7 @@ export declare const AUTO_COMPACT_HOOK_MATCHER = "Bash|Task";
  * so the unqualified command works in the same shell the runner
  * is using.
  */
-export declare const AUTO_COMPACT_HOOK_COMMAND = "peaks compact auto";
+export declare const AUTO_COMPACT_HOOK_COMMAND = "peaks code auto-compact";
 /**
  * Magic comment marker that fences the auto-compatchook block.
  * Both install (writes the marker) and remove (matches on it) use

package/dist/services/hooks/auto-compact-hook-install.js

@@ -39,7 +39,7 @@ import { dirname, join } from 'node:path';
  */
 export const AUTO_COMPACT_HOOK_MATCHER = 'Bash|Task';
 /**
- * Stable command the hook fires. Wraps `peaks compact auto` so the
+ * Stable command the hook fires. Wraps `peaks code auto-compact` so the
  * heavy lifting (ratio probe + in-band `claude --compact` spawn)
  * lives in the CLI surface, not inlined into the hook.
  *
@@ -48,7 +48,7 @@ export const AUTO_COMPACT_HOOK_MATCHER = 'Bash|Task';
  * so the unqualified command works in the same shell the runner
  * is using.
  */
-export const AUTO_COMPACT_HOOK_COMMAND = 'peaks compact auto';
+export const AUTO_COMPACT_HOOK_COMMAND = 'peaks code auto-compact';
 /**
  * Magic comment marker that fences the auto-compatchook block.
  * Both install (writes the marker) and remove (matches on it) use

package/dist/services/ide/adapters/claude-code-adapter.d.ts

@@ -20,6 +20,57 @@ export declare function resolveClaudeModelFromEnv(env: NodeJS.ProcessEnv | undef
  * Callers MAY additionally infer ≥1M from the observed token count: if
  * `contextTokens > DEFAULT_CONTEXT_WINDOW_TOKENS`, the model cannot be a
  * 200K model and must be ≥1M (see `readClaudeTranscriptEstimate`).
+ *
+ * This is the HEURISTIC layer only. Explicit user overrides sit ABOVE it —
+ * see `resolveContextWindow`, which is what the probe actually calls.
  */
 export declare function modelContextWindowTokens(model: string): number;
+/**
+ * Slice 2026-09-09-context-window-override: vendor-neutral escape hatch for
+ * the context-window size in tokens. Third-party / proxied models whose id
+ * carries no `[1M]` suffix (and is absent from the hardcoded allowlist) are
+ * otherwise stuck at the 200K default, which inflates `ratio` up to 5×.
+ * Same spirit as `PEAKS_CALLER_ID`: an env var the user can export, plus a
+ * machine-wide `peaks config set --key context.windowTokens` twin.
+ */
+export declare const CONTEXT_WINDOW_TOKENS_ENV_VAR = "PEAKS_CONTEXT_WINDOW_TOKENS";
+/**
+ * Which layer produced a resolved context window:
+ *   - `env-override`     — `PEAKS_CONTEXT_WINDOW_TOKENS`
+ *   - `config`           — `context.windowTokens` (`peaks config set`)
+ *   - `model-heuristic`  — `[1M]` suffix / `ONE_MILLION_CONTEXT_MODELS`
+ *   - `default`          — 200K safe default
+ */
+export type ContextWindowSource = 'env-override' | 'config' | 'model-heuristic' | 'default';
+export interface ContextWindowResolution {
+    readonly tokens: number;
+    readonly source: ContextWindowSource;
+}
+/** Explicit override inputs (both optional; env wins over config). */
+export interface ContextWindowOverrides {
+    readonly env?: NodeJS.ProcessEnv | undefined;
+    /** Raw `context.windowTokens` value (unvalidated — validated here). */
+    readonly configWindowTokens?: unknown;
+    /** Warning sink for an invalid override (defaults to `console.warn`). */
+    readonly onInvalidOverride?: ((message: string) => void) | undefined;
+}
+/**
+ * Parse an explicit context-window override. Accepts a positive finite
+ * integer only (number, or a numeric string so an env var works); anything
+ * else — `0`, negative, `NaN`, `Infinity`, `1.5`, `'abc'`, `''` — returns
+ * null so the caller can ignore it and fall through to the next layer.
+ */
+export declare function parseContextWindowOverride(raw: unknown): number | null;
+/**
+ * Resolve the context window in tokens AND report which layer won
+ * (first hit wins):
+ *   1. env `PEAKS_CONTEXT_WINDOW_TOKENS`
+ *   2. config `context.windowTokens`
+ *   3. model-name heuristic (`modelContextWindowTokens`)
+ *   4. `DEFAULT_CONTEXT_WINDOW_TOKENS` (200_000)
+ *
+ * An invalid explicit override is ignored with a warning and falls through
+ * to the next layer — a typo must never crash or silently win the probe.
+ */
+export declare function resolveContextWindow(model: string, overrides?: ContextWindowOverrides): ContextWindowResolution;
 export declare const CLAUDE_CODE_ADAPTER: IdeAdapter;

package/dist/services/ide/adapters/claude-code-adapter.js

@@ -161,6 +161,9 @@ export function resolveClaudeModelFromEnv(env) {
  * Callers MAY additionally infer ≥1M from the observed token count: if
  * `contextTokens > DEFAULT_CONTEXT_WINDOW_TOKENS`, the model cannot be a
  * 200K model and must be ≥1M (see `readClaudeTranscriptEstimate`).
+ *
+ * This is the HEURISTIC layer only. Explicit user overrides sit ABOVE it —
+ * see `resolveContextWindow`, which is what the probe actually calls.
  */
 export function modelContextWindowTokens(model) {
     const m = model.trim().toLowerCase();
@@ -174,6 +177,60 @@ export function modelContextWindowTokens(model) {
     }
     return DEFAULT_CONTEXT_WINDOW_TOKENS;
 }
+/**
+ * Slice 2026-09-09-context-window-override: vendor-neutral escape hatch for
+ * the context-window size in tokens. Third-party / proxied models whose id
+ * carries no `[1M]` suffix (and is absent from the hardcoded allowlist) are
+ * otherwise stuck at the 200K default, which inflates `ratio` up to 5×.
+ * Same spirit as `PEAKS_CALLER_ID`: an env var the user can export, plus a
+ * machine-wide `peaks config set --key context.windowTokens` twin.
+ */
+export const CONTEXT_WINDOW_TOKENS_ENV_VAR = 'PEAKS_CONTEXT_WINDOW_TOKENS';
+/**
+ * Parse an explicit context-window override. Accepts a positive finite
+ * integer only (number, or a numeric string so an env var works); anything
+ * else — `0`, negative, `NaN`, `Infinity`, `1.5`, `'abc'`, `''` — returns
+ * null so the caller can ignore it and fall through to the next layer.
+ */
+export function parseContextWindowOverride(raw) {
+    if (typeof raw !== 'number' && typeof raw !== 'string')
+        return null;
+    if (typeof raw === 'string' && raw.trim().length === 0)
+        return null;
+    const parsed = typeof raw === 'number' ? raw : Number(raw.trim());
+    return Number.isFinite(parsed) && Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+/**
+ * Resolve the context window in tokens AND report which layer won
+ * (first hit wins):
+ *   1. env `PEAKS_CONTEXT_WINDOW_TOKENS`
+ *   2. config `context.windowTokens`
+ *   3. model-name heuristic (`modelContextWindowTokens`)
+ *   4. `DEFAULT_CONTEXT_WINDOW_TOKENS` (200_000)
+ *
+ * An invalid explicit override is ignored with a warning and falls through
+ * to the next layer — a typo must never crash or silently win the probe.
+ */
+export function resolveContextWindow(model, overrides = {}) {
+    const warn = overrides.onInvalidOverride ?? ((message) => console.warn(message));
+    const envRaw = overrides.env?.[CONTEXT_WINDOW_TOKENS_ENV_VAR];
+    if (envRaw !== undefined) {
+        const parsed = parseContextWindowOverride(envRaw);
+        if (parsed !== null)
+            return { tokens: parsed, source: 'env-override' };
+        warn(`[peaks] ${CONTEXT_WINDOW_TOKENS_ENV_VAR}="${String(envRaw)}" is not a positive integer — ignoring the override`);
+    }
+    if (overrides.configWindowTokens !== undefined) {
+        const parsed = parseContextWindowOverride(overrides.configWindowTokens);
+        if (parsed !== null)
+            return { tokens: parsed, source: 'config' };
+        warn(`[peaks] config context.windowTokens=${JSON.stringify(overrides.configWindowTokens)} is not a positive integer — ignoring the override`);
+    }
+    const heuristic = modelContextWindowTokens(model);
+    return heuristic === DEFAULT_CONTEXT_WINDOW_TOKENS
+        ? { tokens: heuristic, source: 'default' }
+        : { tokens: heuristic, source: 'model-heuristic' };
+}
 /** A non-negative finite number, or null when the value is not numeric. */
 function numericTokenCount(value) {
     if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
@@ -277,14 +334,20 @@ function findLatestTranscriptUsage(filePath) {
     }
 }
 /**
- * Resolve the context window for a transcript usage entry. Prefers the
- * explicit `modelContextWindowTokens(model)` mapping; when the observed token
- * count contradicts it (tokens exceed the mapped window), the model must be
- * ≥1M, so bump to the 1M window.
+ * Resolve the context window for a transcript usage entry. Explicit user
+ * overrides (`resolveContextWindow`) win outright — the user pinned the
+ * number, so nothing else may contradict it. Without an explicit override,
+ * when the observed token count contradicts the heuristic window (tokens
+ * exceed it), the model must be ≥1M, so bump to the 1M window (the late
+ * rescue; it keeps the heuristic source tag, only the tokens change).
  */
-function resolveContextWindowTokens(model, contextTokens) {
-    const window = modelContextWindowTokens(model);
-    return contextTokens > window ? ONE_MILLION_CONTEXT_TOKENS : window;
+function resolveContextWindowTokens(model, contextTokens, overrides = {}) {
+    const resolved = resolveContextWindow(model, overrides);
+    if (resolved.source === 'env-override' || resolved.source === 'config')
+        return resolved;
+    return contextTokens > resolved.tokens
+        ? { tokens: ONE_MILLION_CONTEXT_TOKENS, source: resolved.source }
+        : resolved;
 }
 /**
  * Conservative transcript-estimate fallback. Recursively searches
@@ -298,9 +361,11 @@ function resolveContextWindowTokens(model, contextTokens) {
  *
  * Window model resolution is env-first: when `envModel` is present, its id
  * (which Claude Code stamps with the `[1M]` / `[200K]` suffix) drives the
- * window; otherwise the transcript `message.model` is used.
+ * window; otherwise the transcript `message.model` is used. Explicit
+ * overrides (env `PEAKS_CONTEXT_WINDOW_TOKENS` / config `context.windowTokens`)
+ * sit above both and are reported via `capacitySource`.
  */
-function readClaudeTranscriptEstimate(outerSessionId, envModel) {
+function readClaudeTranscriptEstimate(outerSessionId, envModel, overrides = {}) {
     const projectsDir = join(homedir(), '.claude', 'projects');
     const path = findTranscriptJsonl(projectsDir, outerSessionId);
     if (path === null)
@@ -309,9 +374,10 @@ function readClaudeTranscriptEstimate(outerSessionId, envModel) {
     if (latest === null)
         return null;
     const model = envModel !== undefined && envModel.trim().length > 0 ? envModel : latest.model;
-    const contextWindowTokens = resolveContextWindowTokens(model, latest.contextTokens);
+    const resolved = resolveContextWindowTokens(model, latest.contextTokens, overrides);
+    const contextWindowTokens = resolved.tokens;
     const ratio = Math.min(1, latest.contextTokens / contextWindowTokens);
-    return { ratio, contextTokens: latest.contextTokens, contextWindowTokens };
+    return { ratio, contextTokens: latest.contextTokens, contextWindowTokens, capacitySource: resolved.source };
 }
 /**
  * Claude Code's vendor-specific context-percent fallback, exposed as
@@ -344,13 +410,17 @@ function readContextPercentFallback(input) {
     }
     if (typeof input.outerSessionId === 'string' && input.outerSessionId.length > 0) {
         const envModel = resolveClaudeModelFromEnv(input.env);
-        const estimate = readClaudeTranscriptEstimate(input.outerSessionId, envModel);
+        const estimate = readClaudeTranscriptEstimate(input.outerSessionId, envModel, {
+            env: input.env,
+            configWindowTokens: input.configWindowTokens
+        });
         if (estimate !== null) {
             return {
                 ratio: estimate.ratio,
                 source: 'transcript-estimate',
                 rawTokens: estimate.contextTokens,
                 capacityTokens: estimate.contextWindowTokens,
+                capacitySource: estimate.capacitySource,
                 ide,
                 capturedAt
             };
@@ -401,7 +471,7 @@ export const CLAUDE_CODE_ADAPTER = {
     // Pathway = 'ide-native' (not 'shell-exec') so the dispatcher
     // routes main-session compacts through the PreToolUse hook in
     // `.claude/settings.local.json`. The hook fires
-    // `peaks compact auto` on the NEXT Bash/Task tool
+    // `peaks code auto-compact` on the NEXT Bash/Task tool
     // call from the runner, which in-band spawns `claude --compact`
     // against the CURRENT runner — not a child process (the
     // shell-exec spawn-new-claude bug documented in
@@ -412,7 +482,7 @@ export const CLAUDE_CODE_ADAPTER = {
         envVarForContextPercent: 'CLAUDE_CONTEXT_USAGE_PERCENT',
         compactCommand: 'claude --compact',
         compactPathway: 'ide-native',
-        postCompactDetectCommand: 'peaks compact auto --json',
+        postCompactDetectCommand: 'peaks code auto-compact --json',
         readContextPercentFallback
     },
     // Slice #011: standards profile. Claude Code reads its constitution at

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

@@ -197,7 +197,7 @@ export interface IdeCompactProfile {
     readonly compactPathway: 'shell-exec' | 'ide-native' | 'llm-self-compress' | 'noop';
     /**
      * Optional command the runner invokes post-compact to confirm
-     * ratio dropped (e.g. `peaks compact auto --json`). When omitted,
+     * ratio dropped (e.g. `peaks code auto-compact --json`). When omitted,
      * the orchestrator polls `envVarForContextPercent` directly.
      */
     readonly postCompactDetectCommand?: string;
@@ -239,6 +239,15 @@ export interface ContextPercentFallbackInput {
     readonly outerSessionId?: string | undefined;
     /** Injectable env (defaults to process.env in the reader). */
     readonly env?: NodeJS.ProcessEnv | undefined;
+    /**
+     * Raw `context.windowTokens` value from the merged config (project layer
+     * over user layer), read by the generic reader so the adapter stays free
+     * of config-path knowledge. UNVALIDATED — the adapter validates it via
+     * `parseContextWindowOverride` and warns on a bad value.
+     *
+     * Slice 2026-09-09-context-window-override.
+     */
+    readonly configWindowTokens?: unknown;
 }
 /**
  * Per-IDE standards-file location + format profile. Used by the

package/dist/services/mode/mode-enforcement.d.ts

@@ -8,7 +8,10 @@ export type ConfirmationOptions = {
     forceConfirm?: boolean | undefined;
 };
 export declare class ConfirmationRequiredError extends Error {
-    constructor(transitionKey: TransitionKey);
+    readonly transitionKey: TransitionKey;
+    readonly mode: SkillPresenceMode;
+    readonly nextActions: readonly string[];
+    constructor(transitionKey: TransitionKey, mode: SkillPresenceMode);
 }
 export declare function requireUserConfirmation(options: ConfirmationOptions): Promise<void>;
 export {};