@dungle-scrubs/tallow 0.8.7 → 0.8.8

package/extensions/subagent-tool/index.ts

@@ -54,7 +54,7 @@ import {
 	setPiRef,
 	spawnBackgroundSubagent,
 } from "./process.js";
-import type { SubagentCompleteDetails } from "./schema.js";
+import type { IsolationMode, SubagentCompleteDetails } from "./schema.js";
 import { SubagentParams } from "./schema.js";
 import {
 	backgroundSubagents,
@@ -173,6 +173,11 @@ export default function (pi: ExtensionAPI) {
 		label: "subagent",
 		description: `Delegate tasks to specialized subagents with isolated context. Modes: single (agent + task), parallel (tasks array), centipede (sequential with {previous} placeholder). Default agent scope is "user" (from ~/.tallow/agents). To include project-local agents, set agentScope: "both". Missing agent names recover gracefully via best-match or ephemeral fallback.
 
+ISOLATION:
+- isolation: "worktree" runs a subagent in a detached temporary git worktree
+- precedence: per-call param > agent frontmatter > _defaults.md frontmatter
+- in parallel/centipede mode, isolation can be set per task item
+
 MODEL SELECTION:
 - model: explicit model name (fuzzy matched, e.g. "opus", "haiku", "gemini flash")
 - No model specified: auto-routes based on task type and complexity
@@ -246,7 +251,22 @@ WHEN NOT TO USE SUBAGENTS:
 			}
 
 			const agentScope: AgentScope = params.agentScope ?? "user";
-			const discovery = discoverAgents(ctx.cwd, agentScope);
+			let discovery: ReturnType<typeof discoverAgents>;
+			try {
+				discovery = discoverAgents(ctx.cwd, agentScope);
+			} catch (error) {
+				const reason = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `Invalid agent frontmatter: ${reason}` }],
+					details: {
+						mode: "single" as const,
+						agentScope,
+						projectAgentsDir: null,
+						results: [],
+					},
+					isError: true,
+				};
+			}
 			const agents = discovery.agents;
 			const defaults = discovery.defaults;
 
@@ -376,12 +396,15 @@ WHEN NOT TO USE SUBAGENTS:
 					bg.historyRetainedMessageCount !== undefined
 						? `\n**History:** compacted (${bg.historyRetainedMessageCount}/${bg.historyOriginalMessageCount} messages retained)`
 						: "";
+				const isolationLine = bg.isolationMode
+					? `\n**Isolation:** ${bg.isolationMode}${bg.worktreePath ? ` (${bg.worktreePath})` : ""}`
+					: "";
 				return {
 					details: {},
 					content: [
 						{
 							type: "text",
-							text: `**Task:** ${bg.id}\n**Agent:** ${bg.agent}\n**Status:** ${bg.status}\n**Duration:** ${duration}\n**Task:** ${bg.task}${historyLine}\n\n**Output:**\n${output}`,
+							text: `**Task:** ${bg.id}\n**Agent:** ${bg.agent}\n**Status:** ${bg.status}\n**Duration:** ${duration}\n**Task:** ${bg.task}${isolationLine}${historyLine}\n\n**Output:**\n${output}`,
 						},
 					],
 				};
@@ -406,7 +429,8 @@ WHEN NOT TO USE SUBAGENTS:
 							: getIcon("error");
 				const preview = bg.task.length > 40 ? `${bg.task.slice(0, 37)}...` : bg.task;
 				const compactedBadge = bg.historyCompacted ? " · compacted" : "";
-				return `${statusIcon} **${bg.id}** (${bg.agent}) - ${bg.status}${compactedBadge} (${duration})\n   ${preview}`;
+				const isolationBadge = bg.isolationMode ? ` · ${bg.isolationMode}` : "";
+				return `${statusIcon} **${bg.id}** (${bg.agent}) - ${bg.status}${compactedBadge}${isolationBadge} (${duration})\n   ${preview}`;
 			});
 
 			return {
@@ -428,7 +452,13 @@ WHEN NOT TO USE SUBAGENTS:
  * Execute centipede (sequential) mode.
  */
 async function executeCentipede(
-	centipede: { agent: string; task: string; cwd?: string; model?: string }[],
+	centipede: {
+		agent: string;
+		task: string;
+		cwd?: string;
+		model?: string;
+		isolation?: IsolationMode;
+	}[],
 	ctx: ExtensionContext,
 	agents: { name: string; source: string }[],
 	defaults: Parameters<typeof runSingleAgent>[13],
@@ -511,7 +541,8 @@ async function executeCentipede(
 				step.model,
 				parentModelId,
 				defaults,
-				routingHints
+				routingHints,
+				step.isolation
 			);
 			results.push(result);
 			latestPartialResult = undefined;
@@ -552,11 +583,20 @@ async function executeCentipede(
 	}
 }
 
+/** Parallel-task payload for subagent parallel mode. */
+type ParallelTask = {
+	agent: string;
+	task: string;
+	cwd?: string;
+	model?: string;
+	isolation?: IsolationMode;
+};
+
 /**
  * Execute parallel mode.
  */
 async function executeParallel(
-	tasks: { agent: string; task: string; cwd?: string; model?: string }[],
+	tasks: ParallelTask[],
 	params: { background?: boolean },
 	ctx: ExtensionContext,
 	agents: Parameters<typeof runSingleAgent>[1],
@@ -586,7 +626,8 @@ async function executeParallel(
 				(t as { model?: string }).model,
 				parentModelId,
 				defaults,
-				routingHints
+				routingHints,
+				t.isolation
 			);
 			if (result?.startsWith("bg_")) taskIds.push(result);
 			else if (result) errors.push(result);
@@ -710,7 +751,8 @@ async function executeParallel(
 					(t as { model?: string }).model,
 					parentModelId,
 					defaults,
-					routingHints
+					routingHints,
+					t.isolation
 				);
 				allResults[globalIndex] = result;
 				return result;
@@ -725,7 +767,95 @@ async function executeParallel(
 		ctx.ui.setWorkingMessage();
 	}
 
-	const counts = countParallelResultStates(results);
+	let counts = countParallelResultStates(results);
+	let stalledRetrySummary: string | undefined;
+
+	const initialStalledIndexes = collectParallelStateIndices(results, "stalled");
+	if (initialStalledIndexes.length > 0) {
+		const retrySummaryLines: string[] = [];
+		const totalRetries = initialStalledIndexes.length;
+
+		try {
+			ctx.ui.setWorkingMessage(
+				`Rerunning ${totalRetries} stalled worker${totalRetries === 1 ? "" : "s"} individually`
+			);
+
+			for (let retryIndex = 0; retryIndex < initialStalledIndexes.length; retryIndex++) {
+				const stalledIndex = initialStalledIndexes[retryIndex];
+				const stalledTask = tasks[stalledIndex];
+				const priorResult = allResults[stalledIndex];
+				const retryTask = buildStalledRetryTask(stalledTask.task);
+				const explicitRetryModel = stalledTask.model ?? priorResult.model ?? parentModelId;
+				const retryRoutingHints = explicitRetryModel ? undefined : routingHints;
+				const retryLabel = explicitRetryModel
+					? `model:${explicitRetryModel}`
+					: retryRoutingHints?.modelScope
+						? `modelScope:${retryRoutingHints.modelScope}`
+						: "auto-routing";
+
+				ctx.ui.setWorkingMessage(
+					`Retrying stalled worker ${retryIndex + 1}/${totalRetries}: ${stalledTask.agent}`
+				);
+
+				const retryResult = await runSingleAgent(
+					ctx.cwd,
+					agents,
+					stalledTask.agent,
+					retryTask,
+					stalledTask.cwd,
+					undefined,
+					signal,
+					(partial) => {
+						if (partial.details?.results[0]) {
+							const partialResult = {
+								...partial.details.results[0],
+								task: stalledTask.task,
+							};
+							allResults[stalledIndex] = partialResult;
+							emitParallelUpdate();
+						}
+					},
+					makeDetails("parallel"),
+					pi.events,
+					undefined,
+					explicitRetryModel,
+					parentModelId,
+					defaults,
+					retryRoutingHints,
+					stalledTask.isolation
+				);
+
+				retryResult.task = stalledTask.task;
+				retryResult.stderr = appendStderrNote(
+					retryResult.stderr,
+					`[Auto-rerun] retried stalled worker individually (${retryLabel})`
+				);
+				allResults[stalledIndex] = retryResult;
+				retrySummaryLines.push(`- [${stalledTask.agent}] ${retryLabel}`);
+				emitParallelUpdate();
+			}
+		} finally {
+			ctx.ui.setWorkingMessage();
+		}
+
+		results = [...allResults];
+		counts = countParallelResultStates(results);
+		const remainingStalledIndexes = collectParallelStateIndices(results, "stalled");
+		const recoveredCount = totalRetries - remainingStalledIndexes.length;
+		const remainingAgents = remainingStalledIndexes.map((index) => results[index].agent).join(", ");
+		const lines = [
+			`Auto-rerun: retried ${totalRetries} stalled worker${totalRetries === 1 ? "" : "s"} individually with narrowed scope.`,
+			`Recovered ${recoveredCount}/${totalRetries}.`,
+		];
+		if (remainingStalledIndexes.length > 0) {
+			lines.push(`Still stalled: ${remainingAgents}.`);
+		}
+		stalledRetrySummary = lines.join(" ");
+		if (retrySummaryLines.length > 0) {
+			stalledRetrySummary += `\n${retrySummaryLines.join("\n")}`;
+		}
+	}
+
 	const summaries = results.map((result) => {
 		const output = getFinalOutput(result.messages);
 		const fallback = result.errorMessage || result.stderr || "(no output)";
@@ -737,7 +867,6 @@ async function executeParallel(
 		return `[${result.agent}] ${stateLabel}: ${preview}`;
 	});
 
-	const finishedNonStalled = counts.completed + counts.failed;
 	let isError = false;
 	let stalledRemediation: string | undefined;
 
@@ -748,41 +877,16 @@ async function executeParallel(
 		const stalledAgentList = stalledAgents.join(", ");
 		const remediation =
 			`Stalled workers: ${stalledAgentList}. ` +
-			"Rerun stalled tasks individually, reduce task scope, " +
-			"or set an explicit model/modelScope for those workers.";
-
-		if (ctx.hasUI && finishedNonStalled > 0) {
-			const continueWithPartials = await ctx.ui.confirm(
-				"Parallel workers stalled",
-				`${counts.stalled} worker${counts.stalled === 1 ? "" : "s"} stalled while ` +
-					`${finishedNonStalled} other task${finishedNonStalled === 1 ? "" : "s"} finished.\n\n` +
-					"Continue and return partial results from finished workers?\n\n" +
-					'Select "No" to abort now and rerun the stalled workers.'
-			);
-			if (!continueWithPartials) {
-				return {
-					content: [
-						{
-							type: "text" as const,
-							text:
-								"Parallel run aborted because stalled workers were detected and " +
-								"you chose not to continue with partial results.\n\n" +
-								`${remediation}`,
-						},
-					],
-					details: makeDetails("parallel")(results),
-					isError: true,
-				};
-			}
-		} else {
-			isError = true;
-			stalledRemediation = ctx.hasUI
-				? "Parallel run finished with stalled workers and no completed non-stalled results.\n" +
-					`${remediation}`
-				: "Non-interactive mode: returning partial results and marking this " +
-					"parallel call as error because some workers stalled.\n" +
-					`${remediation}`;
-		}
+			"Automatic rerun already attempted once per stalled worker. " +
+			"Split task scope further, avoid confirmation-gated steps, " +
+			"or pin a different explicit model/modelScope.";
+		isError = true;
+		stalledRemediation = ctx.hasUI
+			? "Parallel run finished with unrecovered stalled workers after automatic reruns.\n" +
+				`${remediation}`
+			: "Non-interactive mode: returning partial results with error because " +
+				"workers remained stalled after automatic reruns.\n" +
+				`${remediation}`;
 	}
 
 	const batchNote =
@@ -796,6 +900,7 @@ async function executeParallel(
 		`(${counts.completed} completed, ${counts.failed} failed, ${counts.stalled} stalled)`;
 	const summaryText =
 		`${header}${batchNote}\n\n${summaries.join("\n\n")}` +
+		(stalledRetrySummary ? `\n\n${stalledRetrySummary}` : "") +
 		(stalledRemediation ? `\n\n${stalledRemediation}` : "");
 
 	return {
@@ -816,6 +921,7 @@ async function executeSingle(
 		session?: string;
 		model?: string;
 		background?: boolean;
+		isolation?: IsolationMode;
 	},
 	ctx: ExtensionContext,
 	agents: Parameters<typeof runSingleAgent>[1],
@@ -845,7 +951,8 @@ async function executeSingle(
 			params.model,
 			parentModelId,
 			defaults,
-			routingHints
+			routingHints,
+			params.isolation
 		);
 		if (result?.startsWith("bg_")) {
 			return {
@@ -907,7 +1014,8 @@ async function executeSingle(
 		params.model,
 		parentModelId,
 		defaults,
-		routingHints
+		routingHints,
+		params.isolation
 	);
 
 	if (singleSpinnerInterval) {
@@ -1138,6 +1246,63 @@ function countParallelResultStates(results: SingleResult[]): ParallelResultCount
 	return counts;
 }
 
+/**
+ * Retry directive appended to stalled-worker reruns.
+ *
+ * Instructs the worker to aggressively narrow scope so retried tasks
+ * are less likely to deadlock on long/interactive paths.
+ */
+const STALLED_RETRY_SCOPE_GUIDANCE =
+	"[Automatic retry after stall]\n" +
+	"Your previous parallel attempt stalled. Execute a narrower slice now: " +
+	"complete only the smallest high-confidence chunk you can finish quickly.\n" +
+	"If the original task is already small, complete it fully. " +
+	"If it is broad, finish one concrete slice and list remaining follow-ups.";
+
+/**
+ * Build the retry task text for a stalled parallel worker.
+ *
+ * @param task - Original worker task
+ * @returns Task text with explicit scope-narrowing retry guidance
+ */
+function buildStalledRetryTask(task: string): string {
+	const baseTask = task.trim();
+	if (baseTask.length === 0) return STALLED_RETRY_SCOPE_GUIDANCE;
+	return `${baseTask}\n\n${STALLED_RETRY_SCOPE_GUIDANCE}`;
+}
+
+/**
+ * Collect indexes of results that match a target parallel state.
+ *
+ * @param results - Parallel result list
+ * @param state - Target state to match
+ * @returns Zero-based indexes for matching rows
+ */
+function collectParallelStateIndices(
+	results: SingleResult[],
+	state: ParallelResultState
+): number[] {
+	const indexes: number[] = [];
+	for (let index = 0; index < results.length; index++) {
+		if (getParallelResultState(results[index]) === state) {
+			indexes.push(index);
+		}
+	}
+	return indexes;
+}
+
+/**
+ * Append a note to stderr while preserving existing diagnostics.
+ *
+ * @param stderr - Existing stderr text
+ * @param note - Diagnostic note to append
+ * @returns Combined stderr string
+ */
+function appendStderrNote(stderr: string, note: string): string {
+	if (!stderr.trim()) return note;
+	return `${stderr}\n${note}`;
+}
+
 /**
  * Render the tool call header for the subagent tool.
  *

package/extensions/subagent-tool/model-router.ts

@@ -31,6 +31,7 @@ import {
 	resolveModelFuzzy,
 	selectModels,
 } from "@dungle-scrubs/synapse";
+import { getTallowPath, getTallowSettingsPath } from "../_shared/tallow-paths.js";
 import { classifyTask } from "./task-classifier.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
@@ -412,8 +413,7 @@ function resolveModePolicyOverridesField(
  * @returns Merged routing config
  */
 export function loadRoutingConfig(cwd: string = process.cwd()): RoutingConfig {
-	const home = process.env.HOME || os.homedir();
-	const userSettingsPath = path.join(home, ".tallow", "settings.json");
+	const userSettingsPath = getTallowSettingsPath();
 	const projectSettingsPath = path.join(cwd, ".tallow", "settings.json");
 
 	const userRouting = readRawRoutingConfig(userSettingsPath);
@@ -698,7 +698,7 @@ export function loadRoutingSignalsSnapshot(
  */
 function getSubscriptionProviders(): string[] {
 	try {
-		const authPath = path.join(os.homedir(), ".tallow", "auth.json");
+		const authPath = getTallowPath("auth.json");
 		const raw = fs.readFileSync(authPath, "utf-8");
 		const data = JSON.parse(raw) as Record<string, { type?: string }>;
 		return Object.entries(data)