@aeondave/pi-persona 1.16.3 → 1.17.1

package/src/extension.ts

@@ -21,6 +21,7 @@ import { Text } from "@earendil-works/pi-tui";
 import type { AgentConfig } from "./agents/agent.ts";
 import { installBridge, isBridgeMode } from "./bridge.ts";
 import { resolveConfig } from "./core/config.ts";
+import { resolvePersonaConfig } from "./core/settings.ts";
 import { type ContractDef, installedContractNames } from "./core/contract.ts";
 import { type DataRootMigrationResult, migrateLegacyDataRoot } from "./core/data-root.ts";
 import {
@@ -77,6 +78,9 @@ export {
 } from "./extension/shared.ts";
 import { installExocom } from "./exocom/install.ts";
 import { installIdentity } from "./extension/identity.ts";
+import { registerPersonaSettings } from "./extension/persona-settings.ts";
+import { openPersonaModelSettings } from "./extension/persona-model-settings.ts";
+import { collectCompanionSettings } from "./extension/companion-settings.ts";
 import { parseExocomArgv } from "./exocom/activation.ts";
 import { formatLedgerStatus } from "./exocom/status.ts";
 import { registerDelegateTool } from "./tools/delegate-tool.ts";
@@ -87,7 +91,7 @@ import { createMonitorSession, type MonitorSession } from "./monitor/session.ts"
 import { registerCouncilTool } from "./tools/council.ts";
 import { registerFlowTool } from "./tools/flow.ts";
 import { registerModelsTool } from "./tools/models.ts";
-import { type AsyncRun, AsyncRunTracker, boundCompletionSurface, buildCheckIn, buildPeekAlert, buildPeekDigest, buildRetentionOverflowNote, IdleCoalescingNotifier, PeekWatcher, renderCompletion, STALL_FLAG_MS } from "./engine/async.ts";
+import { type AsyncRun, AsyncRunTracker, boundCompletionSurface, buildCheckIn, buildPeekAlert, buildPeekDigest, buildRetentionOverflowNote, isAsyncRunStalled, IdleCoalescingNotifier, PeekWatcher, renderCompletion, STALL_FLAG_MS } from "./engine/async.ts";
 import { emptyUsage, type ToolEvent } from "./engine/stream.ts";
 import { brokerEndpoint } from "./bus/broker/paths.ts";
 import { InProcessBus } from "./bus/inproc.ts";
@@ -108,17 +112,15 @@ import {
 	pendingParticipants,
 	type ModelParticipant,
 } from "./persona/model-participants.ts";
-import { expandCouncilPreset, type OrchestrationGrammar, type Persona } from "./persona/persona.ts";
+import { expandCouncilPreset, resolveCouncilInvocation, type OrchestrationGrammar, type Persona } from "./persona/persona.ts";
 import { bundledSpinePath, bundledWorkerSpinePath, readSpineFile, resolveSpine, type SpineSources } from "./persona/spine.ts";
-import { readLastPersona, writeLastPersona } from "./persona/state.ts";
+import { migratePersonaSettings, patchPersonaSettings, readPersonaSettings, type PersonaSettings } from "./persona/settings-store.ts";
 import { type AgentKind as TelemetryAgentKind, type AgentStatus as TelemetryAgentStatus } from "./telemetry/contract.ts";
 import { TelemetryProducer, type TelemetryAgentInput } from "./telemetry/producer.ts";
 import {
 	type PersonaConfigStore,
 	personaModels,
-	readPersonaConfigs,
 	withPersonaModels,
-	writePersonaConfigs,
 } from "./persona/config-store.ts";
 import { shortModel } from "./tools/delegate.ts";
 import { formatInbox } from "./tools/intercom.ts";
@@ -183,6 +185,7 @@ interface NudgeEntry {
 
 interface CheckInEntry {
 	content: string;
+	kind?: "routine" | "stall";
 }
 
 /**
@@ -279,7 +282,7 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 		return;
 	}
 
-	const config = resolveConfig(process.env);
+	let config = resolveConfig(process.env);
 	if (config.disabled) return;
 	const exocomArgs = parseExocomArgv(options.exocomArgv ?? process.argv);
 	const registerFollowUpRenderer = (customType: "pi-persona" | "exocom_received", label: string): void => {
@@ -342,7 +345,7 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 	pi.registerEntryRenderer("pi-persona-status", (entry, { expanded }, theme) => {
 		const data = entry.data as CheckInEntry;
 		const full = sanitizeTerminalText(data.content || "Async activity · routine check-in");
-		const title = theme.fg("accent", theme.bold("pi-persona · async status"));
+		const title = theme.fg(data.kind === "stall" ? "warning" : "accent", theme.bold(data.kind === "stall" ? "pi-persona · possible stall" : "pi-persona · async status"));
 		if (expanded) return new Text(`${title}\n${theme.fg("toolOutput", full)}`, 0, 0);
 		// The entry title already labels this as async status. Spend the compact preview on the
 		// aggregate and first run row so the operator sees the selected alias and usage label.
@@ -355,8 +358,8 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 	const appendNudgeEntry = (content: string): void => {
 		pi.appendEntry("pi-persona-nudge", { content } satisfies NudgeEntry);
 	};
-	const appendCheckInEntry = (content: string): void => {
-		pi.appendEntry("pi-persona-status", { content } satisfies CheckInEntry);
+	const appendCheckInEntry = (content: string, kind: "routine" | "stall" = "routine"): void => {
+		pi.appendEntry("pi-persona-status", { content, kind } satisfies CheckInEntry);
 	};
 	const appendCommandResult = (
 		label: string,
@@ -390,7 +393,37 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 			return { moved: [], kept: [], warnings: [`data root migration failed: ${message}`] };
 		}
 	})();
+	// One persistent settings owner. The root migration must run before importing the two
+	// retired stores; fork-guarded children returned before any filesystem access above.
+	const settingsFile = join(personaDataDir(), "settings.json");
+	let savedSettings: PersonaSettings = { version: 1, preferences: {}, personas: {}, lastPersona: null };
+	const settingsWarnings: string[] = [];
+	const reportedSettingsWarnings = new Set<string>();
+	try {
+		const result = migratePersonaSettings(settingsFile, {
+			legacyConfigFile: join(personaDataDir(), "config.json"),
+			legacyStateFile: config.stateFile ?? join(personaDataDir(), "state.json"),
+		});
+		savedSettings = result.settings;
+		settingsWarnings.push(...result.warnings);
+	} catch (error) {
+		settingsWarnings.push(`could not load settings: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	config = resolvePersonaConfig(savedSettings.preferences, process.env);
+	function reportSettingsWarning(ctx: ExtensionContext | undefined, message: string): void {
+		if (reportedSettingsWarnings.has(message)) return;
+		reportedSettingsWarnings.add(message);
+		const text = `pi-persona settings: ${compactInlineText(message, { maxChars: 500 })}`;
+		try {
+			if (ctx?.hasUI) ctx.ui.notify(text, "warning");
+			else process.stderr.write(`${text}\n`);
+		} catch {
+			// A failed UI must not turn recoverable configuration trouble into activation failure.
+			try { process.stderr.write(`${text}\n`); } catch { /* Non-fatal diagnostic. */ }
+		}
+	}
 	const reportDataRootMigration = (ctx: ExtensionContext): void => {
+		for (const warning of settingsWarnings) reportSettingsWarning(ctx, warning);
 		if (dataRootMigration.moved.length > 0) {
 			const message = `pi-persona: moved ${dataRootMigration.moved.length} file(s) from the legacy pi-persona storage root into ${personaDataDir()}`;
 			if (ctx.hasUI) ctx.ui.notify(message, "info");
@@ -549,7 +582,7 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 	// rather than to a "subagent" literal that names nobody. Bounded; cleared on teardown.
 	const telemetryAskSenders = new Map<string, string>();
 	const MAX_TRACKED_ASK_SENDERS = 256;
-	type PendingExocomTelemetry = { id: string; sessionId: string; target: string; size: number };
+	type PendingExocomTelemetry = { id: string; sessionId: string; target: string; size: number; replyTo?: string };
 	const telemetryExocomPending = new Map<string, PendingExocomTelemetry[]>();
 	// …and the same for intercom: both channels open at tool_call and close at tool_result, so both are
 	// left hanging when Pi resolves a call as "immediate" and never reaches a result.
@@ -849,21 +882,36 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 	let seedSourceCollisions: string[] = [];
 
 	// Remembered selection lives in the persona data folder; only user gestures write it.
-	const stateFile = config.stateFile ?? join(personaDataDir(), "state.json");
 	const readRememberedPersona = (): string | undefined => {
 		if (!config.persist) return undefined;
-		return readLastPersona(stateFile);
+		try {
+			savedSettings = readPersonaSettings(settingsFile);
+			return savedSettings.lastPersona ?? undefined;
+		} catch (error) {
+			reportSettingsWarning(lastCtx, `could not read remembered persona: ${error instanceof Error ? error.message : String(error)}`);
+			return undefined;
+		}
 	};
 	const persist = (name: string | undefined): void => {
-		if (config.persist) writeLastPersona(stateFile, name);
+		if (!config.persist) return;
+		try {
+			savedSettings = patchPersonaSettings(settingsFile, { lastPersona: name ?? null });
+		} catch (error) {
+			reportSettingsWarning(lastCtx, `could not save remembered persona: ${error instanceof Error ? error.message : String(error)}`);
+		}
 	};
 
-	// Per-persona config (model assignments today, open-ended), indexed by persona name.
-	const configFile = join(personaDataDir(), "config.json");
+	// Model preferences share the canonical file with extension preferences and selection.
 	const readConfigStore = (): PersonaConfigStore => {
-		return readPersonaConfigs(configFile);
+		try {
+			savedSettings = readPersonaSettings(settingsFile);
+			return savedSettings.personas;
+		} catch (error) {
+			reportSettingsWarning(lastCtx, `could not read model settings: ${error instanceof Error ? error.message : String(error)}`);
+			return savedSettings.personas;
+		}
 	};
-	let personaConfigs: PersonaConfigStore = {};
+	let personaConfigs: PersonaConfigStore = savedSettings.personas;
 	// A participant is asked for a model at most ONCE per session — dismissal included, so a
 	// closed picker never becomes a nag. Keyed by persona + assignment key, NOT by persona: a new
 	// roster (or a new strategy's arbiter) is a genuinely new participant and may ask the first time
@@ -1013,9 +1061,9 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 			try {
 				const all = lastCtx?.modelRegistry.getAll() ?? [];
 				const m = all.find((x) => x.provider === handle.provider && x.id === handle.id);
-				if (m) await pi.setModel(m);
+				return m ? await pi.setModel(m) : false;
 			} catch {
-				/* keep current */
+				return false; // keep current, but let the controller report that the switch failed
 			}
 		},
 		setStatus: (text) => {
@@ -1223,13 +1271,12 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 				return;
 			}
 			const now = Date.now();
-			const dueCheckIn = config.checkInEveryMs > 0 && now - lastPeekAt >= config.checkInEveryMs;
-			// Routine status is durable operator history, not a model notification: append it on cadence even
-			// while a turn is busy or human input is queued. This keeps visibility independent of wake eligibility.
-			if (dueCheckIn) {
-				lastPeekAt = now;
+			const waitingRuns = waitingAsyncRunIds();
+			const fast = config.peekEveryMs > 0;
+			const stuck = fast ? peekWatcher.poll(runs, now, STALL_FLAG_MS, waitingRuns) : [];
+			const appendStatus = (content: string, kind: "routine" | "stall"): void => {
 				try {
-					appendCheckInEntry(buildCheckIn(runs, { now, stallMs: STALL_FLAG_MS, waitingForSupervisor: waitingAsyncRunIds() }));
+					appendCheckInEntry(content, kind);
 				} catch (error) {
 					const detail = compactInlineText(error instanceof Error ? error.message : String(error), { maxChars: 120 });
 					const warning = `pi-persona: could not append async status entry${detail ? ` (${detail})` : ""}`;
@@ -1241,27 +1288,30 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 						try { process.stderr.write(`[pi-persona] ${warning}\n`); } catch { /* diagnostics must not block an actionable wake */ }
 					}
 				}
+			};
+			// Every new stall episode is durable operator history, including while the model is busy.
+			if (stuck.length > 0) appendStatus(buildCheckIn(stuck, { now, stallMs: STALL_FLAG_MS, reason: "stall", waitingForSupervisor: waitingRuns }), "stall");
+			const dueCheckIn = config.checkInEveryMs > 0 && now - lastPeekAt >= config.checkInEveryMs;
+			if (dueCheckIn) {
+				lastPeekAt = now;
+				appendStatus(buildCheckIn(runs, { now, stallMs: STALL_FLAG_MS, waitingForSupervisor: waitingRuns }), "routine");
 			}
-			// Poll actionable model wakes only for a free supervisor. A busy/queued session keeps messages
-			// unread and leaves stall state untouched for the next tick, rather than stacking sticky follow-ups.
+			// Interactive stalls are operator-only. Headless sessions may consume one model wake per
+			// run lifetime; unread non-ask messages retain their existing actionable route.
 			if (!canDeliverPersonaNotification(orchestrating, processingDeferredOrchestration, lastCtx?.isIdle?.() === true) || lastCtx?.hasPendingMessages?.() === true) return;
-			// The watchdog is not a model polling loop: the FAST path wakes on newly-stalled legs or unread
-			// progress messages. Completions arrive separately through completionNotifier; `/peek` remains on demand.
-			const fast = config.peekEveryMs > 0;
-			const waitingRuns = waitingAsyncRunIds();
-			const stuck = fast ? peekWatcher.poll(runs, now, STALL_FLAG_MS, waitingRuns) : [];
-			// Drain only progress messages; blocking asks (expectsReply) are surfaced by the intercom
-			// notifier and left for the `intercom inbox` tool — so peek never double-shows them.
 			const unread = fast ? bus.takeWhere(SUPERVISOR, (e) => !e.expectsReply) : [];
-			if (stuck.length === 0 && unread.length === 0) return; // healthy + quiet ⇒ stay silent
+			const wakeCandidates = fast && lastCtx?.hasUI === false
+				? peekWatcher.firstWakeCandidates(runs.filter((run) => isAsyncRunStalled(run, now, STALL_FLAG_MS)))
+				: [];
+			if (wakeCandidates.length === 0 && unread.length === 0) return;
 			const parts: string[] = [];
-			if (stuck.length > 0) parts.push(buildPeekAlert(stuck, { now }));
+			if (wakeCandidates.length > 0) parts.push(buildPeekAlert(wakeCandidates, { now }));
 			if (unread.length > 0) parts.push(`📨 from sub-agents:\n${fenceUntrusted(formatInbox(unread))}`);
-			if (stuck.length > 0) lastPeekAt = now; // message-only wakes do not postpone the routine status cadence
 			try {
 				sendPersonaFollowUp(pi, `[pi-persona] ${parts.join("\n\n")}`);
+				peekWatcher.acknowledgeModelWake(wakeCandidates.map((run) => run.id));
 			} catch {
-				/* ignore */
+				peekWatcher.retryReports(wakeCandidates);
 			}
 		}, tickMs);
 		peekTimer.unref?.();
