pi-crew 0.10.1 → 0.10.2

package/src/runtime/child-pi/child-pi-streams.ts

@@ -11,7 +11,13 @@
 import { logInternalError } from "../../utils/internal-error.ts";
 import { extractText } from "../output/pi-json-output.ts";
 import type { ChildPiRunInput } from "./child-pi.ts";
-import { MAX_ASSISTANT_TEXT_CHARS, MAX_LINE_BUFFER_BYTES, MAX_TOOL_INPUT_CHARS, MAX_TOOL_RESULT_CHARS } from "./child-pi-constants.ts";
+import {
+	MAX_ASSISTANT_TEXT_CHARS,
+	MAX_LINE_BUFFER_BYTES,
+	MAX_THINKING_CHARS,
+	MAX_TOOL_INPUT_CHARS,
+	MAX_TOOL_RESULT_CHARS,
+} from "./child-pi-constants.ts";
 import { appendTranscript, compactString, compactValue, flushPendingTranscriptWrites } from "./child-pi-transcript.ts";
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
@@ -38,6 +44,20 @@ function compactContentPart(part: unknown): unknown | undefined {
 			name: record.name,
 			input: compactValue(typeof record.input === "string" ? compactString(record.input, MAX_TOOL_INPUT_CHARS) : record.input),
 		};
