pi-subagents 0.9.2 → 0.11.0

package/index.ts

@@ -67,9 +67,31 @@ function loadConfig(): ExtensionConfig {
 	return {};
 }
 
+/**
+ * Create a directory and verify it is actually accessible.
+ * On Windows with Azure AD/Entra ID, directories created shortly after
+ * wake-from-sleep can end up with broken NTFS ACLs (null DACL) when the
+ * cloud SID cannot be resolved without network connectivity. This leaves
+ * the directory completely inaccessible to the creating user.
+ */
+function ensureAccessibleDir(dirPath: string): void {
+	fs.mkdirSync(dirPath, { recursive: true });
+	try {
+		fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
+	} catch {
+		// Directory exists but is inaccessible — remove and recreate
+		try {
+			fs.rmSync(dirPath, { recursive: true, force: true });
+		} catch {}
+		fs.mkdirSync(dirPath, { recursive: true });
+		// Verify recovery succeeded
+		fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
+	}
+}
+
 export default function registerSubagentExtension(pi: ExtensionAPI): void {
-	fs.mkdirSync(RESULTS_DIR, { recursive: true });
-	fs.mkdirSync(ASYNC_DIR, { recursive: true });
+	ensureAccessibleDir(RESULTS_DIR);
+	ensureAccessibleDir(ASYNC_DIR);
 
 	// Cleanup old chain directories on startup (after 24h)
 	cleanupOldChainDirs();
@@ -152,13 +174,42 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	};
 
 	const resultFileCoalescer = createFileCoalescer(handleResult, 50);
-	const watcher = fs.watch(RESULTS_DIR, (ev, file) => {
-		if (ev !== "rename" || !file) return;
-		const fileName = file.toString();
-		if (!fileName.endsWith(".json")) return;
-		resultFileCoalescer.schedule(fileName);
-	});
-	watcher.unref?.();
+	let watcher: fs.FSWatcher | null = null;
+	let watcherRestartTimer: ReturnType<typeof setTimeout> | null = null;
+
+	function startResultWatcher(): void {
+		watcherRestartTimer = null;
+		try {
+			watcher = fs.watch(RESULTS_DIR, (ev, file) => {
+				if (ev !== "rename" || !file) return;
+				const fileName = file.toString();
+				if (!fileName.endsWith(".json")) return;
+				resultFileCoalescer.schedule(fileName);
+			});
+			watcher.on("error", () => {
+				// Watcher died (directory deleted, ACL change, etc.) — restart after delay
+				watcher = null;
+				watcherRestartTimer = setTimeout(() => {
+					try {
+						fs.mkdirSync(RESULTS_DIR, { recursive: true });
+						startResultWatcher();
+					} catch {}
+				}, 3000);
+			});
+			watcher.unref?.();
+		} catch {
+			// fs.watch can throw if directory is inaccessible — retry after delay
+			watcher = null;
+			watcherRestartTimer = setTimeout(() => {
+				try {
+					fs.mkdirSync(RESULTS_DIR, { recursive: true });
+					startResultWatcher();
+				} catch {}
+			}, 3000);
+		}
+	}
+
+	startResultWatcher();
 	fs.readdirSync(RESULTS_DIR)
 		.filter((f) => f.endsWith(".json"))
 		.forEach((file) => resultFileCoalescer.schedule(file, 0));
