pi-subagents 0.51.0 → 0.52.0

package/src/runs/foreground/workflow-detach-reconcile.ts

@@ -0,0 +1,194 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { isStorageCapacityError } from "../../shared/file-system-retry.ts";
+import { getSingleResultOutput, readStatus } from "../../shared/utils.ts";
+import {
+	DIRS,
+	SUBAGENT_ASYNC_COMPLETE_EVENT,
+	type AsyncStatus,
+	type IntercomEventBus,
+	type SingleResult,
+	type SubagentState,
+} from "../../shared/types.ts";
+import { updateActiveRunIndex } from "../background/active-run-index.ts";
+import { resultFilePath, writeAsyncResultFile } from "../background/result-files.ts";
+
+function cloneWorkflowStatus(status: AsyncStatus): AsyncStatus {
+	return {
+		...status,
+		steps: status.steps?.map((step) => ({ ...step })),
+		workflow: status.workflow ? { ...status.workflow, trace: [...(status.workflow.trace ?? [])] } : status.workflow,
+	};
+}
+
+function childSucceeded(result: Pick<SingleResult, "exitCode" | "error">): boolean {
+	return result.exitCode === 0 && !result.error;
+}
+
+export function applyDetachedChildToPausedWorkflow(
+	status: AsyncStatus,
+	input: { childRunId: string; result: Pick<SingleResult, "exitCode" | "error" | "sessionFile">; workflowKey?: string },
+): AsyncStatus | undefined {
+	if (status.mode !== "workflow" || status.state !== "paused") return undefined;
+	const next = cloneWorkflowStatus(status);
+	const step = next.steps?.find((candidate) => candidate.runId === input.childRunId)
+		?? (input.workflowKey ? next.steps?.find((candidate) => candidate.workflowKey === input.workflowKey) : undefined);
+	if (!step) return undefined;
+	const succeeded = childSucceeded(input.result);
+	const updatedAt = Date.now();
+	step.status = succeeded ? "completed" : "failed";
+	step.endedAt = updatedAt;
+	delete step.activityState;
+	delete step.currentTool;
+	delete step.currentToolStartedAt;
+	if (input.result.sessionFile) step.sessionFile = input.result.sessionFile;
+	if (succeeded) delete step.error;
+	else if (input.result.error) step.error = input.result.error;
+	next.lastUpdate = updatedAt;
+	const promoted = promotePausedWorkflowIfSettled(next);
+	if (promoted?.state === "failed" && input.result.error) promoted.error = input.result.error;
+	return promoted ?? next;
+}
+
+export function promotePausedWorkflowIfSettled(status: AsyncStatus): AsyncStatus | undefined {
+	if (status.mode !== "workflow" || status.state !== "paused") return undefined;
+	const next = cloneWorkflowStatus(status);
+	const stillOpen = next.steps?.some((candidate) =>
+		candidate.status === "running"
+		|| (candidate.status === "paused" && candidate.activityState === "needs_attention")
+	) === true;
+	if (stillOpen || !next.steps?.length) return undefined;
+	const failed = next.steps.some((candidate) => candidate.status === "failed");
+	const updatedAt = Date.now();
+	next.lastUpdate = updatedAt;
+	next.state = failed ? "failed" : "complete";
+	next.endedAt = updatedAt;
+	delete next.activityState;
+	if (!failed) delete next.error;
+	return next;
+}
+
+function workflowResultChildren(status: AsyncStatus, childRunId: string, result: SingleResult, existingResults: unknown): unknown {
+	const output = getSingleResultOutput(result);
+	if (Array.isArray(existingResults)) {
+		return existingResults.map((entry) => {
+			if (!entry || typeof entry !== "object" || Array.isArray(entry)) return entry;
+			const child = entry as Record<string, unknown>;
+			if (child.runId !== childRunId) return child;
+			return {
+				...child,
+				success: childSucceeded(result),
+				output,
+				outputState: output.trim() ? "present" : "absent",
+				detached: undefined,
+				...(result.error ? { error: result.error } : {}),
+			};
+		});
+	}
+	return status.steps?.map((step) => ({
+		workflowKey: step.workflowKey,
+		agent: step.agent,
+		runId: step.runId,
+		success: step.status === "completed" || step.status === "complete",
+		output: step.runId === childRunId ? output : "",
+		outputState: step.runId === childRunId && output.trim() ? "present" : "absent",
+		...(step.error ? { error: step.error } : {}),
+	}));
+}
+
+function publishedWorkflowResult(status: AsyncStatus, childRunId: string, result: SingleResult, asyncDir: string, existing?: Record<string, unknown>): Record<string, unknown> {
+	const sessionId = status.sessionId ?? (typeof existing?.sessionId === "string" ? existing.sessionId : undefined);
+	const summary = status.state === "complete"
+		? `Workflow completed after detached child ${childRunId} finished.`
+		: status.error ?? (typeof existing?.summary === "string" ? existing.summary : undefined);
+	return {
+		...(existing ?? {}),
+		id: status.runId,
+		runId: status.runId,
+		toolCallId: status.toolCallId,
+		agent: "workflow",
+		mode: "workflow",
+		success: status.state === "complete",
+		state: status.state,
+		summary,
+		error: status.error,
+		activityState: status.activityState,
+		endedAt: status.endedAt,
+		timestamp: Date.now(),
+		results: workflowResultChildren(status, childRunId, result, existing?.results),
+		workflow: status.workflow,
+		asyncDir,
+		cwd: status.cwd,
+		sessionId,
+		completionOwnerId: status.completionOwnerId,
+	};
+}
+
+export function reconcileDetachedWorkflowChildCompletion(input: {
+	state: SubagentState;
+	workflowRunId: string;
+	childRunId: string;
+	result: SingleResult;
+	events?: IntercomEventBus;
+	workflowKey?: string;
+}): boolean {
+	const job = input.state.asyncJobs.get(input.workflowRunId);
+	const asyncDir = job?.asyncDir ?? path.join(DIRS.async, input.workflowRunId);
+	const status = readStatus(asyncDir);
+	if (!status) return false;
+	const next = applyDetachedChildToPausedWorkflow(status, {
+		childRunId: input.childRunId,
+		result: input.result,
+		workflowKey: input.workflowKey,
+	});
+	if (!next) return false;
+	writeAtomicJson(path.join(asyncDir, "status.json"), next);
+	updateActiveRunIndex(asyncDir, next.state, next.toolCallId);
+	if (job) {
+		job.status = next.state;
+		job.updatedAt = next.lastUpdate;
+		job.activityState = next.activityState;
+		job.steps = next.steps?.map((step, index) => ({ ...step, index }));
+		job.workflow = next.workflow;
+	}
+	const resultPath = resultFilePath(DIRS.results, input.workflowRunId);
+	let existing: Record<string, unknown> | undefined;
+	try {
+		const parsed: unknown = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) existing = parsed as Record<string, unknown>;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	const published = publishedWorkflowResult(next, input.childRunId, input.result, asyncDir, existing);
+	writeAsyncResultFile(resultPath, published);
+	if (next.state === "complete" || next.state === "failed") {
+		try {
+			fs.appendFileSync(path.join(asyncDir, "events.jsonl"), `${JSON.stringify({
+				ts: Date.now(),
+				runId: input.workflowRunId,
+				type: "subagent.workflow.completed",
+				state: next.state,
+				...(next.error ? { error: next.error } : {}),
+				reconciledFromDetachedChild: input.childRunId,
+			})}\n`, "utf-8");
+		} catch (error) {
+			if (!isStorageCapacityError(error)) throw error;
+		}
+		input.events?.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+			id: input.workflowRunId,
+			runId: input.workflowRunId,
+			source: "async",
+			mode: "workflow",
+			agent: "workflow",
+			success: next.state === "complete",
+			state: next.state,
+			summary: typeof published.summary === "string" ? published.summary : (next.state === "complete" ? "Workflow completed." : next.error),
+			sessionId: next.sessionId,
+			completionOwnerId: next.completionOwnerId,
+			timestamp: Date.now(),
+			triggerTurn: true,
+		});
+	}
+	return true;
+}

