@aeondave/pi-persona 1.17.3 → 1.17.4

package/src/results/retrieval.ts

@@ -0,0 +1,142 @@
+/** Supervisor-facing terminal receipts and the shared fenced page projection. No lifecycle effects. */
+import { fenceUntrusted } from "../core/fence.ts";
+import { readFailure, type ReadReply, type ScopedReader } from "../bus/result-reader.ts";
+import { RESULT_MAX_BODY_CHARS, RESULT_READ_DEFAULT, RESULT_READ_MAX, type ArchiveFailure, type ResultPage, type ResultReadRequest,
+	type ResultStorage, type SaveOutcome, type TerminalStatus } from "./types.ts";
+import type { StoredBodyPage } from "./record.ts";
+
+export interface ResultReceipt {
+	ref?: string;
+	storage?: ResultStorage;
+	truncated?: boolean;
+	warning?: string;
+}
+
+export function resultReceipt(outcome: SaveOutcome): ResultReceipt {
+	if (!outcome.ok) return { warning: `Terminal report not archived (${outcome.reason}).` };
+	return {
+		ref: outcome.ref, storage: outcome.storage, truncated: outcome.summary.truncated,
+		...(outcome.warnings.length > 0 ? { warning: `Terminal storage: ${outcome.warnings.join(", ")}.` } : {}),
+	};
+}
+
+export function resultReceiptHint(receipt: ResultReceipt | undefined): string {
+	if (!receipt) return "";
+	const reference = receipt.ref
+		? `${receipt.ref} · ${receipt.storage === "session-entry" ? "native session entry accepted (not an fsync guarantee)" : "memory-only; runtime-only, not durable"}. Read with intercom { action:"result", ref:"${receipt.ref}" }.`
+		: "";
+	return [reference, receipt.truncated ? "Saved report truncated by archive limits." : "", receipt.warning ?? ""].filter(Boolean).join(" ");
+}
+
+/** Live reports are not restricted to archive body retention; paging still obeys the same UTF-16 contract. */
+export function pageLiveResult(body: string, offset = 0, limit = RESULT_READ_DEFAULT): StoredBodyPage | undefined {
+	const splitsPair = (at: number): boolean => at > 0 && at < body.length
+		&& /[\uD800-\uDBFF]/.test(body[at - 1]!) && /[\uDC00-\uDFFF]/.test(body[at]!);
+	if (!Number.isSafeInteger(offset) || offset < 0 || offset > body.length || splitsPair(offset)
+		|| !Number.isInteger(limit) || limit < 2 || limit > RESULT_READ_MAX) return undefined;
+	let end = Math.min(body.length, offset + limit);
+	if (splitsPair(end)) end--;
+	return { body: body.slice(offset, end), offset, endOfStoredBody: end === body.length, ...(end < body.length ? { nextOffset: end } : {}) };
+}
+
+/** Metadata is caller-owned; report and diagnostic text are always independently fenced. */
+export function projectResultPage(page: StoredBodyPage, error?: string): string {
+	const cause = error ? `\nFailure detail:\n${fenceUntrusted(error.slice(0, 2048))}` : "";
+	const next = page.nextOffset === undefined ? "end of stored body" : `next offset: ${page.nextOffset}`;
+	return `Page offset ${page.offset}; ${page.body.length} UTF-16 units; ${next}.${cause}\n${page.body === "(no output)" ? page.body : fenceUntrusted(page.body)}`;
+}
+
+// ── reference handoff (flow reference mode): scoped reads over the terminal archive ──
+
+/** The narrow archive face a leg's reader needs — `TerminalResultArchive` satisfies it
+ *  structurally. Readers never own, hydrate or mutate archive state; they page through it. */
+export interface ResultArchiveView {
+	read(request: ResultReadRequest): ResultPage;
+}
+
+/** An archive failure reason mapped onto the reader wire's closed error vocabulary. */
+function readFailureFor(reason: ArchiveFailure["reason"]): ReadReply {
+	switch (reason) {
+		case "invalid":
+			return readFailure("invalid");
+		case "busy":
+			return readFailure("busy");
+		default:
+			// missing / ambiguous / corrupt / conflict / quota — every identity or durability
+			// problem reads to the child as "the ref is not readable here".
+			return readFailure("unavailable");
+	}
+}
+
+/** A scoped reader over the owning session's archive, granted an EXPLICIT ref set (the
+ *  direct upstream phase needs of THIS leg — nothing else). Owner/capability rechecks at
+ *  call time are the root's job (the adapter closure); revocation is one-way and final.
+ *  Reads page the archive's already-stored body; they never rebill, collect live runs, or
+ *  wake anything. Projection/fencing stays the tool's job (`tools/read-result.ts`). */
+export interface ScopedResultReader extends ScopedReader {
+	/** Refs that are not durably readable (missing, unreadable, or memory-only). Empty = healthy. */
+	preflight(): { missing: string[] };
+}
+
+export function makeScopedResultReader(view: ResultArchiveView, granted: readonly string[]): ScopedResultReader {
+	const refs = new Set(granted);
+	let revoked = false;
+	const page = (request: ResultReadRequest): ReadReply => {
+		const result = view.read(request);
+		if (!result.ok) return readFailureFor(result.reason);
+		const s = result.summary;
+		const end = result.offset + result.body.length;
+		return {
+			ok: true, ref: s.ref, body: result.body, offset: result.offset,
+			...(end < s.storedChars ? { nextOffset: end } : {}),
+			storedChars: s.storedChars, originalChars: s.originalChars, truncated: s.truncated,
+			endOfStoredBody: result.endOfStoredBody, status: s.status, provenance: s.provenance,
+		};
+	};
+	return {
+		async read(request, signal): Promise<ReadReply> {
+			if (revoked) return readFailure("revoked");
+			if (signal?.aborted) return readFailure("cancelled");
+			if (!refs.has(request.ref)) return readFailure("denied");
+			return page(request);
+		},
+		revoke(): void {
+			revoked = true;
+		},
+		preflight(): { missing: string[] } {
+			// Reference handoff is a DURABILITY contract: a memory-only record is not a receipt
+			// a later process (or a resumed run) could read back, so it does not pass preflight.
+			const missing: string[] = [];
+			for (const ref of refs) {
+				const result = view.read({ ref, offset: 0, limit: 2 });
+				if (!result.ok || result.summary.storage !== "session-entry") missing.push(ref);
+			}
+			return { missing };
+		},
+	};
+}
+
+/** The full stored body of an archived result, paged out to the archive's own ceiling. Used
+ *  by a reference-mode RESUME to rebuild a done phase's output from the archive (contract 2). */
+export function readArchivedBody(view: ResultArchiveView, ref: string):
+	| { ok: true; body: string; status: TerminalStatus; truncated: boolean }
+	| { ok: false; error: string } {
+	let offset = 0;
+	let body = "";
+	let status: TerminalStatus | undefined;
+	let truncated = false;
+	while (true) {
+		const page = view.read({ ref, offset, limit: RESULT_READ_MAX });
+		if (!page.ok) return { ok: false, error: `${page.reason}: ${page.message}` };
+		status = page.summary.status;
+		truncated = page.summary.truncated;
+		body += page.body;
+		if (page.endOfStoredBody || page.nextOffset === undefined) break;
+		if (page.nextOffset <= offset || body.length >= RESULT_MAX_BODY_CHARS) {
+			return { ok: false, error: `archive paging did not advance past offset ${page.nextOffset}` };
+		}
+		offset = page.nextOffset;
+	}
+	if (status === undefined) return { ok: false, error: "archive returned no status" };
+	return { ok: true, body, status, truncated };
+}