@@ -229,7 +280,7 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 			currentSessionId = ctx.sessionManager.getSessionFile() ?? `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 			const agents = discoverAgents(ctx.cwd, scope).agents;
 			const runId = randomUUID().slice(0, 8);
-			const shareEnabled = params.share !== false;
+			const shareEnabled = params.share === true;
 			const sessionEnabled = shareEnabled || Boolean(params.sessionDir);
 			const sessionRoot = sessionEnabled
 				? params.sessionDir
@@ -400,7 +451,7 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 				const normalized = normalizeSkillInput(params.skill);
 				const chainSkills = normalized === false ? [] : (normalized ?? []);
 				// Use extracted chain execution module
-				return executeChain({
+				const chainResult = await executeChain({
 					chain: params.chain as ChainStep[],
 					task: params.task,
 					agents,
@@ -418,6 +469,33 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 					chainSkills,
 					chainDir: params.chainDir,
 				});
+
+				// User requested async via TUI - dispatch to async executor
+				if (chainResult.requestedAsync) {
+					if (!isAsyncAvailable()) {
+						return {
+							content: [{ type: "text", text: "Background mode requires jiti for TypeScript execution but it could not be found." }],
+							isError: true,
+							details: { mode: "chain" as const, results: [] },
+						};
+					}
+					const id = randomUUID();
+					const asyncCtx = { pi, cwd: ctx.cwd, currentSessionId: currentSessionId! };
+					return executeAsyncChain(id, {
+						chain: chainResult.requestedAsync.chain,
+						agents,
+						ctx: asyncCtx,
+						cwd: params.cwd,
+						maxOutput: params.maxOutput,
+						artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
+						artifactConfig,
+						shareEnabled,
+						sessionRoot,
+						chainSkills: chainResult.requestedAsync.chainSkills,
+					});
+				}
+
+				return chainResult;
 			}
 
 			if (hasTasks && params.tasks) {
@@ -494,6 +572,39 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 						if (override?.model) modelOverrides[i] = override.model;
 						if (override?.skills !== undefined) skillOverrides[i] = override.skills;
 					}
+
+					// User requested background execution
+					if (result.runInBackground) {
+						if (!isAsyncAvailable()) {
+							return {
+								content: [{ type: "text", text: "Background mode requires jiti for TypeScript execution but it could not be found." }],
+								isError: true,
+								details: { mode: "parallel" as const, results: [] },
+							};
+						}
+						const id = randomUUID();
+						const asyncCtx = { pi, cwd: ctx.cwd, currentSessionId: currentSessionId! };
+						// Convert parallel tasks to a chain with a single parallel step
+						const parallelTasks = params.tasks!.map((t, i) => ({
+							agent: t.agent,
+							task: tasks[i],
+							cwd: t.cwd,
+							...(modelOverrides[i] ? { model: modelOverrides[i] } : {}),
+							...(skillOverrides[i] !== undefined ? { skill: skillOverrides[i] } : {}),
+						}));
+						return executeAsyncChain(id, {
+							chain: [{ parallel: parallelTasks }],
+							agents,
+							ctx: asyncCtx,
+							cwd: params.cwd,
+							maxOutput: params.maxOutput,
+							artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
+							artifactConfig,
+							shareEnabled,
+							sessionRoot,
+							chainSkills: [],
+						});
+					}
 				}
 
 				// Execute with overrides (tasks array has same length as params.tasks)
@@ -548,8 +659,32 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 
 				const ok = results.filter((r) => r.exitCode === 0).length;
 				const downgradeNote = parallelDowngraded ? " (async not supported for parallel)" : "";
+
+				// Aggregate outputs from all parallel tasks
+				const aggregatedOutput = results
+					.map((r, i) => {
+						const header = `=== Task ${i + 1}: ${r.agent} ===`;
+						const output = r.truncation?.text || getFinalOutput(r.messages);
+						const hasOutput = Boolean(output?.trim());
+						const status = r.exitCode !== 0
+							? `⚠️ FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
+							: r.error
+								? `⚠️ WARNING: ${r.error}`
+								: !hasOutput
+									? "⚠️ EMPTY OUTPUT"
+									: "";
+						const body = status
+							? (hasOutput ? `${status}\n${output}` : status)
+							: output;
+						return `${header}\n${body}`;
+					})
+					.join("\n\n");
+
+				const summary = `${ok}/${results.length} succeeded${downgradeNote}`;
+				const fullContent = `${summary}\n\n${aggregatedOutput}`;
+
 				return {
-					content: [{ type: "text", text: `${ok}/${results.length} succeeded${downgradeNote}` }],
+					content: [{ type: "text", text: fullContent }],
 					details: {
 						mode: "parallel",
 						results,
@@ -616,6 +751,33 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 					if (override?.model) modelOverride = override.model;
 					if (override?.output !== undefined) effectiveOutput = override.output;
 					if (override?.skills !== undefined) skillOverride = override.skills;
+
+					// User requested background execution
+					if (result.runInBackground) {
+						if (!isAsyncAvailable()) {
+							return {
+								content: [{ type: "text", text: "Background mode requires jiti for TypeScript execution but it could not be found." }],
+								isError: true,
+								details: { mode: "single" as const, results: [] },
+							};
+						}
+						const id = randomUUID();
+						const asyncCtx = { pi, cwd: ctx.cwd, currentSessionId: currentSessionId! };
+						return executeAsyncSingle(id, {
+							agent: params.agent!,
+							task,
+							agentConfig,
+							ctx: asyncCtx,
+							cwd: params.cwd,
+							maxOutput: params.maxOutput,
+							artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
+							artifactConfig,
+							shareEnabled,
+							sessionRoot,
+							skills: skillOverride === false ? [] : skillOverride,
+							output: effectiveOutput,
+						});
+					}
 				}
 
 				const cleanTask = task;
@@ -846,12 +1008,21 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 		return { name: token.slice(0, bracket), config: parseInlineConfig(token.slice(bracket + 1, end !== -1 ? end : undefined)) };
 	};
 
