@xopcai/xopc 0.0.170 → 0.0.171

package/dist/src/agent/orchestration/loop-guard.js

@@ -11,12 +11,16 @@ const DEFAULT_CONFIG = {
 * Stable fingerprint for tool call comparison.
 * Recursively sorts object keys; truncates long string values.
 */
-function fingerprint(toolName, params) {
-	return `${toolName}::${JSON.stringify(params, (_key, value) => {
-		if (typeof value === "object" && value !== null && !Array.isArray(value)) return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
-		if (typeof value === "string" && value.length > 200) return `${value.slice(0, 80)}…[${value.length}]`;
-		return value;
-	})}`;
+function stableJson(value) {
+	return JSON.stringify(value, (_key, item) => {
+		if (typeof item === "object" && item !== null && !Array.isArray(item)) return Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)));
+		if (typeof item === "string" && item.length > 200) return `${item.slice(0, 80)}…[${item.length}]`;
+		return item;
+	});
+}
+function fingerprint(call) {
+	const result = call.resultPreview === void 0 ? "" : `::result=${stableJson(call.resultPreview)}`;
+	return `${call.name}::${stableJson(call.params)}${result}`;
 }
 /**
 * Analyze recent tool calls and produce loop guard result.
@@ -70,11 +74,11 @@ function findConsecutiveRepeats(calls) {
 	let index = calls.length - 1;
 	while (index >= 0) {
 		const current = calls[index];
-		const fp = fingerprint(current.name, current.params);
+		const fp = fingerprint(current);
 		let count = 1;
 		while (index - count >= 0) {
 			const prev = calls[index - count];
-			if (fingerprint(prev.name, prev.params) !== fp) break;
+			if (fingerprint(prev) !== fp) break;
 			count++;
 		}
 		if (count >= 2) groups.push({
@@ -92,7 +96,7 @@ function findConsecutiveRepeats(calls) {
 function countFrequency(calls) {
 	const map = /* @__PURE__ */ new Map();
 	for (const call of calls) {
-		const fp = fingerprint(call.name, call.params);
+		const fp = fingerprint(call);
 		map.set(fp, (map.get(fp) ?? 0) + 1);
 	}
 	return map;

package/dist/src/agent/reply/post-compaction-context.d.ts

