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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vuong Ngo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# @agimon-ai/po-autocompact
+
+Staged checkpoint summarization and iterative context compaction for Po.
+
+Part of the [Po distribution](https://www.npmjs.com/package/@agimon-ai/po).
+
+Instead of waiting for one final summary near the context limit, Autocompact creates up to three
+asynchronous checkpoints and combines each checkpoint with subsequent messages.
+
+> **Alpha:** thresholds and compaction steering may change between releases.
+
+## Requirements
+
+- Node.js 24 or newer
+- Po headless/server host
+- Authentication for the model selected for summarization
+
+## Install
+
+`po init` and `dpi init` include Autocompact in `default.packages` in `.po/modes.yaml`.
+Remove it or move it to a named layer to change which major modes load it.
+The native session facet is `@agimon-ai/po-autocompact/extensions/server`.
+This package does not provide a Pi extension or terminal UI.
+
+## Checkpoint ladder
+
+The native owner uses thresholds around 50%, 75%, and 95% of the usable context window,
+subject to token caps and the host's native-compaction clamp:
+
+1. create an initial compact summary;
+2. combine it with later messages and allow the model to decide whether compaction is ready;
+3. combine again and force compaction on the final pass.
+
+## Per-model token checkpoints
+
+Ratios scale with the window, which is usually what you want. On a very large window they can
+also mean the first checkpoint waits far longer than you would like: half of a one-million-token
+window is 500,000 tokens. `modes.autocompact.overrides` pins individual passes to an absolute
+token count for the models you name, and leaves every other model on the ratio ladder.
+
+```yaml
+modes:
+  autocompact:
+    overrides:
+      - model: 'claude-opus-4-[6-9]'
+        tokens:
+          pass1: 75000
+          pass2: 150000
+          pass3: 200000
+```
+
+- Entries are tried in file order and the first match wins. A model matching nothing behaves
+  exactly as it does without this key.
+- `model` is a glob supporting `*` and character classes such as `[6-9]`. A pattern containing
+  `/` is matched against `provider/id`, anything else against the bare model id, because the
+  wildcard does not cross the separator. Matching ignores case.
+- The lower of the ratio and the token count wins, so an override can only bring a checkpoint
+  forward, never push one past the native compaction boundary.
+- Counts are compared against total context usage, not against growth since the last compaction.
+- A count at or below the current cycle's baseline is ignored and the pass falls back to its
+  ratio. Without that, a compaction landing above the count would satisfy the pass as soon as
+  the next cycle opened and re-fire it every turn.
+- A pass never fires before the one before it. A list that puts a later pass lower is raised to
+  match, the same way a ratio below the previous pass is.
+- A repository config replaces the global list whole rather than merging entry by entry.
+- These keys are not on the cockpit settings page; edit `.po/config.yaml` directly.
+  Summarization runs asynchronously in the background, on the session's own provider, so a model
+  registered by a Pi provider extension summarizes through that extension. Checkpoints are
+  persisted as hidden session entries and used for later steering.
+
+Po uses autocompact's configured model and thinking level, then planning subagent
+configuration, then the active session model. Each checkpoint can make another provider request,
+consume quota, and require credentials. Provider errors or missing authentication affect checkpoint
+generation rather than granting a free local summary.
+
+## Coordination state
+
+Autocompact does not own `@agimon-ai/po-task` or `@agimon-ai/po-team` persistence. The
+native owner reads registered context-contribution snapshots from those packages when available, while Task's
+`tasks.json` and Team's run and intercom state remain owned by their respective packages. Missing
+snapshot data is reported as unavailable and must not be inferred from an Autocompact summary.
+
+## Public API
+
+```ts
+import { thresholdTokens } from '@agimon-ai/po-autocompact';
+import type { AutocompactPass } from '@agimon-ai/po-autocompact';
+```
+
+The server host mounts the native facet and owns its lifecycle. `thresholdTokens` exposes
+the threshold policy for hosts that need to preview or test checkpoint boundaries.
+
+## Development
+
+```bash
+pnpm build
+pnpm typecheck
+pnpm test
+pnpm lint
+```
+
+Maintained by [Agimon](https://agimon.ai/about).
+
+## License
+
+MIT
+
+## Extension lifecycle and source layout
+
+The session root constructs one native owner. Routed server hooks drive checkpoints, context
+projection, compaction observation, and navigation invalidation. Shutdown disposes the checkpoint
+boundary, cancels summarization, and drains pending work before releasing telemetry.
+
+The web entry declares settings sections. Public exports contain reusable policy capabilities.

package/dist/apiContracts.cjs

@@ -0,0 +1,17 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region src/schemas/apiContracts.ts
+/** This facet contributes agent tools, commands or lifecycle only, with no separate HTTP or socket surface. */
+const apiContracts = (0, require("@agimon-ai/po-core/apiContracts").defineApiContract)({
+	version: 1,
+	http: [],
+	sockets: [],
+	dynamic: []
+});
+//#endregion
+exports.apiContracts = apiContracts;
+exports.default = apiContracts;
+
+//# sourceMappingURL=apiContracts.cjs.map

package/dist/apiContracts.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.cjs","names":["defineApiContract"],"sources":["../src/schemas/apiContracts.ts"],"sourcesContent":["import { defineApiContract } from '@agimon-ai/po-core/apiContracts';\n\n/** This facet contributes agent tools, commands or lifecycle only, with no separate HTTP or socket surface. */\nexport const apiContracts = defineApiContract({ version: 1, http: [], sockets: [], dynamic: [] });\nexport default apiContracts;\n"],"mappings":";;;;;;AAGA,MAAa,gBAAA,4CAAeA,CAAAA,CAAAA,kBAAAA,CAAkB;CAAE,SAAS;CAAG,MAAM,CAAC;CAAG,SAAS,CAAC;CAAG,SAAS,CAAC;AAAE,CAAC"}

package/dist/apiContracts.d.mts

@@ -0,0 +1,53 @@
+//#region src/schemas/apiContracts.d.ts
+/** This facet contributes agent tools, commands or lifecycle only, with no separate HTTP or socket surface. */
+export declare const apiContracts: {
+  version: 1;
+  protocols?: Record<string, string> | undefined;
+  schemas?: Record<string, boolean | object> | undefined;
+  http: {
+    id: string;
+    scope: "global" | "session" | "workspace";
+    basePath?: string | undefined;
+    path: string;
+    method: "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT";
+    description: string;
+    availability?: string | undefined;
+    authentication: "device" | "none" | "owner";
+    parameters?: {
+      name: string;
+      in: "header" | "path" | "query";
+      required: boolean;
+      schema: boolean | object;
+    }[] | undefined;
+    body?: {
+      contentType: string;
+      contentTypes?: string[] | undefined;
+      required: boolean;
+      schema: boolean | object;
+    } | undefined;
+    responses: Record<string, {
+      description: string;
+      contentType?: string | undefined;
+      schema?: boolean | object | undefined;
+      events?: Record<string, boolean | object> | undefined;
+    }>;
+  }[];
+  sockets: {
+    id: string;
+    scope: "global" | "session" | "workspace";
+    description: string;
+    availability?: string | undefined;
+    service: string;
+    member: string;
+    direction: "client-to-server" | "server-to-client";
+    kind: "channel" | "method" | "state";
+    input: boolean | object;
+    output?: boolean | object | undefined;
+    errors?: boolean | object | undefined;
+  }[];
+  dynamic: string[];
+  gaps?: string[] | undefined;
+};
+//#endregion
+export { apiContracts as default };
+//# sourceMappingURL=apiContracts.d.mts.map

package/dist/apiContracts.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.d.mts","names":[],"sources":["../src/schemas/apiContracts.ts"],"mappings":";;qBAGa"}

package/dist/apiContracts.mjs

@@ -0,0 +1,13 @@
+import { defineApiContract } from "@agimon-ai/po-core/apiContracts";
+//#region src/schemas/apiContracts.ts
+/** This facet contributes agent tools, commands or lifecycle only, with no separate HTTP or socket surface. */
+const apiContracts = defineApiContract({
+	version: 1,
+	http: [],
+	sockets: [],
+	dynamic: []
+});
+//#endregion
+export { apiContracts, apiContracts as default };
+
+//# sourceMappingURL=apiContracts.mjs.map

package/dist/apiContracts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.mjs","names":[],"sources":["../src/schemas/apiContracts.ts"],"sourcesContent":["import { defineApiContract } from '@agimon-ai/po-core/apiContracts';\n\n/** This facet contributes agent tools, commands or lifecycle only, with no separate HTTP or socket surface. */\nexport const apiContracts = defineApiContract({ version: 1, http: [], sockets: [], dynamic: [] });\nexport default apiContracts;\n"],"mappings":";;;AAGA,MAAa,eAAe,kBAAkB;CAAE,SAAS;CAAG,MAAM,CAAC;CAAG,SAAS,CAAC;CAAG,SAAS,CAAC;AAAE,CAAC"}

package/dist/compactionPolicy-BIJJHcBP.cjs

@@ -0,0 +1,459 @@
+let _earendil_works_pi_coding_agent = require("@earendil-works/pi-coding-agent");
+//#region src/constants/autocompact.ts
+const STATE_CUSTOM_TYPE = "doom-autocompact-state";
+const CHECKPOINT_MESSAGE_TYPE = "doom-autocompact-checkpoint";
+const CONTEXT_MESSAGE_TYPE = "doom-autocompact-context";
+const RESUME_MESSAGE_TYPE = "doom-autocompact-resume";
+const RUNTIME_STATE_MESSAGE_TYPE = "doom-autocompact-runtime-state";
+const COMPACTION_THRESHOLDS = {
+	1: {
+		ratio: .5,
+		capTokens: 2e5
+	},
+	2: {
+		ratio: .75,
+		capTokens: 5e5
+	},
+	3: {
+		ratio: .95,
+		capTokens: 8e5
+	}
+};
+const CHECKPOINT_HEADINGS = [
+	"## Goal",
+	"## Constraints & Preferences",
+	"## Progress",
+	"### Done",
+	"### In Progress",
+	"### Blocked",
+	"## Key Decisions",
+	"## Next Steps",
+	"## Critical Context"
+];
+//#endregion
+//#region src/services/compactionPolicy/index.ts
+function customMessage(entry) {
+	if (entry.type === "custom_message") return entry;
+	if (entry.type === "message" && entry.message.role === "custom") return entry.message;
+}
+const SHOULD_COMPACT_PATTERN = /<shouldCompact>\s*(true|false)\s*<\/shouldCompact>/i;
+const FILE_SECTION_PATTERN = /\n*<(?:read-files|modified-files)>[\s\S]*?<\/(?:read-files|modified-files)>/g;
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isPass(value) {
+	return value === 1 || value === 2 || value === 3;
+}
+function assistantText(entry) {
+	if (entry.type !== "message" || entry.message.role !== "assistant") return void 0;
+	return entry.message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim() || void 0;
+}
+function isAutocompactMessage(value) {
+	return isRecord(value) && typeof value.role === "string";
+}
+function contextDetailsFromUnknown(value) {
+	if (!isRecord(value) || !isStringArray(value.readFiles) || !isStringArray(value.modifiedFiles)) return void 0;
+	if (!Array.isArray(value.retainedMessages) || !value.retainedMessages.every(isAutocompactMessage)) return void 0;
+	if (!isRecord(value.doomAutocompact)) return void 0;
+	const marker = value.doomAutocompact;
+	if (marker.version !== 2 || marker.pass !== 2 && marker.pass !== 3 || typeof marker.cycle !== "number" || typeof marker.requestId !== "string" || typeof marker.snapshotLeafId !== "string" || typeof marker.tokensBefore !== "number") return void 0;
+	return {
+		readFiles: [...value.readFiles],
+		modifiedFiles: [...value.modifiedFiles],
+		retainedMessages: [...value.retainedMessages],
+		doomAutocompact: {
+			version: 2,
+			cycle: marker.cycle,
+			pass: marker.pass,
+			requestId: marker.requestId,
+			snapshotLeafId: marker.snapshotLeafId,
+			tokensBefore: marker.tokensBefore
+		}
+	};
+}
+function createInitialState() {
+	return {
+		version: 2,
+		cycle: 1,
+		pass: 1,
+		phase: "waiting",
+		checkpointQueue: [],
+		exhaustedPasses: [],
+		invalidAttempts: 0,
+		baselineTokens: 0,
+		baselinePending: false,
+		readFiles: [],
+		modifiedFiles: []
+	};
+}
+/**
+* The ratios each pass fires at, with configured values folded in.
+*
+* The ladder only works if it climbs, so a configured pass never sits below the
+* one before it: a file that says pass 2 fires earlier than pass 1 gets pass 1's
+* ratio for pass 2 rather than a pass that can never contribute.
+*/
+function compactionRatios(configured = {}) {
+	let previous = 0;
+	const ratios = {};
+	for (const pass of [
+		1,
+		2,
+		3
+	]) {
+		const ratio = Math.max(configured[pass] ?? COMPACTION_THRESHOLDS[pass].ratio, previous);
+		ratios[pass] = ratio;
+		previous = ratio;
+	}
+	return ratios;
+}
+function thresholdTokens(pass, contextWindow, baselineTokens = 0, configured = {}) {
+	const threshold = COMPACTION_THRESHOLDS[pass];
+	const ratio = compactionRatios(configured)[pass];
+	const baseline = Math.max(0, Math.min(baselineTokens, contextWindow));
+	const remaining = contextWindow - baseline;
+	const staged = baseline + Math.min(Math.floor(remaining * ratio), threshold.capTokens);
+	const nativeTrigger = contextWindow - _earendil_works_pi_coding_agent.DEFAULT_COMPACTION_SETTINGS.reserveTokens;
+	return nativeTrigger > baseline ? Math.min(staged, nativeTrigger) : staged;
+}
+/**
+* Where every pass fires, with a matching model's absolute token checkpoints folded in.
+*
+* A configured token count replaces the ratio only when it fires earlier, so an
+* override can bring a checkpoint forward on a very large window without ever
+* pushing one past the point Pi compacts natively.
+*
+* Two rules keep the ladder usable. A token count at or below the baseline is
+* ignored, because a compaction that lands above it would otherwise satisfy that
+* pass the moment the next cycle opens and re-fire it every turn. And a pass never
+* sits below the one before it, for the same reason {@link compactionRatios}
+* climbs: `evaluateUsage` skips any pass below the one already reached, so a later
+* pass that fires first does not merely reorder the ladder, it locks the earlier
+* passes out of the cycle and forces compaction with no summary ever written.
+*/
+function effectiveThresholds(contextWindow, baselineTokens = 0, configured = {}, tokenOverrides = {}) {
+	let previous = 0;
+	const thresholds = {};
+	for (const pass of [
+		1,
+		2,
+		3
+	]) {
+		const ratioTokens = thresholdTokens(pass, contextWindow, baselineTokens, configured);
+		const absolute = tokenOverrides[pass];
+		thresholds[pass] = Math.max(absolute !== void 0 && absolute > baselineTokens ? Math.min(ratioTokens, absolute) : ratioTokens, previous);
+		previous = thresholds[pass];
+	}
+	return thresholds;
+}
+function latestCheckpointArtifactEntry(branchEntries) {
+	return branchEntries.findLast((entry) => entry.type === "compaction" || entry.type === "custom" && entry.customType === "doom-autocompact-checkpoint" || customMessage(entry)?.customType === "doom-autocompact-checkpoint" || customMessage(entry)?.customType === "doom-autocompact-context");
+}
+function baselineUsageIsSettled(branchEntries) {
+	const boundaryIndex = branchEntries.findLastIndex((entry) => entry.type === "compaction" || customMessage(entry)?.customType === "doom-autocompact-context");
+	return branchEntries.slice(boundaryIndex + 1).some((entry) => {
+		if (entry.type !== "message" || entry.message.role !== "assistant") return false;
+		const { stopReason, usage } = entry.message;
+		if (stopReason === "aborted" || stopReason === "error" || !usage) return false;
+		return (usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite) > 0;
+	});
+}
+function projectContextMessages(messages, branchEntries) {
+	const nativeCompactionIndex = branchEntries.findLastIndex((entry) => entry.type === "compaction");
+	const markerEntry = branchEntries.slice(nativeCompactionIndex + 1).findLast((entry) => customMessage(entry)?.customType === CONTEXT_MESSAGE_TYPE);
+	const markerMessage = markerEntry && customMessage(markerEntry);
+	if (!markerEntry || !markerMessage) return {
+		messages,
+		retainedMessageCount: 0
+	};
+	const details = contextDetailsFromUnknown(markerMessage.details);
+	const summary = checkpointSummaryFromEntry(markerEntry);
+	if (!details || !summary) return {
+		messages,
+		invalidMarker: true,
+		retainedMessageCount: 0
+	};
+	const markerMessageIndex = messages.findLastIndex((message) => message.role === "custom" && message.customType === "doom-autocompact-context" && contextDetailsFromUnknown(message.details)?.doomAutocompact.requestId === details.doomAutocompact.requestId);
+	if (markerMessageIndex === -1) return {
+		messages,
+		invalidMarker: true,
+		retainedMessageCount: 0
+	};
+	return {
+		messages: [
+			{
+				role: "compactionSummary",
+				summary,
+				tokensBefore: details.doomAutocompact.tokensBefore,
+				timestamp: messages[markerMessageIndex]?.timestamp ?? Date.now()
+			},
+			...details.retainedMessages,
+			...messages.slice(markerMessageIndex + 1)
+		],
+		marker: details.doomAutocompact,
+		retainedMessageCount: details.retainedMessages.length
+	};
+}
+function fileOperationsFromMessages(messages) {
+	const fileOps = {
+		read: /* @__PURE__ */ new Set(),
+		written: /* @__PURE__ */ new Set(),
+		edited: /* @__PURE__ */ new Set()
+	};
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		for (const block of message.content) {
+			if (block.type !== "toolCall") continue;
+			const path = typeof block.arguments.path === "string" ? block.arguments.path : void 0;
+			if (!path) continue;
+			if (block.name === "read") fileOps.read.add(path);
+			else if (block.name === "write") fileOps.written.add(path);
+			else if (block.name === "edit") fileOps.edited.add(path);
+		}
+	}
+	return fileOps;
+}
+function parseState(value) {
+	if (!isRecord(value)) return void 0;
+	if (value.version !== 2 || typeof value.cycle !== "number" || !isPass(value.pass)) return void 0;
+	if (value.phase !== "waiting" && value.phase !== "checkpoint_pending" && value.phase !== "checkpoint_ready" && value.phase !== "compacting") return void 0;
+	const baselineTokens = value.baselineTokens ?? 0;
+	if (typeof baselineTokens !== "number" || baselineTokens < 0) return void 0;
+	const baselinePending = value.baselinePending ?? false;
+	if (typeof baselinePending !== "boolean") return void 0;
+	const checkpointQueue = value.checkpointQueue ?? [];
+	if (!Array.isArray(checkpointQueue) || !checkpointQueue.every(isPass) || checkpointQueue.some((pass, index) => index > 0 && pass <= checkpointQueue[index - 1])) return void 0;
+	const exhaustedPasses = value.exhaustedPasses ?? [];
+	if (!Array.isArray(exhaustedPasses) || !exhaustedPasses.every(isPass)) return void 0;
+	const invalidAttempts = value.invalidAttempts ?? 0;
+	if (typeof invalidAttempts !== "number" || invalidAttempts < 0) return void 0;
+	if (!isStringArray(value.readFiles) || !isStringArray(value.modifiedFiles)) return void 0;
+	if (value.requestId !== void 0 && typeof value.requestId !== "string") return void 0;
+	if (value.compactionPass !== void 0 && value.compactionPass !== 2 && value.compactionPass !== 3) return void 0;
+	if ("latestCheckpointEntryId" in value) return void 0;
+	if (value.latestCheckpointSnapshotLeafId !== void 0 && typeof value.latestCheckpointSnapshotLeafId !== "string") return void 0;
+	if (value.lastAttemptLeafId !== void 0 && typeof value.lastAttemptLeafId !== "string") return void 0;
+	if (value.snapshotLeafId !== void 0 && typeof value.snapshotLeafId !== "string") return void 0;
+	if (value.snapshotTokens !== void 0 && (typeof value.snapshotTokens !== "number" || value.snapshotTokens < 0)) return void 0;
+	if (value.pendingCheckpoint !== void 0 && typeof value.pendingCheckpoint !== "string") return void 0;
+	return {
+		version: 2,
+		cycle: value.cycle,
+		pass: value.pass,
+		phase: value.phase,
+		checkpointQueue: [...checkpointQueue],
+		exhaustedPasses: [...exhaustedPasses],
+		invalidAttempts,
+		baselineTokens,
+		baselinePending,
+		readFiles: [...value.readFiles],
+		modifiedFiles: [...value.modifiedFiles],
+		...value.requestId ? { requestId: value.requestId } : {},
+		...value.compactionPass ? { compactionPass: value.compactionPass } : {},
+		...value.latestCheckpointSnapshotLeafId ? { latestCheckpointSnapshotLeafId: value.latestCheckpointSnapshotLeafId } : {},
+		...value.lastAttemptLeafId ? { lastAttemptLeafId: value.lastAttemptLeafId } : {},
+		...value.snapshotLeafId ? { snapshotLeafId: value.snapshotLeafId } : {},
+		...value.snapshotTokens !== void 0 ? { snapshotTokens: value.snapshotTokens } : {},
+		...value.pendingCheckpoint ? { pendingCheckpoint: value.pendingCheckpoint } : {}
+	};
+}
+function checkpointSummaryFromEntry(entry) {
+	if (!entry) return void 0;
+	if (entry.type === "compaction") return entry.summary.trim() || void 0;
+	if (entry.type === "custom") return isRecord(entry.data) && typeof entry.data.summary === "string" ? entry.data.summary.trim() || void 0 : void 0;
+	const marker = customMessage(entry);
+	if (marker) return (typeof marker.content === "string" ? marker.content : marker.content.filter((block) => block.type === "text").map((block) => block.text).join("\n")).trim() || void 0;
+	return assistantText(entry);
+}
+function parseCheckpointDecision(response) {
+	const match = response.match(SHOULD_COMPACT_PATTERN);
+	const summary = response.replace(SHOULD_COMPACT_PATTERN, "").trim();
+	if (!match) return { summary };
+	return {
+		summary,
+		shouldCompact: match[1]?.toLowerCase() === "true"
+	};
+}
+function isStructuredCheckpoint(summary) {
+	return CHECKPOINT_HEADINGS.every((heading) => summary.includes(heading));
+}
+function createRequestId(sessionId, cycle, pass, leafId) {
+	return `${sessionId}:${cycle}:${pass}:${leafId ?? "root"}`;
+}
+function checkpointRequestDetails(cycle, pass, requestId) {
+	return {
+		version: 2,
+		cycle,
+		pass,
+		requestId
+	};
+}
+function mergeFileDetails(current, fileOps, additional) {
+	const modified = /* @__PURE__ */ new Set([
+		...current.modifiedFiles,
+		...additional?.modifiedFiles ?? [],
+		...fileOps ? [...fileOps.edited, ...fileOps.written] : []
+	]);
+	const read = /* @__PURE__ */ new Set([
+		...current.readFiles,
+		...additional?.readFiles ?? [],
+		...fileOps ? [...fileOps.read] : []
+	]);
+	for (const path of modified) read.delete(path);
+	return {
+		readFiles: [...read].sort(),
+		modifiedFiles: [...modified].sort()
+	};
+}
+function fileDetailsFromUnknown(value) {
+	if (!isRecord(value) || !isStringArray(value.readFiles) || !isStringArray(value.modifiedFiles)) return void 0;
+	return {
+		readFiles: value.readFiles,
+		modifiedFiles: value.modifiedFiles
+	};
+}
+function withCanonicalFileSections(summary, details) {
+	const sections = [];
+	if (details.readFiles.length > 0) sections.push(`<read-files>\n${details.readFiles.join("\n")}\n</read-files>`);
+	if (details.modifiedFiles.length > 0) sections.push(`<modified-files>\n${details.modifiedFiles.join("\n")}\n</modified-files>`);
+	const normalized = summary.replace(FILE_SECTION_PATTERN, "").trim();
+	return sections.length > 0 ? `${normalized}\n\n${sections.join("\n\n")}` : normalized;
+}
+//#endregion
+Object.defineProperty(exports, "CHECKPOINT_MESSAGE_TYPE", {
+	enumerable: true,
+	get: function() {
+		return CHECKPOINT_MESSAGE_TYPE;
+	}
+});
+Object.defineProperty(exports, "CONTEXT_MESSAGE_TYPE", {
+	enumerable: true,
+	get: function() {
+		return CONTEXT_MESSAGE_TYPE;
+	}
+});
+Object.defineProperty(exports, "RESUME_MESSAGE_TYPE", {
+	enumerable: true,
+	get: function() {
+		return RESUME_MESSAGE_TYPE;
+	}
+});
+Object.defineProperty(exports, "RUNTIME_STATE_MESSAGE_TYPE", {
+	enumerable: true,
+	get: function() {
+		return RUNTIME_STATE_MESSAGE_TYPE;
+	}
+});
+Object.defineProperty(exports, "STATE_CUSTOM_TYPE", {
+	enumerable: true,
+	get: function() {
+		return STATE_CUSTOM_TYPE;
+	}
+});
+Object.defineProperty(exports, "baselineUsageIsSettled", {
+	enumerable: true,
+	get: function() {
+		return baselineUsageIsSettled;
+	}
+});
+Object.defineProperty(exports, "checkpointRequestDetails", {
+	enumerable: true,
+	get: function() {
+		return checkpointRequestDetails;
+	}
+});
+Object.defineProperty(exports, "checkpointSummaryFromEntry", {
+	enumerable: true,
+	get: function() {
+		return checkpointSummaryFromEntry;
+	}
+});
+Object.defineProperty(exports, "contextDetailsFromUnknown", {
+	enumerable: true,
+	get: function() {
+		return contextDetailsFromUnknown;
+	}
+});
+Object.defineProperty(exports, "createInitialState", {
+	enumerable: true,
+	get: function() {
+		return createInitialState;
+	}
+});
+Object.defineProperty(exports, "createRequestId", {
+	enumerable: true,
+	get: function() {
+		return createRequestId;
+	}
+});
+Object.defineProperty(exports, "effectiveThresholds", {
+	enumerable: true,
+	get: function() {
+		return effectiveThresholds;
+	}
+});
+Object.defineProperty(exports, "fileDetailsFromUnknown", {
+	enumerable: true,
+	get: function() {
+		return fileDetailsFromUnknown;
+	}
+});
+Object.defineProperty(exports, "fileOperationsFromMessages", {
+	enumerable: true,
+	get: function() {
+		return fileOperationsFromMessages;
+	}
+});
+Object.defineProperty(exports, "isStructuredCheckpoint", {
+	enumerable: true,
+	get: function() {
+		return isStructuredCheckpoint;
+	}
+});
+Object.defineProperty(exports, "latestCheckpointArtifactEntry", {
+	enumerable: true,
+	get: function() {
+		return latestCheckpointArtifactEntry;
+	}
+});
+Object.defineProperty(exports, "mergeFileDetails", {
+	enumerable: true,
+	get: function() {
+		return mergeFileDetails;
+	}
+});
+Object.defineProperty(exports, "parseCheckpointDecision", {
+	enumerable: true,
+	get: function() {
+		return parseCheckpointDecision;
+	}
+});
+Object.defineProperty(exports, "parseState", {
+	enumerable: true,
+	get: function() {
+		return parseState;
+	}
+});
+Object.defineProperty(exports, "projectContextMessages", {
+	enumerable: true,
+	get: function() {
+		return projectContextMessages;
+	}
+});
+Object.defineProperty(exports, "thresholdTokens", {
+	enumerable: true,
+	get: function() {
+		return thresholdTokens;
+	}
+});
+Object.defineProperty(exports, "withCanonicalFileSections", {
+	enumerable: true,
+	get: function() {
+		return withCanonicalFileSections;
+	}
+});
+
+//# sourceMappingURL=compactionPolicy-BIJJHcBP.cjs.map