package/src/runs/shared/acceptance.ts

@@ -946,7 +946,7 @@ function reportEvidenceStatus(report: AcceptanceReport, kind: AcceptanceEvidence
 }
 
 function checkNoStagedFiles(cwd: string): AcceptanceRuntimeCheck {
-	const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8" });
+	const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8", windowsHide: true });
 	if (result.status !== 0) {
 		return { id: "no-staged-files", status: "not-applicable", message: "git status unavailable; no staged-files check skipped" };
 	}
@@ -1053,11 +1053,11 @@ interface VerifyWorkspaceState {
 }
 
 function readVerifyWorkspaceState(cwd: string): VerifyWorkspaceState | undefined {
-	const repo = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf-8" });
+	const repo = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf-8", windowsHide: true });
 	if (repo.status !== 0 || !repo.stdout.trim()) return undefined;
 	const repoRoot = fs.realpathSync(repo.stdout.trim());
-	const head = spawnSync("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf-8" });
-	const diff = spawnSync("git", ["diff", "--binary", "--full-index", "HEAD", "--"], { cwd: repoRoot, encoding: "utf-8", maxBuffer: 50 * 1024 * 1024 });
+	const head = spawnSync("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf-8", windowsHide: true });
+	const diff = spawnSync("git", ["diff", "--binary", "--full-index", "HEAD", "--"], { cwd: repoRoot, encoding: "utf-8", maxBuffer: 50 * 1024 * 1024, windowsHide: true });
 	if (head.status !== 0 || diff.status !== 0 || !head.stdout.trim()) return undefined;
 	return {
 		kind: "git-tracked",

package/src/runs/shared/external-job-bridge.ts

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -134,11 +133,6 @@ function processStartIdentity(pid: number): string | undefined {
 			return undefined;
 		}
 	}
