@aeondave/pi-persona 1.17.4 → 1.17.5

package/src/extension.ts

@@ -37,7 +37,8 @@ import {
 	type SpineLegacySelection,
 } from "./core/seed.ts";
 import { type BriefFlow, buildDelegationBrief } from "./core/brief.ts";
-import { canCallTool, canDelegateTo, canFanOut, type RunLimits } from "./core/capabilities.ts";
+import { canCallTool, canDelegateTo, canFanOut, type RunLimits } from "./core/capabilities.ts";
+import { isAllowed } from "./core/permissions.ts";
 import { fenceUntrusted } from "./core/fence.ts";
 import { sanitizeDisplayLabel } from "./core/display-label.ts";
 import { DelegationNudge, orderByMention, PersistenceNudge, PollGuard, renderNudgeModels, renderNudgeRoster } from "./core/nudge.ts";
@@ -48,7 +49,11 @@ import { installedPiVersion, MIN_PI_VERSION, satisfiesFloor } from "./core/pi-co
 import { type EngineAdapterBroker } from "./engine/adapter.ts";
 import { SupervisorBroker } from "./extension/broker-host.ts";
 import { configuredModels, createBuildEngine, DEFAULT_ENGINE_FACTORIES, type EngineFactories } from "./extension/engine.ts";
