one-code-extension 0.4.1 → 0.6.0

package/extensions/compaction/kept-thinking.ts

@@ -0,0 +1,62 @@
+/**
+ * Thinking removed from the turns a compaction keeps. Pure: no pi imports.
+ *
+ * On Fable 5.1, Opus 5.5 and Sonnet 5.5 a signed thinking block is bound to
+ * the conversation before it, and a compaction rewrites that conversation:
+ * the kept reply's thinking fails the check on every later request (a 400 on
+ * accounts created from 2026-08-31; dropped silently under pi-ai 0.99.2's
+ * `drop_block`; findings §46). Blocks may be removed from the start, so the
+ * kept turns go out without theirs, from the first request after the
+ * compaction on, the same bytes every time. Thinking produced after the
+ * compaction binds to that stripped history and stays.
+ *
+ * The kept turns are the assistant messages older than the latest compaction
+ * entry on the session branch (`lib/compaction-boundary.ts`): every message
+ * produced since is newer. Text and tool calls stay.
+ */
+
+/** APIs whose replayed thinking carries a signature the provider checks (pi-ai's converters). */
+const SIGNED_THINKING_APIS = new Set(["anthropic-messages", "bedrock-converse-stream"]);
+
+type ContextMessage = { role: string; timestamp?: number; content?: unknown };
+
+/**
+ * The messages with every thinking block (redacted ones included) removed from
+ * assistant messages older than `compactionTime`, or undefined when nothing
+ * changes: another API, no compaction, or no kept thinking. An assistant
+ * message left empty is skipped by pi-ai's converter, as any empty one is.
+ */
+export function withoutKeptThinking<M extends ContextMessage>(
+	messages: readonly M[],
+	api: string | undefined,
+	compactionTime: number | undefined,
+): M[] | undefined {
+	if (!signsThinking(api) || compactionTime === undefined || Number.isNaN(compactionTime)) return undefined;
+	return stripThinking(messages, (message) => typeof message.timestamp === "number" && message.timestamp < compactionTime);
+}
+
+/**
+ * The messages with every assistant message's thinking removed, for a request
+ * whose system prompt and tools are not the session's (the standalone
+ * compaction request): none of its signed blocks would pass the check. The
+ * messages unchanged on other APIs.
+ */
+export function withoutThinking<M extends ContextMessage>(messages: M[], api: string | undefined): M[] {
+	return (signsThinking(api) && stripThinking(messages, () => true)) || messages;
+}
+
+/** Whether requests on `api` carry signed thinking the provider checks. */
+export const signsThinking = (api: string | undefined): boolean => api !== undefined && SIGNED_THINKING_APIS.has(api);
+
+/** The messages with thinking removed from the assistant messages `applies` picks, or undefined when none had any. Copies only on a change. */
+function stripThinking<M extends ContextMessage>(messages: readonly M[], applies: (message: M) => boolean): M[] | undefined {
+	let result: M[] | undefined;
+	messages.forEach((message, i) => {
+		if (message.role !== "assistant" || !Array.isArray(message.content) || !message.content.some(isThinking) || !applies(message)) return;
+		result ??= messages.slice();
+		result[i] = { ...message, content: message.content.filter((block) => !isThinking(block)) };
+	});
+	return result;
+}
+
+const isThinking = (block: unknown): boolean => (block as { type?: unknown } | null)?.type === "thinking";

package/extensions/compaction/prompt.ts

@@ -4,15 +4,17 @@
  * COMPACTION_INSTRUCTION matches Claude Code's: appended as a user text block
  * after the full conversation, the model answers with an <analysis> block
  * followed by a <summary> block, and only the <summary> content becomes the
- * surviving context. Auto-compaction uses the same prompt.
+ * surviving context. Auto-compaction uses the same prompt. Two lines end in a
+ * space, as Claude Code's do; they are written `\x20` so editors keep them.
  *
  * Claude Code runs the call on the *session's own model* with max_tokens