package/src/results/types.ts

@@ -0,0 +1,128 @@
+import type { ThinkingLevel } from "../core/types.ts";
+
+export const TERMINAL_RESULT_ENTRY = "pi-persona-terminal-result";
+export const RESULT_MAX_ENTRIES = 128;
+/** UTF-8 JSON custom-entry DATA only; the host's JSONL envelope is excluded. */
+export const RESULT_MAX_PAYLOAD_BYTES = 8 * 1024 * 1024;
+export const RESULT_MAX_RECORD_BYTES = 512 * 1024;
+export const RESULT_MAX_BODY_CHARS = 262_144;
+export const RESULT_READ_DEFAULT = 8_000;
+export const RESULT_READ_MAX = 16_000;
+export const RESULT_LIST_DEFAULT = 20;
+export const RESULT_LIST_MAX = 50;
+
+export type TerminalStatus = "done" | "failed" | "stopped";
+export type ResultProvenance = "result-output" | "partial-output" | "error";
+export type ResultStorage = "session-entry" | "memory-only";
+export type ResultWarning = "no-session-storage" | "accounting-unavailable" | "invalid-history"
+	| "duplicate-history" | "ambiguous-history" | "append-failed" | "body-truncated";
+
+/** Cumulative usage only, never a context-window claim or per-token stream. */
+export interface TerminalUsage {
+	input: number;
+	output: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	cost?: number;
+	turns?: number;
+}
+
+/** Trusted caller projection, NOT an arbitrary AgentResult. Unknown fields are rejected.
+ * Metadata ceilings (UTF-16): originKey 1024, originRunId/agent 128, label 256,
+ * model 512, error 2048. Invalid metadata rejects the save rather than silently changing it. */
+export interface TerminalResultInput {
+	/** Immutable activation + run/phase identity. Routing labels are not identities. */
+	originKey: string;
+	originRunId?: string;
+	status: TerminalStatus;
+	agent: string;
+	label?: string;
+	model?: string;
+	thinkingRequested?: ThinkingLevel;
+	thinkingEffective?: ThinkingLevel;
+	usage?: TerminalUsage;
+	/** Epoch milliseconds. Omit to stamp a NEW record with the injected clock. */
+	createdAt?: number;
+	body: string;
+	provenance: ResultProvenance;
+	error?: string;
+}
+
+export interface TerminalResultRecord extends Omit<TerminalResultInput, "createdAt"> {
+	version: 1;
+	ref: string;
+	createdAt: number;
+	/** SHA-256 content identity includes the original body, even its discarded suffix.
+	 * This is collision detection, not authentication of host history. */
+	payloadHash: string;
+	originalChars: number;
+	storedChars: number;
+	truncated: boolean;
+}
+
+export interface ResultSummary extends Omit<TerminalResultRecord, "body" | "payloadHash"> {
+	storage: ResultStorage;
+}
+
+export interface ResultAccounting {
+	/** Includes unknown/malformed/duplicate history and reserved append attempts. */
+	chargedEntries: number;
+	/** null means the lifetime baseline is unaccountable; persistence is disabled. */
+	chargedPayloadBytes: number | null;
+	persistenceDisabled: boolean;
+}
+
+export interface ArchiveEvidence {
+	accounting: ResultAccounting;
+	warnings: ResultWarning[];
+}
+
+export interface ArchiveFailure extends ArchiveEvidence {
+	ok: false;
+	reason: "invalid" | "unavailable" | "conflict" | "ambiguous" | "corrupt" | "quota" | "busy";
+	message: string;
+}
+
+export type SaveOutcome = ArchiveFailure | (ArchiveEvidence & {
+	ok: true;
+	ref: string;
+	/** session-entry means append returned normally or data came from native history.
+	 * It is NOT an fsync/crash-survival guarantee. memory-only is never a durable receipt. */
+	storage: ResultStorage;
+	summary: ResultSummary;
+	idempotent: boolean;
+	storageError?: string;
+});
+
+export interface ResultReadRequest { ref: string; offset?: number; limit?: number }
+export type ResultPage = ArchiveFailure | (ArchiveEvidence & {
+	ok: true;
+	summary: ResultSummary;
+	/** Untrusted text; the integration must apply its shared fence on model delivery. */
+	body: string;
+	offset: number;
+	nextOffset?: number;
+	/** Reached the end of the STORED body, not necessarily the original report. */
+	endOfStoredBody: boolean;
+});
+
+export interface ResultListRequest { cursor?: number; limit?: number }
+export type ResultSummaryPage = ArchiveFailure | (ArchiveEvidence & {
+	ok: true;
+	results: ResultSummary[];
+	/** Opaque-in-practice append ordinal, not a run id or a branch-local index. */
+	nextCursor?: number;
+});
+
+export interface TerminalResultArchiveDeps {
+	/** All branches in ONE owning session file. Never read parent/foreign files.
+	 * History entries are immutable host data. Hydration is read-only and runs once.
+	 * Recreate the archive on owner change; adapters must reject stale-owner writes. */
+	entries: () => readonly unknown[];
+	/** Native custom ENTRY, not a model message. May throw after partially committing. */
+	append: (customType: string, data: unknown) => void;
+	persistent: boolean;
+	/** Must return result:<UUID>. The default uses node:crypto.randomUUID(). */
+	makeRef?: () => string;
+	clock?: () => number;
+}

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

