@matthewfl/pi-contemplator 0.1.15 → 0.1.17

package/package.json

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

package/src/agents/observer/agent.ts

@@ -4,6 +4,7 @@ import { Type } from "@earendil-works/pi-ai";
 import { streamSimple } from "@earendil-works/pi-ai/compat";
 import type { Static } from "typebox";
 import { hashId } from "../../ids.js";
+import { replayTruncatedThinkingAsText } from "../replay-truncated-thinking.js";
 import { logAgentStreamError } from "../stream-errors.js";
 import { OBSERVER_AGENT_LOOP_MAX_TOKENS, boundedMaxTokens } from "../../model-budget.js";
 import { OBSERVER_SYSTEM } from "./prompts.js";
@@ -73,6 +74,8 @@ const RecordObservationsSchema = Type.Object({
 
 type RecordObservationsArgs = Static<typeof RecordObservationsSchema>;
 
+export const OBSERVER_MAX_LENGTH_ATTEMPTS = 4;
+
 /** A terminal provider/agent-loop failure that must not advance observation coverage. */
 export class ObserverStreamError extends Error {
 	readonly stopReason: string;
@@ -205,7 +208,7 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 		apiKey,
 		headers,
 		maxTokens: boundedMaxTokens(model, OBSERVER_AGENT_LOOP_MAX_TOKENS),
-		convertToLlm: (msgs) => msgs as Message[],
+		convertToLlm: replayTruncatedThinkingAsText,
 		toolExecution: "sequential",
 		shouldStopAfterTurn: () => {
 			turnCount++;
@@ -217,7 +220,7 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 	const loop = args.agentLoop ?? agentLoop;
 	const history: AgentMessage[] = [];
 	let terminalFailure: { stopReason: string; errorMessage?: string } | undefined;
-	let lengthRetryAttempted = false;
+	let lengthAttempts = 0;
 	const runInvocation = async (prompt: Message, afterLength = false): Promise<void> => {
 		const context: AgentContext = {
 			systemPrompt: OBSERVER_SYSTEM,
@@ -264,15 +267,18 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 	};
 
 	await runInvocation(initialPrompt);
-	if (accumulated.size === 0 && terminalFailure?.stopReason === "length") {
-		lengthRetryAttempted = true;
+	if (terminalFailure?.stopReason === "length") lengthAttempts = 1;
+	while (accumulated.size === 0 && terminalFailure?.stopReason === "length" && lengthAttempts < OBSERVER_MAX_LENGTH_ATTEMPTS) {
 		// A provider can impose a lower output ceiling than the advertised model
 		// maximum. agentLoop stops on `length` when no tool call was completed; it
 		// does not automatically send a continuation request. Preserve the partial
 		// response so the model can continue from work it already performed rather
-		// than paying to reproduce it, then append a short tool-focused instruction
-		// and reduce reasoning to minimal. A second length stop fails forward at the
-		// bounded-chunk level.
+		// than paying to reproduce it. Plaintext thinking is replayed as ordinary
+		// assistant text at the LLM boundary because some provider templates strip
+		// historical reasoning; encrypted thinking retains its opaque structure.
+		// Then append a short tool-focused instruction and reduce reasoning to
+		// minimal. The bounded attempt limit prevents pathological chunks from
+		// consuming background tokens forever.
 		terminalFailure = undefined;
 		const retryPrompt: Message = {
 			role: "user",
@@ -280,6 +286,10 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 			timestamp: Date.now(),
 		};
 		await runInvocation(retryPrompt, true);
+		// runInvocation mutates this through its async stream callbacks; TypeScript
+		// cannot infer that mutation after the explicit reset above.
+		const retryFailure = terminalFailure as { stopReason: string; errorMessage?: string } | undefined;
+		if (retryFailure?.stopReason === "length") lengthAttempts++;
 	}
 	if (accumulated.size === 0 && !doneCalled && !terminalFailure && rejectedTotal === 0) {
 		const reminder: Message = {
@@ -295,8 +305,8 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 	// zero-observation stop is also a valid empty result after the reminder;
 	// actual stream failures, truncation, and malformed records still throw.
 	if (accumulated.size === 0 && terminalFailure) {
-		const detail = terminalFailure.stopReason === "length" && lengthRetryAttempted
-			? `provider reached the output limit twice without recording an observation (effective max output request: ${baseConfig.maxTokens} tokens)`
+		const detail = terminalFailure.stopReason === "length" && lengthAttempts > 0
+			? `provider reached the output limit ${lengthAttempts} times without recording an observation (effective max output request: ${baseConfig.maxTokens} tokens)`
 			: terminalFailure.errorMessage;
 		throw new ObserverStreamError(terminalFailure.stopReason, detail);
 	}

package/src/agents/replay-truncated-thinking.ts

@@ -0,0 +1,21 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { Message } from "@earendil-works/pi-ai";
+
+/**
+ * Many provider chat templates discard historical reasoning blocks. Preserve
+ * unfinished plaintext work after an output-length stop by replaying it as
+ * ordinary assistant text. Redacted/encrypted blocks remain structured so
+ * their opaque provider payload stays replayable. The original transcript is
+ * never mutated; 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;
+	});
+}

package/src/agents/summarizer/agent.ts

@@ -26,6 +26,7 @@ import {
 import { estimateStringTokens } from "../../tokens.js";
 import { createRecallAgentTool } from "../../tools/recall-observation.js";
 import { createSearchMemoriesAgentTool } from "../../tools/search-memories.js";
+import { replayTruncatedThinkingAsText } from "../replay-truncated-thinking.js";
 import { logAgentStreamError } from "../stream-errors.js";
 import { summarizerContinue, SUMMARIZER_SYSTEM } from "./prompts.js";
 import {
@@ -106,27 +107,6 @@ 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)}…`;

package/src/commands/status.ts

@@ -62,10 +62,6 @@ function truncateStatusText(value: string, limit = 1_000): string {
 	return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`;
 }
 
-function tokenSum(items: { tokenCount: number }[]): number {
-	return items.reduce((sum, item) => sum + item.tokenCount, 0);
-}
-
 function addedSuffix(count: number): string | undefined {
 	return count > 0 ? `+${count.toLocaleString()}` : undefined;
 }
@@ -90,8 +86,6 @@ export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void
 			const full = fullProjection(entries);
 			const drift = diffProjection(visible, full);
 
-			const visibleObservationTokens = tokenSum(visible.observations);
-			const visibleSummaryTokens = tokenSum(visible.summaries);
 			const pools = partitionMemoryPools(folded.activeObservations, folded.activeSummaries, runtime.config.newMemoryPoolMaxTokens);
 			const observationLine = appendSuffixes(
 				`Observations: ${folded.observations.length} recorded / ${folded.activeObservations.length} active / ${visible.observations.length} visible`,
@@ -126,10 +120,9 @@ export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void
 				`Observer source backlog: ~${obsProgress.toLocaleString()} / ${runtime.config.observeAfterTokens.toLocaleString()} tokens (${pct(obsProgress, runtime.config.observeAfterTokens)}%)`,
 				`Summarizer trigger:      old pool ~${pools.oldTokens.toLocaleString()} / ${summarizerTrigger.toLocaleString()} tokens (${pct(pools.oldTokens, summarizerTrigger)}%)`,
 				`Automatic compaction source backlog: ~${compactionProgress.toLocaleString()} / ${compactThreshold.toLocaleString()} tokens (${pct(compactionProgress, compactThreshold)}%; injected memory excluded)`,
-				`Visible observation pool: ~${visibleObservationTokens.toLocaleString()} tokens`,
+				`Active memory total:     ~${pools.totalTokens.toLocaleString()} tokens (observations + summaries; split below)`,
 				`New memory pool:         ~${pools.newTokens.toLocaleString()} / ${runtime.config.newMemoryPoolMaxTokens.toLocaleString()} protection-budget tokens (${pct(pools.newTokens, runtime.config.newMemoryPoolMaxTokens)}%; newest memory always protected whole)`,
-				`Old memory pool:         ~${pools.oldTokens.toLocaleString()} / ${runtime.config.oldMemoryPoolTargetTokens.toLocaleString()} advisory target tokens (${pct(pools.oldTokens, runtime.config.oldMemoryPoolTargetTokens)}%)`,
-				`Summary pool:            ~${visibleSummaryTokens.toLocaleString()} visible tokens`,
+				`Old memory pool:         ~${pools.oldTokens.toLocaleString()} / ${runtime.config.oldMemoryPoolTargetTokens.toLocaleString()} advisory target tokens (${pct(pools.oldTokens, runtime.config.oldMemoryPoolTargetTokens)}%; observations + summaries)`,
 				`Summarizer:              ${runtime.config.summarizerEnabled === false ? "disabled" : "enabled"}; retrigger after +${runtime.config.summarizerRetriggerTokens.toLocaleString()} old-pool tokens / sample above ~${summarizerSamplingTokens.toLocaleString()} tokens`,
 				`Summarizer model:        ${configuredModelLabel(runtime.configuredMemoryWorkerModel("summarizer"))}`,
 				`Observer model:          ${configuredModelLabel(runtime.configuredMemoryWorkerModel("observer"))}`,