-	if (process.platform === "darwin" || process.platform === "freebsd") {
-		const result = spawnSync("/bin/ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf-8" });
-		const started = result.status === 0 ? result.stdout.trim() : "";
-		return started ? `${process.platform}:${started}` : undefined;
-	}
 	return undefined;
 }
 

package/src/runs/shared/model-fallback.ts

@@ -41,7 +41,7 @@ export function normalizeParentModel(model: unknown): ParentModel | undefined {
 /**
  * Normalize a model id or provider segment for fuzzy comparison: case-fold,
  * treat dots/underscores as dashes (so `4.5` matches `4-5`), and collapse
- * repeated separators. Pure.
+ * repeated separators.
  */
 export function normalizeModelSegment(segment: string): string {
 	return segment
@@ -58,7 +58,7 @@ function isPlausibleDateStamp(year: string, month: string, day: string): boolean
 	return yyyy >= 1900 && yyyy <= 2099 && mm >= 1 && mm <= 12 && dd >= 1 && dd <= 31;
 }
 
-/** Drop a trailing date stamp (`-20251001` or `-2025-10-01`) so dated and undated ids match. Pure. */
+/** Drop a trailing date stamp (`-20251001` or `-2025-10-01`) so dated and undated ids match. */
 function stripTrailingDateStamp(segment: string): string {
 	const dashed = /^(.*)-(\d{4})-(\d{2})-(\d{2})$/.exec(segment);
 	if (dashed && isPlausibleDateStamp(dashed[2]!, dashed[3]!, dashed[4]!)) return dashed[1]!;
@@ -67,21 +67,65 @@ function stripTrailingDateStamp(segment: string): string {
 	return segment;
 }
 
+function isRegisteredProvider(provider: string, availableModels: AvailableModelInfo[]): boolean {
+	const normalized = normalizeModelSegment(provider);
+	return availableModels.some((entry) => normalizeModelSegment(entry.provider) === normalized);
+}
+
+/**
+ * Split `provider/id` only when the first path segment is a registered provider.
+ * Hugging Face-style `owner/name` ids therefore stay intact unless `owner` is
+ * itself a provider in the active registry. `:` and `.` keep the same rule.
+ */
+function splitQualifiedModelQuery(
+	baseModel: string,
+	availableModels: AvailableModelInfo[],
+): { queryProvider?: string; queryIdRaw: string } {
+	const slashIdx = baseModel.indexOf("/");
+	if (slashIdx !== -1) {
+		const providerPart = baseModel.slice(0, slashIdx);
+		if (isRegisteredProvider(providerPart, availableModels)) {
+			return { queryProvider: normalizeModelSegment(providerPart), queryIdRaw: baseModel.slice(slashIdx + 1) };
+		}
+		return { queryIdRaw: baseModel };
+	}
+	const providerSeparators = [":", "."];
+	for (const separator of providerSeparators) {
+		const separatorIdx = baseModel.indexOf(separator);
+		if (separatorIdx <= 0) continue;
+		const providerPart = baseModel.slice(0, separatorIdx);
+		if (!isRegisteredProvider(providerPart, availableModels)) continue;
+		return { queryProvider: normalizeModelSegment(providerPart), queryIdRaw: baseModel.slice(separatorIdx + 1) };
+	}
+	return { queryIdRaw: baseModel };
+}
+
+function resolveExactIdMatches(
+	baseModel: string,
+	availableModels: AvailableModelInfo[],
+	preferredProvider?: string,
+): string | undefined {
+	const exactMatches = availableModels.filter((entry) => entry.id === baseModel);
+	if (preferredProvider) {
+		const preferredMatch = exactMatches.find((entry) => entry.provider === preferredProvider);
+		if (preferredMatch) return preferredMatch.fullId;
+	}
+	if (exactMatches.length === 1) return exactMatches[0]!.fullId;
+	return undefined;
+}
+
 function resolveBaseModelCandidate(
 	baseModel: string,
 	availableModels: AvailableModelInfo[],
 	preferredProvider?: string,
 ): string | undefined {
-	if (baseModel.includes("/")) {
-		const exact = availableModels.find((entry) => entry.fullId === baseModel);
-		if (exact) return exact.fullId;
-	} else {
-		const exactMatches = availableModels.filter((entry) => entry.id === baseModel);
-		if (preferredProvider) {
-			const preferredMatch = exactMatches.find((entry) => entry.provider === preferredProvider);
-			if (preferredMatch) return preferredMatch.fullId;
-		}
-		if (exactMatches.length === 1) return exactMatches[0]!.fullId;
+	const exact = availableModels.find((entry) => entry.fullId === baseModel);
+	if (exact) return exact.fullId;
+
+	const { queryProvider } = splitQualifiedModelQuery(baseModel, availableModels);
+	if (queryProvider === undefined) {
+		const exactId = resolveExactIdMatches(baseModel, availableModels, preferredProvider);
+		if (exactId) return exactId;
 	}
 
 	return fuzzyResolveModel(baseModel, availableModels, preferredProvider);
@@ -90,35 +134,20 @@ function resolveBaseModelCandidate(
 /**
  * Fuzzy-resolve a base model id (thinking suffix already stripped) against the
  * registry, tolerating separator, case, and optional date-stamp differences so
- * users do not have to spell provider/model exactly. A qualified `provider/id`
+ * users do not have to spell provider/model exactly. A slash is a provider
+ * prefix only when that prefix is a registered provider; otherwise the whole
+ * string is the model id (Hugging Face `owner/name`). A qualified provider
  * query only matches within the named provider — this never silently switches
  * providers for security/cost-sensitive configs. Returns the matched `fullId`,
  * or `undefined` when there is no match or the match is ambiguous across
- * providers (and no `preferredProvider` disambiguates). Pure.
+ * providers (and no `preferredProvider` disambiguates).
  */
 export function fuzzyResolveModel(
 	baseModel: string,
 	availableModels: AvailableModelInfo[],
 	preferredProvider?: string,
 ): string | undefined {
-	let queryProvider: string | undefined;
-	let queryIdRaw = baseModel;
-	const slashIdx = baseModel.indexOf("/");
-	if (slashIdx !== -1) {
-		queryProvider = normalizeModelSegment(baseModel.slice(0, slashIdx));
-		queryIdRaw = baseModel.slice(slashIdx + 1);
-	} else {
-		const providerSeparators = [":", "."];
-		for (const separator of providerSeparators) {
-			const separatorIdx = baseModel.indexOf(separator);
-			if (separatorIdx <= 0) continue;
-			const providerPart = normalizeModelSegment(baseModel.slice(0, separatorIdx));
-			if (!availableModels.some((entry) => normalizeModelSegment(entry.provider) === providerPart)) continue;
-			queryProvider = providerPart;
-			queryIdRaw = baseModel.slice(separatorIdx + 1);
-			break;
-		}
-	}
+	const { queryProvider, queryIdRaw } = splitQualifiedModelQuery(baseModel, availableModels);
 	const queryId = normalizeModelSegment(queryIdRaw);
 	const queryIdNoDate = stripTrailingDateStamp(queryId);
 
@@ -143,7 +172,7 @@ export function fuzzyResolveModel(
  * thinking suffix). Exact registry matches win; fuzzy normalization
  * (separator/case/date-stamp via {@link fuzzyResolveModel}) is a fallback so
  * spelling differences still resolve. Never switches providers for a qualified
- * query. Pure.
+ * query.
  */
 export function resolveModelCandidate(
 	model: string | undefined,
@@ -272,6 +301,18 @@ export interface BuildModelCandidatesOptions {
 	/** Fallback models warn by default and throw when strict scope enforcement is enabled. */
 	scope?: ModelScopeConfig;
 	onWarn?: (violation: ModelScopeViolation) => void;
+	/** The primary model came from the running parent session, not configuration. */
+	primaryModelFromParent?: boolean;
+}
+
+export function inheritsParentModel(
+	explicitModel: string | boolean | undefined,
+	agentModel: string | boolean | undefined,
+	parentModel: ParentModel | undefined,
+): boolean {
+	const requestedModel = explicitModel ?? agentModel;
+	const trimmed = typeof requestedModel === "string" ? requestedModel.trim() : "";
+	return Boolean(parentModel && (!trimmed || trimmed === INHERIT_MODEL));
 }
 
 export function buildModelCandidates(
@@ -289,7 +330,9 @@ export function buildModelCandidates(
 		if (!raw) continue;
 		const model = raw.trim();
 		const normalized = index === 0
-			? resolveRequiredSubagentModelCandidate(model, availableModels, preferredProvider)
+			? options?.primaryModelFromParent
+				? model
+				: resolveRequiredSubagentModelCandidate(model, availableModels, preferredProvider)
 			: resolveSubagentModelCandidate(model, availableModels, preferredProvider);
 		if (!normalized) {
 			console.warn(`[pi-subagents] Skipping fallback model '${model}' because it is unavailable in this environment.`);

package/src/runs/shared/session-lease.ts

@@ -1,4 +1,3 @@
-import { spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -79,11 +78,6 @@ function getProcessStartIdentity(pid: number): string | undefined {
 			return undefined;
 		}
 	}
-	if (process.platform === "darwin" || process.platform === "freebsd") {
-		const result = spawnSync("/bin/ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf-8" });
-		const started = result.status === 0 ? result.stdout.trim() : "";
-		return started ? `${process.platform}:${started}` : undefined;
-	}
 	return undefined;
 }
 

package/src/runs/shared/worktree.ts

@@ -115,7 +115,7 @@ interface RepoState {
 const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
 
 function runGit(cwd: string, args: string[]): GitResult {
-	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
+	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", windowsHide: true });
 	return {
 		stdout: result.stdout ?? "",
 		stderr: result.stderr ?? "",
@@ -338,6 +338,7 @@ function runWorktreeSetupHook(
 	input: WorktreeSetupHookInput,
 ): string[] {
 	const result = spawnSync(hook.hookPath, [], {
+		windowsHide: true,
 		cwd: input.worktreePath,
 		encoding: "utf-8",
 		input: JSON.stringify(input),

package/src/shared/types.ts

@@ -409,6 +409,12 @@ export type ProcessTerminalV1 =
 		diagnostic?: string;
 	});
 
+/** Identifies the durable schedule that launched a run, so its completion is attributable. */
+export interface ScheduleOrigin {
+	id: string;
+	name?: string;
+}
+
 export type SteeringActionState = "delivered" | "scheduled" | "pending" | "partial" | "recovered" | "failed";
 export type SteeringTargetState = "scheduled" | "pending" | "routed" | "queued" | "delivered" | "late" | "failed" | "recovered";
 
@@ -502,6 +508,7 @@ export interface SteeringRecoveryDescriptor {
 	sessionFile?: string;
 	cwd: string;
 	model?: string;
+	modelOverrideFromParent?: boolean;
 	fallbackModels?: string[];
 	thinking?: string;
 	tools?: string[];
@@ -1408,6 +1415,8 @@ export interface AsyncStatus {
 	workflow?: Details["workflow"];
 	parentWorkflowRunId?: string;
 	workflowKey?: string;
+	/** Set when a durable schedule launched this run, so completions can name their origin. */
+	scheduleOrigin?: ScheduleOrigin;
 	steps?: Array<{
 		agent: string;
 		runner?: ExternalCliRunnerStatus | ExternalJobRunnerStatus;
@@ -1842,6 +1851,8 @@ export interface RunSyncOptions {
 	nestedRoute?: NestedRouteInfo;
 	/** Override the agent's default model (format: "provider/id" or just "id") */
 	modelOverride?: string;
+	/** The override came from the running parent session, not configuration. */
+	modelOverrideFromParent?: boolean;
 	/** LLM intent arbiter for the completion mutation guard (rescues read-only review runs). */
 	llmIntentArbiter?: import("../runs/shared/llm-intent-arbiter.ts").TaskMutationArbiter;
 	/** Override the agent's default thinking level for this run */

package/src/slash/slash-bridge.ts

@@ -39,6 +39,7 @@ interface EventBus {
 
 interface SlashBridgeOptions {
 	events: EventBus;
+	asyncByDefault: boolean;
 	getContext: () => ExtensionContext | null;
 	execute: (
 		id: string,
@@ -79,7 +80,7 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 		const request = data as Partial<SlashSubagentRequest>;
 		if (typeof request.requestId !== "string" || !request.params) return;
 		const { requestId } = request as SlashSubagentRequest;
-		const normalized = normalizePublicSubagentExecution((request as SlashSubagentRequest).params);
+		const normalized = normalizePublicSubagentExecution((request as SlashSubagentRequest).params, { asyncByDefault: options.asyncByDefault });
 		if (!normalized.ok) {
 			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
 				requestId,

package/src/slash/slash-commands.ts

@@ -18,6 +18,7 @@ import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts
 import { findModelInfo, toModelInfo } from "../shared/model-info.ts";
 import { formatTokens, shortenPath } from "../shared/formatters.ts";
 import { listAsyncRuns, formatAsyncRunProgressLabel, type AsyncRunSummary } from "../runs/background/async-status.ts";
+import { encodeInspectReply, handleInspectRpcArgs, INSPECT_WIDGET_KEY } from "../runs/background/inspect-rpc.ts";
 import { listScheduledRunSummaries } from "../runs/background/scheduled-runs.ts";
 import { SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
@@ -711,6 +712,23 @@ export function registerSlashCommands(
 		},
 	});
 
+	pi.registerCommand("subagents-inspect-rpc", {
+		description: "Host integration bridge: answer an async child inspection request with a correlated widget payload (no model turn)",
+		handler: async (args, ctx) => {
+			if (ctx.mode === "tui") {
+				ctx.ui.notify("Inspection replies are emitted only on RPC surfaces. Use /subagents or subagent({ action: \"status\", view: \"transcript\" }) interactively.", "info");
+				return;
+			}
+			if (!ctx.hasUI) return;
+			const reply = handleInspectRpcArgs(args, { state });
+			// Emit-then-retract in one handler: stdio delivers the two widget
+			// updates in order, the host buffers the payload by requestId, and
+			// the dedicated key never accumulates visible state.
+			ctx.ui.setWidget(INSPECT_WIDGET_KEY, encodeInspectReply(reply));
+			ctx.ui.setWidget(INSPECT_WIDGET_KEY, undefined);
+		},
+	});
+
 	pi.registerCommand("subagents-guide", {
 		description: "Show a packaged subagents guide topic",
 		getArgumentCompletions: (prefix) => prefix.includes(" ") ? null : SUBAGENT_GUIDE_TOPICS

package/src/watchdog/change-signature.ts

@@ -38,7 +38,7 @@ export interface WatchdogRepoChangeSignature {
 }
 
 function git(cwd: string, args: string[]): string | undefined {
-	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024, windowsHide: true });
 	if (result.status !== 0) return undefined;
 	return result.stdout;
 }

package/src/watchdog/lsp-diagnostics.ts

@@ -444,6 +444,7 @@ async function collectWithTypeScriptLanguageServer(input: {
 }): Promise<WatchdogLspResult> {
 	const started = Date.now();
 	const child = spawn(input.command.command, input.command.args, {
+		windowsHide: true,
 		cwd: input.root,
 		stdio: "pipe",
 		env: { ...process.env, NO_COLOR: "1" },

package/src/workflows/chat-progress.ts

@@ -26,7 +26,7 @@ interface ResolveWorkflowChatProgressInput {
 }
 
 function git(cwd: string, args: string[]): string | undefined {
-	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
+	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", windowsHide: true });
 	if (result.status !== 0) return undefined;
 	const output = result.stdout.trim();
 	return output || undefined;

package/src/workflows/scripted-workflow.ts

@@ -758,7 +758,18 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 		const child = children.get(key);
 		return child ? [child] : [];
 	}) });
-	const traceChanged = () => options.onTrace?.([...trace]);
+	// Hosts use onTrace to persist a progress journal, and it is invoked from inside
+	// the run-promise handlers below. A throw here would reject the child promise the
+	// script is awaiting, so a single failed status write could mark a completed child
+	// failed and abort its siblings through Promise.all. Telemetry must not decide
+	// workflow outcomes, so a failing callback is reported and the run continues.
+	const traceChanged = () => {
+		try {
+			options.onTrace?.([...trace]);
+		} catch (error) {
+			console.error("Workflow onTrace callback failed:", error);
+		}
+	};
 
 	return await new Promise<WorkflowScriptResult>((resolve, reject) => {
 		const finish = (outcome: { value: unknown } | { error: Error & { workflowErrorKind?: unknown } }) => {
@@ -1012,7 +1023,7 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 			if (!admission) {
 				const seenKeys = new Set<string>();
 				const calls = (batch?.calls ?? [{ key, params }]).filter((call) => {
-					if (seenKeys.has(call.key) || launches.has(call.key) || call.params.resume !== undefined) return false;
+					if (seenKeys.has(call.key) || launches.has(call.key)) return false;
 					seenKeys.add(call.key);
 					return true;
 				});

package/agents/gpt-pro.md

@@ -1,17 +0,0 @@
----
-name: gpt-pro
-description: Surf GPT Pro advisory runner through the external-job provider bridge
-runner:
-  type: external-job
-  provider: surf-oracle
-async: true
-systemPromptMode: replace
-inheritProjectContext: false
-inheritSkills: false
----
-
-You are a read-only GPT Pro advisor reached through Surf Oracle.
-
-Review the supplied task and context.
-Return clear advice, risks, and recommended next steps.
-Do not claim you edited files or ran local tools.