opencode-clm 0.4.0 → 0.4.1

package/NOTICE

@@ -22,7 +22,7 @@ Derived from pi-clm (code and model-facing text, adapted for OpenCode):
   src/steering.ts               src/steering.ts
   src/types.ts                  src/types.ts
   steering/house-brief.md       steering/house-brief.md (byte-identical copy)
-  skills/clm-context/SKILL.md   src/skills/live-context/SKILL.md
+  .agents/skills/clm-context/SKILL.md   src/skills/live-context/SKILL.md
   src/panel/timeline.ts         src/timeline.ts (context chart and its zoom levels)
   src/panel/diff.ts             src/diff.ts (side-by-side diff)
   src/panel/view.ts             src/viewer.ts (panel pages)
@@ -45,5 +45,5 @@ Context Language Models
   Two design choices follow its harness: the fit/shrink edit gate and the default
   25/50/75% reminder steps. pi-clm's skill guidance on edit cost (batch edits, mind the
   tail below an edit, write detailed summaries), carried into
-  skills/clm-context/SKILL.md, covers the same points as the harness prompt in
+  .agents/skills/clm-context/SKILL.md, covers the same points as the harness prompt in
   different words.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-clm",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "OpenCode plugin for Context Language Models: the model edits a file mirror of its own context, and the edited mirror becomes its next input.",
   "type": "module",
   "license": "MIT",
@@ -31,7 +31,7 @@
     "index.ts",
     "tui.ts",
     "src/**/*.ts",
-    "skills/**",
+    ".agents/skills/clm-context/**",
     "steering/**",
     "LICENSE",
     "NOTICE",

package/src/clm.ts

@@ -38,7 +38,6 @@
  * calibrator learns only from requests whose full scope (system prompt and tool schemas
  * included) was estimated; without those sizes it stays at 1.
  */