@@ -5,6 +5,8 @@ export type PostCompactionContextOptions = {
     agentId?: string;
     nowMs?: number;
     userTimezone?: string;
+    sectionNames?: string[];
+    maxContextChars?: number;
 };
 export declare function readPostCompactionContextFromAgentsMd(agentsMdContent: string, options?: PostCompactionContextOptions): string | null;
 export declare function readPostCompactionContext(params: {
@@ -13,4 +15,6 @@ export declare function readPostCompactionContext(params: {
     agentId?: string;
     nowMs?: number;
     userTimezone?: string;
+    sectionNames?: string[];
+    maxContextChars?: number;
 }): string | null;

package/dist/src/agent/reply/post-compaction-context.js

@@ -53,7 +53,7 @@ function extractSections(content, sectionNames, foundNames) {
 	return results;
 }
 function readPostCompactionContextFromAgentsMd(agentsMdContent, options) {
-	const sectionNames = DEFAULT_POST_COMPACTION_SECTIONS;
+	const sectionNames = options?.sectionNames ?? DEFAULT_POST_COMPACTION_SECTIONS;
 	if (sectionNames.length === 0) return null;
 	const foundSectionNames = [];
 	const sections = extractSections(agentsMdContent, sectionNames, foundSectionNames);
@@ -62,7 +62,7 @@ function readPostCompactionContextFromAgentsMd(agentsMdContent, options) {
 	const timezone = options?.userTimezone?.trim() || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
 	const nowMs = options?.nowMs ?? Date.now();
 	const dateStamp = new Intl.DateTimeFormat("en-CA", { timeZone: timezone }).format(new Date(nowMs));
-	const maxContextChars = MAX_CONTEXT_CHARS;
+	const maxContextChars = Math.max(1, options?.maxContextChars ?? MAX_CONTEXT_CHARS);
 	const combined = sections.join("\n\n").replaceAll("YYYY-MM-DD", dateStamp);
 	const safeContent = combined.length > maxContextChars ? `${combined.slice(0, maxContextChars)}\n...[truncated]...` : combined;
 	const isDefaultSections = sectionNames.length === DEFAULT_POST_COMPACTION_SECTIONS.length && sectionNames.every((name, index) => normalizeHeading(name) === normalizeHeading(DEFAULT_POST_COMPACTION_SECTIONS[index] ?? ""));
@@ -84,7 +84,9 @@ function readPostCompactionContext(params) {
 			cfg,
 			agentId,
 			nowMs: params.nowMs,
-			userTimezone: params.userTimezone
+			userTimezone: params.userTimezone,
+			sectionNames: params.sectionNames,
+			maxContextChars: params.maxContextChars
 		});
 	} catch {
 		return null;

package/dist/src/agent/service/process-direct-one-shot.js

@@ -17,8 +17,7 @@ async function runProcessDirect(deps, input) {
 			cfg: deps.config,
 			sessionKey: input.sessionKey,
 			body: input.content,
-			resetSession: deps.resetSession,
-			skipImplicitExpiry: channel === "webchat"
+			resetSession: deps.resetSession
 		});
 		resetTriggeredAtInit = turn.resetTriggered;
 		if (turn.bareReset && turn.ackMessage) return turn.ackMessage;

package/dist/src/agent/service/process-direct-streaming.js

@@ -154,8 +154,7 @@ async function* runProcessDirectStreaming(deps, input) {
 					cfg,
 					sessionKey,
 					body: input.content,
-					resetSession: deps.resetSession,
-					skipImplicitExpiry: channel === "webchat"
+					resetSession: deps.resetSession
 				});
 				resetTriggeredAtInit = turn.resetTriggered;
 				if (turn.bareReset && turn.ackMessage) {

package/dist/src/agent/service.d.ts

@@ -102,7 +102,6 @@ export declare class AgentService {
     private createHookRunner;
     private createProgressManager;
     private initializeReliabilityModules;
-    private initializeLifecycleHandlers;
     setChannelManager(channelManager: ChannelManager): void;
     /**
      * Apply config after save or hot reload so the default model updates without restarting the gateway.
@@ -191,7 +190,6 @@ export declare class AgentService {
      * Handle events from a specific session's agent
      */
     private handleSessionEvent;
-    private checkAndCompact;
     private getContextWindowForSession;
     private dispose;
 }

package/dist/src/agent/service.js

@@ -15,6 +15,7 @@ import { onSessionTranscriptUpdate } from "../session/transcript-events.js";
 import { persistInboundAttachments } from "../channels/attachments/inbound-persist.js";
 import { AgentManager } from "./agent-manager.js";
 import { maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle } from "../session/session-title.js";
+import { resolveCompactionPolicy } from "./memory/compaction-policy.js";
 import { SessionStore } from "../session/store.js";
 import { SessionConfigStore } from "../session/config-store.js";
 import "../session/index.js";
@@ -38,7 +39,6 @@ import "./middleware/index.js";
 import { TurnDiffTracker } from "./coding/turn-diff-tracker.js";
 import { LifecycleManager } from "./lifecycle/manager.js";
 import "./lifecycle/index.js";
-import { CompactionLifecycleHandler } from "./lifecycle/handlers/compaction.js";
 import { MessageRouter } from "./messaging/message-router.js";
 import { CommandHandler } from "./messaging/command-handler.js";
 import { StreamManager } from "./messaging/stream-manager.js";
@@ -203,10 +203,20 @@ var AgentService = class {
 				return this.currentContext?.sessionKey;
 			}
 		});
+		this.sessionStore.setCompactionHooks({
+			before: ({ sessionKey, messageCount, tokenCount }) => this.hookHandler.triggerWithSessionKey(sessionKey, "before_compaction", {
+				messageCount,
+				tokenCount
+			}),
+			after: ({ sessionKey, messageCount, tokenCount, compactedCount }) => this.hookHandler.triggerWithSessionKey(sessionKey, "after_compaction", {
+				messageCount,
+				tokenCount,
+				compactedCount
+			})
+		});
 		this.progressManager = this.createProgressManager();
 		this.initializeReliabilityModules();
 		this.lifecycleManager = new LifecycleManager();
