@aeondave/pi-persona 1.15.2 → 1.16.1

package/src/persona/model-participants.ts

@@ -0,0 +1,240 @@
+/**
+ * Participant-aware model resolution for an orchestrated run.
+ *
+ * A strategy's participants are NOT just its roster members: an arbiter (`params.judge`), a
+ * synthesiser, a critic or a generator is a real participant too — it spawns, it is billed, and its
+ * model matters exactly as much as a core's. This module is the ONE pure place that answers two
+ * questions for the UI layer:
+ *
+ *   1. WHO runs — roster members plus every auxiliary actor declared by an agent-typed strategy
+ *      param (metadata-driven, so a new strategy needs no name switch here).
+ *   2. ON WHAT — the effective model by precedence:
+ *        explicit inline member model
+ *          > saved per-persona assignment for the ROLE key
+ *          > saved per-persona assignment for the agent key
+ *          > the agent's own frontmatter model
+ *          > the session model (the default, NOT an assignment — it must not suppress the picker).
+ *
+ * The persisted assignment KEY is `agent` for a bare member — the historical shape, so every
+ * existing `config.json` keeps applying — and `agent#<hash-of-agent+role>` for a member carrying a
+ * role. The hash keeps the full role as the identity without persisting the role PROMPT (which is
+ * an instruction, not a key, and would leak strategy prose into the user's config file). The human
+ * label stays separate, so the picker and the tree can still say `reviewer · SECURITY`.
+ *
+ * Pure: no engine, no UI, no config store, no clock. The picker decides; this decides WHAT it may
+ * ask about.
+ */
+
+import { createHash } from "node:crypto";
+
+import { memberBaseLabel, parseRosterMember, type RosterMember, type RosterSpec } from "../orchestration/roster.ts";
+import { knownParams } from "../orchestration/strategy.ts";
+import type { StrategyParam } from "../orchestration/sdk.ts";
+
+/** Where a participant's effective model came from — in precedence order. */
+export type ModelSource = "inline" | "assignment" | "agent" | "session" | "none";
+
+/** A strategy param that names a real participant (an arbiter, a synthesiser, …) is marked
+ *  `type: "agent"` in the strategy's own metadata — the single declaration, read from
+ *  `knownParams`, so adding a strategy never means editing this file. */
+function isAgentParam(param: StrategyParam): boolean {
+	return param.type === "agent";
+}
+
+export interface ModelParticipant {
+	/** The agent that runs. */
+	agent: string;
+	/** The on-the-fly role prompt, when the participant carries one (never persisted in `key`). */
+	role?: string;
+	/** Stable model-assignment key: the agent name, or `agent#<hash>` for a role member. */
+	key: string;
+	/** What a human should see: `agent`, or `agent · HINT` for a role member. */
+	label: string;
+	/** A roster member, or an auxiliary actor declared by a strategy param. */
+	origin: "roster" | "param";
+	/** The strategy param that declares this auxiliary actor (roster members omit it). */
+	param?: string;
+	/** The effective model for this participant, by precedence; undefined when nothing supplies one. */
+	model?: string;
+	/** Which step of the precedence supplied `model`. */
+	source: ModelSource;
+	/** Someone already chose this participant's model (inline, a saved assignment, or the agent's own
+	 *  frontmatter) ⇒ never a picker candidate. The session default is deliberately NOT counted. */
+	assigned: boolean;
+}
+
+export interface ParticipantInput {
+	/** The run's members (the caller resolves inline-over-roster via
+	 *  `resolveOrchestrationMembers`). */
+	members?: RosterMember[];
+	/** The running strategy — used to look up its declared agent-typed params. */
+	strategy?: string;
+	/** The strategy's params, as the run will see them. */
+	params?: Record<string, unknown>;
+	/** Param schema override; defaults to `knownParams(strategy)`. Test/forward seam. */
+	schema?: Record<string, StrategyParam>;
+	/** The persona's saved assignments, keyed by `participantKey`. */
+	assigned?: Record<string, string>;
+	/** An agent's own declared model (frontmatter). */
+	agentModel?: (agent: string) => string | undefined;
+	/** The session's own model — the last-resort default. */
+	sessionModel?: string;
+}
+
+/**
+ * The digest behind a role key. SHA-256 (128 bits kept) rather than a short rolling hash: this
+ * value is the identity a model assignment is filed under, so a collision would hand one lens
+ * another's model — a silent, expensive wrong answer. `crypto` is a node builtin (no dependency,
+ * no host package), and the digest is deterministic across processes and runs, which is what lets
+ * a persisted key resolve to the same participant tomorrow.
+ */
+function stableDigest(value: string): string {
+	return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+
+/**
+ * The model-assignment key for a participant. A bare member (no role) keeps the agent name — the
+ * pre-role key shape, so assignments saved before roles existed keep applying to it.
+ */
+export function participantKey(agent: string, role?: string): string {
+	const trimmed = role?.trim();
+	return trimmed ? `${agent}#${stableDigest(`${agent}\0${trimmed}`)}` : agent;
+}
+
+/** One participant's model, resolved in the one precedence order the UI and the engines share. */
+function fromSpec(spec: RosterSpec, origin: "roster" | "param", param: string | undefined, input: ParticipantInput): ModelParticipant {
+	const assigned = input.assigned ?? {};
+	const key = participantKey(spec.agent, spec.role);
+	let model: string | undefined;
+	let source: ModelSource = "none";
+	if (spec.model) {
+		model = spec.model;
+		source = "inline";
+	} else if (assigned[key]) {
+		model = assigned[key];
+		source = "assignment";
+	} else if (assigned[spec.agent]) {
+		model = assigned[spec.agent];
+		source = "assignment";
+	} else {
+		const agentModel = input.agentModel?.(spec.agent);
+		if (agentModel) {
+			model = agentModel;
+			source = "agent";
+		} else if (input.sessionModel) {
+			model = input.sessionModel;
+			source = "session";
+		}
+	}
+	return {
+		agent: spec.agent,
+		...(spec.role ? { role: spec.role } : {}),
+		key,
+		label: memberBaseLabel(asMember(spec)),
+		origin,
+		...(param ? { param } : {}),
+		...(model ? { model } : {}),
+		source,
+		assigned: source === "inline" || source === "assignment" || source === "agent",
+	};
+}
+
+/** Rebuild the member shape `memberBaseLabel` normalises (it takes a RosterMember, not a spec). */
+function asMember(spec: RosterSpec): RosterMember {
+	return spec.role ? { agent: spec.agent, role: spec.role, ...(spec.model ? { model: spec.model } : {}) } : spec.agent;
+}
+
+/** An auxiliary actor resolves in ONE chain: the value the caller supplied → (only where the
+ *  metadata says so) the roster member it names or points at → the real agent named by `default`.
+ *  A default that is a SENTENCE rather than an agent ("the first roster agent") is no participant
+ *  at all — taking a phrase literally would offer a model for a leg that can never run. */
+function auxActorSpec(input: ParticipantInput, paramName: string, param: StrategyParam): RosterSpec | undefined {
+	const supplied = input.params?.[paramName];
+	const spec = toSpec(supplied);
+	if (spec) {
+		// `inheritRoster` is opt-in per param (e.g. `map.verify`'s documented "a member named X"
+		// lookup) and only ever rewrites a BARE selector. An arbiter/critic keeps its historic
+		// meaning — naming that agent IS the actor, whatever role a panel member happens to wear.
+		if (param.inheritRoster && typeof supplied === "string") {
+			const seated = rosterMemberNamed(input.members, spec.agent);
+			if (seated) return seated;
+		}
+		return spec;
+	}
+	const index = rosterIndexOf(param);
+	if (index !== undefined) {
+		const seated = toSpec(input.members?.[index]);
+		if (seated) return seated;
+	}
+	return isAgentName(param.default) ? toSpec(param.default) : undefined;
+}
+
+/** The roster entry an aux selector names, verbatim — its role/inline model included, so the aux
+ *  actor and the panel entry stay ONE participant with ONE model key. */
+function rosterMemberNamed(members: RosterMember[] | undefined, agent: string): RosterSpec | undefined {
+	for (const member of members ?? []) {
+		const spec = toSpec(member);
+		if (spec?.agent === agent) return spec;
+	}
+	return undefined;
+}
+
+/** The roster position an agent-typed param defaults to, when its metadata declares one. */
+function rosterIndexOf(param: StrategyParam): number | undefined {
+	const index = param.rosterIndex;
+	return typeof index === "number" && Number.isInteger(index) && index >= 0 ? index : undefined;
+}
+
+/** Is this default an AGENT NAME (one token) rather than a documentation phrase? Agent names never
+ *  contain whitespace, so a multi-word default is prose describing a default, not a participant. */
+function isAgentName(value: unknown): boolean {
+	return typeof value === "string" && value.trim().length > 0 && !/\s/.test(value.trim());
+}
+
+/** Every participant a run really spawns: the roster first (in run order), then auxiliary actors. */
+export function collectModelParticipants(input: ParticipantInput): ModelParticipant[] {
+	const out: ModelParticipant[] = [];
+	const seen = new Set<string>();
+	for (const raw of input.members ?? []) {
+		const spec = toSpec(raw);
+		if (!spec) continue;
+		const p = fromSpec(spec, "roster", undefined, input);
+		if (seen.has(p.key)) continue;
+		seen.add(p.key);
+		out.push(p);
+	}
+	const schema = input.schema ?? (input.strategy ? knownParams(input.strategy) : undefined);
+	if (schema) {
+		for (const [paramName, param] of Object.entries(schema)) {
+			if (!isAgentParam(param)) continue;
+			const spec = auxActorSpec(input, paramName, param);
+			if (!spec) continue;
+			const p = fromSpec(spec, "param", paramName, input);
+			if (seen.has(p.key)) continue;
+			seen.add(p.key);
+			out.push(p);
+		}
+	}
+	return out;
+}
+
+/** The participants a picker may still ask about: nobody has chosen a model for them, and this
+ *  session has not already asked (and been dismissed) for that key. The caller records the keys it
+ *  asks about BEFORE asking, so a dismissal is remembered too. */
+export function pendingParticipants(
+	participants: readonly ModelParticipant[],
+	opts: { prompted: ReadonlySet<string> },
+): ModelParticipant[] {
+	return participants.filter((p) => !p.assigned && !opts.prompted.has(p.key));
+}
+
+// A roster member / param value is either a bare agent name or an inline specialisation map. Both
+// come from the shared roster grammar (`parseRosterMember`), so an auxiliary actor named inline in
+// a `params.judge` entry is normalised exactly like a `teams.yaml` member.
+function toSpec(value: unknown): RosterSpec | undefined {
+	if (value === undefined || value === null || typeof value === "boolean" || typeof value === "number") return undefined;
+	const member = parseRosterMember(value);
+	if (!member) return undefined;
+	const spec = typeof member === "string" ? { agent: member } : member;
+	return spec.agent.trim() ? spec : undefined;
+}

package/src/persona/orchestrate.ts

@@ -31,6 +31,31 @@ export function resolveStrategyName(orch: OrchestrationGrammar): string | undefi
 	return undefined;
 }
 