@@ -1360,8 +1410,7 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 	 * Every participant a run really spawns — roster members (inline ones included) plus the
 	 * auxiliary actors its strategy declares — with the model each one resolves to.
 	 */
-	function runParticipants(ctx: ExtensionContext, opts: { strategy: string; params?: Record<string, unknown>; members: RosterMember[] }): ModelParticipant[] {
-		const persona = controller.activePersona?.name;
+	function runParticipants(ctx: ExtensionContext, opts: { strategy: string; params?: Record<string, unknown>; members: RosterMember[] }, persona = controller.activePersona?.name): ModelParticipant[] {
 		return collectModelParticipants({
 			members: opts.members,
 			strategy: opts.strategy,
@@ -1383,16 +1432,56 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 	 * authenticated model to choose between.
 	 */
 	async function ensurePersonaModels(ctx: ExtensionContext, participants: ModelParticipant[]): Promise<void> {
-		const persona = controller.activePersona?.name;
-		if (!persona || !ctx.hasUI) return;
-		const missing = pendingParticipants(participants, { prompted: promptedFor(persona, participants) });
+		const scope = modelSelectionScope(ctx);
+		if (!scope || !ctx.hasUI) return;
+		const missing = pendingParticipants(participants, { prompted: promptedFor(scope.persona, participants) });
 		if (missing.length === 0) return;
 		const available = configuredModels(ctx);
-		if (available.length < 2) return; // can't diversify with a single configured model
+		if (available.length < 2) return; // automatic setup cannot diversify a single model
+		const chosen = await choosePersonaModels(ctx, missing, available, scope);
+		if (chosen && Object.keys(chosen).length > 0) savePersonaModels(ctx, scope.persona, chosen);
+	}
+
+	type ModelSelectionScope = { persona: string; isCurrent(): boolean };
+	function modelSelectionScope(ctx: ExtensionContext): ModelSelectionScope | undefined {
+		const active = controller.activePersona;
+		if (!active) return undefined;
+		const sessionId = ctx.sessionManager?.getSessionId?.();
+		return { persona: active.name, isCurrent: () => !disposed && controller.activePersona === active &&
+			(sessionId === undefined || lastCtx?.sessionManager?.getSessionId?.() === sessionId) };
+	}
+
+	/** An explicit user edit is allowed to replace defaults, unlike automatic first-run setup. */
+	async function editPersonaModels(ctx: ExtensionContext, participants: ModelParticipant[], scope: ModelSelectionScope): Promise<void> {
+		const editable = participants.filter((p) => p.source !== "inline");
+		if (editable.length === 0) {
+			ctx.ui.notify("persona models: no editable council participants (inline model pins are unchanged).", "info");
+			return;
+		}
+		// Trust fresh availability here, not the discovery union with provisional catalog entries.
+		const available = ctx.modelRegistry.getAvailable();
+		if (available.length === 0) {
+			ctx.ui.notify("persona models: no available models. Use /login, then retry /persona models.", "warning");
+			return;
+		}
+		const chosen = await choosePersonaModels(ctx, editable, available, scope);
+		if (!chosen) return;
+		if (Object.keys(chosen).length === 0) {
+			ctx.ui.notify("persona models: no model assignments changed; previous choices kept.", "info");
+			return;
+		}
+		if (savePersonaModels(ctx, scope.persona, chosen)) {
+			ctx.ui.notify(`persona models: updated ${Object.keys(chosen).length} model assignment(s) for "${scope.persona}"; applies to future runs.`, "info");
+		}
+	}
+
+	/** UI adapter shared by setup and editing; callers own eligibility and availability policy. */
+	async function choosePersonaModels(ctx: ExtensionContext, participants: ModelParticipant[], available: Array<{ provider: string; id: string }>, scope: ModelSelectionScope): Promise<Record<string, string> | undefined> {
+		const { persona } = scope;
 		const options = orderModelRefs(available.map((m) => `${m.provider}/${m.id}`), ctx.model?.provider);
 		const chosen: Record<string, string> = {};
 		try {
-			for (const p of missing) {
+			for (const p of participants) {
 				// Recorded BEFORE the prompt: a dismissal (or a picker that dies) must not be retried
 				// for this session, exactly like an answer is not asked twice.
 				promptedParticipants.add(`${persona}\0${p.key}`);
@@ -1403,7 +1492,8 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 				const role = p.param ? ` · ${p.param}` : "";
 				// A participant label carries a role prompt (free prose from a team file or a
 				// caller) — sanitised here so a title can never repaint the TUI or forge a row.
-				const title = compactInlineText(`Model for "${p.label}"${purpose ? ` (${purpose})` : ""}${role}  ·  ${persona}`, { maxChars: 120 });
+				const current = p.assigned && p.model ? ` · current: ${p.model}` : "";
+				const title = compactInlineText(`Model for "${p.label}"${purpose ? ` (${purpose})` : ""}${role}  ·  ${persona}${current}`, { maxChars: 200 });
 				// In the TUI: a searchable picker (type to filter) whose viewport follows the
 				// selection — the built-in select can't scroll a hundreds-long provider list
 				// usefully. Outside the TUI (RPC), fall back to the built-in select.
@@ -1415,24 +1505,38 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 								{ overlay: true },
 							)
 						: await ctx.ui.select(title, options);
-				if (pick) chosen[p.key] = pick;
+				if (!scope.isCurrent()) {
+					ctx.ui.notify("persona models: persona or session changed; no assignments changed.", "warning");
+					return;
+				}
+				if (pick && options.includes(pick)) chosen[p.key] = pick;
 			}
 		} catch {
 			/* dismissed / no UI → fall back to the default model */
 		}
-		if (Object.keys(chosen).length === 0) return;
+		if (!scope.isCurrent()) {
+			ctx.ui.notify("persona models: persona or session changed; no assignments changed.", "warning");
+			return;
+		}
+		return chosen;
+	}
+
+	function savePersonaModels(ctx: ExtensionContext, persona: string, chosen: Record<string, string>): boolean {
 		// The picks are live for this session either way (the in-memory store is updated first), so
 		// a save failure costs only PERSISTENCE — but silently swallowing it would re-prompt on every
 		// future session with no hint that the assignment never landed.
 		personaConfigs = withPersonaModels(personaConfigs, persona, chosen);
 		try {
-			writePersonaConfigs(configFile, personaConfigs);
+			savedSettings = patchPersonaSettings(settingsFile, { models: { [persona]: chosen } });
+			personaConfigs = savedSettings.personas;
 		} catch (err) {
 			ctx.ui.notify(
 				`pi-persona: could not save the model assignment for "${persona}" (${err instanceof Error ? err.message : String(err)}) — it applies to this session only.`,
 				"error",
 			);
+			return false;
 		}
+		return true;
 	}
 
 	/** A core's declared verticalization ("Propulsore", "Critico") — the lens it argues from, so a
@@ -1861,6 +1965,7 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 	function doctorReport(): string {
 		const lines: string[] = [];
 		lines.push(`pi-persona — active: ${controller.activePersona?.label ?? "none"}`);
+		lines.push(`settings: ${settingsFile} (/persona-settings; preferences: next session or Pi /reload)`);
 		lines.push(`engine backend: ${config.engine === "child" ? "child-process" : "in-process"}`);
 		const piVersion = installedPiVersion();
 		lines.push(`pi: ${piVersion ?? "unknown"} (requires ≥ ${MIN_PI_VERSION})${piVersion && !satisfiesFloor(piVersion, MIN_PI_VERSION) ? " — BELOW FLOOR" : ""}`);
@@ -2137,12 +2242,114 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 		},
 	});
 
+	// The dedicated settings surface never replaces Pi's /settings and never calls /reload.
+	registerPersonaSettings(pi, {
+		file: settingsFile,
+		companions: () => collectCompanionSettings(pi.events),
+		activeConfig: config,
+		env: process.env,
+		read: () => {
+			savedSettings = readPersonaSettings(settingsFile);
+			personaConfigs = savedSettings.personas;
+			return savedSettings;
+		},
+		write: (patch) => {
+			savedSettings = patchPersonaSettings(settingsFile, patch);
+			personaConfigs = savedSettings.personas;
+		},
+		isCurrent: (ctx) => !disposed && !ctx.signal?.aborted &&
+			(ctx.sessionManager?.getSessionId?.() === undefined ||
+				lastCtx?.sessionManager?.getSessionId?.() === ctx.sessionManager.getSessionId()),
+		diagnostics: doctorReport,
+		models: async (ctx) => {
+			lastCtx = ctx;
+			personaConfigs = readConfigStore();
+			const session = ctx.sessionManager?.getSessionId?.();
+			await openPersonaModelSettings(ctx, {
+				owners: () => personas.map((persona) => ({ name: persona.name, label: persona.label })),
+				activeOwner: () => controller.activePersona?.name,
+				profiles: (owner) => {
+					const persona = personas.find((p) => p.name === owner);
+					return [
+						...(persona?.orchestration?.strategy ? [{ name: "@orchestration", label: "Automatic orchestration" }] : []),
+						...personas.filter((p) => p.name !== owner && (p.council?.strategy || p.council?.members || p.council?.membersProblem))
+							.map((p) => ({ name: p.name, label: `Council: ${p.label}` })),
+					];
+				},
+				participants: (owner, profile) => {
+					const persona = personas.find((p) => p.name === owner);
+					if (!persona) throw new Error(`persona "${owner}" is no longer installed`);
+					const orchestrationStrategy = persona.orchestration?.strategy;
+					if (profile === "@orchestration" && orchestrationStrategy && persona.orchestration) {
+						const orchestration = persona.orchestration;
+						const panel = resolveOrchestrationMembers(orchestration, teams);
+						return runParticipants(ctx, { strategy: orchestrationStrategy, members: panel,
+							...(orchestration.params ? { params: orchestration.params } : {}) }, owner);
+					}
+					const resolved = resolveCouncilInvocation(personas, persona, profile ? { persona: profile } : {});
+					if (!resolved.ok) throw new Error(resolved.error);
+					const { strategy, roster, members, params } = resolved.value;
+					const panel = resolveOrchestrationMembers({ roster, ...(members ? { members } : {}) }, teams);
+					return runParticipants(ctx, { strategy, members: panel, params }, owner);
+				},
+				saved: (owner) => personaModels(personaConfigs, owner),
+				write: (owner, models) => {
+					savedSettings = patchPersonaSettings(settingsFile, { models: { [owner]: models } });
+					personaConfigs = savedSettings.personas;
+				},
+				isCurrent: () => !disposed && (session === undefined || lastCtx?.sessionManager?.getSessionId?.() === session),
+			});
+		},
+	});
+
 	// ── /persona ─────────────────────────────────────────────────────────────────
 	pi.registerCommand("persona", {
-		description: "Switch the active supervisor persona: /persona [name|off|list|reload|seed|restore]",
+		description: "Switch persona or edit council models: /persona [name|off|list|reload|seed|restore|models [council-persona]]",
 		handler: async (args, ctx) => {
 			lastCtx = ctx;
 			const arg = args.trim();
+			if (arg === "models" || arg.startsWith("models ")) {
+				const caller = controller.activePersona;
+				const scope = modelSelectionScope(ctx);
+				if (!caller || !scope) {
+					ctx.ui.notify("persona models: activate a persona first with /persona <name>.", "warning");
+					return;
+				}
+				if (!ctx.hasUI) {
+					ctx.ui.notify("persona models: an interactive TUI or RPC UI is required to select council models; no assignments changed.", "warning");
+					return;
+				}
+				const profile = arg.slice("models".length).trim();
+				const resolved = resolveCouncilInvocation(personas, caller, profile ? { persona: profile } : {});
+				if (!resolved.ok) {
+					ctx.ui.notify(`persona models: ${resolved.error}`, "error");
+					return;
+				}
+				try {
+					const { strategy, roster, members, params } = resolved.value;
+					const panel = resolveOrchestrationMembers({ roster, ...(members ? { members } : {}) }, teams);
+					const deadline = AbortSignal.timeout(20_000);
+					const signal = ctx.signal ? AbortSignal.any([ctx.signal, deadline]) : deadline;
+					const result = await ctx.modelRegistry.refresh?.({ signal });
+					if (!scope.isCurrent()) {
+						ctx.ui.notify("persona models: persona or session changed; no assignments changed.", "warning");
+						return;
+					}
+					if (signal.aborted || result?.aborted) {
+						ctx.ui.notify("persona models: refresh cancelled or timed out; previous assignments kept.", "warning");
+						return;
+					}
+					if (result?.errors.size) {
+						const providers = compactInlineText([...result.errors.keys()].join(", "), { maxChars: 160 });
+						ctx.ui.notify(`persona models: refresh incomplete for ${providers}; previous assignments kept. Check provider configuration and retry.`, "warning");
+						return;
+					}
+					await editPersonaModels(ctx, runParticipants(ctx, { strategy, members: panel, params }), scope);
+				} catch (err) {
+					ctx.ui.notify(`persona models: refresh failed (${err instanceof Error ? err.message : String(err)}); previous assignments kept.`, "error");
+				}
+				return;
+			}
 			if (arg === "off" || arg === "none") {
 				await controller.deactivate();
 				persist(undefined);

package/src/orchestration/sdk.ts

@@ -67,6 +67,8 @@ export interface AgentProgress {
 	tokens?: number;
 	/** The tool the agent is currently running (e.g. "grep src/…"), if any. */
 	activity?: string;
+	/** Timestamp of newly streamed tool output; no tool output text crosses this seam. */
+	toolOutputAt?: number;
 	/** One authoritative runtime tool lifecycle transition; never contains tool args or output. */
 	toolEvent?: ToolEvent;
 }