+	/** Extract --bg flag from end of args, return cleaned args and whether flag was present */
+	const extractBgFlag = (args: string): { args: string; bg: boolean } => {
+		// Only match --bg at the very end to avoid false positives in quoted strings
+		if (args.endsWith(" --bg") || args === "--bg") {
+			return { args: args.slice(0, args.length - (args === "--bg" ? 4 : 5)).trim(), bg: true };
+		}
+		return { args, bg: false };
+	};
+
 	const setupDirectRun = (ctx: ExtensionContext) => {
 		const runId = randomUUID().slice(0, 8);
 		const sessionRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-session-"));
 		return {
 			runId,
-			shareEnabled: true,
+			shareEnabled: false,
 			sessionDirForIndex: (idx?: number) => path.join(sessionRoot, `run-${idx ?? 0}`),
 			artifactsDir: getArtifactsDir(ctx.sessionManager.getSessionFile() ?? null),
 			artifactConfig: { ...DEFAULT_ARTIFACT_CONFIG } as ArtifactConfig,
@@ -905,7 +1076,35 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 				...(i === 0 ? { task: result.task } : {}),
 			}));
 			executeChain({ chain, task: result.task, agents, ctx, ...exec, clarify: true })
-				.then((r) => pi.sendUserMessage(r.content[0]?.text || "(no output)"))
+				.then((r) => {
+					// User requested async via TUI - dispatch to async executor
+					if (r.requestedAsync) {
+						if (!isAsyncAvailable()) {
+							pi.sendUserMessage("Background mode requires jiti for TypeScript execution but it could not be found.");
+							return;
+						}
+						const id = randomUUID();
+						const asyncCtx = { pi, cwd: ctx.cwd, currentSessionId: ctx.sessionManager.getSessionId() ?? id };
+						const sessionRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-session-"));
+						executeAsyncChain(id, {
+							chain: r.requestedAsync.chain,
+							agents,
+							ctx: asyncCtx,
+							maxOutput: undefined,
+							artifactsDir: exec.artifactsDir,
+							artifactConfig: exec.artifactConfig,
+							shareEnabled: false,
+							sessionRoot,
+							chainSkills: r.requestedAsync.chainSkills,
+						}).then((asyncResult) => {
+							pi.sendUserMessage(asyncResult.content[0]?.text || "(launched in background)");
+						}).catch((err) => {
+							pi.sendUserMessage(`Async launch failed: ${err instanceof Error ? err.message : String(err)}`);
+						});
+						return;
+					}
+					pi.sendUserMessage(r.content[0]?.text || "(no output)");
+				})
 				.catch((err) => pi.sendUserMessage(`Chain failed: ${err instanceof Error ? err.message : String(err)}`));
 			return;
 		}
