@posthog/wizard 2.24.1 → 2.25.0

package/dist/{agent-interface-D1vtN6Wn.js → agent-interface-BsuUUPle.js}

@@ -1,18 +1,47 @@
 import { n as __require } from "./rolldown-runtime-B_-DWIq7.js";
-import { F as POSTHOG_FLAG_HEADER_PREFIX, X as WIZARD_VARIANTS, Y as WIZARD_USER_AGENT, Z as WIZARD_VARIANT_FLAG_KEY, a as getLogFilePath, f as skillTmpPath, o as initLogFile, p as getUI, q as WIZARD_REMARK_EVENT_NAME, r as debug, s as logToFile, u as WIZARD_YARA_REPORT_FILE, z as POSTHOG_PROPERTY_HEADER_PREFIX } from "./debug-DxA_f5QT.js";
-import { t as analytics } from "./analytics-CUr82BDl.js";
-import { i as getLlmGatewayUrlFromHost } from "./urls-C8aJWvgh.js";
+import { F as POSTHOG_FLAG_HEADER_PREFIX, J as WIZARD_REMARK_EVENT_NAME, K as WIZARD_ORCHESTRATOR_FLAG_KEY, Q as WIZARD_VARIANT_FLAG_KEY, X as WIZARD_USER_AGENT, Z as WIZARD_VARIANTS, a as getLogFilePath, f as skillTmpPath, o as initLogFile, p as getUI, r as debug, s as logToFile, u as WIZARD_YARA_REPORT_FILE, z as POSTHOG_PROPERTY_HEADER_PREFIX } from "./debug-BwC7UkGH.js";
+import { t as analytics } from "./analytics-CDOujOSQ.js";
+import { i as getLlmGatewayUrlFromHost } from "./urls-vkJ5c0ix.js";
 import { n as ADDITIONAL_FEATURE_PROMPTS } from "./wizard-session-G3VWD6hv.js";
-import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-C6gRLxUE.js";
+import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-CLGgMAEe.js";
 import { createRequire } from "node:module";
 import * as fs$1 from "fs";
 import fs from "fs";
+import * as path$1 from "path";
 import path from "path";
 import { z } from "zod";
 import fg from "fast-glob";
 import { execFileSync } from "child_process";
 import { randomUUID } from "crypto";
 import * as os from "os";
+//#region src/utils/atomic-ledger.ts
+/**
+* Small shared primitives for on-disk ledgers: an atomic JSON writer and a
+* single-chain async mutex. Used by the audit tools and by the orchestrator
+* queue. Lifted here so both share one implementation.
+*/
+/**
+* Atomically write JSON: write to a `.tmp` file then rename over the target. The
+* rename bumps the file's mtime in one step, which is what a file watcher polls.
+*/
+function writeJsonAtomic(targetPath, data) {
+	const tmpPath = `${targetPath}.tmp`;
+	fs$1.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf8");
+	fs$1.renameSync(tmpPath, targetPath);
+}
+/**
+* A single async mutex. Serializes read-modify-write cycles so concurrent callers
+* (parallel task agents, audit tool calls) never interleave a mutation.
+*/
+function makeMutex() {
+	let chain = Promise.resolve();
+	return async function run(fn) {
+		const next = chain.then(() => fn());
+		chain = next.catch(() => void 0);
+		return next;
+	};
+}
+//#endregion
 //#region src/lib/programs/audit/types.ts
 /** Single source of truth for status glyph + color across audit views. */
 const AUDIT_SEVERITY_STYLE = {
@@ -103,6 +132,336 @@ function createSecretVault() {
 	};
 }
 //#endregion
