@aeondave/pi-persona 1.17.4 → 1.17.5

package/src/persona/orchestrate.ts

@@ -7,11 +7,8 @@
 import type { RunLimits } from "../core/capabilities.ts";
 import { makeRoster, type RosterMember } from "../orchestration/roster.ts";
 import {
-	type AgentProgress,
-	type AgentStatus,
 	makeSDK,
 	type SDKDeps,
-	type SteerFn,
 	type StrategyEngine,
 	type StrategyInput,
 } from "../orchestration/sdk.ts";
@@ -72,14 +69,14 @@ export interface RunStrategyDeps {
 	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). */
-	onAgentStatus?: (agent: string, status: AgentStatus, result?: AgentResult, key?: string) => void;
+	onAgentStatus?: SDKDeps["onAgentStatus"];
 	onAgentResult?: SDKDeps["onAgentResult"];
 	/** Per-agent streaming progress (rolling output), for live UI. */
-	onAgentProgress?: (agent: string, progress: AgentProgress, key?: string) => void;
+	onAgentProgress?: SDKDeps["onAgentProgress"];
 	/** Called as each agent starts with a handle to abort just that agent (UI stop). */
-	onAgentStart?: (agent: string, abort: () => void, key?: string) => void;
+	onAgentStart?: SDKDeps["onAgentStart"];
 	/** 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?: SDKDeps["onAgentSteerable"];
 	/** See `SDKDeps.canSpawn` — every strategy spawn, not only `delegate`. */
 	canSpawn?: (agent: string) => boolean;
 }

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

package/src/ui/activity-rows.ts

@@ -0,0 +1,34 @@
+/** Bounded local-work rows. A staged plan is waiting data, never a running agent. */
+import type { CompanionActivity } from "../core/companion.ts";
+import type { AddNodeInput } from "./agent-tree.ts";
+
+export const MAX_COMPANION_ACTIVITIES = 8;
+interface ActivityRecord { event: CompanionActivity; startedAt: number }
+
+function description(event: CompanionActivity): string {
+	const scope = `${event.target} memory`;
+	if (event.state === "staged") return `${scope} · proposal prepared; explicit apply required`;
+	if (event.state === "failed") return `${scope} · ${event.phase} failed; see the memory result`;
+	if (event.state === "done") return `${scope} · ${event.phase === "inspect" ? "inspection complete; ready for review" : event.phase === "apply" ? "staged plan applied" : "plan validation complete"}`;
+	return `${scope} · ${event.phase === "inspect" ? "inspecting" : event.phase === "stage" ? "validating consolidation" : "applying staged plan"}`;
+}
+
+export class ActivityRows {
+	private readonly records = new Map<string, ActivityRecord>();
+	accept(event: CompanionActivity, now: number): { node: AddNodeInput; removed: string[] } | undefined {
+		const id = `activity:pi-persona-mind:${event.activityId}`;
+		const existing = this.records.get(id);
+		if (existing && (existing.event.phase !== event.phase || existing.event.target !== event.target || existing.event.state !== "running")) return undefined;
+		const removed: string[] = [];
+		if (!existing && this.records.size >= MAX_COMPANION_ACTIVITIES) {
+			const victim = [...this.records].find(([, record]) => record.event.state !== "running");
+			if (!victim) return undefined; // never silently evict active local work
+			this.records.delete(victim[0]); removed.push(victim[0]);
+		}
+		const record = { event, startedAt: existing?.startedAt ?? now };
+		this.records.set(id, record);
+		const detail = description(event);
+		return { removed, node: { id, label: "Mind", kind: "activity", status: event.state === "running" ? "running" : event.state === "failed" ? "failed" : "done", detail, output: `${detail}.\nLocal memory operation; no sub-agent or model execution is implied.\nInspect the memory tool or command result for the full receipt.`, startedAt: record.startedAt, lastAdvanceAt: now } };
+	}
+	clear(): string[] { const ids = [...this.records.keys()]; this.records.clear(); return ids; }
+}