-import { installHooks, type HookHost } from "./extension/hooks.ts";
+import { installHooks, type HookHost } from "./extension/hooks.ts";
+import { installActivityIngress, installCompanionPresence } from "./extension/companion.ts";
+import { installMemoryOwner } from "./extension/memory-owner.ts";
+import { installMindWorker } from "./extension/mind-worker.ts";
+import { inheritedMemoryPersona, MEMORY_PERSONA_ENV } from "./core/companion.ts";
 import {
 	canDeliverPersonaNotification,
 	compactNameList,
@@ -110,14 +115,16 @@ import { clearJournal, journalFileName, journalWriter, readJournal } from "./orc
 import { runFlow } from "./orchestration/flow-run.ts";
 import { Semaphore } from "./orchestration/parallel.ts";
 import { flowDisposition, type FlowOutcome } from "./orchestration/flow-run.ts";
-import { type RosterMember, roleHint, rosterNodeKeys, rosterSpec } from "./orchestration/roster.ts";
+import { type RosterMember, rosterNodeKeys, rosterSpec } from "./orchestration/roster.ts";
+import { agentAttemptIdentity, type AgentAttemptIdentity } from "./orchestration/agent-attempt.ts";
+import { snapshotStrategyModels, strategyLegMetadata, type StrategyLegMetadata, type StrategyModels } from "./ui/strategy-leg.ts";
 import type { AgentProgress, AgentStatus, SteerFn } from "./orchestration/sdk.ts";
 import { withResultRefs } from "./orchestration/sdk.ts";
 import { knownParams, strategyNames } from "./orchestration/strategy.ts";
 import { compactMemberResult } from "./orchestration/render.ts";
 import { sumUsage } from "./orchestration/reducers.ts";
 import type { AgentResult, FailureKind } from "./orchestration/types.ts";
-import { isThinkingLevel, type ThinkingLevel } from "./core/types.ts";
+import { isThinkingLevel } from "./core/types.ts";
 import { snapshotOrchestrationParticipants, type OrchestrationLaunchSnapshot } from "./ui/orchestration-launch.ts";
 import { SessionResults } from "./extension/results.ts";
 import { readArchivedBody, resultReceiptHint, type ResultReceipt } from "./results/retrieval.ts";
@@ -144,7 +151,7 @@ import { shortModel } from "./tools/delegate.ts";
 import { formatInbox } from "./tools/intercom.ts";
 import { renderTimerFire, TimerScheduler, type TimerEntry } from "./core/timer.ts";
 import { AgentOverlay } from "./ui/agent-overlay.ts";
-import { type AddNodeInput, type AgentNode, type AgentNodePatch, type AgentTreeChange, AgentTree, type AgentNodeStatus, deriveWaitingNodeIds, isQueuedMarker, isWakeSource, progressPatch, renderAgentTreeSummary } from "./ui/agent-tree.ts";
+import { type AddNodeInput, type AgentNode, type AgentNodePatch, type AgentTreeChange, AgentTree, type AgentNodeStatus, deriveWaitingNodeIds, isQueuedMarker, isNonAgentNode, progressPatch, renderAgentTreeSummary } from "./ui/agent-tree.ts";
 import { WakeRows, type WakeRowChange } from "./ui/wake-rows.ts";
 import { LiveClock } from "./ui/live-clock.ts";
 import { filterModels, ModelPicker, orderModelRefs, type ModelPickerMetadata } from "./ui/model-picker.ts";
@@ -263,7 +270,7 @@ export function inFlightAgentCount(nodes: ReadonlyArray<{ id: string; parentId?:
 	}
 	let count = 0;
 	for (const node of nodes) {
-		if (node.status === "running" && node.kind !== "delegate" && !isWakeSource(node) && !parents.has(node.id)) count++;
+		if (node.status === "running" && node.kind !== "delegate" && !isNonAgentNode(node) && !parents.has(node.id)) count++;
 	}
 	return count;
 }
@@ -310,15 +317,28 @@ export interface PiPersonaOptions {
 	exocomArgv?: readonly string[];
 }
 
-export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions = {}): void {
+export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions = {}): void {
+	// Loaded-extension capabilities must be discoverable even in a real delegated leg. This is a
+	// local host contract, not settings/file inference; disabled supervisors explicitly deny use.
+	const bridgeMode = isBridgeMode();
+	const role = bridgeMode || process.env.PI_PERSONA_LEG === "1" ? "leg" : resolveConfig(process.env).disabled ? "disabled" : "supervisor";
+	installCompanionPresence(pi, role);
+	if (role === "leg") {
+		const inherited = inheritedMemoryPersona(process.env[MEMORY_PERSONA_ENV]);
+		if (inherited !== undefined) {
+			const owner = installMemoryOwner(pi, () => inherited.persona);
+			pi.on("session_start", (_event, ctx) => owner.start(ctx.sessionManager)());
+			pi.on("session_shutdown", () => owner.stop());
+		}
+	}
 	// Cross-process broker (v0.5, spec B3): a child spawned with `PI_PERSONA_BUS` set is a
 	// broker-connected sub-agent, not a supervisor — load ONLY the bridge (comm-plane tools +
-	// inbound follow-ups) and skip the entire persona/delegate/orchestration surface. Checked
-	// before anything else (even config resolution) so bridge mode can never be shadowed by
+	// inbound follow-ups) and skip the entire persona/delegate/orchestration surface. Checked
+	// after the lean companion responders and before the main disabled guard, so it cannot be shadowed by
 	// the fork-bomb guard's `PI_PERSONA_DISABLE=1` short-circuit below, or by any other early
 	// return. `PI_PERSONA_BUS` unset (the default, and every existing test) ⇒ this branch never
 	// runs — zero behavior change.
-	if (isBridgeMode()) {
+	if (bridgeMode) {
 		pi.on("session_start", (_event, ctx) => installBridge(pi, ctx));
 		return;
 	}
@@ -568,7 +588,9 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 
 	// The unified live tree of every in-flight agent — strategy cores, delegate
 	// sub-agents, dynamic specialists — rendered as one sticky widget above the input.
-	const agentTree = new AgentTree();
+	const agentTree = new AgentTree();
+	const companionActivities = installActivityIngress(pi, agentTree);
+	const memoryOwner = installMemoryOwner(pi, () => controller.activePersona?.name ?? null);
 	const wakeRows = new WakeRows();
 	// Explicit telemetry is the public observability seam consumed by pi-persona-flow. It is
 	// session-scoped and starts only after persona + exocom reconciliation in session_start.
@@ -645,7 +667,9 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 		const projection = JSON.stringify(agent);
 		if (lastAgentProjection.get(node.id) === projection) return;
 		lastAgentProjection.set(node.id, projection);
-		producer.publishAgentUpdated(node.id, agent);
+		// Updates are patches: an omitted field would retain the previous attempt's model.
+		// The existing string wire contract uses an empty model to mean explicitly unknown.
+		producer.publishAgentUpdated(node.id, node.model === undefined ? { ...agent, model: "" } : agent);
 	}
 	function refreshSteeredAgentTelemetry(): void {
 		if (!telemetry || steerRegistry.size === 0) return;
@@ -659,7 +683,7 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 		if (!producer) return;
 		// Wake rows (timers, monitors) are not agents, and their labels are free text the telemetry
 		// contract never persists: they stay on the local widget and never reach the bus.
-		if ((change.type === "added" || change.type === "updated") && isWakeSource(change.node)) return;
+		if ((change.type === "added" || change.type === "updated") && isNonAgentNode(change.node)) return;
 		if (change.type === "added") {
 			lastAgentProjection.set(change.node.id, JSON.stringify(telemetryAgent(change.node)));
 			producer.publishAgentAdded(telemetryAgent(change.node));
@@ -669,15 +693,16 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 			publishAgentProjection(change.node);
 			return;
 		}
-		if (change.type === "removed") {
-			for (const node of change.nodes.filter((n) => !isWakeSource(n))) {
+		if (change.type === "removed") {
+			for (const node of change.nodes.filter((n) => !isNonAgentNode(n))) {
 				lastAgentProjection.delete(node.id);
 				const status = node.status === "running" ? "stopped" : telemetryStatus(node);
 				producer.publish("agent.removed", { id: node.id, status });
 			}
-			return;
-		}
-		lastAgentProjection.clear();
+			return;
+		}
+		if (change.nodes.every(isNonAgentNode)) return;
+		lastAgentProjection.clear();
 		producer.publish("agent.cleared", {});
 	}
 	agentTree.onChange(publishAgentTreeChange);
@@ -766,7 +791,7 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 	/** The "N agents" status answers how many agents are working, so a tree holding only wake rows
 	 *  (timers, monitors) publishes none, while the widget lines still show them. */
 	function agentCountStatus(nodes: readonly AgentNode[]): string | undefined {
-		const agents = nodes.filter((node) => !isWakeSource(node));
+		const agents = nodes.filter((node) => !isNonAgentNode(node));
 		return agents.length === 0 ? undefined : String(inFlightAgentCount(agents));
 	}
 	function renderAgentWidget(): void {
@@ -920,8 +945,11 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 			return undefined;
 		}
 	};
-	const persist = (name: string | undefined): void => {
-		if (!config.persist) return;
+	const persist = (name: string | undefined): void => {
+		// An explicit selection revokes the old companion scope even when persistence is off.
+		// Worker runs keep their frozen owners; only the local activity projection is reset.
+		if (!disposed && lastCtx) companionActivities.start(lastCtx);
+		if (!config.persist) return;
 		try {
 			savedSettings = patchPersonaSettings(settingsFile, { lastPersona: name ?? null });
 		} catch (error) {
@@ -1099,7 +1127,8 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 				return false; // keep current, but let the controller report that the switch failed
 			}
 		},
-		setStatus: (text) => {
+		setStatus: (text) => {
+			if (!disposed) memoryOwner.changed();
 			try {
 				lastCtx?.ui.setStatus("persona", text === undefined ? undefined : compactInlineText(text, { maxChars: 80 }));
 			} catch {
@@ -1308,7 +1337,7 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 		announceAsyncRunSettlement(
 			run,
 			lastCtx ? (message, level) => lastCtx?.ui.notify(message, level) : undefined,
-			(settled) => completionNotifier.notify(settled),
+			(settled) => { if (settled.delivery !== "companion") completionNotifier.notify(settled); },
 			lastCtx?.hasUI && lastCtx.mode === "tui" ? (failed) => {
 				const model = failed.result?.modelUsed ?? failed.model;
 				const durationMs = failed.startedAt !== undefined && failed.settledAt !== undefined
@@ -1496,7 +1525,7 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 			/* cosmetic — the status is best-effort */
 		}
 	};
-	const buildEngine: typeof innerBuildEngine = (signal, onProgress, engOpts) => {
+	const buildEngine: typeof innerBuildEngine = (signal, onProgress, engOpts) => {
 		const engine = innerBuildEngine(signal, onProgress, engOpts);
 		return {
 			run: async (spec, progress, sig, steer) => {
@@ -1506,7 +1535,7 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 				return result;
 			},
 		};
-	};
+	};
 
 	/**
 	 * Every participant a run really spawns — roster members (inline ones included) plus the
@@ -1743,77 +1772,25 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 		};
 	}
 
-	// Each core's model beside its name, in the ONE precedence the picker saved under: the
-	// participant's own assignment key (a role member's `agent#hash`, else the bare agent key) →
-	// the agent's declared default → the session model. An inline model is already the participant's
-	// explicit engine pin and wins before any saved assignment.
-	function coreModel(ctx: ExtensionContext, agent: string, assignmentKey: string = agent, participant?: ModelParticipant | null): string | undefined {
-		if (participant === null) return undefined; // a short-hint collision cannot identify one role safely
-		if (participant?.source === "inline" && participant.model) return participant.model;
-		const persona = controller.activePersona?.name;
-		const configured = persona ? personaModels(personaConfigs, persona) : {};
-		return configured[assignmentKey] ?? configured[agent] ?? agents.find((a) => a.name === agent)?.model ?? (ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined);
-	}
-	function coreTelemetryMeta(ctx: ExtensionContext, agent: string, assignmentKey?: string, participant?: ModelParticipant | null): { agent: string; model?: string; thinking?: ThinkingLevel } {
-		const model = coreModel(ctx, agent, assignmentKey, participant);
-		// The member's explicit spec-level effort rides the SAME participant channel as the model, so
-		// every strategy-seeded row (queued seed, live re-add, flow phase) names its effort from the
-		// first frame — the delegate launch rows' own rule. An ambiguous/null participant identifies
-		// no single lens, so it carries nothing, and absence renders nothing.
-		return { agent, ...(model ? { model } : {}), ...(participant?.thinking ? { thinking: participant.thinking } : {}) };
-	}
-	function coreLabel(ctx: ExtensionContext, agent: string, key: string = agent, assignmentKey?: string, participant?: ModelParticipant | null): string {
-		const short = shortModel(coreModel(ctx, agent, assignmentKey, participant));
+	/** Capture at engine construction, after setup: queued legs retain that run's assignments. */
+	function currentStrategyModels(ctx: ExtensionContext): StrategyModels {
+		const persona = controller.activePersona?.name;
+		return snapshotStrategyModels({ agents, ...(persona ? { assigned: personaModels(personaConfigs, persona) } : {}),
+			...(ctx.model ? { sessionModel: `${ctx.model.provider}/${ctx.model.id}` } : {}) });
+	}
+	function coreLabel(identity: AgentAttemptIdentity, key: string, metadata: StrategyLegMetadata): string {
+		const short = shortModel(metadata.model);
 		// `key` is the disambiguated node id (`agent` for a solo member, `agent · HINT` for a
 		// roster-role one) — display that + what the core is FOR + the model, so a watcher reads the
 		// council as roles rather than names, and three `reviewer` lenses still read distinctly.
-		// A roster-ROLE member already carries its lens in `key` (`agent · HINT`) and its standing
-		// purpose would repeat it — but a plain repeat (`melchior#2`) is the same core twice and
-		// still wants its lens, so key off the role separator, not off `key !== agent`.
-		const purpose = key.includes(" · ") ? undefined : corePurpose(agent);
+		// A role member already carries its lens in the display key. The full attempt identity,
+		// rather than that shortened label, decides whether a standing purpose would repeat it.
+		const purpose = identity.role ? undefined : corePurpose(identity.agent);
 		// `key` embeds the member's role HINT (derived from its role prompt), and `short` embeds a
 		// model ref — both are dynamic, so the whole row is collapsed to one escape-free line.
 		return compactInlineText([key, purpose, short].filter(Boolean).join(" · "), { maxChars: 120 });
 	}
 
-	/** The assignment key for a tree node key when no participant was seeded under it: strip the lens
-	 *  hint and the occurrence suffix, leaving the bare agent — the legacy key shape, which always
-	 *  resolves (a role-less agent is exactly how those assignments were saved). */
-	function bareAssignmentKey(nodeKey: string): string {
-		return (nodeKey.split(" · ")[0] ?? nodeKey).replace(/#\d+$/, "");
-	}
-
-	/** Map every picker participant to the SDK's display base. A short role hint is not unique when
-	 *  different role prompts share it, so ambiguous nodes omit the model rather than borrowing
-	 *  another lens' assignment. Repeated SDK keys (`#2`, …) resolve through their base and share the
-	 *  same participant. */
-	function participantByNode(participants: ModelParticipant[]): Map<string, ModelParticipant | null> {
-		const groups = new Map<string, Map<string, ModelParticipant>>();
-		for (const participant of participants) {
-			const base = participant.role ? `${participant.agent} · ${roleHint(participant.role)}` : participant.agent;
-			const group = groups.get(base) ?? new Map<string, ModelParticipant>();
-			group.set(participant.key, participant);
-			groups.set(base, group);
-		}
-		const out = new Map<string, ModelParticipant | null>();
-		for (const [base, group] of groups) {
-			if (group.size !== 1) {
-				out.set(base, null);
-				continue;
-			}
-			const participant = group.values().next().value as ModelParticipant | undefined;
-			if (participant) out.set(base, participant);
-		}
-		return out;
-	}
-
-	function participantForNode(nodeParticipants: ReadonlyMap<string, ModelParticipant | null>, nodeKey: string): ModelParticipant | null | undefined {
-		const exact = nodeParticipants.get(nodeKey);
-		if (exact !== undefined) return exact;
-		const base = nodeKey.replace(/#\d+$/, "");
-		return base === nodeKey ? undefined : nodeParticipants.get(base);
-	}
-
 	/** Surface the SDK's main-model recovery in the UI: a broken member is re-run on the session's own
 	 *  model rather than dropped from the council, and the operator deserves to see that switch.
 	 *  Strictly cosmetic — a toast that throws must never corrupt a run's result. */
@@ -1833,31 +1810,29 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 	// The SDK lifecycle callbacks that drive the unified tree for one strategy run rooted at
 	// `rootId` — shared by /orchestrate, the council tool, and each flow phase. Seeds running
 	// cores, flips ⏳ → ✓/✗ with usage, streams progress, and registers stop/steer handles.
-	function strategyTreeDeps(ctx: ExtensionContext, rootId: string, nodeParticipants: ReadonlyMap<string, ModelParticipant | null> = new Map(), tracked?: TrackedRun) {
+	function strategyTreeDeps(rootId: string, models: StrategyModels, tracked?: TrackedRun) {
 		return {
-			onAgentStart: (agent: string, abort: () => void, key?: string) => {
-				stopRegistry.set(`${rootId}/${key ?? agent}`, abort);
+			onAgentStart: (_agent: string, abort: () => void, key: string) => {
+				stopRegistry.set(`${rootId}/${key}`, abort);
+			},
+			onAgentSteerable: (_agent: string, steer: SteerFn, key: string) => {
+				steerRegistry.set(`${rootId}/${key}`, steer);
 			},
-			onAgentSteerable: (agent: string, steer: SteerFn, key?: string) => {
-				steerRegistry.set(`${rootId}/${key ?? agent}`, steer);
-			},
-			onAgentStatus: (agent: string, st: AgentStatus, result?: AgentResult, key?: string) => {
-				const nodeKey = key ?? agent;
-				const id = `${rootId}/${nodeKey}`;
+			onAgentStatus: (_agent: string, st: AgentStatus, result: AgentResult | undefined, nodeKey: string, identity: AgentAttemptIdentity) => {
+				const id = `${rootId}/${nodeKey}`;
+				const metadata = strategyLegMetadata(identity, models, result);
 				if (st === "running") {
 					// detail "" clears the seeded "queued" marker — this core is actually live now.
 					// Stamp the clock here too: the seed's stamp (from AgentTree.add's upsert) is queue
 					// time, not run time, so a queued leg would otherwise show elapsed time it never
 					// spent running and could raise a false stall badge once it goes live.
 					const now = Date.now();
-					const participant = participantForNode(nodeParticipants, nodeKey);
-					const assignmentKey = participant?.key ?? bareAssignmentKey(nodeKey);
-					agentTree.add({ id, label: coreLabel(ctx, agent, nodeKey, assignmentKey, participant), parentId: rootId, status: "running", kind: "subagent", ...coreTelemetryMeta(ctx, agent, assignmentKey, participant), detail: "", startedAt: now, lastAdvanceAt: now });
+					agentTree.add({ id, label: coreLabel(identity, nodeKey, metadata), parentId: rootId, status: "running", kind: "subagent", ...metadata, detail: "", startedAt: now, lastAdvanceAt: now });
 					return;
 				}
 				stopRegistry.delete(id);
 				steerRegistry.delete(id);
-				const patch: { status: AgentNodeStatus; detail?: string; output?: string; thinkingEffective?: ThinkingLevel } = { status: st };
+				const patch: AgentNodePatch = { status: st, ...metadata };
 				if (result) {
 					const u = formatUsage(result.usage);
 					if (u) patch.detail = u;
@@ -1866,12 +1841,11 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 					// stays up (siblings still going) the row honestly reads `xh→h`; once the run ends the
 					// removal makes it a one-frame flash. effortTag renders the divergence only when the
 					// requested side exists and differs, so an unstamped request shows nothing extra.
-					if (result.thinkingEffective) patch.thinkingEffective = result.thinkingEffective;
-				}
-				agentTree.update(id, patch);
+				}
+				agentTree.add({ id, label: coreLabel(identity, nodeKey, metadata), parentId: rootId, ...patch });
 			},
-			onAgentProgress: (agent: string, p: AgentProgress, key?: string) => {
-				const id = `${rootId}/${key ?? agent}`;
+			onAgentProgress: (_agent: string, p: AgentProgress, key: string) => {
+				const id = `${rootId}/${key}`;
 				if (p.toolEvent) publishAgentTool(id, p.toolEvent);
 				const now = Date.now();
 				agentTree.update(id, progressPatch(p, now));
@@ -1916,7 +1890,6 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 		const label = resolveStrategyName(orch) ?? "strategy";
 		const roster = resolveOrchestrationMembers(orch, teams);
 		const participants = runParticipants(ctx, { strategy: label, ...(orch.params ? { params: orch.params } : {}), members: roster });
-		const participantsByNode = participantByNode(participants);
 		results.activate(ctx);
 		const { rootId, signal, live } = visibleRoot(`${idPrefix}:${label}`, tracked);
 		const capture = results.bind(rootId);
@@ -1928,25 +1901,26 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 		agentTree.add({ id: rootId, label, status: "running", kind: "council", ...live });
 		try {
 			await ensurePersonaModels(ctx, participants, signal, rootId, tracked);
-			if (signal.aborted) {
+			if (signal.aborted) {
 				agentTree.update(rootId, { status: "stopped" });
 				const cancelled: AgentResult = { agent: label, output: "cancelled before orchestration started", usage: emptyUsage(), ok: false, error: "cancelled", failureKind: "abort" };
-				return finish(cancelled);
-			}
+				return finish(cancelled);
+			}
+			const models = currentStrategyModels(ctx);
+			const engine = buildEngine(signal, undefined, { providerFallback: false, async: tracked?.background === true });
 			// Seed the whole roster at once (cores show by name immediately); "queued" until the
 			// engine actually starts each one — an honest view under the concurrency limit.
 			const seedKeys = rosterNodeKeys(roster);
-			roster.forEach((m, i) => {
-				const a = rosterSpec(m).agent;
-				const key = seedKeys[i] ?? a;
-				const participant = participantForNode(participantsByNode, key);
-				const assignmentKey = participant?.key ?? bareAssignmentKey(key);
-				agentTree.add({ id: `${rootId}/${key}`, label: coreLabel(ctx, a, key, assignmentKey, participant), parentId: rootId, status: "running", kind: "subagent", ...coreTelemetryMeta(ctx, a, assignmentKey, participant), detail: "queued" });
+			roster.forEach((m, i) => {
+				const identity = agentAttemptIdentity(rosterSpec(m));
+				const key = seedKeys[i] ?? identity.agent;
+				const metadata = strategyLegMetadata(identity, models);
+				agentTree.add({ id: `${rootId}/${key}`, label: coreLabel(identity, key, metadata), parentId: rootId, status: "running", kind: "subagent", ...metadata, detail: "queued" });
 			});
 			// The signal goes to the STRATEGY as well as the engine: a multi-round strategy checks it
 			// cooperatively between rounds, so an aborted run stops convening instead of running every
 			// remaining round against an already-cancelled engine (docs/STRATEGIES.md).
-			const result = await runPersonaStrategy(orch, task, { engine: buildEngine(signal, undefined, { providerFallback: false, async: tracked?.background === true }), teams, limits: RUN_LIMITS, ...sessionModelDep(ctx), signal, ...strategyTreeDeps(ctx, rootId, participantsByNode, tracked), onAgentResult, ...strategySpawnGate(), ...modelFallbackDep(ctx) });
+			const result = await runPersonaStrategy(orch, task, { engine, teams, limits: RUN_LIMITS, ...sessionModelDep(ctx), signal, ...strategyTreeDeps(rootId, models, tracked), onAgentResult, ...strategySpawnGate(), ...modelFallbackDep(ctx) });
 			agentTree.update(rootId, { status: signal.aborted ? "stopped" : result?.ok === false ? "failed" : "done" });
 			return finish(result ?? { agent: label, output: "", ok: false, usage: emptyUsage(), error: "No strategy result", failureKind: "contract" });
 		} catch (error) {
@@ -2113,34 +2087,32 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 					if (result?.error) patch.detail = result.error;
 					agentTree.update(`${flowRoot}/${id}`, patch);
 				},
-				runPhase: async ({ phase, task, resultRefs }) => {
+				runPhase: async ({ phase, task, resultRefs }) => {
 					const pid = `${flowRoot}/${phase.id}`;
 					const plan = phasePlans.get(phase.id) ?? { members: [], participants: [] };
 					const roster = plan.members;
 					const seedKeys = rosterNodeKeys(roster);
-					const participantsByNode = participantByNode(plan.participants);
-					roster.forEach((m, i) => {
-						const a = rosterSpec(m).agent;
-						const key = seedKeys[i] ?? a;
-						const participant = participantForNode(participantsByNode, key);
-						const assignmentKey = participant?.key ?? bareAssignmentKey(key);
-						agentTree.add({ id: `${pid}/${key}`, label: coreLabel(ctx, a, key, assignmentKey, participant), parentId: pid, status: "running", kind: "subagent", ...coreTelemetryMeta(ctx, a, assignmentKey, participant), detail: "queued" });
+					const models = currentStrategyModels(ctx);
+					// Pin reference grants at the engine seam, beside the same frozen model selection
+					// used for phase seeds and live attempts. Strategies cannot enlarge these grants.
+					const phaseEngine = spec.handoff === "reference"
+						? withResultRefs(buildEngine(signal, undefined, { providerFallback: false, async: tracked?.background === true }), resultRefs)
+						: buildEngine(signal, undefined, { providerFallback: false, async: tracked?.background === true });
+					roster.forEach((m, i) => {
+						const identity = agentAttemptIdentity(rosterSpec(m));
+						const key = seedKeys[i] ?? identity.agent;
+						const metadata = strategyLegMetadata(identity, models);
+						agentTree.add({ id: `${pid}/${key}`, label: coreLabel(identity, key, metadata), parentId: pid, status: "running", kind: "subagent", ...metadata, detail: "queued" });
 					});
 					const orch: OrchestrationGrammar = { mode: "strategy", strategy: phase.strategy, params: phase.params ?? {} };
 					if (phase.roster) orch.roster = phase.roster;
-					// Reference handoff (trusted grant wiring): the phase's legs get EXACTLY the direct
-					// upstream refs flow-run threaded through `runPhase` - pinned at the engine seam, so
-					// a strategy can neither enlarge nor smuggle refs (the SDK strips its own attempts).
-					const phaseEngine = spec.handoff === "reference"
-						? withResultRefs(buildEngine(signal, undefined, { providerFallback: false, async: tracked?.background === true }), resultRefs)
-						: buildEngine(signal, undefined, { providerFallback: false, async: tracked?.background === true });
 					const r = await runPersonaStrategy(orch, task, {
 						engine: phaseEngine,
 						teams,
 						limits: RUN_LIMITS,
 						...sessionModelDep(ctx),
 						signal, // cooperative per-round abort inside the phase's strategy, not just the engine
-						...strategyTreeDeps(ctx, pid, participantsByNode, tracked),
+						...strategyTreeDeps(pid, models, tracked),
 						onAgentResult: (result, key) => { result.resultReceipt = capture(`phase:${phase.id}:leg:${key}`, result); },
 						...strategySpawnGate(),
 						...modelFallbackDep(ctx),
@@ -2378,7 +2350,9 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 		return lines.join("\n");
 	}
 
-	const hookHost: HookHost = {
+	const hookHost: HookHost = {
+		companionActivities,
+		memoryOwner,
 		identity,
 		results,
 		get config() { return config; },
@@ -2463,7 +2437,16 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 
 	// ONE launch pool for every background run: a delegate leg, a `council` and a `flow` each take a slot
 	// (maxConcurrency). The strategy SDK's own per-run semaphore gates the legs INSIDE a council or flow.
-	const launchPool = new Semaphore(RUN_LIMITS.maxConcurrency);
+	const launchPool = new Semaphore(RUN_LIMITS.maxConcurrency);
+	installMindWorker(pi, {
+		context: () => disposed ? undefined : lastCtx,
+		canLaunch: () => {
+			const caps = controller.capabilities;
+			if (caps && (!canFanOut(caps) || !canCallTool(caps, "memory"))) return "persona denies memory or delegation tools";
+			return isAllowed("mind", controller.activePersona?.delegate, config.delegateDefaultAllow) || "persona denies delegation to mind; the delegate target rules must allow mind";
+		},
+		tracker, tree: agentTree, slots: launchPool, stopRegistry, steerRegistry, buildEngine, startPeek,
+	});
 	const backgroundRuns = createBackgroundRuns({
 		tracker,
 		agentTree,

package/src/orchestration/agent-attempt.ts

@@ -0,0 +1,15 @@
+/** Exact metadata for one engine attempt; display hints are never participant identities. */
+import type { ThinkingLevel } from "../core/types.ts";
+
+export interface AgentAttemptIdentity {
+	readonly agent: string;
+	readonly role?: string;
+	readonly model?: string;
+	readonly thinking?: ThinkingLevel;
+}
+
+/** Copy primitives only: no task, tool grants, result references or mutable caller object. */
+export function agentAttemptIdentity(spec: AgentAttemptIdentity): AgentAttemptIdentity {
+	return Object.freeze({ agent: spec.agent, ...(spec.role !== undefined ? { role: spec.role } : {}),
+		...(spec.model !== undefined ? { model: spec.model } : {}), ...(spec.thinking !== undefined ? { thinking: spec.thinking } : {}) });
+}

package/src/orchestration/flow-run.ts

@@ -161,7 +161,10 @@ function buildPhaseTask(baseTask: string, spec: FlowSpec, phase: FlowPhase, upst
 			parts.push(`\n--- ${id} ---`);
 			parts.push(`status: ${r.ok ? "done" : "failed"}`);
 			if (ref === undefined) {
-				parts.push(`result reference unavailable: ${r.output.slice(0, 200) || "(no output)"}`);
+				const preview = r.output.slice(0, 200);
+				parts.push(preview
+					? `result reference unavailable:\n${fenceUntrusted(preview)}`
+					: "result reference unavailable: (no output)");
 				continue;
 			}
 			parts.push(`result ref: ${ref}`);

package/src/orchestration/sdk.ts

@@ -13,6 +13,7 @@ import { planModelRecovery } from "./model-retry.ts";
 import { mapWithConcurrency, Semaphore } from "./parallel.ts";
 import { aggregateResults, sumUsage } from "./reducers.ts";
 import { roleHint, type RosterMember } from "./roster.ts";
+import { agentAttemptIdentity, type AgentAttemptIdentity } from "./agent-attempt.ts";
 import type { AgentResult, ModelRecovery } from "./types.ts";
 import { type ReducerResult, type VoteOpts, voteReduce } from "./voting.ts";
 
@@ -199,17 +200,17 @@ export interface SDKDeps {
 	/** Per-agent lifecycle, for live UI. The result is passed on done/failed so the
 	 *  UI can capture each agent's output/usage. `key` is a run-unique display id (the
 	 *  `agent` name for a solo member, disambiguated by role/occurrence when the same agent
-	 *  runs several times in one roster) — key the UI node by it, not by `agent`, or three
-	 *  same-agent roster-role members collapse into one node. Falls back to `agent`. */
-	onAgentStatus?: (agent: string, status: AgentStatus, result?: AgentResult, key?: string) => void;
+	 *  runs several times in one roster). The frozen `attempt` carries exact full-role/model/effort
+	 *  identity: never recover those fields by parsing this shortened display key. */
+	onAgentStatus?: (agent: string, status: AgentStatus, result: AgentResult | undefined, key: string, attempt: AgentAttemptIdentity) => void;
 	/** One final logical leg after model recovery, never intermediate attempts. Storage is non-fatal. */
-	onAgentResult?: (result: AgentResult, key: string) => void;
+	onAgentResult?: (result: AgentResult, key: string, attempt: AgentAttemptIdentity) => void;
 	/** Per-agent streaming progress (rolling output), for live UI. See `onAgentStatus.key`. */
-	onAgentProgress?: (agent: string, progress: AgentProgress, key?: string) => void;
+	onAgentProgress?: (agent: string, progress: AgentProgress, key: string, attempt: AgentAttemptIdentity) => void;
 	/** Called as each agent starts with a handle to abort just that agent (for UI stop). */
-	onAgentStart?: (agent: string, abort: () => void, key?: string) => void;
+	onAgentStart?: (agent: string, abort: () => void, key: string, attempt: AgentAttemptIdentity) => void;
 	/** Called once an agent is live with a handle to steer it (in-process engine only). */
-	onAgentSteerable?: (agent: string, steer: SteerFn, key?: string) => void;
+	onAgentSteerable?: (agent: string, steer: SteerFn, key: string, attempt: AgentAttemptIdentity) => void;
 	/** Emitted immediately BEFORE a leg is re-run on the main model after a model-caused failure,
 	 *  so live UI can say so while it happens (`key` is the same logical node as the attempt it
 	 *  replaces). Purely cosmetic: a throw here is contained and can never discard the billed
@@ -303,8 +304,9 @@ export function makeSDK(deps: SDKDeps): StrategySDK {
 			// seam via `withResultRefs`, which runs BELOW this layer).
 			const spec = requested.resultRefs === undefined ? requested : stripResultRefs(requested);
 			const key = uiKeyFor(spec);
+			let currentAttempt = agentAttemptIdentity(spec);
 			const finish = (result: AgentResult): AgentResult => {
-				try { deps.onAgentResult?.(result, key); } catch { /* storage must not discard a completed leg */ }
+				try { deps.onAgentResult?.(result, key, currentAttempt); } catch { /* storage must not discard a completed leg */ }
 				return result;
 			};
 			if (deps.canSpawn && !deps.canSpawn(spec.agent)) {
@@ -338,6 +340,8 @@ export function makeSDK(deps: SDKDeps): StrategySDK {
 				const detachRoot: Array<() => void> = [];
 				let announcedStart = false;
 				const attempt = async (aSpec: AgentRunSpec): Promise<AgentResult> => {
+					const identity = agentAttemptIdentity(aSpec);
+					currentAttempt = identity;
 					const ac = current ?? new AbortController();
 					current = ac;
 					if (deps.signal) {
@@ -348,9 +352,9 @@ export function makeSDK(deps: SDKDeps): StrategySDK {
 					}
 					if (!announcedStart) {
 						announcedStart = true;
-						deps.onAgentStart?.(aSpec.agent, () => current?.abort(), key);
+						deps.onAgentStart?.(aSpec.agent, () => current?.abort(), key, identity);
 					}
-					deps.onAgentStatus?.(aSpec.agent, "running", undefined, key);
+					deps.onAgentStatus?.(aSpec.agent, "running", undefined, key, identity);
 					// A slot grant is not an engine start. Root or local cancellation in a lifecycle
 					// callback must prevent the engine invocation, not merely hand it an aborted signal.
 					if (ac.signal.aborted) {
@@ -366,9 +370,9 @@ export function makeSDK(deps: SDKDeps): StrategySDK {
 					try {
 						result = await deps.engine.run(
 							aSpec,
-							onProgress ? (p) => onProgress(aSpec.agent, p, key) : undefined,
+							onProgress ? (p) => onProgress(aSpec.agent, p, key, identity) : undefined,
 							ac.signal,
-							deps.onAgentSteerable ? (steer) => deps.onAgentSteerable?.(aSpec.agent, steer, key) : undefined,
+							deps.onAgentSteerable ? (steer) => deps.onAgentSteerable?.(aSpec.agent, steer, key, identity) : undefined,
 						);
 					} catch (err) {
 						// PER-LEG failure — contained, never rethrown: one blown engine call must not discard
@@ -385,7 +389,7 @@ export function makeSDK(deps: SDKDeps): StrategySDK {
 				};
 				try {
 					const first = await attempt(spec);
-					deps.onAgentStatus?.(spec.agent, first.ok ? "done" : "failed", first, key);
+					deps.onAgentStatus?.(spec.agent, first.ok ? "done" : "failed", first, key, currentAttempt);
 
 					// ── Main-only model recovery ──────────────────────────────────────────────
 					// A model-caused failure (`provider`/`unknown-model`) gets exactly ONE re-run on the
@@ -427,7 +431,7 @@ export function makeSDK(deps: SDKDeps): StrategySDK {
 					// a fresh controller or spend another child slot after it has been stopped.
 					if (deps.signal?.aborted || current?.signal.aborted) {
 						const stopped = { ...abortedLeg(spec.agent), usage: first.usage };
-						deps.onAgentStatus?.(spec.agent, "failed", stopped, key);
+						deps.onAgentStatus?.(spec.agent, "failed", stopped, key, currentAttempt);
 						return stopped;
 					}
 					// The retry is a REAL attempt: admitted and charged like any other child, but inside
@@ -444,7 +448,7 @@ export function makeSDK(deps: SDKDeps): StrategySDK {
 						modelRecovery: recovery,
 						...(!second.ok ? { error: `Initial model ${plan.from ?? "(unresolved)"} failed: ${first.error ?? first.failureKind ?? "unknown cause"}; main model ${plan.to} failed: ${second.error ?? second.failureKind ?? "unknown cause"}` } : {}),
 					};
-					deps.onAgentStatus?.(spec.agent, settled.ok ? "done" : "failed", settled, key);
+					deps.onAgentStatus?.(spec.agent, settled.ok ? "done" : "failed", settled, key, currentAttempt);
 					return settled;
 				} finally {
 					for (const detach of detachRoot) detach();