opencode-clm 0.4.0 → 0.5.0

package/src/mirror-guard.ts

@@ -80,10 +80,12 @@ export function classifyMirrorToolCall(
 		case "write":
 			return isMirror(pathArg(input)) ? "write" : "none";
 		case "apply_patch":
+		case "patch": // OpenCode 2's name for the same tool and input
 			return typeof input.patchText === "string" && patchPaths(input.patchText).some(isMirror) ? "write" : "none";
 		case "read":
 			return isMirror(pathArg(input)) ? "read" : "none";
-		case "bash": {
+		case "bash":
+		case "shell": { // OpenCode 2's name for bash, with the same `command` input
 			if (typeof input.command !== "string") return "none";
 			const command = input.command;
 			if (!referencesMirror(command, mirrorPath)) return "none";

package/src/opencode-v2.ts

@@ -0,0 +1,305 @@
+/**
+ * OpenCode 2 adapter: conversion between the provider-level messages of OpenCode 2's
+ * `session.hook("context")` and the `{ info, parts }` messages the core works on
+ * (src/opencode.ts, as delivered by OpenCode 1's `experimental.chat.messages.transform`).
+ *
+ * OpenCode 2 hands the hook the request it is about to send (packages/core/src/session/
+ * runner/to-llm-message.ts, 2.1.1): `user` and `assistant` messages carry the stored session
+ * message id; an assistant message is followed by one `role: "tool"` message per tool result
+ * (no id, paired by call id); a hosted tool's result sits inline in the assistant content.
+ * `system` messages (mid-conversation instructions, reasoning-effort markers), messages
+ * without an id (native compaction windows) and assistant messages with content OpenCode 1
+ * has no part for (media, provider compaction) have no `{ info, parts }` form: they are
+ * kept out of the core's view and put back next to the message they followed.
+ *
+ * Identity rule, as in `unflatten`: a message the core returns untouched (the same object
+ * `fromV2` made) maps back to the exact OpenCode 2 messages it stands for, provider metadata
+ * included, so an unedited context reaches the provider byte for byte. A rewritten message
+ * is rebuilt from its parts, reusing every original part that did not change.
+ */
+import type { OcMessage, OcPart } from "./opencode.ts";
+
+/** One content part of an OpenCode 2 message (`@opencode/ai` `ContentPart`). */
+export type V2Part = { type: string; [key: string]: any };
+
+/** One message of the OpenCode 2 `context` hook (`@opencode/ai` `Message`). */
+export interface V2Message {
+	id?: string;
+	role: "system" | "user" | "assistant" | "tool";
+	content: V2Part[];
+	metadata?: Record<string, unknown>;
+	[key: string]: unknown;
+}
+
+/** Provider-reported usage of one assistant message (`session.step.ended` `tokens`). */
+export interface V2Tokens {
+	input?: number;
+	output?: number;
+	reasoning?: number;
+	cache?: { read?: number; write?: number };
+}
+
+/** A message with no `{ info, parts }` form, and where it stood. */
+interface Opaque {
+	message: V2Message;
+	/** Id of the converted message it followed; undefined when it came first. */
+	after?: string;
+	/** Id of the converted message that followed it; undefined when it came last. */
+	before?: string;
+}
+
+/** The core's view of one OpenCode 2 request, and what is needed to map it back. */
+export interface V2View {
+	sessionID: string;
+	/** `{ info, parts }` messages, in request order. */
+	messages: OcMessage[];
+	/** The OpenCode 2 messages each converted message stands for (assistant: plus its tool messages). */
+	origin: Map<OcMessage, V2Message[]>;
+	/** The same, by message id, for messages the core rewrote. */
+	byId: Map<string, V2Message[]>;
+	/** Original OpenCode 2 part of each converted part. */
+	parts: Map<OcPart, V2Part>;
+	opaque: Opaque[];
+}
+
+/** The text of a tool result value (`@opencode/ai` `ToolResultValue`). */
+function resultText(result: { type?: string; value?: unknown } | undefined): string {
+	if (!result) return "";
+	const value = result.value;
+	if (result.type === "content" && Array.isArray(value)) {
+		return value.filter((item) => item?.type === "text").map((item) => String(item.text ?? "")).join("\n");
+	}
+	if (result.type === "error") {
+		const error = (value as { error?: unknown } | undefined)?.error ?? value;
+		const message = typeof error === "string" ? error : (error as { message?: unknown } | undefined)?.message;
+		const content = (value as { content?: unknown } | undefined)?.content;
+		const detail = Array.isArray(content) ? content.filter((item) => item?.type === "text").map((item) => String(item.text ?? "")).join("\n") : "";
+		const head = typeof message === "string" ? message : stringify(error);
+		return detail ? `${head}\n${detail}` : head;
+	}
+	return typeof value === "string" ? value : stringify(value);
+}
+
+function stringify(value: unknown): string {
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+
+/** Tool-result file items as OpenCode 1 attachments (`fileBlock` reads `mime` and `filename`). */
+function attachments(result: { type?: string; value?: unknown } | undefined): Array<{ mime: string; filename?: string }> {
+	if (result?.type !== "content" || !Array.isArray(result.value)) return [];
+	return result.value
+		.filter((item) => item?.type === "file" && typeof item.mime === "string")
+		.map((item) => ({ mime: String(item.mime), ...(typeof item.name === "string" ? { filename: item.name } : {}) }));
+}
+
+/** The OpenCode 1 tool state that `toolPartOutput` reads, from a call and its result. */
+function toolState(call: V2Part, result: V2Part | undefined): Record<string, unknown> {
+	const input = call.input && typeof call.input === "object" ? call.input : {};
+	if (!result) return { status: "pending", input };
+	const value = result.result as { type?: string; value?: unknown } | undefined;
+	if (value?.type === "error") return { status: "error", input, error: resultText(value), time: { start: 0, end: 0 } };
+	const files = attachments(value);
+	return {
+		status: "completed",
+		input,
+		output: resultText(value),
+		title: "",
+		metadata: {},
+		time: { start: 0, end: 0 },
+		...(files.length > 0 ? { attachments: files } : {}),
+	};
+}
+
+/** Opening line of the user message OpenCode 2 sends in place of a summarized history. */
+export const CHECKPOINT_OPEN = "<conversation-checkpoint>";
+
+/** Part types of an assistant message that have an OpenCode 1 counterpart. */
+const ASSISTANT_PARTS = new Set(["text", "reasoning", "tool-call", "tool-result"]);
+
+function convertible(message: V2Message): boolean {
+	if (typeof message.id !== "string" || message.id === "") return false;
+	if (message.role === "user") return message.content.every((part) => part.type === "text" || part.type === "media");
+	if (message.role === "assistant") return message.content.every((part) => ASSISTANT_PARTS.has(part.type));
+	return false;
+}
+
+/**
+ * OpenCode 2 request messages → `{ info, parts }` messages. `usage` supplies the provider
+ * count of an assistant message (from `session.step.ended`), which the core's budget
+ * calibration reads as `info.tokens`.
+ */
+export function fromV2(messages: readonly V2Message[], sessionID: string, usage?: (messageID: string) => V2Tokens | undefined): V2View {
+	const view: V2View = { sessionID, messages: [], origin: new Map(), byId: new Map(), parts: new Map(), opaque: [] };
+	const pending: Opaque[] = [];
+	let last: string | undefined;
+	const add = (oc: OcMessage, group: V2Message[]) => {
+		for (const item of pending.splice(0)) item.before = oc.info.id;
+		view.messages.push(oc);
+		view.origin.set(oc, group);
+		view.byId.set(oc.info.id, group);
+		last = oc.info.id;
+	};
+	for (let index = 0; index < messages.length; index++) {
+		const message = messages[index]!;
+		if (!convertible(message)) {
+			const item: Opaque = { message, ...(last !== undefined ? { after: last } : {}) };
+			view.opaque.push(item);
+			pending.push(item);
+			continue;
+		}
+		const id = message.id!;
+		const info: OcMessage["info"] = { id, sessionID, role: message.role as "user" | "assistant", time: { created: 0 } };
+		if (message.role === "user") {
+			// OpenCode 2 sends a summary compaction as one user message (to-llm-message.ts
+			// `compaction`); marked like OpenCode 1's summary, so the core rebases onto it.
+			if (String(message.content[0]?.text ?? "").startsWith(CHECKPOINT_OPEN)) info.summary = true;
+			const parts = message.content.map((part, at): OcPart => {
+				const converted: OcPart = part.type === "text"
+					? { id: `${id}:${at}`, type: "text", text: String(part.text ?? "") }
+					: { id: `${id}:${at}`, type: "file", mime: String(part.media?.mime ?? part.media?.mimeType ?? "application/octet-stream"), filename: part.filename };
+				view.parts.set(converted, part);
+				return converted;
+			});
+			add({ info, parts }, [message]);
+			continue;
+		}
+		// An assistant message and the tool messages that follow it.
+		const group = [message];
+		while (index + 1 < messages.length && messages[index + 1]!.role === "tool" && messages[index + 1]!.id === undefined) {
+			group.push(messages[++index]!);
+		}
+		const results = new Map<string, V2Part>();
+		for (const item of group) {
+			for (const part of item.content) if (part.type === "tool-result") results.set(String(part.id), part);
+		}
+		const parts: OcPart[] = [];
+		message.content.forEach((part, at) => {
+			let converted: OcPart | undefined;
+			if (part.type === "text") converted = { id: `${id}:${at}`, type: "text", text: String(part.text ?? "") };
+			else if (part.type === "reasoning") converted = { id: `${id}:${at}`, type: "reasoning", text: String(part.text ?? "") };
+			else if (part.type === "tool-call") {
+				converted = { id: `${id}:${at}`, type: "tool", callID: String(part.id), tool: String(part.name), state: toolState(part, results.get(String(part.id))) };
+			}
+			if (!converted) return;
+			view.parts.set(converted, part);
+			parts.push(converted);
+		});
+		const tokens = usage?.(id);
+		add({ info: { ...info, ...(tokens ? { tokens } : {}) }, parts }, group);
+	}
+	return view;
+}
+
+/** A core note or notice (no OpenCode 2 source): plain user text. */
+function noteToV2(message: OcMessage): V2Message {
+	const text = message.parts.filter((part) => part.type === "text").map((part) => String(part.text ?? "")).join("\n");
+	return { role: "user", content: [{ type: "text", text }] };
+}
+
+/** A user message the core rewrote: its text parts, original parts reused where unchanged. */
+function userToV2(message: OcMessage, original: V2Message, view: V2View): V2Message {
+	const content = message.parts.flatMap((part): V2Part[] => {
+		const source = view.parts.get(part);
+		if (source) return [source];
+		return part.type === "text" ? [{ type: "text", text: String(part.text ?? "") }] : [];
+	});
+	return { ...original, content };
+}
+
+/**
+ * An assistant message the core rewrote (an edited body, or tool results edited, withheld or
+ * capped): untouched parts keep their original form, a changed result becomes a text result
+ * in the original place (inline for a hosted tool, else its own `tool` message).
+ */
+function assistantToV2(message: OcMessage, group: V2Message[], view: V2View): V2Message[] {
+	const [original, ...tools] = group as [V2Message, ...V2Message[]];
+	const calls = new Map<string, V2Part>();
+	for (const part of original.content) if (part.type === "tool-call") calls.set(String(part.id), part);
+	const inline = new Map<string, V2Part>();
+	for (const part of original.content) if (part.type === "tool-result") inline.set(String(part.id), part);
+	const separate = new Map<string, V2Message>();
+	for (const tool of tools) {
+		const result = tool.content.find((part) => part.type === "tool-result");
+		if (result) separate.set(String(result.id), tool);
+	}
+	const content: V2Part[] = [];
+	const results: V2Message[] = [];
+	for (const part of message.parts) {
+		if (part.type !== "tool") {
+			const source = view.parts.get(part);
+			if (source) content.push(source);
+			else if (part.type === "text") content.push({ type: "text", text: String(part.text ?? "") });
+			else if (part.type === "reasoning") content.push({ type: "reasoning", text: String(part.text ?? "") });
+			continue;
+		}
+		const callID = String(part.callID);
+		const call = calls.get(callID);
+		if (!call) continue;
+		content.push(call);
+		const untouched = view.parts.has(part);
+		const hosted = inline.get(callID);
+		if (hosted) {
+			content.push(untouched ? hosted : { ...hosted, result: { type: "text", value: String(part.state?.output ?? "") }, providerMetadata: undefined });
+			continue;
+		}
+		const tool = separate.get(callID);
+		if (untouched) {
+			if (tool) results.push(tool);
+			continue;
+		}
+		const source = tool?.content.find((item) => item.type === "tool-result");
+		results.push({
+			role: "tool",
+			content: [{
+				type: "tool-result",
+				id: callID,
+				name: String(part.tool),
+				result: { type: "text", value: String(part.state?.output ?? "") },
+				...(source?.providerExecuted !== undefined ? { providerExecuted: source.providerExecuted } : {}),
+			}],
+		});
+	}
+	// An edited body drops the replay data of the text it replaced.
+	const edited = content.some((item) => !original.content.includes(item));
+	const rebuilt: V2Message = { ...original, content };
+	if (edited) delete rebuilt.providerMetadata;
+	return content.length > 0 ? [rebuilt, ...results] : results;
+}
+
+/**
+ * `{ info, parts }` messages the core returned → OpenCode 2 request messages, with the
+ * messages that had no `{ info, parts }` form put back after the message they followed (or,
+ * when that one is gone, before the message that followed them).
+ */
+export function toV2(view: V2View, result: readonly OcMessage[]): V2Message[] {
+	const present = new Set(result.map((message) => message.info.id));
+	const placed = new Set<Opaque>();
+	const out: V2Message[] = [];
+	const emit = (item: Opaque) => {
+		if (placed.has(item)) return;
+		placed.add(item);
+		out.push(item.message);
+	};
+	for (const item of view.opaque) if (item.after === undefined) emit(item);
+	for (const message of result) {
+		const id = message.info.id;
+		for (const item of view.opaque) {
+			if (item.before === id && (item.after === undefined || !present.has(item.after))) emit(item);
+		}
+		const group = view.origin.get(message);
+		if (group) out.push(...group);
+		else {
+			const original = view.byId.get(id);
+			if (!original) out.push(noteToV2(message));
+			else if (original[0]!.role === "user") out.push(userToV2(message, original[0]!, view));
+			else out.push(...assistantToV2(message, original, view));
+		}
+		for (const item of view.opaque) if (item.after === id) emit(item);
+	}
+	for (const item of view.opaque) emit(item);
+	return out;
+}

package/src/opencode.ts

@@ -27,7 +27,10 @@
  *   "[Tool execution was interrupted]".
  * Flattening never depends on settings: the projection digest is computed from it, and a
  * settings toggle must not discard an accepted revision. Reasoning is always flattened;
- * `withoutReasoning` hides it from the mirror view only.
+ * `withoutReasoning` hides it from the mirror view only. Every flat message carries
+ * `updatedAt` (`info.time.updated`, else `completed`, else `created`), OpenCode's in-place
+ * write marker: digests exclude it (`canonicalMessage`), and the projection reads it only to
+ * re-anchor a late rewrite of the tail instead of dropping the revision (projection.ts).
  *
  * Known gap: an assistant message whose only sendable parts are empty text parts has no
  * flat form and is left out of the request. OpenCode sends it as an empty assistant turn.
@@ -125,9 +128,12 @@ export function flatten(messages: readonly OcMessage[]): LiveContextMessage[] {
 		if (!sentToModel(message)) continue;
 		const id = message.info.id;
 		const timestamp = Number(message.info.time?.created ?? 0);
+		// OpenCode writes `completed` (and, on some hosts, `updated`); both move when a message
+		// is written in place, `created` does not.
+		const updatedAt = Number(message.info.time?.updated ?? message.info.time?.completed ?? message.info.time?.created ?? 0);
 		if (message.info.role === "user") {
 			const content = userContent(message);
-			if (content.length > 0) out.push({ role: "user", content, ocMessageID: id, timestamp });
+			if (content.length > 0) out.push({ role: "user", content, ocMessageID: id, timestamp, updatedAt });
 			continue;
 		}
 		const content: Record<string, unknown>[] = [];
@@ -147,11 +153,12 @@ export function flatten(messages: readonly OcMessage[]): LiveContextMessage[] {
 					isError: output.isError,
 					ocMessageID: id,
 					timestamp,
+					updatedAt,
 				});
 			}
 		}
 		if (content.length === 0) continue;
-		out.push({ role: "assistant", content, ocMessageID: id, timestamp });
+		out.push({ role: "assistant", content, ocMessageID: id, timestamp, updatedAt });
 		out.push(...results);
 	}
 	return out;

package/src/presentation.ts

@@ -93,6 +93,8 @@ export interface ClmStatus {
 	/** The accepted revision now in effect, if any. */
 	checkpoint?: { revision: number; anchorCount: number; beforeEstimate: number; afterEstimate: number };
 	lastRequest?: { rawMessages: number; sentMessages: number; mirrorBlocks: number };
+	/** OpenCode's newest compaction of the session in this process. */
+	lastCompaction?: { reason: "auto" | "manual"; at: number };
 	steering?: SteeringDocument;
 	/** Settings changed for this session (`budget 20k, guard off`); absent when none. */
 	changed?: string;
@@ -135,6 +137,10 @@ export function statusText(status: ClmStatus): string {
 		const request = status.lastRequest;
 		lines.push(`last request: ${request.rawMessages} raw messages → ${request.sentMessages} sent, ${request.mirrorBlocks} mirror blocks`);
 	}
+	if (status.lastCompaction) {
+		const time = new Date(status.lastCompaction.at).toTimeString().slice(0, 5);
+		lines.push(`last compaction: OpenCode, ${status.lastCompaction.reason === "auto" ? "automatic" : "/compact"}, at ${time}`);
+	}
 	lines.push(steeringStatusLine(status.steering));
 	if (status.changed) lines.push(`Changed: ${status.changed}`);
 	if (status.settingsWarning) lines.push(`settings warning: ${status.settingsWarning}`);

package/src/projection.ts

@@ -13,6 +13,15 @@
 // whole messages (ids change) or truncates the parts of a kept message (its toolCall and
 // toolResult disappear, so the digest changes); both still fail closed.
 //
+// One mismatch source is OpenCode's own late writes: it keeps updating message objects
+// after `experimental.chat.messages.transform` returns (an assistant message being
+// finalized, turn diffs attached to a user message). A checkpoint taken mid-turn digests
+// those still-mutable tail messages, and the late write flips the digest. `sourceStamps`
+// (per-message digest + captured `time.updated`) lets `applyProjection` attribute such a
+// mismatch to a post-capture OpenCode write and re-anchor the checkpoint to the stable
+// head instead of dropping the revision (see `reanchorTail`); anything not attributable
+// stays fail-closed.
+//
 // pi-clm's `recoverProjectionFromRetryErrors` is not ported. Pi writes failed assistant
 // responses to its session log but drops them from live state, so a resumed log hashes
 // differently. OpenCode keeps the error on the assistant message (`info.error`), and the
@@ -29,6 +38,19 @@ export const PROJECTION_SHORTER_REASON = "Raw context is shorter than the projec
 
 export type EstimateUnit = "characters" | "tokens";
 
+/** One source message's content digest plus the write time captured with it. */
+export interface SourceStamp {
+	digest: string;
+	updatedAt: number;
+	/**
+	 * Digest of the same message with OpenCode's `<system-reminder>` blocks removed
+	 * (whitespace-normalized). OpenCode appends and removes mode-change reminders on user
+	 * messages between requests without moving any write-time field; a change confined to
+	 * those blocks is attributable against this fingerprint.
+	 */
+	strippedDigest?: string;
+}
+
 export interface ProjectionCheckpoint {
 	version: 1;
 	revision: number;
@@ -38,6 +60,12 @@ export interface ProjectionCheckpoint {
 	sourceIds: string[];
 	/** `digestSourcePrefix` of those messages. */
 	sourceDigest: string;
+	/**
+	 * Per-message digest and captured write time (length is sourceMessageCount). Lets a
+	 * mismatch be attributed to specific messages and a late OpenCode write of the tail be
+	 * re-anchored instead of dropped; absent on checkpoints written by older versions.
+	 */
+	sourceStamps?: SourceStamp[];
 	projectedMessages: LiveContextMessage[];
 	beforeEstimate: number;
 	afterEstimate: number;
@@ -47,11 +75,21 @@ export interface ProjectionCheckpoint {
 	editTrace?: ContextEditTrace;
 }
 
+/** The trimmed anchor returned when a late tail rewrite was re-anchored instead of dropped. */
+export interface ProjectionReanchor {
+	sourceMessageCount: number;
+	sourceIds: string[];
+	sourceStamps: SourceStamp[];
+	sourceDigest: string;
+}
+
 export type ProjectionApplication =
 	| {
 			valid: true;
 			messages: LiveContextMessage[];
 			suffix: LiveContextMessage[];
+			/** Set when the anchor was trimmed to the stable head (see `reanchorTail`). */
+			reanchor?: ProjectionReanchor;
 	  }
 	| {
 			valid: false;
@@ -64,6 +102,60 @@ export function sourceMessageId(message: LiveContextMessage): string {
 	return typeof message.ocMessageID === "string" ? message.ocMessageID : "";
 }
 
+/** The prune-invariant form of one source message (see `digestSourcePrefix`). */
+function sourceDigestForm(message: LiveContextMessage): LiveContextMessage {
+	if (message.role !== "toolResult") return message;
+	return {
+		role: message.role,
+		toolCallId: message.toolCallId,
+		toolName: message.toolName,
+		isError: message.isError,
+		ocMessageID: message.ocMessageID,
+	};
+}
+
+const SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+
+/** Whitespace-normalized text without OpenCode's reminder blocks, for the stripped fingerprint. */
+function normalizeReminderFingerprint(text: string): string {
+	return text
+		.replace(/\r\n/g, "\n")
+		.replace(SYSTEM_REMINDER_RE, "")
+		.replace(/\n{2,}/g, "\n\n")
+		.trim();
+}
+
+/**
+ * The message with OpenCode's `<system-reminder>` blocks removed from its text parts; parts
+ * that become empty are dropped. OpenCode appends and removes mode-change reminders on user
+ * messages between requests without touching any write-time field, so a digest over this
+ * form tells a reminder-only edit apart from a real content change.
+ */
+export function stripSystemReminders(message: LiveContextMessage): LiveContextMessage {
+	const content = message.content;
+	if (!Array.isArray(content)) return message;
+	const stripped: unknown[] = [];
+	for (const part of content) {
+		if (!part || typeof part !== "object") {
+			stripped.push(part);
+			continue;
+		}
+		const block = part as Record<string, unknown>;
+		if (block.type !== "text" || typeof block.text !== "string") {
+			stripped.push(block);
+			continue;
+		}
+		const text = normalizeReminderFingerprint(block.text);
+		if (text !== "") stripped.push({ ...block, text });
+	}
+	return { ...message, content: stripped };
+}
+
+/** `digestSourceMessage` of the message without OpenCode's system-reminder blocks. */
+export function digestSourceMessageWithoutReminders(message: LiveContextMessage): string {
+	return digestMessages([sourceDigestForm(stripSystemReminders(message))]);
+}
+
 /**
  * Digest a raw source prefix in a form OpenCode's prune cannot change: every `toolResult`
  * keeps only role, toolCallId, toolName, isError and ocMessageID. Content is dropped for
@@ -71,18 +163,22 @@ export function sourceMessageId(message: LiveContextMessage): string {
  * created and may be cleared when it is validated.
  */
 export function digestSourcePrefix(messages: readonly LiveContextMessage[]): string {
-	return digestMessages(
-		messages.map((message) => {
-			if (message.role !== "toolResult") return message;
-			return {
-				role: message.role,
-				toolCallId: message.toolCallId,
-				toolName: message.toolName,
-				isError: message.isError,
-				ocMessageID: message.ocMessageID,
-			};
-		}),
-	);
+	return digestMessages(messages.map(sourceDigestForm));
+}
+
+/** `digestSourcePrefix` of one message: per-message attribution for tail re-anchoring. */
+export function digestSourceMessage(message: LiveContextMessage): string {
+	return digestMessages([sourceDigestForm(message)]);
+}
+
+/** A message's stamp: its content digest, the write time OpenCode last wrote, and the
+ * reminder-stripped fingerprint. */
+export function sourceStamp(message: LiveContextMessage): SourceStamp {
+	return {
+		digest: digestSourceMessage(message),
+		updatedAt: typeof message.updatedAt === "number" ? message.updatedAt : 0,
+		strippedDigest: digestSourceMessageWithoutReminders(message),
+	};
 }
 
 /**
@@ -109,6 +205,7 @@ export function createProjectionCheckpoint(options: {
 		sourceMessageCount: options.sourceMessages.length,
 		sourceIds: options.sourceMessages.map(sourceMessageId),
 		sourceDigest: digestSourcePrefix(options.sourceMessages),
+		sourceStamps: options.sourceMessages.map(sourceStamp),
 		projectedMessages: [...options.projectedMessages],
 		beforeEstimate: options.beforeEstimate,
 		afterEstimate: options.afterEstimate,
@@ -124,7 +221,11 @@ export function createProjectionCheckpoint(options: {
 
 /**
  * Replace the checkpoint's raw source prefix and keep every raw message appended after
- * it. A mismatch fails closed and returns a copy of the untouched raw context.
+ * it. A mismatch fails closed and returns a copy of the untouched raw context — unless the
+ * checkpoint has per-message stamps and every changed message was written by OpenCode after
+ * it was captured (the current turn's tail still being finalized): then the anchor is
+ * trimmed to the stable head, the trimmed tail flows as ordinary suffix, and the caller
+ * persists `reanchor` on the checkpoint.
  */
 export function applyProjection(
 	rawMessages: readonly LiveContextMessage[],
@@ -147,8 +248,50 @@ export function applyProjection(
 		return { valid: false, messages: [...rawMessages], reason: PROJECTION_SOURCE_IDS_REASON };
 	}
 	if (digestSourcePrefix(prefix) !== checkpoint.sourceDigest) {
-		return { valid: false, messages: [...rawMessages], reason: PROJECTION_PREFIX_MISMATCH_REASON };
+		return reanchorTail(rawMessages, prefix, checkpoint) ??
+			{ valid: false, messages: [...rawMessages], reason: PROJECTION_PREFIX_MISMATCH_REASON };
 	}
 	const suffix = rawMessages.slice(checkpoint.sourceMessageCount);
 	return { valid: true, messages: [...checkpoint.projectedMessages, ...suffix], suffix };
 }
+
+/**
+ * A mismatch OpenCode itself caused. Every changed message must be explained by an
+ * OpenCode write: either its write time (`time.completed`/`updated`, not `created`) moved
+ * past the stamp, or the change is confined to OpenCode's `<system-reminder>` mode-change
+ * blocks (verified against the reminder-stripped per-message digest). That is the tail of
+ * the current turn still being finalized or a mode switch — not a revert, a compaction or
+ * a foreign transform, which change ids or content in ways neither check explains and stay
+ * fail-closed. The anchor is trimmed to the last stable message; the trimmed tail becomes
+ * ordinary suffix, the same contract as pi-clm's rebasing for appended messages.
+ */
+function reanchorTail(
+	rawMessages: readonly LiveContextMessage[],
+	prefix: readonly LiveContextMessage[],
+	checkpoint: ProjectionCheckpoint,
+): ProjectionApplication | undefined {
+	const stamps = checkpoint.sourceStamps;
+	if (!Array.isArray(stamps) || stamps.length !== prefix.length) return undefined;
+	const changed = prefix.map((message, index) => digestSourceMessage(message) !== stamps[index]!.digest);
+	const first = changed.indexOf(true);
+	if (first <= 0) return undefined;
+	const attributable = prefix.every((message, index) => {
+		if (!changed[index]) return true;
+		const stamp = stamps[index]!;
+		if (typeof message.updatedAt === "number" && message.updatedAt > stamp.updatedAt) return true;
+		// OpenCode appends and removes `<system-reminder>` blocks (mode changes) on user
+		// messages without moving any write time; a change confined to those blocks is still
+		// an OpenCode edit. Everything else fails closed.
+		return typeof stamp.strippedDigest === "string" && digestSourceMessageWithoutReminders(message) === stamp.strippedDigest;
+	});
+	if (!attributable) return undefined;
+	const stable = prefix.slice(0, first);
+	const reanchor: ProjectionReanchor = {
+		sourceMessageCount: stable.length,
+		sourceIds: stable.map(sourceMessageId),
+		sourceStamps: stable.map(sourceStamp),
+		sourceDigest: digestSourcePrefix(stable),
+	};
+	const suffix = rawMessages.slice(stable.length);
+	return { valid: true, messages: [...checkpoint.projectedMessages, ...suffix], suffix, reanchor };
+}

package/src/settings.ts

@@ -75,7 +75,7 @@ export function parseCompaction(value: unknown, name = "compaction"): Compaction
 
 export const PACKAGE_DIR = resolve(fileURLToPath(new URL("..", import.meta.url)));
 export const HOUSE_STEERING = join(PACKAGE_DIR, "steering", "house-brief.md");
-export const SKILLS_DIR = join(PACKAGE_DIR, "skills");
+export const SKILLS_DIR = join(PACKAGE_DIR, ".agents/skills/clm-context");
 
 type Env = Record<string, string | undefined>;
 
@@ -168,7 +168,9 @@ export function parseCooldown(value: unknown, name = "reminderCooldown"): number
 	if (text === "off" || text === "none" || text === "0" || text === "0%") return 0;
 	const percent = text.endsWith("%");
 	const number = percent ? text.slice(0, -1).trim() : text;
-	const parsed = /^\d*\.?\d+$/.test(number) ? Number(number) / (percent ? 100 : 1) : Number.NaN;
+	// Bounded, and unambiguous: `\d*\.?\d+` backtracks polynomially on a long digit string (CodeQL).
+	const parsed =
+		number.length <= 32 && /^(?:\d+(?:\.\d+)?|\.\d+)$/.test(number) ? Number(number) / (percent ? 100 : 1) : Number.NaN;
 	if (!(parsed > 0 && parsed < 1)) throw new Error(`${name} must be ${COOLDOWN_FORMS}, got ${JSON.stringify(value)}`);
 	return parsed;
 }