@duckmind/dm-darwin-arm64 0.13.5 → 0.13.6

package/extensions/dm-subagents/artifacts.ts

@@ -1,9 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { ArtifactPaths } from "./types.ts";
-
-const TEMP_ARTIFACTS_DIR = path.join(os.tmpdir(), "dm-subagent-artifacts");
+import { TEMP_ARTIFACTS_DIR, type ArtifactPaths } from "./types.ts";
 const CLEANUP_MARKER_FILE = ".last-cleanup";
 
 export function getArtifactsDir(sessionFile: string | null): string {
@@ -64,7 +62,10 @@ export function cleanupOldArtifacts(dir: string, maxAgeDays: number): void {
 			if (stat.mtimeMs < cutoff) {
 				fs.unlinkSync(filePath);
 			}
-		} catch {}
+		} catch {
+			// Artifact cleanup is best-effort housekeeping. Skip files that disappear
+			// or become unreadable while scanning so one bad entry does not block the rest.
+		}
 	}
 
 	fs.writeFileSync(markerPath, String(now));
@@ -80,6 +81,8 @@ export function cleanupAllArtifactDirs(maxAgeDays: number): void {
 	try {
 		dirs = fs.readdirSync(sessionsBase);
 	} catch {
+		// Session artifact cleanup is best-effort. If the sessions root cannot be read,
+		// skip cleanup instead of failing extension startup.
 		return;
 	}
 
@@ -87,6 +90,9 @@ export function cleanupAllArtifactDirs(maxAgeDays: number): void {
 		const artifactsDir = path.join(sessionsBase, dir, "subagent-artifacts");
 		try {
 			cleanupOldArtifacts(artifactsDir, maxAgeDays);
-		} catch {}
+		} catch {
+			// Session cleanup is best-effort. Keep going so one unreadable session dir
+			// does not block cleanup for the rest.
+		}
 	}
 }

package/extensions/dm-subagents/async-execution.ts

@@ -23,6 +23,8 @@ import {
 	type MaxOutputConfig,
 	ASYNC_DIR,
 	RESULTS_DIR,
+	TEMP_ROOT_DIR,
+	getAsyncConfigPath,
 	resolveChildMaxSubagentDepth,
 } from "./types.ts";
 
@@ -113,7 +115,8 @@ export function isAsyncAvailable(): boolean {
 function spawnRunner(cfg: object, suffix: string, cwd: string): number | undefined {
 	if (!jitiCliPath) return undefined;
 	
-	const cfgPath = path.join(os.tmpdir(), `dm-async-cfg-${suffix}.json`);
+	fs.mkdirSync(TEMP_ROOT_DIR, { recursive: true });
+	const cfgPath = getAsyncConfigPath(suffix);
 	fs.writeFileSync(cfgPath, JSON.stringify(cfg));
 	const runner = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-runner.ts");
 	

package/extensions/dm-subagents/index.ts

@@ -259,7 +259,7 @@ EXECUTION (use exactly ONE mode):
 CHAIN TEMPLATE VARIABLES (use in task strings):
 • {task} - The original task/request from the user
 • {previous} - Text response from the previous step (empty for first step)
-• {chain_dir} - Shared directory for chain files (e.g., <tmpdir>/dm-chain-runs/abc123/)
+• {chain_dir} - Shared directory for chain files (e.g., <tmpdir>/pi-subagents-<scope>/chain-runs/abc123/)
 
 Example: { chain: [{agent:"scout", task:"Analyze {task}"}, {agent:"planner", task:"Plan based on {previous}"}] }
 

package/extensions/dm-subagents/schemas.ts

@@ -83,7 +83,7 @@ export const SubagentParams = Type.Object({
 		enum: ["fresh", "fork"],
 		description: "'fresh' (default) or 'fork' to branch from parent session",
 	})),
-	chainDir: Type.Optional(Type.String({ description: "Persistent directory for chain artifacts. Default: <tmpdir>/dm-chain-runs/ (auto-cleaned after 24h)" })),
+	chainDir: Type.Optional(Type.String({ description: "Persistent directory for chain artifacts. Default: a user-scoped temp directory under <tmpdir>/ (auto-cleaned after 24h)" })),
 	async: Type.Optional(Type.Boolean({ description: "Run in background (default: false, or per config)" })),
 	agentScope: Type.Optional(Type.String({ description: "Agent discovery scope: 'user', 'project', or 'both' (default: 'both'; project wins on name collisions)" })),
 	cwd: Type.Optional(Type.String()),

package/extensions/dm-subagents/settings.ts

@@ -3,12 +3,10 @@
  */
 
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentConfig } from "./agents.ts";
 import { normalizeSkillInput } from "./skills.ts";