package/src/tools/council.ts

@@ -2,9 +2,10 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { fenceUntrusted } from "../core/fence.ts";
-import { expandDetailHint, failureDetails, formatCouncilCallLabel, isInline } from "../extension/shared.ts";
+import { resultReceiptHint } from "../results/retrieval.ts";
+import { expandDetailHint, failureDetails, formatCouncilCallLabel, isInline, toastCause } from "../extension/shared.ts";
 import { knownParams, missingRequiredParams, strategyCatalog } from "../orchestration/strategy.ts";
-import { memberBaseLabel, type RosterMember } from "../orchestration/roster.ts";
+import { memberBaseLabel, parseRuntimeRosterMember, type RosterMember } from "../orchestration/roster.ts";
 import { formatCouncilResult, humanizeAggregateResult } from "../orchestration/render.ts";
 import type { FailureKind } from "../orchestration/types.ts";
 import type { AgentResult } from "../orchestration/types.ts";
@@ -13,6 +14,7 @@ import type { OrchestrationGrammar, Persona } from "../persona/persona.ts";
 import type { PersonaController } from "../persona/controller.ts";
 import { Text } from "@earendil-works/pi-tui";
 import { createReportBody } from "../ui/report-body.ts";
+import { orchestrationLaunchLines, type OrchestrationLaunchSnapshot } from "../ui/orchestration-launch.ts";
 import { compactInlineText, compactVisibleText, sanitizeTerminalText } from "../ui/presentation.ts";
 import { toolUsageField } from "../ui/usage.ts";
 import { emptyUsage } from "../engine/stream.ts";