@@ -942,15 +1141,16 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 	});
 
 	pi.registerCommand("run", {
-		description: "Run a subagent directly: /run agent[output=file] task",
+		description: "Run a subagent directly: /run agent[output=file] task [--bg]",
 		getArgumentCompletions: makeAgentCompletions(false),
 		handler: async (args, ctx) => {
-			const input = args.trim();
+			const { args: cleanedArgs, bg } = extractBgFlag(args);
+			const input = cleanedArgs.trim();
 			const firstSpace = input.indexOf(" ");
-			if (firstSpace === -1) { ctx.ui.notify("Usage: /run <agent> <task>", "error"); return; }
+			if (firstSpace === -1) { ctx.ui.notify("Usage: /run <agent> <task> [--bg]", "error"); return; }
 			const { name: agentName, config: inline } = parseAgentToken(input.slice(0, firstSpace));
 			const task = input.slice(firstSpace + 1).trim();
-			if (!task) { ctx.ui.notify("Usage: /run <agent> <task>", "error"); return; }
+			if (!task) { ctx.ui.notify("Usage: /run <agent> <task> [--bg]", "error"); return; }
 
 			const agents = discoverAgents(baseCwd, "both").agents;
 			if (!agents.find((a) => a.name === agentName)) { ctx.ui.notify(`Unknown agent: ${agentName}`, "error"); return; }
@@ -963,6 +1163,7 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 			if (inline.output !== undefined) params.output = inline.output;
 			if (inline.skill !== undefined) params.skill = inline.skill;
 			if (inline.model) params.model = inline.model;
+			if (bg) params.async = true;
 			pi.sendUserMessage(`Call the subagent tool with these exact parameters: ${JSON.stringify({ ...params, agentScope: "both" })}`);
 		},
 	});
@@ -1040,10 +1241,11 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 	};
 
 	pi.registerCommand("chain", {
-		description: "Run agents in sequence: /chain scout \"scan code\" -> planner \"analyze auth\"",
+		description: "Run agents in sequence: /chain scout \"task\" -> planner [--bg]",
 		getArgumentCompletions: makeAgentCompletions(true),
 		handler: async (args, ctx) => {
-			const parsed = parseAgentArgs(args, "chain", ctx);
+			const { args: cleanedArgs, bg } = extractBgFlag(args);
+			const parsed = parseAgentArgs(cleanedArgs, "chain", ctx);
 			if (!parsed) return;
 			const chain = parsed.steps.map(({ name, config, task: stepTask }, i) => ({
 				agent: name,
@@ -1054,15 +1256,18 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 				...(config.skill !== undefined ? { skill: config.skill } : {}),
 				...(config.progress !== undefined ? { progress: config.progress } : {}),
 			}));
-			pi.sendUserMessage(`Call the subagent tool with these exact parameters: ${JSON.stringify({ chain, task: parsed.task, clarify: false, agentScope: "both" })}`);
+			const params: Record<string, unknown> = { chain, task: parsed.task, clarify: false, agentScope: "both" };
+			if (bg) params.async = true;
+			pi.sendUserMessage(`Call the subagent tool with these exact parameters: ${JSON.stringify(params)}`);
 		},
 	});
 
 	pi.registerCommand("parallel", {
-		description: "Run agents in parallel: /parallel scout \"scan bugs\" -> reviewer \"check style\"",
+		description: "Run agents in parallel: /parallel scout \"task1\" -> reviewer \"task2\" [--bg]",
 		getArgumentCompletions: makeAgentCompletions(true),
 		handler: async (args, ctx) => {
-			const parsed = parseAgentArgs(args, "parallel", ctx);
+			const { args: cleanedArgs, bg } = extractBgFlag(args);
+			const parsed = parseAgentArgs(cleanedArgs, "parallel", ctx);
 			if (!parsed) return;
 			if (parsed.steps.length > MAX_PARALLEL) { ctx.ui.notify(`Max ${MAX_PARALLEL} parallel tasks`, "error"); return; }
 			const tasks = parsed.steps.map(({ name, config, task: stepTask }) => ({
@@ -1074,7 +1279,9 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 				...(config.skill !== undefined ? { skill: config.skill } : {}),
 				...(config.progress !== undefined ? { progress: config.progress } : {}),
 			}));
-			pi.sendUserMessage(`Call the subagent tool with these exact parameters: ${JSON.stringify({ chain: [{ parallel: tasks }], task: parsed.task, clarify: false, agentScope: "both" })}`);
+			const params: Record<string, unknown> = { chain: [{ parallel: tasks }], task: parsed.task, clarify: false, agentScope: "both" };
+			if (bg) params.async = true;
+			pi.sendUserMessage(`Call the subagent tool with these exact parameters: ${JSON.stringify(params)}`);
 		},
 	});
 