+//#region src/lib/programs/orchestrator/queue.ts
+/**
+* The orchestrator task queue.
+*
+* In memory, synchronous, single-owner: one Node process drives the run, so
+* there is no locking. The queue imposes no execution policy — `nextRunnable`
+* returns every pending task whose dependencies are satisfied, and how many of
+* those run at once is decided by the task graph, not the queue.
+*
+* Every transition rewrites `<installDir>/.posthog-wizard-cache/queue.json`, a
+* small file holding the whole queue, handoffs included. It is the run's log
+* and the report's source. The whole cache folder is run-scoped and wiped when
+* the run ends.
+*/
+const TaskStatus = {
+	Pending: "pending",
+	Running: "running",
+	Done: "done",
+	Skipped: "skipped",
+	Failed: "failed"
+};
+const QUEUE_DIR_NAME = ".posthog-wizard-cache";
+const DEFAULT_MAX_ATTEMPTS = 2;
+function nowIso() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/** Dropped in the cache folder so an orphaned copy explains itself. */
+const DELETE_ME_FILE = ".DELETE-ME.md";
+const DELETE_ME_BODY = `# Safe to delete
+
+This folder contains run artifacts from the PostHog Wizard. This should have
+been deleted if the Wizard has finished running. If this wasn't deleted for
+some reason, you can safely delete the entire \`${QUEUE_DIR_NAME}/\` folder.
+`;
+var QueueStore = class {
+	tasks = [];
+	onTransition;
+	runId;
+	queuePath;
+	constructor(installDir, runId, opts) {
+		this.onTransition = opts?.onTransition;
+		this.runId = runId;
+		const dir = path$1.join(installDir, QUEUE_DIR_NAME);
+		this.queuePath = path$1.join(dir, "queue.json");
+		fs$1.mkdirSync(dir, { recursive: true });
+		fs$1.writeFileSync(path$1.join(dir, DELETE_ME_FILE), DELETE_ME_BODY);
+	}
+	list() {
+		return this.tasks;
+	}
+	get(id) {
+		return this.tasks.find((t) => t.id === id);
+	}
+	/**
+	* Every pending task whose dependencies are all satisfied (`done` or
+	* `skipped`). A skipped dependency does not block downstream work.
+	*/
+	nextRunnable() {
+		const doneIds = new Set(this.tasks.filter((t) => t.status === TaskStatus.Done || t.status === TaskStatus.Skipped).map((t) => t.id));
+		return this.tasks.filter((t) => t.status === TaskStatus.Pending && t.dependsOn.every((d) => doneIds.has(d)));
+	}
+	/**
+	* True when no task is running and none can be started. Either everything
+	* is terminal, or the only pending tasks are blocked by a failed dependency.
+	*/
+	isDrained() {
+		if (this.tasks.some((t) => t.status === TaskStatus.Running)) return false;
+		return this.nextRunnable().length === 0;
+	}
+	summary() {
+		const counts = {
+			[TaskStatus.Pending]: 0,
+			[TaskStatus.Running]: 0,
+			[TaskStatus.Done]: 0,
+			[TaskStatus.Skipped]: 0,
+			[TaskStatus.Failed]: 0
+		};
+		for (const t of this.tasks) counts[t.status] += 1;
+		return {
+			...counts,
+			total: this.tasks.length
+		};
+	}
+	readHandoff(id) {
+		return this.get(id)?.handoff ?? null;
+	}
+	/** Handoffs of completed tasks of a given type, oldest first. */
+	readHandoffsByType(type) {
+		return this.tasks.filter((t) => t.type === type && t.handoff).map((t) => t.handoff);
+	}
+	enqueue(input) {
+		const task = {
+			id: randomUUID(),
+			type: input.type,
+			label: input.label,
+			status: TaskStatus.Pending,
+			dependsOn: input.dependsOn ?? [],
+			inputs: input.inputs ?? {},
+			model: input.model,
+			attempts: 0,
+			maxAttempts: input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+			enqueuedBy: input.enqueuedBy ?? "orchestrator",
+			createdAt: nowIso()
+		};
+		this.tasks.push(task);
+		this.reflect();
+		this.notify("enqueue", task);
+		return task;
+	}
+	start(id) {
+		const t = this.require(id);
+		t.status = TaskStatus.Running;
+		t.startedAt = nowIso();
+		t.attempts += 1;
+		this.reflect();
+		this.notify("start", t);
+		return t;
+	}
+	complete(id, handoff) {
+		return this.finish(id, TaskStatus.Done, handoff);
+	}
+	/** Terminal: the agent could not do the task. Not done, not failed. */
+	skip(id, handoff) {
+		return this.finish(id, TaskStatus.Skipped, handoff);
+	}
+	fail(id, error, handoff) {
+		const t = this.require(id);
+		t.error = error;
+		return this.finish(id, TaskStatus.Failed, handoff);
+	}
+	/** Put a failed/running task back to pending for a retry within the run. */
+	requeue(id) {
+		const t = this.require(id);
+		t.status = TaskStatus.Pending;
+		t.startedAt = void 0;
+		t.finishedAt = void 0;
+		this.reflect();
+		this.notify("requeue", t);
+		return t;
+	}
+	finish(id, status, handoff) {
+		const t = this.require(id);
+		if (handoff) t.handoff = handoff;
+		t.status = status;
+		t.finishedAt = nowIso();
+		this.reflect();
+		this.notify(status === TaskStatus.Done ? "complete" : status === TaskStatus.Skipped ? "skip" : "fail", t);
+		return t;
+	}
+	reflect() {
+		const file = {
+			version: 1,
+			runId: this.runId,
+			tasks: this.tasks
+		};
+		writeJsonAtomic(this.queuePath, file);
+	}
+	notify(event, task) {
+		try {
+			this.onTransition?.(event, task);
+		} catch (error) {
+			analytics.captureException(error instanceof Error ? error : new Error(String(error)), {
+				step: "orchestrator_queue_listener",
+				event
+			});
+		}
+	}
+	require(id) {
+		const t = this.get(id);
+		if (!t) throw new Error(`No task ${id} in the queue`);
+		return t;
+	}
+};
+//#endregion
+//#region src/lib/programs/orchestrator/queue-tools.ts
+/**
+* Orchestrator MCP tools, registered into the existing `wizard-tools` server when
+* a queue is present. They let the orchestrator agent and task agents grow the
+* queue, report completion with a structured handoff, and read prior handoffs.
+*
+* The guard logic and the apply functions are plain, exported, and unit-tested.
+* `buildOrchestratorTools` wraps them in the SDK `tool()` shape.
+*/
+function stableStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+}
+function dedupKey(type, inputs) {
+	return `${type}::${stableStringify(inputs)}`;
+}
+/**
+* A backstop on total queue size. Tasks can enqueue tasks, so a misbehaving
+* type could grow the queue without bound. Keeping the graph small is the job
+* of good agent and skill design, not this number — it only stops a runaway.
+* The real flow is ~9 tasks, so this sits well clear of it.
+*/
+const MAX_QUEUE_TASKS = 30;
+/**
+* Validate an enqueue. Structural checks only — a real type, real dependencies,
+* not a literal duplicate, and not past the runaway backstop. How much runs,
+* and in what shape, is the task graph's business, not a knob's.
+*/
+function checkEnqueueGuards(ctx, args) {
+	const tasks = ctx.store.list();
+	if (tasks.length >= MAX_QUEUE_TASKS) return {
+		ok: false,
+		guard: "queue-full",
+		message: `The queue already holds ${tasks.length} tasks (cap ${MAX_QUEUE_TASKS}). Refine the existing tasks rather than adding more.`
+	};
+	if (!ctx.validTypes.includes(args.type)) return {
+		ok: false,
+		guard: "unknown-type",
+		message: `Unknown task type "${args.type}". Valid types: ${ctx.validTypes.join(", ")}.`
+	};
+	for (const dep of args.dependsOn ?? []) if (!ctx.store.get(dep)) return {
+		ok: false,
+		guard: "unknown-dep",
+		message: `Dependency "${dep}" is not a known task id.`
+	};
+	const key = dedupKey(args.type, args.inputs ?? {});
+	if (tasks.some((t) => t.status !== TaskStatus.Failed && dedupKey(t.type, t.inputs) === key)) return {
+		ok: false,
+		guard: "dedup",
+		message: `A "${args.type}" task with these inputs already exists.`
+	};
+	return { ok: true };
+}
+function applyEnqueue(ctx, args) {
+	const guard = checkEnqueueGuards(ctx, args);
+	if (!guard.ok) return guard;
+	return {
+		ok: true,
+		task: ctx.store.enqueue({
+			type: args.type,
+			label: args.label,
+			inputs: args.inputs ?? {},
+			dependsOn: args.dependsOn ?? [],
+			model: args.model,
+			enqueuedBy: ctx.currentTaskId ?? "orchestrator"
+		})
+	};
+}
+function applyComplete(ctx, args) {
+	const id = ctx.currentTaskId;
+	if (!id) return {
+		ok: false,
+		message: "complete_task can only be called by a running task agent."
+	};
+	if (args.status === TaskStatus.Failed) ctx.store.fail(id, {
+		type: "self-reported",
+		message: args.handoff.forNextAgent
+	}, args.handoff);
+	else if (args.status === TaskStatus.Skipped) ctx.store.skip(id, args.handoff);
+	else ctx.store.complete(id, args.handoff);
+	return { ok: true };
+}
+function applyReadHandoffs(ctx, args) {
+	if (args.taskId) {
+		const h = ctx.store.readHandoff(args.taskId);
+		return h ? [h] : [];
+	}
+	if (args.type) return ctx.store.readHandoffsByType(args.type);
+	const currentId = ctx.currentTaskId;
+	const current = currentId ? ctx.store.get(currentId) : void 0;
+	if (!current) return [];
+	return current.dependsOn.map((depId) => ctx.store.readHandoff(depId)).filter((h) => h !== null);
+}
+const HANDOFF_SHAPE = {
+	goals: z.string().describe("What this task was asked to achieve."),
+	did: z.string().describe("What you actually did."),
+	forNextAgent: z.string().describe("What the next agent should know."),
+	filesTouched: z.array(z.string()).optional(),
+	conflict: z.string().optional().describe("A one-line summary of any conflict you could not cleanly resolve (e.g. a dependency or build conflict). Put full detail in your work; this line is surfaced to the user.")
+};
+function textResult(text, isError = false) {
+	return {
+		isError,
+		content: [{
+			type: "text",
+			text
+		}]
+	};
+}
+/**
+* Build the orchestrator tools in the SDK `tool()` shape. Called from
+* createWizardToolsServer only when a queue context is present.
+*/
+function buildOrchestratorTools(tool, ctx) {
+	return [
+		tool("enqueue_task", "Add a task to the orchestrator queue. Use it to seed work and to enqueue follow-up work you discover. Keep tasks small and discrete.", {
+			type: z.string().describe(`The task type. One of: ${ctx.validTypes.join(", ")}.`),
+			label: z.string().optional().describe("A short label for the UI — the action in a few words (e.g. \"Add the PostHog SDK\", \"Initialize PostHog\"). Leave out file names, class names, and other specifics."),
+			inputs: z.record(z.unknown()).optional(),
+			dependsOn: z.array(z.string()).optional().describe("Task ids that must be done before this task runs."),
+			model: z.string().optional(),
+			reason: z.string().describe("One line on why this task is needed.")
+		}, ((args) => {
+			const res = applyEnqueue(ctx, args);
+			if (!res.ok) {
+				analytics.wizardCapture("orchestrator guard tripped", {
+					guard: res.guard,
+					type: args.type
+				});
+				return textResult(res.message, true);
+			}
+			return textResult(JSON.stringify({ id: res.task.id }));
+		})),
+		tool("complete_task", "Report the outcome of your task. Always call this exactly once when you finish, with a structured handoff for the next agent. Use status 'skipped' when the task does not apply to this project and you cannot do it (say why in the handoff) — not 'done'.", {
+			status: z.enum([
+				"done",
+				"failed",
+				"skipped"
+			]),
+			handoff: z.object(HANDOFF_SHAPE)
+		}, ((args) => {
+			const res = applyComplete(ctx, args);
+			if (!res.ok) return textResult(res.message, true);
+			return textResult("ok");
+		})),
+		tool("read_handoffs", "Read structured handoffs from earlier tasks. With no argument, returns the handoffs of your dependencies.", {
+			type: z.string().optional(),
+			taskId: z.string().optional()
+		}, ((args) => {
+			const handoffs = applyReadHandoffs(ctx, args);
+			return textResult(JSON.stringify(handoffs, null, 2));
+		}))
+	];
+}
+//#endregion
 //#region src/lib/wizard-tools.ts
 /**
 * Unified in-process MCP server for the PostHog wizard.
@@ -292,14 +651,9 @@ const auditUpdateSchema = z.object({
 	file: z.string().optional(),
 	details: z.string().optional()
 });
-/**
-* Atomically write JSON: write to .tmp then rename. The rename is what bumps
-* the file's mtime, which is what the UI's file watcher polls on.
-*/
+/** Atomically write the audit ledger. Thin typed wrapper over writeJsonAtomic. */
 function writeLedgerAtomic(targetPath, checks) {
-	const tmpPath = `${targetPath}.tmp`;
-	fs.writeFileSync(tmpPath, JSON.stringify(checks, null, 2), "utf8");
-	fs.renameSync(tmpPath, targetPath);
+	writeJsonAtomic(targetPath, checks);
 }
 /**
 * Apply a batch of patches to the ledger by id. Returns the new array and the
@@ -375,25 +729,13 @@ function appendAuditChecksToLedger(targetPath, additions) {
 		added: additions.length
 	};
 }
-/**
-* Single async mutex shared by audit tools — guarantees a read-modify-write
-* cycle on the ledger is atomic across concurrent tool calls (e.g. future subagents).
-*/
-function makeMutex() {
-	let chain = Promise.resolve();
-	return async function run(fn) {
-		const next = chain.then(() => fn());
-		chain = next.catch(() => void 0);
-		return next;
-	};
-}
 const SERVER_NAME = "wizard-tools";
 /**
 * Create the unified in-process MCP server with all wizard tools.
 * Must be called asynchronously because the SDK is an ESM module loaded via dynamic import.
 */
 async function createWizardToolsServer(options) {
-	const { workingDirectory, detectPackageManager, skillsBaseUrl, askBridge, askMaxQuestions = 10, secretVault = createSecretVault() } = options;
+	const { workingDirectory, detectPackageManager, skillsBaseUrl, askBridge, askMaxQuestions = 10, secretVault = createSecretVault(), orchestrator } = options;
 	const { tool, createSdkMcpServer } = await getSDKModule$1();
 	let askCallCount = 0;
 	let cachedSkillMenu = {};
@@ -673,7 +1015,8 @@ async function createWizardToolsServer(options) {
 						isError: true
 					};
 				}
