pi-roundtable 0.7.19 → 0.9.0

package/src/core/runtime/pi-agent-runtime.ts

@@ -1,5 +1,4 @@
 import { rmSync } from "node:fs";
-import { join } from "node:path";
 import {
 	type AgentSession,
 	type ModelRuntime,
@@ -15,38 +14,47 @@ import type {
 	TranscriptEntry,
 	TurnResult,
 } from "../domain/conversation.ts";
-import { AgentRunError, ConfigError } from "../domain/errors.ts";
+import { AgentRunError } from "../domain/errors.ts";
 import type { TurnRequest } from "../domain/ports.ts";
 import { assistantName } from "../i18n/index.ts";
-import {
-	AUTO_THINKING,
-	parseModelRef,
-	type ThinkingLevel,
-	type ThinkingSetting,
-} from "../models.ts";
+import { promptScopeOf } from "../interactions/prompts.ts";
+import { AUTO_THINKING, type ThinkingLevel } from "../models.ts";
+import { MEMORY_TOOLS } from "../modules/memory/owner-memory.ts";
 import { withoutReplyFiles } from "../reply-files.ts";
-import { planOrder, type TransientTask } from "../sessions.ts";
-import { textOf } from "../shared/session-messages.ts";
-import { addressee, type Speaker, type Tier } from "../speakers.ts";
+import type { TransientTask } from "../sessions.ts";
+import type { Speaker, Tier } from "../speakers.ts";
 import { type ToolTiers, toolsForTier, toolTiers } from "../tool-tiers.ts";
-import { ConversationSessions } from "./conversation-sessions.ts";
-import { ASK_USER_TOOL } from "./extensions/ask-user.ts";
 import {
-	ConfirmationGate,
-	confirmedTurnText,
-} from "./extensions/confirmation-gate.ts";
-import { COMPACT_TOOL } from "./extensions/self-compact-guard.ts";
+	type AgentModelSettings,
+	bridgeTurnRefusal,
+	chosenAgentModel,
+	useChosenAgentModel,
+} from "./bridge-guard.ts";
+import { ConversationSessions } from "./conversation-sessions.ts";
+import { confirmedTurnText } from "./extensions/confirmation-gate.ts";
+import { loadsMemory } from "./extensions/private-memory.ts";
+import { missingToolsError } from "./extensions/self-compact-guard.ts";
 import { interimPoster } from "./interim-text.ts";
+import { preflightTools } from "./preflight-tools.ts";
 import { PromptSlot, workTimeout } from "./prompt-slot.ts";
-import {
-	type PiAgentRuntimeOptions,
-	TRANSCRIPT_ENTRY_CHARS,
-	type TurnMessage,
-} from "./runtime-types.ts";
+import { carriesMemory, recordMemoryTurn } from "./reader-history.ts";
+import type { PiAgentRuntimeOptions, TurnMessage } from "./runtime-types.ts";
 import { archiveSessions } from "./session-archive.ts";
+import {
+	memoryReader,
+	refusedSpeaker,
+	turnAddressee,
+} from "./session-conversation.ts";
 import { SessionFactory } from "./session-factory.ts";