-
-const CHAIN_RUNS_DIR = path.join(os.tmpdir(), "dm-chain-runs");
+import { CHAIN_RUNS_DIR } from "./types.ts";
 const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 // =============================================================================
@@ -100,7 +98,9 @@ export function createChainDir(runId: string, baseDir?: string): string {
 export function removeChainDir(chainDir: string): void {
 	try {
 		fs.rmSync(chainDir, { recursive: true });
-	} catch {}
+	} catch {
+		// Chain cleanup is best-effort. Runs can already have cleaned their temp dir.
+	}
 }
 
 export function cleanupOldChainDirs(): void {
@@ -110,6 +110,8 @@ export function cleanupOldChainDirs(): void {
 	try {
 		dirs = fs.readdirSync(CHAIN_RUNS_DIR);
 	} catch {
+		// Startup cleanup is best-effort. If the scoped temp root is unreadable,
+		// skip cleanup instead of failing extension startup.
 		return;
 	}
 

package/extensions/dm-subagents/subagent-runner.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
+import type { Message } from "@mariozechner/pi-ai";
 import { appendJsonl, getArtifactPaths } from "./artifacts.ts";
 import { getPiSpawnCommand } from "./pi-spawn.ts";
 import { captureSingleOutputSnapshot, resolveSingleOutput } from "./single-output.ts";
@@ -27,6 +28,7 @@ import {
 } from "./parallel-utils.ts";
 import { buildPiArgs, cleanupTempDir } from "./pi-args.ts";
 import { formatModelAttemptNote, isRetryableModelFailure } from "./model-fallback.ts";
+import { detectSubagentError, extractTextFromContent, extractToolArgsPreview, getFinalOutput } from "./utils.ts";
 import {
 	cleanupWorktrees,
 	createWorktrees,
@@ -123,32 +125,44 @@ function emptyUsage(): Usage {
 	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
 }
 
-function parseRunOutput(output: string): { usage: Usage; model?: string; error?: string } {
-	const usage = emptyUsage();
-	let model: string | undefined;
-	let error: string | undefined;
-	for (const line of output.split("\n")) {
-		if (!line.trim()) continue;
-		try {
-			const evt = JSON.parse(line) as { type?: string; message?: { role?: string; model?: string; errorMessage?: string; usage?: any } };
-			if (evt.type !== "message_end" || evt.message?.role !== "assistant") continue;
-			const msg = evt.message;
-			if (msg.model) model = msg.model;
-			if (msg.errorMessage) error = msg.errorMessage;
-			const u = msg.usage;
-			if (u) {
-				usage.turns++;
-				usage.input += u.input ?? u.inputTokens ?? 0;
-				usage.output += u.output ?? u.outputTokens ?? 0;
-				usage.cacheRead += u.cacheRead ?? 0;
-				usage.cacheWrite += u.cacheWrite ?? 0;
-				usage.cost += u.cost?.total ?? 0;
-			}
-		} catch {
-			// Ignore malformed stdout lines.
-		}
-	}
-	return { usage, model, error };
+interface ChildEventContext {
+	eventsPath: string;
+	runId: string;
+	stepIndex: number;
+	agent: string;
+}
+
+interface ChildUsage {
+	input?: number;
+	inputTokens?: number;
+	output?: number;
+	outputTokens?: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	cost?: { total?: number };
+}
+
+type ChildMessage = Message & {
+	model?: string;
+	errorMessage?: string;
+	usage?: ChildUsage;
+};
+
+interface ChildEvent {
+	type?: string;
+	message?: ChildMessage;
+	toolName?: string;
+	args?: Record<string, unknown>;
+}
+
+interface RunPiStreamingResult {
+	stderr: string;
+	exitCode: number | null;
+	messages: Message[];
+	usage: Usage;
+	model?: string;
+	error?: string;
+	finalOutput: string;
 }
 
 function runPiStreaming(
@@ -159,7 +173,8 @@ function runPiStreaming(
 	piPackageRoot?: string,
 	piArgv1?: string,
 	maxSubagentDepth?: number,
-): Promise<{ stdout: string; stderr: string; exitCode: number | null }> {
+	childEventContext?: ChildEventContext,
+): Promise<RunPiStreamingResult> {
 	return new Promise((resolve) => {
 		const outputStream = fs.createWriteStream(outputFile, { flags: "w" });
 		const spawnEnv = { ...process.env, ...(env ?? {}), ...getSubagentDepthEnv(maxSubagentDepth) };
@@ -168,29 +183,119 @@ function runPiStreaming(
 			...(piArgv1 ? { argv1: piArgv1 } : {}),
 		});
 		const child = spawn(spawnSpec.command, spawnSpec.args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: spawnEnv });
-		let stdout = "";
 		let stderr = "";
+		let stdoutBuf = "";
+		let stderrBuf = "";
+		const messages: Message[] = [];
+		const usage = emptyUsage();
+		let model: string | undefined;
+		let error: string | undefined;
+		const rawStdoutLines: string[] = [];
+
+		const writeOutputLine = (line: string) => {
+			if (!line.trim()) return;
+			outputStream.write(`${line}\n`);
+		};
+
+		const writeOutputText = (text: string) => {
+			for (const line of text.split("\n")) {
+				writeOutputLine(line);
+			}
+		};
+
+		const appendChildEvent = (event: Record<string, unknown>) => {
+			if (!childEventContext) return;
+			appendJsonl(childEventContext.eventsPath, JSON.stringify({
+				...event,
+				subagentSource: "child",
+				subagentRunId: childEventContext.runId,
+				subagentStepIndex: childEventContext.stepIndex,
+				subagentAgent: childEventContext.agent,
+				observedAt: Date.now(),
+			}));
+		};
+
+		const appendChildLine = (type: "subagent.child.stdout" | "subagent.child.stderr", line: string) => {
+			appendChildEvent({ type, line });
+		};
+
+		const processStdoutLine = (line: string) => {
+			if (!line.trim()) return;
+			let event: ChildEvent;
+			try {
+				event = JSON.parse(line) as ChildEvent;
+			} catch {
+				rawStdoutLines.push(line);
+				writeOutputLine(line);
+				appendChildLine("subagent.child.stdout", line);
+				return;
+			}
+
+			appendChildEvent(event);
+
+			if (event.type === "tool_execution_start" && event.toolName) {
+				const toolArgs = extractToolArgsPreview(event.args ?? {});
+				writeOutputLine(toolArgs ? `${event.toolName}: ${toolArgs}` : event.toolName);
+				return;
+			}
+
+			if ((event.type === "message_end" || event.type === "tool_result_end") && event.message) {
+				messages.push(event.message);
+				const text = extractTextFromContent(event.message.content);
+				if (text) writeOutputText(text);
+
+				if (event.type !== "message_end" || event.message.role !== "assistant") return;
+				if (event.message.model) model = event.message.model;
+				if (event.message.errorMessage) error = event.message.errorMessage;
+				const eventUsage = event.message.usage;
+				if (!eventUsage) return;
+				usage.turns++;
+				usage.input += eventUsage.input ?? eventUsage.inputTokens ?? 0;
+				usage.output += eventUsage.output ?? eventUsage.outputTokens ?? 0;
+				usage.cacheRead += eventUsage.cacheRead ?? 0;
+				usage.cacheWrite += eventUsage.cacheWrite ?? 0;
+				usage.cost += eventUsage.cost?.total ?? 0;
+			}
+		};
+
+		const processStderrText = (text: string) => {
+			stderr += text;
+			stderrBuf += text;
+			outputStream.write(text);
+			if (!childEventContext) return;
+			const lines = stderrBuf.split("\n");
+			stderrBuf = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				appendChildLine("subagent.child.stderr", line);
+			}
+		};
 
 		child.stdout.on("data", (chunk: Buffer) => {
 			const text = chunk.toString();
-			stdout += text;
-			outputStream.write(text);
+			stdoutBuf += text;
+			const lines = stdoutBuf.split("\n");
+			stdoutBuf = lines.pop() || "";
+			for (const line of lines) processStdoutLine(line);
 		});
 
 		child.stderr.on("data", (chunk: Buffer) => {
-			const text = chunk.toString();
-			stderr += text;
-			outputStream.write(text);
+			processStderrText(chunk.toString());
 		});
 
 		child.on("close", (exitCode) => {
+			if (stdoutBuf.trim()) processStdoutLine(stdoutBuf);
+			if (stderrBuf.trim()) appendChildLine("subagent.child.stderr", stderrBuf);
 			outputStream.end();
-			resolve({ stdout, stderr, exitCode });
+			const finalOutput = getFinalOutput(messages) || rawStdoutLines.join("\n").trim();
+			resolve({ stderr, exitCode, messages, usage, model, error, finalOutput });
 		});
 
-		child.on("error", () => {
+		child.on("error", (spawnError) => {
 			outputStream.end();
-			resolve({ stdout, stderr, exitCode: 1 });
+			const finalOutput = getFinalOutput(messages) || rawStdoutLines.join("\n").trim();
+			const spawnErrorMessage = spawnError instanceof Error ? spawnError.message : String(spawnError);
+			resolve({ stderr, exitCode: 1, messages, usage, model, error: error ?? spawnErrorMessage, finalOutput });
 		});
 	});
 }
@@ -395,14 +500,13 @@ async function runSingleStep(
 	const attemptedModels: string[] = [];
 	const modelAttempts: ModelAttempt[] = [];
 	const attemptNotes: string[] = [];
-	let finalResult:
-		| { stdout: string; stderr: string; exitCode: number | null; usage: Usage; model?: string; error?: string }
-		| undefined;
+	const eventsPath = path.join(path.dirname(ctx.outputFile), "events.jsonl");
+	let finalResult: RunPiStreamingResult | undefined;
 
 	for (let index = 0; index < candidates.length; index++) {
 		const candidate = candidates[index];
 		const { args, env, tempDir } = buildPiArgs({
-			baseArgs: ["-p"],
+			baseArgs: ["--mode", "json", "-p"],
 			task,
 			sessionEnabled,
 			sessionDir,
@@ -415,28 +519,41 @@ async function runSingleStep(
 			mcpDirectTools: step.mcpDirectTools,
 			promptFileStem: step.agent,
 		});
-		const outputFile = index === 0 ? ctx.outputFile : `${ctx.outputFile}.attempt-${index + 1}`;
-		const run = await runPiStreaming(args, step.cwd ?? ctx.cwd, outputFile, env, ctx.piPackageRoot, ctx.piArgv1, step.maxSubagentDepth);
+		const run = await runPiStreaming(
+			args,
+			step.cwd ?? ctx.cwd,
+			ctx.outputFile,
+			env,
+			ctx.piPackageRoot,
+			ctx.piArgv1,
+			step.maxSubagentDepth,
+			{ eventsPath, runId: ctx.id, stepIndex: ctx.flatIndex, agent: step.agent },
+		);
 		cleanupTempDir(tempDir);
 
-		const parsed = parseRunOutput(run.stdout);
-		const error = parsed.error || (run.exitCode !== 0 && run.stderr.trim() ? run.stderr.trim() : undefined);
+		const hiddenError = run.exitCode === 0 && !run.error ? detectSubagentError(run.messages) : null;
+		const effectiveExitCode = hiddenError?.hasError ? (hiddenError.exitCode ?? 1) : run.exitCode;
+		const error = hiddenError?.hasError
+			? hiddenError.details
+				? `${hiddenError.errorType} failed (exit ${effectiveExitCode}): ${hiddenError.details}`
+				: `${hiddenError.errorType} failed with exit code ${effectiveExitCode}`
+			: run.error || (run.exitCode !== 0 && run.stderr.trim() ? run.stderr.trim() : undefined);
 		const attempt: ModelAttempt = {
-			model: candidate ?? parsed.model ?? step.model ?? "default",
-			success: run.exitCode === 0 && !error,
-			exitCode: run.exitCode,
+			model: candidate ?? run.model ?? step.model ?? "default",
+			success: effectiveExitCode === 0 && !error,
+			exitCode: effectiveExitCode,
 			error,
-			usage: parsed.usage,
+			usage: run.usage,
 		};
 		modelAttempts.push(attempt);
 		if (candidate) attemptedModels.push(candidate);
-		finalResult = { ...run, usage: parsed.usage, model: candidate ?? parsed.model, error };
+		finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error };
 		if (attempt.success) break;
 		if (!isRetryableModelFailure(error) || index === candidates.length - 1) break;
 		attemptNotes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
 	}
 
-	const rawOutput = (finalResult?.stdout || "").trim();
+	const rawOutput = finalResult?.finalOutput ?? "";
 	const resolvedOutput = step.outputPath && finalResult?.exitCode === 0
 		? resolveSingleOutput(step.outputPath, rawOutput, outputSnapshot)
 		: { fullOutput: rawOutput };

package/extensions/dm-subagents/types.ts

@@ -309,10 +309,66 @@ export const DEFAULT_ARTIFACT_CONFIG: ArtifactConfig = {
 	cleanupDays: 7,
 };
 
+function sanitizeTempScopeSegment(value: string): string {
+	const sanitized = value
+		.trim()
+		.replace(/[^A-Za-z0-9._-]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+	return sanitized || "unknown";
+}
+
+export function resolveTempScopeId(options?: {
+	env?: NodeJS.ProcessEnv;
+	getuid?: (() => number) | undefined;
+	userInfo?: (() => { username?: string | null }) | undefined;
+	homedir?: (() => string) | undefined;
+}): string {
+	const env = options?.env ?? process.env;
+	const getuid = options && Object.hasOwn(options, "getuid")
+		? options.getuid
+		: process.getuid?.bind(process);
+	if (typeof getuid === "function") {
+		return `uid-${getuid()}`;
+	}
+
+	for (const key of ["USERNAME", "USER", "LOGNAME"] as const) {
+		const value = env[key];
+		if (value) return `user-${sanitizeTempScopeSegment(value)}`;
+	}
+
+	const userInfo = options && Object.hasOwn(options, "userInfo")
+		? options.userInfo
+		: os.userInfo;
+	try {
+		const username = userInfo?.().username;
+		if (username) return `user-${sanitizeTempScopeSegment(username)}`;
+	} catch {
+		// Fall through to home-directory-based scoping.
+	}
+
+	const homedir = env.USERPROFILE ?? env.HOME;
+	if (homedir) return `home-${sanitizeTempScopeSegment(homedir)}`;
+
+	const resolveHomedir = options && Object.hasOwn(options, "homedir")
+		? options.homedir
+		: os.homedir;
+	try {
+		const fallbackHomedir = resolveHomedir?.();
+		if (fallbackHomedir) return `home-${sanitizeTempScopeSegment(fallbackHomedir)}`;
+	} catch {
+		// Fall through to the last-resort shared scope.
+	}
+
+	return "shared";
+}
+
 export const MAX_PARALLEL = 8;
 export const MAX_CONCURRENCY = 4;
-export const RESULTS_DIR = path.join(os.tmpdir(), "dm-async-subagent-results");
-export const ASYNC_DIR = path.join(os.tmpdir(), "dm-async-subagent-runs");
+export const TEMP_ROOT_DIR = path.join(os.tmpdir(), `pi-subagents-${resolveTempScopeId()}`);
+export const RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results");
+export const ASYNC_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-runs");
+export const CHAIN_RUNS_DIR = path.join(TEMP_ROOT_DIR, "chain-runs");
+export const TEMP_ARTIFACTS_DIR = path.join(TEMP_ROOT_DIR, "artifacts");
 export const WIDGET_KEY = "subagent-async";
 export const SLASH_RESULT_TYPE = "subagent-slash-result";
 export const SLASH_SUBAGENT_REQUEST_EVENT = "subagent:slash:request";
@@ -329,6 +385,10 @@ export const DEFAULT_FORK_PREAMBLE =
 	"Your sole job is to execute the task below. Do not continue or respond to the prior conversation " +
 	"— focus exclusively on completing this task using your tools.";
 
+export function getAsyncConfigPath(suffix: string): string {
+	return path.join(TEMP_ROOT_DIR, `async-cfg-${suffix}.json`);
+}
+
 export function wrapForkTask(task: string, preamble?: string | false): string {
 	if (preamble === false) return task;
 	const effectivePreamble = preamble ?? DEFAULT_FORK_PREAMBLE;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckmind/dm-darwin-arm64",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "description": "DuckMind (dm) binary payload for darwin arm64",
   "license": "MIT",
   "os": [