@@ -1192,7 +1399,9 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 		}
 	});
 	pi.on("session_shutdown", () => {
-		watcher.close();
+		watcher?.close();
+		if (watcherRestartTimer) clearTimeout(watcherRestartTimer);
+		watcherRestartTimer = null;
 		if (poller) clearInterval(poller);
 		poller = null;
 		// Clear all pending cleanup timers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",
@@ -34,12 +34,21 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "test": "node --experimental-strip-types --test *.test.ts"
+    "test": "node --experimental-strip-types --test *.test.ts",
+    "test:integration": "node --experimental-transform-types --import ./test/register-loader.mjs --test test/*.test.ts",
+    "test:e2e": "node --experimental-transform-types --import ./test/register-loader.mjs --test test/e2e-*.test.ts",
+    "test:all": "node --experimental-transform-types --import ./test/register-loader.mjs --test *.test.ts test/*.test.ts"
   },
   "pi": {
     "extensions": [
       "./index.ts",
       "./notify.ts"
     ]
+  },
+  "devDependencies": {
+    "@marcfargas/pi-test-harness": "^0.5.0",
+    "@mariozechner/pi-agent-core": "^0.54.0",
+    "@mariozechner/pi-ai": "^0.54.0",
+    "@mariozechner/pi-coding-agent": "^0.54.0"
   }
 }

package/parallel-utils.ts

