peaks-loop 4.0.25 → 4.0.27

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

@@ -1,3 +1,4 @@
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { claudeCodeSubAgentDispatcher } from '../../dispatch/sub-agent-dispatcher.js';
@@ -17,6 +18,293 @@ import { claudeCodeSubAgentDispatcher } from '../../dispatch/sub-agent-dispatche
  *
  * 不可消除的 per-IDE 字段(见 tech-doc.md §1.3)。
  */
+/**
+ * Read Claude Code's statusline state file
+ * (`~/.claude/statusline-state.json`) and parse a context-percent key.
+ * Moved from the generic reader in slice
+ * 2026-09-02-vendor-neutral-context-probe — Claude-specific paths now live
+ * only in the Claude Code adapter.
+ */
+function readClaudeStatuslinePercent() {
+    const path = join(homedir(), '.claude', 'statusline-state.json');
+    if (!existsSync(path))
+        return null;
+    try {
+        const json = JSON.parse(readFileSync(path, 'utf8'));
+        const candidates = ['contextPercent', 'context_usage_percent', 'contextPercentUsed'];
+        for (const key of candidates) {
+            const raw = json[key];
+            if (typeof raw === 'number' && Number.isFinite(raw)) {
+                return raw > 1.5 ? raw / 100 : Math.max(0, Math.min(1, raw));
+            }
+        }
+    }
+    catch (err) { // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
+        if (err instanceof ReferenceError)
+            throw err; // surface module-load bugs
+        if (err instanceof SyntaxError)
+            throw err; // surface parse bugs (e.g. broken statusline JSON)
+        return null; // only swallow IO errors
+    }
+    return null;
+}
+/**
+ * Recursive search for `<outerSessionId>.jsonl` under `projectsDir`. The
+ * Mac layout encodes the cwd as a single hash directory; on Mac Claude Code
+ * nests the transcript under that hash with an extra level of subdirectory we
+ * cannot predict ahead of time. A flat readdir misses that branch and returns
+ * null — the silent-failure mode this recursion closes.
+ *
+ * Moved from the generic reader in slice
+ * 2026-09-02-vendor-neutral-context-probe. The lookup key is the OUTER
+ * session id (Claude Code names its transcript by the outer session UUID),
+ * NOT the peaks session id.
+ */
+function findTranscriptJsonl(projectsDir, outerSessionId) {
+    if (!existsSync(projectsDir))
+        return null;
+    try {
+        const stack = [projectsDir];
+        while (stack.length > 0) {
+            const dir = stack.pop();
+            if (dir === undefined)
+                break;
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const full = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    stack.push(full);
+                }
+                else if (entry.isFile() && entry.name === `${outerSessionId}.jsonl`) {
+                    return full;
+                }
+            }
+        }
+    }
+    catch (err) { // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
+        if (err instanceof ReferenceError)
+            throw err; // surface module-load bugs
+        if (err instanceof SyntaxError)
+            throw err; // surface parse bugs
+        return null; // only swallow IO errors
+    }
+    return null;
+}
+/** 1M-context window size in tokens (documented single choice: 1,000,000). */
+const ONE_MILLION_CONTEXT_TOKENS = 1_000_000;
+/** Safe-default (non-1M) context window size in tokens. */
+const DEFAULT_CONTEXT_WINDOW_TOKENS = 200_000;
+/** Reverse-scan chunk size in bytes (keeps memory bounded on multi-MB transcripts). */
+const TRANSCRIPT_SCAN_CHUNK_BYTES = 64 * 1024;
+/**
+ * Known 1M-context Claude model id prefixes whose ids do NOT carry a `1m`
+ * suffix (e.g. `claude-sonnet-4-5-20250929`). The substring match is
+ * intentionally generous — every `claude-sonnet-4*` / `claude-opus-4*`
+ * variant is 1M-context.
+ */
+const ONE_MILLION_CONTEXT_MODELS = ['claude-opus-4', 'claude-sonnet-4'];
+/**
+ * Model-aware context-window size in tokens.
+ *
+ * Detection rule (documented):
+ *   1. Empty / unknown model → DEFAULT_CONTEXT_WINDOW_TOKENS (200_000).
+ *   2. Suffix heuristic — a model id containing `1m` (case-insensitive) is
+ *      treated as 1M-context.
+ *   3. Explicit allowlist — known 1M Claude model ids
+ *      (ONE_MILLION_CONTEXT_MODELS).
+ *   4. Everything else → 200_000 (the safe default).
+ *
+ * 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`).
+ */
+export function modelContextWindowTokens(model) {
+    const m = model.trim().toLowerCase();
+    if (m.length === 0)
+        return DEFAULT_CONTEXT_WINDOW_TOKENS;
+    if (m.includes('1m'))
+        return ONE_MILLION_CONTEXT_TOKENS;
+    for (const known of ONE_MILLION_CONTEXT_MODELS) {
+        if (m.includes(known))
+            return ONE_MILLION_CONTEXT_TOKENS;
+    }
+    return DEFAULT_CONTEXT_WINDOW_TOKENS;
+}
+/** 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)
+        return value;
+    return null;
+}
+/**
+ * Parse a single jsonl line into its token count + model id. Returns null
+ * when the line has no `message.usage` object with numeric token fields.
+ */
+function parseTranscriptUsageLine(line) {
+    if (line.length === 0)
+        return null;
+    let json;
+    try {
+        json = JSON.parse(line);
+    }
+    catch {
+        return null; // non-JSON line (blank / corrupt) — skip
+    }
+    if (typeof json !== 'object' || json === null)
+        return null;
+    const record = json;
+    const message = record.message;
+    if (typeof message !== 'object' || message === null)
+        return null;
+    const msg = message;
+    const usage = msg.usage;
+    if (typeof usage !== 'object' || usage === null)
+        return null;
+    const u = usage;
+    const inputTokens = numericTokenCount(u.input_tokens);
+    const cacheRead = numericTokenCount(u.cache_read_input_tokens);
+    const cacheCreation = numericTokenCount(u.cache_creation_input_tokens);
+    if (inputTokens === null && cacheRead === null && cacheCreation === null)
+        return null;
+    const contextTokens = (inputTokens ?? 0) + (cacheRead ?? 0) + (cacheCreation ?? 0);
+    // Model id lives at `message.model`, falling back to a top-level `model`.
+    const model = typeof msg.model === 'string'
+        ? msg.model
+        : typeof record.model === 'string' ? record.model : '';
+    return { contextTokens, model };
+}
+/**
+ * Reverse-scan the transcript jsonl (from the END) for the LATEST entry that
+ * carries a numeric `message.usage`. The file can be many MB; it is read in
+ * backward chunks of TRANSCRIPT_SCAN_CHUNK_BYTES — never fully into memory —
+ * and stops at the first (newest) usable entry.
+ */
+function findLatestTranscriptUsage(filePath) {
+    let fd = null;
+    try {
+        const size = statSync(filePath).size;
+        if (size === 0)
+            return null;
+        fd = openSync(filePath, 'r');
+        let position = size;
+        let carry = ''; // partial line head carried into the next (older) chunk
+        while (position > 0) {
+            const readLen = Math.min(TRANSCRIPT_SCAN_CHUNK_BYTES, position);
+            position -= readLen;
+            const buf = Buffer.alloc(readLen);
+            const bytesRead = readSync(fd, buf, 0, readLen, position);
+            if (bytesRead <= 0)
+                break;
+            const lines = (buf.toString('utf8', 0, bytesRead) + carry).split('\n');
+            carry = lines[0] ?? '';
+            for (let i = lines.length - 1; i >= 1; i--) {
+                const line = lines[i];
+                if (line === undefined)
+                    continue;
+                const parsed = parseTranscriptUsageLine(line);
+                if (parsed !== null)
+                    return parsed;
+            }
+        }
+        // The final carry is the first line of the file (complete, since it starts at byte 0).
+        if (carry.length > 0) {
+            const parsed = parseTranscriptUsageLine(carry);
+            if (parsed !== null)
+                return parsed;
+        }
+        return null;
+    }
+    catch (err) {
+        // Narrow: surface module-load / parse bugs, swallow IO errors only
+        // (mirrors the other adapter read helpers' catch discipline).
+        if (err instanceof ReferenceError)
+            throw err;
+        if (err instanceof SyntaxError)
+            throw err;
+        return null;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                closeSync(fd);
+            }
+            catch { /* best-effort */ }
+        }
+    }
+}
+/**
+ * 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.
+ */
+function resolveContextWindowTokens(model, contextTokens) {
+    const window = modelContextWindowTokens(model);
+    return contextTokens > window ? ONE_MILLION_CONTEXT_TOKENS : window;
+}
+/**
+ * Conservative transcript-estimate fallback. Recursively searches
+ * `~/.claude/projects/<hash>/<outerSessionId-or-nested>.jsonl` (Mac may nest
+ * the jsonl under an extra directory we cannot predict ahead of time) and
+ * estimates `ratio = contextTokens / contextWindowTokens` from the LATEST
+ * `message.usage` entry — token-based + model-aware, NOT the old
+ * `bytes / 256KB` (which over-fired because the transcript grows unboundedly).
+ * Tagged `'transcript-estimate'` (v2.14.0) so callers know it is a real
+ * signal, NOT a hard gate.
+ */
+function readClaudeTranscriptEstimate(outerSessionId) {
+    const projectsDir = join(homedir(), '.claude', 'projects');
+    const path = findTranscriptJsonl(projectsDir, outerSessionId);
+    if (path === null)
+        return null;
+    const latest = findLatestTranscriptUsage(path);
+    if (latest === null)
+        return null;
+    const contextWindowTokens = resolveContextWindowTokens(latest.model, latest.contextTokens);
+    const ratio = Math.min(1, latest.contextTokens / contextWindowTokens);
+    return { ratio, contextTokens: latest.contextTokens, contextWindowTokens };
+}
+/**
+ * Claude Code's vendor-specific context-percent fallback, exposed as
+ * `IdeCompactProfile.readContextPercentFallback`. The generic reader calls
+ * this only when the primary env-var probe misses; only the adapter knows the
+ * Claude-specific statusline + transcript paths. Resolution order:
+ *   1. statusline poll (`~/.claude/statusline-state.json`)
+ *   2. transcript estimate — looks up `<outerSessionId>.jsonl` under
+ *      `~/.claude/projects/<hash>/...` using the OUTER session id (Claude
+ *      names its transcript by the outer session UUID, not the peaks sid),
+ *      and estimates `contextTokens / contextWindowTokens` from the LATEST
+ *      `message.usage` entry (token-based + model-aware).
+ * Returns `null` when neither yields a signal → the reader emits
+ * `conservative-fallback`.
+ */
+function readContextPercentFallback(input) {
+    const capturedAt = new Date().toISOString();
+    // Byte-based capacity is carried only for the percent path (statusline-poll
+    // returns a 0..1 ratio; capacityBytes is metadata there). The
+    // transcript-estimate path is token-based and surfaces `capacityTokens`
+    // (the model window) instead — see readClaudeTranscriptEstimate.
+    const capacityBytes = 256 * 1024;
+    const ide = 'claude-code';
+    const statusline = readClaudeStatuslinePercent();
+    if (statusline !== null) {
+        return { ratio: statusline, source: 'statusline-poll', capacityBytes, ide, capturedAt };
+    }
+    if (typeof input.outerSessionId === 'string' && input.outerSessionId.length > 0) {
+        const estimate = readClaudeTranscriptEstimate(input.outerSessionId);
+        if (estimate !== null) {
+            return {
+                ratio: estimate.ratio,
+                source: 'transcript-estimate',
+                rawTokens: estimate.contextTokens,
+                capacityTokens: estimate.contextWindowTokens,
+                ide,
+                capturedAt
+            };
+        }
+    }
+    return null;
+}
 export const CLAUDE_CODE_ADAPTER = {
     id: 'claude-code',
     displayName: 'Claude Code',
@@ -71,7 +359,8 @@ export const CLAUDE_CODE_ADAPTER = {
         envVarForContextPercent: 'CLAUDE_CONTEXT_USAGE_PERCENT',
         compactCommand: 'claude --compact',
         compactPathway: 'ide-native',
-        postCompactDetectCommand: 'peaks compact auto --json'
+        postCompactDetectCommand: 'peaks compact auto --json',
+        readContextPercentFallback
     },
     // Slice #011: standards profile. Claude Code reads its constitution at
     // CLAUDE.md + module-level rules under .claude/rules/**. The values mirror

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

@@ -12,6 +12,7 @@
  * 其他全部归一化到 peaks 内部模型(见 hook-protocol.ts)。
  */
 import type { SubAgentDispatcher } from '../dispatch/sub-agent-dispatcher.js';
+import type { ContextPercentProbe } from '../context/auto-compact-types.js';
 export type IdeId = 'claude-code' | 'trae' | 'codex' | 'cursor' | 'qoder' | 'tongyi-lingma' | 'hermes' | 'openclaw' | 'zcode';
 export interface IdeCapabilities {
     /** peaks gate enforce 是否适用该 IDE(必备) */
@@ -200,6 +201,44 @@ export interface IdeCompactProfile {
      * the orchestrator polls `envVarForContextPercent` directly.
      */
     readonly postCompactDetectCommand?: string;
+    /**
+     * Optional vendor-specific fallback the generic `readContextPercent`
+     * reader calls when the primary env-var probe misses. Returns a
+     * completed `ContextPercentProbe` (e.g. `statusline-poll` /
+     * `transcript-estimate`) or `null` when the adapter has no signal —
+     * the reader then falls through to `conservative-fallback`.
+     *
+     * Keeps IDE-specific filesystem / env knowledge (Claude Code's
+     * `~/.claude/statusline-state.json` + `~/.claude/projects` transcript
+     * layout, etc.) inside the adapter, not the generic reader. Adapters
+     * that do not opt in simply omit the field; new IDEs are addable
+     * without touching the generic reader.
+     *
+     * Added in slice 2026-09-02-vendor-neutral-context-probe.
+     */
+    readonly readContextPercentFallback?: (input: ContextPercentFallbackInput) => ContextPercentProbe | null;
+}
+/**
+ * Input the generic `readContextPercent` reader passes to an adapter's
+ * optional `IdeCompactProfile.readContextPercentFallback` hook. The adapter
+ * owns the vendor-specific fallback logic (statusline poll, transcript
+ * lookup, etc.); the generic reader stays IDE-agnostic.
+ *
+ * Added in slice 2026-09-02-vendor-neutral-context-probe.
+ */
+export interface ContextPercentFallbackInput {
+    /** Project root (the probe's `--project` anchor). */
+    readonly projectRoot: string;
+    /** Peaks session id (NOT the harness / IDE transcript id). */
+    readonly sessionId: string;
+    /**
+     * Outer (harness / IDE) session id — the id the IDE uses to name its
+     * transcript / session files (e.g. a UUID). Optional: when unresolved,
+     * adapters whose fallback depends on it should return `null`.
+     */
+    readonly outerSessionId?: string | undefined;
+    /** Injectable env (defaults to process.env in the reader). */
+    readonly env?: NodeJS.ProcessEnv | undefined;
 }
 /**
  * Per-IDE standards-file location + format profile. Used by the

package/dist/services/memory/llm-reranker.d.ts

@@ -35,10 +35,9 @@
  *
  * Why 4-bytes-per-token:
  *
- *   - `headroom-client.ts:60` already uses `BYTES_PER_TOKEN = 4` as
- *     its rough English-text approximation. Reusing the same constant
- *     keeps token estimates comparable across the headroom + rerank
- *     pipelines in the AC-ZA-5 benchmark.
+ *   - `BYTES_PER_TOKEN = 4` is the standard rough English-text
+ *     approximation (1 token ≈ 4 bytes). It keeps token estimates
+ *     stable and comparable in the AC-ZA-5 benchmark.
  *
  * Out of scope (YAGNI per Karpathy #2 Simplicity First):
  *
@@ -112,7 +111,7 @@ export interface RerankResult {
 }
 /**
  * Estimate token count for a string. `1 token ≈ 4 bytes` for English
- * text — same approximation as `headroom-client.ts:60`.
+ * text (standard rough approximation).
  */
 export declare function estimateTokens(text: string): number;
 /**

package/dist/services/memory/llm-reranker.js

@@ -35,10 +35,9 @@
  *
  * Why 4-bytes-per-token:
  *
- *   - `headroom-client.ts:60` already uses `BYTES_PER_TOKEN = 4` as
- *     its rough English-text approximation. Reusing the same constant
- *     keeps token estimates comparable across the headroom + rerank
- *     pipelines in the AC-ZA-5 benchmark.
+ *   - `BYTES_PER_TOKEN = 4` is the standard rough English-text
+ *     approximation (1 token ≈ 4 bytes). It keeps token estimates
+ *     stable and comparable in the AC-ZA-5 benchmark.
  *
  * Out of scope (YAGNI per Karpathy #2 Simplicity First):
  *
@@ -49,9 +48,8 @@
  *   - No integration with `memory-search-service.ts` (Z-A is a spike;
  *     the wiring into `peaks memory search` is Z-B).
  */
-// Approximate 1 token = 4 bytes for English text. Matches
-// `headroom-client.ts:60` so the AC-ZA-5 benchmark can compare
-// rerank input cost against headroom compressed cost directly.
+// Approximate 1 token = 4 bytes for English text. Standard rough
+// approximation used across the pipeline (AC-ZA-5 benchmark).
 const BYTES_PER_TOKEN = 4;
 // Hard caps so a pathological query / 60-candidate list cannot blow
 // up the LLM prompt. These are conservative defaults; Z-B may tune.
@@ -62,7 +60,7 @@ const MAX_DESCRIPTION_CHARS = 240;
 const DEFAULT_CHAT_TIMEOUT_MS = 5_000;
 /**
  * Estimate token count for a string. `1 token ≈ 4 bytes` for English
- * text — same approximation as `headroom-client.ts:60`.
+ * text (standard rough approximation).
  */
 export function estimateTokens(text) {
     return Math.ceil(Buffer.byteLength(text, 'utf8') / BYTES_PER_TOKEN);

package/dist/services/memory/memory-search-service.d.ts

@@ -59,35 +59,3 @@ export declare function loadMemoryIndex(projectRoot: string): MemoryIndexSnapsho
  * spec §Component Details).
  */
 export declare function searchMemory(input: MemorySearchInput): MemorySearchResult[];
-/**
- * Envelope for the optional headroom-compressed version of the search
- * result text. The compressed text is intended for the LLM-side prompt
- * (it preserves the entry names + descriptions in a more token-efficient
- * form); the structured `matches` array is unchanged and remains the
- * machine-readable form. `null` when compression was not requested,
- * did not run, or failed (see `warning` for the reason).
- */
-export interface CompressedResultsEnvelope {
-    readonly mode: 'balanced' | 'aggressive' | 'conservative';
-    readonly originalSize: number;
-    readonly compressedSize: number;
-    readonly compressionRatio: number;
-    readonly compressedText: string;
-    readonly warning: string | null;
-}
-export interface MemorySearchWithResults {
-    readonly matches: MemorySearchResult[];
-    readonly compressedResults: CompressedResultsEnvelope | null;
-}
-export interface MemorySearchOptions {
-    /** When true, read preferences.headroom.perTouchpoint.memorySearch and
-     *  compress joined match text via headroom-ai. Falls back silently to
-     *  the structured `matches` array when compression is unavailable. */
-    readonly compressResults?: boolean;
-}
-/**
- * Run the search + optionally compress the joined match text via headroom.
- * The structured `matches` array is the canonical output. The
- * `compressedResults` is a derived view for LLM-side prompt assembly.
- */
-export declare function searchMemoryWithResults(input: MemorySearchInput, options?: MemorySearchOptions): Promise<MemorySearchWithResults>;

package/dist/services/memory/memory-search-service.js

@@ -1,9 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { fuzzyMatchWithKey } from '../fuzzy-matching/fuzzy-match-service.js';
-import { compressPrompt } from '../context/headroom-client.js';
-import { loadPreferences } from '../preferences/preferences-service.js';
-import { shouldCompressResults } from '../context/headroom-prefs.js';
 const DEFAULT_LIMIT = 6;
 /**
  * Read `.peaks/memory/index.json` and flatten the on-disk `hot[<kind>][]`
@@ -81,37 +78,3 @@ export function searchMemory(input) {
         };
     });
 }
-/**
- * Run the search + optionally compress the joined match text via headroom.
- * The structured `matches` array is the canonical output. The
- * `compressedResults` is a derived view for LLM-side prompt assembly.
- */
-export async function searchMemoryWithResults(input, options = {}) {
-    const matches = searchMemory(input);
-    if (options.compressResults !== true) {
-        return { matches, compressedResults: null };
-    }
-    const projectRoot = input.projectRoot ?? process.cwd();
-    const prefs = loadPreferences(projectRoot).headroom;
-    const joinedText = matches.map((m) => `${m.name}: ${m.description}`).join('\n');
-    const joinedBytes = Buffer.byteLength(joinedText, 'utf8');
-    const decision = shouldCompressResults(prefs, joinedBytes, 'memorySearch');
-    if (!decision.compress) {
-        return { matches, compressedResults: null };
-    }
-    const result = await compressPrompt(joinedText, decision.mode);
-    if (result.warning !== null || result.compressedPrompt === null) {
-        return { matches, compressedResults: null };
-    }
-    return {
-        matches,
-        compressedResults: {
-            mode: decision.mode,
-            originalSize: result.originalSize,
-            compressedSize: result.compressedSize,
-            compressionRatio: result.compressionRatio,
-            compressedText: result.compressedPrompt,
-            warning: result.warning
-        }
-    };
-}

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

@@ -16,14 +16,11 @@ export declare function writeAtomic(filePath: string, prefs: ProjectPreferences)
  * current shape. Returns the migrated object + a list of changes
  * applied (for surfacing in the CLI envelope and the migration log).
  *
- * The v1 → v2 mapping fills in the `headroom.perTouchpoint` sub-keys
- * that v1 didn't track: each touchpoint gets the v1 `headroom.defaultMode`
- * (or 'balanced' if absent), and `compressMinBytes` is preserved
- * verbatim. v1's `agentShieldPrompt` and `loopAutonomousEnabled` were
- * already present, so they carry through unchanged. The `fanout` field
- * is new in v2 — it defaults to `{ defaultMode: 'fan-out' }` so the
- * pre-v2 behavior (peak-code SKILL instructed fan-out when ≥ 2 leaves)
- * is preserved.
+ * v1's `agentShieldPrompt` and `loopAutonomousEnabled` were already
+ * present, so they carry through unchanged. The `fanout` field is new
+ * in v2 — it defaults to `{ defaultMode: 'fan-out' }` so the pre-v2
+ * behavior (peak-code SKILL instructed fan-out when ≥ 2 leaves) is
+ * preserved.
  */
 export type MigrateResult = {
     readonly fromVersion: string;

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

@@ -135,25 +135,6 @@ export function migratePreferences(projectRoot, opts = {}) {
         };
     }
     const changes = [];
-    // v1 → v2: headroom.perTouchpoint fill-in (v1 only had defaultMode).
-    const headroomRaw = (raw.headroom ?? {});
-    const defaultMode = isHeadroomModeString(headroomRaw.defaultMode)
-        ? headroomRaw.defaultMode
-        : 'balanced';
-    const perTouchpoint = {
-        subAgentDispatch: defaultMode,
-        memorySearch: defaultMode,
-        retrospectiveSearch: defaultMode,
-        doctorScan: defaultMode,
-        doctorRoute: 'conservative'
-    };
-    changes.push(`headroom.perTouchpoint filled in with defaultMode='${defaultMode}' (v1 lacked per-touchpoint overrides)`);
-    if (typeof headroomRaw.compressMinBytes === 'number') {
-        changes.push(`headroom.compressMinBytes preserved at ${headroomRaw.compressMinBytes}`);
-    }
-    else {
-        changes.push(`headroom.compressMinBytes defaulted to 4096`);
-    }
     // v1 → v2: fanout block was absent; v2 needs it. Default to the
     // pre-v2 behavior (fan-out when ≥ 2 leaves).
     if (raw.fanout === undefined) {
@@ -176,14 +157,6 @@ export function migratePreferences(projectRoot, opts = {}) {
     // fully-valid v2 ProjectPreferences.
     const migrated = mergePreferences(DEFAULT_PREFERENCES, {
         ...raw,
-        headroom: {
-            enabled: typeof headroomRaw.enabled === 'boolean' ? headroomRaw.enabled : true,
-            defaultMode,
-            perTouchpoint,
-            compressMinBytes: typeof headroomRaw.compressMinBytes === 'number'
-                ? headroomRaw.compressMinBytes
-                : 4096
-        },
         fanout: typeof raw.fanout === 'object' && raw.fanout !== null && !Array.isArray(raw.fanout)
             ? (raw.fanout.defaultMode === 'serial'
                 ? { defaultMode: 'fan-out' }
@@ -203,6 +176,3 @@ export function migratePreferences(projectRoot, opts = {}) {
         written
     };
 }
-function isHeadroomModeString(value) {
-    return value === 'balanced' || value === 'aggressive' || value === 'conservative';
-}

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

@@ -22,27 +22,6 @@ export type UaPromptDecision = 'unset' | 'skip-this-session' | 'skip-forever';
  *   - 'lax'      — always downgrade to previous level (faster, riskier)
  */
 export type ClassifyConservatism = 'default' | 'strict' | 'lax';
-/**
- * Per-touchpoint headroom-AI mode override.
- * Spec §7.4 — default 'balanced'.
- */
-export type HeadroomMode = 'balanced' | 'aggressive' | 'conservative';
-export interface HeadroomPreferences {
-    /** Whether headroom integration is enabled globally. Default: true */
-    readonly enabled: boolean;
-    /** Default mode if a touchpoint doesn't override. Default: 'balanced' */
-    readonly defaultMode: HeadroomMode;
-    /** Per-touchpoint mode overrides */
-    readonly perTouchpoint: {
-        subAgentDispatch: HeadroomMode;
-        memorySearch: HeadroomMode;
-        retrospectiveSearch: HeadroomMode;
-        doctorScan: HeadroomMode;
-        doctorRoute: HeadroomMode;
-    };
-    /** Minimum joined-result byte count before search-touchpoint compression runs. Default: 4096. */
-    readonly compressMinBytes: number;
-}
 export interface ClassifyRuleOverrides {
     /** File count threshold above which a task is promoted to 'feature' */
     readonly feature_threshold_files?: number;
@@ -101,7 +80,6 @@ export interface ProjectPreferences {
     readonly agentShieldPrompt: UaPromptDecision;
     readonly classifyConservatism: ClassifyConservatism;
     readonly classifyRules: ClassifyRuleOverrides;
-    readonly headroom: HeadroomPreferences;
     readonly swarmSpeculative: SwarmSpeculativePreferences;
     /** Loop Autonomous (L4 14.5) toggle. Default: false — never auto-enable. */
     readonly loopAutonomousEnabled: boolean;

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

@@ -28,18 +28,6 @@ export const DEFAULT_PREFERENCES = {
         feature_threshold_lines: 100,
         runtime_clean_grace_hours: 24,
     },
-    headroom: {
-        enabled: true,
-        defaultMode: 'balanced',
-        perTouchpoint: {
-            subAgentDispatch: 'balanced',
-            memorySearch: 'balanced',
-            retrospectiveSearch: 'balanced',
-            doctorScan: 'balanced',
-            doctorRoute: 'conservative',
-        },
-        compressMinBytes: 4096,
-    },
     swarmSpeculative: {
         enabled: true,
         maxConcurrent: 3,

package/dist/services/retrospective/retrospective-search-service.d.ts

@@ -35,21 +35,3 @@ export interface RetrospectiveSearchResult {
  * runs (cheaper to filter, then fuzzy on a smaller set).
  */
 export declare function searchRetrospective(input: RetrospectiveSearchInput): RetrospectiveSearchResult[];
-export interface CompressedRetrospectiveResultsEnvelope {
-    readonly mode: 'balanced' | 'aggressive' | 'conservative';
-    readonly originalSize: number;
-    readonly compressedSize: number;
-    readonly compressionRatio: number;
-    readonly compressedText: string;
-    readonly warning: string | null;
-}
-export interface RetrospectiveSearchWithResults {
-    readonly matches: RetrospectiveSearchResult[];
-    readonly compressedResults: CompressedRetrospectiveResultsEnvelope | null;
-}
-export interface RetrospectiveSearchOptions {
-    /** When true, compress joined match text via headroom-ai. Falls back
-     *  silently to the structured `matches` array on failure. */
-    readonly compressResults?: boolean;
-}
-export declare function searchRetrospectiveWithResults(input: RetrospectiveSearchInput, options?: RetrospectiveSearchOptions): Promise<RetrospectiveSearchWithResults>;