-import { type PromptImages, SteerableRun } from "./steerable-run.ts";
-import { lastReply, turnAnswer } from "./turn-answer.ts";
+import { promptImages, SteerableRun } from "./steerable-run.ts";
+import { runningCalls } from "./tool-call-scope.ts";
+import {
+	lastReply,
+	transcriptOf,
+	turnAnswer,
+	unspokenTurn,
+} from "./turn-answer.ts";
+import { progressReporter } from "./turn-progress.ts";
 import { workerReport } from "./worker-task.ts";
 
 export {
@@ -56,6 +64,8 @@ export {
 	sessionExtensions,
 } from "./runtime-types.ts";
 
+const MEMORY = new Set<string>(MEMORY_TOOLS);
+
 /** AgentRuntime over the Pi SDK: one persistent session per channel, each with its own loader. */
 const STOPPED = "stopped by the owner";
 
@@ -69,10 +79,11 @@ export class PiAgentRuntime implements AgentRuntime {
 	/** The tier and speaker of each conversation's running turn. */
 	readonly #turns = new Map<
 		ChannelKey,
-		{ tier: Tier; speaker: Speaker | undefined }
+		{ tier: Tier; speaker: Speaker; withheld: boolean }
 	>();
 	/** Each conversation's turn in progress, which the owner may steer or stop. */
 	readonly #running = new Map<ChannelKey, SteerableRun>();
+	readonly #memoryTurns = new Map<ChannelKey, () => void>();
 
 	/** Builds the runtime without starting a session; the preflight proves it can run. */
 	constructor(options: PiAgentRuntimeOptions) {
@@ -81,7 +92,8 @@ export class PiAgentRuntime implements AgentRuntime {
 		this.#tiers = options.toolTiers ?? toolTiers();
 		this.#factory = new SessionFactory(options, {
 			speaker: (channel) => this.#turns.get(channel)?.speaker,
-			runTask: (channel, task) => this.#runTask(channel, task),
+			withholdsMemory: (channel) => this.#turns.get(channel)?.withheld === true,
+			runTask: (scope, task) => this.#runTask(scope, task),
 		});
 		this.#sessions = new ConversationSessions(
 			options,
@@ -90,54 +102,64 @@ export class PiAgentRuntime implements AgentRuntime {
 		);
 	}
 
-	/**
-	 * Proves the model and every required tool resolve, in a throwaway session that runs no turn;
-	 * startup stops here before anything connects.
-	 */
+	/** Resolves the model and required tools in throwaway shared and private sessions, without a turn. */
 	async preflight(): Promise<void> {
-		const probe = await this.#factory.create(
-			"probe:startup",
-			SessionManager.inMemory(this.#factory.workDir()),
-			new ConfirmationGate(this.#factory.link().holds, this.#options.owner),
-			new PromptSlot(),
-			join(this.#factory.workDir(), "probe-attachments"),
-			undefined,
-			"owner",
-		);
-		const registered = new Set(
-			probe.session.getAllTools().map((tool) => tool.name),
+		const required = this.#factory.requiredTools();
+		const registered = await preflightTools(
+			this.#factory,
+			this.#options.owner,
+			required,
 		);
-		probe.session.dispose();
-		const expected = [
-			...this.#factory.link().requiredTools,
-			COMPACT_TOOL,
-			ASK_USER_TOOL,
-			...planOrder(this.#factory.plan).flatMap(
-				(tool) => tool.snapshot().requiredTools ?? [],
-			),
-		];
-		const missing = expected.filter((name) => !registered.has(name));
-		if (missing.length > 0) {
-			throw new ConfigError(
-				`required tools are not registered: ${missing.join(", ")}`,
-			);
-		}
+		const missing = required.filter((name) => !registered.has(name));
+		if (missing.length > 0) throw missingToolsError(missing);
 	}
 
 	// pi-lens-ignore: high-complexity, high-fan-out, mixed-async-styles — one turn's lifecycle end to end; batch 4 splits it with the channel router
 	async runTurn(request: TurnRequest): Promise<TurnResult> {
 		const { logger, turnTimeoutMs = 10 * 60_000 } = this.#options;
+		if (!request.speaker) return unspokenTurn();
 		const key = request.agent?.session ?? request.channel;
-		const channelSession = await this.#sessions.freshSession(key, request);
+		// Resolve current scope; refuse a foreign private speaker before touching its session.
+		const conversation = await this.#sessions.conversation(key, request);
+		const refused = refusedSpeaker(conversation, request.speaker);
+		if (refused) return { ok: false, error: new AgentRunError(refused) };
+		const scoped = { ...request, conversation };
+		const channelSession = await this.#sessions.freshSession(key, scoped);
+		const who = turnAddressee(
+			request.speaker,
+			channelSession,
+			this.#options.owner,
+		);
 		const { session } = channelSession;
-		const level = await this.#thinkingLevel(key, session, request);
+		const agentModel = chosenAgentModel(request.agent?.name, this.#options);
+		const bridgeRefused =
+			conversation.visibility === "shared"
+				? await bridgeTurnRefusal(
+						request.agent?.name,
+						this.#options,
+						{
+							messages: session.messages,
+							sessionManager: session.sessionManager,
+							reader: request.speaker.principalId,
+						},
+						agentModel,
+					)
+				: undefined;
+		if (bridgeRefused)
+			return { ok: false, error: new AgentRunError(bridgeRefused) };
+		const level = await this.#thinkingLevel(key, session, request, agentModel);
 		if (session.thinkingLevel !== level) session.setThinkingLevel(level);
 		const gate = await this.#sessions.gate(key, request.agent !== undefined);
 		const pending = gate.pending();
 		const registered = new Set(session.getAllTools().map((tool) => tool.name));
-		// The speaker's tier limits the tools; a turn nobody spoke in, such as the owner's own chat, is the owner's.
-		const tier = request.speaker?.tier ?? "owner";
+		// The speaker's tier limits the tools.
+		const { tier } = request.speaker;
 		// An approving turn also has the held calls' tools, which a dispatched worker may have used.
+		// The agent server may keep a speaker below the owner tier out of memory: no tools, no block.
+		const withheld =
+			request.agent !== undefined &&
+			this.#options.agents?.memory === "owners" &&
+			tier !== "owner";
 		const wanted = toolsForTier(
 			[
 				...new Set([
@@ -149,8 +171,17 @@ export class PiAgentRuntime implements AgentRuntime {
 			],
 			tier,
 			this.#tiers,
+		).filter((name) => !withheld || !MEMORY.has(name));
+		const markPrivateMemory = recordMemoryTurn(
+			session.sessionManager,
+			request.speaker.principalId,
+			!withheld &&
+				channelSession.memory !== "none" &&
+				memoryReader(conversation, request.speaker) !== undefined &&
+				loadsMemory(registered),
 		);
-		this.#turns.set(key, { tier, speaker: request.speaker });
+		this.#memoryTurns.set(key, markPrivateMemory);
+		this.#turns.set(key, { tier, speaker: request.speaker, withheld });
 		const missing = wanted.filter((name) => !registered.has(name));
 		if (missing.length > 0) {
 			logger.warn(
@@ -167,7 +198,8 @@ export class PiAgentRuntime implements AgentRuntime {
 		gate.beginTurn(
 			request.selection.id,
 			request.confirmed === true,
-			addressee(request.speaker, this.#options.owner),
+			who,
+			request.speaker,
 		);
 		if (request.confirmed && pending) {
 			logger.info(
@@ -184,12 +216,18 @@ export class PiAgentRuntime implements AgentRuntime {
 		const toolCalls: string[] = [];
 		// Text written before the final answer is posted as the turn goes; the final reply stays the caller's.
 		const interim = interimPoster(request, this.#options);
+		// The caller's live view: the text as it streams and each tool, never the thinking.
+		const progress = request.progress
+			? progressReporter(request.progress)
+			: undefined;
 		const unsubscribe = session.subscribe((event) => {
+			progress?.observe(event);
 			if (event.type === "tool_execution_start") {
 				toolCalls.push(event.toolName);
 				interim?.toolStart(event.toolName);
 			}
 			if (event.type === "message_end") {
+				if (carriesMemory(event.message)) markPrivateMemory();
 				turnMessages.push(event.message);
 				interim?.messageEnd(event.message);
 			}
@@ -197,7 +235,7 @@ export class PiAgentRuntime implements AgentRuntime {
 		const slot = this.#sessions.slot(key);
 		slot.bind(
 			request.interactive
-				? this.#options.prompts?.(request.channel, request.speaker)
+				? this.#options.prompts?.(request.channel, promptScopeOf(scoped))
 				: undefined,
 			request.agent?.name ?? assistantName(),
 			interim ? () => interim.flush() : undefined,
@@ -220,11 +258,7 @@ export class PiAgentRuntime implements AgentRuntime {
 			const attachments = request.attachments ?? NO_ATTACHMENTS;
 			const text =
 				request.confirmed && pending
-					? confirmedTurnText(
-							pending,
-							request.text,
-							addressee(request.speaker, this.#options.owner),
-						)
+					? confirmedTurnText(pending, request.text, who)
 					: request.text;
 			await running.run(() =>
 				session.prompt(
@@ -244,9 +278,11 @@ export class PiAgentRuntime implements AgentRuntime {
 		} finally {
 			this.#running.delete(key);
 			this.#turns.delete(key);
+			this.#memoryTurns.delete(key);
 			cancelTimeout();
 			slot.unbind();
 			unsubscribe();
+			progress?.close();
 			await interim?.flush();
 			gate.endTurn();
 			const usage = session.getContextUsage();
@@ -324,23 +360,33 @@ export class PiAgentRuntime implements AgentRuntime {
 		return stopped;
 	}
 
-	/**
-	 * Runs a task in a fresh, unsaved session with the selected tools and the channel's
-	 * confirmation gate, and returns its final text.
-	 */
+	/** Runs a task in an unsaved session with the selected tools and conversation's gate. */
 	// pi-lens-ignore: high-fan-out — builds, runs, and disposes one transient session; batch 4 turns it into the core's child-run API
-	async #runTask(channel: ChannelKey, task: TransientTask): Promise<string> {
+	async #runTask(
+		scope: { turn: ChannelKey; home: ChannelKey },
+		task: TransientTask,
+	): Promise<string> {
 		const { dataDir } = this.#options;
 		const { signal } = task;
-		// A worker asks nothing: its held actions wait for the owner's next message.
+		// A task works at the tier of the turn that started it; without one there is no tier to take.
+		const turn = this.#turns.get(scope.turn);
+		if (!turn)
+			throw new AgentRunError(
+				`a task runs beside a turn of its conversation, at that turn's tier, and ${scope.turn} has no turn running`,
+			);
+		// A worker inherits the starting turn's conversation and memory policy, without asking.
+		const parent = await this.#sessions.session(scope.turn);
+		const { conversation, memory } = parent;
 		const worker = await this.#factory.create(
-			channel,
+			scope.home,
 			SessionManager.inMemory(this.#factory.workDir()),
-			await this.#sessions.gate(channel, false),
+			await this.#sessions.gate(scope.home, false),
 			new PromptSlot(),
-			ownerAttachmentDir(dataDir, channel),
+			ownerAttachmentDir(dataDir, scope.home),
 			undefined,
 			"owner",
+			conversation,
+			{ turn: scope.turn, memory },
 		);
 		const { session } = worker;
 		const toolCalls: string[] = [];
@@ -352,16 +398,17 @@ export class PiAgentRuntime implements AgentRuntime {
 		const timer = setTimeout(abort, task.timeoutMs);
 		try {
 			const registered = new Set(session.getAllTools().map((t) => t.name));
-			const excluded = new Set([...task.exclude, ASK_USER_TOOL]);
-			// A task works at the tier of the turn that started it.
-			const tier = this.#turns.get(channel)?.tier ?? "owner";
+			// A worker that loaded the reader's memory may report it: the call that started it, and the
+			// calls that one runs within, then record their results as the reader's.
+			if (memoryReader(conversation, turn.speaker) && loadsMemory(registered)) {
+				parent.draws.drawn(runningCalls());
+				this.#memoryTurns.get(scope.turn)?.();
+			}
+			const { tier } = turn;
 			worker.tools = this.#factory
-				.toolsFor(task.selection)
+				.taskTools(task.selection, task.exclude)
 				.filter(
-					(name) =>
-						!excluded.has(name) &&
-						registered.has(name) &&
-						this.#tiers.allows(tier, name),
+					(name) => registered.has(name) && this.#tiers.allows(tier, name),
 				);
 			session.setActiveToolsByName([...worker.tools]);
 			await withoutReplyFiles(() => session.prompt(task.text));
@@ -409,39 +456,31 @@ export class PiAgentRuntime implements AgentRuntime {
 	async heldActions(
 		session: ChannelKey,
 	): Promise<PendingConfirmation | undefined> {
-		const gate = await this.#sessions.gate(session, true);
-		return gate.pending();
+		return this.#sessions.held(session);
 	}
 
 	async recentTranscript(
 		channel: ChannelKey,
 		limit: number,
 	): Promise<TranscriptEntry[]> {
-		const { session } = await this.#sessions.session(channel);
-		const entries: TranscriptEntry[] = [];
-		for (const message of session.messages) {
-			if (message.role !== "user" && message.role !== "assistant") continue;
-			const text = textOf(message.content).trim();
-			if (text)
-				entries.push({
-					role: message.role,
-					text: text.slice(0, TRANSCRIPT_ENTRY_CHARS),
-				});
-		}
-		return entries.slice(-limit);
+		await this.#sessions.held(channel);
+		return transcriptOf(await this.#sessions.messages(channel), limit);
 	}
 
-	/**
-	 * The turn's thinking level: an agent's fixed setting, or the judge's pick, which is kept for the
-	 * next turn while the judge is unsure. An agent session also switches to the agent's model here.
-	 */
+	/** Uses the checked model snapshot; auto thinking keeps the last pick while the judge is unsure. */
 	async #thinkingLevel(
 		key: ChannelKey,
 		session: AgentSession,
 		request: TurnRequest,
+		agentModel?: AgentModelSettings,
 	): Promise<ThinkingLevel> {
 		const setting = request.agent
-			? await this.#useAgentModel(session, request.agent.name)
+			? await useChosenAgentModel(
+					session,
+					this.#modelRuntime,
+					request.agent.name,
+					agentModel,
+				)
 			: AUTO_THINKING;
 		if (setting !== AUTO_THINKING) {
 			this.#sessions.judged.delete(key);
@@ -455,38 +494,7 @@ export class PiAgentRuntime implements AgentRuntime {
 		return level;
 	}
 
-	/** Switches an agent session to the agent's current model; returns its thinking setting. */
-	async #useAgentModel(
-		session: AgentSession,
-		name: string,
-	): Promise<ThinkingSetting> {
-		const agents = this.#options.agents;
-		if (!agents)
-			throw new ConfigError("agent turns need the runtime's agents option");
-		const { model, thinking } = agents.modelOf(name);
-		const ref = parseModelRef(model);
-		if (
-			session.model?.provider !== ref?.provider ||
-			session.model?.id !== ref?.id
-		) {
-			const resolved = ref && this.#modelRuntime.getModel(ref.provider, ref.id);
-			if (!resolved)
-				throw new AgentRunError(
-					`${name}'s model ${model} is not available on this host`,
-				);
-			await session.setModel(resolved);
-		}
-		return thinking;
-	}
-
 	dispose(): void {
 		this.#sessions.dispose();
 	}
 }
-
-function promptImages(attachments: TurnAttachments): PromptImages {
-	return attachments.images.map((image) => ({
-		type: "image" as const,
-		...image,
-	}));
-}

package/src/core/runtime/preflight-tools.ts

@@ -0,0 +1,47 @@
+import { join } from "node:path";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { ConfirmationGate } from "./extensions/confirmation-gate.ts";
+import { PromptSlot } from "./prompt-slot.ts";
+import type { PiAgentRuntimeOptions } from "./runtime-types.ts";
+import type { SessionFactory } from "./session-factory.ts";
+
+/**
+ * Tools available in either startup scope, without running a turn or retaining a session.
+ * The private probe is built only when the shared one lacks a required tool, so a host
+ * without scoped tools starts exactly as before.
+ */
+export async function preflightTools(
+	factory: SessionFactory,
+	owner: PiAgentRuntimeOptions["owner"],
+	required: readonly string[],
+): Promise<Set<string>> {
+	const registered = new Set<string>();
+	for (const conversation of [
+		{ visibility: "shared" },
+		{ visibility: "private", principalId: owner.id },
+	] as const) {
+		if (
+			conversation.visibility === "private" &&
+			required.every((name) => registered.has(name))
+		)
+			break;
+		const probe = await factory.create(
+			conversation.visibility === "shared"
+				? "probe:startup"
+				: "probe:startup-private",
+			SessionManager.inMemory(factory.workDir()),
+			new ConfirmationGate(factory.link().holds, owner),
+			new PromptSlot(),
+			join(factory.workDir(), "probe-attachments"),
+			undefined,
+			"owner",
+			conversation,
+		);
+		try {
+			for (const tool of probe.session.getAllTools()) registered.add(tool.name);
+		} finally {
+			probe.session.dispose();
+		}
+	}
+	return registered;
+}

package/src/core/runtime/prompt-slot.ts

@@ -1,5 +1,5 @@
-import type { OwnerPrompts, OwnerQuestion } from "../domain/owner-prompts.ts";
 import { assistantName } from "../i18n/index.ts";
+import type { OwnerQuestion, Prompts } from "../interactions/prompts.ts";
 
 /**
  * A run's way to ask the owner while it works. A turn they started or a report turn binds the
@@ -9,7 +9,7 @@ import { assistantName } from "../i18n/index.ts";
  * leaves out.
  */
 export class PromptSlot {
-	#prompts: OwnerPrompts | undefined;
+	#prompts: Prompts | undefined;
 	#beforeCard: (() => Promise<void>) | undefined;
 	#asker = assistantName();
 	#open = 0;
@@ -21,7 +21,7 @@ export class PromptSlot {
 	 * runs before each card opens, such as posting the text the turn wrote before it.
 	 */
 	bind(
-		prompts: OwnerPrompts | undefined,
+		prompts: Prompts | undefined,
 		asker: string,
 		beforeCard?: () => Promise<void>,
 	): void {
@@ -42,12 +42,12 @@ export class PromptSlot {
 	}
 
 	/** The turn's prompts, each open card counted as waiting; undefined when none is bound. */
-	get prompts(): OwnerPrompts | undefined {
+	get prompts(): Prompts | undefined {
 		const prompts = this.#prompts;
 		if (!prompts) return undefined;
 		return {
-			confirm: (title, message, signal) =>
-				this.#waiting(() => prompts.confirm(title, message, signal)),
+			confirm: (title, message, signal, minTier) =>
+				this.#waiting(() => prompts.confirm(title, message, signal, minTier)),
 			ask: (title, question: OwnerQuestion, signal) =>
 				this.#waiting(() => prompts.ask(title, question, signal)),
 		};

package/src/core/runtime/reader-history.ts

@@ -0,0 +1,129 @@
+import type {
+	ContextWithSystemEvent,
+	SessionManager,
+} from "@earendil-works/pi-coding-agent";
+import { SYSTEM_PRINCIPAL } from "../identity/principal-store.ts";
+import { MEMORY_TOOLS } from "../modules/memory/owner-memory.ts";
+import { guardHidesPrivateExchange } from "./extensions/private-memory.ts";
+import { SCOPE_ENTRY } from "./session-scope.ts";
+
+/** A turn's reader and whether its request carried private memory, retained across compaction. */
+export const MEMORY_TURN_ENTRY = "roundtable-memory-turn";
+interface ReaderRecord {
+	reader: string;
+	privateMemory: boolean;
+}
+type Messages = ContextWithSystemEvent["messages"];
+const MEMORY = new Set<string>(MEMORY_TOOLS);
+
+/** Persist before prompting; the returned marker records later memory exchanges or memory-loaded workers. */
+export function recordMemoryTurn(
+	manager: Pick<SessionManager, "appendCustomEntry">,
+	reader: string,
+	privateMemory: boolean,
+): () => void {
+	const turnId = crypto.randomUUID();
+	manager.appendCustomEntry(MEMORY_TURN_ENTRY, {
+		turnId,
+		reader,
+		privateMemory,
+	});
+	return () => {
+		if (privateMemory) return;
+		privateMemory = true;
+		manager.appendCustomEntry(MEMORY_TURN_ENTRY, {
+			turnId,
+			reader,
+			privateMemory,
+		});
+	};
+}
+
+/** Includes immediate validation/truncation failures and calls an aborted turn left unanswered. */
+export function carriesMemory(
+	message: ContextWithSystemEvent["messages"][number],
+): boolean {
+	if (message.role === "assistant")
+		return message.content.some(
+			(part) => part.type === "toolCall" && MEMORY.has(part.name),
+		);
+	if (message.role !== "toolResult") return false;
+	return (
+		MEMORY.has(message.toolName) ||
+		(typeof message.details === "object" &&
+			message.details !== null &&
+			"privateTo" in message.details)
+	);
+}
+
+function readerRecord(data: unknown): ReaderRecord | undefined {
+	if (typeof data !== "object" || data === null) return undefined;
+	if (
+		!("reader" in data) ||
+		!("privateMemory" in data) ||
+		typeof data.reader !== "string" ||
+		data.reader.length === 0 ||
+		typeof data.privateMemory !== "boolean"
+	)
+		return undefined;
+	return { reader: data.reader, privateMemory: data.privateMemory };
+}
+
+/**
+ * Whether bridge's raw branch would replay another reader's private turn, including retained
+ * prompts/reasoning and compacted entries. Explicit privateTo results still restrict the reader,
+ * and SYSTEM is a reader of its own. Untagged memory before the first scope record is no one's
+ * in this public form; later unrecorded exchanges fail closed.
+ */
+export function bridgeHistoryHidesMemory(
+	branch: ReturnType<SessionManager["getBranch"]>,
+	reader: string | undefined,
+): boolean {
+	return bridgeHistoryHidesMemoryFor(branch, reader);
+}
+
+/**
+ * The core's own check, which public `bridgeHistoryHidesMemory` leaves its attribution knob out
+ * of: untagged memory before the first scope record keeps the primary-owner legacy attribution,
+ * and SYSTEM counts as primary owner when `primaryOwner` is supplied.
+ */
+export function bridgeHistoryHidesMemoryFor(
+	branch: ReturnType<SessionManager["getBranch"]>,
+	reader: string | undefined,
+	primaryOwner?: string,
+): boolean {
+	const normalized = (who: string | undefined) =>
+		who === SYSTEM_PRINCIPAL && primaryOwner !== undefined ? primaryOwner : who;
+	const current = normalized(reader);
+	let record: ReaderRecord | undefined;
+	let messages: Messages = [];
+	let legacy = true;
+	const hidden = () => {
+		const whose = normalized(record?.reader);
+		const carried = record?.privateMemory || messages.some(carriesMemory);
+		if (record && carried && whose !== current) return true;
+		return guardHidesPrivateExchange(messages, {
+			shared: true,
+			reader: current,
+			legacyOwner: record ? whose : legacy ? primaryOwner : undefined,
+			turnReader: whose,
+		});
+	};
+	for (const entry of branch) {
+		if (
+			entry.type === "custom" &&
+			(entry.customType === MEMORY_TURN_ENTRY ||
+				entry.customType === SCOPE_ENTRY)
+		) {
+			if (hidden()) return true;
+			messages = [];
+			if (entry.customType === SCOPE_ENTRY) legacy = false;
+			else {
+				record = readerRecord(entry.data);
+				// A corrupt record cannot establish safe ownership of a private turn.
+				if (!record) return true;
+			}
+		} else if (entry.type === "message") messages.push(entry.message);
+	}
+	return hidden();
+}