+	// Reasoning is display-only, but the agent view pane renders the FULL
+	// assistant message (AssistantMessageComponent) — without the thinking
+	// parts the pane would look sparse next to a real pi session. Keep them
+	// capped so a long-thinking model cannot balloon the event log.
+	if (record.type === "thinking")
+		return {
+			type: "thinking",
+			thinking:
+				typeof record.thinking === "string"
+					? compactString(record.thinking, MAX_THINKING_CHARS, {
+							preserveImportant: false,
+						})
+					: "",
+		};
 	if (record.type === "toolResult")
 		return {
 			type: "toolResult",

package/src/runtime/detached-run-results.ts

@@ -0,0 +1,90 @@
+/**
+ * Result delivery for runs detached by an agent-view switch.
+ *
+ * Opening an agent view mid-run releases the foreground waiter (see
+ * `detachRunPromise`), so the parent turn settles with a "detached" tool
+ * result and the run keeps executing. Without this module the run's FINAL
+ * result would never reach the conversation: the async notifier only toasts,
+ * and its toast is suppressed while a view session is active (different
+ * session id) or when the run finished before the operator returned to main.
+ *
+ * The registry is in-process; a pending result is parked while an agent view is
+ * open so the worker's own view session never receives the parent's report.
+ */
+import { loadRunManifestById } from "../state/stores/state-store.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { isFinishedRunStatus } from "./process-status.ts";
+
+interface DetachedRun {
+	runId: string;
+	cwd: string;
+}
+
+const detachedRuns = new Map<string, DetachedRun>();
+
+/** Record a run whose foreground waiter was released by a view switch. */
+export function markRunDetached(runId: string, cwd: string): void {
+	if (!runId || !cwd) return;
+	detachedRuns.set(runId, { runId, cwd });
+}
+
+/** Cheap guard for hot paths (render tick): nothing to do when empty. */
+export function hasDetachedRuns(): boolean {
+	return detachedRuns.size > 0;
+}
+
+export function forgetDetachedRun(runId: string): void {
+	detachedRuns.delete(runId);
+}
+
+export function clearDetachedRunsForTest(): void {
+	detachedRuns.clear();
+}
+
+/** Human-readable completion summary for a detached run. */
+export function formatDetachedRunResult(manifest: TeamRunManifest, tasks: TeamTaskState[]): string {
+	const lines = [
+		`pi-crew run ${manifest.status}: ${manifest.runId} (${manifest.team}/${manifest.workflow ?? "none"})`,
+		`Goal: ${manifest.goal}`,
+		"",
+		"This run was detached when you opened an agent view; it finished in the background.",
+	];
+	if (tasks.length > 0) {
+		lines.push("", "Tasks:");
+		for (const task of tasks) {
+			const detail = task.error ? ` — ${task.error}` : "";
+			lines.push(`  • ${task.id} (${task.role ?? "?"}): ${task.status}${detail}`);
+		}
+	}
+	if (manifest.artifactsRoot) lines.push("", `Artifacts: ${manifest.artifactsRoot}`);
+	lines.push(`State: ${manifest.stateRoot}`);
+	return lines.join("\n");
+}
+
+/**
+ * Results of finished detached runs that may be shown in the CURRENT session.
+ * Entries are NOT removed: the caller drops each one with `forgetDetachedRun`
+ * only after the delivery actually succeeded, so a failed send retries on the
+ * next tick instead of losing the run's outcome.
+ *
+ * Gating is by "am I inside an agent view", not by session id: the report must
+ * never land inside a worker's view session, but matching the owner's id is too
+ * brittle (the main session can be replaced/renamed while the view is open, and
+ * the registry is per pi process anyway, so any non-view session here IS the
+ * operator's own).
+ */
+export function peekFinishedDetachedRunResults(options: { inViewSession?: boolean } = {}): { runId: string; text: string }[] {
+	if (detachedRuns.size === 0 || options.inViewSession) return [];
+	const ready: { runId: string; text: string }[] = [];
+	for (const entry of [...detachedRuns.values()]) {
+		const loaded = loadRunManifestById(entry.cwd, entry.runId);
+		if (!loaded) {
+			// Run state vanished (pruned/deleted) — nothing left to report.
+			detachedRuns.delete(entry.runId);
+			continue;
+		}
+		if (!isFinishedRunStatus(loaded.manifest.status)) continue;
+		ready.push({ runId: entry.runId, text: formatDetachedRunResult(loaded.manifest, loaded.tasks) });
+	}
+	return ready;
+}

package/src/runtime/goal-workflow/adaptive-plan.ts

@@ -368,6 +368,11 @@ export interface InjectAdaptivePlanInput {
 	tasks: TeamTaskState[];
 	workflow: WorkflowConfig;
 	team: TeamConfig;
+	/** False for scaffold (dry-run) runs: the planner never executes, so there
+	 *  is no plan to inject — and no plan to be missing. Reports neutral
+	 *  (neither injected nor missing) so the preview completes instead of
+	 *  blocking on a plan a dry-run can never produce. */
+	executeWorkers?: boolean;
 }
 
 export interface InjectAdaptivePlanResult {
@@ -377,8 +382,18 @@ export interface InjectAdaptivePlanResult {
 	missingPlan: boolean;
 }
 
+/**
+ * True for workflows whose `assess` step emits a plan the runtime injects as
+ * concrete tasks. The `implementation` workflow is adaptive by name (historic
+ * hard-code, kept for backward compat); any other workflow opts in via
+ * frontmatter `adaptive: true`.
+ */
+export function isAdaptiveWorkflow(workflow: WorkflowConfig): boolean {
+	return workflow.adaptive === true || workflow.name === "implementation";
+}
+
 export async function injectAdaptivePlanIfReady(input: InjectAdaptivePlanInput): Promise<InjectAdaptivePlanResult> {
-	if (input.workflow.name !== "implementation")
+	if (!isAdaptiveWorkflow(input.workflow) || input.executeWorkers === false)
 		return {
 			tasks: input.tasks,
 			workflow: input.workflow,
@@ -504,11 +519,22 @@ export async function injectAdaptivePlanIfReady(input: InjectAdaptivePlanInput):
 			const itemId = `adaptive-p${phaseIndex + 1}-t${taskIndex + 1}`;
 			const stepId = `adaptive-${phaseIndex + 1}-${taskIndex + 1}-${slug(planned.role)}`;
 			const taskId = `adaptive-${String(counter).padStart(2, "0")}-${slug(planned.role)}`;
+			// Same display contract as static workflow steps: the planner's
+			// title (or the task text's first line) names the task; the full
+			// task text is the description for detail surfaces. Never the bare
+			// stepId — the task list is the plan, not an id roster.
+			const firstLine =
+				planned.task
+					.split("\n")
+					.map((line) => line.trim())
+					.filter(Boolean)
+					.find((line) => !line.startsWith("#")) ?? "";
+			const title = (planned.title ?? firstLine ?? stepId).slice(0, 120);
 			phaseItemIds.push(itemId);
 			planItems.push({
 				id: itemId,
 				ref: stepId,
-				title: planned.title ?? planned.task.slice(0, 80),
+				title,
 				taskIds: [],
 				specIds: [],
 				acceptance: [],
@@ -527,7 +553,8 @@ export async function injectAdaptivePlanIfReady(input: InjectAdaptivePlanInput):
 				stepId,
 				role: planned.role,
 				agent: input.team.roles.find((role) => role.name === planned.role)?.agent ?? planned.role,
-				title: planned.title ?? stepId,
+				title,
+				description: planned.task !== title ? planned.task : undefined,
 				status: "queued",
 				dependsOn: previousStepIds,
 				cwd: input.manifest.cwd,

package/src/runtime/goal-workflow/dynamic-workflow-runner.ts

@@ -26,6 +26,7 @@ import { writeArtifact } from "../../state/stores/artifact-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { packageRoot, projectCrewRoot, userPiRoot } from "../../utils/paths.ts";
+import { safeAbort } from "../../utils/safe-abort.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 import type { DynamicWorkflowConfig } from "../../workflows/workflow-config.ts";
 import { assertDeterministicScript, isDeterminismCheckEnabled } from "../deterministic-ast.ts";
@@ -231,7 +232,10 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 				// ERR-1: abort the timeout controller so the abort propagates to
 				// runChildPi (via the combined signal passed to makeWorkflowCtx),
 				// which kills spawned children instead of letting them run.
-				timeoutController.abort();
+				// safeAbort: the combined signal may feed a signal-spawned child
+				// (abortChildProcess AbortError would otherwise reach the
+				// uncaughtException handler from this timer callback).
+				safeAbort(timeoutController, "dwf-script-timeout");
 				reject(
 					new Error(
 						`Dynamic workflow script timed out after ${SCRIPT_TIMEOUT_MS}ms. The script may have spawned a child process that did not exit. Check for spawn/exec calls without proper stdio handling.`,

package/src/runtime/merge-gate.ts

@@ -181,15 +181,31 @@ export function mergeTaskUpdatesPreservingTerminal(base: TeamTaskState[], result
 			const current = indexById.get(updated.id);
 			if (!current) continue;
 			if (!shouldMergeTaskUpdate(current, updated)) {
-				// Log skipped merges for visibility into rejected parallel updates.
-				// In distributed systems with parallel workers, rejected merges may
-				// indicate bugs (wrong status, timestamp corruption) if they accumulate.
-				console.debug("[merge-gate] Skipping stale merge for task", updated.id, {
-					currentStatus: current.status,
-					updatedStatus: updated.status,
-					currentFinishedAt: current.finishedAt,
-					updatedFinishedAt: updated.finishedAt,
-				});
+				// Routine no-op skips (an unchanged queued/running snapshot
+				// arriving from a parallel worker) are NORMAL parallel-merge
+				// behaviour and must stay silent — pi renders extension
+				// console output inline in the session transcript, so logging
+				// every skip floods whatever session is open (main or an
+				// agent view). Only a REAL rejected change (status transition,
+				// completion time, or result) is surfaced, as a warning: in
+				// distributed systems, rejected transitions may indicate bugs
+				// (wrong status, timestamp corruption) if they accumulate.
+				const meaningfulDiff =
+					updated.status !== current.status ||
+					updated.finishedAt !== current.finishedAt ||
+					updated.startedAt !== current.startedAt ||
+					Boolean(updated.resultArtifact) !== Boolean(current.resultArtifact) ||
+					Boolean(updated.error) ||
+					Boolean(updated.modelAttempts?.length) ||
+					Boolean(updated.usage);
+				if (meaningfulDiff) {
+					console.warn("[merge-gate] Rejected update for task", updated.id, {
+						currentStatus: current.status,
+						updatedStatus: updated.status,
+						currentFinishedAt: current.finishedAt,
+						updatedFinishedAt: updated.finishedAt,
+					});
+				}
 				skipped += 1;
 				continue;
 			}

package/src/runtime/model/model-fallback.ts

@@ -282,9 +282,13 @@ function warnUnvalidatedPassthrough(model: string, reason: string): void {
 	const key = `${model}|${reason}`;
 	if (passthroughWarned.has(key)) return;
 	passthroughWarned.add(key);
-	console.warn(
-		`[model-routing] unvalidated passthrough: '${model}' (${reason}) — not confirmed against the configured model catalog; spawn may fail at the provider.`,
-	);
+	// Muted: per-model passthrough noise became too loud when many pi-crew
+	// child workers resolve their parent model + fallback chain against the
+	// full catalog (each worker printed one line). Dedup Set is preserved
+	// so re-enabling is a one-line revert.
+	// console.warn(
+	// 	`[model-routing] unvalidated passthrough: '${model}' (${reason}) — not confirmed against the configured model catalog; spawn may fail at the provider.`,
+	// );
 }
 
 /** Test seam: the dedup set is module-global (one warn per model+reason per

package/src/runtime/process-status.ts

@@ -25,6 +25,12 @@ 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;
+/** Window (ms) during which an active run whose agents are all
+ * completed/queued-without-evidence still counts as display-active: the
+ * runner just wrote the manifest (task transition) and the next worker has
+ * not recorded progress yet. Without this the dock flickers off between
+ * phases of a healthy run. */
+const SPAWN_GAP_VISIBILITY_MS = 60 * 1000;
 
 export function checkProcessLiveness(pid: number | undefined): ProcessLiveness {
 	if (pid === undefined || !Number.isInteger(pid) || pid <= 0) {
@@ -150,5 +156,14 @@ export function isDisplayActiveRun(run: TeamRunManifest, agents: CrewAgentRecord
 	// runs, or from cross-cwd registry history; showing them causes noisy 0/0 rows and
 	// needless spinner redraws. The full dashboard can still list historical runs.
 	if (agents.length === 0) return false;
-	return agents.some(hasDurableActiveAgentEvidence);
+	if (agents.some(hasDurableActiveAgentEvidence)) return true;
+	// Spawn gap between phases: an active run whose manifest was JUST written
+	// and whose next agents are queued/waiting without evidence yet stays
+	// visible — the runner is alive and about to spawn them. Stale manifests
+	// (zombies) fall through and stay hidden.
+	if (agents.some((agent) => agent.status === "queued" || agent.status === "waiting")) {
+		const updatedAt = new Date(run.updatedAt).getTime();
+		if (Number.isFinite(updatedAt) && now - updatedAt < SPAWN_GAP_VISIBILITY_MS) return true;
+	}
+	return false;
 }

package/src/runtime/recovery/crash-recovery.ts

@@ -283,6 +283,22 @@ export function cancelOrphanedRuns(
 			continue;
 		}
 
+		// Foreground (in-process) runs have NO async worker PID, so the liveness
+		// check above cannot apply. They execute inside THIS pi process — a
+		// recently-updated manifest conclusively proves the run is alive; only a
+		// run that has gone quiet for the stale threshold can be an orphan (a
+		// crashed process stops updating). Without this, a YOUNG foreground run
+		// (first worker heartbeat not yet written) was orphan-cancelled by the
+		// session that opened its agent view seconds after the run started —
+		// killing the very run the user was looking at.
+		if (!manifest.async) {
+			const updatedMs = manifest.updatedAt ? new Date(manifest.updatedAt).getTime() : Number.NaN;
+			if (Number.isFinite(updatedMs) && now - updatedMs <= staleThresholdMs) {
+				skipped.push(manifest.runId);
+				continue;
+			}
+		}
+
 		// Check for recent heartbeat activity
 		const loaded = loadRunManifestById(cwd, manifest.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 		if (!loaded) continue;

package/src/runtime/run-tracker.ts

@@ -5,21 +5,38 @@ import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { projectCrewRoot } from "../utils/paths.ts";
 import { isFinishedRunStatus } from "./process-status.ts";
 
+export interface RunWaitResult {
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	/** True when the waiter was released early by `detachRunPromise` while the
+	 *  run itself keeps executing (see that function). */
+	detached?: boolean;
+}
+
 export interface ActiveRunPromise {
-	promise: Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }>;
-	resolve: (value: { manifest: TeamRunManifest; tasks: TeamTaskState[] }) => void;
+	promise: Promise<RunWaitResult>;
+	resolve: (value: RunWaitResult) => void;
 	reject: (reason: unknown) => void;
 }
 
 const activeRunPromises = new Map<string, ActiveRunPromise>();
 
+/**
+ * Runs whose waiter should be released on its next opportunity.
+ *
+ * A detach request can arrive BEFORE `executeTeamRun` registers its foreground
+ * promise (the tool starts the run and calls `waitForRun` immediately, so a
+ * slow-starting run puts the waiter on the polling path with no promise to
+ * resolve). The flag makes the request path-independent: the polling loop
+ * consumes it just like `detachRunPromise` resolves a registered promise.
+ */
+const detachRequests = new Set<string>();
+
 export function registerRunPromise(runId: string): ActiveRunPromise {
-	let resolve!: (value: { manifest: TeamRunManifest; tasks: TeamTaskState[] }) => void;
+	detachRequests.delete(runId);
+	let resolve!: (value: RunWaitResult) => void;
 	let reject!: (reason: unknown) => void;
-	const promise = new Promise<{
-		manifest: TeamRunManifest;
-		tasks: TeamTaskState[];
-	}>((res, rej) => {
+	const promise = new Promise<RunWaitResult>((res, rej) => {
 		resolve = res;
 		reject = rej;
 	});
@@ -28,7 +45,41 @@ export function registerRunPromise(runId: string): ActiveRunPromise {
 	return entry;
 }
 
-export function resolveRunPromise(runId: string, result: { manifest: TeamRunManifest; tasks: TeamTaskState[] }): void {
+/**
+ * Release a foreground waiter WITHOUT stopping the run.
+ *
+ * A foreground `team run` keeps the parent pi turn streaming for the whole run,
+ * and pi's `switchSession` tears the current session down via
+ * `session.abort()` → `waitForIdle()`. Opening an agent view therefore hung
+ * silently until the run finished. Detaching resolves the tool's `waitForRun`
+ * with the run's current (still-running) state so the tool call returns, the
+ * parent turn can settle, and the session switch lands — `executeTeamRun`
+ * itself keeps going in this process and the async notifier reports completion.
+ *
+ * Returns false only when the run's state cannot be read at all. When no
+ * foreground promise is registered yet (or the waiter is on the polling path),
+ * the request is recorded and consumed by `waitForRun` on its next poll.
+ */
+export function detachRunPromise(runId: string, cwd: string): boolean {
+	const loaded = loadRunManifestById(cwd, runId);
+	if (!loaded) return false;
+	const entry = activeRunPromises.get(runId);
+	if (entry) {
+		activeRunPromises.delete(runId);
+		detachRequests.delete(runId);
+		entry.resolve({ ...loaded, detached: true });
+		return true;
+	}
+	detachRequests.add(runId);
+	return true;
+}
+
+/** True while a detach was requested but no waiter has consumed it yet. */
+export function hasPendingRunDetach(runId: string): boolean {
+	return detachRequests.has(runId);
+}
+
+export function resolveRunPromise(runId: string, result: RunWaitResult): void {
 	const entry = activeRunPromises.get(runId);
 	if (entry) {
 		entry.resolve(result);
@@ -54,15 +105,22 @@ export async function waitForRun(
 	runId: string,
 	cwd: string,
 	options: { timeoutMs?: number; pollIntervalMs?: number } = {},
-): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
+): Promise<RunWaitResult> {
 	const { timeoutMs = 300_000, pollIntervalMs = 500 } = options;
 	const deadline = Date.now() + timeoutMs;
 
+	// A detach requested before this waiter existed applies to it (and is
+	// consumed here, so it can never leak onto a later waiter for the same run).
+	const detachPending = detachRequests.delete(runId);
+
 	// Fast path: already terminal on disk
 	const loaded = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 	if (loaded && isFinishedRunStatus(loaded.manifest.status)) {
 		return loaded;
 	}
+	if (detachPending && loaded) {
+		return { ...loaded, detached: true };
+	}
 
 	// Medium path: foreground promise registered in this process
 	const entry = activeRunPromises.get(runId);
@@ -78,9 +136,17 @@ export async function waitForRun(
 		}
 	}
 
-	// Slow path: background run — poll with exponential backoff capped at pollIntervalMs
+	// Slow path: background run — poll with exponential backoff capped at pollIntervalMs.
+	// This path is ALSO taken by a foreground run whose executeTeamRun has not
+	// registered its promise yet (the tool calls waitForRun immediately after
+	// starting the run), so it must honour a pending detach request too —
+	// otherwise opening an agent view can never release the parent turn.
 	let attempt = 0;
 	while (Date.now() < deadline) {
+		if (detachRequests.delete(runId)) {
+			const current = loadRunManifestById(cwd, runId);
+			if (current) return { ...current, detached: true };
+		}
 		if (attempt === 0) {
 			// Early exit: if the run directory doesn't exist, don't waste time polling.
 			// Use projectCrewRoot() to honour the .pi/teams/ fallback for .pi-based
@@ -109,6 +175,7 @@ export function hasActiveRunPromise(runId: string): boolean {
 }
 
 export function clearRunPromisesForTest(): void {
+	detachRequests.clear();
 	for (const entry of activeRunPromises.values()) {
 		entry.reject(new Error("Cleared by test"));
 	}

package/src/runtime/team-runner.ts

@@ -258,7 +258,7 @@ export {
 // Re-export the test-only helpers so existing test imports still resolve.
 export { __test__mergeTaskUpdates, __test__shouldMergeTaskUpdate } from "./merge-gate.ts";
 
-import { injectAdaptivePlanIfReady } from "./goal-workflow/adaptive-plan.ts";
+import { injectAdaptivePlanIfReady, isAdaptiveWorkflow } from "./goal-workflow/adaptive-plan.ts";
 
 // formatTaskProgress / runEffectivenessLines / scratchpadSummaryLines /
 // lastProgressContentHash / writeProgress moved to ./finalize-run.ts (2026-08
@@ -769,7 +769,7 @@ async function executeTeamRunCore(
 	}
 	let tasks = refreshTaskGraphQueues(input.tasks);
 	let queueIndex = buildTaskGraphIndex(tasks);
-	const canInjectAdaptivePlan = workflow.name === "implementation";
+	const canInjectAdaptivePlan = isAdaptiveWorkflow(workflow);
 	let adaptivePlanInjected = false;
 	let adaptivePlanMissing = false;
 	const attemptAdaptivePlan = async () => {
@@ -779,6 +779,7 @@ async function executeTeamRunCore(
 			tasks,
 			workflow,
 			team: input.team,
+			executeWorkers: input.executeWorkers,
 		});
 		adaptivePlanInjected = adaptivePlanInjected || adaptivePlan.injected;
 		adaptivePlanMissing = adaptivePlan.missingPlan;

package/src/schema/config-schema.ts

@@ -282,7 +282,7 @@ export const PiTeamsOtlpConfigSchema = Type.Object(
 
 export const PiTeamsUiConfigSchema = Type.Object(
 	{
-		widgetPlacement: Type.Optional(Type.Union([Type.Literal("aboveEditor"), Type.Literal("belowEditor")])),
+		widgetPlacement: Type.Optional(Type.Union([Type.Literal("aboveEditor"), Type.Literal("belowEditor"), Type.Literal("bottom")])),
 		widgetMaxLines: Type.Optional(Type.Integer({ minimum: 1, maximum: 50 })),
 		powerbar: Type.Optional(Type.Boolean()),
 		dashboardPlacement: Type.Optional(Type.Union([Type.Literal("center"), Type.Literal("right")])),

package/src/state/stores/plan-store.ts

@@ -50,7 +50,7 @@ export function loadPlanRecords(manifest: TeamRunManifest): PlanRecord[] {
 		const raw = fs.readFileSync(planFilePath(manifest), "utf-8");
 		const parsed = JSON.parse(raw) as Partial<PlanFile>;
 		if (!parsed || !Array.isArray(parsed.revisions)) return [];
-		return parsed.revisions.filter((r): r is PlanRecord => Boolean(r && r.id && typeof r.version === "number"));
+		return parsed.revisions.filter((r): r is PlanRecord => Boolean(r?.id && typeof r.version === "number"));
 	} catch (err) {
 		if ((err as NodeJS.ErrnoException).code === "ENOENT") return [];
 		logInternalError("plan-store.read-failed", err instanceof Error ? err : new Error(String(err)), `run=${manifest.runId}`);

package/src/state/stores/state-store.ts

@@ -260,7 +260,42 @@ export function createRunPaths(cwd: string, runId = createRunId()): RunPaths {
 	};
 }
 
-export function createTasksFromWorkflow(runId: string, workflow: WorkflowConfig, team: TeamConfig, cwd: string): TeamTaskState[] {
+/**
+ * Trailing phrases a step template leaves in front of `{goal}` — "Explore
+ * the codebase for the goal: {goal}" should name the task ("Explore the
+ * codebase"), not quote the whole run goal after every verb. The run goal is
+ * run-level context (statusline shows it once); a task list that repeats it
+ * per row reads like a roster of workers, not a list of work.
+ */
+const GOAL_TAILS = ["for the goal", "for goal", "the goal", "goal", "cho mục tiêu", "của mục tiêu", "mục tiêu", "for", "of", "cho", "của"];
+
+function stripGoalTail(prefix: string): string {
+	let name = prefix.replace(/[\s:—-]+$/, "").trim();
+	let changed = true;
+	while (changed) {
+		changed = false;
+		const lowered = name.toLowerCase();
+		for (const tail of GOAL_TAILS) {
+			if (lowered.endsWith(tail) && lowered.length > tail.length) {
+				name = name
+					.slice(0, name.length - tail.length)
+					.replace(/[\s:—-]+$/, "")
+					.trim();
+				changed = true;
+				break;
+			}
+		}
+	}
+	return name;
+}
+
+export function createTasksFromWorkflow(
+	runId: string,
+	workflow: WorkflowConfig,
+	team: TeamConfig,
+	cwd: string,
+	goal?: string,
+): TeamTaskState[] {
 	const stepToTaskId = new Map(workflow.steps.map((step, index) => [step.id, createTaskId(step.id, index)]));
 	return workflow.steps.map((step, index) => {
 		const role = team.roles.find((candidate) => candidate.name === step.role);
@@ -270,13 +305,48 @@ export function createTasksFromWorkflow(runId: string, workflow: WorkflowConfig,
 			.filter((candidate) => candidate.dependsOn?.includes(step.id))
 			.map((candidate) => stepToTaskId.get(candidate.id))
 			.filter((childId): childId is string => childId !== undefined);
+		// The plan's own words become the task's display identity: a heading
+		// from the step body if present, else its first content line; the
+		// remaining body is kept as `description` for detail surfaces (task
+		// list detail line, view). Falls back to the step id when the body
+		// carries no text of its own — `task` is optional on literal
+		// WorkflowStep objects.
+		//
+		// `{goal}` in the title line is the RUN's goal, context for every
+		// task, not this task's name. The template prefix before the
+		// placeholder names the task; a placeholder-only body ("{goal}",
+		// direct-run) adopts the goal itself as the title. `description`
+		// lines substitute the placeholder (the prompt path substitutes
+		// separately — unchanged).
+		const bodyLines =
+			typeof step.task === "string" && step.task.trim()
+				? step.task
+						.split("\n")
+						.map((line) => line.trim())
+						.filter(Boolean)
+				: [];
+		const heading = bodyLines.find((line) => line.startsWith("#"));
+		const titleLine = heading ?? bodyLines[0];
+		const substitute = (text: string): string => (goal ? text.replaceAll("{goal}", goal) : text);
+		let title: string;
+		let restLines: string[];
+		const placeholderAt = titleLine?.indexOf("{goal}") ?? -1;
+		if (titleLine && placeholderAt >= 0) {
+			title = stripGoalTail(titleLine.slice(0, placeholderAt)) || goal || step.id;
+			restLines = bodyLines.filter((line) => line !== titleLine);
+		} else {
+			title = (titleLine ?? step.id).replace(/^#+\s*/, "");
+			restLines = heading ? bodyLines.filter((line) => line !== titleLine) : bodyLines.slice(1);
+		}
+		const description = restLines.map(substitute).join("\n");
 		return {
 			id,
 			runId,
 			stepId: step.id,
 			role: step.role,
 			agent: role?.agent ?? step.role,
-			title: step.id,
+			title: title.slice(0, 120),
+			description: description && description !== title ? description : undefined,
 			status: "queued",
 			dependsOn: dependencies,
 			cwd,
@@ -305,7 +375,7 @@ export function createRunManifest(params: {
 }): { manifest: TeamRunManifest; tasks: TeamTaskState[]; paths: RunPaths } {
 	const paths = createRunPaths(params.cwd);
 	const now = new Date().toISOString();
-	const tasks = params.workflow ? createTasksFromWorkflow(paths.runId, params.workflow, params.team, params.cwd) : [];
+	const tasks = params.workflow ? createTasksFromWorkflow(paths.runId, params.workflow, params.team, params.cwd, params.goal) : [];
 	const manifest: TeamRunManifest = {
 		schemaVersion: CURRENT_SCHEMA_VERSION,
 		runId: paths.runId,

package/src/state/types.ts

@@ -554,6 +554,8 @@ export interface TeamTaskState {
 	role: string;
 	agent: string;
 	title: string;
+	/** Full step body (the detailed plan text behind `title`). */
+	description?: string;
 	displayName?: string;
 	status: TeamTaskStatus;
 	dependsOn: string[];