@agimon-ai/po-autocompact 0.0.0-alpha.0

package/dist/extensions/server.mjs

@@ -0,0 +1,850 @@
+import { S as STATE_CUSTOM_TYPE, _ as withCanonicalFileSections, a as createInitialState, b as RESUME_MESSAGE_TYPE, c as fileDetailsFromUnknown, d as latestCheckpointArtifactEntry, f as mergeFileDetails, h as projectContextMessages, i as contextDetailsFromUnknown, l as fileOperationsFromMessages, m as parseState, n as checkpointRequestDetails, o as createRequestId, p as parseCheckpointDecision, r as checkpointSummaryFromEntry, s as effectiveThresholds, t as baselineUsageIsSettled, u as isStructuredCheckpoint, v as CHECKPOINT_MESSAGE_TYPE, x as RUNTIME_STATE_MESSAGE_TYPE, y as CONTEXT_MESSAGE_TYPE } from "../compactionPolicy-CDCYTj2b.mjs";
+import { composeServerProviderOverrides, defineServerPlugin } from "@agimon-ai/po-core/serverFacet";
+import { composeRootHooks, defineHook, defineRoot } from "@agimon-ai/po-core/extensionFile";
+import { DOOM_CONTEXT_CONTRIBUTIONS_SERVICE, requireDoomContextContributions } from "@agimon-ai/po-core/contextContributions";
+import { DOOM_UI_HUB_SERVICE, requireDoomUiHub } from "@agimon-ai/po-core/uiHub";
+import { loadDoomConfig } from "@agimon-ai/po-config";
+import { createDoomTelemetry } from "@agimon-ai/po-telemetry";
+import { minimatch } from "minimatch";
+const FOOTER_SOURCE = "doom-autocompact";
+const STATUS_KEY = "doom-autocompact";
+//#endregion
+//#region src/services/autocompactRuntime/index.ts
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function latestPlanSnapshot(branch) {
+	for (const entry of branch.toReversed()) {
+		if (entry.type !== "custom" || entry.customType !== "agent-harness-plan-document") continue;
+		if (!entry.data || typeof entry.data !== "object") return void 0;
+		const data = entry.data;
+		if (typeof data.content !== "string" || typeof data.path !== "string") return void 0;
+		return {
+			content: data.content,
+			path: data.path
+		};
+	}
+}
+const EMPTY_CONTEXT_CONTRIBUTIONS = Object.freeze({
+	entries: Object.freeze([]),
+	errors: Object.freeze([])
+});
+function readContextContributionsSnapshot(service) {
+	if (!service) return EMPTY_CONTEXT_CONTRIBUTIONS;
+	try {
+		return service.snapshot();
+	} catch (error) {
+		return {
+			entries: [],
+			errors: [{
+				source: DOOM_CONTEXT_CONTRIBUTIONS_SERVICE,
+				id: "service-snapshot",
+				label: "Context contributions",
+				order: 0,
+				message: errorMessage(error)
+			}]
+		};
+	}
+}
+function formatContextContributions(snapshot) {
+	const sections = snapshot.entries.map((entry) => `### ${entry.label}\n${entry.text}`);
+	sections.push(...snapshot.errors.map((error) => `### ${error.label}\n(unavailable: ${error.message})`));
+	return sections.length > 0 ? sections.join("\n\n") : "(no registered context contributions)";
+}
+function runtimeStateSnapshot(branch, contextContributions) {
+	const plan = latestPlanSnapshot(branch);
+	return {
+		...plan ? { planPath: plan.path } : {},
+		contributions: contextContributions.entries,
+		contributionErrors: contextContributions.errors
+	};
+}
+function formatRuntimeState(snapshot) {
+	return `<compaction-runtime-state>
+Authoritative runtime state captured when compaction committed. Use it to resume coordination without reconstructing state from the summary.
+<active-plan>
+${snapshot.planPath ? `Source: ${snapshot.planPath}\nExact plan content is restored separately by Doom Plan.` : "(no active plan document)"}
+</active-plan>
+<context-contributions>
+${formatContextContributions({
+		entries: snapshot.contributions,
+		errors: snapshot.contributionErrors
+	})}
+</context-contributions>
+</compaction-runtime-state>`;
+}
+function steeringEnvelope(snapshot) {
+	const plan = snapshot.plan ? `Source: ${snapshot.plan.path}\n\n${snapshot.plan.content}` : "(no active plan document)";
+	const importantContext = [snapshot.readFiles.length > 0 ? `Read files: ${snapshot.readFiles.join(", ")}` : void 0, snapshot.modifiedFiles.length > 0 ? `Modified files: ${snapshot.modifiedFiles.join(", ")}` : void 0].filter((value) => Boolean(value));
+	return `<compaction-steering priority="user,plan,context-contributions,important-context,recent-messages">
+<user-prompt source="conversation">
+Treat the user's explicit goals, constraints, corrections, and preferences in the conversation as authoritative. Newer user instructions override older ones.
+</user-prompt>
+<active-plan>
+${plan}
+</active-plan>
+<context-contributions>
+${formatContextContributions(snapshot.contextContributions)}
+</context-contributions>
+<important-context>
+${importantContext.length > 0 ? importantContext.join("\n") : "(none recorded outside the conversation)"}
+</important-context>
+</compaction-steering>`;
+}
+function checkpointInstructions(pass, steering) {
+	const decision = pass === 2 ? "Start with exactly <shouldCompact>true</shouldCompact> or <shouldCompact>false</shouldCompact>. Use true when the staged summary safely retains the important parent context. Use false only when it is not yet sufficient for safe compaction.\n\n" : "";
+	return `Create Doom autocompact checkpoint pass ${pass}.
+
+${steeringEnvelope(steering)}
+
+Apply the steering evidence in priority order. Do not invent plan or contributed runtime state. Preserve verified facts and mark unresolved inference explicitly. Newer evidence replaces superseded information.
+
+${decision}Return only the decision tag when required, followed by a concise structured checkpoint using every heading below. Keep exact goals, constraints, decisions, blockers, commands, errors, file paths, validation evidence, and the immediate next action. Separate verified facts from unresolved inference.
+
+## Goal
+## Constraints & Preferences
+## Progress
+### Done
+### In Progress
+### Blocked
+## Key Decisions
+## Next Steps
+## Critical Context`;
+}
+const DEFAULT_RUNTIME_CONFIG = {
+	enabled: true,
+	ratios: {},
+	overrides: []
+};
+/**
+* What the Doom config says about this package.
+*
+* `modes.autocompact` is read first and `modes.planning.subagents` is the
+* fallback, because summarization borrowed the planning subagent model before
+* it had keys of its own and existing files still spell it that way.
+*/
+function autocompactRuntimeConfig(root, onLoadFailure) {
+	let modes;
+	try {
+		modes = loadDoomConfig(root).modes;
+	} catch (error) {
+		process.emitWarning("Doom autocompact configuration could not be loaded; using the active session model instead.");
+		onLoadFailure?.(error);
+		return DEFAULT_RUNTIME_CONFIG;
+	}
+	const configured = modes?.autocompact;
+	const agent = (configured && (configured.model !== void 0 || configured.thinking !== void 0) ? {
+		...configured.model ? { model: configured.model } : {},
+		...configured.thinking ? { thinking: configured.thinking } : {}
+	} : void 0) ?? modes?.planning?.subagents;
+	const thresholds = configured?.thresholds;
+	return {
+		enabled: configured?.enabled ?? true,
+		...agent ? { agent } : {},
+		ratios: {
+			...thresholds?.pass1 === void 0 ? {} : { 1: thresholds.pass1 },
+			...thresholds?.pass2 === void 0 ? {} : { 2: thresholds.pass2 },
+			...thresholds?.pass3 === void 0 ? {} : { 3: thresholds.pass3 }
+		},
+		overrides: configured?.overrides ?? []
+	};
+}
+//#endregion
+//#region src/services/autocompactTelemetry/index.ts
+const SERVICE_NAME = "doom-autocompact";
+const PACKAGE_NAME = "@agimon-ai/po-autocompact";
+const AUTOCOMPACT_EVENT = {
+	checkpointStarted: "doom_autocompact.checkpoint_started",
+	checkpointCompleted: "doom_autocompact.checkpoint_completed",
+	checkpointFailed: "doom_autocompact.checkpoint_failed",
+	checkpointInvalid: "doom_autocompact.checkpoint_invalid",
+	configurationLoadFailed: "doom_autocompact.configuration_load_failed",
+	contextContributionDegraded: "doom_autocompact.context_contribution_degraded",
+	contextCommitted: "doom_autocompact.context_committed",
+	contextApplied: "doom_autocompact.context_applied",
+	contextMarkerInvalid: "doom_autocompact.context_marker_invalid",
+	contextHookSlow: "doom_autocompact.context_hook_slow",
+	nativeCompactionCompleted: "doom_autocompact.native_compaction_completed"
+};
+function createAutocompactTelemetry(options = {}) {
+	const telemetry = createDoomTelemetry({
+		serviceName: SERVICE_NAME,
+		packageName: PACKAGE_NAME,
+		cwd: options.cwd,
+		workspaceRoot: options.workspaceRoot,
+		env: options.env,
+		telemetryFactory: options.telemetryFactory,
+		warn: options.warn,
+		enableLogs: true,
+		enableTraces: true
+	});
+	return {
+		recordError: (event, error, attributes) => telemetry.recordError(event, error, attributes),
+		recordWarning: (event, error, attributes) => telemetry.recordWarning(event, error, attributes),
+		recordEvent: (event, attributes) => telemetry.recordEvent(event, attributes),
+		runInSpan: (name, attributes, callback) => telemetry.runInSpan(name, attributes, callback),
+		flush: () => telemetry.flush(),
+		shutdown: () => telemetry.shutdown()
+	};
+}
+//#endregion
+//#region src/services/modelOverrides/index.ts
+/**
+* A pattern naming a provider is matched against `provider/id`, anything else
+* against the bare id. `*` does not cross `/`, so a bare pattern tested against a
+* qualified subject would never match and would read as a silently dead rule.
+*/
+function matchesModelPattern(pattern, model) {
+	const subject = pattern.includes("/") ? `${model.provider}/${model.id}` : model.id;
+	return minimatch(subject, pattern, { nocase: true });
+}
+function resolveModelTokenOverrides(model, overrides) {
+	if (!model) return {};
+	const matched = overrides.find((entry) => matchesModelPattern(entry.model, model));
+	if (!matched) return {};
+	const { pass1, pass2, pass3 } = matched.tokens;
+	return {
+		...pass1 === void 0 ? {} : { 1: pass1 },
+		...pass2 === void 0 ? {} : { 2: pass2 },
+		...pass3 === void 0 ? {} : { 3: pass3 }
+	};
+}
+//#endregion
+//#region src/services/summarizationModel/index.ts
+const THINKING_SUFFIX_PATTERN = /:(off|minimal|low|medium|high|xhigh|max)$/;
+/** Splits a `provider/model` reference, tolerating the optional thinking suffix. */
+function parseModelReference(reference) {
+	const trimmed = reference.trim();
+	const thinking = THINKING_SUFFIX_PATTERN.exec(trimmed)?.[1];
+	const identity = trimmed.replace(THINKING_SUFFIX_PATTERN, "");
+	const separator = identity.indexOf("/");
+	if (separator <= 0 || separator >= identity.length - 1) return void 0;
+	return {
+		provider: identity.slice(0, separator),
+		modelId: identity.slice(separator + 1),
+		...thinking ? { thinking } : {}
+	};
+}
+//#endregion
+//#region src/services/nativeAutocompact/index.ts
+/** Exact canonical-prefix comparison refuses to apply summaries to edited or replaced evidence. */
+function tailAfter(snapshot, current) {
+	if (snapshot.length > current.length || snapshot.some((message, index) => JSON.stringify(message) !== JSON.stringify(current[index]))) return void 0;
+	return current.slice(snapshot.length);
+}
+function leaf(entries) {
+	return entries.findLast((entry) => entry.type !== "custom" || entry.customType !== "doom-autocompact-state" && entry.customType !== "doom-autocompact-checkpoint")?.id ?? "root";
+}
+function createNativeAutocompact(dependencies = {}) {
+	const telemetry = dependencies.telemetry ?? createAutocompactTelemetry();
+	let active = true;
+	let generation = 0;
+	let state = createInitialState();
+	let snapshot;
+	let previousSnapshot;
+	let context;
+	let contributions;
+	let controller;
+	let serial = Promise.resolve();
+	const work = /* @__PURE__ */ new Set();
+	const applied = /* @__PURE__ */ new Set();
+	const invalid = /* @__PURE__ */ new Set();
+	let configFailureReported = false;
+	let footer;
+	let navigating = false;
+	let lastNativeCompactionId;
+	let checkpointBoundary;
+	const attributes = () => ({
+		"pi.session.id": context?.sessionId ?? "",
+		"autocompact.cycle": state.cycle,
+		"autocompact.pass": state.pass,
+		...state.requestId ? { "autocompact.request.id": state.requestId } : {},
+		...state.snapshotLeafId ? { "autocompact.snapshot_leaf_id": state.snapshotLeafId } : {},
+		...state.snapshotTokens === void 0 ? {} : { "autocompact.tokens_before": state.snapshotTokens }
+	});
+	const configured = (execution) => autocompactRuntimeConfig(execution.repoRoot, (error) => {
+		if (!configFailureReported) {
+			configFailureReported = true;
+			telemetry.recordWarning(AUTOCOMPACT_EVENT.configurationLoadFailed, error, attributes());
+		}
+	});
+	const alive = (version) => active && !navigating && generation === version;
+	const refreshStatus = (execution) => {
+		const phase = state.phase === "checkpoint_pending" ? "summarizing" : state.phase === "checkpoint_ready" ? "applying" : void 0;
+		footer?.update(phase ? {
+			fullText: `Compacting p${state.pass}`,
+			compactText: `C${state.pass}`
+		} : void 0);
+		execution.client.setStatus(STATUS_KEY, phase ? `Compacting pass ${state.pass} (${phase})…` : void 0);
+	};
+	const enqueue = (callback) => {
+		const version = generation;
+		const operation = serial.then(async () => {
+			if (alive(version)) await callback();
+		});
+		serial = operation.catch(() => void 0);
+		return operation;
+	};
+	const persist = async (execution, version) => {
+		if (!alive(version)) return;
+		await execution.session.appendCustomEntry(STATE_CUSTOM_TYPE, {
+			...state,
+			nativeSnapshot: snapshot,
+			nativePreviousSnapshot: previousSnapshot,
+			nativeLastCompactionId: lastNativeCompactionId
+		});
+		if (alive(version)) refreshStatus(execution);
+	};
+	const clear = () => {
+		delete state.requestId;
+		delete state.snapshotLeafId;
+		delete state.snapshotTokens;
+		delete state.pendingCheckpoint;
+		delete state.compactionPass;
+		snapshot = void 0;
+	};
+	const fail = async (execution, version, error, malformed = false) => {
+		if (!alive(version)) return;
+		const eventAttributes = attributes();
+		const attempts = state.invalidAttempts + 1;
+		const pass = state.pass;
+		const failedLeaf = state.snapshotLeafId;
+		state.invalidAttempts += 1;
+		if (state.invalidAttempts >= 3) {
+			state.checkpointQueue = state.checkpointQueue.filter((item) => item !== pass);
+			state.exhaustedPasses.push(pass);
+			state.invalidAttempts = 0;
+		}
+		state.phase = "waiting";
+		clear();
+		state.lastAttemptLeafId = failedLeaf;
+		await persist(execution, version);
+		if (!alive(version)) return;
+		await execution.client.notify({
+			body: `Doom autocompact summarization pass ${pass} failed: ${error instanceof Error ? error.message : String(error)}`,
+			level: "error"
+		});
+		await telemetry.recordError(malformed ? AUTOCOMPACT_EVENT.checkpointInvalid : AUTOCOMPACT_EVENT.checkpointFailed, error, {
+			...eventAttributes,
+			"autocompact.checkpoint.attempts": attempts,
+			"autocompact.checkpoint.exhausted": attempts >= 3
+		});
+	};
+	const branch = async (execution) => await execution.session.entries();
+	const canonical = async (execution, entries) => {
+		if (!execution.session.contextMessages) throw new Error("Canonical context is unavailable for autocompact.");
+		return projectContextMessages(await execution.session.contextMessages(), entries).messages;
+	};
+	const contributionSnapshot = async (execution) => {
+		const result = readContextContributionsSnapshot(contributions);
+		for (const error of result.errors) {
+			await execution.client.notify({
+				body: `Doom autocompact context contribution degraded (${error.source}/${error.id}): ${error.message}`,
+				level: "warning"
+			});
+			await telemetry.recordWarning(AUTOCOMPACT_EVENT.contextContributionDegraded, new Error(error.message), {
+				...attributes(),
+				"autocompact.context_contribution.source": error.source,
+				"autocompact.context_contribution.id": error.id,
+				"autocompact.context_contribution.order": error.order
+			});
+		}
+		return result;
+	};
+	const runtimeState = async (execution, entries, version, appendMessage = checkpointBoundary?.appendMessage.bind(checkpointBoundary)) => {
+		const saved = runtimeStateSnapshot(entries, await contributionSnapshot(execution));
+		if (!alive(version)) return;
+		await appendMessage?.({
+			type: RUNTIME_STATE_MESSAGE_TYPE,
+			text: formatRuntimeState(saved),
+			display: false,
+			details: {
+				version: 2,
+				...saved
+			}
+		});
+		return {
+			"autocompact.runtime.plan_present": Boolean(saved.planPath),
+			"autocompact.runtime.contribution_count": saved.contributions.length,
+			"autocompact.runtime.contribution_error_count": saved.contributionErrors.length
+		};
+	};
+	const resetCycle = () => {
+		state.phase = "waiting";
+		state.checkpointQueue = [];
+		state.exhaustedPasses = [];
+		state.invalidAttempts = 0;
+		state.baselinePending = true;
+		state.cycle += 1;
+		state.pass = 1;
+		delete state.lastAttemptLeafId;
+		delete state.latestCheckpointSnapshotLeafId;
+		clear();
+		previousSnapshot = void 0;
+	};
+	const applyReady = async (execution, version) => {
+		if (state.phase !== "checkpoint_ready" || !state.pendingCheckpoint || !state.requestId || !state.snapshotLeafId) return false;
+		const decision = parseCheckpointDecision(state.pendingCheckpoint);
+		if (!isStructuredCheckpoint(decision.summary)) {
+			await fail(execution, version, /* @__PURE__ */ new Error("Summarization returned an incomplete checkpoint."), true);
+			return false;
+		}
+		const entries = await branch(execution);
+		const messages = await canonical(execution, entries);
+		if (!alive(version)) return false;
+		const tail = snapshot && tailAfter(snapshot, messages);
+		if (!tail) {
+			await fail(execution, version, /* @__PURE__ */ new Error("Canonical checkpoint evidence changed; summary must be regenerated."));
+			return false;
+		}
+		const pass = state.pass;
+		if (pass === 1 || pass === 2 && decision.shouldCompact !== true) {
+			await execution.session.appendCustomEntry(CHECKPOINT_MESSAGE_TYPE, {
+				...checkpointRequestDetails(state.cycle, pass, state.requestId),
+				summary: decision.summary
+			});
+			if (!alive(version)) return false;
+			previousSnapshot = snapshot;
+			state.latestCheckpointSnapshotLeafId = state.snapshotLeafId;
+			state.checkpointQueue = state.checkpointQueue.filter((item) => item !== pass);
+			state.pass = pass === 1 ? 2 : 3;
+			state.phase = "waiting";
+			state.invalidAttempts = 0;
+			clear();
+			await persist(execution, version);
+			return false;
+		}
+		if (!execution.session.appendMessage) throw new Error("Checkpoint messages are unavailable.");
+		const files = mergeFileDetails(state, fileOperationsFromMessages(messages));
+		const details = {
+			...files,
+			doomAutocompact: {
+				version: 2,
+				cycle: state.cycle,
+				pass,
+				requestId: state.requestId,
+				snapshotLeafId: state.snapshotLeafId,
+				tokensBefore: state.snapshotTokens ?? 0
+			},
+			retainedMessages: tail
+		};
+		const idle = (await execution.session.activity()).isIdle;
+		if (!alive(version)) return false;
+		const id = await execution.session.appendMessage({
+			type: CONTEXT_MESSAGE_TYPE,
+			text: withCanonicalFileSections(decision.summary, files),
+			display: false,
+			details
+		});
+		if (!alive(version) || !id) return false;
+		await execution.session.setLabel?.(id, `autocompact:c${state.cycle}:p${pass}`);
+		if (!alive(version)) return false;
+		const runtimeAttributes = await runtimeState(execution, entries, version, execution.session.appendMessage.bind(execution.session));
+		if (!alive(version)) return false;
+		const committedAttributes = attributes();
+		state.readFiles = files.readFiles;
+		state.modifiedFiles = files.modifiedFiles;
+		resetCycle();
+		await persist(execution, version);
+		if (!alive(version)) return false;
+		await telemetry.recordEvent(AUTOCOMPACT_EVENT.contextCommitted, {
+			...committedAttributes,
+			"autocompact.message_count.before": messages.length,
+			"autocompact.message_count.retained": tail.length,
+			"autocompact.apply_mode": idle ? "idle" : "turn_end",
+			...runtimeAttributes
+		});
+		if (idle && alive(version)) await execution.session.admitPrompt?.("Asynchronous compaction completed. Continue from the compacted checkpoint's immediate next action without repeating completed work.", "steer", void 0, `${RESUME_MESSAGE_TYPE}:${details.doomAutocompact.requestId}`);
+		return true;
+	};
+	const progress = async (execution, allowBusy = false, appendMessage = checkpointBoundary?.appendMessage.bind(checkpointBoundary)) => {
+		const version = generation;
+		context = execution;
+		const activity = await execution.session.activity();
+		if (!alive(version) || activity.hasPendingMessages) return;
+		if (appendMessage && (activity.isIdle || allowBusy)) {
+			const checkpointExecution = {
+				...execution,
+				session: {
+					...execution.session,
+					appendMessage
+				}
+			};
+			if (await applyReady(checkpointExecution, version)) return;
+		}
+		if (!alive(version) || state.phase !== "waiting") return;
+		const configuration = configured(execution);
+		if (!configuration.enabled || !execution.session.contextUsage || !execution.textCompletion?.summarize) return;
+		const usage = await execution.session.contextUsage();
+		const entries = await branch(execution);
+		if (!alive(version) || !usage || usage.tokens === null) return;
+		if (state.baselinePending) {
+			if (!baselineUsageIsSettled(entries)) return;
+			state.baselineTokens = usage.tokens;
+			state.baselinePending = false;
+			await persist(execution, version);
+			return;
+		}
+		const currentLeaf = leaf(entries);
+		if (currentLeaf === state.lastAttemptLeafId) return;
+		const thresholds = effectiveThresholds(usage.contextWindow, state.baselineTokens, configuration.ratios, resolveModelTokenOverrides(execution.model, configuration.overrides));
+		for (const pass of [
+			1,
+			2,
+			3
+		]) if (pass >= state.pass && !state.checkpointQueue.includes(pass) && !state.exhaustedPasses.includes(pass) && usage.tokens >= thresholds[pass]) state.checkpointQueue.push(pass);
+		const pass = state.checkpointQueue[0];
+		if (!pass) return;
+		const messages = await canonical(execution, entries);
+		const steering = await contributionSnapshot(execution);
+		if (!alive(version)) return;
+		snapshot = messages;
+		const previous = pass > 1 ? checkpointSummaryFromEntry(latestCheckpointArtifactEntry(entries)) : void 0;
+		const requestId = createRequestId(execution.sessionId, state.cycle, pass, currentLeaf);
+		state.phase = "checkpoint_pending";
+		state.pass = pass;
+		state.requestId = requestId;
+		state.snapshotLeafId = currentLeaf;
+		state.snapshotTokens = usage.tokens;
+		delete state.lastAttemptLeafId;
+		delete state.pendingCheckpoint;
+		await persist(execution, version);
+		if (!alive(version)) return;
+		controller?.abort();
+		controller = new AbortController();
+		const signal = controller.signal;
+		const ownReference = configuration.agent?.model ? parseModelReference(configuration.agent.model) : void 0;
+		const candidate = ownReference ? `${ownReference.provider}/${ownReference.modelId}` : void 0;
+		const reference = candidate && execution.textCompletion.available(candidate) ? candidate : execution.model ? `${execution.model.provider}/${execution.model.id}` : "";
+		const thinking = configuration.agent?.thinking ?? (reference === candidate ? ownReference?.thinking : void 0) ?? (await execution.session.readModelSettings?.())?.thinkingLevel;
+		if (!alive(version)) return;
+		const requestAttributes = {
+			...attributes(),
+			"autocompact.message_count.before": messages.length
+		};
+		const delta = previousSnapshot ? tailAfter(previousSnapshot, messages) : void 0;
+		const completion = telemetry.runInSpan("doom_autocompact.checkpoint", requestAttributes, async () => {
+			await telemetry.recordEvent(AUTOCOMPACT_EVENT.checkpointStarted, requestAttributes);
+			return execution.textCompletion.summarize(reference, {
+				messages: pass > 1 && delta ? delta : messages,
+				instructions: checkpointInstructions(pass, {
+					plan: latestPlanSnapshot(entries),
+					contextContributions: steering,
+					readFiles: state.readFiles,
+					modifiedFiles: state.modifiedFiles
+				}),
+				...previous ? { previousSummary: previous } : {},
+				...thinking ? { thinkingLevel: thinking } : {},
+				signal
+			});
+		}).then(async (summary) => {
+			await enqueue(async () => {
+				if (!alive(version) || signal.aborted || state.requestId !== requestId) return;
+				if (!summary.trim()) {
+					await fail(execution, version, /* @__PURE__ */ new Error("Summarization returned an empty checkpoint."));
+					return;
+				}
+				state.phase = "checkpoint_ready";
+				state.pendingCheckpoint = summary.trim();
+				await persist(execution, version);
+				if (!alive(version)) return;
+				await telemetry.recordEvent(AUTOCOMPACT_EVENT.checkpointCompleted, {
+					...requestAttributes,
+					"autocompact.checkpoint.characters": summary.length
+				});
+				if ((await execution.session.activity()).isIdle && alive(version)) await progress(execution);
+			});
+		}).catch(async (error) => {
+			await enqueue(async () => {
+				if (alive(version) && state.requestId === requestId) await fail(execution, version, error);
+			});
+		});
+		work.add(completion);
+		completion.then(() => work.delete(completion), () => work.delete(completion));
+	};
+	const restore = async (execution) => {
+		if (!active) return;
+		if (!checkpointBoundary) {
+			if (!execution.session.registerCheckpointBoundary) throw new Error("Native checkpoint boundaries are unavailable.");
+			checkpointBoundary = execution.session.registerCheckpointBoundary(async (boundary) => {
+				if (!active || navigating || boundary.signal?.aborted) return;
+				const current = context ?? execution;
+				await enqueue(() => boundary.signal?.aborted ? Promise.resolve() : progress(current, true, boundary.appendMessage.bind(boundary)));
+			});
+		}
+		navigating = false;
+		generation += 1;
+		const version = generation;
+		controller?.abort(/* @__PURE__ */ new Error("Autocompact session generation changed."));
+		controller = void 0;
+		context = execution;
+		applied.clear();
+		invalid.clear();
+		const entries = await branch(execution);
+		if (!alive(version)) return;
+		const entry = entries.findLast((item) => item.type === "custom" && item.customType === "doom-autocompact-state");
+		const data = entry?.type === "custom" && entry.data && typeof entry.data === "object" ? entry.data : void 0;
+		state = parseState(data) ?? createInitialState();
+		lastNativeCompactionId = typeof data?.nativeLastCompactionId === "string" ? data.nativeLastCompactionId : void 0;
+		const validMessages = (value) => Array.isArray(value) && value.every((message) => message && typeof message === "object" && typeof message.role === "string");
+		snapshot = validMessages(data?.nativeSnapshot) ? data.nativeSnapshot : void 0;
+		previousSnapshot = validMessages(data?.nativePreviousSnapshot) ? data.nativePreviousSnapshot : void 0;
+		if (state.phase === "checkpoint_ready" && state.requestId) {
+			const artifacts = entries.slice(entry ? entries.indexOf(entry) + 1 : 0);
+			const committed = artifacts.findLast((item) => {
+				const message = item.type === "message" ? item.message : void 0;
+				if (message?.role !== "custom" || message.customType !== "doom-autocompact-context") return false;
+				const details = contextDetailsFromUnknown(message.details);
+				return details !== void 0 && details.doomAutocompact.requestId === state.requestId && details.doomAutocompact.cycle === state.cycle && details.doomAutocompact.pass === state.pass && details.doomAutocompact.snapshotLeafId === state.snapshotLeafId && isStructuredCheckpoint(checkpointSummaryFromEntry(item) ?? "");
+			});
+			if (committed?.type === "message" && committed.message.role === "custom") {
+				const details = contextDetailsFromUnknown(committed.message.details);
+				state.readFiles = details.readFiles;
+				state.modifiedFiles = details.modifiedFiles;
+				resetCycle();
+				await persist(execution, version);
+			} else if (artifacts.findLast((item) => {
+				if (item.type !== "custom" || item.customType !== "doom-autocompact-checkpoint") return false;
+				const details = item.data;
+				return details?.version === 2 && details.requestId === state.requestId && details.cycle === state.cycle && details.pass === state.pass && isStructuredCheckpoint(checkpointSummaryFromEntry(item) ?? "");
+			}) && (state.pass === 1 || state.pass === 2)) {
+				previousSnapshot = snapshot;
+				state.latestCheckpointSnapshotLeafId = state.snapshotLeafId;
+				state.checkpointQueue = state.checkpointQueue.filter((pass) => pass !== state.pass);
+				state.pass = state.pass === 1 ? 2 : 3;
+				state.phase = "waiting";
+				state.invalidAttempts = 0;
+				clear();
+				await persist(execution, version);
+			}
+		}
+		if (state.phase !== "waiting" && state.phase !== "checkpoint_ready") {
+			state.phase = "waiting";
+			clear();
+			await persist(execution, version);
+		}
+		if (alive(version)) await enqueue(() => progress(execution));
+	};
+	return {
+		hooks: [
+			{
+				event: "session_start",
+				handle: (_event, execution) => restore(execution)
+			},
+			{
+				event: "session_tree",
+				handle: (event, execution) => {
+					if (!active) return;
+					if (event.status === "started") {
+						navigating = true;
+						generation += 1;
+						controller?.abort(/* @__PURE__ */ new Error("Autocompact navigation started."));
+						return;
+					}
+					return restore(execution);
+				}
+			},
+			{
+				event: "turn_end",
+				handle: (_event, execution) => enqueue(() => progress(execution))
+			},
+			{
+				event: "agent_settled",
+				handle: (_event, execution) => enqueue(() => progress(execution))
+			},
+			{
+				event: "session_before_compact",
+				handle: (event, execution) => active && !navigating && configured(execution).enabled && event.reason === "threshold" && (state.phase === "checkpoint_pending" || state.phase === "checkpoint_ready" || state.baselinePending) ? { cancel: true } : void 0
+			},
+			{
+				event: "context",
+				async handle(event, execution) {
+					if (!active || navigating || !Array.isArray(event.messages)) return;
+					const started = Date.now();
+					try {
+						const version = generation;
+						const entries = await branch(execution);
+						if (!alive(version)) return;
+						const projection = projectContextMessages(event.messages, entries);
+						if (projection.invalidMarker) {
+							const id = leaf(entries);
+							if (!invalid.has(id)) {
+								invalid.add(id);
+								await telemetry.recordError(AUTOCOMPACT_EVENT.contextMarkerInvalid, /* @__PURE__ */ new Error("Doom autocompact context marker is malformed."), {
+									...attributes(),
+									"autocompact.leaf_id": id
+								});
+							}
+							return;
+						}
+						if (!projection.marker) return;
+						if (!applied.has(projection.marker.requestId)) {
+							applied.add(projection.marker.requestId);
+							await telemetry.recordEvent(AUTOCOMPACT_EVENT.contextApplied, {
+								...attributes(),
+								"autocompact.request.id": projection.marker.requestId,
+								"autocompact.cycle": projection.marker.cycle,
+								"autocompact.pass": projection.marker.pass,
+								"autocompact.snapshot_leaf_id": projection.marker.snapshotLeafId,
+								"autocompact.tokens_before": projection.marker.tokensBefore,
+								"autocompact.message_count.before": event.messages.length,
+								"autocompact.message_count.after": projection.messages.length,
+								"autocompact.message_count.retained": projection.retainedMessageCount
+							});
+						}
+						return alive(version) ? { messages: projection.messages } : void 0;
+					} finally {
+						const hookMs = Date.now() - started;
+						if (active && hookMs >= 25) await telemetry.recordEvent(AUTOCOMPACT_EVENT.contextHookSlow, {
+							...attributes(),
+							hook_ms: hookMs,
+							"autocompact.message_count": event.messages.length
+						});
+					}
+				}
+			},
+			{
+				event: "session_compact",
+				handle: (event, execution) => {
+					if (!active || event.status !== "completed" || typeof event.entryId !== "string" || event.entryId === lastNativeCompactionId) return;
+					const observedGeneration = generation;
+					return enqueue(async () => {
+						const entries = await branch(execution);
+						const compacted = entries.findLast((entry) => entry.type === "compaction");
+						if (!alive(observedGeneration) || !compacted || compacted.id !== event.entryId || compacted.id === lastNativeCompactionId) return;
+						generation += 1;
+						const version = generation;
+						controller?.abort(/* @__PURE__ */ new Error("Native compaction superseded checkpoint."));
+						controller = void 0;
+						lastNativeCompactionId = compacted.id;
+						const files = mergeFileDetails(state, void 0, fileDetailsFromUnknown("details" in compacted ? compacted.details : void 0));
+						state.readFiles = files.readFiles;
+						state.modifiedFiles = files.modifiedFiles;
+						await execution.session.setLabel?.(compacted.id, `autocompact:c${state.cycle}:external`);
+						if (!alive(version)) return;
+						const runtimeAttributes = await runtimeState(execution, entries, version);
+						if (!alive(version)) return;
+						const nativeAttributes = attributes();
+						resetCycle();
+						await persist(execution, version);
+						if (alive(version)) await telemetry.recordEvent(AUTOCOMPACT_EVENT.nativeCompactionCompleted, {
+							...nativeAttributes,
+							"autocompact.native.reason": typeof event.reason === "string" ? event.reason : "unknown",
+							"autocompact.native.from_extension": "fromHook" in compacted && compacted.fromHook === true,
+							"autocompact.tokens_before": compacted.tokensBefore,
+							...runtimeAttributes
+						});
+					});
+				}
+			}
+		],
+		plugin(cordis) {
+			cordis.inject([DOOM_UI_HUB_SERVICE], (injected) => {
+				const contribution = requireDoomUiHub(injected).registerFooter({
+					source: FOOTER_SOURCE,
+					id: "autocompact",
+					order: 20
+				});
+				footer = contribution;
+				if (context && active) refreshStatus(context);
+				return () => {
+					contribution.dispose();
+					if (footer === contribution) footer = void 0;
+				};
+			});
+			cordis.inject([DOOM_CONTEXT_CONTRIBUTIONS_SERVICE], (injected) => {
+				const service = requireDoomContextContributions(injected);
+				contributions = service;
+				return () => {
+					if (contributions === service) contributions = void 0;
+				};
+			});
+		},
+		start: restore,
+		async stop() {
+			active = false;
+			checkpointBoundary?.dispose();
+			checkpointBoundary = void 0;
+			generation += 1;
+			controller?.abort(/* @__PURE__ */ new Error("Autocompact is shutting down."));
+			await Promise.allSettled([...work, serial]);
+			context?.client.setStatus(STATUS_KEY, void 0);
+			footer?.update(void 0);
+			footer = void 0;
+			context = void 0;
+			contributions = void 0;
+			await telemetry.shutdown();
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = defineRoot(() => {
+	const runtime = createNativeAutocompact();
+	return {
+		value: runtime,
+		services: [runtime.plugin],
+		onDispose: runtime.stop
+	};
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-settled.server.ts
+var agent_settled_server_default = defineHook(({ root }) => root.hooks.find((hook) => hook.event === "agent_settled"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/context.server.ts
+var context_server_default = defineHook(({ root }) => root.hooks.find((hook) => hook.event === "context"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-before-compact.server.ts
+var session_before_compact_server_default = defineHook(({ root }) => root.hooks.find((hook) => hook.event === "session_before_compact"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-compact.server.ts
+var session_compact_server_default = defineHook(({ root }) => root.hooks.find((hook) => hook.event === "session_compact"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-start.server.ts
+var session_start_server_default = defineHook(({ root }) => root.hooks.find((hook) => hook.event === "session_start"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-tree.server.ts
+var session_tree_server_default = defineHook(({ root }) => root.hooks.find((hook) => hook.event === "session_tree"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/turn-end.server.ts
+var turn_end_server_default = defineHook(({ root }) => root.hooks.find((hook) => hook.event === "turn_end"));
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = defineServerPlugin({
+	name: "@agimon-ai/po-autocompact",
+	providerOverrides: composeServerProviderOverrides(root_server_default),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...composeRootHooks(scopeSession),
+			get hooks() {
+				return [
+					via({ event: "agent_settled" }, at(agent_settled_server_default, contextSession)),
+					via({ event: "context" }, at(context_server_default, contextSession)),
+					via({ event: "session_before_compact" }, at(session_before_compact_server_default, contextSession)),
+					via({ event: "session_compact" }, at(session_compact_server_default, contextSession)),
+					via({ event: "session_start" }, at(session_start_server_default, contextSession)),
+					via({ event: "session_tree" }, at(session_tree_server_default, contextSession)),
+					via({ event: "turn_end" }, at(turn_end_server_default, contextSession))
+				];
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+export { facet as default, facet };
+
+//# sourceMappingURL=server.mjs.map