@aeondave/pi-persona 1.16.2 → 1.17.0

package/CHANGELOG.md

@@ -6,6 +6,40 @@ used in its [GitHub releases](https://github.com/AeonDave/pi-persona/releases).
 
 ## [Unreleased]
 
+## [1.17.0](https://github.com/AeonDave/pi-persona/releases/tag/v1.17.0) - 2026-10-19
+
+### Added
+
+- `/persona models [council-persona]` refreshes the host catalog and reopens model selection for
+  the active caller's council participants, preserving cancelled choices, unrelated assignments,
+  and explicit inline model pins. No supervisor switch or model request is required.
+- A hermetic installed-host Pi 1.3.0 qualification script covers real command dispatch, assignment
+  persistence, custom-message starts and missing-auth council recovery without network requests.
+
+### Fixed
+
+- Publish terminal progress for single delegates before removing their tree node, preserving `done`
+  status in Flow and other telemetry consumers.
+- Preserve Exocom reply references and optional target-correlated transport IDs while keeping each
+  queued/terminal telemetry row stable; retain bounded broadcast delivery receipts.
+- Report an exact acknowledged broadcast receipt as delivered even when failures for other peers
+  exceed the retained sample; recipients without exact evidence remain conservatively unknown.
+- Classify Pi's `No API key found for <provider>` diagnostic as a provider failure in both engines,
+  allowing the existing single main-model recovery for councils/strategies/flows. Ordinary delegate
+  provider pins remain strict; aborts, timeouts, contract and agent failures remain terminal.
+- Report a refused persona model switch instead of silently recording an override when Pi rejects
+  it for missing authentication; keep the actual session model and restoration state intact.
+- Remove a timing race from the supervisor-ask telemetry test: verify the persisted timeout
+  transition history rather than polling a transient 20 ms state through asynchronous disk writes.
+
+## [1.16.3](https://github.com/AeonDave/pi-persona/releases/tag/v1.16.3) - 2026-10-13
+
+### Fixed
+
+- Reject Pi `+name`/`-name` tool modifiers in agent and per-run allowlists before either engine
+  starts. Those selectors are literal allowlist entries in pi-persona; Pi 1.2 instead applies them
+  to its default tools. Use `deny` or `excludeTools` for denials.
+
 ## [1.16.2](https://github.com/AeonDave/pi-persona/releases/tag/v1.16.2) - 2026-10-08
 
 ### Fixed

package/README.md

@@ -39,9 +39,9 @@ your customizations.
 | Install option | Command |
 |---|---|
 | This project only | `pi install -l npm:@aeondave/pi-persona` |
-| Pin this release | `pi install npm:@aeondave/pi-persona@1.16.2` |
+| Pin this release | `pi install npm:@aeondave/pi-persona@1.17.0` |
 | Update an unpinned install | `pi update npm:@aeondave/pi-persona` |
-| Git alternative | `pi install git:github.com/AeonDave/pi-persona@v1.16.2` |
+| Git alternative | `pi install git:github.com/AeonDave/pi-persona@v1.17.0` |
 
 Restart Pi after updating. For a pinned install, install the new version or tag explicitly.
 If switching from a Git install, remove that source first with
@@ -91,6 +91,7 @@ the worker has acted on it.
 | `/peek` | Show a compact progress summary |
 | `/persona list` | List installed personas |
 | `/persona off` | Turn off the active persona |
+| `/persona models [council-persona]` | Refresh the catalog and reselect council models for the active persona |
 | `/models <query>` | Find an available model |
 | `/doctor` | Check configuration and available capabilities |
 
@@ -151,6 +152,8 @@ Strategies are not restricted to the similarly named persona: `council` can sele
 custom role-based groups without team files. Model selection includes external arbiters. In councils
 and flows, a provider failure or unavailable model can recover once on the supervisor's model, with
 the switch visible and both attempts accounted; ordinary delegates keep explicit provider pins strict.
+To replace old council assignments without changing supervisors, run `/persona models magi`
+(or `/persona models` for the active council). Cancel a choice to keep its previous value.
 See [the reference](docs/REFERENCE.md) for an inline council example and recovery limits.
 
 ## Make it yours
@@ -187,6 +190,8 @@ npm test
 ```
 
 Pi loads the TypeScript extension directly; there is no build step.
+To qualify a separately installed Pi 1.3.0 host without cloud calls or your profile, run
+`node --import tsx scripts/qualify-host.mjs <absolute-path-to-pi-coding-agent-package>`.
 The [CI workflow](https://github.com/AeonDave/pi-persona/actions/workflows/test.yml) runs strict
 typechecking, dependency auditing and the test suite on Linux and Windows. The OpenSSF badge links to the project's
 scored supply-chain checks; it is not a certification that the code is free of vulnerabilities.

package/docs/ARCHITECTURE.md

@@ -300,6 +300,19 @@ inline model pins taking precedence. If distinct full roles share a short displa
 keeps the hint (with `#N` suffixes for repeated node keys) but omits the uncertain model label rather
 than borrowing another role's choice. Routing still resolves the full role key, not the display hint.
 
+**Model assignment repair is configuration, not execution recovery.** `/persona models [profile]`
+is an explicit user edit in the Pi adapter: it reuses `resolveCouncilInvocation`,
+`collectModelParticipants` and the existing locked config writer, without adding another roster,
+model store or provider-routing policy. The active caller owns saved assignments even when borrowing
+another council profile. Automatic discovery stays never-nag; explicit editing may replace saved or
+agent defaults, but not inline pins. Host catalog refresh has a 20-second cooperative deadline;
+reported cancellation/errors or a caller/session change leave assignments untouched. Selection uses
+the refreshed host availability snapshot rather than treating all catalog entries as authenticated.
+Cancelled rows preserve their old choices; accepted choices merge without clearing other personas.
+Running engines retain their captured assignments. Missing credentials are classified at the engine
+adapter boundary; only the SDK decides whether a main-model recovery is admissible. This separation
+avoids a global reset or automatic repinning that could silently change billing and panel diversity.
+
 ### MCP (and other `session_start`-scoped extensions) in sub-agents
 
 **A sub-agent does NOT share the supervisor's MCP session, and an in-process sub-agent gets NO MCP at

package/docs/REFERENCE.md

@@ -189,9 +189,11 @@ files are seed sources. A fresh install has no installed personas until `/person
 | Preset | `presets/*.preset.json` | reusable council strategy, roster, and parameter bundle |
 
 `tools` accepts an allowlist such as `[read, grep]`, an `allow`/`deny` object, or `[]` for no tools.
-Omit it to inherit the session tool set. `model`, `isolation: worktree`, `mcp: true`, and `purpose`
-are optional agent metadata. The body is the agent prompt. Inline roster members specialise one
-agent with a role, model, or skills without requiring another agent file.
+Entries are plain tool names or `*` patterns; Pi's `+name`/`-name` default-tool modifier
+syntax is not an allowlist and is rejected. Use the `deny` field to remove tools. Omit `tools` to
+inherit the session tool set. `model`, `isolation: worktree`,
+`mcp: true`, and `purpose` are optional agent metadata. The body is the agent prompt. Inline roster
+members specialise one agent with a role, model, or skills without requiring another agent file.
 
 ### Multi-agent quick start
 
@@ -301,10 +303,28 @@ With an active persona, UI, and at least two configured models, unassigned parti
 picked and saved for the active persona, even when borrowing another persona's council profile.
 Dismissing a picker suppresses another prompt for that participant during the session, not for
 later teams with different participants. Headless runs never prompt.
+
+Run `/persona models` to explicitly reselect the active council's models, or `/persona models magi`
+to edit the MAGI panel while keeping another supervisor active. The optional name selects an
+installed council persona, not a strategy or team. The command refreshes the host catalog first,
+then offers each editable participant, including previously dismissed choices and saved or agent
+defaults. One available model is enough for this explicit edit. Choices are saved under the **active
+caller's** persona, just as for `council({ persona: "magi" })`; it never activates the borrowed
+profile. Cancelled choices, unrelated assignments and other personas remain unchanged. Inline
+`members[].model` pins still win and are not editable here. TUI/RPC UI is required; no model call
+is made. Changes apply to future runs, not workers already running. `/persona magi` still switches
+the supervisor; `/persona reload` reloads definitions without resetting saved models.
+Refresh is bounded to 20 seconds cooperatively; provider errors, cancellation, or a persona/session
+change cancel the edit without replacing assignments. The list uses the host's refreshed availability,
+not every model in its catalog.
+
 An unavailable choice is not overwritten: a provider or unknown-model failure may recover once
 on the main model, with the switch reported and both attempts accounted. This does not relax
 ordinary delegate provider pins. The MAGI persona retains its canonical core team; the Judge
 persona retains impartial arbitration. Other personas choose whichever strategy fits the task.
+The exact Pi diagnostic `No API key found for <provider>` counts as a provider failure in both
+engines, so it can use this same bounded recovery. If the main model is the failing model too,
+recovery cannot help: use `/login` or change `/model`, then reselect with `/persona models`.
 
 **A delegation policy on any persona** — fields are generic and are never keyed to a persona name.
 The runtime rejects incomplete briefs before a model call, supplies a missing contract, rejects

package/docs/TELEMETRY.md

@@ -8,6 +8,14 @@ waiting from tool arguments, output text or a quiet clock.
 
 Telemetry is a vendor-neutral v2 envelope. `producerId` and `producerVersion` identify the emitting plugin; `version` identifies the wire schema. `seq` is monotonic only within `(producerId, sessionId)`, and `id` is deduplicated within that same scope.
 
+Message payload `id` is the stable lifecycle-row key: queued and terminal updates keep it unchanged.
+Optional `wireId` identifies the actual transport message, and `replyTo` references that transport's
+original ID. Exocom sends attach `wireId` only after an exact target-correlated successful receipt;
+broadcast receipts are bounded and omitted mappings remain unknown. Do not replace the queued row's
+`id` with a wire ID, infer a mapping by timestamp/alias, or merge observations from different streams.
+Single delegates publish their terminal progress before tree removal, so a completed worker remains
+`done` in the telemetry instead of being mistaken for a stopped in-flight leg.
+
 The pi-persona producer writes semantic projections under `telemetry/v2/<workspace>/<producerId>/`. `<workspace>` always identifies the Pi process's actual cwd; joining another Exocom scope does not rewrite telemetry identity. It never persists task/prompt text, tool arguments/activity, model output, paths, secrets, or message bodies. Known pi-persona event payloads are allowlisted; an unreviewed producer event retains only its envelope/type (payload `{}`) at the producer and consumer boundary. Future producers must add a reviewed allowlist/schema before publishing data intended for a consumer.
 
 JSONL compaction is atomic and hysteretic. It preserves the initial `instance.started` anchor and complete records; the configured byte limit is therefore a soft bound for an anchor plus one complete event. The `.previous` backup is recovered after an interrupted swap.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeondave/pi-persona",
-  "version": "1.16.2",
+  "version": "1.17.0",
   "private": false,
   "type": "module",
   "description": "Supervised multi-agent orchestration for Pi — async workers, live steering, cross-session collaboration, and switchable personas.",
@@ -104,7 +104,7 @@
     "typescript": "^7.0.2"
   },
   "pi": {
-    "image": "https://raw.githubusercontent.com/AeonDave/pi-persona/v1.16.2/assets/banner.png",
+    "image": "https://raw.githubusercontent.com/AeonDave/pi-persona/v1.17.0/assets/banner.png",
     "video": "https://cdn.jsdelivr.net/gh/AeonDave/pi-persona@6655d281ce7965a75303dd704bd29db73db04070/assets/demo1.mp4",
     "extensions": [
       "./src/extension.ts"

package/src/engine/adapter.ts

@@ -18,7 +18,7 @@ import { type ChildEngineOptions, type ChildRunSpec, runChildAgent } from "./chi
 import { looksLikeProviderError } from "./errors.ts";
 import { nextChildHandle } from "./handles.ts";
 import { combineSignals } from "./signals.ts";
-import { unknownAgentFailure, unknownContractFailure } from "./spec-preflight.ts";
+import { toolModifierFailure, unknownAgentFailure, unknownContractFailure } from "./spec-preflight.ts";
 import type { ToolEvent } from "./stream.ts";
 
 /** The engine-side face of the cross-process broker (spec B3/B4/B7) — a child-engine
@@ -113,6 +113,9 @@ export function makeEngine(deps: EngineAdapterDeps): StrategyEngine {
 		): Promise<AgentResult> {
 			const cfg = deps.resolveAgent(spec.agent);
 			if (!cfg) return unknownAgentFailure(spec.agent, deps.listAgents?.() ?? []);
+			const tools = spec.tools ?? cfg.tools;
+			const invalidTools = toolModifierFailure(spec.agent, tools);
+			if (invalidTools) return invalidTools;
 
 			// Resolved (and pinned) up front: the SAME def both instructs the member and
 			// validates its output — an instruction/validation drift is impossible. A named
@@ -132,7 +135,6 @@ export function makeEngine(deps: EngineAdapterDeps): StrategyEngine {
 			// a child without it defaults to "adaptive", which some models reject.
 			if (model && deps.childThinking && !model.includes(":")) model = `${model}:${deps.childThinking}`;
 			if (model) childSpec.model = model;
-			const tools = spec.tools ?? cfg.tools;
 			if (tools !== undefined) childSpec.tools = tools;
 			if (cfg.excludeTools && cfg.excludeTools.length > 0) childSpec.excludeTools = cfg.excludeTools;
 			// The shared behavioral layer (docs/SPINE.md) + the agent's own persona + any

package/src/engine/errors.ts

@@ -19,6 +19,7 @@ const PROVIDER_PATTERNS: readonly RegExp[] = [
 	/\brate.?limit|\b429\b|too many requests/i,
 	/\bquota\b|billing|insufficient.?credits/i,
 	/\b401\b|\b403\b|unauthorized|invalid[\s_-]?api[\s_-]?key/i,
+	/\bno api key found for [a-z0-9][a-z0-9._-]*\b/i,
 	/\b5\d\d\b|internal server error|bad gateway|service unavailable|gateway timeout|overloaded|capacity/i,
 	/model.{0,24}(not.{0,8}(supported|found|exist)|does not exist)|unsupported.{0,12}model/i,
 	/\beconnreset\b|\betimedout\b|\beconnrefused\b|socket hang up|fetch failed/i,

package/src/engine/inproc.ts

@@ -35,7 +35,7 @@ import type { AgentResult } from "../orchestration/types.ts";
 import { looksLikeProviderError } from "./errors.ts";
 import { nextChildHandle } from "./handles.ts";
 import { combineSignals } from "./signals.ts";
-import { unknownAgentFailure, unknownContractFailure } from "./spec-preflight.ts";
+import { toolModifierFailure, unknownAgentFailure, unknownContractFailure } from "./spec-preflight.ts";
 import { applyEvent, createStreamState, emptyUsage, type ProgressSnapshot, snapshot } from "./stream.ts";
 
 /** The minimal slice of Pi's AgentSession the engine drives — also the test seam. */
@@ -315,6 +315,9 @@ export function makeInProcessEngine(deps: InProcessDeps): StrategyEngine {
 		async run(spec: AgentRunSpec, onProgress?, callSignal?, onSteerable?): Promise<AgentResult> {
 			const cfg = deps.resolveAgent(spec.agent);
 			if (!cfg) return unknownAgentFailure(spec.agent, deps.listAgents?.() ?? []);
+			const tools = spec.tools ?? cfg.tools;
+			const invalidTools = toolModifierFailure(spec.agent, tools);
+			if (invalidTools) return invalidTools;
 			// A requested contract is a runtime guard, not merely prompt decoration. Resolve it
 			// before model/session construction so a missing name can never run unconstrained.
 			const requestedContract = spec.outputContract?.trim();
@@ -346,7 +349,6 @@ export function makeInProcessEngine(deps: InProcessDeps): StrategyEngine {
 			const rm = model as { provider?: string; id?: string };
 			const resolvedRef = rm.provider && rm.id ? `${rm.provider}/${rm.id}` : ref;
 			const thinkingLevel = isThinkingLevel(deps.childThinking) ? deps.childThinking : undefined;
-			const tools = spec.tools ?? cfg.tools;
 			const excludeTools = cfg.excludeTools;
 
 			// Diagnostic tag: which agent + which model ref + whether it was dynamically

package/src/engine/spec-preflight.ts

@@ -31,3 +31,16 @@ export function unknownAgentFailure(agent: string, installed: string[]): AgentRe
 export function unknownContractFailure(agent: string, requested: string, installed: string[]): AgentResult {
 	return failure(agent, `[${agent}] output contract "${requested}" not found${installedHint("contracts", installed)}`, "contract");
 }
+
+/** Pi's SDK treats leading `+`/`-` entries in `tools` as default-tool modifiers, not as
+ *  literal allowlist entries. AgentRunSpec.tools and agent frontmatter use this field as an
+ *  allowlist, so reject that syntax before either engine reaches Pi. Use excludeTools for denies. */
+export function toolModifierFailure(agent: string, tools: readonly string[] | undefined): AgentResult | undefined {
+	const modifier = tools?.find((selector) => /^[+-]/.test(selector.trim()));
+	if (modifier === undefined) return undefined;
+	return failure(
+		agent,
+		`[${agent}] unsupported tool modifier "${modifier.trim()}" in tools allowlist; use plain tool names/patterns or excludeTools for denials`,
+		"contract",
+	);
+}

package/src/extension/hooks.ts

@@ -61,7 +61,7 @@ export interface HookHost {
 	get telemetry(): TelemetryProducer | undefined;
 	set telemetry(value: TelemetryProducer | undefined);
 	readonly telemetryToolStartedAt: Map<string, { startedAt: number; name: string }>;
-	readonly telemetryExocomPending: Map<string, Array<{ id: string; sessionId: string; target: string; size: number }>>;
+	readonly telemetryExocomPending: Map<string, Array<{ id: string; sessionId: string; target: string; size: number; replyTo?: string }>>;
 	readonly telemetryIntercomPending: Map<string, { kind: string; to: string; size: number; replyTo?: string }>;
 	readonly lastAgentProjection: Map<string, string>;
 	readonly telemetryAskSenders: Map<string, string>;
@@ -306,6 +306,7 @@ export function installHooks(pi: ExtensionAPI, h: HookHost, exocom: ExocomInstal
 				status: "failed",
 				expectsReply: false,
 				size: message.size,
+				...(message.replyTo ? { replyTo: message.replyTo } : {}),
 			});
 		}
 		h.telemetryExocomPending.clear();
@@ -557,6 +558,7 @@ export function installHooks(pi: ExtensionAPI, h: HookHost, exocom: ExocomInstal
 		if (event.toolName === "exocom_send") {
 			const text = typeof input.message === "string" ? input.message : "";
 			const target = typeof input.target === "string" ? input.target : "";
+			const replyTo = typeof input.in_reply_to === "string" && input.in_reply_to.length > 0 ? input.in_reply_to : undefined;
 			let peers: DisplayPeer[] = [];
 			try { peers = exocom.plane?.listPeers() ?? []; } catch { /* h.telemetry cannot break the tool */ }
 			const sessions = canonicalExocomTelemetryTargets(peers, target);
@@ -566,6 +568,7 @@ export function installHooks(pi: ExtensionAPI, h: HookHost, exocom: ExocomInstal
 				sessionId,
 				target: target === "*" ? (peers.find((peer) => peer.session_id === sessionId)?.target ?? sessionId) : target,
 				size,
+				...(replyTo ? { replyTo } : {}),
 			}));
 			if (pending.length > 0) h.telemetryExocomPending.set(event.toolCallId, pending);
 			for (const message of pending) h.telemetry?.publish("message.sent", {
@@ -577,6 +580,7 @@ export function installHooks(pi: ExtensionAPI, h: HookHost, exocom: ExocomInstal
 				status: "queued",
 				expectsReply: false,
 				size: message.size,
+				...(message.replyTo ? { replyTo: message.replyTo } : {}),
 			});
 		}
 		return undefined;
@@ -606,8 +610,24 @@ export function installHooks(pi: ExtensionAPI, h: HookHost, exocom: ExocomInstal
 			const pending = h.telemetryExocomPending.get(event.toolCallId) ?? [];
 			h.telemetryExocomPending.delete(event.toolCallId);
 			const details = event.details && typeof event.details === "object" && !Array.isArray(event.details)
-				? event.details as { failed?: Array<{ target?: unknown }>; failedCount?: unknown; omittedFailures?: unknown }
+				? event.details as {
+					target?: unknown;
+					msg_id?: unknown;
+					sent?: unknown;
+					failed?: Array<{ target?: unknown }>;
+					failedCount?: unknown;
+					omittedFailures?: unknown;
+				}
 				: undefined;
+			const receipts = Array.isArray(details?.sent)
+				? details.sent.flatMap((receipt) => {
+					if (!receipt || typeof receipt !== "object" || Array.isArray(receipt)) return [];
+					const item = receipt as { target?: unknown; msg_id?: unknown };
+					return typeof item.target === "string" && typeof item.msg_id === "string" && item.msg_id.length > 0
+						? [{ target: item.target, msgId: item.msg_id }]
+						: [];
+				})
+				: [];
 			const sampledFailures = details?.failed ?? [];
 			const failedTargets = new Set(sampledFailures.flatMap((failure) => typeof failure.target === "string" ? [failure.target] : []));
 			// A broadcast samples its failures (`MAX_BROADCAST_DETAIL_ITEMS` in tools/exocom.ts) and
@@ -618,16 +638,31 @@ export function installHooks(pi: ExtensionAPI, h: HookHost, exocom: ExocomInstal
 				typeof details?.omittedFailures === "number" ? details.omittedFailures : 0,
 				declaredFailures - sampledFailures.length,
 			);
-			for (const message of pending) h.telemetry?.publish("message.sent", {
-				id: message.id,
-				channel: "exocom",
-				from: exocom.telemetrySessionId(ctx),
-				to: message.sessionId,
-				kind: "message",
-				status: event.isError || failedTargets.has(message.target) ? "failed" : omittedFailures > 0 ? "unknown" : "delivered",
-				expectsReply: false,
-				size: message.size,
-			});
+			for (const message of pending) {
+				const matchingReceipts = !event.isError && details?.target === "*"
+					? receipts.filter((receipt) => receipt.target === message.target)
+					: [];
+				const failed = event.isError || failedTargets.has(message.target);
+				const wireId = failed ? undefined
+					: details?.target === message.target && typeof details.msg_id === "string" && details.msg_id.length > 0
+						? details.msg_id
+						: matchingReceipts.length === 1 ? matchingReceipts[0]!.msgId : undefined;
+				h.telemetry?.publish("message.sent", {
+					id: message.id,
+					channel: "exocom",
+					from: exocom.telemetrySessionId(ctx),
+					to: message.sessionId,
+					kind: "message",
+					// A matching successful ACK receipt settles this recipient even when the bounded
+					// broadcast failure sample omitted failures for other peers. Without a receipt, an
+					// incomplete failure sample cannot prove this particular row was delivered.
+					status: failed ? "failed" : omittedFailures > 0 && wireId === undefined ? "unknown" : "delivered",
+					expectsReply: false,
+					size: message.size,
+					...(message.replyTo ? { replyTo: message.replyTo } : {}),
+					...(wireId ? { wireId } : {}),
+				});
+			}
 		}
 		if (event.toolName === "intercom") {
 			const action = typeof telemetryInput.action === "string" ? telemetryInput.action : "";

package/src/extension.ts

@@ -108,7 +108,7 @@ 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 { type AgentKind as TelemetryAgentKind, type AgentStatus as TelemetryAgentStatus } from "./telemetry/contract.ts";
@@ -549,7 +549,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.
@@ -1013,9 +1013,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) => {
@@ -1383,16 +1383,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 +1443,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,12 +1456,23 @@ 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.
@@ -1432,7 +1484,9 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 				`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
@@ -2139,10 +2193,52 @@ export default function piPersona(pi: ExtensionAPI, options: PiPersonaOptions =
 
 	// ── /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/persona/controller.ts

@@ -30,7 +30,7 @@ export interface PersonaHost {
 	setThinkingLevel(level: ThinkingLevel): void;
 	getModel(): ModelHandle | undefined;
 	findModel(ref: string): ModelHandle | undefined;
-	setModel(model: ModelHandle): void | Promise<void>;
+	setModel(model: ModelHandle): void | boolean | Promise<void | boolean>;
 	setStatus(text: string | undefined): void;
 	/** Optional: a declared-but-unavailable model/thinking would otherwise fail silently. */
 	warn?(message: string): void;
@@ -108,11 +108,24 @@ export class PersonaController {
 		if (persona.model) {
 			const model = this.host.findModel(persona.model);
 			if (model) {
-				if (!this.modelOverridden) {
+				const firstOverride = !this.modelOverridden;
+				if (firstOverride) {
 					this.baselineModel = this.host.getModel();
 					this.modelOverridden = true;
 				}
-				await this.host.setModel(model);
+				const applied = await this.host.setModel(model);
+				if (applied === false) {
+					// Pi's setModel returns false when the provider has no configured auth. Do not
+					// leave a phantom override behind: a later persona or deactivation must not
+					// restore a baseline for a model that never became active.
+					if (firstOverride) {
+						this.modelOverridden = false;
+						this.baselineModel = undefined;
+					}
+					this.host.warn?.(
+						`persona "${persona.name}" declared model "${persona.model}" but provider authentication is not configured; keeping the current model`,
+					);
+				}
 			} else {
 				this.host.warn?.(
 					`persona "${persona.name}" declared model "${persona.model}" which is not configured; keeping the current model`,

package/src/telemetry/contract.ts

@@ -4,7 +4,7 @@ export const TELEMETRY_EVENT_NAME = "pi:telemetry" as const;
 export const LEGACY_TELEMETRY_EVENT_NAME = "pi-persona:telemetry" as const;
 export const LEGACY_TELEMETRY_VERSION = 1 as const;
 export const TELEMETRY_PRODUCER_ID = "pi-persona" as const;
-export const TELEMETRY_PRODUCER_VERSION = "1.16.2" as const;
+export const TELEMETRY_PRODUCER_VERSION = "1.17.0" as const;
 
 export type InstanceStatus = "active" | "idle" | "stopped" | "stale" | (string & {});
 export type AgentKind = "subagent" | "delegate" | "council" | "flow" | "phase" | (string & {});
@@ -54,6 +54,8 @@ export interface MessageDescriptor {
 	expectsReply: boolean;
 	size: number;
 	replyTo?: string;
+	/** Transport-native identity, distinct from `id`, which remains the stable telemetry-row key. */
+	wireId?: string;
 }
 
 export interface PeerDescriptor {
@@ -145,9 +147,9 @@ const KNOWN_FIELDS: Record<string, readonly string[]> = {
 	"instance.stopped": ["reason"], "agent.added": ["id", "label", "kind", "status", "parentId", "agent", "persona", "model"],
 	"agent.updated": ["id", "patch"], "agent.removed": ["id", "status"], "agent.cleared": [],
 	"tool.started": ["callId", "agentId", "name", "status"], "tool.finished": ["callId", "agentId", "name", "status", "durationMs"],
-	"message.sent": ["id", "channel", "from", "to", "kind", "status", "expectsReply", "size", "replyTo"],
-	"message.received": ["id", "channel", "from", "to", "kind", "status", "expectsReply", "size", "replyTo"],
-	"message.replied": ["id", "channel", "from", "to", "kind", "status", "expectsReply", "size", "replyTo"],
+	"message.sent": ["id", "channel", "from", "to", "kind", "status", "expectsReply", "size", "replyTo", "wireId"],
+	"message.received": ["id", "channel", "from", "to", "kind", "status", "expectsReply", "size", "replyTo", "wireId"],
+	"message.replied": ["id", "channel", "from", "to", "kind", "status", "expectsReply", "size", "replyTo", "wireId"],
 	"peers.snapshot": ["peers"],
 };
 
@@ -198,7 +200,7 @@ function validKnownPayload(type: string, payload: Record<string, unknown>): bool
 	if (type === "agent.removed") return stringField(payload, "id") && (payload.status === undefined || ["done", "failed", "stopped"].includes(payload.status as string));
 	if (type === "tool.started") return stringField(payload, "callId") && stringField(payload, "agentId") && stringField(payload, "name") && stringField(payload, "status") && !TERMINAL_TOOL_STATUS.includes(payload.status as string);
 	if (type === "tool.finished") return stringField(payload, "callId") && stringField(payload, "agentId") && stringField(payload, "name") && ["done", "failed"].includes(payload.status as string) && numberField(payload, "durationMs", { min: 0 });
-	if (type === "message.sent" || type === "message.received" || type === "message.replied") return stringField(payload, "id") && stringField(payload, "channel") && stringField(payload, "from") && stringField(payload, "to") && stringField(payload, "kind") && stringField(payload, "status") && typeof payload.expectsReply === "boolean" && numberField(payload, "size", { integer: true, min: 0 }) && (payload.replyTo === undefined || stringField(payload, "replyTo"));
+	if (type === "message.sent" || type === "message.received" || type === "message.replied") return stringField(payload, "id") && stringField(payload, "channel") && stringField(payload, "from") && stringField(payload, "to") && stringField(payload, "kind") && stringField(payload, "status") && typeof payload.expectsReply === "boolean" && numberField(payload, "size", { integer: true, min: 0 }) && (payload.replyTo === undefined || stringField(payload, "replyTo")) && (payload.wireId === undefined || stringField(payload, "wireId"));
 	if (type === "peers.snapshot") return Array.isArray(payload.peers) && payload.peers.every((peer) => { const p = objectPayload(peer); return p !== undefined && stringField(p, "sessionId") && stringField(p, "displayName") && stringField(p, "persona", false) && stringField(p, "model", false) && numberField(p, "contextPercent", { min: 0, max: 100 }) && typeof p.status === "string" && numberField(p, "sent", { integer: true, min: 0 }) && numberField(p, "received", { integer: true, min: 0 }); });
 	return true;
 }

package/src/tools/delegate.ts

@@ -654,7 +654,9 @@ export async function runDelegate(
 			(steer) => onLegSteerable?.(0, steer),
 		);
 		const text = r.ok ? r.output || "(no output)" : `Agent "${params.agent}" failed: ${r.error ?? "(no detail)"}`;
-		return { text, results: [r], views: [viewOf(params.agent, label, r)], ok: r.ok };
+		const terminalView = viewOf(params.agent, label, r);
+		onProgress?.([{ ...terminalView }]);
+		return { text, results: [r], views: [terminalView], ok: r.ok };
 	}
 
 	return { text: "delegate: provide either { agent, task } or { tasks: [{ agent, task }, ...] }", results: [], views: [], ok: false };

package/src/tools/exocom.ts

@@ -36,6 +36,11 @@ export const MAX_BROADCAST_DETAIL_ITEMS = 64;
 const MODEL_BROADCAST_ID_SAMPLE = 12;
 const MODEL_BROADCAST_FAILURE_SAMPLE = 8;
 
+/** Keep a correlation token only when it is already safe and bounded; never truncate a route token. */
+function isExactBoundedMetadataText(value: unknown, max: number): value is string {
+	return typeof value === "string" && value.length > 0 && normalizeMetadataText(value, max, "") === value;
+}
+
 const ExocomListParams = Type.Object({
 	offset: Type.Optional(Type.Integer({ minimum: 0, maximum: 1_000_000, description: "Zero-based page offset into the live peer list." })),
 	limit: Type.Optional(Type.Integer({ minimum: 1, maximum: MAX_MODEL_PEER_ROWS, description: `Maximum peers to show (default ${MAX_MODEL_PEER_ROWS}).` })),
@@ -68,6 +73,8 @@ type ExocomSendDetails =
 		queuedCount: number;
 		failedCount: number;
 		msg_ids: string[];
+		/** Bounded transport receipts, retaining the exact route token needed to correlate each peer. */
+		sent: Array<{ target: string; msg_id: string }>;
 		failed: Array<{ target: string; error: string }>;
 		omittedMsgIds: number;
 		omittedFailures: number;
@@ -386,6 +393,11 @@ export function registerExocomTools(
 					`${normalizeMetadataText(item.target, 80, "peer")}: ${rejectedTargets.has(item.target) ? "rejected by the peer; reason quoted below" : normalizeMetadataText(item.error, 160, "send failed")}`,
 				);
 				const omittedFailures = failed.length - shownFailures.length;
+				const shownReceipts = sent.flatMap((item) =>
+					isExactBoundedMetadataText(item.target, 80) && isExactBoundedMetadataText(item.msg_id, 128)
+						? [{ target: item.target, msg_id: item.msg_id }]
+						: [],
+				).slice(0, MAX_BROADCAST_DETAIL_ITEMS);
 				const action = omittedIds > 0 || omittedFailures > 0
 					? `; ${[
 						shownIds.length > 0 ? `msg_ids: ${shownIds.join(", ")}${omittedIds > 0 ? `; +${omittedIds} more msg_ids omitted` : ""}` : "",
@@ -402,11 +414,12 @@ export function registerExocomTools(
 						queuedCount: sent.length,
 						failedCount: failed.length,
 						msg_ids: sent.slice(0, MAX_BROADCAST_DETAIL_ITEMS).map((item) => normalizeMetadataText(item.msg_id, 128, "msg")),
+						sent: shownReceipts,
 						failed: failed.slice(0, MAX_BROADCAST_DETAIL_ITEMS).map((failure) => ({
 							target: normalizeMetadataText(failure.target, 80, "peer"),
 							error: normalizeMetadataText(failure.error, 240, "send failed"),
 						})),
-						omittedMsgIds: Math.max(0, sent.length - MAX_BROADCAST_DETAIL_ITEMS),
+						omittedMsgIds: Math.max(0, sent.length - shownReceipts.length),
 						omittedFailures: Math.max(0, failed.length - MAX_BROADCAST_DETAIL_ITEMS),
 					},
 				};