- * 32000, keeping the system prompt, tools, and message prefix intact — so the
- * provider prompt cache pays for most of the compaction call. The extension
- * does the same.
+ * 128000 (findings §47), keeping the system prompt, tools, and message
+ * prefix intact — so the provider prompt cache pays for most of the compaction
+ * call. The extension does the same; the cap is lowered to the model's output
+ * limit and to the room the context window leaves.
  */
 
-export const COMPACTION_MAX_TOKENS = 32_000;
+export const COMPACTION_MAX_TOKENS = 128_000;
 
 export const COMPACTION_INSTRUCTION = `CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.
 
@@ -87,7 +89,7 @@ Here's an example of how your output should be structured:
 5. Problem Solving:
    [Description of solved problems and ongoing troubleshooting]
 
-6. All user messages:
+6. All user messages:\x20
     - [Detailed non tool use user message]
     - [...]
 
@@ -105,7 +107,7 @@ Here's an example of how your output should be structured:
 </summary>
 </example>
 
-Please provide your summary based on the conversation so far, following this structure and ensuring precision and thoroughness in your response.
+Please provide your summary based on the conversation so far, following this structure and ensuring precision and thoroughness in your response.\x20
 
 There may be additional summarization instructions provided in the included context. If so, remember to follow these instructions when creating the above summary. Examples of instructions include:
 <example>
@@ -138,7 +140,7 @@ export function buildCompactionInstruction(options: {
 	 * says so, so the summary covers the part that is actually discarded
 	 * instead of re-telling what the model will still see in full.
 	 */
-	keptTail?: { count: number; opening?: string };
+	keptTail?: { count: number; landmark?: string };
 }): string {
 	const notice =
 		options.reason === "manual"
@@ -155,11 +157,12 @@ export function buildCompactionInstruction(options: {
 
 /**
  * The scope note for pi's kept tail: the summary replaces only what precedes
- * it. Quoting how the first kept message opens gives the model a landmark it
- * can find in the transcript, since a bare count is easy to miscount.
+ * it. Naming the first kept message (how it opens, or the tool it calls) gives
+ * the model a landmark it can find in the transcript, since a bare count is
+ * easy to miscount.
  */
-export function keptTailNote(tail: { count: number; opening?: string }): string {
-	const landmark = tail.opening?.trim() ? `, beginning with the message that opens "${tail.opening.trim()}"` : "";
+export function keptTailNote(tail: { count: number; landmark?: string }): string {
+	const landmark = tail.landmark?.trim() ? `, beginning with ${tail.landmark.trim()}` : "";
 	return ` Only the earlier part of the conversation is being summarized: the final ${tail.count} ${
 		tail.count === 1 ? "message" : "messages"
 	}${landmark}, stay in context verbatim after the summary. Do not summarize them; cover everything before them, and use them only to judge which earlier details still matter.`;

package/extensions/context-budget/budget.ts

@@ -32,17 +32,31 @@ function finite(n: number | null | undefined): number | undefined {
  * from; `left` takes the size now and returns what remains of the budget. The
  * value never rises within a turn (as CC's does not), the first known size
  * becomes the baseline when the turn started without an estimate, and an
- * unknown size repeats the last value.
+ * unknown size repeats the last value. A compaction inside the turn shrinks
+ * the context below the baseline, so `rebase` measures growth from the
+ * smaller context on top of what the turn had already spent; without it the
+ * countdown stood still until the context regrew past the turn's start.
  */
 export class TurnBudget {
 	private start: number | undefined;
+	/** Spent since `start`. */
 	private spent = 0;
+	/** Spent before the last rebase. */
+	private banked = 0;
 
 	constructor(readonly budget: number) {}
 
 	startTurn(contextTokens: number | null | undefined): void {
 		this.start = finite(contextTokens);
 		this.spent = 0;
+		this.banked = 0;
+	}
+
+	/** Measure from `contextTokens` (or the next known size) on, keeping what the turn spent so far. */
+	rebase(contextTokens: number | null | undefined): void {
+		this.banked += this.spent;
+		this.spent = 0;
+		this.start = finite(contextTokens);
 	}
 
 	left(contextTokens: number | null | undefined): number {
@@ -51,7 +65,7 @@ export class TurnBudget {
 			if (this.start === undefined) this.start = now;
 			this.spent = Math.max(this.spent, now - this.start);
 		}
-		return Math.max(0, this.budget - this.spent);
+		return Math.max(0, this.budget - this.banked - this.spent);
 	}
 }
 

package/extensions/context-budget/index.ts

@@ -1,31 +1,37 @@
 /**
  * context-budget extension — Claude Code's `<total_tokens>N tokens left</total_tokens>`
- * line, in the three places CC puts it (budget.ts says what the number is):
+ * line, in the places CC puts it (budget.ts says what the number is). It
+ * stores the line in One Code's own way; system-reminder's payload hook turns
+ * the stored line into Claude Code's per-model shapes on the wire
+ * (lib/turn-budget-layout.ts):
  *
- * - the end of every user message: the constant budget, a raw `sticky-append`
- *   reminder keyed once per session (`since: 0`, so a resumed session's earlier
- *   user messages carry it too — byte-identical to what they carried before);
+ * - the first prompt: the constant budget in the first-message context stack
+ *   (CONTEXT_ORDER.totalTokens), so it joins the mid-conversation system
+ *   message where there is one;
+ * - every later user message: the constant budget as a raw marker, a `sticky-append`
+ *   reminder keyed once per session (`since: 0`: every user message a request
+ *   sends carries it, the first prompt excepted);
  * - every tool result: the countdown, a RAW `last-append` one-shot queued at
- *   `tool_result` time and written into the stored result by system-reminder
- *   (so it persists in the session like CC's and no later request re-caches the
- *   message). That is why this extension sits BEFORE `system-reminder` in the
- *   package manifest — pi runs `tool_result` handlers in load order, and the
- *   block must be queued before system-reminder's handler takes the one-shots.
- *   It emits only at runtime, never at load, so the "listeners load first" rule
- *   for the bus is not at stake;
+ *   `tool_result` time and bound to its call's id, so it rides that result on
+ *   the next request (pi runs a parallel batch's `tool_result` hooks
+ *   concurrently; unbound, every countdown would land on the batch's last
+ *   result). The request that carries it records it (extensions/ledger), so no
+ *   later request re-renders it;
  * - the system prompt, before the gitStatus block — appended by the
  *   system-prompt extension from the same pure module.
  *
  * A turn starts at the first `agent_start` after a settle (whoever opened it: a
  * prompt or a harness notification) and its baseline is pi's context estimate
- * at that moment. CC_TOTAL_TOKENS=0 turns all three off.
+ * at that moment; a compaction rebases it (budget.ts). CC_TOTAL_TOKENS=0 turns
+ * all three off.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { REMINDER_CHANNEL, type ReminderPayload } from "../lib/reminders.ts";
+import { CONTEXT_ORDER, REMINDER_CHANNEL, type ReminderPayload } from "../lib/reminders.ts";
 import { totalTokensBlock, TurnBudget, turnTokenBudget } from "./budget.ts";
 
 const USER_MESSAGE_KEY = "total-tokens";
+const FIRST_PROMPT_KEY = "total-tokens-first";
 
 export default function contextBudgetExtension(pi: ExtensionAPI) {
 	const enabled = () => process.env.CC_TOTAL_TOKENS !== "0";
@@ -38,11 +44,18 @@ export default function contextBudgetExtension(pi: ExtensionAPI) {
 		if (!enabled()) return;
 		pi.events.emit(REMINDER_CHANNEL, {
 			text: totalTokensBlock(budget.budget),
-			scope: "every-turn",
+			key: FIRST_PROMPT_KEY,
+			placement: "first-prepend",
+			order: CONTEXT_ORDER.totalTokens,
+		} satisfies ReminderPayload);
+		pi.events.emit(REMINDER_CHANNEL, {
+			text: totalTokensBlock(budget.budget),
 			key: USER_MESSAGE_KEY,
 			placement: "sticky-append",
 			raw: true,
 			since: 0,
+			// The first prompt carries the line in the context stack instead.
+			skipStackCarrier: true,
 		} satisfies ReminderPayload);
 	});
 
@@ -54,13 +67,20 @@ export default function contextBudgetExtension(pi: ExtensionAPI) {
 	pi.on("agent_settled", () => {
 		busy = false;
 	});
+	// A compaction (an auto one mid-turn, an overflow retry) drops the context
+	// below the turn's baseline; pi knows its new size only after the next reply,
+	// so the first size it reports becomes the baseline.
+	pi.on("session_compact", (_event, ctx) => {
+		budget.rebase(ctx.getContextUsage()?.tokens);
+	});
 
-	pi.on("tool_result", (_event, ctx) => {
+	pi.on("tool_result", (event, ctx) => {
 		if (!enabled()) return;
 		pi.events.emit(REMINDER_CHANNEL, {
 			text: totalTokensBlock(budget.left(ctx.getContextUsage()?.tokens)),
 			placement: "last-append",
 			raw: true,
+			toolCallId: event.toolCallId,
 		} satisfies ReminderPayload);
 	});
 }

package/extensions/context-management/index.ts

@@ -38,9 +38,8 @@
  * for an anthropic-messages endpoint you have confirmed accepts it.
  */
 
-import { readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { type ExtensionAPI, getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isAnthropicOAuth } from "../lib/anthropic-auth.ts";
 import { looksLikeAnthropicRequest } from "../lib/anthropic-payload.ts";
 import { CACHE_RETENTION_ENV, mainSessionCacheRetention } from "../lib/cache-retention.ts";
 
@@ -59,11 +58,20 @@ const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
 // "fallbacks: Extra inputs are not permitted" (verified live, api.anthropic.com
 // 2026-09-01). Mirrors pi's shouldUseServerSideFallbackBeta.
 const SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
+// The same trap for models whose compat carries `supportsMidConvoEffort` (Opus 5,
+// Opus 5.5, Fable 5.1): pi inserts `role: "system"` messages holding an
+// `output_config`, and without these two betas the API 400s with
+// "messages.1.output_config: Extra inputs are not permitted" (verified live,
+// 2026-09-23). `test/unit/context-management.test.ts` fails when the installed
+// pi-ai declares a beta this list does not account for.
+const MID_CONVERSATION_OUTPUT_CONFIG_BETA = "mid-conversation-output-config-2026-07-01";
+const THINKING_BINDING_CONTROLS_BETA = "thinking-binding-controls-2026-08-01";
 
 export interface AnthropicModelCompat {
 	forceAdaptiveThinking?: boolean;
 	supportsEagerToolInputStreaming?: boolean;
 	allowedFallbackModels?: unknown[];
+	supportsMidConvoEffort?: boolean;
 }
 
 /** pi's beta list for this model/auth, with the context-management beta appended. */
@@ -75,6 +83,7 @@ export function anthropicBetas(oauth: boolean, compat: AnthropicModelCompat | un
 	if (compat?.forceAdaptiveThinking !== true) betas.push(INTERLEAVED_THINKING_BETA);
 	// pi puts a `fallbacks` body field on these models; the beta must ride along.
 	if ((compat?.allowedFallbackModels?.length ?? 0) > 0) betas.push(SERVER_SIDE_FALLBACK_BETA);
+	if (compat?.supportsMidConvoEffort === true) betas.push(MID_CONVERSATION_OUTPUT_CONFIG_BETA, THINKING_BINDING_CONTROLS_BETA);
 	betas.push(CONTEXT_MANAGEMENT_BETA);
 	return betas.join(",");
 }
@@ -83,9 +92,16 @@ export function anthropicBetas(oauth: boolean, compat: AnthropicModelCompat | un
 // tool-search); re-exported so existing importers keep working.
 export { looksLikeAnthropicRequest } from "../lib/anthropic-payload.ts";
 
-/** The edit is rejected unless thinking is enabled or the model is adaptive. */
+/**
+ * The edit is rejected unless thinking is on: enabled or adaptive in the
+ * request, or left to an adaptive model's default. A request that turns
+ * thinking off (`{ type: "disabled" }`, "off" effort on Opus 5 and Haiku 5.5)
+ * takes no edit, adaptive model or not (round-2 review H3).
+ */
 export function clearThinkingApplies(payload: Record<string, unknown>, forceAdaptiveThinking: boolean): boolean {
-	return payload.thinking !== undefined || forceAdaptiveThinking;
+	const type = (payload.thinking as { type?: unknown } | undefined)?.type;
+	if (type === undefined) return payload.thinking === undefined && forceAdaptiveThinking;
+	return type === "enabled" || type === "adaptive";
 }
 
 export function withClearThinking(payload: Record<string, unknown>): Record<string, unknown> {
@@ -99,29 +115,6 @@ export function withClearThinking(payload: Record<string, unknown>): Record<stri
 	};
 }
 
-/** mtime cache: this runs on every provider request, the hottest path there is. */
-let authCache: { mtimeMs: number; oauth: boolean } | undefined;
-
-/** OAuth logins need pi's identity betas kept in the header we overwrite. */
-export function isAnthropicOAuth(): boolean {
-	// getAgentDir() honours PI_CODING_AGENT_DIR, so an isolated one-code app
-	// reads its own auth.json rather than ~/.pi's.
-	const path = join(getAgentDir(), "auth.json");
-	try {
-		const mtimeMs = statSync(path).mtimeMs;
-		const cached = authCache;
-		if (cached && cached.mtimeMs === mtimeMs) return cached.oauth;
-		const auth = JSON.parse(readFileSync(path, "utf8"));
-		const entry = auth?.anthropic;
-		const oauth = entry?.type === "oauth" || typeof entry?.refresh === "string";
-		authCache = { mtimeMs, oauth };
-		return oauth;
-	} catch {
-		authCache = undefined;
-		return false;
-	}
-}
-
 interface AnthropicishModel {
 	api?: string;
 	provider?: string;
@@ -141,6 +134,21 @@ export function clearThinkingEnabled(flag: string | undefined, model: Anthropici
 	return model.provider === "anthropic" && (model.baseUrl ?? "").includes("api.anthropic.com");
 }
 
+/**
+ * The headers a side call on the session model needs so its request matches the
+ * session's: the auth headers plus, where clear_thinking is on, the beta header
+ * the session's requests carry (completeSimple bypasses our header hook).
+ */
+export function sessionRequestHeaders<H extends Record<string, string | null>>(
+	model: { api?: string; provider?: string; baseUrl?: string; compat?: unknown } | undefined,
+	headers: H | undefined,
+): H | Record<string, string | null> | undefined {
+	// compat is a provider union; clearThinkingEnabled only passes Anthropic models.
+	const anthropic = model as AnthropicishModel | undefined;
+	if (!clearThinkingEnabled(process.env.CC_CLEAR_THINKING, anthropic)) return headers;
+	return { ...headers, "anthropic-beta": anthropicBetas(isAnthropicOAuth(), anthropic?.compat) };
+}
+
 export default function contextManagementExtension(pi: ExtensionAPI) {
 	const flag = () => process.env.CC_CLEAR_THINKING;
 

package/extensions/doctor/build.ts

@@ -7,8 +7,6 @@
  * MCP servers reachable, what external programs are missing — then the issues.
  */
 
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { extensionVersion } from "../lib/package-version.ts";
 import { piVersionWarning, TESTED_PI_MAX_EXCLUSIVE, TESTED_PI_MIN } from "../lib/pi-version.ts";
@@ -20,6 +18,10 @@ import { collectCompat, importedConfigSection, mcpSection } from "./compat.ts";
 import { checkDependencies, dependenciesSection, type ShellsInput } from "./dependencies.ts";
 import { readSettingsEnv } from "../lib/claude-settings.ts";
 import { resolveBashSpawn, resolvePowerShellSpawn } from "../lib/shell-spawn.ts";
+import { upgradeCommandFor } from "../lib/update-check.mjs";
+import { replacedBuiltinsFix } from "../lib/replaced-builtins.mjs";
+import { keepWindowFix } from "../lib/compaction-keep.mjs";
+import { configCommand } from "./builtins.ts";
 import { shellToolPolicy } from "../powershell/policy.ts";
 import { collectModelFacts, modelsSection } from "./models.ts";
 import { computePresets, presetsSection } from "./presets.ts";
@@ -35,8 +37,8 @@ import {
 	type SessionView,
 	shortenHome,
 } from "./report.ts";
-
-export const BUNDLED_AGENTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "agents");
+import { MODE_LABELS } from "../lib/config-mode.ts";
+import { BUNDLED_AGENTS_DIR } from "../subagents/agents.ts";
 
 /** The environment variables a first-time user is most likely to already have; hinted when nothing is configured. */
 export const COMMON_KEY_ENV_VARS = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "OPENROUTER_API_KEY", "OPENCODE_API_KEY"];
@@ -60,14 +62,21 @@ export function installationSection(env: DoctorEnvironment, findings: Finding[])
 	lines.push({ text: `Node ${env.nodeVersion} · ${env.platform}-${env.arch}`, level: "dim" });
 	lines.push({ text: `pi agent dir: ${shortenHome(env.agentDir, env.home)} (auth, models, sessions, pi settings)`, level: "dim" });
 	lines.push({ text: `One Code state: ${shortenHome(env.stateDir, env.home)} (own settings, plans)`, level: "dim" });
-	const claudeDir = env.env.CLAUDE_CONFIG_DIR ? `${env.env.CLAUDE_CONFIG_DIR} (CLAUDE_CONFIG_DIR)` : shortenHome(`${env.home}/.claude`, env.home);
-	lines.push({ text: `Claude Code config read from: ${claudeDir} (never written)`, level: "dim" });
+	lines.push({ text: `Config sources: ${MODE_LABELS[env.configMode]} (switch in /memory)`, level: "dim" });
+	if (env.configMode === "independent") {
+		lines.push({ text: "Claude Code config: not read (~/.claude, .claude/, CLAUDE.md, ~/.claude.json, managed settings)", level: "dim" });
+	} else {
+		const claudeDir = env.env.CLAUDE_CONFIG_DIR ? `${env.env.CLAUDE_CONFIG_DIR} (CLAUDE_CONFIG_DIR)` : shortenHome(`${env.home}/.claude`, env.home);
+		lines.push({ text: `Claude Code config read from: ${claudeDir} (never written)`, level: "dim" });
+	}
 
 	const versionWarning = piVersionWarning(env.piVersion);
 	if (versionWarning) {
 		lines.push({ text: `pi ${env.piVersion} is outside the tested range ${TESTED_PI_MIN} – <${TESTED_PI_MAX_EXCLUSIVE}`, level: "warn" });
 		findings.push({ level: "warn", text: versionWarning, fix: env.install === "app" ? "Upgrade One Code (it pins a tested pi)." : "Update one-code-extension, or pin pi inside the tested range." });
 	}
+	replacedBuiltinsLines(env, lines, findings);
+	compactionKeepLines(env, lines, findings);
 
 	if (env.latest) {
 		switch (env.latest.status) {
@@ -76,7 +85,7 @@ export function installationSection(env: DoctorEnvironment, findings: Finding[])
 				break;
 			case "behind":
 				lines.push({
-					text: `Updates: ${env.latest.version} is available (you have ${env.oneCodeVersion}) — ${env.install === "app" ? "npm install -g @one-ai/one-code" : "pi update"}`,
+					text: `Updates: ${env.latest.version} is available (you have ${env.oneCodeVersion}) — ${upgradeCommandFor(env.install, env.env)}`,
 					level: "warn",
 				});
 				break;
@@ -90,6 +99,40 @@ export function installationSection(env: DoctorEnvironment, findings: Finding[])
 	return { title: "Installation", lines };
 }
 
+/** pi 0.99's built-in tool search and MCP, which ours replace: off, or still loaded with the fix. */
+function replacedBuiltinsLines(env: DoctorEnvironment, lines: ReportLine[], findings: Finding[]): void {
+	const view = env.replacedBuiltins;
+	if (!view) return;
+	if (view.left.length === 0) {
+		lines.push({ text: "pi's built-in tool-search and mcp: off (One Code provides its own)", level: "dim" });
+		return;
+	}
+	const names = view.left.map((builtin) => builtin.name).join(" and ");
+	lines.push({ text: `pi's built-in ${names}: still on, so pi warns at every start`, level: "warn" });
+	findings.push({
+		level: "warn",
+		text: `pi skips its built-in ${names} because One Code provides its own, and warns about it at every start, advising you to remove One Code. Keep One Code; turning the built-in off silences the warning.`,
+		fix: replacedBuiltinsFix(view.left, view.paths, configCommand(env.install)),
+	});
+}
+
+/** pi's compaction keep window: 0, or above 0 with the fix (lib/compaction-keep.mjs). */
+function compactionKeepLines(env: DoctorEnvironment, lines: ReportLine[], findings: Finding[]): void {
+	const view = env.compactionKeep;
+	if (!view) return;
+	if (view.value === 0) {
+		lines.push({ text: "pi's compaction keep window: 0 (One Code keeps the last reply, as Claude Code does)", level: "dim" });
+		return;
+	}
+	const where = view.source === "default" ? "pi's default" : `set in the ${view.source} settings${view.model ? ` for ${view.model}` : ""}`;
+	lines.push({ text: `pi's compaction keep window: ${view.value} tokens (${where}), so /compact refuses shorter sessions`, level: "warn" });
+	findings.push({
+		level: "warn",
+		text: `One Code keeps only the last reply after a compaction, so pi's keep window of ${view.value} tokens only stops /compact on a session shorter than that.`,
+		fix: keepWindowFix(shortenHome(view.source === "project" ? view.paths.project : view.paths.user, env.home), view.model),
+	});
+}
+
 export interface ProviderSummary {
 	provider: string;
 	name: string;
@@ -178,7 +221,15 @@ export function buildDoctorReport({ env, registry, session }: BuildInput): Docto
 	const presets = computePresets(registry.available, session.model);
 	sections.push(presetsSection(presets, session.model));
 
-	const compat = collectCompat({ cwd: env.cwd, home: env.home, agentDir: env.agentDir, env: env.env, bundledAgentsDir: BUNDLED_AGENTS_DIR });
+	const compat = collectCompat({
+		cwd: env.cwd,
+		home: env.home,
+		agentDir: env.agentDir,
+		env: env.env,
+		bundledAgentsDir: BUNDLED_AGENTS_DIR,
+		piConfigDirName: env.piConfigDirName,
+		registeredMcpServers: env.registeredMcpServers,
+	});
 	findings.push(...compat.findings);
 	sections.push(importedConfigSection(compat, env.home));
 	sections.push(mcpSection(compat, session, env.home));

package/extensions/doctor/builtins.ts

@@ -0,0 +1,84 @@
+/**
+ * Which of pi's built-in extensions that One Code replaces the running pi
+ * still loads, read from pi's own settings (lib/replaced-builtins.mjs has the
+ * rule). Shared by the startup notice (branding) and `/doctor`, in the
+ * session and from `onecode doctor`.
+ */
+
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME, getPackageDir, type SettingsManager } from "@earendil-works/pi-coding-agent";
+import { piHasBuiltinExtensions } from "../lib/pi-version.ts";
+import { type CompactionKeepView, compactionKeepView } from "../lib/compaction-keep.mjs";
+import { BUILTIN_EXTENSIONS_PI, type BuiltinLeftOn, builtinsLeftOn, type GlobMatcher, globMatches } from "../lib/replaced-builtins.mjs";
+
+/**
+ * pi's own minimatch, the matcher its `!` override entries go through, loaded
+ * from pi's install so every glob form (extglobs included) reads as pi reads
+ * it. Falls back to the module's port when that copy cannot be loaded (a
+ * compiled pi binary, an unusual layout).
+ */
+function piGlobMatcher(): GlobMatcher {
+	try {
+		const { minimatch } = createRequire(join(getPackageDir(), "package.json"))("minimatch") as { minimatch?: unknown };
+		if (typeof minimatch === "function") return (pattern, path) => (minimatch as (path: string, pattern: string) => boolean)(path, pattern);
+	} catch {
+		// pi's copy is not reachable: use the port.
+	}
+	return globMatches;
+}
+
+export interface ReplacedBuiltinsView {
+	/** The replaced built-ins pi still loads; empty when the settings turn them all off. */
+	left: BuiltinLeftOn[];
+	/** The settings files a fix edits. */
+	paths: { user: string; project: string };
+}
+
+/**
+ * The view for a pi with the built-ins, or undefined on an older pi (nothing
+ * to report) or when the settings cannot be read (pi reports that itself).
+ */
+export function replacedBuiltinsView(
+	piVersion: string | undefined,
+	settings: () => Pick<SettingsManager, "getGlobalSettings" | "getProjectSettings">,
+	paths: { agentDir: string; cwd: string },
+): ReplacedBuiltinsView | undefined {
+	if (!piHasBuiltinExtensions(piVersion, BUILTIN_EXTENSIONS_PI)) return undefined;
+	try {
+		const manager = settings();
+		return {
+			left: builtinsLeftOn(manager.getGlobalSettings().extensions, manager.getProjectSettings().extensions, piGlobMatcher()),
+			paths: { user: join(paths.agentDir, "settings.json"), project: join(paths.cwd, CONFIG_DIR_NAME, "settings.json") },
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+/** pi's compaction keep window and the settings files that set it, or undefined when they cannot be read. */
+export function keepView(
+	settings: () => Pick<SettingsManager, "getGlobalSettings" | "getProjectSettings">,
+	paths: { agentDir: string; cwd: string },
+	modelKey?: string,
+): (CompactionKeepView & { paths: { user: string; project: string } }) | undefined {
+	try {
+		const manager = settings();
+		return {
+			...compactionKeepView(manager.getGlobalSettings(), manager.getProjectSettings(), modelKey),
+			paths: { user: join(paths.agentDir, "settings.json"), project: join(paths.cwd, CONFIG_DIR_NAME, "settings.json") },
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+/** Whether this is the bundled app (its launcher sets `CC_VERSION`) or One Code on the user's own pi. */
+export function installKind(env: NodeJS.ProcessEnv = process.env): "app" | "pi-package" {
+	return env.CC_VERSION ? "app" : "pi-package";
+}
+
+/** How the user opens pi's config UI: `onecode config` under the bundled app. */
+export function configCommand(install: "app" | "pi-package"): string {
+	return install === "app" ? "onecode config" : "pi config";
+}

package/extensions/doctor/cli.ts

@@ -11,12 +11,14 @@
  */
 
 import { join } from "node:path";
-import { ModelRegistry, ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { CONFIG_DIR_NAME, ModelRegistry, ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { keepView, replacedBuiltinsView } from "./builtins.ts";
 import { oneCodeStateDir } from "../lib/paths.ts";
 import { loadPermissionSettings } from "../permissions/settings.ts";
 import { buildDoctorReport } from "./build.ts";
 import { type DoctorReport, renderDoctorText, type SessionView } from "./report.ts";
 import { lookupLatestVersion } from "./update-lookup.ts";
+import { configMode } from "../lib/config-mode.ts";
 
 export interface DoctorCliOptions {
 	agentDir: string;
@@ -68,6 +70,7 @@ export async function collectDoctorCliReport(options: DoctorCliOptions): Promise
 			home,
 			agentDir,
 			stateDir: oneCodeStateDir(env, home),
+			configMode: configMode(),
 			env,
 			platform: process.platform,
 			arch: process.arch,
@@ -75,6 +78,9 @@ export async function collectDoctorCliReport(options: DoctorCliOptions): Promise
 			oneCodeVersion: options.version,
 			install: options.install,
 			piVersion: options.piVersion,
+			replacedBuiltins: replacedBuiltinsView(options.piVersion, () => settings, { agentDir, cwd }),
+			compactionKeep: keepView(() => settings, { agentDir, cwd }),
+			piConfigDirName: CONFIG_DIR_NAME,
 			latest,
 		},
 		registry: {