@@ -0,0 +1,93 @@
+/**
+ * Parallel execution utilities for the async runner.
+ * Kept minimal and self-contained so the standalone runner can use them
+ * without pulling in the full extension dependency tree.
+ */
+
+/** A single agent step in the runner config */
+export interface RunnerSubagentStep {
+	agent: string;
+	task: string;
+	cwd?: string;
+	model?: string;
+	tools?: string[];
+	extensions?: string[];
+	mcpDirectTools?: string[];
+	systemPrompt?: string | null;
+	skills?: string[];
+	outputPath?: string;
+}
+
+/** Parallel step group — multiple agents running concurrently */
+export interface ParallelStepGroup {
+	parallel: RunnerSubagentStep[];
+	concurrency?: number;
+	failFast?: boolean;
+}
+
+export type RunnerStep = RunnerSubagentStep | ParallelStepGroup;
+
+export function isParallelGroup(step: RunnerStep): step is ParallelStepGroup {
+	return "parallel" in step && Array.isArray((step as ParallelStepGroup).parallel);
+}
+
+/** Flatten runner steps into individual SubagentSteps for status tracking */
+export function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[] {
+	const flat: RunnerSubagentStep[] = [];
+	for (const step of steps) {
+		if (isParallelGroup(step)) {
+			for (const task of step.parallel) flat.push(task);
+		} else {
+			flat.push(step);
+		}
+	}
+	return flat;
+}
+
+/** Run async tasks with bounded concurrency, preserving result order */
+export async function mapConcurrent<T, R>(
+	items: T[],
+	limit: number,
+	fn: (item: T, i: number) => Promise<R>,
+): Promise<R[]> {
+	// Clamp to at least 1; NaN/undefined/0/negative all become 1
+	const safeLimit = Math.max(1, Math.floor(limit) || 1);
+	const results: R[] = new Array(items.length);
+	let next = 0;
+
+	async function worker(): Promise<void> {
+		while (next < items.length) {
+			const i = next++;
+			results[i] = await fn(items[i], i);
+		}
+	}
+
+	await Promise.all(
+		Array.from({ length: Math.min(safeLimit, items.length) }, () => worker()),
+	);
+	return results;
+}
+
+/** Aggregate outputs from parallel tasks into a single string for {previous} */
+export function aggregateParallelOutputs(
+	results: Array<{ agent: string; output: string; exitCode: number | null; error?: string }>,
+): string {
+	return results
+		.map((r, i) => {
+			const header = `=== Parallel Task ${i + 1} (${r.agent}) ===`;
+			const hasOutput = Boolean(r.output?.trim());
+			const status =
+				r.exitCode === -1
+					? "⏭️ SKIPPED"
+					: r.exitCode !== 0
+						? `⚠️ FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
+						: !hasOutput
+							? "⚠️ EMPTY OUTPUT"
+							: "";
+			const body = status ? (hasOutput ? `${status}\n${r.output}` : status) : r.output;
+			return `${header}\n${body}`;
+		})
+		.join("\n\n");
+}
+
+export const MAX_PARALLEL_CONCURRENCY = 4;

package/render.ts

@@ -20,9 +20,68 @@ function getTermWidth(): number {
 	return process.stdout.columns || 120;
 }
 
+// Grapheme segmenter for proper Unicode handling (shared instance)
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+/**
+ * Truncate a line to maxWidth, preserving ANSI styling through the ellipsis.
+ * 
+ * pi-tui's truncateToWidth adds \x1b[0m before ellipsis which resets all styling,
+ * causing background color bleed in the TUI. This implementation tracks active
+ * ANSI styles and re-applies them before the ellipsis.
+ * 
+ * Uses Intl.Segmenter for proper Unicode/emoji handling (not char-by-char).
+ */
 function truncLine(text: string, maxWidth: number): string {
 	if (visibleWidth(text) <= maxWidth) return text;
-	return truncateToWidth(text, maxWidth - 1) + "…";
+
+	const targetWidth = maxWidth - 1; // Room for single ellipsis character
+	let result = "";
+	let currentWidth = 0;
+	let activeStyles: string[] = []; // Track ALL active styles (not just last)
+	let i = 0;
+
+	while (i < text.length) {
+		// Check for ANSI escape code
+		const ansiMatch = text.slice(i).match(/^\x1b\[[0-9;]*m/);
+		if (ansiMatch) {
+			const code = ansiMatch[0];
+			result += code;
+
+			if (code === "\x1b[0m" || code === "\x1b[m") {
+				activeStyles = []; // Reset clears all styles
+			} else {
+				activeStyles.push(code); // Stack styles (bold + color, etc.)
+			}
+			i += code.length;
+			continue;
+		}
+
+		// Find end of non-ANSI text segment
+		let end = i;
+		while (end < text.length && !text.slice(end).match(/^\x1b\[[0-9;]*m/)) {
+			end++;
+		}
+
+		// Segment into graphemes for proper Unicode handling
+		const textPortion = text.slice(i, end);
+		for (const seg of segmenter.segment(textPortion)) {
+			const grapheme = seg.segment;
+			const graphemeWidth = visibleWidth(grapheme);
+
+			if (currentWidth + graphemeWidth > targetWidth) {
+				// Re-apply all active styles before ellipsis to preserve background/colors
+				return result + activeStyles.join("") + "…";
+			}
+
+			result += grapheme;
+			currentWidth += graphemeWidth;
+		}
+		i = end;
+	}
+
+	// Reached end without exceeding width (shouldn't happen given initial check)
+	return result + activeStyles.join("") + "…";
 }
 
 // Track last rendered widget state to avoid no-op re-renders
@@ -319,7 +378,9 @@ export function renderSubagentResult(
 		c.addChild(new Text(truncLine(stepHeader, w), 0, 0));
 
 		const taskMaxLen = Math.max(20, w - 12);
-		const taskPreview = r.task.slice(0, taskMaxLen) + (r.task.length > taskMaxLen ? "..." : "");
+		const taskPreview = r.task.length > taskMaxLen
+			? `${r.task.slice(0, taskMaxLen)}...`
+			: r.task;
 		c.addChild(new Text(truncLine(theme.fg("dim", `    task: ${taskPreview}`), w), 0, 0));
 
 		const outputTarget = extractOutputTarget(r.task);
@@ -340,22 +401,31 @@ export function renderSubagentResult(
 			}
 			// Current tool for running step
 			if (rProg.currentTool) {
-				const toolLine = rProg.currentToolArgs
-					? `${rProg.currentTool}: ${rProg.currentToolArgs.slice(0, 100)}${rProg.currentToolArgs.length > 100 ? "..." : ""}`
+				const maxToolArgsLen = Math.max(50, w - 20);
+				const toolArgsPreview = rProg.currentToolArgs
+					? (rProg.currentToolArgs.length > maxToolArgsLen
+						? `${rProg.currentToolArgs.slice(0, maxToolArgsLen)}...`
+						: rProg.currentToolArgs)
+					: "";
+				const toolLine = toolArgsPreview
+					? `${rProg.currentTool}: ${toolArgsPreview}`
 					: rProg.currentTool;
 				c.addChild(new Text(truncLine(theme.fg("warning", `    > ${toolLine}`), w), 0, 0));
 			}
 			// Recent tools
 			if (rProg.recentTools?.length) {
 				for (const t of rProg.recentTools.slice(0, 3)) {
-					const args = t.args.slice(0, 90) + (t.args.length > 90 ? "..." : "");
-					c.addChild(new Text(truncLine(theme.fg("dim", `      ${t.tool}: ${args}`), w), 0, 0));
+					const maxArgsLen = Math.max(40, w - 30);
+					const argsPreview = t.args.length > maxArgsLen
+						? `${t.args.slice(0, maxArgsLen)}...`
+						: t.args;
+					c.addChild(new Text(truncLine(theme.fg("dim", `      ${t.tool}: ${argsPreview}`), w), 0, 0));
 				}
 			}
-			// Recent output (limited)
+			// Recent output - let truncLine handle truncation entirely
 			const recentLines = (rProg.recentOutput ?? []).slice(-5);
 			for (const line of recentLines) {
-				c.addChild(new Text(truncLine(theme.fg("dim", `      ${line.slice(0, 100)}${line.length > 100 ? "..." : ""}`), w), 0, 0));
+				c.addChild(new Text(truncLine(theme.fg("dim", `      ${line}`), w), 0, 0));
 			}
 		}
 

package/schemas.ts

@@ -83,7 +83,7 @@ export const SubagentParams = Type.Object({
 	maxOutput: MaxOutputSchema,
 	artifacts: Type.Optional(Type.Boolean({ description: "Write debug artifacts (default: true)" })),
 	includeProgress: Type.Optional(Type.Boolean({ description: "Include full progress in result (default: false)" })),
-	share: Type.Optional(Type.Boolean({ description: "Create shareable session log (default: true)", default: true })),
+	share: Type.Optional(Type.Boolean({ description: "Upload session to GitHub Gist for sharing (default: false)" })),
 	sessionDir: Type.Optional(
 		Type.String({ description: "Directory to store session logs (default: temp; enables sessions even if share=false)" }),
 	),