-import { randomUUID } from "node:crypto";
 import { appendFile, mkdir, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
@@ -261,11 +260,6 @@ export class ClmSession {
 	private pendingAlerts: string[] = [];
 	/** The settings warning last shown to the user, so a new or changed one toasts once. */
 	private shownSettingsWarning?: string;
-	/**
-	 * Per-process seed of the stable document id. Fresh on every open, so a document id never
-	 * repeats even when a corrupt state file resets the revision counter to 0.
-	 */
-	private readonly nonce = randomUUID();
 	private readonly tokenCache = new WeakMap<LiveContextMessage, number>();
 	private saving: Promise<void> = Promise.resolve();
 	private running: Promise<unknown> = Promise.resolve();
@@ -1264,6 +1258,24 @@ export class ClmSession {
 		} else if (this.state.checkpoint) {
 			this.invalidationStreak = 0;
 		}
+		if (projection.valid && projection.reanchor) {
+			// OpenCode rewrote messages of the current turn after the checkpoint was captured
+			// (an assistant message still being finalized). Trim the anchor to the stable head
+			// instead of dropping the revision: the trimmed tail becomes ordinary suffix,
+			// exactly as if the edit had been committed a moment later. Silent by design;
+			// `reanchored` in events.jsonl records it for the panel and for debugging.
+			this.invalidationStreak = 0;
+			const reanchor = projection.reanchor;
+			const revision = this.state.revision;
+			await this.updateState(
+				(state) =>
+					state.checkpoint && state.revision === revision
+						? { ...state, checkpoint: { ...state.checkpoint, ...reanchor } }
+						: state,
+				true,
+			).catch(() => undefined);
+			await this.log({ event: "reanchored", revision, sourceMessageCount: reanchor.sourceMessageCount });
+		}
 		const origin = this.forkOrigin;
 		this.forkOrigin = undefined;
 		if (origin && !noticesOnly && !this.state.checkpoint && this.state.revision === 0 && (await this.restoreFromFork(origin, source))) {
@@ -1331,9 +1343,10 @@ export class ClmSession {
 		const snapshot = noticesOnly ? undefined : renderContextDocument(effective, {
 			revision: this.state.revision,
 			protectedIndexes: new Set<number>(),
-			// Constant until the next accepted edit or reset, so header ids read on one call
-			// remain valid on the next; bodies are escaped accordingly.
-			documentSeed: `${this.sessionID}:${this.nonce}:${checkpoint?.sourceDigest ?? "raw"}`,
+			// Constant until the next accepted edit or reset — and across process restarts,
+			// as pi-clm's is — so header ids read on one call remain valid on the next;
+			// bodies are escaped accordingly.
+			documentSeed: `${this.sessionID}:${checkpoint?.sourceDigest ?? "raw"}`,
 		});
 		if (snapshot) {
 			try {

package/src/context-document.ts

@@ -54,7 +54,10 @@ function normalizeJson(value: unknown): unknown {
 }
 
 export function canonicalMessage(message: LiveContextMessage): string {
-	return JSON.stringify(normalizeJson(message));
+	// `updatedAt` is OpenCode write metadata, not content: OpenCode rewrites it in place while
+	// a message is still being finalized, so it must not reach any digest or block id.
+	const { updatedAt: _updatedAt, ...rest } = message;
+	return JSON.stringify(normalizeJson(rest));
 }
 
 export function digestMessages(messages: LiveContextMessage[]): string {

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/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>;
 

package/src/state.ts

@@ -96,6 +96,23 @@ function isMessageArray(value: unknown): value is LiveContextMessage[] {
 	);
 }
 
+/** Per-message stamps (`projection.ts` SourceStamp): a hex digest and a finite `updatedAt`. */
+function isSourceStamps(value: unknown, count: unknown): boolean {
+	return (
+		Array.isArray(value) &&
+		value.length === count &&
+		value.every(
+			(stamp) =>
+				isObject(stamp) &&
+				typeof stamp.digest === "string" &&
+				/^[a-f0-9]{64}$/.test(stamp.digest) &&
+				Number.isFinite(stamp.updatedAt) &&
+				(stamp.strippedDigest === undefined ||
+					(typeof stamp.strippedDigest === "string" && /^[a-f0-9]{64}$/.test(stamp.strippedDigest))),
+		)
+	);
+}
+
 function isContextEditTrace(value: unknown): value is ContextEditTrace {
 	if (!isObject(value)) return false;
 	const trace = value as Partial<ContextEditTrace>;
@@ -134,6 +151,7 @@ export function isProjectionCheckpoint(value: unknown): value is ProjectionCheck
 		checkpoint.sourceIds.every((id) => typeof id === "string") &&
 		typeof checkpoint.sourceDigest === "string" &&
 		/^[a-f0-9]{64}$/.test(checkpoint.sourceDigest) &&
+		(checkpoint.sourceStamps === undefined || isSourceStamps(checkpoint.sourceStamps, checkpoint.sourceMessageCount)) &&
 		isMessageArray(checkpoint.projectedMessages) &&
 		Number.isFinite(checkpoint.beforeEstimate) &&
 		Number.isFinite(checkpoint.afterEstimate) &&
@@ -238,12 +256,43 @@ export async function loadLiveContextState(directory: string): Promise<LoadedSta
 		delete parsed.budgetCheck;
 		repaired = `${path} had an invalid budgetCheck; dropped it, the fixed overhead is measured again.`;
 	}
+	// A malformed outcome costs only itself: the panel loses one line, the checkpoint stays.
+	if (isObject(parsed) && parsed.lastOutcome !== undefined && !isOutcome(parsed.lastOutcome)) {
+		delete parsed.lastOutcome;
+		repaired = `${path} had an invalid lastOutcome; dropped it, the last outcome is unknown.`;
+	}
+	// Malformed per-message stamps cost only tail re-anchoring: the checkpoint keeps working
+	// with the whole-prefix digest and fails closed on a mismatch, as before.
+	if (
+		isObject(parsed) &&
+		isObject(parsed.checkpoint) &&
+		parsed.checkpoint.sourceStamps !== undefined &&
+		!isSourceStamps(parsed.checkpoint.sourceStamps, parsed.checkpoint.sourceMessageCount)
+	) {
+		delete parsed.checkpoint.sourceStamps;
+		repaired = `${path} had invalid sourceStamps; dropped them, tail re-anchoring is off for this checkpoint.`;
+	}
 	if (!isLiveContextState(parsed)) {
-		return { state: initialLiveContextState(), warning: `${path} has an invalid shape; starting clean.` };
+		return { state: initialLiveContextState(), warning: `${path} has an invalid shape (${stateProblem(parsed)}); starting clean.` };
 	}
 	return repaired ? { state: parsed, repaired } : { state: parsed };
 }
 
+/** Names the first state check `value` fails, so a load warning locates the bad field. */
+function stateProblem(value: unknown): string {
+	if (!isObject(value)) return "not an object";
+	if (value.version !== STATE_VERSION) return `unsupported version ${JSON.stringify(value.version)}`;
+	if (typeof value.enabled !== "boolean") return "enabled is not a boolean";
+	if (!isCount(value.revision)) return "revision is not a count";
+	if (value.checkpoint !== undefined) {
+		if (!isProjectionCheckpoint(value.checkpoint)) return "checkpoint is invalid";
+		if (value.checkpoint.revision !== value.revision) return "checkpoint revision does not match the state revision";
+	}
+	if (value.lastOutcome !== undefined && !isOutcome(value.lastOutcome)) return "lastOutcome is invalid";
+	if (value.budgetCheck !== undefined && !isBudgetCheck(value.budgetCheck)) return "budgetCheck is invalid";
+	return "unknown";
+}
+
 /**
  * Write `state.json` atomically with mode 0600: temp file, fsync, rename, then fsync the
  * directory (best effort). Concurrent saves are not ordered: the last rename wins, so an

package/src/types.ts

@@ -4,6 +4,8 @@ export type LiveContextMessage = {
 	role: string;
 	content?: unknown;
 	timestamp?: number;
+	/** OpenCode's `info.time.updated`: the in-place write marker used for tail re-anchoring. */
+	updatedAt?: number;
 	[key: string]: unknown;
 };