@@ -24,6 +26,7 @@ export interface CouncilToolDeps {
 	set lastCtx(value: ExtensionContext | undefined);
 	controller: PersonaController;
 	personas: Persona[];
+	launchSnapshot(ctx: ExtensionContext, orch: OrchestrationGrammar): OrchestrationLaunchSnapshot;
 	runStrategyVisible(
 		ctx: ExtensionContext,
 		orch: OrchestrationGrammar,
@@ -60,7 +63,7 @@ export function registerCouncilTool(pi: ExtensionAPI, d: CouncilToolDeps): void
 		members: Type.Optional(
 			Type.Array(Type.Unknown(), {
 				description:
-					'Ephemeral panel members for THIS call — each an installed agent name ("scout") or an inline { agent, role?, model?, skills? } specialisation. They win `roster` and the profile\'s own members for this call only: no team file, persona file, or inherited model/tool is touched. Omit to use the named roster.',
+					'Ephemeral panel members for THIS call — each an installed agent name ("scout") or an inline { agent, role?, model?, thinking?, skills?, tools?, isolation?, mcp? } specialisation. thinking is per-leg requested effort (off/minimal/low/medium/high/xhigh/max); Pi clamps it to model capabilities, overriding the agent and shared child effort defaults. They win `roster` and the profile\'s own members for this call only: no team file, persona file, or inherited model/tool is touched. Omit to use the named roster.',
 			}),
 		),
 		params: Type.Optional(
@@ -113,6 +116,7 @@ ${strategyCatalog()}`,
 			}
 			const { strategy, roster, members, params: mergedParams, persona } = resolved.value;
 			const panel = panelLabel({ roster, members });
+			let launch: OrchestrationLaunchSnapshot | undefined;
 			try {
 				// Fully persona-driven: a persona's `council:` block picks the strategy, roster,
 				// and params — a new ensemble (more members, supermajority, multi-round) needs no
@@ -127,7 +131,9 @@ ${strategyCatalog()}`,
 					if (unknown.length > 0) {
 						const note = `council: ignoring unknown param(s) [${unknown.join(", ")}] for "${strategy}" — known: ${Object.keys(schema).join(", ") || "(none)"}`;
 						if (process.env.PI_PERSONA_DEBUG) process.stderr.write(`[pi-persona] ${note}\n`);
-						ctx.ui.notify(note, "warning");
+						// The toast is bounded/sanitized for the operator; the model-facing paramNote below
+						// keeps the raw note byte-identical (payloads are not presentation).
+						ctx.ui.notify(toastCause(note), "warning");
 						paramNote = `\n\n(${note})`;
 					}
 				}
@@ -135,6 +141,14 @@ ${strategyCatalog()}`,
 				// Ephemeral members ride the SAME grammar path as a named team (see
 				// `resolveOrchestrationMembers`) — nothing about the profile is inherited.
 				if (members) orch.members = members;
+				try {
+					const snapshot = d.launchSnapshot(ctx, orch);
+					launch = { ...snapshot, participants: snapshot.participants.map((p) => ({ ...p })) };
+				} catch {
+					// A display lookup must not change launch admission; its failure is visible, not
+					// replaced with guessed models or an apparently successful empty panel.
+					launch = { participants: [], unavailable: true };
+				}
 				// The same launch `delegate` uses: ONE tracked run. Interactive sessions get a receipt now and
 				// the ruling as ONE completion follow-up (the idle-gated wake, fenced and bounded); headless
 				// sessions join the run before returning, since nothing would deliver a follow-up there.
@@ -146,7 +160,7 @@ ${strategyCatalog()}`,
 					const names = compactInlineText(`${strategy} · ${panel}`, { maxChars: 120 });
 					return {
 						content: [{ type: "text", text: `${launchReceipt("council", id, names, "with the ruling")}${paramNote}` }],
-						details: { runId: id, strategy, roster: panel, persona },
+						details: { runId: id, strategy, roster: panel, persona, launch },
 						isError: false,
 					};
 				}
@@ -155,7 +169,7 @@ ${strategyCatalog()}`,
 				const result = run?.result;
 				if (!result) {
 					const message = run?.error ?? run?.status ?? "the run record is gone";
-					return { content: [{ type: "text", text: `council failed: ${message}` }], details: failureDetails({ error: message, strategy, roster: panel }), isError: true };
+					return { content: [{ type: "text", text: `council failed: ${message}` }], details: failureDetails({ error: message, strategy, roster: panel, ...(launch ? { launch } : {}) }), isError: true };
 				}
 				const s = (result.structured ?? {}) as {
 					headline?: string;
@@ -167,6 +181,7 @@ ${strategyCatalog()}`,
 				};
 				const headline = s.headline ?? (typeof s.count === "number" ? `${s.count} member results` : s.status ?? "");
 				const details = {
+					launch,
 					ok: result.ok,
 					headline,
 					status: s.status,
@@ -179,32 +194,31 @@ ${strategyCatalog()}`,
 					persona,
 					...(result.error ? { error: result.error } : {}),
 					...(result.failureKind ? { failureKind: result.failureKind } : {}),
+					...(run?.resultReceipt ? { resultReceipt: { ...run.resultReceipt } } : {}),
 				};
 				return {
 					// The ruling is sub-agent (council member) text — fence it like every other
 					// path that hands sub-agent output to the supervisor.
 					// A run stopped before it convened has no ruling, only its cause: show that, not an empty fence.
-					content: [{ type: "text", text: `${fenceUntrusted(result.output || result.error || "")}${paramNote}${d.drainBusBlock()}` }],
+					content: [{ type: "text", text: `${fenceUntrusted(result.output || result.error || "")}${run?.resultReceipt ? `\n\n${resultReceiptHint(run.resultReceipt)}` : ""}${paramNote}${d.drainBusBlock()}` }],
 					details: result.ok ? details : failureDetails(details),
 					isError: !result.ok,
 					...toolUsageField(usage),
 				};
 			} catch (err) {
 				const message = err instanceof Error ? err.message : String(err);
-				return { content: [{ type: "text", text: `council failed: ${message}` }], details: failureDetails({ error: message, strategy, roster: panel }), isError: true };
+				return { content: [{ type: "text", text: `council failed: ${message}` }], details: failureDetails({ error: message, strategy, roster: panel, ...(launch ? { launch } : {}) }), isError: true };
 			}
 		},
 		renderCall(args, theme) {
-			const resolved = resolveCouncilInvocation(d.personas, d.controller.activePersona, {
-				persona: args.persona,
-				strategy: args.strategy,
-				roster: args.roster,
-				members: args.members,
-				params: args.params as Record<string, unknown> | undefined,
-			});
-			const strategy = resolved.ok ? resolved.value.strategy : (args.strategy ?? "?");
-			// With inline members there is no named team to name — label the panel itself.
-			const roster = resolved.ok ? panelLabel(resolved.value) : (args.roster ?? args.persona ?? "?");
+			// Native Pi draws the call before its saved result. Keep this title args-only and
+			// neutral about omitted defaults; the receipt below carries the resolved snapshot.
+			const members = Array.isArray(args.members) ? args.members.flatMap((raw) => {
+				const parsed = parseRuntimeRosterMember(raw);
+				return parsed.ok ? [parsed.member] : [];
+			}) : [];
+			const strategy = args.strategy ?? "profile defaults";
+			const roster = members?.length ? panelLabel({ roster: "", members }) : args.roster ?? args.persona ?? "profile roster";
 			return new Text(theme.fg("toolTitle", theme.bold(formatCouncilCallLabel(strategy, roster))), 0, 0);
 		},
 		renderResult(result, { expanded }, theme, context) {
@@ -220,6 +234,7 @@ ${strategyCatalog()}`,
 				error?: string;
 				failureKind?: FailureKind;
 				runId?: string;
+				launch?: OrchestrationLaunchSnapshot;
 			};
 			const first = result.content[0];
 			const failed = (context?.isError ?? result.isError) || d.ok === false || !!d.error;
