peaks-loop 4.0.33 → 4.0.35

package/dist/services/24h-mode/auto-engage.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice B): auto-engage may set the
+ * 24h MODE — and ONLY the 24h mode.
+ *
+ * `24h` is the single mode that may be set without an explicit user pick
+ * (the T1–T5 triggers, and `peaks code run --24h`). Every other mode
+ * still requires the Step-1 hard-pause AskUserQuestion
+ * (`mode-gate.shouldPauseAtGate` keeps `step-1-mode-select` in
+ * `HARD_PAUSE_STEPS`).
+ *
+ * Before this slice the auto-engage paths wrote only
+ * `.peaks/_runtime/<sid>/24h-state.json`; the presence lease kept
+ * whatever mode it had (or none), so `24h` was invisible to the mode
+ * gate and `strict` + `24H_ACTIVE` still paused every gate. This module
+ * is the single place that closes that gap, and the single guard that
+ * refuses to stamp any other mode.
+ */
+export declare const AUTO_ENGAGE_PRESENCE_MODE: "24h";
+export type AutoEngagePresenceResult = {
+    applied: true;
+    mode: typeof AUTO_ENGAGE_PRESENCE_MODE;
+    updated: number;
+} | {
+    applied: false;
+    mode: string;
+    reason: 'mode-not-auto-settable' | 'no-in-flight-lease' | 'stamp-failed';
+};
+/**
+ * Stamp the 24h mode onto every in-flight presence lease of the bound
+ * session. Fail-soft: never throws — a missing lease / unreadable store
+ * degrades to `{ applied: false }` so the auto-engage caller can still
+ * report the 24h-state transition.
+ */
+export declare function applyAutoEngagePresenceMode(input: {
+    projectRoot: string;
+    sessionId: string;
+    /** Defaults to `24h`; any other value is refused. */
+    mode?: string;
+}): AutoEngagePresenceResult;

package/dist/services/24h-mode/auto-engage.js

@@ -0,0 +1,46 @@
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice B): auto-engage may set the
+ * 24h MODE — and ONLY the 24h mode.
+ *
+ * `24h` is the single mode that may be set without an explicit user pick
+ * (the T1–T5 triggers, and `peaks code run --24h`). Every other mode
+ * still requires the Step-1 hard-pause AskUserQuestion
+ * (`mode-gate.shouldPauseAtGate` keeps `step-1-mode-select` in
+ * `HARD_PAUSE_STEPS`).
+ *
+ * Before this slice the auto-engage paths wrote only
+ * `.peaks/_runtime/<sid>/24h-state.json`; the presence lease kept
+ * whatever mode it had (or none), so `24h` was invisible to the mode
+ * gate and `strict` + `24H_ACTIVE` still paused every gate. This module
+ * is the single place that closes that gap, and the single guard that
+ * refuses to stamp any other mode.
+ */
+import { stampPresenceLeaseMode } from '../skills/presence-lease-service.js';
+export const AUTO_ENGAGE_PRESENCE_MODE = '24h';
+/**
+ * Stamp the 24h mode onto every in-flight presence lease of the bound
+ * session. Fail-soft: never throws — a missing lease / unreadable store
+ * degrades to `{ applied: false }` so the auto-engage caller can still
+ * report the 24h-state transition.
+ */
+export function applyAutoEngagePresenceMode(input) {
+    const mode = input.mode ?? AUTO_ENGAGE_PRESENCE_MODE;
+    if (mode !== AUTO_ENGAGE_PRESENCE_MODE) {
+        return { applied: false, mode, reason: 'mode-not-auto-settable' };
+    }
+    let updated;
+    try {
+        updated = stampPresenceLeaseMode({
+            projectRoot: input.projectRoot,
+            sessionId: input.sessionId,
+            mode: AUTO_ENGAGE_PRESENCE_MODE
+        }).updated;
+    }
+    catch {
+        return { applied: false, mode, reason: 'stamp-failed' };
+    }
+    if (updated === 0) {
+        return { applied: false, mode, reason: 'no-in-flight-lease' };
+    }
+    return { applied: true, mode: AUTO_ENGAGE_PRESENCE_MODE, updated };
+}

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

@@ -95,9 +95,15 @@ export type HandoffExitCondition = (typeof HANDOFF_EXIT_CONDITIONS)[number];
 export declare function isHandoffExitCondition(s: string): s is HandoffExitCondition;
 export declare function isHandoffState(s: State): boolean;
 /**
- * Slice 2026-07-28 (rid-027): resolve the auto-compact mode from
- * 24h-mode awareness. Returns `'partial'` when the session is
- * `24H_ACTIVE`, otherwise `'standard'`. This is the CLI-side default;
- * the explicit `--mode` flag in `peaks compact auto` overrides it.
+ * Slice 2026-07-28 (rid-027), re-keyed by slice
+ * 2026-09-09-mode-consolidation: resolve the auto-compact mode from
+ * the PRESENCE MODE, not the 24h state machine. Returns `'partial'`
+ * when the mode is `24h`, otherwise `'standard'`. This is the CLI-side
+ * default; the explicit `--mode` flag in `peaks code auto-compact`
+ * overrides it.
+ *
+ * `sessionId` is retained in the signature for callers that still pass
+ * it; the resolution itself is project-scoped (the presence lease is
+ * per project + caller).
  */