-		this.initializeLifecycleHandlers();
 		this.streamManager = new StreamManager();
 		this.sessionContextManager = new SessionContextManager();
 		this.feedbackCoordinator = new FeedbackCoordinator({
@@ -400,7 +410,6 @@ var AgentService = class {
 			setupSessionEventHandling: (sk) => this.setupSessionEventHandling(sk),
 			sessionHydrator: this.sessionHydrator,
 			getLastAssistantPlainText: (sk) => this.getLastAssistantPlainText(sk),
-			checkAndCompact: (sk, msgs) => this.checkAndCompact(sk, msgs),
 			enqueueMaybeAutoTitleAfterPersist: (sk) => this.enqueueMaybeAutoTitleAfterPersist(sk),
 			getConfig: () => this.effectiveAppConfig(),
 			resetSession: (sk) => this.resetSession(sk),
@@ -418,19 +427,9 @@ var AgentService = class {
 			keepRecentMessages: 20,
 			preserveSystemMessages: true
 		};
-		const compactionConfig = {
-			enabled: true,
-			mode: "abstractive",
-			reserveTokens: 8e3,
-			triggerThreshold: .8,
-			minMessagesBeforeCompact: 10,
-			keepRecentMessages: 10,
-			evictionWindow: .2,
-			retentionWindow: 6
-		};
 		const appCfg = this.config.config;
 		if (!appCfg) throw new Error("AgentService requires config.config for session store paths");
-		return new SessionStore({ config: appCfg }, windowConfig, compactionConfig);
+		return new SessionStore({ config: appCfg }, windowConfig, resolveCompactionPolicy(appCfg));
 	}
 	createHookRunner() {
 		if (!this.config.extensionRegistry) return void 0;
@@ -498,15 +497,6 @@ var AgentService = class {
 		});
 		this.contextMiddleware = new ContextMiddleware();
 	}
-	initializeLifecycleHandlers() {
-		this.lifecycleManager.on("llm_response", new CompactionLifecycleHandler({
-			minMessages: 20,
-			maxTokens: 8e3,
-			preserveReasoning: true,
-			accumulateUsage: true
-		}));
-		log.debug({ handlers: this.lifecycleManager.getRegisteredHandlers() }, "Lifecycle handlers initialized");
-	}
 	setChannelManager(channelManager) {
 		this.inboundLoop.setChannelManager(channelManager);
 	}
@@ -809,27 +799,6 @@ var AgentService = class {
 		}
 		this.agentEventHandler.handle(event, currentContext);
 	}
