@matthewfl/pi-contemplator 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matthewfl/pi-contemplator",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "A Pi extension that keeps long-running agentic sessions on track with background memory, contemplation, and structural review.",
   "type": "module",
   "license": "MIT",
@@ -50,10 +50,11 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "^0.84.4",
-    "@earendil-works/pi-ai": "^0.84.4",
-    "@earendil-works/pi-coding-agent": "^0.84.4",
-    "@earendil-works/pi-tui": "^0.84.4",
+    "@earendil-works/pi-agent-core": "^0.85.0",
+    "@earendil-works/pi-ai": "^0.85.0",
+    "@earendil-works/pi-coding-agent": "^0.85.0",
+    "@earendil-works/pi-server": "^0.85.0",
+    "@earendil-works/pi-tui": "^0.85.0",
     "@types/node": "^22.0.0",
     "typebox": "^1.1.38",
     "typescript": "^5.6.0",

package/src/agents/contemplator/agent.ts

@@ -506,6 +506,8 @@ export class Contemplator {
 		this.history = [];
 		this.historyEntryIds = [];
 		const historyMessagesByEntryId = new Map<string, AgentMessage>();
+		const checkpointCoveredObservationIds = new Set<string>();
+		const checkpointCoveredReviewIds = new Set<string>();
 		let resetProjection: ReturnType<typeof fullProjection> | undefined;
 		if (resetTracking) {
 			this.deliveredProbeIds.clear();
@@ -539,7 +541,7 @@ export class Contemplator {
 				}
 			}
 			if (entry.customType === CONTEMPLATOR_MESSAGE && entry.data && typeof entry.data === "object") {
-				const data = entry.data as { message?: unknown; compacted?: unknown; retainedMessageEntryIds?: unknown };
+				const data = entry.data as { message?: unknown; compacted?: unknown; retainedMessageEntryIds?: unknown; coveredObservationIds?: unknown; coveredReviewIds?: unknown };
 				const message = data.message;
 				if (message && typeof message === "object") {
 					const typedMessage = message as AgentMessage;
@@ -550,6 +552,8 @@ export class Contemplator {
 							: [];
 						this.history = [typedMessage, ...retainedIds.map((id) => historyMessagesByEntryId.get(id)!)];
 						this.historyEntryIds = [entry.id, ...retainedIds];
+						if (Array.isArray(data.coveredObservationIds)) for (const id of data.coveredObservationIds) if (typeof id === "string") checkpointCoveredObservationIds.add(id);
+						if (Array.isArray(data.coveredReviewIds)) for (const id of data.coveredReviewIds) if (typeof id === "string") checkpointCoveredReviewIds.add(id);
 					} else {
 						this.history.push(typedMessage);
 						this.historyEntryIds.push(entry.id);
@@ -607,10 +611,10 @@ export class Contemplator {
 			}
 		}
 		if (resetTracking && resetProjection) {
-			// Successful contemplator update prompts are the durable coverage record.
-			// Only memories present in those prompts are considered seen after reload;
-			// memories from a failed, unpersisted run remain pending and retryable.
-			const coveredIds = new Set<string>();
+			// Successful update prompts and private-history compaction checkpoints are
+			// the durable coverage record. Checkpoints carry ids from prompts replaced
+			// by their summary; failed, unpersisted runs remain pending and retryable.
+			const coveredIds = new Set<string>([...checkpointCoveredObservationIds, ...checkpointCoveredReviewIds]);
 			for (const message of this.history) {
 				if (message.role !== "user") continue;
 				const text = customMessageText(message.content);
@@ -1359,7 +1363,28 @@ export class Contemplator {
 			debugLog("contemplator.compaction_postponed", { reason: "retained history lacked durable entry ids", retainedMessageCount: retainedMessages.length, retainedReferenceCount: retainedMessageEntryIds.length });
 			return;
 		}
-		const checkpoint = { version: 2, compacted: true, message: summaryMessage, retainedMessageEntryIds };
+		// Record only coverage evidenced by the exact durable prompt prefix being
+		// replaced. `seen*Ids` may also contain observations appended concurrently
+		// while summary generation awaited; those remain pending and must not be
+		// declared covered before their own prompt is persisted. Coverage is a delta
+		// per checkpoint, and restore unions checkpoints, avoiding cumulative O(n²)
+		// id duplication across a very long session.
+		const prefixCoveredIds = new Set<string>();
+		for (const message of history.slice(0, prefixEnd)) {
+			if (message.role !== "user") continue;
+			const text = customMessageText(message.content);
+			if (!text.includes("NEW MEMORY UPDATE")) continue;
+			for (const id of memoryReferenceIds(text)) prefixCoveredIds.add(id);
+		}
+		const currentProjection = fullProjection(ctx.sessionManager.getBranch() as Entry[]);
+		const checkpoint = {
+			version: 2,
+			compacted: true,
+			message: summaryMessage,
+			retainedMessageEntryIds,
+			coveredObservationIds: currentProjection.observations.filter((item) => prefixCoveredIds.has(item.id)).map((item) => item.id),
+			coveredReviewIds: (currentProjection.reviews ?? []).filter((item) => prefixCoveredIds.has(item.id)).map((item) => item.id),
+		};
 		const checkpointEntryId = this.appendContemplatorHistoryEntry(ctx, checkpoint);
 		this.history = [summaryMessage, ...retainedMessages];
 		this.historyEntryIds = [checkpointEntryId, ...retainedMessageEntryIds];

package/src/agents/summarizer/agent.ts

@@ -106,6 +106,27 @@ function textResult(text: string, details: Record<string, unknown> = {}, termina
 	return { content: [{ type: "text" as const, text }], details, ...(terminate ? { terminate: true } : {}) };
 }
 
+/**
+ * Many provider chat templates discard historical reasoning blocks. Preserve
+ * unfinished plaintext work after an output-length stop by replaying it as
+ * ordinary assistant text; unlike provider-specific thinking metadata, text
+ * survives every supported conversation serializer. Redacted/encrypted blocks
+ * must remain structured so their opaque provider payload stays replayable.
+ * The durable/in-memory transcript remains unchanged—this transformation is
+ * only applied at the LLM boundary.
+ */
+export function replayTruncatedThinkingAsText(messages: readonly AgentMessage[]): Message[] {
+	return messages.map((message) => {
+		if (message.role !== "assistant" || message.stopReason !== "length" || !message.content.some((part) => part.type === "thinking" && !part.redacted)) return message as Message;
+		return {
+			...message,
+			content: message.content.map((part) => part.type === "thinking" && !part.redacted
+				? { type: "text" as const, text: `[Incomplete analysis from the preceding truncated response]\n${part.thinking}` }
+				: part),
+		} as Message;
+	});
+}
+
 function preview(content: string): string {
 	const compact = content.replace(/\s+/g, " ").trim();
 	return compact.length <= 100 ? compact : `${compact.slice(0, 100)}…`;
@@ -540,7 +561,7 @@ export async function runSummarizer(args: RunSummarizerArgs): Promise<Summarizer
 			apiKey: args.apiKey,
 			headers: args.headers,
 			maxTokens: boundedMaxTokens(args.model, maxOutputTokens),
-			convertToLlm: (messages) => messages as Message[],
+			convertToLlm: replayTruncatedThinkingAsText,
 			toolExecution: "sequential",
 			beforeToolCall: async ({ toolCall, context: toolContext }) => {
 				if (toolCall.name !== "done") return undefined;
@@ -597,7 +618,7 @@ export async function runSummarizer(args: RunSummarizerArgs): Promise<Summarizer
 		let stopReason = await runOnce("The preceding summarize call and receipt are an illustrative example only. Its placeholder ids are not real and it did not create a summary. Now pick any five coherent groups of actual memories worth combining and use summarize to create about five summary memories. Do not rank the whole pool; the first five worthwhile groups are good enough, and you will have more chances afterward. Record a summary as soon as it looks reasonable rather than drafting all five in prose or thinking. If you create one in prose or thinking, record it with summarize immediately. Memories not combined remain verbatim. If fewer than five are worthwhile, create only those; if none are safe, call done.", false);
 		for (let invocation = 1; !completedWithDone && invocation < SUMMARIZER_MAX_INVOCATIONS; invocation++) {
 			const continuingTruncatedResponse = stopReason === "length";
-			stopReason = await runOnce(continuingTruncatedResponse ? "Continue working." : summarizerContinue(drafts.size, invocation), !continuingTruncatedResponse);
+			stopReason = await runOnce(continuingTruncatedResponse ? "Continue working from the incomplete analysis above. Do not restart it." : summarizerContinue(drafts.size, invocation), !continuingTruncatedResponse);
 		}
 	} catch (error) {
 		debugLog("summarizer.error", { error: error instanceof Error ? error.message : String(error), acceptedSummaries: drafts.size });