@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.0

package/src/hindsight/state.ts

@@ -187,6 +187,17 @@ export class HindsightRetainQueue {
 	}
 }
 
+/** Rolling hash of messages[0, count) for retention-cache validation (see #lastRetainedPrefixKey). */
+function retentionPrefixKey(messages: HindsightMessage[], count: number): string {
+	let key = "";
+	for (let i = 0; i < count; i++) {
+		const m = messages[i];
+		if (m === undefined) break;
+		key = Bun.hash(`${key}\u0000${m.role}\u0000${m.content}`).toString(36);
+	}
+	return key;
+}
+
 /** Per-session Hindsight runtime state owned by its AgentSession. */
 export class HindsightSessionState {
 	/** Session id used for retain-queue metadata. */
@@ -202,6 +213,17 @@ export class HindsightSessionState {
 	session: AgentSession;
 	banksSet: Set<string>;
 	lastRetainedTurn: number;
+	#lastRetainedMessageIndex: number = 0;
+	#cachedTranscript: string = "";
+	// Rolling hash of ALL messages in [0, #lastRetainedMessageIndex) at cache
+	// time. The incremental full-session cache assumes the branch is append-only;
+	// a rewind, branch switch, compaction, or in-place edit rewrites the prefix
+	// without changing the session id. Re-hashing the current prefix at use time
+	// makes the cache self-healing: on ANY prefix change (not just the boundary
+	// message) we rebuild the full transcript instead of retaining stale content
+	// or silently retaining nothing forever. Hashing is orders of magnitude
+	// cheaper than the re-formatting this cache avoids.
+	#lastRetainedPrefixKey: string = "";
 	hasRecalledForFirstTurn: boolean;
 	lastRecallSnippet?: string;
 	/** Cached `<mental_models>` block injected into developer instructions. */
@@ -236,6 +258,9 @@ export class HindsightSessionState {
 		this.session = options.session;
 		this.banksSet = options.banksSet;
 		this.lastRetainedTurn = options.lastRetainedTurn ?? 0;
+		this.#lastRetainedMessageIndex = 0;
+		this.#cachedTranscript = "";
+		this.#lastRetainedPrefixKey = "";
 		this.hasRecalledForFirstTurn = options.hasRecalledForFirstTurn ?? false;
 		this.aliasOf = options.aliasOf;
 		this.retainQueue = new HindsightRetainQueue(this);
@@ -243,12 +268,18 @@ export class HindsightSessionState {
 
 	setSessionId(sessionId: string): void {
 		this.sessionId = sessionId;
+		this.#lastRetainedMessageIndex = 0;
+		this.#cachedTranscript = "";
+		this.#lastRetainedPrefixKey = "";
 	}
 
 	resetConversationTracking(): void {
 		this.lastRetainedTurn = 0;
 		this.hasRecalledForFirstTurn = false;
 		this.lastRecallSnippet = undefined;
+		this.#lastRetainedMessageIndex = 0;
+		this.#cachedTranscript = "";
+		this.#lastRetainedPrefixKey = "";
 	}
 
 	enqueueRetain(content: string, context?: string): void {
@@ -285,21 +316,35 @@ export class HindsightSessionState {
 	async retainSession(messages: HindsightMessage[]): Promise<void> {
 		const retainedAt = new Date();
 		const retainFullWindow = this.config.retainMode === "full-session";
-		let target: HindsightMessage[];
 		let documentId: string;
+		let transcript: string;
+		let nextCachedTranscript: string | undefined;
 
 		if (retainFullWindow) {
-			target = messages;
 			documentId = this.sessionId;
+			const boundary = this.#lastRetainedMessageIndex;
+			if (boundary > messages.length || retentionPrefixKey(messages, boundary) !== this.#lastRetainedPrefixKey) {
+				this.#lastRetainedMessageIndex = 0;
+				this.#cachedTranscript = "";
+				this.#lastRetainedPrefixKey = "";
+			}
+			const newMessages = messages.slice(this.#lastRetainedMessageIndex);
+			const { transcript: newPart } = prepareRetentionTranscript(newMessages, true);
+			if (!newPart) return;
+			nextCachedTranscript = this.#cachedTranscript ? `${this.#cachedTranscript}\n\n${newPart}` : newPart;
+			transcript = nextCachedTranscript;
 		} else {
 			const windowTurns = this.config.retainEveryNTurns + this.config.retainOverlapTurns;
-			target = sliceLastTurnsByUserBoundary(messages, windowTurns);
+			const target = sliceLastTurnsByUserBoundary(messages, windowTurns);
 			documentId = `${this.sessionId}-${retainedAt.getTime()}`;
+			this.#lastRetainedMessageIndex = 0;
+			this.#cachedTranscript = "";
+			this.#lastRetainedPrefixKey = "";
+			const { transcript: windowTranscript } = prepareRetentionTranscript(target, true);
+			if (!windowTranscript) return;
+			transcript = windowTranscript;
 		}
 
-		const { transcript } = prepareRetentionTranscript(target, true);
-		if (!transcript) return;
-
 		await ensureBankExists(this.client, this.bankId, this.config, this.banksSet);
 		await this.client.retain(this.bankId, transcript, {
 			documentId,
@@ -309,6 +354,11 @@ export class HindsightSessionState {
 			timestamp: retainedAt,
 			async: true,
 		});
+		if (nextCachedTranscript !== undefined) {
+			this.#cachedTranscript = nextCachedTranscript;
+			this.#lastRetainedMessageIndex = messages.length;
+			this.#lastRetainedPrefixKey = retentionPrefixKey(messages, messages.length);
+		}
 	}
 
 	async maybeRetainOnAgentEnd(): Promise<void> {
@@ -341,6 +391,14 @@ export class HindsightSessionState {
 	async forceRetainCurrentSession(): Promise<void> {
 		const messages = extractMessages(this.session.sessionManager);
 		if (messages.length === 0) return;
+		// Forced retains are user-initiated rebuilds (`/memory enqueue`): drop the
+		// incremental cache so the full transcript is reformatted and resent even
+		// when no new messages arrived since the last auto-retain — otherwise a
+		// rebuild could never recover an upstream document that was deleted or a
+		// previous async retain that never materialized.
+		this.#lastRetainedMessageIndex = 0;
+		this.#cachedTranscript = "";
+		this.#lastRetainedPrefixKey = "";
 		try {
 			await this.retainSession(messages);
 			this.lastRetainedTurn = messages.filter(m => m.role === "user").length;

package/src/internal-urls/local-protocol.ts

@@ -3,6 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { AgentRegistry } from "../registry/agent-registry";
+import { isMarkdownPath } from "../utils/lang-from-path";
 import { buildDirectoryResource } from "./filesystem-resource";
 import { parseInternalUrl } from "./parse";
 import { validateRelativePath } from "./skill-protocol";
@@ -43,8 +44,8 @@ function shortLocalRoot(options: LocalProtocolOptions): string {
 }
 
 function getContentType(filePath: string): InternalResource["contentType"] {
+	if (isMarkdownPath(filePath)) return "text/markdown";
 	const ext = path.extname(filePath).toLowerCase();
-	if (ext === ".md") return "text/markdown";
 	if (ext === ".json") return "application/json";
 	return "text/plain";
 }

package/src/internal-urls/memory-protocol.ts

@@ -4,6 +4,7 @@ import { getAgentDir, isEnoent } from "@oh-my-pi/pi-utils";
 import { getMemoryRoot } from "../memories";
 import { getMnemopiSessionState, type MnemopiScopedMemoryHit, type MnemopiSessionState } from "../mnemopi/state";
 import { AgentRegistry } from "../registry/agent-registry";
+import { isMarkdownPath } from "../utils/lang-from-path";
 import { buildDirectoryResource } from "./filesystem-resource";
 import { validateRelativePath } from "./skill-protocol";
 import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
@@ -117,8 +118,7 @@ async function tryResolveInRoot(url: InternalUrl, memoryRoot: string): Promise<I
 	}
 
 	const content = await Bun.file(realTargetPath).text();
-	const ext = path.extname(realTargetPath).toLowerCase();
-	const contentType: InternalResource["contentType"] = ext === ".md" ? "text/markdown" : "text/plain";
+	const contentType: InternalResource["contentType"] = isMarkdownPath(realTargetPath) ? "text/markdown" : "text/plain";
 
 	return {
 		url: url.href,

package/src/internal-urls/skill-protocol.ts

@@ -12,12 +12,12 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { getActiveSkills } from "../extensibility/skills";
+import { isMarkdownPath } from "../utils/lang-from-path";
 import { buildDirectoryResource } from "./filesystem-resource";
 import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
 
 function getContentType(filePath: string): InternalResource["contentType"] {
-	const ext = path.extname(filePath).toLowerCase();
-	if (ext === ".md") return "text/markdown";
+	if (isMarkdownPath(filePath)) return "text/markdown";
 	return "text/plain";
 }
 

package/src/internal-urls/ssh-protocol.ts

@@ -30,6 +30,7 @@ import {
 	statRemotePath,
 	writeRemoteFile,
 } from "../ssh/file-transfer";
+import { isMarkdownPath } from "../utils/lang-from-path";
 import type {
 	InternalResource,
 	InternalUrl,
@@ -44,11 +45,11 @@ const SSH_TEXT_MAX_BYTES = 1024 * 1024;
 
 /** POSIX-aware content type from the last path segment's extension. */
 function contentTypeFor(remotePath: string): InternalResource["contentType"] {
+	if (isMarkdownPath(remotePath)) return "text/markdown";
 	const slash = remotePath.lastIndexOf("/");
 	const base = slash === -1 ? remotePath : remotePath.slice(slash + 1);
 	const dot = base.lastIndexOf(".");
 	const ext = dot <= 0 ? "" : base.slice(dot).toLowerCase();
-	if (ext === ".md") return "text/markdown";
 	if (ext === ".json") return "application/json";
 	return "text/plain";
 }

package/src/internal-urls/vault-protocol.ts

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { $which, isEnoent } from "@oh-my-pi/pi-utils";
 import { isSettingsInitialized, settings } from "../config/settings";
 import { getDefault } from "../config/settings-schema";
+import { isMarkdownPath } from "../utils/lang-from-path";
 import { parseInternalUrl } from "./parse";
 import { validateRelativePath } from "./skill-protocol";
 import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, WriteContext } from "./types";
@@ -114,8 +115,8 @@ function toVaultValidationError(error: unknown): Error {
 }
 
 function getContentType(filePath: string): ContentType {
+	if (isMarkdownPath(filePath)) return "text/markdown";
 	const ext = path.extname(filePath).toLowerCase();
-	if (ext === ".md") return "text/markdown";
 	if (ext === ".json") return "application/json";
 	return "text/plain";
 }

package/src/live/audio-worklet.txt

@@ -0,0 +1,59 @@
+class OmpPcmSourceProcessor extends AudioWorkletProcessor {
+	constructor() {
+		super();
+		this.frames = [];
+		this.frameOffset = 0;
+		this.queuedSamples = 0;
+		this.muted = false;
+		this.maxQueuedSamples = Math.floor(sampleRate * 0.75);
+		this.port.onmessage = event => {
+			const message = event.data;
+			if (message.type === "mute") {
+				this.muted = message.muted;
+				this.clear();
+				return;
+			}
+			if (message.type !== "audio" || this.muted || !(message.samples instanceof Float32Array)) return;
+			let samples = message.samples;
+			if (samples.length > this.maxQueuedSamples) samples = samples.slice(samples.length - this.maxQueuedSamples);
+			this.frames.push(samples);
+			this.queuedSamples += samples.length;
+			while (this.queuedSamples > this.maxQueuedSamples && this.frames.length > 1) {
+				const stale = this.frames.shift();
+				this.queuedSamples -= stale.length - this.frameOffset;
+				this.frameOffset = 0;
+			}
+		};
+	}
+
+	clear() {
+		this.frames.length = 0;
+		this.frameOffset = 0;
+		this.queuedSamples = 0;
+	}
+
+	process(_inputs, outputs) {
+		const output = outputs[0];
+		const channel = output && output[0];
+		if (!channel) return true;
+		channel.fill(0);
+		if (this.muted) return true;
+		let outputOffset = 0;
+		while (outputOffset < channel.length && this.frames.length > 0) {
+			const frame = this.frames[0];
+			const available = frame.length - this.frameOffset;
+			const count = Math.min(available, channel.length - outputOffset);
+			channel.set(frame.subarray(this.frameOffset, this.frameOffset + count), outputOffset);
+			outputOffset += count;
+			this.frameOffset += count;
+			this.queuedSamples -= count;
+			if (this.frameOffset === frame.length) {
+				this.frames.shift();
+				this.frameOffset = 0;
+			}
+		}
+		return true;
+	}
+}
+
+registerProcessor("omp-pcm-source", OmpPcmSourceProcessor);

package/src/live/browser-runtime.txt

@@ -0,0 +1,221 @@
+(() => {
+	const INPUT_SAMPLE_RATE = 16_000;
+	const LEVEL_INTERVAL_MS = 50;
+	const OPEN_TIMEOUT_MS = 20_000;
+	let context;
+	let peer;
+	let channel;
+	let sourceNode;
+	let sourceTrack;
+	let remoteSource;
+	let analyser;
+	let levelWaveform;
+	let levelTimer;
+	let disconnectTimer;
+	let workletUrl;
+	let closing = false;
+	let muted = false;
+	let openSettled = false;
+	let openResolve;
+	let openReject;
+	let previousInputSample;
+	let inputPhase = 0;
+	const openPromise = new Promise((resolve, reject) => {
+		openResolve = resolve;
+		openReject = reject;
+	});
+
+	function reportFailure(message) {
+		if (closing) return;
+		if (!openSettled) {
+			openSettled = true;
+			openReject(new Error(message));
+		}
+		Promise.resolve(window.__ompLiveFailure(message)).catch(() => {});
+	}
+
+	function waitForIceGathering() {
+		if (peer.iceGatheringState === "complete") return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				peer.removeEventListener("icegatheringstatechange", onChange);
+				reject(new Error("Timed out gathering WebRTC ICE candidates"));
+			}, 10_000);
+			function onChange() {
+				if (peer.iceGatheringState !== "complete") return;
+				clearTimeout(timeout);
+				peer.removeEventListener("icegatheringstatechange", onChange);
+				resolve();
+			}
+			peer.addEventListener("icegatheringstatechange", onChange);
+		});
+	}
+
+	function decodePcm(base64) {
+		const encoded = atob(base64);
+		const bytes = new Uint8Array(encoded.length);
+		for (let index = 0; index < encoded.length; index++) bytes[index] = encoded.charCodeAt(index);
+		const view = new DataView(bytes.buffer);
+		const samples = new Float32Array(bytes.length / 4);
+		for (let index = 0; index < samples.length; index++) samples[index] = view.getFloat32(index * 4, true);
+		return samples;
+	}
+
+	function resample(samples) {
+		if (samples.length === 0) return new Float32Array();
+		const step = INPUT_SAMPLE_RATE / context.sampleRate;
+		const prefix = previousInputSample === undefined ? 0 : 1;
+		const input = new Float32Array(samples.length + prefix);
+		if (prefix === 1) input[0] = previousInputSample;
+		input.set(samples, prefix);
+		if (prefix === 0) inputPhase = 0;
+		const available = input.length - 1;
+		if (available <= 0) {
+			previousInputSample = input[0];
+			return new Float32Array();
+		}
+		const outputLength = Math.max(0, Math.ceil((available - inputPhase) / step));
+		const output = new Float32Array(outputLength);
+		let written = 0;
+		while (inputPhase < available) {
+			const index = Math.floor(inputPhase);
+			const fraction = inputPhase - index;
+			output[written++] = input[index] + (input[index + 1] - input[index]) * fraction;
+			inputPhase += step;
+		}
+		inputPhase -= available;
+		previousInputSample = input[input.length - 1];
+		return written === output.length ? output : output.slice(0, written);
+	}
+
+	function reportLevel() {
+		if (!analyser || !levelWaveform) return;
+		analyser.getFloatTimeDomainData(levelWaveform);
+		let sum = 0;
+		for (const sample of levelWaveform) sum += sample * sample;
+		const level = Math.min(1, Math.max(0, Math.sqrt(sum / levelWaveform.length)));
+		Promise.resolve(window.__ompLiveOutputLevel(level)).catch(() => {});
+	}
+
+	function attachRemoteTrack(event) {
+		if (closing || event.track.kind !== "audio") return;
+		if (remoteSource) remoteSource.disconnect();
+		const stream = new MediaStream([event.track]);
+		remoteSource = context.createMediaStreamSource(stream);
+		analyser = context.createAnalyser();
+		analyser.fftSize = 1024;
+		levelWaveform = new Float32Array(analyser.fftSize);
+		remoteSource.connect(analyser);
+		analyser.connect(context.destination);
+		clearInterval(levelTimer);
+		levelTimer = setInterval(reportLevel, LEVEL_INTERVAL_MS);
+	}
+
+	async function start(workletSource) {
+		if (peer) throw new Error("Live browser runtime already started");
+		context = new AudioContext({ latencyHint: "interactive" });
+		await context.resume();
+		workletUrl = URL.createObjectURL(new Blob([workletSource], { type: "text/javascript" }));
+		await context.audioWorklet.addModule(workletUrl);
+		sourceNode = new AudioWorkletNode(context, "omp-pcm-source", {
+			numberOfInputs: 0,
+			numberOfOutputs: 1,
+			outputChannelCount: [1],
+		});
+		const destination = context.createMediaStreamDestination();
+		sourceNode.connect(destination);
+		sourceTrack = destination.stream.getAudioTracks()[0];
+		sourceTrack.enabled = !muted;
+
+		peer = new RTCPeerConnection();
+		peer.addTrack(sourceTrack, destination.stream);
+		peer.ontrack = attachRemoteTrack;
+		peer.onconnectionstatechange = () => {
+			clearTimeout(disconnectTimer);
+			if (peer.connectionState === "failed" || peer.connectionState === "closed") {
+				reportFailure(`WebRTC peer connection ${peer.connectionState}`);
+			} else if (peer.connectionState === "disconnected") {
+				disconnectTimer = setTimeout(() => {
+					if (peer && peer.connectionState === "disconnected") reportFailure("WebRTC peer connection disconnected");
+				}, 2_000);
+			}
+		};
+		channel = peer.createDataChannel("oai-events");
+		channel.onopen = () => {
+			if (openSettled) return;
+			openSettled = true;
+			openResolve();
+		};
+		channel.onerror = () => reportFailure("Live data channel failed");
+		channel.onclose = () => reportFailure("Live data channel closed unexpectedly");
+		channel.onmessage = event => {
+			if (typeof event.data !== "string") return;
+			Promise.resolve(window.__ompLiveServerEvent(event.data)).catch(() => {});
+		};
+
+		const offer = await peer.createOffer();
+		await peer.setLocalDescription(offer);
+		await waitForIceGathering();
+		if (!peer.localDescription || !peer.localDescription.sdp) throw new Error("Browser produced an empty WebRTC offer");
+		return peer.localDescription.sdp;
+	}
+
+	async function acceptAnswer(sdp) {
+		if (!peer) throw new Error("Live browser runtime has not started");
+		await peer.setRemoteDescription({ type: "answer", sdp });
+	}
+
+	async function waitForOpen() {
+		let timeout;
+		try {
+			await Promise.race([
+				openPromise,
+				new Promise((_, reject) => {
+					timeout = setTimeout(() => reject(new Error("Timed out waiting for the live data channel to open")), OPEN_TIMEOUT_MS);
+				}),
+			]);
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
+
+	function send(payload) {
+		if (!channel || channel.readyState !== "open") throw new Error("Live data channel is not open");
+		channel.send(payload);
+	}
+
+	function pushAudio(base64) {
+		if (!sourceNode || muted) return;
+		const output = resample(decodePcm(base64));
+		if (output.length === 0) return;
+		sourceNode.port.postMessage({ type: "audio", samples: output }, [output.buffer]);
+	}
+
+	function setMuted(nextMuted) {
+		muted = nextMuted;
+		previousInputSample = undefined;
+		inputPhase = 0;
+		if (sourceTrack) sourceTrack.enabled = !muted;
+		if (sourceNode) sourceNode.port.postMessage({ type: "mute", muted });
+	}
+
+	async function close() {
+		if (closing) return;
+		closing = true;
+		clearInterval(levelTimer);
+		clearTimeout(disconnectTimer);
+		if (channel) channel.close();
+		if (peer) peer.close();
+		if (remoteSource) remoteSource.disconnect();
+		if (analyser) analyser.disconnect();
+		if (sourceNode) {
+			sourceNode.port.postMessage({ type: "mute", muted: true });
+			sourceNode.disconnect();
+		}
+		if (sourceTrack) sourceTrack.stop();
+		if (workletUrl) URL.revokeObjectURL(workletUrl);
+		if (context && context.state !== "closed") await context.close();
+	}
+
+	window.ompCodexLive = { start, acceptAnswer, waitForOpen, send, pushAudio, setMuted, close };
+})();