-export declare function getAutoCompactMode(projectRoot: string, sessionId: string): AutoCompactMode;
+export declare function getAutoCompactMode(projectRoot: string, _sessionId?: string): AutoCompactMode;

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

@@ -11,7 +11,7 @@
  * WAITING_USER — proposal §1 T3/T4 exception).
  */
 import { B3_THRESHOLD, isDecisionKey } from './state.js';
-import { read24hState } from './store.js';
+import { resolveAutoCompactProfile } from '../mode/mode-status-service.js';
 export const B3_TRIGGER_REASONS = [
     'prd_direction_change',
     'blocker_3_consecutive_slices',
@@ -128,17 +128,17 @@ export function isHandoffState(s) {
     return s === 'HANDOFF';
 }
 /**
- * Slice 2026-07-28 (rid-027): resolve the auto-compact mode from
- * 24h-mode awareness. Returns `'partial'` when the session is
- * `24H_ACTIVE`, otherwise `'standard'`. This is the CLI-side default;
- * the explicit `--mode` flag in `peaks compact auto` overrides it.
+ * Slice 2026-07-28 (rid-027), re-keyed by slice
+ * 2026-09-09-mode-consolidation: resolve the auto-compact mode from
+ * the PRESENCE MODE, not the 24h state machine. Returns `'partial'`
+ * when the mode is `24h`, otherwise `'standard'`. This is the CLI-side
+ * default; the explicit `--mode` flag in `peaks code auto-compact`
+ * overrides it.
+ *
+ * `sessionId` is retained in the signature for callers that still pass
+ * it; the resolution itself is project-scoped (the presence lease is
+ * per project + caller).
  */
-export function getAutoCompactMode(projectRoot, sessionId) {
-    try {
-        const snap = read24hState(projectRoot, sessionId);
-        return snap.state === '24H_ACTIVE' ? 'partial' : 'standard';
-    }
-    catch {
-        return 'standard';
-    }
+export function getAutoCompactMode(projectRoot, _sessionId) {
+    return resolveAutoCompactProfile(projectRoot);
 }

package/dist/services/audit/enforcers/active-skill-resolver.d.ts

@@ -30,7 +30,9 @@ export interface ActiveSkillResolution {
     readonly sessionId: string | null;
     /**
      * Mode token recorded on the canonical lease (e.g. `full-auto`,
-     * `assisted`, `swarm`, `strict`). `null` when the source is not
+     * `assisted`, `strict`, `24h`). Normalized on read: a legacy
+     * on-disk `'swarm'` surfaces as `'full-auto'` (slice
+     * 2026-09-09-mode-consolidation). `null` when the source is not
      * `canonical` (the legacy `active-skill-*.json` files do not
      * surface a mode field, and the `env` / `none` cases are test
      * overrides). Slice 2026-08-04-rid-005 surfaced this so the

package/dist/services/audit/enforcers/active-skill-resolver.js

@@ -29,7 +29,7 @@ import { join } from 'node:path';
 import { getSessionIdCanonical } from '../../session/session-manager.js';
 import { getSessionDir } from '../../session/getSessionDir.js';
 import { readPresenceLease, listPresenceLeases } from '../../skills/presence-lease-service.js';
-import { getCurrentSessionId } from '../../skills/skill-presence-service.js';
+import { getCurrentSessionId, normalizeSkillPresenceMode } from '../../skills/skill-presence-service.js';
 const ACTIVE_SKILL_PREFIX = 'active-skill-';
 /**
  * Resolve the active peak skill for the current hook invocation.
@@ -99,7 +99,7 @@ export function resolveActiveSkillForCaller(projectRoot, opts) {
                     skill: projection.lease.skill,
                     callerId: lease.callerId,
                     sessionId,
-                    mode: typeof projection.mode === 'string' && projection.mode.length > 0 ? projection.mode : null,
+                    mode: normalizeSkillPresenceMode(typeof projection.mode === 'string' ? projection.mode : null) ?? null,
                     source: 'canonical',
                 };
             }
@@ -127,9 +127,7 @@ export function resolveActiveSkillForCaller(projectRoot, opts) {
                 const raw = readFileSync(filePath, 'utf8');
                 const parsed = JSON.parse(raw);
                 if (typeof parsed.skill === 'string' && parsed.skill.length > 0) {
-                    const legacyMode = typeof parsed.mode === 'string' && parsed.mode.length > 0
-                        ? parsed.mode
-                        : null;
+                    const legacyMode = normalizeSkillPresenceMode(typeof parsed.mode === 'string' ? parsed.mode : null) ?? null;
                     return { skill: parsed.skill, callerId, sessionId, mode: legacyMode, source: 'file' };
                 }
             }

package/dist/services/code/auto-compact-lifecycle.d.ts

@@ -76,7 +76,7 @@ export declare function summarizeLifecycleError(error: unknown): string;
  *
  * This is the integration with the actual post-compact detection path.
  * The claude-code adapter's `postCompactDetectCommand` is
- * `peaks compact auto --json` — i.e. the next probe through this very
+ * `peaks code auto-compact --json` — i.e. the next probe through this very
  * function. So when a probe finds a run still sitting at `compacting`
  * and MEASURES a ratio that has dropped below the auto-fire threshold,
  * that measurement is the proof the compact landed. Only then do we

package/dist/services/code/auto-compact-lifecycle.js

@@ -168,7 +168,7 @@ export function summarizeLifecycleError(error) {
  *
  * This is the integration with the actual post-compact detection path.
  * The claude-code adapter's `postCompactDetectCommand` is
- * `peaks compact auto --json` — i.e. the next probe through this very
+ * `peaks code auto-compact --json` — i.e. the next probe through this very
  * function. So when a probe finds a run still sitting at `compacting`
  * and MEASURES a ratio that has dropped below the auto-fire threshold,
  * that measurement is the proof the compact landed. Only then do we

package/dist/services/code/auto-compact-modes.d.ts

@@ -8,7 +8,7 @@
  *
  * Slice 2026-07-29-context-evaluation-accuracy Part 22: a new
  * `autoFire` tier is added between soft-warn and preCompact. peaks-loop
- * preempts and runs `peaks compact auto --execute` itself when
+ * preempts and runs `peaks code auto-compact` itself when
  * context crosses `autoFire`; the LLM is NOT asked to "decide"
  * (the LLM-judged 0.85–0.95 zone was the source of false-positive
  * "context too low" reports at 60%+ free — the LLM was guessing).

package/dist/services/code/auto-compact-modes.js

@@ -8,7 +8,7 @@
  *
  * Slice 2026-07-29-context-evaluation-accuracy Part 22: a new
  * `autoFire` tier is added between soft-warn and preCompact. peaks-loop
- * preempts and runs `peaks compact auto --execute` itself when
+ * preempts and runs `peaks code auto-compact` itself when
  * context crosses `autoFire`; the LLM is NOT asked to "decide"
  * (the LLM-judged 0.85–0.95 zone was the source of false-positive
  * "context too low" reports at 60%+ free — the LLM was guessing).

package/dist/services/code/auto-compact-orchestrator.js

@@ -1,7 +1,7 @@
 /**
  * Auto-compact orchestrator (v2.13.0 AC-2 + AC-3 + AC-4).
  *
- * Closes the loop between `peaks compact auto` (AC-1) and the IDE's
+ * Closes the loop between `peaks code auto-compact` (AC-1) and the IDE's
  * native compact capability (AC-3). peaks-loop is project-aware: it
  * knows the current plan, open questions, recent decisions, in-flight
  * batches, todo state, git status, and active skills. That context is
@@ -16,7 +16,7 @@
  *   3. If 0.85 ≤ ratio < 0.95 (pre-compact zone): peaks-loop prepares
  *      the convergence toolkit (checkpoint + auto-decisions log +
  *      IDE-dispatch handle) and surfaces it to the LLM. The LLM
- *      DECIDES when to fire `peaks compact auto --execute`;
+ *      DECIDES when to fire `peaks code auto-compact`;
  *      peaks-loop does NOT auto-fire. The toolkit is ready so the
  *      LLM doesn't lose context to a last-second `/compact` panic.
  *   4. If ratio < 0.85: skip — return a one-line info row.
@@ -34,7 +34,7 @@ import { getSessionIdCanonical } from '../session/session-manager.js';
 import { resolveOuterSessionId } from '../session/binding-status-service.js';
 import { AUTO_COMPACT_PRE_COMPACT_RATIO, AUTO_COMPACT_THRESHOLD_RATIO } from '../context/auto-compact-types.js';
 import { describeMode, thresholdFor } from './auto-compact-modes.js';
-import { read24hState } from '../24h-mode/store.js';
+import { resolveAutoCompactProfile } from '../mode/mode-status-service.js';
 import { CompactLifecyclePublisher, newCompactRunId, settleOpenLifecycleRun, summarizeLifecycleError } from './auto-compact-lifecycle.js';
 const PRE_COMPACT_REASON = 'pre-compact-auto';
 /**
@@ -72,7 +72,7 @@ export function evaluateCompactTrigger(ratio, mode = 'standard') {
     }
     if (ratio < preCompact) {
         // 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. Closes the
         // LLM-misjudges-context window that previously let the
@@ -255,20 +255,15 @@ function writePreCompactCheckpoint(input) {
     return path;
 }
 /**
- * Slice 2026-07-28 (rid-027): resolve the auto-compact mode from
- * 24h-mode awareness. Returns `'partial'` when the session is
- * `24H_ACTIVE`, otherwise `'standard'`. The CLI flag `--mode` takes
- * precedence (caller passes `input.mode` directly), so this helper is
- * only consulted when the flag is absent.
+ * Slice 2026-07-28 (rid-027), re-keyed by slice
+ * 2026-09-09-mode-consolidation: resolve the auto-compact mode from
+ * the PRESENCE MODE, not the 24h state machine. Returns `'partial'`
+ * when the mode is `24h`, otherwise `'standard'`. The CLI flag
+ * `--mode` takes precedence (caller passes `input.mode` directly), so
+ * this helper is only consulted when the flag is absent.
  */
-function resolveAutoCompactMode(projectRoot, sessionId) {
-    try {
-        const snap = read24hState(projectRoot, sessionId);
-        return snap.state === '24H_ACTIVE' ? 'partial' : 'standard';
-    }
-    catch {
-        return 'standard';
-    }
+function resolveAutoCompactMode(projectRoot) {
+    return resolveAutoCompactProfile(projectRoot);
 }
 /**
  * Execute the auto-compact flow.
@@ -300,9 +295,10 @@ export async function runAutoCompact(input) {
         };
     }
     // Slice 2026-07-28 (rid-027): resolve mode. CLI flag `--mode` wins;
-    // 24h-mode awareness yields 'partial' when 24h_ACTIVE; default
-    // 'standard' preserves v2.13.0 zero-pause contract.
-    const mode = input.mode ?? resolveAutoCompactMode(input.projectRoot, sessionId);
+    // slice 2026-09-09-mode-consolidation keys the default off the
+    // presence MODE ('24h' → 'partial'); 'standard' preserves the
+    // v2.13.0 zero-pause contract.
+    const mode = input.mode ?? resolveAutoCompactMode(input.projectRoot);
     // Lazy import to avoid the AC-1 module depending on the orchestrator.
     const { readContextPercent } = await import('../context/auto-compact-reader.js');
     const outerSessionId = resolveOuterSessionId(input.projectRoot, sessionId, input.env ?? process.env);
@@ -398,12 +394,12 @@ export async function runAutoCompact(input) {
             ? [
                 'RED-LINE compact dispatched — further sub-agent dispatch BLOCKED until ratio < 0.85',
                 'Post-compact resume picks up the convergence plan from auto-decisions.md',
-                'Next `peaks compact auto` probe will confirm ratio dropped below 0.85'
+                'Next `peaks code auto-compact` probe will confirm ratio dropped below 0.85'
             ]
             : [
                 'Pre-compact dispatched — IDE compact in progress (async)',
                 'Post-compact resume picks up the convergence plan from auto-decisions.md',
-                'Next `peaks compact auto` probe will confirm ratio dropped below 0.85'
+                'Next `peaks code auto-compact` probe will confirm ratio dropped below 0.85'
             ];
         plan = buildConvergencePlan({
             sessionId,

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/memory-index-reader.d.ts

@@ -1,8 +1,34 @@
 import type { MemoryIndexEntry } from '../memory/memory-search-service.js';
+/**
+ * Slice 2026-09-09-memory-retrieval: the two tiers the orchestrator
+ * preflight ranks over.
+ *
+ * - `hot`  — standing rules / feedback / decisions. Always eligible.
+ * - `warm` — project / reference memos. Injected only on task relevance.
+ *
+ * `cold` is deep storage and is deliberately NOT surfaced here.
+ */
+export interface MemoryTieredSelection {
+    hot: MemoryIndexEntry[];
+    warm: MemoryIndexEntry[];
+}
 export declare class MemoryIndexReader {
     private readonly projectRoot;
     private cache;
     constructor(projectRoot: string);
+    /**
+     * Flatten the whole index (all tiers, all buckets). Kept for
+     * back-compat with the pre-2026-09-09 callers.
+     */
     loadIfStale(): MemoryIndexEntry[];
+    /**
+     * Slice 2026-09-09-memory-retrieval: read the index as tiers.
+     *
+     * Returns `null` when `.peaks/memory/index.json` is absent or
+     * unreadable — the caller distinguishes "no index" from "index with
+     * zero entries" for its fail-soft reason code. Never throws.
+     */
+    selectTiered(): MemoryTieredSelection | null;
     selectFeedbackLayerA(cap: number): MemoryIndexEntry[];
+    private loadSnapshot;
 }