pi-crew 0.9.11 → 0.9.13

package/src/runtime/background-runner.ts

@@ -25,6 +25,19 @@ import type { executeTeamRun as ExecuteTeamRunFn } from "./team-runner.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 
 let _cachedExecuteTeamRun: typeof ExecuteTeamRunFn | undefined;
+
+/** Maximum runtime for a single background run before the watchdog force-aborts
+ *  it. Prevents zombie background-runner processes when a team run hangs forever
+ *  (e.g. a hung child Pi process, a stuck lock, or a test that spawns a run
+ *  without cleanup). Default 2h — generous for legitimate long runs (research
+ *  workflows, goal-loops) but catches true zombies (observed: 10h+ stale test
+ *  runs). Override via PI_CREW_MAX_RUN_MS env (milliseconds). The watchdog
+ *  aborts via the shared AbortController, then force-exits after a grace
+ *  period in case the abort signal does not propagate to all execution paths. */
+const MAX_BACKGROUND_RUN_MS = (() => {
+	const env = Number.parseInt(process.env.PI_CREW_MAX_RUN_MS ?? "", 10);
+	return Number.isFinite(env) && env > 0 ? env : 2 * 60 * 60 * 1000;
+})();
 async function executeTeamRun(
 	...args: Parameters<typeof ExecuteTeamRunFn>
 ): Promise<Awaited<ReturnType<typeof ExecuteTeamRunFn>>> {
@@ -234,6 +247,7 @@ function runCleanup(
 	stopParentGuard: () => void,
 	stopHeartbeat: () => void,
 	keepAlive: NodeJS.Timeout,
+	watchdogTimer: NodeJS.Timeout,
 	exitDueToRejection: boolean,
 	eventsPath?: string,
 ): void {
@@ -245,6 +259,9 @@ function runCleanup(
 	// FIX: clearInterval FIRST, then kill children. This ensures the heartbeat
 	// interval is always cleaned up even if terminateActiveChildPiProcesses throws.
 	clearInterval(keepAlive);
+	// Clear the anti-zombie watchdog so a normally-completing run does not
+	// carry a pending force-exit timer into the exit path.
+	clearTimeout(watchdogTimer);
 	// FIX Issues #1, #2, #4: Wrap child process termination in try/catch so errors
 	// don't prevent the cleanup from completing. We log but don't re-throw since
 	// we're already exiting.
@@ -563,6 +580,37 @@ async function main(): Promise<void> {
 	// bounded by the 5s interval. The event loop exit is deferred at most 5s.
 	const keepAlive = setInterval(() => {}, 5000);
 
+	// WATCHDOG (anti-zombie): if the run exceeds MAX_BACKGROUND_RUN_MS without
+	// completing, abort it and force-exit. Without this, a hung team run
+	// (stuck child Pi, deadlocked lock, test that never cleans up) leaves the
+	// background-runner alive forever because keepAlive holds the event loop.
+	// The watchdog fires once; it is cleared in the finally block via runCleanup.
+	const watchdogTimer = setTimeout(() => {
+		console.error(`[background-runner] WATCHDOG: run ${runId} exceeded ${MAX_BACKGROUND_RUN_MS}ms — aborting (zombie prevention)`);
+		try {
+			appendEvent(manifest.eventsPath, {
+				type: "async.watchdog_fired",
+				runId,
+				message: `Run exceeded ${MAX_BACKGROUND_RUN_MS}ms and was force-aborted to prevent a zombie background-runner process.`,
+				data: { maxRunMs: MAX_BACKGROUND_RUN_MS },
+			});
+		} catch { /* best-effort event log */ }
+		// Signal the finally block to exit(1) after cleanup.
+		exitDueToRejection = true;
+		// Abort the in-flight team run via the shared signal (propagates to
+		// executeTeamRun → child-pi → kills child processes).
+		abortController.abort();
+		// Hard-exit safety net: if the abort does not propagate within 15s
+		// (e.g. a hung native call), force-kill so the process cannot linger.
+		const forceExit = setTimeout(() => {
+			console.error(`[background-runner] WATCHDOG: abort did not propagate within grace period — force-exiting`);
+			stopParentGuard();
+			try { terminateActiveChildPiProcesses(); } catch { /* best-effort */ }
+			process.exit(1);
+		}, 15_000);
+		forceExit.unref();
+	}, MAX_BACKGROUND_RUN_MS);
+
 	try {
 		debugLog(`[background-runner] about to call discoverAgents`);
 		const agents = allAgents(discoverAgents(cwd));
@@ -798,6 +846,7 @@ async function main(): Promise<void> {
 				stopParentGuard,
 				stopHeartbeat,
 				keepAlive,
+				watchdogTimer,
 				exitDueToRejection,
 				manifest.eventsPath,
 			);

package/src/runtime/chain-runner.ts

@@ -496,25 +496,54 @@ export class ChainRunner {
 			return context;
 		}
 
-		// Limit history size to prevent memory leak (H2)
-		const limitedHandoffs = handoffs.slice(-ChainRunner.MAX_CHAIN_HISTORY_SIZE);
+		const notes: string[] = [];
+
+		// Limit history size to prevent memory leak (H2). Emit a marker so a dropped
+		// entry does not vanish silently — this was the only silent-loss path in the
+		// output-handling machinery (see research-findings/output-handling-deep-dive.md §F).
+		let limitedHandoffs = handoffs;
+		if (handoffs.length > ChainRunner.MAX_CHAIN_HISTORY_SIZE) {
+			const dropped = handoffs.length - ChainRunner.MAX_CHAIN_HISTORY_SIZE;
+			notes.push(`[chain history limited to last ${ChainRunner.MAX_CHAIN_HISTORY_SIZE} entries; ${dropped} older entr${dropped === 1 ? "y" : "ies"} omitted]`);
+			limitedHandoffs = handoffs.slice(-ChainRunner.MAX_CHAIN_HISTORY_SIZE);
+		}
 
-		// Limit per-entry size to prevent memory issues from large artifacts
+		// Limit per-entry size to prevent memory issues from large artifacts.
 		const filteredHandoffs = limitedHandoffs.filter(h => {
 			const size = JSON.stringify(h).length;
 			return size <= ChainRunner.MAX_HANDOFF_ENTRY_SIZE;
 		});
+		const oversizedDropped = limitedHandoffs.length - filteredHandoffs.length;
+		if (oversizedDropped > 0) {
+			notes.push(`[${oversizedDropped} handoff entr${oversizedDropped === 1 ? "y" : "ies"} omitted (> ${ChainRunner.MAX_HANDOFF_ENTRY_SIZE} bytes each)]`);
+		}
 
-		return {
-			...context,
-			__chainHistory: filteredHandoffs.map(h => ({
+		// Track array-cap drops so capped lists do not vanish silently. Each field
+		// over its cap records the full count so a reader knows data was elided.
+		const arrayCapNotes: string[] = [];
+		const mapped = filteredHandoffs.map(h => {
+			const over: string[] = [];
+			if (h.filesCreated && h.filesCreated.length > 50) over.push(`filesCreated=${h.filesCreated.length}`);
+			if (h.filesModified && h.filesModified.length > 50) over.push(`filesModified=${h.filesModified.length}`);
+			if (h.decisions && h.decisions.length > 20) over.push(`decisions=${h.decisions.length}`);
+			if (h.nextSteps && h.nextSteps.length > 20) over.push(`nextSteps=${h.nextSteps.length}`);
+			if (over.length > 0) arrayCapNotes.push(`step ${h.taskId}: ${over.join(", ")} (capped)`);
+			return {
 				step: h.taskId,
 				outcome: h.outcome,
 				filesCreated: h.filesCreated?.slice(0, 50), // Limit array size
 				filesModified: h.filesModified?.slice(0, 50), // Limit array size
 				decisions: h.decisions?.slice(0, 20), // Limit array size
 				nextSteps: h.nextSteps?.slice(0, 20), // Limit array size
-			})),
+				...(h.outputText ? { outputText: h.outputText.slice(0, 5000) } : {}), // Size-capped worker output
+			};
+		});
+		if (arrayCapNotes.length > 0) notes.push(`[list caps applied: ${arrayCapNotes.join("; ")}]`);
+
+		return {
+			...context,
+			__chainHistory: mapped,
+			...(notes.length > 0 ? { __chainHistoryNotes: notes } : {}),
 		};
 	}
 
@@ -525,13 +554,23 @@ export class ChainRunner {
 		config: ChainStep,
 		context: Record<string, unknown>
 	): Promise<TaskResult> {
+		// Pass step config (team/workflow/model) into the packet context so the
+		// concrete ChainTaskRunner can resolve which team/workflow to run. Without
+		// this, a step parsed to a @teamName reference would lose its team because
+		// the only channel from executeStep to runTask is the TaskPacket. Purely
+		// additive — adds sibling keys alongside __chainHistory/Notes.
 		const packet: TaskPacket = {
 			taskId: `chain-${Date.now()}-${config.name}`,
 			runId: "chain",
 			goal: config.inlineGoal ?? config.name,
 			summarizeThreshold: 3000,
 			collapseContext: true,
-			context,
+			context: {
+				...context,
+				__chainStepTeam: config.team,
+				__chainStepWorkflow: config.workflow,
+				__chainStepModel: config.model,
+			},
 		};
 
 		return this.taskRunner.runTask(packet);

package/src/runtime/child-pi.ts

@@ -17,6 +17,7 @@ import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
 import { registerChildProcess, unregisterChildProcess } from "../extension/crew-cleanup.ts";
 import { classifyProcessCrash } from "./crash-classification.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { extractText } from "./pi-json-output.ts";
 
 const POST_EXIT_STDIO_GUARD_MS = DEFAULT_CHILD_PI.postExitStdioGuardMs;
 const FINAL_DRAIN_MS = DEFAULT_CHILD_PI.finalDrainMs;
@@ -218,6 +219,13 @@ export interface ChildPiRunResult {
 	stdout: string;
 	stderr: string;
 	error?: string;
+	/** RAW (uncapped) final assistant text, captured at stream-parse time BEFORE
+	 *  the 16K transcript compaction. This is the AUTHORITATIVE worker output —
+	 *  it becomes results/<id>.txt so downstream dependencies are not bounded by
+	 *  the transcript's telemetry cap. Undefined when no assistant text was seen
+	 *  (mock paths, error paths) — callers MUST fall back to transcript-derived
+	 *  finalText. See research-findings/output-handling-deep-dive.md §A. */
+	rawFinalText?: string;
 	exitStatus?: WorkerExitStatus;
 	/** True if the agent was hard-aborted (max_turns + grace exceeded). */
 	aborted?: boolean;
@@ -512,6 +520,12 @@ function compactChildPiLine(line: string): { persistedLine: string; event?: unkn
 export class ChildPiLineObserver {
 	private buffer = "";
 	private readonly input: ChildPiRunInput;
+	/** RAW (uncapped) assistant-text fragments, accumulated in arrival order.
+	 *  Mirrors {@link parsePiJsonOutput}'s textEvents/finalText extraction but
+	 *  operates on the RAW event stream instead of the 16K-compacted transcript.
+	 *  This is the source of the AUTHORITATIVE result.txt; the transcript stays
+	 *  compacted (memory bound). */
+	private readonly rawTextEvents: string[] = [];
 
 	constructor(input: ChildPiRunInput) {
 		this.input = input;
@@ -531,8 +545,26 @@ export class ChildPiLineObserver {
 		this.emitLine(line);
 	}
 
+	/** Last non-empty RAW assistant text (mirrors {@link parsePiJsonOutput}'s
+	 *  finalText semantics but uncapped). Undefined when no assistant text was
+	 *  seen by this observer. {@link extractText} already drops empty fragments,
+	 *  so the last entry is the final assistant utterance. */
+	getRawFinalText(): string | undefined {
+		return this.rawTextEvents.length > 0 ? this.rawTextEvents[this.rawTextEvents.length - 1] : undefined;
+	}
+
 	private emitLine(line: string): void {
 		if (!line.trim()) return;
+		// Parse the RAW line once so we can BOTH compact it (telemetry transcript,
+		// 16K-capped memory bound) AND capture the uncapped assistant text for the
+		// authoritative result. Non-JSON lines contribute no assistant text.
+		try {
+			const rawParsed = JSON.parse(line);
+			const rawTexts = extractText(rawParsed);
+			if (rawTexts.length > 0) this.rawTextEvents.push(...rawTexts);
+		} catch {
+			// Not valid JSON — compactChildPiLine handles the raw-text fallback below.
+		}
 		const compact = compactChildPiLine(line);
 		if (compact.event !== undefined) {
 			try {
@@ -919,6 +951,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				try {
 					resolve({
 						...result,
+						rawFinalText: lineObserver.getRawFinalText(),
 						exitStatus: result.exitStatus ?? {
 							exitCode: result.exitCode,
 							cancelled: abortRequested,

package/src/runtime/handoff-manager.ts

@@ -99,6 +99,9 @@ export interface HandoffSummary {
 
 	// Context snapshot
 	contextSnapshot: string;
+
+	/** Worker output text propagated through the chain (read from resultArtifact). */
+	outputText?: string;
 }
 
 /**
@@ -121,6 +124,9 @@ export interface TaskResult {
 	filesDeleted?: string[];
 	decisions?: Decision[];
 	error?: string;
+
+	/** Worker's textual output (read from resultArtifact during chain execution). */
+	outputText?: string;
 }
 
 /**
@@ -443,6 +449,7 @@ export class HandoffManager {
 			},
 
 			contextSnapshot,
+			...(result.outputText ? { outputText: result.outputText } : {}),
 		};
 	}
 

package/src/runtime/live-session-runtime.ts

@@ -4,8 +4,13 @@ import type { AgentConfig } from "../agents/agent-config.ts";
 import type { CrewRuntimeConfig } from "../config/config.ts";
 import type { TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { appendEvent } from "../state/event-log.ts";
-import { buildMemoryBlock } from "./agent-memory.ts";
 import { trackTaskUsage } from "./usage-tracker.ts";
+// NOTE: buildMemoryBlock is intentionally NOT imported here. The agent memory
+// block is injected via renderTaskPrompt().full (the USER prompt), which is
+// shared by both the child-pi path (no system prompt) and the live-session
+// path. Adding it to liveSystemPrompt() too duplicated the entire memory
+// block (up to 200 lines) in both the user and system prompts. Keep memory
+// in a single place: the shared user prompt. See G3 fix.
 import { createStreamingOutput, type StreamingOutputHandle } from "./streaming-output.ts";
 import { registerLiveAgent, disposeLiveAgentSession, terminateLiveAgent, updateLiveAgentStatus, trackLiveAgentToolStart, trackLiveAgentToolEnd, trackLiveAgentTurnEnd, trackLiveAgentResponseText, markLiveAgentCompleted } from "./live-agent-manager.ts";
 import { applyLiveAgentControlRequest, applyLiveAgentControlRequests, type LiveAgentControlCursor } from "./live-agent-control.ts";
@@ -371,8 +376,10 @@ function compressSessionToolDescriptions(session: LiveSessionLike): void {
 	// is loaded and tree-shakeable, so adding the actual logic later is trivial.
 }
 
-function liveSystemPrompt(input: LiveSessionSpawnInput): string {
-	const memory = input.agent.memory ? buildMemoryBlock(input.agent.name, input.agent.memory, input.task.cwd, Boolean(input.agent.tools?.some((tool) => tool === "write" || tool === "edit"))) : "";
+export function liveSystemPrompt(input: LiveSessionSpawnInput): string {
+	// Agent MEMORY is intentionally omitted here — it is already injected via
+	// renderTaskPrompt().full (the user prompt, shared with the child-pi path).
+	// See the import-block note above and the G3 fix.
 	const role = input.task.role;
 	const styleBlock = buildCommunicationStyle(role);
 	const contractBlock = buildOutputContract(role);
@@ -390,7 +397,6 @@ function liveSystemPrompt(input: LiveSessionSpawnInput): string {
 		sensitiveConstraint,
 		"",
 		input.agent.systemPrompt || "Follow the user task exactly and report verification evidence.",
-		memory ? `\n${memory}` : "",
 	].filter(Boolean).join("\n");
 }
 

package/src/runtime/pi-json-output.ts

@@ -75,7 +75,11 @@ function textFromContent(content: unknown): string[] {
 	return text;
 }
 
-function extractText(value: unknown): string[] {
+/** Extract assistant-text fragments from a parsed Pi JSON event.
+ *  Exported so {@link ChildPiLineObserver} can capture the RAW (uncapped)
+ *  assistant text for the authoritative result, mirroring the extraction
+ *  order this function uses inside {@link parsePiJsonOutput}. */
+export function extractText(value: unknown): string[] {
 	const obj = asRecord(value);
 	if (!obj) return [];
 	const message = asRecord(obj.message);

package/src/runtime/process-status.ts

@@ -16,7 +16,11 @@ export interface ProcessLiveness {
  */
 const ORPHANED_ACTIVE_RUN_MS = 2 * 60 * 1000;
 /** How long a completed run stays visible in the widget after completion. */
-const COMPLETED_VISIBILITY_GRACE_MS = 8000;
+const COMPLETED_VISIBILITY_GRACE_MS = 8_000;
+/** Errors (failed/cancelled) linger far longer so a failed run leaves a visible
+ * trace in the crew widget for ~10 min (F-5). Successful completions vanish
+ * quickly to keep the widget quiet. */
+const ERROR_VISIBILITY_GRACE_MS = 10 * 60 * 1000;
 /** Maximum age (ms) for an active run before it's considered stale.
  * After this time, PID-only liveness is unreliable due to PID recycling. */
 const STALE_ACTIVE_RUN_MS = 30 * 60 * 1000;
@@ -120,12 +124,13 @@ export function isDisplayActiveRun(run: TeamRunManifest, agents: CrewAgentRecord
 	}
 	// Grace period: show completed runs for a few seconds so users see the result.
 	if (run.status === "completed" || run.status === "failed" || run.status === "cancelled") {
+		const grace = run.status === "completed" ? COMPLETED_VISIBILITY_GRACE_MS : ERROR_VISIBILITY_GRACE_MS;
 		const lastAgentActivity = agents.reduce<number>((max, agent) => {
 			const ts = agent.completedAt ?? agent.startedAt;
 			const parsed = ts ? new Date(ts).getTime() : 0;
 			return Number.isFinite(parsed) && parsed > max ? parsed : max;
 		}, new Date(run.updatedAt).getTime());
-		if (Number.isFinite(lastAgentActivity) && now - lastAgentActivity < COMPLETED_VISIBILITY_GRACE_MS) return true;
+		if (Number.isFinite(lastAgentActivity) && now - lastAgentActivity < grace) return true;
 		return false;
 	}
 	if (!isActiveRunStatus(run.status)) return false;

package/src/runtime/task-output-context.ts

@@ -14,6 +14,12 @@ export interface DependencyContextEntry {
 	status: string;
 	resultSummary: string;
 	resultPath?: string;
+	/** Absolute path to the FULL (untruncated) result, teed when the inline
+	 *  resultSummary was materially truncated (>TEE_THRESHOLD_MULTIPLIER). The
+	 *  downstream worker can `read` this to recover the dropped middle. Mirrors
+	 *  the sharedReads recovery path so dependency injection is no longer
+	 *  circular (re-reading resultPath used to yield the same truncated text). */
+	fullOutputPath?: string;
 	structuredResults?: Record<string, unknown>;
 	artifactsProduced?: string[];
 	usage?: { inputTokens: number; outputTokens: number; durationMs: number };
@@ -50,6 +56,16 @@ function containedExists(filePath: string, baseDir?: string): boolean {
  */
 export const MAX_RESULT_INLINE_BYTES = 32_000;
 
+/**
+ * Tee-recovery multiplier (R2). A shared artifact is teed to disk — so the
+ * downstream worker can `read` the dropped middle — when its size exceeds
+ * this fraction of {@link MAX_RESULT_INLINE_BYTES}. Lowered from 2.0
+ * (64 KB) to 1.25 (40 KB) so the 32–64 KB band, where the head+tail split
+ * is already materially lossy for structured content, also gets a recovery
+ * path instead of losing the middle forever.
+ */
+export const TEE_THRESHOLD_MULTIPLIER = 1.25;
+
 /**
  * Read a file and return its content, truncating to a head+tail slice if it
  * exceeds {@link MAX_RESULT_INLINE_BYTES} characters. Multi-byte UTF-8
@@ -110,10 +126,11 @@ function writeTeeFile(fullOutputPath: string, content: string): boolean {
  * content AND (when tee was actually written) the absolute path to the full
  * file. Returns undefined if the file cannot be read at all.
  *
- * Tee threshold: only when content.length > 2 * MAX_RESULT_INLINE_BYTES
- * (the head+tail is materially lossy — small over-threshold files are not
- * teed because the inline content is mostly intact and the worker can live
- * with the 75/25 split). File content is read once and reused for both the
+ * Tee threshold: only when content.length > TEE_THRESHOLD_MULTIPLIER ×
+ * MAX_RESULT_INLINE_BYTES (R2: 1.25× = 40 KB; previously 2× = 64 KB). Below
+ * the tee threshold the head+tail split is mostly intact and the worker can
+ * live with it; at/above the threshold the dropped middle is recoverable via
+ * the teed full file. File content is read once and reused for both the
  * pipeline (truncation) and the tee write (full file).
  *
  * Truncation behavior is unchanged from the P0-A pipeline: ANSI strip +
@@ -131,8 +148,10 @@ export function readIfSmallWithTee(
 		const content = fs.readFileSync(safePath, "utf-8");
 		if (content.length > maxChars) {
 			let fullOutputPath: string | undefined;
-			// Tee only when truncation is materially lossy (>2× threshold).
-			if (opts.tee && content.length > maxChars * 2) {
+			// Tee when truncation is materially lossy (>TEE_THRESHOLD_MULTIPLIER ×
+			// threshold). R2: lowered from 2× (64 KB) to 1.25× (40 KB) so the
+			// 32–64 KB band also gets a recovery path.
+			if (opts.tee && content.length > maxChars * TEE_THRESHOLD_MULTIPLIER) {
 				if (writeTeeFile(opts.tee.fullOutputPath, content)) {
 					fullOutputPath = opts.tee.fullOutputPath;
 				}
@@ -267,13 +286,18 @@ export function collectDependencyOutputContext(manifest: TeamRunManifest, tasks:
 	const byStep = new Map(tasks.map((item) => [item.stepId, item]).filter((entry): entry is [string, TeamTaskState] => Boolean(entry[0])));
 	const byId = new Map(tasks.map((item) => [item.id, item]));
 	const dependencies = task.dependsOn.map((dep) => byStep.get(dep) ?? byId.get(dep)).filter((item): item is TeamTaskState => Boolean(item)).map((item) => {
-		const resultText = item.resultArtifact ? readIfSmall(item.resultArtifact.path, manifest.artifactsRoot) : undefined;
+		const fullOutputPath = item.resultArtifact ? teePathForArtifact(manifest.artifactsRoot, task.id, item.id) : undefined;
+		const teeResult = item.resultArtifact
+			? readIfSmallWithTee(item.resultArtifact.path, { baseDir: manifest.artifactsRoot, ...(fullOutputPath ? { tee: { fullOutputPath } } : {}) })
+			: undefined;
+		const resultText = teeResult?.content;
 		return {
 			taskId: item.id,
 			role: item.role,
 			status: item.status,
 			resultSummary: resultText ?? "",
 			resultPath: item.resultArtifact?.path,
+			...(teeResult?.fullOutputPath ? { fullOutputPath: teeResult.fullOutputPath } : {}),
 			structuredResults: resultText ? tryParseJson(resultText) : undefined,
 			artifactsProduced: listTaskArtifacts(manifest, item.id),
 			usage: aggregateUsage(item),
@@ -317,6 +341,11 @@ export function renderDependencyOutputContext(context: DependencyOutputContext):
 		parts.push("# Dependency Outputs", "");
 		for (const dep of context.dependencies) {
 			parts.push(`## ${dep.taskId} (${dep.role})`, `Status: ${dep.status}`, dep.resultPath ? `Result artifact: ${dep.resultPath}` : "", "", dep.resultSummary?.trim() || "(no result output)", "");
+			// P1-A dependency tee-recovery hint: when the dependency's result was
+			// materially truncated (>1.25× MAX_RESULT_INLINE_BYTES) the full RAW
+			// content was teed to fullOutputPath. Mirrors the sharedReads hint so the
+			// downstream worker can read the dropped middle instead of re-deriving.
+			if (dep.fullOutputPath) parts.push(`Full output (if you need the missing middle): ${dep.fullOutputPath}`, "");
 			if (dep.structuredResults) parts.push("Structured results:", JSON.stringify(dep.structuredResults, null, 2), "");
 			if (dep.artifactsProduced?.length) parts.push(`Artifacts produced: ${dep.artifactsProduced.join(", ")}`, "");
 			if (dep.usage) parts.push(`Usage: ${dep.usage.inputTokens} input tokens, ${dep.usage.outputTokens} output tokens, ${dep.usage.durationMs}ms`, "");

package/src/runtime/task-runner/prompt-builder.ts

@@ -120,7 +120,11 @@ export async function renderTaskPrompt(manifest: TeamRunManifest, step: Workflow
 		// O4: project knowledge (.crew/knowledge.md) — workers don't load the
 		// pi-crew extension (spawned with --no-extensions), so before_agent_start
 		// never fires for them. Inject here so every worker sees project knowledge.
-		buildKnowledgeFragment(task.cwd),
+		buildKnowledgeFragment(task.cwd, {
+			goal: manifest.goal,
+			taskText: step.task,
+			role: step.role,
+		}),
 	].filter(Boolean).join("\n");
 
 	// Dynamic suffix: goal, step, skills, task packet, dependency context, memory — changes per task

package/src/runtime/task-runner.ts

@@ -342,6 +342,7 @@ export async function runTeamTask(
 		let error: string | undefined;
 		let modelAttempts: ModelAttemptSummary[] | undefined;
 		let parsedOutput: ParsedPiJsonOutput | undefined;
+	let rawFinalText: string | undefined;
 		let finalStdout = "";
 		let transcriptPath: string | undefined;
 		let terminalEvidence: OperationTerminalEvidence[] = [];
@@ -717,6 +718,7 @@ export async function runTeamTask(
 					childResult.stdout,
 				);
 				parsedOutput = parsePiJsonOutput(transcriptText);
+				rawFinalText = childResult.rawFinalText;
 				error =
 					childResult.error ||
 					(childResult.exitCode && childResult.exitCode !== 0
@@ -836,6 +838,11 @@ export async function runTeamTask(
 				kind: "result",
 				relativePath: `results/${task.id}.txt`,
 				content:
+					// Prefer the RAW (uncapped) final assistant text captured before the
+					// transcript's 16K compaction — this is the authoritative worker output.
+					// Fall back to transcript-derived finalText, then stdout/stderr, so a
+					// missing raw capture (mock/error path) never yields empty/garbage.
+					cleanResultText(rawFinalText) ??
 					cleanResultText(parsedOutput?.finalText) ??
 					cleanResultText(finalStdout) ??
 					cleanResultText(finalStderr) ??

package/src/schema/team-tool-schema.ts

@@ -114,6 +114,12 @@ export const TeamToolParams = Type.Object({
 	goal: Type.Optional(
 		Type.String({ description: "High-level objective for a team run." }),
 	),
+	chain: Type.Optional(
+		Type.String({
+			description:
+				'Chain expression: "step1 -> step2 -> step3". Runs each step as a sequential team run, passing handoff context forward via the goal text. Supports inline goals ("...") and @team references. e.g. chain=\'"Research X" -> "Analyze" -> "Write report"\'.',
+		}),
+	),
 	task: Type.Optional(
 		Type.String({
 			description: "Concrete task text for direct role/agent execution.",
@@ -370,6 +376,9 @@ export interface TeamToolParamsValue {
 	role?: string;
 	agent?: string;
 	goal?: string;
+	/** Chain expression: "step1 -> step2 -> step3". Runs each step as a sequential
+	 *  team run with handoff context passed forward via the goal. */
+	chain?: string;
 	task?: string;
 	singleAgent?: boolean;
 	runId?: string;

package/src/ui/crew-footer.ts

@@ -90,9 +90,9 @@ export class CrewFooter {
 		].join(" • ");
 		const badges = this.data.badges?.length ? this.data.badges.map((badge) => `[${badge}]`).join(" ") : "";
 		this.cacheLines = [
-			this.theme.fg("dim", pad(truncate(firstParts.join(" • "), lineWidth, "..."), lineWidth)),
-			this.theme.fg("dim", pad(truncate(usageLine, lineWidth, "..."), lineWidth)),
-			this.theme.fg("dim", pad(truncate(badges, lineWidth, "..."), lineWidth)),
+			this.theme.fg("dim", pad(truncate(firstParts.join(" • "), lineWidth), lineWidth)),
+			this.theme.fg("dim", pad(truncate(usageLine, lineWidth), lineWidth)),
+			this.theme.fg("dim", pad(truncate(badges, lineWidth), lineWidth)),
 		];
 		this.cacheKey = key;
 		this.cacheWidth = width;

package/src/ui/crew-select-list.ts

@@ -86,7 +86,7 @@ export class CrewSelectList<T = string> {
 			const suffix = item.description ? this.theme.fg("dim", ` — ${item.description}`) : "";
 			const raw = `${prefix}${item.label}${suffix}`;
 			const line = index === this.selectedIndex ? this.theme.inverse?.(raw) ?? raw : raw;
-			lines.push(pad(truncate(line, width, "..."), Math.max(1, width)));
+			lines.push(pad(truncate(line, width), Math.max(1, width)));
 		}
 		if (hasBottom) lines.push(this.theme.fg("muted", `↓ ${this.items.length - (this.scrollOffset + slots)} more`));
 		return lines.slice(0, maxHeight);

package/src/ui/dashboard-panes/agents-pane.ts

@@ -6,6 +6,28 @@ import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
 import { formatCost } from "../../state/usage.ts";
 import { listLiveAgents, listLiveAgentsByWorkspace, type LiveAgentHandle } from "../../runtime/live-agent-manager.ts";
 import { computeLiveDurationMs } from "../live-duration.ts";
+import { visibleWidth } from "../../utils/visual.ts";
+
+/**
+ * Fixed visible widths for the per-agent numeric metrics (finding V-1).
+ * Right-aligning each field to a constant width stops the right edge of the
+ * stats block from jittering every tick as values change width
+ * (e.g. `9.9s`→`10.0s`, `950`→`1.0k`, `$0.9`→`$1.0`).
+ */
+const TOKENS_METRIC_WIDTH = 5; // `1.2k`, `12.3k`, `123`
+const COST_METRIC_WIDTH = 7; // `$0.0500`, `$1.50`
+const DURATION_METRIC_WIDTH = 6; // `3.0s`, `59.9s`, `120.0s`
+
+/**
+ * Width-aware right-align (padStart) for a numeric metric so its column stays
+ * stable across ticks. Uses `visibleWidth` so wide/CJK glyphs never misalign
+ * the padding. Values wider than `width` are returned verbatim (no truncation)
+ * so outliers overflow gracefully instead of crashing the render.
+ */
+function alignMetric(value: string, width: number): string {
+	const gap = width - visibleWidth(value);
+	return gap > 0 ? " ".repeat(gap) + value : value;
+}
 
 /**
  * Returns true if this agent did real work (LLM call, tool use, or non-trivial duration).
@@ -89,12 +111,12 @@ export function renderAgentsPane(snapshot: RunUiSnapshot | undefined, options: R
 		const tokenTotal = (agent.usage?.input ?? 0) + (agent.usage?.output ?? 0) + (agent.usage?.cacheRead ?? 0) + (agent.usage?.cacheWrite ?? 0);
 		if (tokenTotal > 0) {
 			const tok = tokenTotal >= 1000 ? `${(tokenTotal / 1000).toFixed(1)}k` : `${tokenTotal}`;
-			stats.push(tok);
+			stats.push(alignMetric(tok, TOKENS_METRIC_WIDTH));
 		}
 		// Per-agent cost (Round 17 BS-1): the data is already on task.usage.cost;
 		// surface it live so the user sees $ burn per agent during a run.
 		if (agent.usage?.cost && agent.usage.cost > 0) {
-			stats.push(formatCost(agent.usage.cost));
+			stats.push(alignMetric(formatCost(agent.usage.cost), COST_METRIC_WIDTH));
 		}
 		if (liveHandle) {
 			// Round 23 (BUG 1): the duration math here was naive —
@@ -104,13 +126,13 @@ export function renderAgentsPane(snapshot: RunUiSnapshot | undefined, options: R
 			// fired for EVERY running live agent in the dashboard. Use the shared,
 			// validated computeLiveDurationMs (mirrors widget-formatters.ts).
 			const ms = computeLiveDurationMs(liveHandle.activity);
-			stats.push(`${(ms / 1000).toFixed(1)}s`);
+			stats.push(alignMetric(`${(ms / 1000).toFixed(1)}s`, DURATION_METRIC_WIDTH));
 			if (options.showModel !== false && liveHandle.modelName && liveHandle.modelName !== "default") {
 				stats.push(liveHandle.modelName);
 			}
 		} else if (agent.startedAt) {
 			const ms = Date.now() - new Date(agent.startedAt).getTime();
-			if (Number.isFinite(ms)) stats.push(`${(ms / 1000).toFixed(1)}s`);
+			if (Number.isFinite(ms)) stats.push(alignMetric(`${(ms / 1000).toFixed(1)}s`, DURATION_METRIC_WIDTH));
 		}
 
 		const statsStr = stats.length ? ` · ${stats.join(" ")}` : "";

package/src/ui/dashboard-panes/cancellation-pane.ts

@@ -40,4 +40,27 @@ export function renderCancellationPane(manifest: TeamRunManifest, tasks: TeamTas
 	}
 
 	return lines;
+}
+
+/**
+ * D-1 / L-2 — a one-line terminal-run reason for the dashboard detail row.
+ *
+ * Surfaces *why* a failed/cancelled/stopped run ended without forcing the
+ * user to switch panes. This also gives this module a real consumer (it was
+ * previously zero-importer dead code per the UI/UX review), wiring it in as
+ * the natural home for cancellation/failure reason display.
+ *
+ * Resolution order: structured `run.cancelled` event reason → first failed
+ * task's error → first policy-decision message.
+ */
+export function summarizeTerminalReason(
+	manifest: TeamRunManifest,
+	tasks: TeamTaskState[],
+	cancellationReason?: string,
+): string | undefined {
+	if (cancellationReason) return cancellationReason;
+	const failed = tasks.find((task) => task.status === "failed" && task.error);
+	if (failed?.error) return failed.error;
+	if (manifest.policyDecisions?.length) return manifest.policyDecisions[0]?.message;
+	return undefined;
 }