Function injectM0M1Pi

packages/pi-plugin/src/inject-compartments-pi.ts:2072–2296

(
	state: PiM0M1State,
	db: ContextDatabase,
	piMessages: PiAgentMessage[],
	entryIds?: readonly (string | undefined)[],
	recomputeM1ThisPass = false,
)

}

export function injectM0M1Pi(
	state: PiM0M1State,
	db: ContextDatabase,
	piMessages: PiAgentMessage[],
	entryIds?: readonly (string | undefined)[],
	recomputeM1ThisPass = false,
): PiM0M1InjectionResult {
	// One compartment snapshot for the WHOLE decision: the materialize decision
	// and every cached-marker reload below normalize against this same set, so a
	// concurrent count change can't flip markers to null mid-decision and escape
	// the guarded fallback (TOCTOU).
	const currentCompartments = getCompartments(db, state.sessionId);
	let decision = mustMaterializePi(state, db, currentCompartments);
	let m0 = "";
	let m1 = PI_M1_PLACEHOLDER;
	let markers: PiM0SnapshotMarkers | null = null;
	let materialized = false;
	let contentionExhausted = false;
	let memoryUpdateCount = 0;
	let m1Recomputed = false;
	let freshFallbackRenderedMemoryIds: number[] | null = null;

	if (decision.value) {
		// On contention exhaustion, reuse the cached m[0]/m[1] pair rather than
		// throwing (matches OpenCode injectM0M1). A sibling process mutated state
		// mid-materialization; serving the slightly-stale cached pair this pass is
		// correct and the next pass retries — dropping injection entirely would lose
		// the whole history block.
		try {
			const result = materializeM0PiWithRetry(state, db);
			m0 = result.m0;
			m1 = result.m1;
			markers = result.snapshotMarkers;
			materialized = true;
			m1Recomputed = true;
		} catch (error) {
			if (!(error instanceof PiMaterializeContentionError)) throw error;
			try {
				const cached = replayCachedM1Pi(db, state, currentCompartments);
				contentionExhausted = true;
				m0 = cached.m0;
				m1 = cached.m1;
				markers = cached.markers;
				logSession(
					state.sessionId,
					"pi m[0] materialization contention exhausted; reusing cached m[0]/m[1]",
				);
			} catch {
				// No cached baseline to fall back to — this happens when the cache was
				// deliberately cleared THIS pass (cache-bust) and then hit contention.
				// Dropping injection would lose the entire history block, so render a
				// fresh (non-persisted) m[0]/m[1] pair as a last resort. It is not cached
				// because we couldn't win the materialize lock; the next pass
				// re-materializes and persists.
				const fresh = renderFreshM0PiNonPersisted(state, db);
				m0 = fresh.m0;
				markers = fresh.snapshotMarkers;
				freshFallbackRenderedMemoryIds = fresh.renderedMemoryIds;