pi-roundtable 0.8.0 → 0.9.1

package/src/core/runtime/conversation-sessions.ts

@@ -1,18 +1,30 @@
 import { mkdirSync } from "node:fs";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
 import { ownerAttachmentDir } from "../attachments/attachment-dir.ts";
 import type {
 	ChannelKey,
 	PendingConfirmation,
 } from "../domain/conversation.ts";
-import type { TurnRequest } from "../domain/ports.ts";
+import type { TurnConversation, TurnRequest } from "../domain/ports.ts";
 import type { ThinkingLevel } from "../models.ts";
 import type { ToolTiers } from "../tool-tiers.ts";
-import { ConfirmationGate } from "./extensions/confirmation-gate.ts";
+import { ConfirmationGate, unexpired } from "./extensions/confirmation-gate.ts";
 import { PromptSlot } from "./prompt-slot.ts";
 import type { ChannelSession, PiAgentRuntimeOptions } from "./runtime-types.ts";
 import { revisionsKey, skillsKey } from "./runtime-types.ts";
+import {
+	conversationChanged,
+	namedConversation,
+	sessionConversation,
+} from "./session-conversation.ts";
 import type { SessionFactory } from "./session-factory.ts";
+import {
+	historyMessages,
+	historyScope,
+	scopedHistory,
+} from "./session-scope.ts";
+
+type AgentMessage = AgentSession["messages"][number];
 
 /** The open sessions of a runtime's conversations and what is held for each of them. */
 export class ConversationSessions {
@@ -21,6 +33,11 @@ export class ConversationSessions {
 	readonly #tiers: ToolTiers;
 	readonly #sessions = new Map<ChannelKey, Promise<ChannelSession>>();
 	readonly #gates = new Map<ChannelKey, ConfirmationGate>();
+	/**
+	 * What the store held for a conversation that has no gate yet, once read: a host asks what is
+	 * pending before the conversation's first turn after a restart, which builds its gate.
+	 */
+	readonly #restored = new Map<ChannelKey, PendingConfirmation | undefined>();
 	/** Each conversation's way to ask the owner during its current turn. */
 	readonly #slots = new Map<ChannelKey, PromptSlot>();
 	/** Each conversation's level the judge picked for its last turn, kept while the judge is unsure. */
@@ -41,9 +58,24 @@ export class ConversationSessions {
 		this.#tiers = tiers;
 	}
 
-	/** The held actions of a conversation whose gate is open. */
+	/** The held actions of a conversation whose gate is open, or that `held` has restored from the store. */
 	pending(channel: ChannelKey): PendingConfirmation | undefined {
-		return this.#gates.get(channel)?.pending();
+		const gate = this.#gates.get(channel);
+		return gate ? gate.pending() : unexpired(this.#restored.get(channel));
+	}
+
+	/**
+	 * The conversation's held actions, restored from the store the first time they are asked for
+	 * after a restart. Builds neither a gate nor a session: a gate's flavour follows the turn that
+	 * first needs it, an agent's or not, and only the turn knows which.
+	 */
+	async held(key: ChannelKey): Promise<PendingConfirmation | undefined> {
+		if (!this.#gates.has(key) && !this.#restored.has(key)) {
+			const stored = await this.#options.confirmations.load(key);
+			// A turn may have built the gate while the store was read; its held actions are the later ones.
+			if (!this.#gates.has(key)) this.#restored.set(key, stored);
+		}
+		return this.pending(key);
 	}
 
 	/** Disposes every open session. */
@@ -77,6 +109,7 @@ export class ConversationSessions {
 				this.#tiers,
 			);
 			this.#gates.set(key, gate);
+			this.#restored.delete(key);
 		}
 		return gate;
 	}
@@ -96,7 +129,7 @@ export class ConversationSessions {
 	 */
 	session(
 		key: ChannelKey,
-		request?: Pick<TurnRequest, "channel" | "agent" | "kind">,
+		request?: Pick<TurnRequest, "channel" | "agent" | "kind" | "conversation">,
 	): Promise<ChannelSession> {
 		let pending = this.#sessions.get(key);
 		if (!pending) {
@@ -104,28 +137,87 @@ export class ConversationSessions {
 			mkdirSync(sessionDir, { recursive: true });
 			const channel = request?.channel ?? key;
 			const agent = request?.agent;
-			pending = (async () =>
-				this.#factory.create(
+			pending = (async () => {
+				const conversation = await sessionConversation(
+					key,
+					request,
+					this.#options,
+				);
+				// A history of another scope is archived, never replayed, and what it held goes with it,
+				// after a restart too: no one approves, or reads, an action held for someone else.
+				const { history, archived } = scopedHistory(
+					sessionDir,
+					this.#factory.cwd(agent),
+					conversation,
+				);
+				if (archived > 0) {
+					this.#options.logger.info(
+						{ channel: key, archived },
+						"the conversation serves someone else now; its earlier history was archived",
+					);
+					this.#gates.delete(key);
+					this.#restored.delete(key);
+					await this.#options.confirmations.save(key, undefined);
+				}
+				return this.#factory.create(
 					agent?.home ?? channel,
-					SessionManager.continueRecent(this.#factory.cwd(agent), sessionDir),
+					history,
 					await this.gate(key, agent !== undefined),
 					this.slot(key),
 					ownerAttachmentDir(this.#options.dataDir, channel),
 					agent,
 					request?.kind ?? "owner",
-				))();
+					conversation,
+				);
+			})();
 			pending.catch(() => this.#sessions.delete(key));
 			this.#sessions.set(key, pending);
 		}
 		return pending;
 	}
 
-	/** The conversation's session, rebuilt with its history when its session tools or skills changed. */
+	/**
+	 * Whom the conversation serves at this turn: as the turn names it, else as the host records it
+	 * now, read at every turn so a record changed while the session is open counts; else as its open
+	 * session was made for, or its history records, so a conversation nothing names carries on as it
+	 * was, after a restart too; else shared.
+	 */
+	async conversation(
+		key: ChannelKey,
+		request: Pick<TurnRequest, "agent" | "conversation">,
+	): Promise<TurnConversation> {
+		const named = await namedConversation(key, request, this.#options);
+		if (named) return named;
+		const open = this.#sessions.get(key);
+		if (open) return (await open).conversation;
+		return (
+			historyScope(
+				this.#factory.sessionDir(key),
+				this.#factory.cwd(request.agent),
+			) ?? { visibility: "shared" }
+		);
+	}
+
+	/**
+	 * The conversation's session for the turn: rebuilt with its history when its session tools or
+	 * skills changed, and made anew, with nothing held for it, when the conversation serves someone
+	 * else than it was made for, its history archived rather than replayed.
+	 */
 	async freshSession(
 		key: ChannelKey,
 		request: TurnRequest,
 	): Promise<ChannelSession> {
 		const channelSession = await this.session(key, request);
+		if (
+			conversationChanged(channelSession.conversation, request.conversation)
+		) {
+			this.#options.logger.info(
+				{ channel: key },
+				"the conversation's scope changed; starting an isolated session",
+			);
+			await this.forget(key);
+			return this.session(key, request);
+		}
 		const stale = this.#staleReason(channelSession, request);
 		if (!stale) return channelSession;
 		this.#options.logger.info(
@@ -137,7 +229,7 @@ export class ConversationSessions {
 		return this.session(key, request);
 	}
 
-	/** Why a cached session must be rebuilt before this turn, or undefined when it is current. */
+	/** Why a cached session must be rebuilt, keeping its history, before this turn; undefined when it is current. */
 	#staleReason(
 		channelSession: ChannelSession,
 		request: TurnRequest,
@@ -151,6 +243,40 @@ export class ConversationSessions {
 		return undefined;
 	}
 
+	/**
+	 * The messages of a conversation's history: its open session's, or else read from its files
+	 * without opening one, so reading them fixes no scope; none when they were recorded, or its open
+	 * session was made, for someone else than the conversation serves now.
+	 */
+	async messages(key: ChannelKey): Promise<readonly AgentMessage[]> {
+		const now = await this.conversation(key, {});
+		const open = this.#sessions.get(key);
+		if (open) {
+			const { conversation, session } = await open;
+			return conversationChanged(conversation, now) ? [] : session.messages;
+		}
+		return historyMessages(
+			this.#factory.sessionDir(key),
+			this.#factory.cwd(undefined),
+			now,
+		);
+	}
+
+	/**
+	 * Forgets a session that was disposed of while its turn still ran, so the conversation's next
+	 * turn opens a new one from its files; a newer session of the conversation stays.
+	 */
+	drop(key: ChannelKey, disposed: ChannelSession): void {
+		const open = this.#sessions.get(key);
+		if (!open) return;
+		void open
+			.then((current) => {
+				if (current === disposed && this.#sessions.get(key) === open)
+					this.#sessions.delete(key);
+			})
+			.catch(() => undefined);
+	}
+
 	/** Drops the open session and everything held for the conversation, leaving its files. */
 	// pi-lens-ignore: mixed-async-styles — disposal failures of a dropped session are swallowed in a chain on purpose
 	async forget(channel: ChannelKey): Promise<void> {
@@ -160,6 +286,7 @@ export class ConversationSessions {
 			?.then(({ session }) => session.dispose())
 			.catch(() => undefined);
 		this.#gates.delete(channel);
+		this.#restored.delete(channel);
 		this.#slots.delete(channel);
 		this.usage.delete(channel);
 		this.judged.delete(channel);

package/src/core/runtime/extensions/ask-user.ts

@@ -1,8 +1,8 @@
 import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import type { OwnerAnswer, OwnerQuestion } from "../../domain/owner-prompts.ts";
 import { messages } from "../../i18n/index.ts";
 import { type OwnerIdentity, ownerWords } from "../../identity.ts";
+import type { OwnerAnswer, OwnerQuestion } from "../../interactions/prompts.ts";
 import { toolText } from "../../shared/tool-result.ts";
 import type { PromptSlot } from "../prompt-slot.ts";
 

package/src/core/runtime/extensions/confirmation-gate.ts

@@ -3,10 +3,11 @@ import type {
 	HeldCall,
 	PendingConfirmation,
 } from "../../domain/conversation.ts";
-import type { OwnerPrompts } from "../../domain/owner-prompts.ts";
 import { type HoldCheck, type HoldContext, higherTier } from "../../holds.ts";
 import { messages } from "../../i18n/index.ts";
 import { type OwnerIdentity, ownerWords } from "../../identity.ts";
+import type { Prompts } from "../../interactions/prompts.ts";
+import type { Speaker } from "../../speakers.ts";
 import type { ToolTiers } from "../../tool-tiers.ts";
 import type { PromptSlot } from "../prompt-slot.ts";
 
@@ -16,6 +17,17 @@ const CARD_INPUT_CHARS = 1_500;
 /** Held actions older than this cannot be approved any more. */
 export const CONFIRMATION_TTL_MS = 24 * 3_600_000;
 
+/** The held actions when they can still be approved at `now`; expired ones count as none. */
+export function unexpired(
+	pending: PendingConfirmation | undefined,
+	now = new Date(),
+): PendingConfirmation | undefined {
+	if (!pending) return undefined;
+	return now.getTime() - pending.heldAt.getTime() > CONFIRMATION_TTL_MS
+		? undefined
+		: pending;
+}
+
 /** JSON with object keys sorted at every level, so equal inputs compare equal. */
 // pi-lens-ignore: no-unknown-parameters — tool input is untyped model JSON; this is where it is read
 export function canonicalJson(value: unknown): string {
@@ -55,7 +67,7 @@ function byCodeUnit(a: string, b: string): number {
 export class ConfirmationGate {
 	#selectionId: string | undefined;
 	/** The running turn's speaker, whom the actions it holds belong to. */
-	#speakerId: string | undefined;
+	#speaker: Pick<Speaker, "id" | "principalId"> | undefined;
 	#pending: PendingConfirmation | undefined;
 	#approved: HeldCall[] = [];
 	readonly #holds: HoldCheck;
@@ -86,25 +98,22 @@ export class ConfirmationGate {
 
 	/** Held actions awaiting the owner's answer; expired ones count as none. */
 	pending(now = new Date()): PendingConfirmation | undefined {
-		const pending = this.#pending;
-		if (!pending) return undefined;
-		return now.getTime() - pending.heldAt.getTime() > CONFIRMATION_TTL_MS
-			? undefined
-			: pending;
+		return unexpired(this.#pending, now);
 	}
 
 	/**
-	 * `addressee` is who the turn is for; without one, the owner. `speakerId` is who spoke the turn,
-	 * recorded with what it holds; without one, only the owner may approve them.
+	 * `addressee` is who the turn is for; without one, the owner. `speaker` is who spoke the turn,
+	 * recorded with what it holds by their id and principal; without one, only the owners may
+	 * approve them.
 	 */
 	beginTurn(
 		selectionId: string,
 		confirmed: boolean,
 		addressee?: OwnerIdentity,
-		speakerId?: string,
+		speaker?: Pick<Speaker, "id" | "principalId">,
 	): void {
 		this.#selectionId = selectionId;
-		this.#speakerId = speakerId;
+		this.#speaker = speaker;
 		this.#addressee = addressee ?? this.#owner;
 		this.#approved = confirmed ? [...(this.pending()?.calls ?? [])] : [];
 		this.#pending = undefined;
@@ -127,7 +136,7 @@ export class ConfirmationGate {
 	async review(
 		tool: string,
 		input: Record<string, unknown>,
-		ask?: { prompts: OwnerPrompts; asker: string; signal?: AbortSignal },
+		ask?: { prompts: Prompts; asker: string; signal?: AbortSignal },
 	): Promise<string | undefined> {
 		return (await this.decide(tool, input, ask)).reason;
 	}
@@ -139,7 +148,7 @@ export class ConfirmationGate {
 	async decide(
 		tool: string,
 		input: Record<string, unknown>,
-		ask?: { prompts: OwnerPrompts; asker: string; signal?: AbortSignal },
+		ask?: { prompts: Prompts; asker: string; signal?: AbortSignal },
 	): Promise<{ reason?: string; approvedOnCard?: true }> {
 		const call = this.#needing(tool, input);
 		if (!call) return {};
@@ -191,7 +200,12 @@ export class ConfirmationGate {
 			selectionId,
 			heldAt: new Date(),
 			calls: [],
-			...(this.#speakerId === undefined ? {} : { speakerId: this.#speakerId }),
+			...(this.#speaker
+				? {
+						speakerId: this.#speaker.id,
+						principalId: this.#speaker.principalId,
+					}
+				: {}),
 		};
 		if (
 			!pending.calls.some((c) => c.tool === call.tool && c.input === call.input)