@@ -227,27 +242,29 @@ ${strategyCatalog()}`,
 				// Interactive launch receipt: the ruling arrives later as the completion follow-up.
 				const launched = failed ? theme.fg("error", theme.bold("council failed"))
 					: `${theme.fg("toolTitle", theme.bold("council "))}${theme.fg("accent", compactInlineText(`launched ${d.runId} · ${d.strategy ?? "?"} · ${d.roster ?? "?"}`, { maxChars: 120 }))}`;
-				return new Text(expanded && first?.type === "text" ? `${launched}\n${theme.fg("toolOutput", sanitizeTerminalText(first.text))}` : launched, 0, 0);
+				const metadata = orchestrationLaunchLines(d.launch, expanded).join("\n");
+				return new Text([launched, theme.fg("dim", metadata), expanded && first?.type === "text" ? theme.fg("toolOutput", sanitizeTerminalText(first.text)) : ""].filter(Boolean).join("\n"), 0, 0);
 			}
 			const body = sanitizeTerminalText(d.body || (first && first.type === "text" ? first.text : ""));
+			const metadata = d.launch ? `\n\nLaunch request (Pi may clamp effort):\n${orchestrationLaunchLines(d.launch, expanded).join("\n")}` : "";
 			if (failed) {
 				const cause = compactInlineText([d.failureKind, d.error].filter((part): part is string => !!part).join(" · "), { maxChars: 160 });
 				const title = () => theme.fg("error", theme.bold(`council failed${cause ? ` · ${cause}` : ""}`));
 				if (expanded) {
 					// Only a completed council retains a ruling body; preflight/host errors are literal.
-					if (typeof d.body === "string") return createReportBody(body || "(no ruling)", theme, { header: title }, context?.lastComponent);
-					return new Text(`${title()}\n${theme.fg("toolOutput", body || "(no ruling)")}`, 0, 0);
+					if (typeof d.body === "string") return createReportBody(`${body || "(no ruling)"}${metadata}`, theme, { header: title }, context?.lastComponent);
+					return new Text(`${title()}\n${theme.fg("toolOutput", body || "(no ruling)")}${theme.fg("dim", metadata)}`, 0, 0);
 				}
 				const preview = compactVisibleText(body || "(no ruling)", { maxLines: 3, maxLineChars: 100 });
 				const hint = preview.truncated ? `\n${theme.fg("dim", expandDetailHint())}` : "";
-				return new Text(`${title()}\n${theme.fg("toolOutput", preview.text)}${hint}`, 0, 0);
+				return new Text(`${title()}\n${theme.fg("toolOutput", preview.text)}${hint}${theme.fg("dim", metadata)}`, 0, 0);
 			}
 			const text = formatCouncilResult(
 				{ headline: d.headline, status: d.status, tally: d.tally, usedFallback: d.usedFallback, body },
 				expanded,
 				expandDetailHint(),
 			);
-			return expanded ? createReportBody(text, theme, {}, context?.lastComponent) : new Text(theme.fg("accent", text), 0, 0);
+			return expanded ? createReportBody(`${text}${metadata}`, theme, {}, context?.lastComponent) : new Text(`${theme.fg("accent", text)}${theme.fg("dim", metadata)}`, 0, 0);
 		},
 	});
 }