+/** The reserved team key under which an EPHEMERAL `members:` list is registered for one run.
+ *  A CLONE of the shared team map carries it, so no team file, discovery map, or later call
+ *  ever sees it — the reserved key is a per-call implementation detail, not a team name. */
+export const ADHOC_MEMBERS_KEY = "__adhoc_members__";
+
+/**
+ * The members a run actually uses: inline `orch.members` when present (they WIN the named
+ * team — ephemeral, one call, nothing written back), else the named `orch.roster`'s members.
+ * An unknown team name is a diagnostic naming the known teams, raised BEFORE any engine call.
+ * No roster at all ⇒ `[]`; whether that is fatal is the strategy's own call.
+ */
+export function resolveOrchestrationMembers(
+	orch: Pick<OrchestrationGrammar, "roster" | "members">,
+	teams: Record<string, RosterMember[]>,
+): RosterMember[] {
+	if (orch.members && orch.members.length > 0) return orch.members;
+	if (!orch.roster) return [];
+	const members = teams[orch.roster];
+	if (!members) {
+		const known = Object.keys(teams).sort();
+		throw new Error(`unknown roster "${orch.roster}" (${known.length > 0 ? `available teams: ${known.join(", ")}` : "no teams are defined"})`);
+	}
+	return members;
+}
+
 export interface RunStrategyDeps {
 	engine: StrategyEngine;
 	teams: Record<string, RosterMember[]>;
@@ -39,6 +64,11 @@ export interface RunStrategyDeps {
 	/** The session's own model (`provider/id`) — a strategy's last-resort recovery model for a
 	 *  member whose own model broke with no healthy peer to borrow from. */
 	sessionModel?: string;
+	/** The session model read AT USE TIME (the session can switch models mid-run), forwarded
+	 *  beside the static `sessionModel` so a late leg still sees the current one. */
+	getSessionModel?: () => string | undefined;
+	/** A provider reroute was applied to one leg (the fallback layer's telemetry hook). */
+	onModelFallback?: (info: { agent: string; from?: string; to: string; key: string }) => void;
 	log?: (message: string) => void;
 	/** Per-agent lifecycle, for live UI (which roster agent is running/done + its result).
 	 *  `key` is a run-unique display id (disambiguates same-agent roster-role members). */
@@ -66,9 +96,18 @@ export async function runPersonaStrategy(
 	// so the council/flow surfaces it instead of an opaque "no ruling".
 	if (!strategy) throw new Error(`unknown strategy "${name}" (available: ${strategyNames().join(", ")})`);
 
-	const sdkDeps: SDKDeps = { engine: deps.engine, roster: makeRoster(deps.teams), limits: deps.limits };
+	// Ephemeral members ride a CLONE of the shared team map under a reserved key: the
+	// strategies read members by team name, so this is the one seam that lets an ad-hoc
+	// council run through the exact same path — without ever mutating `deps.teams`.
+	// An unknown NAMED roster is still left to the strategy (which fails with its own
+	// "a roster of … is required" before any engine call); only inline members change here.
+	const adhocMembers = orch.members && orch.members.length > 0 ? orch.members : undefined;
+	const teams = adhocMembers ? { ...deps.teams, [ADHOC_MEMBERS_KEY]: adhocMembers } : deps.teams;
+	const sdkDeps: SDKDeps = { engine: deps.engine, roster: makeRoster(teams), limits: deps.limits };
 	if (deps.signal) sdkDeps.signal = deps.signal;
 	if (deps.sessionModel) sdkDeps.sessionModel = deps.sessionModel;
+	if (deps.getSessionModel) sdkDeps.getSessionModel = deps.getSessionModel;
+	if (deps.onModelFallback) sdkDeps.onModelFallback = deps.onModelFallback;
 	if (deps.log) sdkDeps.log = deps.log;
 	if (deps.onAgentStatus) sdkDeps.onAgentStatus = deps.onAgentStatus;
 	if (deps.onAgentProgress) sdkDeps.onAgentProgress = deps.onAgentProgress;
@@ -77,7 +116,10 @@ export async function runPersonaStrategy(
 	if (deps.canSpawn) sdkDeps.canSpawn = deps.canSpawn;
 
 	const input: StrategyInput = { task, params: orch.params ?? {} };
-	if (orch.roster) input.roster = orch.roster;
+	// Inline members win the named team for this call (`resolveOrchestrationMembers` is the
+	// shared read path for callers that need the roster resolved up front — the tree seeding).
+	if (adhocMembers) input.roster = ADHOC_MEMBERS_KEY;
+	else if (orch.roster) input.roster = orch.roster;
 
 	return strategy.run(input, makeSDK(sdkDeps));
 }

package/src/persona/persona.ts

@@ -10,6 +10,7 @@
 import { asBoolean, asPermission, asStringArray, parseYamlSubset, splitFrontmatter } from "../core/frontmatter.ts";
 import type { Permission } from "../core/permissions.ts";
 import { asSystemPromptMode, type SystemPromptMode } from "../core/types.ts";
+import { parseRuntimeRosterMember, type RosterMember } from "../orchestration/roster.ts";
 
 export type OrchestrationMode = "solo" | "parallel" | "pipeline" | "strategy" | "flow";
 const ORCHESTRATION_MODES: readonly OrchestrationMode[] = ["solo", "parallel", "pipeline", "strategy", "flow"];
@@ -20,6 +21,9 @@ export interface OrchestrationGrammar {
 	strategy?: string;
 	flow?: string;
 	roster?: string;
+	/** Ephemeral members for THIS run — validated inline specialisations that win `roster`
+	 *  (see `resolveOrchestrationMembers`). Never written back to a team or persona file. */
+	members?: RosterMember[];
 	/** Strategy parameters (e.g. rounds, aggregate, critic). */
 	params?: Record<string, unknown>;
 }
@@ -41,6 +45,13 @@ export interface CouncilSpec {
 export interface CouncilDraft {
 	strategy?: string;
 	roster?: string;
+	/** Ephemeral members declared inline (bare agent names or `{ agent, … }` maps), validated
+	 *  at parse. They win `roster` for the calls this persona convenes. */
+	members?: RosterMember[];
+	/** Set when a `members:` block was AUTHORED but unusable (not a list, empty, or an entry
+	 *  that is not a member). Kept as a diagnostic so the call fails loudly instead of
+	 *  quietly convening some other roster. */
+	membersProblem?: string;
 	params?: Record<string, unknown>;
 	/** A named preset (presets/<name>.preset.json) providing defaults; authored fields override. */
 	preset?: string;
@@ -165,23 +176,51 @@ function parseDelegationPolicy(value: unknown): DelegationPolicy | undefined {
 	return Object.keys(policy).length > 0 ? policy : undefined;
 }
 
-/** Parse a persona's `council:` block (strategy + roster + params, or just a `preset`). */
+/** Parse a persona's `council:` block (strategy + roster + members + params, or just a `preset`). */
 function parseCouncil(value: unknown): CouncilDraft | undefined {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
 	const o = value as Record<string, unknown>;
 	const strategy = typeof o.strategy === "string" && o.strategy.trim() ? o.strategy.trim() : "";
 	const preset = typeof o.preset === "string" && o.preset.trim() ? o.preset.trim() : "";
-	if (!strategy && !preset) return undefined; // a council needs at least a strategy or a preset
+	// Validate `members:` BEFORE the a-council-needs-a-strategy gate: a members-only block
+	// with a broken list is a broken declaration, and returning undefined here would drop the
+	// diagnostic and let the call quietly convene the MAGI fallback instead.
+	const parsedMembers = Object.hasOwn(o, "members") ? parseMembersBlock(o.members) : undefined;
+	if (!strategy && !preset && !parsedMembers) return undefined;
 	const spec: CouncilDraft = {};
 	if (strategy) spec.strategy = strategy;
 	if (preset) spec.preset = preset;
 	if (typeof o.roster === "string" && o.roster.trim()) spec.roster = o.roster.trim();
+	if (parsedMembers) {
+		if (parsedMembers.ok) spec.members = parsedMembers.members;
+		else spec.membersProblem = parsedMembers.error;
+	}
 	if (o.params && typeof o.params === "object" && !Array.isArray(o.params)) {
 		spec.params = o.params as Record<string, unknown>;
 	}
 	return spec;
 }
 
+/**
+ * Validate an authored `members:` block into roster members. A block that was explicitly
+ * supplied but is not a usable list is an ERROR, never a silent absence: dropping it would
+ * fall back to the persona's named team (or MAGI) and present an unrelated ensemble as the
+ * one the author asked for. Members are validated with the STRICT runtime parser, so a
+ * malformed specialisation field (`tools: ["read", 42]`, `model: 42`) is a diagnostic rather
+ * than a silently dropped field that widens or narrows what the leg may do.
+ */
+export function parseMembersBlock(value: unknown): { ok: true; members: RosterMember[] } | { ok: false; error: string } {
+	if (!Array.isArray(value)) return { ok: false, error: "council.members must be a list of agent names or { agent, … } members" };
+	if (value.length === 0) return { ok: false, error: "council.members is empty — declare at least one member or drop the key" };
+	const members: RosterMember[] = [];
+	for (const [i, raw] of value.entries()) {
+		const parsed = parseRuntimeRosterMember(raw);
+		if (!parsed.ok) return { ok: false, error: `council.members[${i}]: ${parsed.error}` };
+		members.push(parsed.member);
+	}
+	return { ok: true, members };
+}
+
 /** Expand a council `preset` (presets/<name>.preset.json) into concrete fields: the preset
  *  supplies defaults, authored fields win, and `params` shallow-merge (authored over preset).
  *  The `preset` key is consumed. An unknown preset just drops the key (authored fields kept). */
@@ -190,8 +229,14 @@ export function expandCouncilPreset(draft: CouncilDraft, presets: Record<string,
 	const base = presets[draft.preset];
 	const { preset: _consumed, ...authored } = draft;
 	if (!base) return authored;
-	const merged: CouncilDraft = { ...base, ...authored };
-	if (base.params || authored.params) merged.params = { ...base.params, ...authored.params };
+	// Presets only declare strategy, roster, and params. Copy that allowlist instead of
+	// spreading a runtime object, so an extra `members` key cannot bypass parseMembersBlock.
+	const defaults: CouncilDraft = {};
+	if (typeof base.strategy === "string" && base.strategy.trim()) defaults.strategy = base.strategy.trim();
+	if (typeof base.roster === "string" && base.roster.trim()) defaults.roster = base.roster.trim();
+	if (base.params && typeof base.params === "object" && !Array.isArray(base.params)) defaults.params = base.params;
+	const merged: CouncilDraft = { ...defaults, ...authored };
+	if (defaults.params || authored.params) merged.params = { ...defaults.params, ...authored.params };
 	return merged;
 }
 
@@ -203,12 +248,19 @@ export interface CouncilInvocation {
 	persona?: string | undefined;
 	strategy?: string | undefined;
 	roster?: string | undefined;
+	/** Raw `members:` from the call — validated HERE so an unusable block is a diagnostic
+	 *  rather than a silent fall back to the named team (a tool schema cannot validate it). */
+	members?: unknown;
 	params?: Record<string, unknown> | undefined;
 }
 
 export interface ResolvedCouncilInvocation {
 	strategy: string;
+	/** The named team. EMPTY when inline `members` are in effect — there is no named team for
+	 *  an ephemeral call, and a misleading team name would mislabel the card and the tree. */
 	roster: string;
+	/** The ephemeral members actually in effect (validated), when any. */
+	members?: RosterMember[];
 	params: Record<string, unknown>;
 	/** Persona whose council declaration supplied the defaults, when any. */
 	persona?: string;
@@ -218,6 +270,10 @@ export type CouncilInvocationResolution =
 	| { ok: true; value: ResolvedCouncilInvocation }
 	| { ok: false; error: string };
 
+function hasCouncilDeclaration(council: CouncilDraft | undefined): boolean {
+	return Boolean(council?.strategy || council?.members || council?.membersProblem);
+}
+
 /** Resolve a council call without mutating the active persona.
  *
  * An explicit persona is intentionally strict: it must exist and declare a
@@ -236,7 +292,7 @@ export function resolveCouncilInvocation(
 		sourcePersona = personas.find((persona) => persona.isPersona && persona.name === requestedName);
 		if (!sourcePersona) {
 			const available = personas
-				.filter((persona) => persona.isPersona && Boolean(persona.council?.strategy))
+				.filter((persona) => persona.isPersona && hasCouncilDeclaration(persona.council))
 				.map((persona) => persona.name)
 				.sort();
 			return {
@@ -244,30 +300,46 @@ export function resolveCouncilInvocation(
 				error: `no persona named "${requestedName}". Council personas: ${available.join(", ") || "(none)"}`,
 			};
 		}
-		if (!sourcePersona.council?.strategy) {
+		if (!hasCouncilDeclaration(sourcePersona.council)) {
 			return {
 				ok: false,
 				error: `persona "${requestedName}" declares no usable council`,
 			};
 		}
-	} else if (activePersona?.council?.strategy) {
+	} else if (hasCouncilDeclaration(activePersona?.council)) {
 		sourcePersona = activePersona;
 	}
 
 	const base = sourcePersona?.council;
+	if (base?.membersProblem) {
+		return { ok: false, error: `${requestedName ? `persona "${requestedName}"` : `the active persona "${activePersona?.name ?? "?"}"`}: ${base.membersProblem}` };
+	}
 	const strategy = request.strategy?.trim() || base?.strategy || "magi";
-	const roster =
-		request.roster?.trim() ||
-		base?.roster ||
-		sourcePersona?.orchestration?.roster ||
-		(!requestedName ? activePersona?.orchestration?.roster : undefined) ||
-		"magi";
+	// Ephemeral members win the named team, for this call only: nothing is written back to
+	// teams.yaml, the persona file, or any model/prompt/capability the profile would imply.
+	let members = base?.members;
+	if (request.members !== undefined) {
+		const parsed = parseMembersBlock(request.members);
+		if (!parsed.ok) return { ok: false, error: parsed.error };
+		members = parsed.members;
+	}
+	const roster = members
+		? ""
+		: request.roster?.trim() ||
+			base?.roster ||
+			sourcePersona?.orchestration?.roster ||
+			(!requestedName ? activePersona?.orchestration?.roster : undefined) ||
+			"magi";
+	// Profile params belong to the profile's strategy. A per-call strategy switch starts
+	// with that strategy's own defaults; only explicitly supplied params cross the switch.
+	const inheritedParams = strategy !== (base?.strategy || "magi") ? {} : base?.params ?? {};
 	const value: ResolvedCouncilInvocation = {
 		strategy,
 		roster,
-		params: { ...(base?.params ?? {}), ...(request.params ?? {}) },
+		params: { ...inheritedParams, ...(request.params ?? {}) },
 	};
 	if (sourcePersona) value.persona = sourcePersona.name;
+	if (members) value.members = members;
 	return { ok: true, value };
 }
 

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.15.2" as const;
+export const TELEMETRY_PRODUCER_VERSION = "1.16.1" as const;
 
 export type InstanceStatus = "active" | "idle" | "stopped" | "stale" | (string & {});
 export type AgentKind = "subagent" | "delegate" | "council" | "flow" | "phase" | (string & {});