package/src/ui/agent-overlay.ts

@@ -23,7 +23,7 @@ import {
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 
-import { type AgentNode, type AgentTree, type FlatRow, deriveWaitingNodeIds, effortTag, flattenTree, isWakeSource, nodeGlyph, runningAnnotation, thinkingDetailLine } from "./agent-tree.ts";
+import { type AgentNode, type AgentTree, type FlatRow, deriveWaitingNodeIds, effortTag, flattenTree, isWakeSource, isNonAgentNode, nodeGlyph, runningAnnotation, thinkingDetailLine } from "./agent-tree.ts";
 import { LiveClock } from "./live-clock.ts";
 import { visibleWindow } from "./model-picker.ts";
 import { compactInlineText, OPEN_SEQUENCE_TAIL, sanitizeTerminalText } from "./presentation.ts";
@@ -234,7 +234,7 @@ export class AgentOverlay extends Container {
 	 */
 	private selectedLeaf(leaves: FlatRow[]): FlatRow | undefined {
 		const anchored = this.selectedId !== undefined ? leaves.find((r) => r.node.id === this.selectedId) : undefined;
-		const leaf = anchored ?? leaves.find((r) => !isWakeSource(r.node)) ?? leaves[0];
+		const leaf = anchored ?? leaves.find((r) => !isNonAgentNode(r.node)) ?? leaves[0];
 		if (this.selectedId !== undefined && anchored === undefined && leaf !== undefined) this.aimLost = true;
 		this.selectedId = leaf?.node.id;
 		return leaf;
@@ -305,7 +305,7 @@ export class AgentOverlay extends Container {
 		}
 		this.addChild(new Spacer(1));
 		const stoppable = selected !== undefined && this.canStopNode(selected);
-		const steerable = selected !== undefined && selected.status === "running" && (this.actions.canSteer?.(selected.id) ?? false);
+		const steerable = selected !== undefined && !isNonAgentNode(selected) && selected.status === "running" && (this.actions.canSteer?.(selected.id) ?? false);
 		this.addChild(new Text(t.fg("dim", `↑↓ navigate   ⏎ open${this.hintLine("list", stoppable, steerable, this.stoppableIds(nodes).length)}   esc close`), 1, 0));
 		this.renderNotice();
 	}
@@ -383,8 +383,9 @@ export class AgentOverlay extends Container {
 		// A wake source is armed, not a live agent: it has no steer handle, so the agent-only "● live"
 		// badge and the steer-unavailable hint below would both be wrong for it.
 		const wake = isWakeSource(node);
+		const localActivity = node.kind === "activity";
 		this.addChild(
-			new Text(`${nodeGlyph(node)} ${t.fg("accent", t.bold(safeInline(node.label) || "agent"))}${live ? t.fg("success", wake ? "  ● armed" : "  ● live") : ""}`, 1, 0),
+			new Text(`${nodeGlyph(node)} ${t.fg("accent", t.bold(safeInline(node.label) || "agent"))}${live ? t.fg("success", localActivity ? "  ● local work" : wake ? "  ● armed" : "  ● live") : ""}`, 1, 0),
 		);
 		if (node.detail) this.addChild(new Text(t.fg("dim", safeInline(node.detail)), 1, 0));
 		// The drill-in has room for FULL effort names (the rows stay compact): an observed level
@@ -409,7 +410,7 @@ export class AgentOverlay extends Container {
 		for (const line of all.slice(start, end)) this.addChild(new Text(t.fg("toolOutput", line), 1, 0));
 		if (this.detailScroll > 0) this.addChild(new Text(t.fg("dim", `▼ ${this.detailScroll} newer`), 1, 0));
 
-		const steerable = live && (this.actions.canSteer?.(node.id) ?? false);
+		const steerable = live && !isNonAgentNode(node) && (this.actions.canSteer?.(node.id) ?? false);
 		const stoppable = this.canStopNode(node);
 		if (this.steering && !steerable) this.steering = false; // agent finished mid-compose
 		this.addChild(new Spacer(1));
@@ -421,7 +422,7 @@ export class AgentOverlay extends Container {
 		} else {
 			this.addChild(new Text(t.fg("dim", `esc back   ·   ↑↓ scroll${this.hintLine("detail", stoppable, steerable)}`), 1, 0));
 			this.renderNotice();
-			if (live && !steerable && !wake) {
+			if (live && !steerable && !isNonAgentNode(node)) {
 				this.addChild(new Text(t.fg("dim", "(steer unavailable: no live handle yet, or this engine/broker does not expose one)"), 1, 0));
 			}
 		}
@@ -456,7 +457,8 @@ export class AgentOverlay extends Container {
 				} else if (hadNotice) this.refresh();
 				return;
 			}
-			if (keyData === "s" && (this.actions.canSteer?.(this.detailId) ?? false)) {
+			const detailNode = this.tree.snapshot().find((node) => node.id === this.detailId);
+			if (keyData === "s" && detailNode && !isNonAgentNode(detailNode) && (this.actions.canSteer?.(this.detailId) ?? false)) {
 				this.steering = true;
 				this.steerBuffer = "";
 				this.refresh();
@@ -492,7 +494,7 @@ export class AgentOverlay extends Container {
 			// Steer straight from the list: drill into the selected agent with the
 			// compose line already open (same gate as the detail view's `s`).
 			const leaf = this.aimedLeaf(leaves);
-			if (leaf && leaf.node.status === "running" && (this.actions.canSteer?.(leaf.node.id) ?? false)) {
+			if (leaf && !isNonAgentNode(leaf.node) && leaf.node.status === "running" && (this.actions.canSteer?.(leaf.node.id) ?? false)) {
 				this.detailId = leaf.node.id;
 				this.detailScroll = 0;
 				this.steering = true;
@@ -512,8 +514,8 @@ export class AgentOverlay extends Container {
 	/** Whether an agent can be stopped right now: it must be running, and the caller's `canStop`
 	 *  gate (defaulting to "yes" when omitted) must agree. Shared by both hints and `tryStop`, so
 	 *  the hint that advertises "x stop" and the handler that actually gates it never diverge. */
-	private canStopNode(node: Pick<AgentNode, "id" | "status">): boolean {
-		return node.status === "running" && (this.actions.canStop?.(node.id) ?? true);
+	private canStopNode(node: Pick<AgentNode, "id" | "status" | "kind">): boolean {
+		return node.kind !== "activity" && node.status === "running" && (this.actions.canStop?.(node.id) ?? true);
 	}
 
 	/** The agents `X` would stop: every leaf that `x` could stop, wake sources excluded. `X` means
@@ -521,7 +523,7 @@ export class AgentOverlay extends Container {
 	 *  only by an explicit `x` on its own row. One list feeds the hint count, the confirmation prompt
 	 *  and the bulk stop, so the three always agree. */
 	private stoppableIds(snap: AgentNode[] = this.tree.snapshot()): string[] {
-		return this.leafRows(snap).filter((r) => !isWakeSource(r.node) && this.canStopNode(r.node)).map((r) => r.node.id);
+		return this.leafRows(snap).filter((r) => !isNonAgentNode(r.node) && this.canStopNode(r.node)).map((r) => r.node.id);
 	}
 
 	/** The trailing "x stop"/"X stop all"/"s steer" hint fragment for an action line — the list's

package/src/ui/agent-tree.ts

@@ -15,7 +15,7 @@ import { formatUsage } from "./usage.ts";
  */
 
 export type AgentNodeStatus = "running" | "done" | "failed" | "stopped";
-export type AgentNodeKind = "subagent" | "delegate" | "council" | "flow" | "phase" | "monitor" | "timer";
+export type AgentNodeKind = "subagent" | "delegate" | "council" | "flow" | "phase" | "monitor" | "timer" | "activity";
 
 export interface AgentNode {
 	id: string;
@@ -78,10 +78,16 @@ export function isWakeSource(node: Pick<AgentNode, "kind">): boolean {
 	return node.kind === "monitor" || node.kind === "timer";
 }
 
+/** Local companion work shares the view but is neither an agent nor a wake source. */
+export function isNonAgentNode(node: Pick<AgentNode, "kind">): boolean {
+	return isWakeSource(node) || node.kind === "activity";
+}
+
 /** The kind-aware glyph shared by every surface (tree, overlay): a running timer is ⏰, a running
  *  monitor ◉; everything else, settled wake rows included, uses the ordinary status glyph. */
 export function nodeGlyph(node: Pick<AgentNode, "status" | "kind">): string {
 	if (node.status === "running") {
+		if (node.kind === "activity") return "◈";
 		if (node.kind === "timer") return "⏰";
 		if (node.kind === "monitor") return "◉";
 	}
@@ -136,6 +142,7 @@ export function isQueuedMarker(detail: string | undefined): boolean {
 export function runningAnnotation(node: Pick<AgentNode, "status" | "startedAt" | "lastAdvanceAt" | "detail" | "kind" | "dueAt">, now: number, stallMs: number, waitingForSupervisor = false): string | undefined {
 	if (node.status !== "running" || node.startedAt === undefined) return undefined;
 	if (isQueuedMarker(node.detail)) return undefined;
+	if (node.kind === "activity") return formatDuration(now - node.startedAt);
 	if (waitingForSupervisor) return "waiting for supervisor";
 	if (node.dueAt !== undefined) {
 		const left = node.dueAt - now;
@@ -236,6 +243,8 @@ function wakeDigestLine(hidden: readonly AgentNode[], now: number | undefined):
 	const monitors = hidden.filter((node) => node.kind === "monitor").length;
 	const timers = hidden.filter((node) => node.kind === "timer").length;
 	const parts: string[] = [];
+	const activities = hidden.filter((node) => node.kind === "activity");
+	if (activities.length > 0) parts.push(`◈ Mind · ${safeInline(activities[activities.length - 1]!.detail ?? "local memory work")}`);
 	if (monitors > 0) parts.push(`${nodeGlyph({ status: "running", kind: "monitor" })} ${monitors} monitor${monitors === 1 ? "" : "s"}`);
 	if (timers > 0) parts.push(`${nodeGlyph({ status: "running", kind: "timer" })} ${timers} timer${timers === 1 ? "" : "s"}`);
 	if (now !== undefined) {
@@ -277,7 +286,7 @@ export function renderAgentTreeSummary(nodes: AgentNode[], maxRows = 8, opts: Re
 	// same parent→children order, so a row's flat index doubles as its position in the rendered list.
 	const flat = flattenTree(nodes);
 	const hiddenWake = (from: number): AgentNode[] =>
-		flat.slice(from).map((row) => row.node).filter((node) => isWakeSource(node) && node.status === "running");
+		flat.slice(from).map((row) => row.node).filter((node) => node.kind === "activity" || (isWakeSource(node) && node.status === "running"));
 	let visibleCount = Math.max(0, limit - (failureLine !== undefined ? 2 : 1));
 	let hidden = hiddenWake(visibleCount);
 	if (hidden.length > 0) {
@@ -300,9 +309,9 @@ export interface AddNodeInput {
 	status?: AgentNodeStatus;
 	kind?: AgentNodeKind;
 	agent?: string;
-	model?: string;
-	thinking?: ThinkingLevel;
-	thinkingEffective?: ThinkingLevel;
+	model?: string | undefined;
+	thinking?: ThinkingLevel | undefined;
+	thinkingEffective?: ThinkingLevel | undefined;
 	detail?: string;
 	output?: string;
 	startedAt?: number;
@@ -314,9 +323,9 @@ export interface AgentNodePatch {
 	status?: AgentNodeStatus;
 	kind?: AgentNodeKind;
 	agent?: string;
-	model?: string;
-	thinking?: ThinkingLevel;
-	thinkingEffective?: ThinkingLevel;
+	model?: string | undefined;
+	thinking?: ThinkingLevel | undefined;
+	thinkingEffective?: ThinkingLevel | undefined;
 	detail?: string;
 	output?: string;
 	startedAt?: number;
@@ -330,9 +339,19 @@ function applyPatch(node: AgentNode, patch: AgentNodePatch): void {
 	if (patch.status) node.status = patch.status;
 	if (patch.kind !== undefined) node.kind = patch.kind;
 	if (patch.agent !== undefined) node.agent = patch.agent;
-	if (patch.model !== undefined) node.model = patch.model;
-	if (patch.thinking !== undefined) node.thinking = patch.thinking;
-	if (patch.thinkingEffective !== undefined) node.thinkingEffective = patch.thinkingEffective;
+	// Omission preserves metadata; explicit undefined clears a previous attempt's intent/observation.
+	if (Object.hasOwn(patch, "model")) {
+		if (patch.model === undefined) delete node.model;
+		else node.model = patch.model;
+	}
+	if (Object.hasOwn(patch, "thinking")) {
+		if (patch.thinking === undefined) delete node.thinking;
+		else node.thinking = patch.thinking;
+	}
+	if (Object.hasOwn(patch, "thinkingEffective")) {
+		if (patch.thinkingEffective === undefined) delete node.thinkingEffective;
+		else node.thinkingEffective = patch.thinkingEffective;
+	}
 	if (patch.detail !== undefined) node.detail = patch.detail;
 	if (patch.output !== undefined) node.output = patch.output;
 	if (patch.startedAt !== undefined) node.startedAt = patch.startedAt;

package/src/ui/strategy-leg.ts

@@ -0,0 +1,40 @@
+/** Model intent for live strategy rows, resolved from exact attempt identity and frozen run settings. */
+import { isThinkingLevel, type ThinkingLevel } from "../core/types.ts";
+import type { AgentAttemptIdentity } from "../orchestration/agent-attempt.ts";
+import type { AgentResult } from "../orchestration/types.ts";
+import { participantKey } from "../persona/model-participants.ts";
+
+export interface StrategyModels {
+	readonly assigned: Readonly<Record<string, string>>;
+	readonly agents: Readonly<Record<string, string>>;
+	readonly sessionModel?: string;
+}
+
+export function snapshotStrategyModels(input: { assigned?: Record<string, string>; agents: readonly { name: string; model?: string }[]; sessionModel?: string }): StrategyModels {
+	return Object.freeze({ assigned: Object.freeze({ ...input.assigned }),
+		agents: Object.freeze(Object.fromEntries(input.agents.flatMap((a) => a.model ? [[a.name, a.model]] : []))),
+		...(input.sessionModel ? { sessionModel: input.sessionModel } : {}) });
+}
+
+export interface StrategyLegMetadata {
+	agent: string;
+	model: string | undefined;
+	thinking: ThinkingLevel | undefined;
+	thinkingEffective: ThinkingLevel | undefined;
+}
+
+/** A bare observed id preserves a known provider only when it exactly names the same requested id. */
+function observedModel(observed: string | undefined, requested: string | undefined): string | undefined {
+	const value = observed?.trim();
+	if (!value) return requested;
+	if (!value.includes("/") && requested?.includes("/") && requested.slice(requested.indexOf("/") + 1) === value) return requested;
+	return value;
+}
+
+export function strategyLegMetadata(identity: AgentAttemptIdentity, models: StrategyModels, result?: AgentResult): StrategyLegMetadata {
+	const requested = identity.model ?? models.assigned[participantKey(identity.agent, identity.role)]
+		?? models.assigned[identity.agent] ?? models.agents[identity.agent] ?? models.sessionModel;
+	return { agent: identity.agent, model: observedModel(result?.modelUsed, requested),
+		thinking: isThinkingLevel(result?.thinkingRequested) ? result.thinkingRequested : identity.thinking,
+		thinkingEffective: isThinkingLevel(result?.thinkingEffective) ? result.thinkingEffective : undefined };
+}