-	async checkAndCompact(sessionKey, messages) {
-		const contextWindow = this.getContextWindowForSession(sessionKey);
-		const prep = this.sessionStore.prepareCompaction(sessionKey, messages, contextWindow);
-		if (!prep.needsCompaction) return;
-		log.info({
-			sessionKey,
-			reason: prep.stats?.reason,
-			usagePercent: prep.stats?.usagePercent
-		}, "Session needs compaction");
-		const result = await this.sessionStore.compact(sessionKey, messages, contextWindow, void 0, false);
-		await this.hookHandler.trigger("after_compaction", {
-			messageCount: messages.length,
-			tokenCount: result.tokensBefore,
-			compactedCount: messages.length - result.firstKeptIndex
-		});
-		log.info({
-			sessionKey,
-			tokensBefore: result.tokensBefore,
-			tokensAfter: result.tokensAfter
-		}, "Session compacted");
-	}
 	getContextWindowForSession(sessionKey) {
 		try {
 			return this.modelManager.getResolvedModelForSession(sessionKey).contextWindow ?? 128e3;

package/dist/src/agent/session/session-inspector.js

@@ -2,8 +2,10 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_workspace_defaults, resolveDefaultAgentWorkspaceDir } from "../../config/workspace-defaults.js";
 import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
+import { init_providers, resolveModel } from "../../providers/index.js";
 import { effectiveWorkspacePathForSession, projectWorkspacePath } from "../../session/session-workspace.js";
 import { getProjectForSession } from "../../projects/workspace.js";
+import { resolveCompactionPolicy } from "../memory/compaction-policy.js";
 import { resolveVerboseLevel } from "../../session/config-store.js";
 import { resolveEffectiveReasoningLevel, resolveEffectiveThinkingLevel } from "../../session/thinking-resolve.js";
 import "../../session/index.js";
@@ -12,6 +14,7 @@ import { formatSessionContextReport } from "../service/session-context-report.js
 //#region src/agent/session/session-inspector.ts
 init_workspace_defaults();
 init_logger();
+init_providers();
 const log = createLogger("SessionInspector");
 var SessionInspector = class {
 	opts;
@@ -37,8 +40,13 @@ var SessionInspector = class {
 	*/
 	async compact(sessionKey, options) {
 		const messages = await this.opts.sessionStore.load(sessionKey);
-		const contextWindow = await this.contextWindowForSession(sessionKey);
-		const result = await this.opts.sessionStore.compact(sessionKey, messages, contextWindow, options?.instructions, options?.force ?? true);
+		await this.ensureEffectiveSessionModel(sessionKey);
+		const policy = resolveCompactionPolicy(this.opts.getConfig());
+		const sessionModel = this.opts.modelManager.getResolvedModelForSession(sessionKey);
+		const model = policy.model ? resolveModel(policy.model) : sessionModel;
+		const primaryRef = `${model.provider}/${model.id}`;
+		const fallbackModels = this.opts.modelManager.getFallbackCandidatesForSession(sessionKey).map((candidate) => resolveModel(`${candidate.provider}/${candidate.model}`)).filter((candidate) => `${candidate.provider}/${candidate.id}` !== primaryRef);
+		const result = await this.opts.sessionStore.compact(sessionKey, messages, model, options?.instructions, options?.force ?? true, { fallbackModels });
 		if (result.compacted) this.opts.agentManager.removeAgent(sessionKey);
 		log.info({
 			sessionKey,

package/dist/src/cli/commands/doctor/checks/database-schema.js

@@ -52,7 +52,7 @@ async function checkDatabaseSchema(ctx) {
 		id: "database-schema",
 		label: "Database schema",
 		status: "pass",
-		message: `SQLite schema v${status.dbVersion} (current release v59).`,
+		message: `SQLite schema v${status.dbVersion} (current release v61).`,
 		hints: []
 	};
 }

package/dist/src/config/schema.d.ts

@@ -1552,7 +1552,23 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 }>>;
             }, z.core.$strict>>;
             retention: z.ZodOptional<z.ZodObject<{
-                compaction: z.ZodDefault<z.ZodBoolean>;
+                compaction: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    triggerThreshold: z.ZodDefault<z.ZodNumber>;
+                    reserveTokens: z.ZodDefault<z.ZodNumber>;
+                    minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
+                    keepRecentTokens: z.ZodDefault<z.ZodNumber>;
+                    recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
+                    summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
+                    summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
+                    summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+                    summaryRetries: z.ZodDefault<z.ZodNumber>;
+                    qualityGuard: z.ZodDefault<z.ZodBoolean>;
+                    model: z.ZodOptional<z.ZodString>;
+                    minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
+                    maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
+                    postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>>;
                 maxAgeDays: z.ZodOptional<z.ZodNumber>;
                 maxItems: z.ZodOptional<z.ZodNumber>;
                 maxChars: z.ZodOptional<z.ZodNumber>;

package/dist/src/gateway/hono/lib/config-payload.d.ts

@@ -307,6 +307,29 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
             maxEntries: number;
         };
     };
+    userContext: {
+        memory: {
+            retention: {
+                compaction: {
+                    enabled: boolean;
+                    triggerThreshold: number;
+                    reserveTokens: number;
+                    minMessagesBeforeCompact: number;
+                    keepRecentTokens: number;
+                    recentTurnsPreserve: number;
+                    summaryMaxTokens: number;
+                    summaryChunkTokens: number;
+                    summaryTimeoutMs: number;
+                    summaryRetries: number;
+                    qualityGuard: boolean;
+                    minToolResultKeepChars: number;
+                    maxActiveTranscriptBytes: number;
+                    postCompactionSections: string[];
+                    model?: string;
+                };
+            };
+        };
+    };
     tui: {
         defaultAgent: string;
     };

package/dist/src/gateway/hono/lib/config-payload.js

@@ -1,3 +1,4 @@
+import { ContextCompactionPolicySchema, init_config } from "../../../user-context/config.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
 import { resolveModelsJsonPath } from "../../../config/paths.js";
 import { buildChannelCatalogForConfig, buildChannelCatalogFromSnapshot, getChannelSetupStatus, init_channel_catalog_service } from "../../../channels/catalog/channel-catalog-service.js";
@@ -20,6 +21,7 @@ init_credentials();
 init_models_json();
 init_providers();
 init_plugin_registry();
+init_config();
 function readModelsJsonProviderApiKey(providerId) {
 	const { config } = loadModelsJson(resolveModelsJsonPath());
 	const key = (config.providers?.[providerId])?.apiKey;
@@ -175,6 +177,7 @@ async function buildSafeWebConfigPayload(service, options = {}) {
 		browser: buildSafeBrowserConfigForWeb(config.browser),
 		goals: resolveGoalsConfigForWeb(config),
 		session: resolveSessionConfigForWeb(config),
+		userContext: { memory: { retention: { compaction: ContextCompactionPolicySchema.parse(config.userContext?.memory.retention?.compaction) } } },
 		tui: { defaultAgent: config.tui?.defaultAgent ?? "coder" },
 		tunnel: {
 			enabled: config.tunnel?.enabled === true,

package/dist/src/gateway/hono/routes/config-patch/misc.d.ts

@@ -2,7 +2,7 @@
  * `PATCH /api/config` — tail sections that are each <50 lines:
  *   update / goals / session / gateway.{skillsMarketplaceProvider,
  *   skillsStoreBaseUrl} / providers / providersConfig / stt / tts / tools /
- *   tunnel / bindings / mcp.
+ *   userContext.memory.retention.compaction / tunnel / bindings / mcp.
  *
  * Most of these delegate to a `mergeXxxConfigPatch(config, body) → { ok,
  * message? }` helper that lives next to the schema, so this file is mostly

package/dist/src/gateway/hono/routes/config-patch/misc.js

@@ -1,3 +1,4 @@
+import { ContextCompactionPolicySchema, init_config } from "../../../../user-context/config.js";
 import { BindingsConfigSchema, BrowserConfigSchema, McpConfigSchema, VoiceConfigSchema, init_schema } from "../../../../config/schema.js";
 import { CredentialResolver, init_credentials } from "../../../../auth/credentials.js";
 import { canonicalizeConfiguredMcpServer } from "../../../../config/mcp-config-normalize.js";
@@ -13,6 +14,7 @@ import { PATCH_OK, patchError } from "./result.js";
 //#region src/gateway/hono/routes/config-patch/misc.ts
 init_schema();
 init_credentials();
+init_config();
 async function applyMiscPatch(config, body) {
 	if (body.update !== void 0 && typeof body.update === "object" && body.update !== null) {
 		const updateResult = mergeUpdateConfigPatch(config, body.update);
@@ -28,6 +30,32 @@ async function applyMiscPatch(config, body) {
 		const sessionResult = mergeSessionConfigPatch(config, body.session);
 		if (sessionResult.ok === false) return patchError(sessionResult.message);
 	}
+	if (body.userContext !== void 0) {
+		if (typeof body.userContext !== "object" || body.userContext === null || Array.isArray(body.userContext)) return patchError("userContext must be an object");
+		const userContextPatch = body.userContext;
+		if (userContextPatch.memory !== void 0) {
+			if (typeof userContextPatch.memory !== "object" || userContextPatch.memory === null || Array.isArray(userContextPatch.memory)) return patchError("userContext.memory must be an object");
+			const memoryPatch = userContextPatch.memory;
+			if (memoryPatch.retention !== void 0) {
+				if (typeof memoryPatch.retention !== "object" || memoryPatch.retention === null || Array.isArray(memoryPatch.retention)) return patchError("userContext.memory.retention must be an object");
+				const retentionPatch = memoryPatch.retention;
+				if (retentionPatch.compaction !== void 0) {
+					const parsed = ContextCompactionPolicySchema.safeParse(retentionPatch.compaction);
+					if (!parsed.success) return patchError(parsed.error.issues.map((issue) => issue.message).join("; "));
+					config.userContext = {
+						...config.userContext,
+						memory: {
+							...config.userContext?.memory,
+							retention: {
+								...config.userContext?.memory?.retention,
+								compaction: parsed.data
+							}
+						}
+					};
+				}
+			}
+		}
+	}
 	if (body.tui !== void 0) {
 		if (typeof body.tui !== "object" || body.tui === null || Array.isArray(body.tui)) return patchError("tui must be an object");
 		const tuiPatch = body.tui;

package/dist/src/gateway/hono/routes/sessions.js

@@ -5,7 +5,6 @@ import { evictEmbeddedSessionRunner } from "../../../agent/embedded/session-runn
 import { messagesToClientHistory } from "../../../session/client-history.js";
 import { deleteMediaUrisNoLongerReferenced } from "../../../media/session-references.js";
 import { createGatewayRouteLogger, logRouteError } from "../lib/route-logger.js";
-import { computeUserRoundDeleteRange } from "../../../session/user-round-delete.js";
 import { respondStartupUnavailable } from "../lib/startup-unavailable.js";
 import { randomUUID } from "node:crypto";
 //#region src/gateway/hono/routes/sessions.ts
@@ -459,48 +458,35 @@ function registerSessionsRoutes(authenticated, deps) {
 		evictEmbeddedSessionRunner(key, "gateway_bash_execution_appended");
 		return c.json({ ok: true });
 	});
-	authenticated.get("/api/sessions/:key/compaction/checkpoints", async (c) => {
+	authenticated.get("/api/sessions/:key/compaction/boundaries", async (c) => {
 		const key = c.req.param("key");
 		if (!await service.sessionIndexInstance.getSessionMetadata(key)) return c.json({
 			ok: false,
 			error: "Session not found"
 		}, 404);
-		const checkpoints = await service.sessions.listCompactionCheckpoints(key);
+		const boundaries = await service.sessions.listCompactionBoundaries(key);
 		return c.json({
 			ok: true,
-			payload: { checkpoints }
-		});
-	});
-	authenticated.get("/api/sessions/:key/compaction/checkpoints/:checkpointId", async (c) => {
-		const key = c.req.param("key");
-		const checkpointId = c.req.param("checkpointId");
-		const checkpoint = await service.sessions.getCompactionCheckpoint(key, checkpointId);
-		if (!checkpoint) return c.json({
-			ok: false,
-			error: "Checkpoint not found"
-		}, 404);
-		return c.json({
-			ok: true,
-			payload: { checkpoint }
+			payload: { boundaries }
 		});
 	});
 	authenticated.post("/api/sessions/:key/compaction/restore", async (c) => {
 		const key = c.req.param("key");
 		const body = await c.req.json().catch(() => ({}));
-		const checkpointId = typeof body.checkpointId === "string" ? body.checkpointId.trim() : "";
-		if (!checkpointId) return c.json({
+		const compactionId = typeof body.compactionId === "string" ? body.compactionId.trim() : "";
+		if (!compactionId) return c.json({
 			ok: false,
-			error: "checkpointId required"
+			error: "compactionId required"
 		}, 400);
 		try {
-			await service.sessions.restoreCompactionCheckpoint(key, checkpointId);
+			await service.sessions.restoreBeforeCompactionBoundary(key, compactionId);
 		} catch (err) {
 			logRouteError(log, c, err, "gateway.route.sessions", {
-				operation: "restoreCheckpoint",
+				operation: "restoreCompactionBoundary",
 				sessionKey: key
 			});
 			const msg = err instanceof Error ? err.message : String(err);
-			if (msg.includes("not found") || msg.includes("Invalid")) return c.json({
+			if (msg.includes("not found")) return c.json({
 				ok: false,
 				error: msg
 			}, 404);
@@ -695,30 +681,19 @@ function registerSessionsRoutes(authenticated, deps) {
 	authenticated.delete("/api/sessions/:key/messages", async (c) => {
 		const key = c.req.param("key");
 		const body = await c.req.json().catch(() => ({}));
-		const loaded = await service.sessionIndexInstance.loadMessages(key);
-		if (!loaded) return c.json({ error: "Session not found" }, 404);
-		let startIndex = typeof body.startIndex === "number" ? body.startIndex : -1;
-		let count = typeof body.count === "number" ? body.count : 0;
 		const userRoundIndex = typeof body.userRoundIndex === "number" ? body.userRoundIndex : void 0;
-		if (userRoundIndex !== void 0) {
-			const range = computeUserRoundDeleteRange(loaded, userRoundIndex);
-			if (!range) return c.json({ error: "User round index out of range" }, 400);
-			startIndex = range.startIndex;
-			count = range.count;
-		}
-		if (startIndex < 0 || count <= 0) return c.json({ error: "Invalid startIndex or count" }, 400);
-		if (startIndex >= loaded.length) return c.json({ error: "Index out of range" }, 400);
-		const deleteCount = Math.min(count, loaded.length - startIndex);
-		const removed = loaded.slice(startIndex, startIndex + deleteCount);
-		const next = loaded.slice(0, startIndex).concat(loaded.slice(startIndex + deleteCount));
-		await service.sessionIndexInstance.saveMessages(key, next);
+		if (userRoundIndex === void 0 || !Number.isInteger(userRoundIndex) || userRoundIndex < 0) return c.json({ error: "userRoundIndex must be a non-negative integer" }, 400);
+		const result = await service.sessionIndexInstance.deleteUserRound(key, userRoundIndex);
+		if (!result) return c.json({ error: "User round index out of range" }, 400);
 		await deleteMediaUrisNoLongerReferenced({
-			removed,
-			remaining: next
+			removed: result.removedMessages,
+			remaining: result.remainingMessages
 		});
+		evictEmbeddedSessionRunner(key, "gateway_user_round_deleted");
+		service.agentService.evictSessionAgent(key);
 		return c.json({
 			ok: true,
-			deleted: deleteCount
+			deleted: result.deleted
 		});
 	});
 	authenticated.post("/api/sessions/:key/reset", async (c) => {

package/dist/src/gateway/service/sessions-api.d.ts

@@ -92,9 +92,8 @@ export declare class GatewaySessionsApi {
         verboseLevel?: string;
         workingDirectory?: string;
     }): Promise<import("../../agent/session/session-config-service.js").PatchSessionAgentConfigResult>;
-    listCompactionCheckpoints(key: string): Promise<import("../../session/types.js").CompactionCheckpointSummary[]>;
-    getCompactionCheckpoint(key: string, checkpointId: string): Promise<import("../../session/types.js").CompactionCheckpointDetail>;
-    restoreCompactionCheckpoint(key: string, checkpointId: string): Promise<void>;
+    listCompactionBoundaries(key: string): Promise<import("../../session/types.js").CompactionBoundarySummary[]>;
+    restoreBeforeCompactionBoundary(key: string, compactionId: string): Promise<void>;
     runCompaction(key: string, options?: {
         instructions?: string;
         force?: boolean;

package/dist/src/gateway/service/sessions-api.js

@@ -93,14 +93,11 @@ var GatewaySessionsApi = class {
 	patchAgentConfig(sessionKey, body) {
 		return this.opts.getAgentService().sessionConfig.patch(sessionKey, body);
 	}
-	listCompactionCheckpoints(key) {
-		return this.opts.sessionIndex.listCompactionCheckpoints(key);
+	listCompactionBoundaries(key) {
+		return this.opts.sessionIndex.listCompactionBoundaries(key);
 	}
-	getCompactionCheckpoint(key, checkpointId) {
-		return this.opts.sessionIndex.getCompactionCheckpointDetail(key, checkpointId);
-	}
-	async restoreCompactionCheckpoint(key, checkpointId) {
-		await this.opts.sessionIndex.restoreCompactionCheckpoint(key, checkpointId);
+	async restoreBeforeCompactionBoundary(key, compactionId) {
+		await this.opts.sessionIndex.restoreBeforeCompactionBoundary(key, compactionId);
 		this.opts.getAgentService().evictSessionAgent(key);
 	}
 	async runCompaction(key, options) {

package/dist/src/session/index.d.ts

@@ -6,8 +6,7 @@ export { SessionConfigStore, resolveThinkingLevel, resolveReasoningLevel, resolv
 export { resolveEffectiveThinkingLevel, resolveEffectiveReasoningLevel } from './thinking-resolve.js';
 export type { SessionAgentConfig } from './config-types.js';
 export { normalizeWorkingDirectoryInput, effectiveWorkspacePathForSession, projectWorkspacePath, } from './session-workspace.js';
-export { SessionStatus, type SessionMetadata, type SessionDetail, type SessionListQuery, type PaginatedResult, type SessionStats, type ExportFormat, type SessionExport, type SessionTranscriptSummary, type CompactionCheckpointSummary, type CompactionCheckpointDetail, } from './types.js';
-export { normalizeCompactionCheckpointId } from './compaction-checkpoints.js';
+export { SessionStatus, type SessionMetadata, type SessionDetail, type SessionListQuery, type PaginatedResult, type SessionStats, type ExportFormat, type SessionExport, type SessionTranscriptSummary, type CompactionBoundarySummary, } from './types.js';
 export { shouldSkipWebchatInboundByAbortCutoff } from './abort-cutoff.js';
 export { DEFAULT_RESET_AT_HOUR, DEFAULT_RESET_MODE, DEFAULT_IDLE_MINUTES, evaluateSessionFreshness, resolveDailyResetAtMs, resolveSessionResetPolicy, type SessionFreshness, type SessionResetConfig, type SessionResetMode, type SessionResetPolicy, type SessionResetType, } from './reset-policy.js';
 export { resolveChannelResetConfig, resolveSessionResetType, } from './reset-type.js';

package/dist/src/session/index.js

@@ -3,7 +3,6 @@ import { buildSessionContextForLlm, isTranscriptContextEntry, mergeLlmMessagesPr
 import { effectiveWorkspacePathForSession, normalizeWorkingDirectoryInput, projectWorkspacePath } from "./session-workspace.js";
 import { emitSessionTranscriptUpdate, onSessionTranscriptUpdate } from "./transcript-events.js";
 import { fallbackTitleFromMessages, generateSessionTitleFromMessages, getSessionTitleSource, isWebchatSessionKey, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, provisionalTitleFromUserText, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleSessionKey, shouldRefineSessionTitleWithLlm } from "./session-title.js";
-import { normalizeCompactionCheckpointId } from "./compaction-checkpoints.js";
 import { flattenMessageContent, messagesToClientHistory } from "./client-history.js";
 import { SessionStore } from "./store.js";
 import { applySessionPatchToMetadata } from "./patch-metadata.js";
@@ -18,4 +17,4 @@ import { resolveSession, resolveSessionKeyForRequest } from "./resolve-session.j
 import { DEFAULT_RESET_TRIGGERS, RESET_OVERLAP_COMMANDS, bareResetAckMessage, matchResetTriggers, resolveResetTriggers, shouldSkipResetOverlapCommand, stripLeadingEnvelopeTimestamp } from "./reset-triggers.js";
 import { initSessionTurn } from "./init-session-turn.js";
 import { CURRENT_SESSION_TRANSCRIPT_VERSION, XOPC_SESSION_TRANSCRIPT_TYPE } from "./transcript-format.js";
-export { CURRENT_SESSION_TRANSCRIPT_VERSION, DEFAULT_IDLE_MINUTES, DEFAULT_RESET_AT_HOUR, DEFAULT_RESET_MODE, DEFAULT_RESET_TRIGGERS, RESET_OVERLAP_COMMANDS, SessionConfigStore, SessionIndex, SessionStatus, SessionStore, XOPC_SESSION_TRANSCRIPT_TYPE, applySessionPatchToMetadata, bareResetAckMessage, buildSessionContextForLlm, effectiveWorkspacePathForSession, emitSessionTranscriptUpdate, evaluateSessionFreshness, fallbackTitleFromMessages, flattenMessageContent, generateSessionTitleFromMessages, getSessionTitleSource, initSessionTurn, isTranscriptContextEntry, isWebchatSessionKey, matchResetTriggers, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, mergeLlmMessagesPreservingContextRows, messagesToClientHistory, normalizeCompactionCheckpointId, normalizeWorkingDirectoryInput, onSessionTranscriptUpdate, projectWorkspacePath, provisionalTitleFromUserText, resolveChannelResetConfig, resolveDailyResetAtMs, resolveEffectiveReasoningLevel, resolveEffectiveThinkingLevel, resolveReasoningLevel, resolveResetTriggers, resolveSession, resolveSessionKeyForRequest, resolveSessionLifecycleTimestamps, resolveSessionResetPolicy, resolveSessionResetType, resolveThinkingLevel, resolveVerboseLevel, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleSessionKey, shouldRefineSessionTitleWithLlm, shouldSkipResetOverlapCommand, shouldSkipWebchatInboundByAbortCutoff, stripLeadingEnvelopeTimestamp, transcriptRowsFromJsonArray };
+export { CURRENT_SESSION_TRANSCRIPT_VERSION, DEFAULT_IDLE_MINUTES, DEFAULT_RESET_AT_HOUR, DEFAULT_RESET_MODE, DEFAULT_RESET_TRIGGERS, RESET_OVERLAP_COMMANDS, SessionConfigStore, SessionIndex, SessionStatus, SessionStore, XOPC_SESSION_TRANSCRIPT_TYPE, applySessionPatchToMetadata, bareResetAckMessage, buildSessionContextForLlm, effectiveWorkspacePathForSession, emitSessionTranscriptUpdate, evaluateSessionFreshness, fallbackTitleFromMessages, flattenMessageContent, generateSessionTitleFromMessages, getSessionTitleSource, initSessionTurn, isTranscriptContextEntry, isWebchatSessionKey, matchResetTriggers, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, mergeLlmMessagesPreservingContextRows, messagesToClientHistory, normalizeWorkingDirectoryInput, onSessionTranscriptUpdate, projectWorkspacePath, provisionalTitleFromUserText, resolveChannelResetConfig, resolveDailyResetAtMs, resolveEffectiveReasoningLevel, resolveEffectiveThinkingLevel, resolveReasoningLevel, resolveResetTriggers, resolveSession, resolveSessionKeyForRequest, resolveSessionLifecycleTimestamps, resolveSessionResetPolicy, resolveSessionResetType, resolveThinkingLevel, resolveVerboseLevel, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleSessionKey, shouldRefineSessionTitleWithLlm, shouldSkipResetOverlapCommand, shouldSkipWebchatInboundByAbortCutoff, stripLeadingEnvelopeTimestamp, transcriptRowsFromJsonArray };

package/dist/src/session/init-session-turn.d.ts

@@ -19,6 +19,5 @@ export type InitSessionTurnOptions = {
     sessionKey: string;
     body?: string;
     resetSession: SessionResetFn;
-    skipImplicitExpiry?: boolean;
 };
 export declare function initSessionTurn(opts: InitSessionTurnOptions): Promise<InitSessionTurnResult>;

package/dist/src/session/init-session-turn.js

@@ -50,8 +50,7 @@ async function initSessionTurn(opts) {
 		now,
 		policy: resetPolicy
 	}) : { fresh: false };
-	const skipImplicit = opts.skipImplicitExpiry ?? false;
-	const staleRollover = Boolean(sessionMetadata && !skipImplicit && !freshness.fresh);
+	const staleRollover = Boolean(sessionMetadata && resetPolicy.configured === true && !freshness.fresh);
 	const needsRollover = triggerMatch.resetTriggered || staleRollover;
 	let sessionId = sessionMetadata?.sessionId;
 	let previousSessionId;