@selesai/code 0.8.5 → 0.8.7

package/dist/extensions/pi-subagents/src/shared/session-lineage.ts

@@ -0,0 +1,71 @@
+import * as fs from "node:fs";
+
+/**
+ * Resolve the chain of session identities whose workflow estate the current
+ * session should adopt. Session files record their parent in the header's
+ * `parentSession` field, so a fresh session created by handoff/new/fork can
+ * walk back to every predecessor and re-attach its persisted async runs,
+ * results, retained children, and wait subscriptions.
+ */
+
+export interface SessionLineageInput {
+	sessionManager: {
+		getSessionFile(): string | null | undefined;
+		getHeader?(): { parentSession?: string | null } | null;
+	};
+}
+
+export interface SessionLineageOptions {
+	/** Maximum number of session identities retained in the lineage. Defaults to 8. */
+	depth?: number;
+	/** Explicit parent session file (e.g. SessionStartEvent.previousSessionFile). */
+	parentHint?: string | null;
+}
+
+const MAX_HEADER_BYTES = 2048;
+
+function readParentSessionHeader(sessionFile: string): string | undefined {
+	let text: string;
+	try {
+		const fd = fs.openSync(sessionFile, "r");
+		try {
+			const buffer = Buffer.alloc(MAX_HEADER_BYTES);
+			const read = fs.readSync(fd, buffer, 0, buffer.length, 0);
+			text = buffer.subarray(0, read).toString("utf-8");
+		} finally {
+			fs.closeSync(fd);
+		}
+	} catch {
+		return undefined;
+	}
+	const newline = text.indexOf("\n");
+	const line = newline >= 0 ? text.slice(0, newline) : text;
+	if (!line.trim()) return undefined;
+	try {
+		const header = JSON.parse(line) as { type?: unknown; parentSession?: unknown };
+		if (header.type !== "session") return undefined;
+		return typeof header.parentSession === "string" && header.parentSession ? header.parentSession : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function resolveSessionLineage(input: SessionLineageInput, options: SessionLineageOptions = {}): string[] {
+	const depth = Math.max(1, Math.floor(options.depth ?? 8));
+	const lineage: string[] = [];
+	const seen = new Set<string>();
+	const current = input.sessionManager.getSessionFile();
+	if (current) {
+		lineage.push(current);
+		seen.add(current);
+	}
+	let parent = options.parentHint ?? input.sessionManager.getHeader?.()?.parentSession;
+	if (!parent && current) parent = readParentSessionHeader(current);
+	while (parent && lineage.length < depth && !seen.has(parent)) {
+		if (!fs.existsSync(parent)) break;
+		lineage.push(parent);
+		seen.add(parent);
+		parent = readParentSessionHeader(parent);
+	}
+	return lineage;
+}

package/dist/extensions/pi-subagents/src/shared/types.ts

@@ -215,7 +215,7 @@ export interface ControlEvent {
 	nestedRunId?: string;
 	nestingPath?: NestedRunAddress["path"];
 	message: string;
-	reason?: "idle" | "completion_guard" | "active_long_running" | "tool_failures" | "supervisor_request" | "time_threshold" | "turn_threshold" | "token_threshold";
+	reason?: "idle" | "completion_guard" | "active_long_running" | "tool_failures" | "supervisor_request" | "time_threshold" | "turn_threshold" | "token_threshold" | "tool_open_threshold";
 	turns?: number;
 	tokens?: number;
 	toolCount?: number;
@@ -528,6 +528,8 @@ export interface SteeringRecoveryDescriptor {
 	structuredOutputSchema?: JsonSchemaObject;
 	acceptance?: AcceptanceInput;
 	controlConfig?: ResolvedControlConfig;
+	/** Raw per-run bridge override. Omitted descriptors continue to use global config. */
+	intercomBridge?: IntercomBridgeConfig;
 	absoluteDeadlineAt?: number;
 	initialTurnBudget?: ResolvedTurnBudget;
 	initialToolBudget?: ResolvedToolBudget;
@@ -1029,6 +1031,7 @@ export interface Details {
 	controlEvents?: ControlEvent[];
 	steering?: SteerActionResult;
 	asyncId?: string;
+	background?: boolean;
 	asyncDir?: string;
 	timeoutMs?: number;
 	deadlineAt?: number;
@@ -1086,7 +1089,7 @@ export interface Details {
 		trace: Array<{
 			operation: "run" | "status";
 			key: string;
-			state: "started" | "completed" | "failed" | "reused";
+			state: "started" | "completed" | "failed" | "detached" | "stopped" | "reused";
 			agent?: string;
 			runId?: string;
 			phase?: string;
@@ -1259,6 +1262,8 @@ export interface AsyncStartedEvent {
 	asyncDir?: string;
 	/** Parent-resolved launch directory, used as a trusted artifact root while this session is live. */
 	cwd?: string;
+	/** Parent-resolved child session root, used only while this session owns the live run. */
+	sessionRoot?: string;
 	pid?: number;
 	sessionId?: string;
 	mode?: SubagentRunMode;
@@ -1361,6 +1366,8 @@ export interface AsyncStatus {
 	pendingAppends?: number;
 	parallelGroups?: AsyncParallelGroupStatus[];
 	workflowGraph?: WorkflowGraphSnapshot;
+	/** Auto-relaunch count when a workflow budget result triggered a fresh top-level run. */
+	workflowRelaunchCount?: number;
 	checkpoint?: ChainCheckpointState;
 	processTerminal?: ProcessTerminalV1;
 	runFanoutBudget?: RunFanoutBudgetSnapshot;
@@ -1460,8 +1467,14 @@ export type AsyncJobStep = NonNullable<AsyncStatus["steps"]>[number] & {
 export interface AsyncJobState {
 	asyncId: string;
 	asyncDir: string;
+	/** True when the job was adopted from a previous session via lineage carry-over. */
+	adopted?: boolean;
+	/** Host tool-call id retained when it differs from the internal run id. */
+	toolCallId?: string;
 	/** Parent-resolved launch directory retained for trusted live artifact lookup. */
 	cwd?: string;
+	/** Parent-resolved child session root retained for trusted live transcript lookup. */
+	sessionRoot?: string;
 	status: "queued" | "running" | "complete" | "failed" | "paused" | "stopped" | "rejected";
 	/** Short caller-facing task/goal shown in fleet surfaces when available. */
 	description?: string;
@@ -1654,6 +1667,12 @@ export interface ActiveAsyncCapacitySnapshot {
 export interface SubagentState {
 	baseCwd: string;
 	currentSessionId: string | null;
+	/** Ordered session identities (session file paths) whose workflow estate this session adopts, self first. */
+	sessionLineage?: string[];
+	/** Earliest result-file mtime eligible for adoption from lineage sessions (replay guard). */
+	adoptedResultWindowStart?: number;
+	/** Set when a session switch adopted live workflows; consumed on the first settled turn to inject a carry-over summary. */
+	handoffResumePending?: boolean;
 	/** Runtime-owned artifact resolution inputs used by Fleet transcript targeting. */
 	artifactDirPreference?: ArtifactDirPreference;
 	/** Runtime authority snapshot used by optional inspector controls. */
@@ -1661,6 +1680,10 @@ export interface SubagentState {
 	/** Runtime mission-store snapshot used by optional inspector context. */
 	missionStoreConfig?: MissionStoreConfig;
 	parentSessionFile?: string | null;
+	/** Extension-owned roots trusted for child session transcript reads. */
+	trustedSessionRoots?: string[];
+	/** Live async session roots created by this parent executor, keyed by run id. */
+	liveAsyncSessionRoots?: Map<string, string>;
 	/** Last valid parent session model observed for this session; used when continuation contexts omit ctx.model. */
 	lastParentModel?: { provider: string; id: string };
 	subagentInProgress?: boolean;
@@ -1757,6 +1780,10 @@ export interface RunSyncOptions {
 	interruptSignal?: AbortSignal;
 	timeoutMs?: number;
 	deadlineAt?: number;
+	/** Per-call per-tool timeout (ms), resolved with the agent/config/environment ladder at execution. */
+	toolTimeoutMs?: number;
+	/** Raw global config.toolTimeoutMs, used by the per-child resolver. */
+	configToolTimeoutMs?: number;
 	turnBudget?: ResolvedTurnBudget;
 	usageBudget?: UsageBudgetConfig;
 	/** Enforce maxTurns + graceTurns as a hard model-turn boundary. */
@@ -1821,6 +1848,8 @@ export interface RunSyncOptions {
 	};
 	/** Private live callback for the exact child prompt after runtime acceptance injection. */
 	onEffectivePrompt?: (prompt: string) => void;
+	/** Internal lifecycle hook for the observer shared across retries of one logical child. */
+	onOrcaProgressTabCreated?: (tab: import("../runs/shared/orca-progress-tabs.ts").OrcaProgressTab) => void;
 }
 
 export type IntercomBridgeMode = "off" | "fork-only" | "always";
@@ -1882,8 +1911,22 @@ export const FLEET_KEYBINDING_ACTIONS = [
 export type FleetKeybindingAction = typeof FLEET_KEYBINDING_ACTIONS[number];
 export type FleetKeybindingsConfig = Partial<Record<FleetKeybindingAction, string[]>>;
 
+export interface OrcaProgressTabsConfig {
+	/** Create one Orca terminal tab per running subagent. Experimental and opt-in. */
+	enabled?: boolean;
+}
+
+export interface MainWindowRendererConfig {
+	/** Unit of horizontal space in main chat subagent call/result rows. Omit to preserve current spacing. Set 0 for no extra padding. */
+	horizontalSpacing?: number;
+	/** Maximum collapsed rich-result rows. Expanded output is not capped. */
+	compactResultMaxLines?: number;
+}
+
 export interface ExtensionConfig {
 	asyncByDefault?: boolean;
+	/** Optional shortcut that detaches the active foreground single-subagent run. */
+	foregroundDetachShortcut?: string;
 	/** Show the Claude Code-style navigable fleet. Defaults to true. */
 	fleetView?: boolean;
 	/** Place the persistent FleetView above or below the editor. Defaults to belowEditor. */
@@ -1892,12 +1935,16 @@ export interface ExtensionConfig {
 	fleetKeybindings?: FleetKeybindingsConfig;
 	/** Show the under-editor async runs widget. Defaults to true, including when FleetView is enabled. */
 	asyncWidget?: boolean;
-	/** Tool description variant registered for the parent-facing subagent tool. Defaults to full. */
+	/** Tool description variant registered for the parent-facing subagent tool. Defaults to compact. */
 	toolDescriptionMode?: ToolDescriptionMode;
 	/** Include legacy append-step and checkpoint controls in the registered tool schema. Defaults to false. */
 	legacyChainControls?: boolean;
 	/** Inline chat rendering for the subagent tool. Defaults to rich. */
 	inlineToolDisplay?: InlineToolDisplay;
+	/** Density controls for the main chat subagent call/result renderer. */
+	mainWindowRenderer?: MainWindowRendererConfig;
+	/** Experimental observer: mirror each native subagent's progress into a new Orca tab. */
+	orcaProgressTabs?: OrcaProgressTabsConfig;
 	forceTopLevelAsync?: boolean;
 	waitTool?: WaitToolConfig;
 	defaultSessionDir?: string;
@@ -1907,6 +1954,12 @@ export interface ExtensionConfig {
 	maxSubagentSpawnsPerSession?: number;
 	/** Cumulative logical-child cap for one top-level run tree. Defaults to 64. */
 	maxSubagentSpawnsPerRun?: number;
+	/**
+	 * Max auto-relaunches when a scripted workflow ends with a fan-out budget
+	 * result before the goal is clean. Each relaunch is a fresh top-level run
+	 * with a new fan-out budget. Defaults to 12; 0 means unlimited.
+	 */
+	maxWorkflowAutoRelaunches?: number;
 	/** Optional active top-level async run cap per parent session. Unset or 0 means unlimited. */
 	maxActiveAsyncRunsPerSession?: number;
 	/** Global cap on simultaneously-running subagent tasks within a single run. Defaults to 20. */
@@ -1921,6 +1974,15 @@ export interface ExtensionConfig {
 	 * Must be a positive integer; invalid values are ignored.
 	 */
 	timeoutMs?: number;
+	/**
+	 * Optional hard per-tool-call timeout in milliseconds. Bounds a single
+	 * subagent tool call inside the child; the run-level timeout remains
+	 * authoritative. Known-fast built-in tools have a five-minute default when
+	 * this is undefined. Precedence: call param > agent frontmatter > this config >
+	 * SELESAI_SUBAGENT_TOOL_TIMEOUT_MS. Must be a positive integer; invalid values
+	 * are rejected with an error.
+	 */
+	toolTimeoutMs?: number;
 	control?: ControlConfig;
 	completionBatch?: CompletionBatchConfig;
 	turnBudget?: TurnBudgetConfig;
@@ -2044,7 +2106,7 @@ export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
 export const POLL_INTERVAL_MS = 250;
 export const MAX_WIDGET_JOBS = 4;
 export const DEFAULT_SUBAGENT_MAX_DEPTH = 2;
-export const SUBAGENT_ACTIONS = ["list", "get", "models", "children.list", "guide", "create", "update", "delete", "eject", "disable", "enable", "reset", "mission.create", "mission.list", "mission.show", "mission.update", "mission.resolve-decision", "mission.attach-run", "mission.close", "worktree.discard", "refine", "refine.show", "refine.rollback", "inspector.open", "inspector.status", "inspector.close", "project.open", "project.status", "project.close", "status", "grant-spawn-budget", "interrupt", "resume", "steer", "stop", "dismiss", "append-step", "approve-checkpoint", "reject-checkpoint", "doctor", "watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model", "schedule.create", "schedule.list", "schedule.show", "schedule.history", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"] as const;
+export const SUBAGENT_ACTIONS = ["list", "get", "models", "children.list", "guide", "create", "update", "delete", "eject", "disable", "enable", "reset", "mission.create", "mission.list", "mission.show", "mission.update", "mission.resolve-decision", "mission.attach-run", "mission.close", "worktree.discard", "refine", "refine.show", "refine.rollback", "inspector.open", "inspector.status", "inspector.close", "project.open", "project.status", "project.close", "status", "debug.run", "grant-spawn-budget", "interrupt", "resume", "steer", "stop", "dismiss", "append-step", "approve-checkpoint", "reject-checkpoint", "doctor", "watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model", "schedule.create", "schedule.list", "schedule.show", "schedule.history", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"] as const;
 
 export const DEFAULT_FORK_PREAMBLE =
 	"You are a delegated subagent running from a fork of the parent session. " +

package/dist/extensions/pi-subagents/src/slash/slash-commands.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { keyText, type ExtensionAPI, type ExtensionContext } from "@selesai/code";
-import { Key, matchesKey, truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { Key, matchesKey, truncateToWidth, type Component, type KeyId, type TUI } from "@earendil-works/pi-tui";
 import { BUILTIN_AGENT_NAMES, discoverAgents } from "../agents/agents.ts";
 import { registerInlineSubagentInvocation } from "./inline-subagents.ts";
 import { resolveExistingReadPaths } from "../shared/settings.ts";
@@ -632,7 +632,7 @@ function slashRunWorkflowScript(key: string, child: Record<string, unknown>): st
 export function registerSlashCommands(
 	pi: ExtensionAPI,
 	state: SubagentState,
-	options: { fleetKeybindings?: FleetKeybindingsConfig } = {},
+	options: { fleetKeybindings?: FleetKeybindingsConfig; foregroundDetachShortcut?: string } = {},
 ): void {
 	registerInlineSubagentInvocation(pi, state);
 	let fleetOpen = false;
@@ -743,33 +743,42 @@ export function registerSlashCommands(
 		handler: async (ctx) => showFleet(ctx),
 	});
 
+	const detachForegroundRun = (args: string, ctx: ExtensionContext): void => {
+		const id = args.trim();
+		let control: ReturnType<typeof selectForegroundDetachControl>;
+		try {
+			control = selectForegroundDetachControl(state, id);
+		} catch (error) {
+			ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			return;
+		}
+		if (!control) {
+			ctx.ui.notify(id ? `No active foreground run found for '${id}'.` : "No active foreground single-subagent run to detach.", "info");
+			return;
+		}
+		if (control.mode !== "single") {
+			ctx.ui.notify("/subagents-detach currently supports single-subagent runs only.", "error");
+			return;
+		}
+		if (!control.detach?.()) {
+			ctx.ui.notify(`Foreground run ${control.runId} is not currently detachable.`, "info");
+			return;
+		}
+		sendSlashText(pi, `Detached foreground run ${control.runId} without terminating its child. Use subagent({ action: "status", id: ${JSON.stringify(control.runId)} }) or subagent_wait({ id: ${JSON.stringify(control.runId)} }) to recover the eventual result. This does not daemonize the process or guarantee survival across Pi reload/restart.`);
+	};
+
 	pi.registerCommand("subagents-detach", {
 		description: "Detach the active foreground single-subagent run without terminating it",
-		handler: async (args, ctx) => {
-			const id = args.trim();
-			let control: ReturnType<typeof selectForegroundDetachControl>;
-			try {
-				control = selectForegroundDetachControl(state, id);
-			} catch (error) {
-				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-				return;
-			}
-			if (!control) {
-				ctx.ui.notify(id ? `No active foreground run found for '${id}'.` : "No active foreground single-subagent run to detach.", "info");
-				return;
-			}
-			if (control.mode !== "single") {
-				ctx.ui.notify("/subagents-detach currently supports single-subagent runs only.", "error");
-				return;
-			}
-			if (!control.detach?.()) {
-				ctx.ui.notify(`Foreground run ${control.runId} is not currently detachable.`, "info");
-				return;
-			}
-			sendSlashText(pi, `Detached foreground run ${control.runId} without terminating its child. Use subagent({ action: "status", id: ${JSON.stringify(control.runId)} }) or subagent_wait({ id: ${JSON.stringify(control.runId)} }) to recover the eventual result. This does not daemonize the process or guarantee survival across Pi reload/restart.`);
-		},
+		handler: async (args, ctx) => detachForegroundRun(args, ctx),
 	});
 
+	if (options.foregroundDetachShortcut) {
+		pi.registerShortcut(options.foregroundDetachShortcut as KeyId, {
+			description: "Detach the active foreground subagent and keep it running in the background",
+			handler: async (ctx) => detachForegroundRun("", ctx),
+		});
+	}
+
 	pi.registerCommand("subagents-stop", {
 		description: "Stop a current-session async subagent run",
 		handler: async (args, ctx) => {

package/dist/extensions/pi-subagents/src/slash/slash-live-state.ts

@@ -81,6 +81,7 @@ function buildParallelInitialResult(params: SubagentParamsLike): AgentToolResult
 		content: [{ type: "text", text: tasks.map((task) => `${task.agent}: ${task.task}`).join("\n\n") }],
 		details: {
 			mode: "parallel",
+			...(params.async ? { background: true } : {}),
 			...(params.context ? { context: params.context } : {}),
 			results: tasks.map((task, index) => createPlaceholderResult(task.agent, task.task, "running", index)),
 			progress: tasks.map((task, index) => ({
@@ -136,6 +137,7 @@ function buildChainInitialResult(params: SubagentParamsLike): AgentToolResult<De
 		}],
 		details: {
 			mode: "chain",
+			...(params.async ? { background: true } : {}),
 			...(params.context ? { context: params.context } : {}),
 			results,
 			progress: results.map((result, index) => ({
@@ -164,6 +166,7 @@ function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<D
 		content: [{ type: "text", text: task }],
 		details: {
 			mode: "single",
+			...(params.async ? { background: true } : {}),
 			...(params.context ? { context: params.context } : {}),
 			results: [createPlaceholderResult(agent, task, "running", 0)],
 			progress: [{
@@ -189,6 +192,7 @@ function buildWorkflowInitialResult(params: SubagentParamsLike): AgentToolResult
 		details: {
 			mode: "workflow",
 			...(params.context ? { context: params.context } : {}),
+			...(params.async ? { background: true } : {}),
 			results: [],
 			workflow: { trace: [], emits: [], console: [] },
 		},