-			})
+			}),
+			...orchestrator ? buildOrchestratorTools(tool, orchestrator) : []
 		]
 	});
 }
@@ -687,7 +1030,10 @@ const WIZARD_TOOL_NAMES = {
 	auditSeedChecks: `mcp__${SERVER_NAME}__audit_seed_checks`,
 	auditAddChecks: `mcp__${SERVER_NAME}__audit_add_checks`,
 	auditResolveChecks: `mcp__${SERVER_NAME}__audit_resolve_checks`,
-	wizardAsk: `mcp__${SERVER_NAME}__wizard_ask`
+	wizardAsk: `mcp__${SERVER_NAME}__wizard_ask`,
+	enqueueTask: `mcp__${SERVER_NAME}__enqueue_task`,
+	completeTask: `mcp__${SERVER_NAME}__complete_task`,
+	readHandoffs: `mcp__${SERVER_NAME}__read_handoffs`
 };
 //#endregion
 //#region src/utils/custom-headers.ts
@@ -1761,7 +2107,7 @@ function buildAuthErrorContext(workingDirectory, gatewayUrl, homeDir = os.homedi
 *   Phase 2 — collect remark (once): block with remark prompt
 *   Phase 3 — allow stop: return {}
 */
-function createStopHook(featureQueue, signals) {
+function createStopHook(featureQueue, signals, requestRemark = true) {
 	let featureIndex = 0;
 	let remarkRequested = false;
 	return (input) => {
@@ -1784,7 +2130,7 @@ function createStopHook(featureQueue, signals) {
 				reason: prompt
 			};
 		}
-		if (!remarkRequested) {
+		if (requestRemark && !remarkRequested) {
 			remarkRequested = true;
 			logToFile("Stop hook: requesting reflection");
 			return {
@@ -1805,6 +2151,14 @@ function buildWizardMetadata(flags = {}) {
 	return { ...(variantKey && WIZARD_VARIANTS[variantKey]) ?? WIZARD_VARIANTS["base"] };
 }
 /**
+* Whether this run uses the experimental task-queue orchestrator. Gated by the
+* boolean `wizard-orchestrator` feature flag, targeted to the user in the wizard's
+* analytics project.
+*/
+function isOrchestratorEnabled(flags = {}) {
+	return flags[WIZARD_ORCHESTRATOR_FLAG_KEY] === "true";
+}
+/**
 * Build env for the SDK subprocess: process.env plus ANTHROPIC_CUSTOM_HEADERS, which always
 * includes `x-posthog-use-bedrock-fallback: true` so the LLM gateway falls back to Bedrock on
 * Anthropic 5xx, plus any wizard metadata/flags.
@@ -2008,7 +2362,6 @@ async function initializeAgent(config, options) {
 	initLogFile();
 	logToFile("Agent initialization starting");
 	logToFile("Install directory:", options.installDir);
-	getUI().log.step("Initializing Claude agent...");
 	try {
 		const gatewayUrl = getLlmGatewayUrlFromHost(config.posthogApiHost);
 		process.env.ANTHROPIC_BASE_URL = gatewayUrl;
@@ -2038,7 +2391,8 @@ async function initializeAgent(config, options) {
 			detectPackageManager: config.detectPackageManager,
 			skillsBaseUrl: config.skillsBaseUrl,
 			askBridge: config.askBridge,
-			askMaxQuestions: config.askMaxQuestions
+			askMaxQuestions: config.askMaxQuestions,
+			orchestrator: config.orchestrator
 		});
 		const agentRunConfig = {
 			workingDirectory: config.workingDirectory,
@@ -2062,8 +2416,6 @@ async function initializeAgent(config, options) {
 			gatewayUrl,
 			apiKeyPresent: !!config.posthogApiKey
 		});
-		getUI().log.step(`Verbose logs: ${getLogFilePath()}`);
-		getUI().log.success("Agent initialized. Let's get cooking!");
 		return agentRunConfig;
 	} catch (error) {
 		getUI().log.error(`Failed to initialize agent: ${error.message}`);
@@ -2130,9 +2482,18 @@ async function runAgent(agentConfig, prompt, options, spinner, config, middlewar
 		} else logToFile(`Agent run completed in ${durationSeconds}s`);
 		const remark = signals.remark();
 		if (remark) analytics.capture(WIZARD_REMARK_EVENT_NAME, { remark });
+		const usage = lastResultMessage?.usage;
 		analytics.wizardCapture("agent completed", {
 			duration_ms: durationMs,
-			duration_seconds: durationSeconds
+			duration_seconds: durationSeconds,
+			model: agentConfig.model,
+			num_turns: lastResultMessage?.num_turns,
+			total_cost_usd: lastResultMessage?.total_cost_usd,
+			input_tokens: usage?.input_tokens,
+			output_tokens: usage?.output_tokens,
+			cache_creation_input_tokens: usage?.cache_creation_input_tokens,
+			cache_read_input_tokens: usage?.cache_read_input_tokens,
+			...config?.analyticsProperties
 		});
 		try {
 			middleware?.finalize(lastResultMessage, durationMs);
@@ -2239,7 +2600,7 @@ async function runAgent(agentConfig, prompt, options, spinner, config, middlewar
 					PreToolUse: createPreToolUseYaraHooks(),
 					PostToolUse: createPostToolUseYaraHooks(),
 					Stop: [{
-						hooks: [createStopHook(config?.additionalFeatureQueue ?? [], signals)],
+						hooks: [createStopHook(config?.additionalFeatureQueue ?? [], signals, config?.requestRemark ?? true)],
 						timeout: 30
 					}]
 				}
@@ -2263,7 +2624,7 @@ async function runAgent(agentConfig, prompt, options, spinner, config, middlewar
 				}
 				loggedInitialContext = true;
 			}
-			handleSDKMessage(message, options, spinner, signals, receivedSuccessResult, tasks);
+			handleSDKMessage(message, options, spinner, signals, receivedSuccessResult, tasks, isOrchestratorEnabled(agentConfig.wizardFlags ?? {}));
 			if (abortCases.length > 0 && !abortReason && message.type === "assistant") {
 				const content = message.message?.content;
 				if (Array.isArray(content)) {
@@ -2390,7 +2751,9 @@ async function runAgent(agentConfig, prompt, options, spinner, config, middlewar
 			const durationMs = Date.now() - startTime;
 			analytics.wizardCapture("agent aborted", {
 				duration_ms: durationMs,
-				duration_seconds: Math.round(durationMs / 1e3)
+				duration_seconds: Math.round(durationMs / 1e3),
+				model: agentConfig.model,
+				...config?.analyticsProperties
 			});
 		}
 	}
@@ -2500,14 +2863,14 @@ function extractTaskIdFromResult(content) {
 		}
 	}
 }
-function handleSDKMessage(message, options, spinner, signals, receivedSuccessResult = false, tasks) {
+function handleSDKMessage(message, options, spinner, signals, receivedSuccessResult = false, tasks, suppressTaskRender = false) {
 	const STATUS_RANK = {
 		completed: 0,
 		in_progress: 1
 	};
 	const rank = (status) => STATUS_RANK[status] ?? 2;
 	const syncTasks = () => {
-		if (!tasks) return;
+		if (!tasks || suppressTaskRender) return;
 		const sorted = Array.from(tasks.values()).sort((a, b) => rank(a.status) - rank(b.status));
 		getUI().syncTodos(sorted);
 	};
@@ -2586,6 +2949,6 @@ function handleSDKMessage(message, options, spinner, signals, receivedSuccessRes
 	}
 }
 //#endregion
-export { AUDIT_CHECKS_KEY as _, backupAndFixClaudeSettings as a, coerceAuditChecks as b, restoreClaudeSettings as c, writeScanReport as d, WIZARD_TOOL_NAMES as f, AUDIT_CHECKS_FILE as g, installSkillById as h, runAgent as i, AgentSignals as l, fetchSkillMenu as m, buildWizardMetadata as n, checkAllSettingsConflicts as o, downloadSkill as p, initializeAgent as r, recoverOrphanedSettingsBackups as s, buildAgentEnv as t, formatScanReport as u, AUDIT_REPORT_FILE as v, getAuditChecks as x, AUDIT_SEVERITY_STYLE as y };
+export { AUDIT_SEVERITY_STYLE as C, AUDIT_REPORT_FILE as S, getAuditChecks as T, QUEUE_DIR_NAME as _, runAgent as a, AUDIT_CHECKS_FILE as b, recoverOrphanedSettingsBackups as c, formatScanReport as d, writeScanReport as f, installSkillById as g, fetchSkillMenu as h, isOrchestratorEnabled as i, restoreClaudeSettings as l, downloadSkill as m, buildWizardMetadata as n, backupAndFixClaudeSettings as o, WIZARD_TOOL_NAMES as p, initializeAgent as r, checkAllSettingsConflicts as s, buildAgentEnv as t, AgentSignals as u, QueueStore as v, coerceAuditChecks as w, AUDIT_CHECKS_KEY as x, TaskStatus as y };
 
-//# sourceMappingURL=agent-interface-D1vtN6Wn.js.map
+//# sourceMappingURL=agent-interface-BsuUUPle.js.map