@selesai/code 0.8.5 → 0.8.6

package/dist/extensions/inline-skills.ts

@@ -22,6 +22,9 @@ function getSkillName(command: SkillCommand): string {
 
 function getInlineSkillToken(textBeforeCursor: string): string | undefined {
 	const match = textBeforeCursor.match(/(?:^|[^a-z0-9_-])\$([a-z0-9-]*)$/i);
+	// Group 1 is always present when the regex matches (it can be empty but
+	// never undefined), so the ?? fallback is unreachable.
+	/* v8 ignore next 1 */
 	return match ? match[1] ?? "" : undefined;
 }
 

package/dist/extensions/pi-subagents/agents/builder.md

@@ -21,12 +21,15 @@ Rules:
 - If a required product, architecture, or scope decision is not approved: when the injected bridge instructions make `contact_supervisor` available, use it with `reason: "need_decision"` and wait; otherwise stop, do not guess, and report the exact blocking decision in your final response.
 - Do not launch subagents. Do not send routine completion handoffs.
 - Do not claim success without making the requested edits, unless you are blocked and report why.
+- If the task specifies a progress file path, append a `## Round N` entry to that file before finishing (use the round number from the task; if none is given, count existing `## Round` entries and add one). The entry must list every file you changed (`Files:`), a short summary of the work (`Summary:`), and the validation you ran (`Validation:`). If the task names no progress file, skip this.
 
 Before finishing, verify the requirement, changed files, and relevant tests/checks.
 
 Final response:
 
 Implemented: ...
-Changed files: ...
-Validation: ...
+Progress:
+Files: ... (every file changed)
+Summary: ... (one or two lines on what was done)
+Validation: ... (checks run and outcome)
 Open risks/questions: ...

package/dist/extensions/pi-subagents/agents/commentator.md

@@ -14,7 +14,7 @@ acceptanceRole: read-only
 
 You are a review-only subagent. Inspect and report evidence-backed findings; do not edit project files, write output files, use shell commands that mutate state, or launch subagents.
 
-Review the supplied target directly. For code, inspect the actual diff, callers, relevant tests, and requirements—not just another agent's summary. Use `bash` only for read-only inspection or test commands.
+Review the supplied target directly. If the task names a progress file, read it first and scope your review to its latest round entry: inspect the diff restricted to the files that entry lists (`git diff -- <files>`). Older entries are already reviewed—re-inspect only files the latest entry repeats. If no progress file is named, or it is missing or empty, review the full uncommitted diff. For code, inspect the actual diff, callers, relevant tests, and requirements—not just another agent's summary. Use `bash` only for read-only inspection or test commands.
 
 Check:
 - correctness, regressions, edge cases, and plan/requirement adherence;

package/dist/extensions/pi-subagents/docs/configuration.md

@@ -155,6 +155,14 @@ Caps cumulative logical child admissions in one top-level run tree. The default
 
 The budget counts single launches, expanded `tasks`/`count`, static chain steps and parallel groups, actual dynamic `expand` items, appended chain steps, workflow children, and nested child calls. Static and materialized dynamic groups are admitted atomically. Startup retries, model fallback, and retained-child resume reuse the original logical child claim. Claims are never released or refunded. This cap is independent from the session-wide cumulative spawn budget and `globalConcurrencyLimit`.
 
+## `maxWorkflowAutoRelaunches`
+
+```json
+{ "maxWorkflowAutoRelaunches": 12 }
+```
+
+Maximum automatic relaunches when an async scripted workflow ends with a fan-out `budget` result before the goal is clean. Each relaunch re-runs the same `workflowScript` as a fresh top-level run with a new fan-out budget, the same mission, and the same progress file, so the loop keeps building until the commentator reports clean. Defaults to 12; `0` means unlimited. When the cap is reached, the workflow completes as `failed` with a note to raise the cap or relaunch manually. Foreground workflows are unaffected — their budget results surface to the parent inline.
+
 ## `maxActiveAsyncRunsPerSession`
 
 ```json

package/dist/extensions/pi-subagents/docs/workflows.md

@@ -62,7 +62,7 @@ return runs.run("test", { agent: "worker", task });
 
 A plain workflow creates one enclosing mission by default. Its children do not create separate missions. The result exposes the id as `details.missionId`, and human-readable output ends with `Mission: <id> (<status>)`. Pass `mission:false` for an ephemeral workflow with no mission or durable `state` global.
 
-For watched same-repo workflows, pass `async:false` to show the live in-chat workflow card. `chatProgress` can force `off` or `live-card` when the automatic policy is not what you want. Foreground workflows default to a 30-minute timeout; async workflows have no default timeout. See the [tool reference](tool-reference.md) for the full parameter list.
+For watched same-repo workflows, pass `async:false` to show the live in-chat workflow card. `chatProgress` can force `off` or `live-card` when the automatic policy is not what you want. Foreground workflows default to a 30-minute timeout; async workflows have no default timeout. Async workflows that end with a fan-out `budget` result auto-relaunch as a fresh top-level run (new fan-out budget, same mission and progress file) until the commentator reports clean or the `maxWorkflowAutoRelaunches` cap is reached (default 12; 0 = unlimited). See the [tool reference](tool-reference.md) for the full parameter list.
 
 The legacy `/chain`, `/parallel`, and `/run-chain` commands are not registered.
 

package/dist/extensions/pi-subagents/skills/pi-subagents/references/execution-controls.md

@@ -55,7 +55,7 @@ its resolved launch context as `[fresh]` or `[fork]`. Aggregate headers show
 
 `workflowScript` is the scripted orchestration surface. Use `runs.run(key, { agent, task, ... })` for one child, `runs.all([...])` for parallel children, and ordinary JavaScript for sequence, branching, filtering, retries, and aggregation. Scripts are ordinary JavaScript statement bodies, so use an explicit return such as `workflowScript: "return runs.run('main', { agent: 'worker', task: '...' })"` for a useful one-child result. Prefer a single scripted workflow whenever the parent is starting a coordinated wave, such as multiple reviews, review plus gate monitor, worker then monitor setup, cross-repo prep lanes, or a fanout that the parent will consume together; use the declarative `chain` / `tasks` modes when the shape is known up front.
 
-**Workflow modes as `workflowScript` auto-loops.** The bundled `workflow` extension ships its four mode shapes (task, prototype, quicktype, loop) as `workflowScript` auto-loops launched via `/workflow-*`. Each mode runs its phases as `runs.run` steps and loops the build↔review round until the commentator reports clean. There are no checkpoints (one-shot-and-sleep); durable state is the auto-created mission per launch; recover via `mission.list`/`status`.
+**Workflow modes as `workflowScript` auto-loops.** The bundled `workflow` extension ships its four mode shapes (task, prototype, quicktype, loop) as `workflowScript` auto-loops launched via `/workflow-*`. Each mode runs its phases as `runs.run` steps and loops the build → review → fix round (a blocking review triggers a fix round that addresses only the findings) until the commentator reports clean. There are no checkpoints (one-shot-and-sleep); durable state is the auto-created mission per launch; recover via `mission.list`/`status`.
 
 ```js
 subagent({

package/dist/extensions/pi-subagents/src/extension/config.ts

@@ -59,6 +59,12 @@ function validateConfig(config: Record<string, unknown>): void {
 			|| config.maxActiveAsyncRunsPerSession < 0)) {
 		throw new Error("config.maxActiveAsyncRunsPerSession must be a non-negative integer");
 	}
+	if (config.maxWorkflowAutoRelaunches !== undefined
+		&& (typeof config.maxWorkflowAutoRelaunches !== "number"
+			|| !Number.isInteger(config.maxWorkflowAutoRelaunches)
+			|| config.maxWorkflowAutoRelaunches < 0)) {
+		throw new Error("config.maxWorkflowAutoRelaunches must be a non-negative integer");
+	}
 	validateMissionStoreConfig(config.missions);
 	validateAuthorityPolicy(config.authorityPolicy);
 	validatePermissionConfig(config.permissions);

package/dist/extensions/pi-subagents/src/extension/index.ts

@@ -16,6 +16,7 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { keyText, type ExtensionAPI, type ExtensionContext, type ToolDefinition } from "@selesai/code";
 import { Box, Container, Spacer, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component } from "@earendil-works/pi-tui";
@@ -23,6 +24,7 @@ import { discoverAgents } from "../agents/agents.ts";
 import { ensureAccessibleDir } from "../shared/accessible-dir.ts";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.ts";
 import { resolveCurrentSessionId } from "../shared/session-identity.ts";
+import { resolveSessionLineage } from "../shared/session-lineage.ts";
 import { cleanupOldChainDirs } from "../shared/settings.ts";
 import { clearLegacyResultAnimationTimer, renderSubagentResult, renderSubagentSummary } from "../tui/render.ts";
 import { openSubagentFleet } from "../tui/fleet.ts";
@@ -376,6 +378,12 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	const artifactCleanupDays = config.artifactConfig?.cleanupDays ?? DEFAULT_ARTIFACT_CONFIG.cleanupDays;
 	cleanupAllArtifactDirs(artifactCleanupDays);
 
+	// Replay guard for lineage result adoption: accept result files written at
+	// most this long before the adoption window opened (covers completions that
+	// raced the session switch). Older files were left behind by a dead watcher
+	// and are ignored until their owning session is resumed.
+	const ADOPTED_RESULT_SLACK_MS = 60_000;
+
 	const state: SubagentState = {
 		baseCwd: "",
 		currentSessionId: null,
@@ -630,19 +638,26 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 
 	pi.on("agent_end", async (_event, ctx) => {
 		if (!ctx.hasUI) await drainOutstandingWork({ state, events: pi.events });
-		const ownerSessionId = state.currentSessionId;
-		if (!ownerSessionId) return;
+		const ownerSessionIds = state.sessionLineage?.length
+			? state.sessionLineage
+			: state.currentSessionId ? [state.currentSessionId] : [];
+		if (ownerSessionIds.length === 0) return;
 		goalTurnId += 1;
 		try {
 			const location = resolveMissionStoreLocation({ projectRoot: state.baseCwd, ...(config.missions ? { config: config.missions } : {}) });
-			const retainedChildren = listRetainedChildren(DIRS.async, ownerSessionId);
-			for (const notice of collectGoalContinuationNotices({ location, ownerSessionId, retainedChildren, turnId: goalTurnId })) {
-				handleSubagentControlNotice({
-					pi,
-					state,
-					visibleControlNotices: new Set(),
-					details: { source: "goal", event: notice.event, noticeText: notice.message },
-				});
+			const retainedChildren = listRetainedChildren(DIRS.async, ownerSessionIds);
+			const emittedMissions = new Set<string>();
+			for (const ownerSessionId of ownerSessionIds) {
+				for (const notice of collectGoalContinuationNotices({ location, ownerSessionId, retainedChildren, turnId: goalTurnId })) {
+					if (emittedMissions.has(notice.missionId)) continue;
+					emittedMissions.add(notice.missionId);
+					handleSubagentControlNotice({
+						pi,
+						state,
+						visibleControlNotices: new Set(),
+						details: { source: "goal", event: notice.event, noticeText: notice.message },
+					});
+				}
 			}
 		} catch (error) {
 			console.error("Failed to evaluate goal missions:", error);
@@ -650,6 +665,11 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	});
 
 	registerSlashCommands(pi, state, { fleetKeybindings: config.fleetKeybindings });
+	pi.on("resources_discover", () => {
+		return {
+			promptPaths: [fileURLToPath(new URL("../../prompts", import.meta.url))],
+		};
+	});
 
 	const eventUnsubscribeStoreKey = "__piSubagentEventUnsubscribes";
 	const controlNoticeSeenStoreKey = "__piSubagentVisibleControlNotices";
@@ -758,14 +778,47 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			resolveMaxActiveAsyncRunsPerSession(config.maxActiveAsyncRunsPerSession),
 			{ liveWorkflowRunIds: new Set(state.workflowControllers?.keys() ?? []) },
 		);
+		const adoptedActive = [...state.asyncJobs.values()].filter((job) => job.adopted && (job.status === "queued" || job.status === "running")).length;
+		if (adoptedActive > 0) {
+			state.activeAsyncCapacity = {
+				...state.activeAsyncCapacity,
+				used: state.activeAsyncCapacity.used + adoptedActive,
+			};
+		}
 	};
 
-	const resetSessionState = (ctx: ExtensionContext, recovering: boolean) => {
+	const formatActiveWorkflowSummary = (target: SubagentState, intro: string): string => {
+		const active = [...target.asyncJobs.values()]
+			.filter((job) => job.status === "queued" || job.status === "running")
+			.sort((left, right) => (left.startedAt ?? 0) - (right.startedAt ?? 0));
+		const lines = active.map((job) => {
+			const label = job.mode === "workflow"
+				? `workflow[${job.workflowKey ?? "script"}]`
+				: `${job.mode ?? "run"}${job.agents?.length ? ` ${job.agents.join(", ")}` : ""}`;
+			const step = job.currentStep !== undefined
+				? ` · step ${job.currentStep + 1}/${job.chainStepCount ?? job.stepsTotal ?? "?"}`
+				: "";
+			const activity = job.currentTool ? ` · last: ${job.currentTool}` : "";
+			const adopted = job.adopted ? " (carried over from a previous session)" : "";
+			return `- ${job.asyncId} ${label}${step}${activity}${adopted}`;
+		});
+		return [
+			intro,
+			...lines,
+			"Monitor with subagent status <id>; interrupt/resume/steer by run id; children.list lists completed steps. Results arrive automatically.",
+		].join("\n");
+	};
+
+	const resetSessionState = (ctx: ExtensionContext, recovering: boolean, previousSessionFile?: string | null) => {
 		state.widgetsSuspended = false;
 		state.baseCwd = ctx.cwd;
 		goalTurnId = 0;
 		state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
 		state.parentSessionFile = ctx.sessionManager.getSessionFile();
+		state.sessionLineage = resolveSessionLineage({ sessionManager: ctx.sessionManager }, { parentHint: previousSessionFile ?? null });
+		state.handoffResumePending = false;
+		if (state.sessionLineage.length > 1) state.adoptedResultWindowStart = Date.now() - ADOPTED_RESULT_SLACK_MS;
+		else state.adoptedResultWindowStart = undefined;
 		state.subagentSpawns = {
 			sessionId: state.currentSessionId,
 			count: 0,
@@ -791,7 +844,8 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		state.lastForegroundControlId = null;
 		resetJobs(ctx);
 		restoreForegroundRunHistory(state, { resultsDir: DIRS.results });
-		restoreActiveJobs(ctx);
+		const adoptedJobs = restoreActiveJobs(ctx);
+		state.handoffResumePending = adoptedJobs > 0 && state.lastUiContext?.hasUI === true;
 		scheduledRunManager.bindSession(ctx);
 		restoreSlashFinalSnapshots(ctx.sessionManager.getEntries());
 		waitSubscriptionManager.restore();
@@ -807,6 +861,17 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 
 	pi.on("agent_settled", () => {
 		resumeWidgetsAfterCompaction();
+		if (state.handoffResumePending && state.lastUiContext?.hasUI === true) {
+			state.handoffResumePending = false;
+			pi.sendMessage(
+				{
+					customType: "subagent-handoff-resume",
+					content: formatActiveWorkflowSummary(state, "Session handoff detected. The previous session's background workflows were carried over:"),
+					display: false,
+				},
+				{ triggerTurn: true },
+			);
+		}
 	});
 
 	pi.on("session_before_compact", (event) => {
@@ -819,7 +884,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		pi.sendMessage(
 			{
 				customType: "subagent-compaction-resume",
-				content: "Compaction is complete. Resume the parent task now; background subagent results will arrive separately when ready.",
+				content: formatActiveWorkflowSummary(state, "Compaction is complete. Resume the parent task now; results for the runs below arrive separately when ready:"),
 				display: false,
 			},
 			{ triggerTurn: true },
@@ -828,7 +893,8 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 
 	pi.on("session_start", (event, ctx) => {
 		const recovering = event.reason === "startup" || event.reason === "reload" || event.reason === "resume";
-		resetSessionState(ctx, recovering);
+		const previousSessionFile = event.reason === "new" || event.reason === "fork" ? event.previousSessionFile : null;
+		resetSessionState(ctx, recovering, previousSessionFile);
 		herdrStatusBridge.sessionStarted({
 			hasUI: ctx.hasUI === true,
 			runs: activeHerdrRuns(),
@@ -842,6 +908,9 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		stopResultWatcher();
 		state.currentSessionId = null;
 		state.parentSessionFile = null;
+		state.sessionLineage = undefined;
+		state.adoptedResultWindowStart = undefined;
+		state.handoffResumePending = false;
 		completionNotifier.dispose();
 		delete process.env[SUBAGENT_PARENT_SESSION_ENV];
 		for (const unsubscribe of eventUnsubscribes) {

package/dist/extensions/pi-subagents/src/runs/background/async-job-tracker.ts

@@ -54,7 +54,7 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 	handleStarted: (data: unknown) => void;
 	handleComplete: (data: unknown) => void;
 	resetJobs: (ctx?: ExtensionContext) => void;
-	restoreActiveJobs: (ctx?: ExtensionContext) => void;
+	restoreActiveJobs: (ctx?: ExtensionContext) => number;
 	dispose: () => void;
 } {
 	const completionRetentionMs = options.completionRetentionMs ?? 10000;
@@ -645,26 +645,32 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 		}
 	};
 
-	const restoreActiveJobs = (ctx?: ExtensionContext) => {
+	const restoreActiveJobs = (ctx?: ExtensionContext): number => {
 		if (ctx?.hasUI) state.lastUiContext = ctx;
-		if (!state.currentSessionId) return;
+		if (!state.currentSessionId) return 0;
+		const sessionIds = state.sessionLineage?.length ? state.sessionLineage : [state.currentSessionId];
 		let runs: AsyncRunSummary[];
 		try {
-			runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: state.currentSessionId, resultsDir, kill: options.kill, now: options.now });
+			runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionIds, resultsDir, kill: options.kill, now: options.now });
 		} catch (error) {
 			console.error(`Failed to restore active async jobs from '${asyncDirRoot}':`, error);
-			return;
+			return 0;
 		}
+		let adopted = 0;
 		for (const run of runs) {
+			if (state.asyncJobs.has(run.id)) continue;
 			const job = summaryToJob(run);
+			job.adopted = run.sessionId !== undefined && run.sessionId !== state.currentSessionId;
 			state.asyncJobs.set(run.id, job);
 			if (job.status === "running") runningJobIds.add(job.asyncId);
 			rememberFleetJob(state, job);
 			watchJob(job);
+			if (job.adopted) adopted += 1;
 		}
-		if (runs.length === 0) return;
+		if (runs.length === 0) return 0;
 		ensurePoller();
 		rerenderLastWidget();
+		return adopted;
 	};
 
 	return { ensurePoller, refreshWidget, handleStarted, handleComplete, resetJobs, restoreActiveJobs, dispose };

package/dist/extensions/pi-subagents/src/runs/background/async-status.ts

@@ -120,6 +120,8 @@ export interface AsyncRunSummary {
 interface AsyncRunListOptions {
 	states?: Array<AsyncRunSummary["state"]>;
 	sessionId?: string;
+	/** Accept runs owned by any of these session identities (union). */
+	sessionIds?: string[];
 	limit?: number;
 	/** Limits status-file reads after candidates are ordered by status mtime. */
 	entryLimit?: number;
@@ -468,6 +470,7 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 		// match.
 		if (allowedStates && !allowedStates.has(status.state)) continue;
 		if (options.sessionId && status.sessionId !== options.sessionId) continue;
+		if (options.sessionIds && (status.sessionId === undefined || !options.sessionIds.includes(status.sessionId))) continue;
 		const nestedWarnings: string[] = [];
 		let nestedRoute: NestedRoute | undefined;
 		if (options.reconcile !== false) {

package/dist/extensions/pi-subagents/src/runs/background/notify.ts

@@ -239,7 +239,7 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 
 export default function registerSubagentNotify(
 	pi: ExtensionAPI,
-	state: Pick<SubagentState, "currentSessionId">,
+	state: Pick<SubagentState, "currentSessionId" | "sessionLineage">,
 	options: RegisterSubagentNotifyOptions = {},
 ): CompletionNotifier {
 	const seen = new Map<string, number>();
@@ -250,6 +250,9 @@ export default function registerSubagentNotify(
 	const batchers = new Map<string, CompletionBatcher<PendingCompletion>>();
 	let disposed = false;
 
+	const ownsSession = (sessionId: string) =>
+		sessionId === state.currentSessionId || state.sessionLineage?.includes(sessionId) === true;
+
 	const settle = (items: PendingCompletion[], accepted: boolean) => {
 		for (const item of items) {
 			pending.delete(item.key);
@@ -274,7 +277,7 @@ export default function registerSubagentNotify(
 	};
 
 	const deliver = (result: CompletionNotification): Promise<boolean> => {
-		if (disposed || typeof result.sessionId !== "string" || result.sessionId !== state.currentSessionId) return Promise.resolve(false);
+		if (disposed || typeof result.sessionId !== "string" || !ownsSession(result.sessionId)) return Promise.resolve(false);
 		if (result.intercomDelivered === true) return Promise.resolve(true);
 		const key = buildCompletionKey(result, "notify");
 		const seenAt = seen.get(key);

package/dist/extensions/pi-subagents/src/runs/background/result-watcher.ts

@@ -168,7 +168,24 @@ export function createResultWatcher(
 	const ownsSession = (sessionId: string, epoch: number) => {
 		if (!deliveryActive || epoch !== deliveryEpoch) return false;
 		if (!activeSessionId && state.currentSessionId) activeSessionId = state.currentSessionId;
-		return activeSessionId === sessionId && state.currentSessionId === sessionId;
+		if (activeSessionId !== state.currentSessionId) return false;
+		if (sessionId === state.currentSessionId) return true;
+		return (state.sessionLineage ?? []).includes(sessionId);
+	};
+
+	const lineageOwnsResult = (identity: ResultFileIdentity, file: string): boolean => {
+		const lineage = state.sessionLineage;
+		if (!identity.sessionId || !lineage || !lineage.includes(identity.sessionId)) return false;
+		// Replay guard: only accept lineage results written around or after the
+		// adoption window. The previous session's watcher deleted every result it
+		// delivered, so older files are stale leftovers, not missed deliveries.
+		const windowStart = state.adoptedResultWindowStart;
+		if (windowStart === undefined) return false;
+		try {
+			return fsApi.statSync(path.join(resultsDir, file)).mtimeMs >= windowStart;
+		} catch {
+			return false;
+		}
 	};
 
 	const scheduleResult = (file: string, triggerTurn: boolean, delayMs = 0) => {
@@ -210,6 +227,7 @@ export function createResultWatcher(
 		// files keep their existing diagnostics and compatibility behavior.
 		if (!identity.sessionId) return true;
 		if (identity.sessionId === state.currentSessionId) return true;
+		if (lineageOwnsResult(identity, file)) return true;
 		if (identity.asyncDir && fsApi.existsSync(path.join(identity.asyncDir, MISSION_BINDING_FILE))) return true;
 		if (identity.runId && (observed ?? observedRunIds()).has(identity.runId)) return true;
 		return Boolean(deps.observeCompletion && !deps.observedCompletionRunIds);

package/dist/extensions/pi-subagents/src/runs/background/retained-children.ts

@@ -32,8 +32,8 @@ function boundedTaskSummary(value: string | undefined): string {
 		: normalized;
 }
 
-export function listRetainedChildren(asyncDirRoot: string, sessionId: string): RetainedChild[] {
-	return listAsyncRuns(asyncDirRoot, { sessionId, states: ["complete"], reconcile: false })
+export function listRetainedChildren(asyncDirRoot: string, sessionIds: string[]): RetainedChild[] {
+	return listAsyncRuns(asyncDirRoot, { sessionIds, states: ["complete"], reconcile: false })
 		.flatMap((run) => {
 			if (!run.parentWorkflowRunId || run.steps.length !== 1) return [];
 			const step = run.steps[0]!;

package/dist/extensions/pi-subagents/src/runs/background/run-id-resolver.ts

@@ -94,9 +94,10 @@ function toolCallIdAsyncLocations(toolCallId: string, asyncDirRoot: string, resu
 
 function foregroundIds(state: SubagentState | undefined): string[] {
 	if (!state) return [];
+	const acceptedSessions = new Set(state.sessionLineage?.length ? state.sessionLineage : state.currentSessionId ? [state.currentSessionId] : []);
 	const remembered = state.currentSessionId
 		? [...(state.foregroundRuns?.values() ?? [])]
-			.filter((run) => run.sessionId === state.currentSessionId)
+			.filter((run) => run.sessionId !== undefined && acceptedSessions.has(run.sessionId))
 			.map((run) => run.runId)
 		: [];
 	return [...new Set([...state.foregroundControls.keys(), ...remembered])];
@@ -106,7 +107,9 @@ function hasExactForegroundId(state: SubagentState | undefined, id: string): boo
 	if (!state) return false;
 	if (state.foregroundControls.has(id)) return true;
 	const remembered = state.foregroundRuns?.get(id);
-	return Boolean(remembered && state.currentSessionId && remembered.sessionId === state.currentSessionId);
+	if (!remembered || !state.currentSessionId || remembered.sessionId === undefined) return false;
+	const acceptedSessions = new Set(state.sessionLineage?.length ? state.sessionLineage : [state.currentSessionId]);
+	return acceptedSessions.has(remembered.sessionId);
 }
 
 function nestedScopeFromState(state: SubagentState | undefined): NestedRunResolutionScope | undefined {

package/dist/extensions/pi-subagents/src/runs/background/run-status.ts

@@ -217,6 +217,8 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 	const asyncDirRoot = deps.asyncDirRoot ?? DIRS.async;
 	const resultsDir = deps.resultsDir ?? DIRS.results;
 	const currentSessionId = deps.state?.currentSessionId ?? undefined;
+	const acceptedSessions = new Set<string>(deps.state?.sessionLineage?.length ? deps.state.sessionLineage : currentSessionId ? [currentSessionId] : []);
+	const ownsSession = (sessionId: string | undefined) => sessionId !== undefined && acceptedSessions.has(sessionId);
 	if (params.view && params.view !== "fleet" && params.view !== "transcript") {
 		return {
 			content: [{ type: "text", text: `Unknown status view: ${params.view}. Valid: fleet, transcript.` }],
@@ -236,7 +238,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			};
 		}
 		try {
-			const runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: currentSessionId, resultsDir, kill: deps.kill, now: deps.now });
+			const runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], ...(acceptedSessions.size ? { sessionIds: [...acceptedSessions] } : {}), resultsDir, kill: deps.kill, now: deps.now });
 			if (params.view === "transcript") {
 				if (runs.length === 1) return inspectSubagentStatus({ ...params, id: runs[0]!.id }, deps);
 				return {
@@ -332,9 +334,9 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		const status = reconciliation.status;
 		if (!status && diskStatus?.displayDismissedAt !== undefined) {
 			if (params.view === "transcript") {
-				if (currentSessionId && diskStatus.sessionId !== currentSessionId) {
+				if (currentSessionId && !ownsSession(diskStatus.sessionId)) {
 					return {
-						content: [{ type: "text", text: "Transcript view is only available for async runs owned by the current session." }],
+						content: [{ type: "text", text: "Transcript view is only available for async runs owned by the current session or its carried-over predecessors." }],
 						isError: true,
 						details: { mode: "single", results: [] },
 					};
@@ -351,9 +353,9 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		const eventsPath = path.join(asyncDir, "events.jsonl");
 		if (status) {
 			if (params.view === "transcript") {
-				if (currentSessionId && status.sessionId !== currentSessionId) {
+				if (currentSessionId && !ownsSession(status.sessionId)) {
 					return {
-						content: [{ type: "text", text: "Transcript view is only available for async runs owned by the current session." }],
+						content: [{ type: "text", text: "Transcript view is only available for async runs owned by the current session or its carried-over predecessors." }],
 						isError: true,
 						details: { mode: "single", results: [] },
 					};

package/dist/extensions/pi-subagents/src/runs/background/wait-subscriptions.ts

@@ -245,7 +245,8 @@ export function createWaitSubscriptionManager(
 				try {
 					const record = parseRecord(JSON.parse(fs.readFileSync(path.join(subscriptionsDir, file), "utf-8")));
 					if (!record || file !== `${record.token}.json`) continue;
-					if (record.sessionId === state.currentSessionId) {
+					const acceptedSessions = new Set(state.sessionLineage?.length ? state.sessionLineage : [state.currentSessionId]);
+					if (acceptedSessions.has(record.sessionId)) {
 						subscriptions.set(record.token, record);
 						if (record.targetKind === "foreground" && !state.foregroundRuns?.has(record.runId)) unresolvedRestoredForegroundTokens.add(record.token);
 					}

package/dist/extensions/pi-subagents/src/runs/foreground/foreground-history.ts

@@ -121,11 +121,14 @@ export function persistForegroundRunHistory(state: SubagentState, options: { res
 	writeAtomicJson(historyPath(resultsDir), { version: HISTORY_VERSION, runs });
 }
 
-export function restoreForegroundRunHistory(state: SubagentState, options: { resultsDir?: string; sessionId?: string | null; limit?: number } = {}): number {
-	const sessionId = options.sessionId ?? state.currentSessionId;
-	if (!sessionId) return 0;
+export function restoreForegroundRunHistory(state: SubagentState, options: { resultsDir?: string; sessionId?: string | null; sessionIds?: string[]; limit?: number } = {}): number {
+	const sessionIds = options.sessionIds
+		?? (options.sessionId ? [options.sessionId] : state.sessionLineage)
+		?? (state.currentSessionId ? [state.currentSessionId] : []);
+	if (sessionIds.length === 0) return 0;
+	const accepted = new Set(sessionIds);
 	const index = readIndex(options.resultsDir ?? DIRS.results);
-	const runs = sortAndBound(index.runs.filter((run) => run.sessionId === sessionId), options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
+	const runs = sortAndBound(index.runs.filter((run) => run.sessionId !== undefined && accepted.has(run.sessionId)), options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
 	state.foregroundRuns ??= new Map();
 	let restored = 0;
 	for (const run of runs) {

package/dist/extensions/pi-subagents/src/runs/foreground/subagent-executor.ts

@@ -115,6 +115,7 @@ import { resolveAuthorityDecision } from "../../policy/authority.ts";
 import { handleHerdrInspectorAction, HERDR_INSPECTOR_ACTIONS } from "../../inspectors/herdr/actions.ts";
 import { handleHerdrProjectPaneAction, HERDR_PROJECT_PANE_ACTIONS } from "../../inspectors/herdr/project-panes.ts";
 import { previewSimpleWorkflowRun, runWorkflowScript, WorkflowScriptError, type WorkflowScriptChildResult } from "../../workflows/scripted-workflow.ts";
+import { resolveAutoRelaunchDecision, resolveMaxWorkflowAutoRelaunches } from "../../workflows/workflow-auto-relaunch.ts";
 import { renderWorkflowPrompt } from "../../shared/prompt-resources.ts";
 import { resolveWorkflowChatProgress, type WorkflowChatProgressProjection } from "../../workflows/chat-progress.ts";
 import {
@@ -781,7 +782,8 @@ function updateRememberedForegroundChild(state: SubagentState, input: { runId: s
 function resolveForegroundResumeTarget(params: SubagentParamsLike, state: SubagentState): { runId: string; mode: SubagentRunMode; state: "complete"; agent: string; index: number; cwd: string; sessionFile: string; model?: string; thinking?: string; launchContractDigest?: string; capabilityCeiling?: ResolvedSubagentCapabilityCeiling } | undefined {
 	const requested = (params.id ?? params.runId)?.trim();
 	if (!requested || !state.foregroundRuns?.size || !state.currentSessionId) return undefined;
-	const sessionRuns = [...state.foregroundRuns.values()].filter((run) => run.sessionId === state.currentSessionId);
+	const acceptedSessions = new Set(state.sessionLineage?.length ? state.sessionLineage : [state.currentSessionId]);
+	const sessionRuns = [...state.foregroundRuns.values()].filter((run) => run.sessionId !== undefined && acceptedSessions.has(run.sessionId));
 	const direct = sessionRuns.find((run) => run.runId === requested);
 	const matches = direct ? [direct] : sessionRuns.filter((run) => run.runId.startsWith(requested));
 	if (matches.length === 0) return undefined;
@@ -4889,8 +4891,17 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 						appendWorkflowEvent({ type: "subagent.workflow.trace", trace });
 					};
 					try {
-						const workflow = await runWorkflowScript({
-							script: workflowScript,
+						const autoRelaunchCap = resolveMaxWorkflowAutoRelaunches(deps.config.maxWorkflowAutoRelaunches);
+						let relaunched = 0;
+						let capReached = false;
+						let workflow: Awaited<ReturnType<typeof runWorkflowScript>> | undefined;
+						while (true) {
+							if (relaunched > 0) {
+								workflowFanoutBudget = createRunFanoutBudget(`${workflowRunId}#${relaunched + 1}`, workflowFanoutBudget.limit);
+								status = { ...status, workflow: { trace: [], emits: [], console: [] } };
+							}
+							workflow = await runWorkflowScript({
+								script: workflowScript,
 							timeoutMs: timeout,
 							signal: controller.signal,
 							prompts: workflowPrompts,
@@ -4988,14 +4999,33 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 							},
 							status: async (keyOrRunId, workflowSignal) => workflowChildResult(keyOrRunId, await execute(randomUUID(), { action: "status", id: keyOrRunId }, workflowSignal, undefined, ctx, preserveActiveSession)),
 						});
+							const decision = resolveAutoRelaunchDecision(workflow?.value, relaunched, autoRelaunchCap);
+							if (!decision.relaunch) {
+								capReached = decision.capped;
+								break;
+							}
+							relaunched += 1;
+							status = { ...status, workflowRelaunchCount: relaunched };
+							persist();
+							appendWorkflowEvent({ type: "subagent.workflow.relaunched", relaunched });
+						}
+						if (!workflow) throw new Error("Workflow script produced no result.");
 						const returnPreview = formatWorkflowValue(workflow.value).slice(0, 1_000);
 						const emitPreview = workflow.emits.length > 0 ? ` Emitted: ${workflow.emits.map(formatWorkflowValue).join(", ").slice(0, 1_000)}` : "";
-						const summary = `Workflow completed with ${workflow.children.length} child run(s). Return: ${returnPreview}${emitPreview} Trace: ${workflow.trace.length} event(s).`;
+						const relaunchNote = relaunched > 0 ? `Auto-relaunched ${relaunched} time(s) with a fresh fan-out budget. ` : "";
+						const summary = `${relaunchNote}Workflow completed with ${workflow.children.length} child run(s). Return: ${returnPreview}${emitPreview} Trace: ${workflow.trace.length} event(s).`;
 						const workflowUsage = sumResultsUsage(workflowResults);
-						status = { ...status, state: "complete", endedAt: Date.now(), workflow: { value: workflow.value, trace: workflow.trace, emits: workflow.emits, console: workflow.console }, totalTokens: { input: workflowUsage.input, output: workflowUsage.output, total: workflowUsage.input + workflowUsage.output }, totalCost: sumResultsCost(workflowResults) };
-						writeAtomicJson(resultPath, { id: workflowRunId, runId: workflowRunId, toolCallId, agent: "workflow", mode: "workflow", success: true, state: "complete", summary, output: summary, results: workflow.children.map((child) => ({ workflowKey: child.key, ...(child.agent ? { agent: child.agent } : {}), ...(child.runId ? { runId: child.runId } : {}), output: child.output, outputState: child.output.trim() || child.structuredOutput !== undefined ? "present" : "absent", structuredOutput: child.structuredOutput, success: child.ok, ...(child.artifactPaths[0] ? { artifactPaths: { outputPath: child.artifactPaths[0] } } : {}) })), workflow: status.workflow, asyncDir, cwd: workflowCwd, sessionId: currentSessionId, timestamp: Date.now(), durationMs: Date.now() - startedAt });
-						persist();
-						appendWorkflowEvent({ type: "subagent.workflow.completed", state: "complete" });
+						if (capReached) {
+							status = compactOptional<AsyncStatus>({ ...status, state: "failed", error: `Workflow auto-relaunch cap reached after ${relaunched} relaunch(es); the goal is not clean yet. The progress file is current; raise config.maxWorkflowAutoRelaunches or relaunch manually.`, endedAt: Date.now(), workflow: { value: workflow.value, trace: workflow.trace, emits: workflow.emits, console: workflow.console } });
+							writeAtomicJson(resultPath, { id: workflowRunId, runId: workflowRunId, toolCallId, agent: "workflow", mode: "workflow", success: false, state: "failed", summary: status.error, error: status.error, results: workflow.children.map((child) => ({ workflowKey: child.key, ...(child.agent ? { agent: child.agent } : {}), ...(child.runId ? { runId: child.runId } : {}), output: child.output, outputState: child.output.trim() || child.structuredOutput !== undefined ? "present" : "absent", structuredOutput: child.structuredOutput, success: child.ok, ...(child.artifactPaths[0] ? { artifactPaths: { outputPath: child.artifactPaths[0] } } : {}) })), workflow: status.workflow, asyncDir, cwd: workflowCwd, sessionId: currentSessionId, timestamp: Date.now(), durationMs: Date.now() - startedAt });
+							persist();
+							appendWorkflowEvent({ type: "subagent.workflow.completed", state: "failed", error: status.error });
+						} else {
+							status = { ...status, state: "complete", endedAt: Date.now(), workflow: { value: workflow.value, trace: workflow.trace, emits: workflow.emits, console: workflow.console }, totalTokens: { input: workflowUsage.input, output: workflowUsage.output, total: workflowUsage.input + workflowUsage.output }, totalCost: sumResultsCost(workflowResults) };
+							writeAtomicJson(resultPath, { id: workflowRunId, runId: workflowRunId, toolCallId, agent: "workflow", mode: "workflow", success: true, state: "complete", summary, output: summary, results: workflow.children.map((child) => ({ workflowKey: child.key, ...(child.agent ? { agent: child.agent } : {}), ...(child.runId ? { runId: child.runId } : {}), output: child.output, outputState: child.output.trim() || child.structuredOutput !== undefined ? "present" : "absent", structuredOutput: child.structuredOutput, success: child.ok, ...(child.artifactPaths[0] ? { artifactPaths: { outputPath: child.artifactPaths[0] } } : {}) })), workflow: status.workflow, asyncDir, cwd: workflowCwd, sessionId: currentSessionId, timestamp: Date.now(), durationMs: Date.now() - startedAt });
+							persist();
+							appendWorkflowEvent({ type: "subagent.workflow.completed", state: "complete" });
+						}
 					} catch (error) {
 						const partial = error instanceof WorkflowScriptError ? error.partial : { trace: [], emits: [], console: [], children: [] };
 						const stopped = controller.signal.aborted;
@@ -5326,7 +5356,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 			}
 			if (action === "children.list") {
 				deps.state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
-				const children = listRetainedChildren(DIRS.async, deps.state.currentSessionId);
+				const children = listRetainedChildren(DIRS.async, deps.state.sessionLineage?.length ? deps.state.sessionLineage : [deps.state.currentSessionId]);
 				return {
 					content: [{ type: "text", text: formatRetainedChildren(children) }],
 					details: { mode: "management", results: [] },