@lll9p/pi-better-compaction 0.6.0 → 0.7.0

package/README.md

@@ -4,7 +4,7 @@ English | [中文](README.zh-CN.md)
 
 A [pi](https://github.com/nicepkg/pi) extension that upgrades context compaction with two coordinated strategies:
 
-1. **OpenAI Responses APIs** use the provider's native compaction endpoint, preserving opaque context that plain text summaries lose.
+1. **OpenAI Responses APIs**, including supported GitHub Copilot models, use the provider's native compaction endpoint, preserving opaque context that plain text summaries lose.
 2. **All other APIs** (Anthropic, Gemini, etc.) can run pi's built-in compaction with a **dedicated cheaper/faster model**, so summarization doesn't consume quota on your primary model.
 
 Everything fails open — if any step cannot proceed, pi's default compaction takes over.
@@ -44,10 +44,6 @@ If the file doesn't exist, all defaults apply. The extension never creates this
 ```jsonc
 {
   "enabled": true,
-  "midRun": {
-    "enabled": false,
-    "thresholdPercent": 80
-  },
   "compactionVersion": "v2",
   "compactionModel": null,
   "compactionThinkingLevel": "off",
@@ -69,8 +65,6 @@ If the file doesn't exist, all defaults apply. The extension never creates this
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
 | `enabled` | `boolean` | `true` | Master switch. Set `false` to disable the extension entirely. |
-| `midRun.enabled` | `boolean` | `false` | Reserved and currently ignored. The mid-run guard remains disabled even when set to `true`. |
-| `midRun.thresholdPercent` | `number` | `80` | Reserved threshold for the disabled mid-run guard. Must be greater than 0 and at most 100. |
 | `compactionVersion` | `"v1" \| "v2"` | `"v2"` | Protocol for Responses-family APIs. **V2** (streaming, encrypted blob) is the current OpenAI default. **V1** uses the legacy `/responses/compact` endpoint. |
 | `compactionModel` | `string \| null` | `null` | Model for fallback compaction (non-Responses APIs, or when native compact fails). Format: `"provider/model-id"`, e.g. `"openai/gpt-5.1-mini"`. `null` = let pi use the current chat model. |
 | `compactionThinkingLevel` | `string` | `"off"` | Thinking level for the fallback compaction model. One of: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. |

package/README.zh-CN.md

@@ -44,10 +44,6 @@ cd pi-better-compaction && pi install .
 ```jsonc
 {
   "enabled": true,
-  "midRun": {
-    "enabled": false,
-    "thresholdPercent": 80
-  },
   "compactionVersion": "v2",
   "compactionModel": null,
   "compactionThinkingLevel": "off",
@@ -69,8 +65,6 @@ cd pi-better-compaction && pi install .
 | 选项 | 类型 | 默认值 | 说明 |
 |------|------|--------|------|
 | `enabled` | `boolean` | `true` | 总开关。设为 `false` 完全禁用扩展。 |
-| `midRun.enabled` | `boolean` | `false` | 保留配置，当前会被忽略。即使设为 `true`，mid-run guard 仍保持禁用。 |
-| `midRun.thresholdPercent` | `number` | `80` | 已禁用的 mid-run guard 的保留阈值。必须大于 0 且不超过 100。 |
 | `compactionVersion` | `"v1" \| "v2"` | `"v2"` | Responses 系列 API 的压缩协议。**V2**（流式，加密 blob）是 OpenAI 当前默认协议；**V1** 使用旧版 `/responses/compact` 端点。 |
 | `compactionModel` | `string \| null` | `null` | 回退压缩使用的模型（用于非 Responses API，或原生压缩失败时）。格式：`"provider/model-id"`，如 `"openai/gpt-5.1-mini"`。`null` = 由 pi 使用当前对话模型。 |
 | `compactionThinkingLevel` | `string` | `"off"` | 回退压缩模型的思考级别。可选：`off`、`minimal`、`low`、`medium`、`high`、`xhigh`、`max`。 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lll9p/pi-better-compaction",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "Better compaction for pi: native /responses/compact replay for OpenAI Responses APIs, plus a configurable compaction model driving pi's native summarization everywhere else.",
   "author": "Lilin Lao",
@@ -38,7 +38,6 @@
     "src/debug.ts",
     "src/details-store.ts",
     "src/extension-runtime.ts",
-    "src/midrun.ts",
     "src/native-fallback.ts",
     "src/payload-rewrite.ts",
     "src/request-context-cache.ts",

package/src/compact-client-v2.ts

@@ -67,6 +67,8 @@ export type ExecuteV2CompactionOptions = {
 
 const DEFAULT_MAX_RETRIES = 2;
 const SSE_ACCEPT = "text/event-stream";
+// Copilot rejects compaction_trigger with a smaller explicit output ceiling.
+const COPILOT_COMPACTION_OUTPUT_CEILING = 20_000;
 
 // ── Helpers ────────────────────────────────────────────────────────────
 
@@ -123,7 +125,7 @@ async function collectStreamOutput(response: Response, signal?: AbortSignal): Pr
 	let buffer = "";
 
 	try {
-		while (true) {
+		stream: while (true) {
 			if (signal?.aborted) {
 				reader.cancel();
 				return { ok: false, reason: "aborted" as const };
@@ -176,7 +178,7 @@ async function collectStreamOutput(response: Response, signal?: AbortSignal): Pr
 							usage = resp.usage as V2CompactionUsage;
 						}
 					}
-					continue;
+					break stream;
 				}
 
 				if (eventType === "response.failed" || eventType === "error") {
@@ -184,16 +186,18 @@ async function collectStreamOutput(response: Response, signal?: AbortSignal): Pr
 					serverError = isRecord(errorObj)
 						? (typeof errorObj.message === "string" ? errorObj.message : JSON.stringify(errorObj))
 						: String(errorObj);
-					continue;
+					break stream;
 				}
 			}
 		}
 	} catch (error) {
-		if (isAbortError(error)) {
+		if (signal?.aborted || isAbortError(error)) {
 			return { ok: false, reason: "aborted" as const };
 		}
 		return { ok: false, reason: "stream-parse-error", errorMessage: error instanceof Error ? error.message : String(error) };
 	} finally {
+		// Completion is terminal even when a gateway keeps the HTTP body open.
+		try { await reader.cancel(); } catch { /* noop */ }
 		try { reader.releaseLock(); } catch { /* noop */ }
 	}
 
@@ -237,7 +241,7 @@ async function executeV2Attempt(
 			signal,
 		});
 	} catch (error) {
-		if (isAbortError(error)) {
+		if (signal?.aborted || isAbortError(error)) {
 			return { failure: { ok: false, reason: "aborted" } };
 		}
 		return {
@@ -294,21 +298,36 @@ function isRetryable(result: V2CompactionFailure): boolean {
  * to the input, streams the SSE response, and collects the compaction blob.
  *
  * Retries recoverable failures up to `maxRetries` times (default 2).
+ *
+ * Copilot routes in Pi 0.84.4; tested means live native compaction and replay.
+ *
+ * | Provider (via Copilot) | API | Tested |
+ * | --- | --- | --- |
+ * | OpenAI (Astra) | Responses | Yes |
+ * | xAI (Grok 4.6) | Responses | Failed (HTTP 422) |
+ * | Google (Gemini) | Chat Completions | No; outside this path |
+ * | Anthropic (Opus) | Messages | No; outside this path |
  */
 export async function executeV2Compaction(
 	options: ExecuteV2CompactionOptions,
 ): Promise<V2CompactionResult> {
-	const { runtime, request, signal, settings, context } = options;
+	const { runtime, request, settings, context } = options;
+	const deadline = AbortSignal.timeout(600_000);
+	const signal = options.signal ? AbortSignal.any([options.signal, deadline]) : deadline;
 	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
 
-	const headers = toHeaders(runtime, SSE_ACCEPT);
+	const headers = toHeaders(runtime, SSE_ACCEPT, request.input);
 	const url = runtime.responsesUrl;
 
 	// Build request body: input + compaction_trigger, stream=true.
 	const requestBody = {
 		...request,
 		input: [...request.input, { type: "compaction_trigger" }],
+		store: false,
 		stream: true,
+		...(runtime.provider === "github-copilot" ? {
+			max_output_tokens: COPILOT_COMPACTION_OUTPUT_CEILING,
+		} : {}),
 	};
 
 	let lastFailure: V2CompactionFailure | undefined;

package/src/compact-client.ts

@@ -121,7 +121,7 @@ export async function executeNativeCompaction(
 	options: ExecuteNativeCompactionOptions,
 ): Promise<NativeCompactionClientResult> {
 	const { runtime, request, signal, settings, context } = options;
-	const headers = toHeaders(runtime);
+	const headers = toHeaders(runtime, JSON_CONTENT_TYPE, request.input);
 
 	if (signal?.aborted) {
 		const aborted: NativeCompactionClientFailure = {

package/src/config.ts

@@ -128,7 +128,6 @@ export function loadExtensionConfig(configPath: string = CONFIG_PATH): LoadedExt
 	const warnings: string[] = [];
 	const resolved: ExtensionConfig = {
 		...DEFAULT_EXTENSION_CONFIG,
-		midRun: { ...DEFAULT_EXTENSION_CONFIG.midRun },
 		responsesCompactApis: [...DEFAULT_EXTENSION_CONFIG.responsesCompactApis],
 	};
 	let source: string | undefined;
@@ -139,18 +138,6 @@ export function loadExtensionConfig(configPath: string = CONFIG_PATH): LoadedExt
 
 		resolved.enabled = toBoolean(raw.enabled, "enabled", warnings) ?? resolved.enabled;
 
-		if (raw.midRun === undefined) {
-			// Keep defaults.
-		} else if (isRecord(raw.midRun)) {
-			resolved.midRun.enabled =
-				toBoolean(raw.midRun.enabled, "midRun.enabled", warnings) ?? resolved.midRun.enabled;
-			resolved.midRun.thresholdPercent =
-				toThresholdPercent(raw.midRun.thresholdPercent, "midRun.thresholdPercent", warnings) ??
-				resolved.midRun.thresholdPercent;
-		} else {
-			warnings.push("Ignoring midRun: expected a JSON object.");
-		}
-
 		resolved.allowCompactionContinuityBreak =
 			toBoolean(raw.allowCompactionContinuityBreak, "allowCompactionContinuityBreak", warnings) ??
 			resolved.allowCompactionContinuityBreak;

package/src/extension-runtime.ts

@@ -671,7 +671,6 @@ export function registerExtensionRuntime(
 	pi: ExtensionAPI,
 	dependencies: ExtensionRuntimeDependencies = DEFAULT_DEPENDENCIES,
 ): void {
-	// Mid-run compaction is intentionally disabled regardless of config.
 	pi.on("session_start", (_event, ctx) => {
 		const { config, source, warnings } = dependencies.loadExtensionConfig();
 		if (!config.enabled) return;

package/src/payload-rewrite.ts

@@ -227,6 +227,43 @@ function areEquivalentValues(left: unknown, right: unknown): boolean {
 	return false;
 }
 
+// Match pruned output runs by call ID; all other items must stay unchanged. -- PI/gpt-6-astra
+/** @internal — exported for unit testing only */
+export function alignPrunedInput(actual: readonly unknown[], expected: readonly unknown[]): number[] | undefined {
+	const indices: number[] = [];
+	let actualIndex = 0;
+	for (let expectedIndex = 0; expectedIndex < expected.length;) {
+		const item = expected[expectedIndex];
+		if (isRecord(item) && item.type === "function_call_output") {
+			const outputs = new Map<string, number>();
+			while (expectedIndex < expected.length) {
+				const output = expected[expectedIndex];
+				if (!isRecord(output) || output.type !== "function_call_output") break;
+				if (typeof output.call_id !== "string" || outputs.has(output.call_id)) return undefined;
+				outputs.set(output.call_id, expectedIndex++);
+			}
+			while (actualIndex < actual.length) {
+				const output = actual[actualIndex];
+				if (!isRecord(output) || output.type !== "function_call_output") break;
+				const index = typeof output.call_id === "string" ? outputs.get(output.call_id) : undefined;
+				if (index === undefined || !areEquivalentValues(
+					{ ...output, output: undefined },
+					{ ...(expected[index] as Record<string, unknown>), output: undefined },
+				)) return undefined;
+				outputs.delete(output.call_id as string);
+				indices.push(index);
+				actualIndex++;
+			}
+			if (outputs.size > 0) return undefined;
+		} else {
+			if (!areEquivalentValues(actual[actualIndex], item)) return undefined;
+			indices.push(expectedIndex++);
+			actualIndex++;
+		}
+	}
+	return actualIndex === actual.length ? indices : undefined;
+}
+
 function toBranchSummaryMessage(entry: BranchSummaryEntry): AgentMessage {
 	return {
 		role: "branchSummary",
@@ -449,7 +486,8 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 		...freshPreamble.trailingInput,
 	];
 
-	if (!areEquivalentValues(args.payload.input, originalPiReplayInput)) {
+	const originalIndices = alignPrunedInput(args.payload.input, originalPiReplayInput);
+	if (!originalIndices) {
 		const parity = compareResponsesInputParity(args.payload.input, originalPiReplayInput);
 		return {
 			ok: false,
@@ -467,17 +505,13 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 	const compactionSummaryCount = serializeMessagesToResponsesInput(args.model, [compactionSummaryMessage]).length;
 	const preCompactionKeptCount = serializeMessagesToResponsesInput(args.model, preCompactionKeptMessages).length;
 	const tailStartIndex = freshPreambleCount + compactionSummaryCount + preCompactionKeptCount;
-	const tailEndIndex = args.payload.input.length - trailingPreambleCount;
-	const actualCompactionSummary = cloneResponsesInputSlice(
-		args.payload.input.slice(freshPreambleCount, freshPreambleCount + compactionSummaryCount),
-	);
-	const actualPreCompactionKeptWindow = cloneResponsesInputSlice(
-		args.payload.input.slice(
-			freshPreambleCount + compactionSummaryCount,
-			freshPreambleCount + compactionSummaryCount + preCompactionKeptCount,
-		),
+	const tailEndIndex = originalPiReplayInput.length - trailingPreambleCount;
+	const actualSlice = (start: number, end: number) => cloneResponsesInputSlice(
+		args.payload.input.filter((_, index) => originalIndices[index] >= start && originalIndices[index] < end),
 	);
-	const actualPostCompactionTail = cloneResponsesInputSlice(args.payload.input.slice(tailStartIndex, tailEndIndex));
+	const actualCompactionSummary = actualSlice(freshPreambleCount, freshPreambleCount + compactionSummaryCount);
+	const actualPreCompactionKeptWindow = actualSlice(freshPreambleCount + compactionSummaryCount, tailStartIndex);
+	const actualPostCompactionTail = actualSlice(tailStartIndex, tailEndIndex);
 	if (!actualCompactionSummary || !actualPreCompactionKeptWindow || !actualPostCompactionTail) {
 		return {
 			ok: false,

package/src/runtime.ts

@@ -39,7 +39,7 @@ export type NativeCompactionRuntime = {
 	model: string;
 	baseUrl: string;
 	apiKey: string;
-	headers?: Record<string, string>;
+	headers?: Record<string, string | null>;
 	compactPath: string;
 	compactUrl: string;
 	responsesUrl: string;
@@ -127,25 +127,13 @@ export function buildCompactPath(api: ResponsesCompactApi): string {
 	return api === "openai-codex-responses" ? CODEX_COMPACT_PATH : OPENAI_COMPACT_PATH;
 }
 
-/** Strip null-valued entries so downstream consumers receive a clean Record<string, string>. */
-function filterNullHeaders(headers: Record<string, string | null> | undefined): Record<string, string> | undefined {
-	if (!headers) return undefined;
-	const filtered: Record<string, string> = {};
-	for (const [key, value] of Object.entries(headers)) {
-		if (value !== null) {
-			filtered[key] = value;
-		}
-	}
-	return Object.keys(filtered).length > 0 ? filtered : undefined;
-}
-
 async function resolveRequestAuth(
 	ctx: ExtensionContext,
 	model: RuntimeModel,
-): Promise<{ apiKey?: string; headers?: Record<string, string> }> {
+): Promise<{ apiKey?: string; headers?: Record<string, string | null>; baseUrl?: string }> {
 	const modelRegistry = ctx.modelRegistry as {
 		getApiKeyAndHeaders?: (currentModel: RuntimeModel) => Promise<
-			| { ok: true; apiKey?: string; headers?: Record<string, string | null> }
+			| { ok: true; apiKey?: string; headers?: Record<string, string | null>; baseUrl?: string }
 			| { ok: false; error: string }
 		>;
 	};
@@ -155,7 +143,7 @@ async function resolveRequestAuth(
 	}
 
 	const auth = await modelRegistry.getApiKeyAndHeaders(model);
-	return auth.ok ? { apiKey: auth.apiKey, headers: filterNullHeaders(auth.headers) } : {};
+	return auth.ok ? { apiKey: auth.apiKey, headers: auth.headers, baseUrl: auth.baseUrl } : {};
 }
 
 export function isSupportedApi(api: string): api is ResponsesCompactApi {
@@ -201,7 +189,16 @@ export async function resolveNativeCompactionEnvironment(
 		};
 	}
 
-	const currentModel = ctx.model;
+	let sessionModel: RuntimeModel | undefined;
+	const branch = ctx.sessionManager?.getBranch?.() ?? [];
+	for (let index = branch.length - 1; index >= 0; index -= 1) {
+		const entry = branch[index];
+		if (entry?.type === "model_change") {
+			sessionModel = ctx.modelRegistry.find(entry.provider, entry.modelId);
+			break;
+		}
+	}
+	const currentModel = ctx.model ?? sessionModel;
 	const descriptor = getRuntimeModelDescriptor(currentModel);
 	if (!currentModel || !descriptor.provider || !descriptor.api || !descriptor.model) {
 		return {
@@ -223,14 +220,6 @@ export async function resolveNativeCompactionEnvironment(
 		};
 	}
 
-	if (!descriptor.baseUrl) {
-		return {
-			ok: false,
-			reason: "missing-base-url",
-			...descriptor,
-		};
-	}
-
 	let requestPayload: ResponsesCompatibleRequestPayload | undefined;
 	if (payload !== undefined) {
 		if (!isResponsesCompatiblePayload(payload)) {
@@ -252,7 +241,13 @@ export async function resolveNativeCompactionEnvironment(
 		requestPayload = payload;
 	}
 
-	const { apiKey, headers } = await resolveRequestAuth(ctx, currentModel);
+	const { apiKey, headers, baseUrl: authBaseUrl } = await resolveRequestAuth(ctx, currentModel);
+	// OAuth can route a configured Individual model to an Enterprise endpoint.
+	// Use the same resolved endpoint for transport AND persisted replay identity.
+	const baseUrl = normalizeBaseUrl(authBaseUrl) ?? descriptor.baseUrl;
+	if (!baseUrl) {
+		return { ok: false, reason: "missing-base-url", ...descriptor };
+	}
 	if (!apiKey) {
 		return {
 			ok: false,
@@ -267,14 +262,14 @@ export async function resolveNativeCompactionEnvironment(
 			provider: descriptor.provider,
 			api: descriptor.api,
 			model: descriptor.model,
-			baseUrl: descriptor.baseUrl,
+			baseUrl,
 			apiKey,
 			headers,
 			compactPath: buildCompactPath(descriptor.api),
-			compactUrl: buildCompactUrl(descriptor.baseUrl, descriptor.api),
-			responsesUrl: buildResponsesUrl(descriptor.baseUrl, descriptor.api),
+			compactUrl: buildCompactUrl(baseUrl, descriptor.api),
+			responsesUrl: buildResponsesUrl(baseUrl, descriptor.api),
 			payload: requestPayload,
-			currentModel,
+			currentModel: { ...currentModel, baseUrl },
 		},
 	};
 }

package/src/shared-headers.ts

@@ -55,31 +55,25 @@ function buildCodexUserAgent(): string {
  * and Codex-specific headers (account ID, originator, user-agent, beta flag).
  *
  * @param accept - The Accept header value. Defaults to `application/json`.
+ * @param input - The request input items, used for Copilot vision detection.
  */
 export function toHeaders(
 	runtime: NativeCompactionRuntime,
 	accept: string = JSON_CONTENT_TYPE,
+	input: readonly unknown[] = [],
 ): Record<string, string> {
 	const headers = new Headers();
-	// Model-level headers may contain null values (ProviderHeaders); null means "unset".
-	for (const [key, value] of Object.entries(runtime.currentModel.headers ?? {})) {
-		if (value != null) {
-			headers.set(key, String(value));
+	headers.set("authorization", `Bearer ${runtime.apiKey}`);
+	if (runtime.provider === "github-copilot") {
+		// Compaction is an agent-initiated request, even when history ends with a user.
+		headers.set("x-initiator", "agent");
+		headers.set("openai-intent", "conversation-edits");
+		if (input.some((item) => isRecord(item) && [item.content, item.output].some((blocks) =>
+			Array.isArray(blocks) && blocks.some((block) => isRecord(block) && block.type === "input_image"),
+		))) {
+			headers.set("copilot-vision-request", "true");
 		}
 	}
-	// Extension-resolved headers (already filtered by resolveRequestAuth, but defensive).
-	for (const [key, value] of Object.entries(runtime.headers ?? {})) {
-		if (value == null) {
-			headers.delete(key);
-		} else {
-			headers.set(key, value);
-		}
-	}
-	headers.set("accept", accept);
-	headers.set("content-type", JSON_CONTENT_TYPE);
-	if (!headers.has("authorization")) {
-		headers.set("authorization", `Bearer ${runtime.apiKey}`);
-	}
 
 	if (runtime.api === "openai-codex-responses") {
 		const accountId = extractCodexAccountId(runtime.apiKey);
@@ -91,6 +85,18 @@ export function toHeaders(
 		headers.set("openai-beta", "responses=experimental");
 	}
 
+	// Defaults first, then model headers, then resolved request auth. Null means
+	// remove, even for Authorization and Codex-specific headers.
+	for (const source of [runtime.currentModel.headers, runtime.headers]) {
+		for (const [key, value] of Object.entries(source ?? {})) {
+			if (value == null) headers.delete(key);
+			else headers.set(key, value);
+		}
+	}
+	// These two are mandatory transport invariants, not overridable auth defaults.
+	headers.set("accept", accept);
+	headers.set("content-type", JSON_CONTENT_TYPE);
+
 	return Object.fromEntries(headers.entries());
 }
 

package/src/types.ts

@@ -33,14 +33,8 @@ export type DebugArtifactKind =
 	| "compaction-event"
 	| "lifecycle";
 
-export type MidRunConfig = {
-	enabled: boolean;
-	thresholdPercent: number;
-};
-
 export type ExtensionConfig = {
 	enabled: boolean;
-	midRun: MidRunConfig;
 	/**
 	 * Allow a Responses session whose latest compaction was not created by this extension
 	 * to restart native compaction from Pi's current serialized session context.
@@ -310,10 +304,6 @@ export function createNativeCompactionResult(
 
 export const DEFAULT_EXTENSION_CONFIG: ExtensionConfig = {
 	enabled: true,
-	midRun: {
-		enabled: false,
-		thresholdPercent: 80,
-	},
 	allowCompactionContinuityBreak: false,
 	compactionModel: undefined,
 	compactionThinkingLevel: "off",

package/src/midrun.ts

@@ -1,229 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { loadExtensionConfig } from "./config";
-import { writeDebugArtifact } from "./debug";
-import { EXTENSION_ID, type LoadedExtensionConfig } from "./types";
-
-type MidRunPhase = "idle" | "abort-pending" | "compacting" | "resume-pending" | "failed";
-
-type MidRunState = {
-	phase: MidRunPhase;
-	generation: number;
-	sessionId?: string;
-	baselineCompactionId?: string;
-	triggerTokens?: number;
-	triggerPercent?: number;
-	triggerContextWindow?: number;
-};
-
-type ConfigLoader = () => LoadedExtensionConfig;
-
-const RESUME_CUSTOM_TYPE = "pi-better-compaction-midrun-resume";
-const RESUME_PROMPT = `[pi-better-compaction/midrun]
-Context compaction completed. Continue the interrupted task from the exact point where execution stopped.`;
-const MIDRUN_COMPACTION_INSTRUCTIONS =
-	"Preserve the active task, completed work, decisions, changed files, failures, current tool-loop state, and exact next steps so execution can resume immediately after compaction.";
-
-function getSessionId(ctx: ExtensionContext): string | undefined {
-	try {
-		return ctx.sessionManager.getSessionId();
-	} catch {
-		return undefined;
-	}
-}
-
-function getLatestCompactionId(ctx: ExtensionContext): string | undefined {
-	const branch = ctx.sessionManager.getBranch();
-	for (let index = branch.length - 1; index >= 0; index--) {
-		const entry = branch[index];
-		if (entry?.type === "compaction") return entry.id;
-	}
-	return undefined;
-}
-
-function resetState(state: MidRunState): void {
-	state.phase = "idle";
-	state.generation += 1;
-	state.sessionId = undefined;
-	state.baselineCompactionId = undefined;
-	state.triggerTokens = undefined;
-	state.triggerPercent = undefined;
-	state.triggerContextWindow = undefined;
-}
-
-function sameSession(state: MidRunState, ctx: ExtensionContext): boolean {
-	return state.sessionId !== undefined && state.sessionId === getSessionId(ctx);
-}
-
-function notifyFailure(ctx: ExtensionContext, message: string): void {
-	if (ctx.hasUI) {
-		ctx.ui.notify(`${EXTENSION_ID}: ${message}`, "error");
-	}
-}
-
-function scheduleResume(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	state: MidRunState,
-	generation: number,
-): void {
-	state.phase = "resume-pending";
-
-	setImmediate(() => {
-		if (
-			state.generation !== generation ||
-			state.phase !== "resume-pending" ||
-			!sameSession(state, ctx)
-		) {
-			return;
-		}
-
-		if (!ctx.isIdle() || ctx.hasPendingMessages()) {
-			resetState(state);
-			return;
-		}
-
-		resetState(state);
-		pi.sendMessage(
-			{
-				customType: RESUME_CUSTOM_TYPE,
-				content: RESUME_PROMPT,
-				display: false,
-				details: { source: "midrun-compaction" },
-			},
-			{ triggerTurn: true },
-		);
-	});
-}
-
-export function registerMidRunGuard(
-	pi: ExtensionAPI,
-	loadConfig: ConfigLoader = loadExtensionConfig,
-): void {
-	const state: MidRunState = { phase: "idle", generation: 0 };
-
-	pi.on("turn_end", (event, ctx) => {
-		const { config } = loadConfig();
-		if (!config.enabled || !config.midRun.enabled || state.phase !== "idle") return;
-		if (event.toolResults.length === 0 || ctx.hasPendingMessages()) return;
-
-		const usage = ctx.getContextUsage();
-		if (!usage || usage.tokens == null || usage.percent == null) return;
-		if (usage.percent < config.midRun.thresholdPercent) return;
-
-		const sessionId = getSessionId(ctx);
-		if (!sessionId) return;
-
-		state.phase = "abort-pending";
-		state.generation += 1;
-		state.sessionId = sessionId;
-		state.baselineCompactionId = getLatestCompactionId(ctx);
-		state.triggerTokens = usage.tokens;
-		state.triggerPercent = usage.percent;
-		state.triggerContextWindow = usage.contextWindow;
-
-		writeDebugArtifact(
-			"lifecycle",
-			{
-				event: "midrun.threshold",
-				turnIndex: event.turnIndex,
-				tokens: usage.tokens,
-				contextWindow: usage.contextWindow,
-				percent: usage.percent,
-				thresholdPercent: config.midRun.thresholdPercent,
-				baselineCompactionId: state.baselineCompactionId,
-			},
-			config,
-			ctx,
-		);
-
-		// Never compact while the agent run is active; let Pi settle first.
-		ctx.abort();
-	});
-
-	pi.on("agent_settled", (_event, ctx) => {
-		if (state.phase !== "abort-pending") return;
-		if (!sameSession(state, ctx)) {
-			resetState(state);
-			return;
-		}
-
-		// An earlier agent_settled handler may already have started or queued another run.
-		if (!ctx.isIdle() || ctx.hasPendingMessages()) {
-			resetState(state);
-			return;
-		}
-
-		const generation = state.generation;
-		const latestCompactionId = getLatestCompactionId(ctx);
-		if (latestCompactionId !== state.baselineCompactionId) {
-			const { config } = loadConfig();
-			writeDebugArtifact(
-				"lifecycle",
-				{
-					event: "midrun.coalesced",
-					reason: "compaction-already-occurred-during-abort",
-					baselineCompactionId: state.baselineCompactionId,
-					latestCompactionId,
-				},
-				config,
-				ctx,
-			);
-			scheduleResume(pi, ctx, state, generation);
-			return;
-		}
-
-		const { config } = loadConfig();
-		if (!config.enabled || !config.midRun.enabled) {
-			scheduleResume(pi, ctx, state, generation);
-			return;
-		}
-
-		const usage = ctx.getContextUsage();
-		if (usage?.percent != null && usage.percent < config.midRun.thresholdPercent) {
-			scheduleResume(pi, ctx, state, generation);
-			return;
-		}
-
-		state.phase = "compacting";
-		ctx.compact({
-			customInstructions: MIDRUN_COMPACTION_INSTRUCTIONS,
-			onComplete: () => {
-				if (
-					state.generation !== generation ||
-					state.phase !== "compacting" ||
-					!sameSession(state, ctx)
-				) {
-					return;
-				}
-				scheduleResume(pi, ctx, state, generation);
-			},
-			onError: (error) => {
-				if (state.generation !== generation || !sameSession(state, ctx)) return;
-
-				const latest = getLatestCompactionId(ctx);
-				if (/Already compacted/i.test(error.message) && latest !== state.baselineCompactionId) {
-					scheduleResume(pi, ctx, state, generation);
-					return;
-				}
-
-				state.phase = "failed";
-				writeDebugArtifact(
-					"lifecycle",
-					{
-						event: "midrun.failed",
-						errorMessage: error.message,
-						triggerTokens: state.triggerTokens,
-						triggerPercent: state.triggerPercent,
-						triggerContextWindow: state.triggerContextWindow,
-					},
-					config,
-					ctx,
-				);
-				notifyFailure(ctx, `mid-run compaction failed: ${error.message}`);
-			},
-		});
-	});
-
-	pi.on("session_start", () => resetState(state));
-	pi.on("session_shutdown", () => resetState(state));
-}