pi-squad 0.17.1 → 0.18.0

package/src/runtime.ts

@@ -0,0 +1,196 @@
+import { completeSimple, type Message, type TextContent } from "@earendil-works/pi-ai/compat";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { ADVISOR_SYSTEM_PROMPT, buildAdvisorConsultText, type AdvisorConsultInput } from "./advisor.js";
+import { logError, debug } from "./logger.js";
+import type { Squad, SquadAgentEntry, SuspendedStallAttention, Task } from "./types.js";
+import { THINKING_LEVELS } from "./types.js";
+import type { Scheduler, SchedulerSpawnContext } from "./scheduler.js";
+import type { SquadWidgetControls, SquadWidgetState } from "./panel/squad-widget.js";
+import * as store from "./store.js";
+
+export interface InlineSquadStart {
+	goal: string;
+	agents?: Record<string, SquadAgentEntry>;
+	tasks?: Array<{ id: string; title: string; description?: string; agent: string; depends?: string[]; inheritContext?: boolean }>;
+	config?: { maxConcurrency?: number; autoUnblock?: boolean; maxRetries?: number };
+}
+
+/** All mutable extension state has one owner. */
+export const runtime = {
+	squadEnabled: true,
+	schedulers: new Map<string, Scheduler>(),
+	activeSquadId: null as string | null,
+	overlayOpen: false,
+	closeOverlay: null as (() => void) | null,
+	uiCtx: null as ExtensionContext | null,
+	widgetState: { squadId: null, enabled: true } as SquadWidgetState,
+	widgetControls: null as SquadWidgetControls | null,
+	getMainSessionThinking: (() => undefined) as () => string | undefined,
+};
+
+export const DISABLED_GUIDANCE = "pi-squad is disabled. Run /squad enable, then retry this operation; no squad work was changed.";
+export const disabledToolResult = () => ({
+	content: [{ type: "text" as const, text: DISABLED_GUIDANCE }],
+	details: undefined,
+});
+
+/** Keep main-session focus, compact widget, and detail panel targeting identical. */
+export function focusSquad(squadId: string | null): void {
+	runtime.activeSquadId = squadId;
+	runtime.widgetState.squadId = squadId;
+	if (squadId && runtime.squadEnabled) runtime.widgetState.enabled = true;
+	runtime.widgetControls?.refreshNow();
+}
+
+/** Format completion against active work while retaining cancelled history. */
+export function formatTaskProgress(tasks: Task[]): string {
+	const done = tasks.filter((task) => task.status === "done").length;
+	const cancelled = tasks.filter((task) => task.status === "cancelled").length;
+	const active = tasks.length - cancelled;
+	return cancelled > 0
+		? `${done}/${active} active tasks done · ${cancelled} cancelled · ${tasks.length} total`
+		: `${done}/${tasks.length} tasks done`;
+}
+
+function resolveContextWindow(model: string | null): number | undefined {
+	const ctx = runtime.uiCtx;
+	if (!ctx) return undefined;
+	try {
+		if (!model) return ctx.model?.contextWindow;
+		let clean = model;
+		const lastColon = model.lastIndexOf(":");
+		if (lastColon > 0 && (THINKING_LEVELS as readonly string[]).includes(model.slice(lastColon + 1))) {
+			clean = model.slice(0, lastColon);
+		}
+		const all = ctx.modelRegistry.getAll();
+		const slash = clean.indexOf("/");
+		if (slash > 0) {
+			const provider = clean.slice(0, slash);
+			const id = clean.slice(slash + 1);
+			const m = all.find((x) => x.provider === provider && x.id === id);
+			if (m) return m.contextWindow;
+		}
+		return all.find((x) => x.id === clean)?.contextWindow;
+	} catch {
+		return undefined;
+	}
+}
+
+export function getMainSessionModel(): string | undefined {
+	try {
+		const m = runtime.uiCtx?.model;
+		return m ? `${m.provider}/${m.id}` : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function resolveSquadDefaults(): { model?: string; thinking?: string } {
+	const settings = store.loadSquadSettings();
+	let model: string | undefined;
+	if (settings.defaultModel === "main") model = getMainSessionModel();
+	else if (settings.defaultModel !== "pi-default") model = settings.defaultModel;
+	let thinking: string | undefined;
+	if (settings.defaultThinking === "main") thinking = runtime.getMainSessionThinking();
+	else if (settings.defaultThinking !== "pi-default") thinking = settings.defaultThinking;
+	return { model, thinking };
+}
+
+async function consultAdvisor(input: AdvisorConsultInput): Promise<string | null> {
+	const ctx = runtime.uiCtx;
+	if (!ctx) return null;
+	const settings = store.loadSquadSettings();
+	if (!settings.advisor.enabled) return null;
+
+	try {
+		let model = settings.advisor.model === "main" ? ctx.model : undefined;
+		if (!model && settings.advisor.model !== "main") {
+			const ref = settings.advisor.model;
+			const slash = ref.indexOf("/");
+			if (slash > 0) model = ctx.modelRegistry.find(ref.slice(0, slash), ref.slice(slash + 1));
+		}
+		if (!model) {
+			logError("squad-advisor", `advisor model "${settings.advisor.model}" not resolvable`);
+			return null;
+		}
+
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (!auth.ok || !auth.apiKey) {
+			logError("squad-advisor", `no auth for advisor model ${model.provider}/${model.id}`);
+			return null;
+		}
+
+		const userMessage: Message = {
+			role: "user",
+			content: [{ type: "text", text: buildAdvisorConsultText(input) }],
+			timestamp: Date.now(),
+		} as Message;
+
+		const response = await completeSimple(
+			model,
+			{ systemPrompt: ADVISOR_SYSTEM_PROMPT, messages: [userMessage] },
+			{
+				apiKey: auth.apiKey,
+				headers: auth.headers,
+				maxTokens: settings.advisor.maxTokens,
+				reasoning: settings.advisor.reasoning as never,
+			},
+		);
+
+		const text = response.content
+			.filter((b): b is TextContent => b.type === "text")
+			.map((b) => b.text)
+			.join("\n")
+			.trim();
+		debug("squad-advisor", `consulted ${model.provider}/${model.id} for ${input.taskId}: in=${response.usage?.input ?? 0} out=${response.usage?.output ?? 0}`);
+		return text || null;
+	} catch (error) {
+		logError("squad-advisor", `consult failed: ${(error as Error).message}`);
+		return null;
+	}
+}
+
+export const schedulerSpawnContext: SchedulerSpawnContext = {
+	resolveContextWindow,
+	getDefaultModelThinking: resolveSquadDefaults,
+	consultAdvisor,
+};
+
+export function getActiveScheduler(): Scheduler | null {
+	if (!runtime.activeSquadId) return null;
+	return runtime.schedulers.get(runtime.activeSquadId) || null;
+}
+
+export function repairFocusAfterCancellation(cancelledId: string): void {
+	const nextFocus = runtime.activeSquadId === cancelledId || (runtime.activeSquadId !== null && !store.loadSquad(runtime.activeSquadId))
+		? null
+		: runtime.activeSquadId;
+	focusSquad(nextFocus);
+}
+
+export function activeSuspendedAttentionForProject(cwd: string): Array<{ squadId: string; attention: SuspendedStallAttention }> {
+	return store.listSquadsForProject(cwd)
+		.filter((squad) => Boolean(squad.suspendedStallAttention))
+		.map((squad) => ({ squadId: squad.id, attention: squad.suspendedStallAttention! }));
+}
+
+export function isResumeCandidate(squad: Squad): boolean {
+	return squad.status === "paused" || squad.status === "failed" ||
+		(squad.status === "review" && squad.review?.status === "failed") ||
+		store.loadAllTasks(squad.id).some((task) => task.status === "suspended" || task.status === "failed");
+}
+
+export function resolveResumeSquad(cwd: string, explicitId?: string): Squad | null {
+	if (explicitId) return store.loadSquad(explicitId);
+	if (runtime.activeSquadId) {
+		const active = store.loadSquad(runtime.activeSquadId);
+		if (active?.cwd === cwd && isResumeCandidate(active)) return active;
+	}
+	return store.listSquadsForProject(cwd)
+		.filter(isResumeCandidate)
+		.sort((a, b) => b.created.localeCompare(a.created))[0] ?? null;
+}
+
+export function forceWidgetUpdate(): void {
+	runtime.widgetControls?.requestUpdate();
+}

package/src/scheduler-runtime.ts

@@ -0,0 +1,117 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { logError } from "./logger.js";
+import { buildCompletionSummary, buildFailureSummary } from "./report.js";
+import { buildOrchestratorReviewGate } from "./review.js";
+import { Scheduler, formatSuspendedStallAttention, type SchedulerEvent } from "./scheduler.js";
+import * as store from "./store.js";
+import type { SuspendedStallAttention } from "./types.js";
+import { forceWidgetUpdate, formatTaskProgress, focusSquad, repairFocusAfterCancellation, runtime, schedulerSpawnContext } from "./runtime.js";
+
+/** Wire one scheduler to durable main-session notifications. */
+export function wireSchedulerEvents(pi: ExtensionAPI, scheduler: Scheduler, squadId: string): void {
+	scheduler.onEvent((event: SchedulerEvent) => {
+		// Durable scheduler state remains authoritative, but disabled mode suppresses
+		// late operational UI, acknowledgements, focus, and ordinary notifications.
+		if (!runtime.squadEnabled) return;
+		forceWidgetUpdate();
+		switch (event.type) {
+			case "squad_review_required": {
+				const tasks = store.loadAllTasks(squadId);
+				const squad = store.loadSquad(squadId);
+				const summary = buildCompletionSummary(tasks, squad?.cwd);
+				const totalCost = tasks.reduce((sum, task) => sum + task.usage.cost, 0);
+				scheduler.updateContext();
+				if (!squad) break;
+				pi.sendMessage({
+					customType: "squad-review-required",
+					content: `[squad] TASK EXECUTION FINISHED for "${squadId}" — WORK IS UNTRUSTED AND NOT YET ACCEPTED.\n\n` +
+						`Squad claims (review inputs only):\n${summary}\n\n` +
+						`Total cost: $${totalCost.toFixed(4)}\n\n` +
+						buildOrchestratorReviewGate(squad, tasks),
+					display: true,
+				}, { triggerTurn: true, deliverAs: "followUp" });
+				// Keep the settled scheduler addressable. A later exact-task message
+				// can reopen the task immediately on its bound durable Pi session.
+				break;
+			}
+			case "suspended_stall": {
+				try {
+					const attention = event.data as SuspendedStallAttention;
+					pi.sendMessage({
+						customType: `squad-suspended-stall:${squadId}:${attention.fingerprint}`,
+						content: formatSuspendedStallAttention(squadId, attention),
+						display: true,
+					}, { triggerTurn: true, deliverAs: "followUp" });
+					scheduler.acknowledgeSuspendedStall(attention.fingerprint);
+				} catch (error) {
+					logError("squad-scheduler", `suspended-stall delivery failed for ${squadId}: ${(error as Error).message}`);
+				}
+				break;
+			}
+			case "squad_failed": {
+				const tasks = store.loadAllTasks(squadId);
+				const failed = tasks.filter((task) => task.status === "failed");
+				pi.sendMessage({
+					customType: "squad-failed",
+					content: `[squad] Squad "${squadId}" has stalled. ` +
+						`${formatTaskProgress(tasks)}, ${failed.length} failed.\n` +
+						`Failed: ${buildFailureSummary(tasks)}\n` +
+						"Use squad_status for details or squad_modify to adjust.",
+					display: true,
+				}, { triggerTurn: true, deliverAs: "followUp" });
+				break;
+			}
+			case "orchestrator_reply":
+				pi.sendMessage({
+					customType: "squad-agent-reply",
+					content: `[squad] Direct reply from '${event.agentName}' on task '${event.taskId}':\n${event.message}`,
+					display: true,
+				}, { triggerTurn: true, deliverAs: "followUp" });
+				break;
+			case "escalation":
+				pi.sendMessage({
+					customType: "squad-escalation",
+					content: `[squad] Agent '${event.agentName}' on task '${event.taskId}' needs attention:\n` +
+						`${event.message}\n\nReply to me and I'll forward your answer, or use the squad panel.`,
+					display: true,
+				}, { triggerTurn: true });
+				break;
+		}
+	});
+}
+
+/** Cancel one persisted exact squad without ever inferring or changing focus. */
+export async function cancelExactSquad(squadId: string, skillPaths: string[]): Promise<boolean> {
+	const squad = store.loadSquad(squadId);
+	if (!squad) return false;
+	const live = runtime.schedulers.get(squadId);
+	if (live) await live.stop();
+	else await new Scheduler(squadId, skillPaths, schedulerSpawnContext).stop();
+	const fresh = store.loadSquad(squadId);
+	if (fresh) {
+		fresh.status = "failed";
+		delete fresh.suspendedStallAttention;
+		store.saveSquad(fresh);
+	}
+	runtime.schedulers.delete(squadId);
+	repairFocusAfterCancellation(squadId);
+	return true;
+}
+
+/** Reconstruct one exact persisted squad without changing focus or starting work. */
+export function reviveScheduler(pi: ExtensionAPI, squadId: string, skillPaths: string[]): Scheduler {
+	let scheduler = runtime.schedulers.get(squadId);
+	if (!scheduler) {
+		scheduler = new Scheduler(squadId, skillPaths, schedulerSpawnContext);
+		runtime.schedulers.set(squadId, scheduler);
+		wireSchedulerEvents(pi, scheduler, squadId);
+	}
+	return scheduler;
+}
+
+/** Reconstruct and focus one exact persisted squad without creating/linking another. */
+export function ensureScheduler(pi: ExtensionAPI, squadId: string, skillPaths: string[]): Scheduler {
+	const scheduler = reviveScheduler(pi, squadId, skillPaths);
+	focusSquad(squadId);
+	return scheduler;
+}

package/src/scheduler.ts

@@ -797,159 +797,173 @@ export class Scheduler {
 
 	private handleAgentEvent(event: AgentEvent): void {
 		switch (event.type) {
-			case "message_end": {
-				const msg = event.data;
-				if (msg?.role === "assistant") {
-					// Extract text from assistant message
-					const text = this.extractAssistantText(msg);
-					if (text) {
-						// Route @mentions
-						this.router.processMessage(event.taskId, event.agentName, text);
-
-						// Log message
-						store.appendMessage(this.squadId, event.taskId, {
-							ts: store.now(),
-							from: event.agentName,
-							type: "text",
-							// Persist the complete handoff. Reports can be arbitrarily long;
-							// presentation layers may viewport them, but source data must never truncate.
-							text,
-						});
-
-						// A squad_message is a request/response channel, not fire-and-forget.
-						// Persist an acknowledgement marker before emitting so restart/focus
-						// changes cannot forward the same response twice.
-						if (this.hasPendingOrchestratorRequest(event.taskId)) {
-							store.appendMessage(this.squadId, event.taskId, {
-								ts: store.now(),
-								from: event.agentName,
-								type: "reply",
-								to: "orchestrator",
-								text: "Response forwarded to main orchestrator",
-							});
-							this.emit({
-								type: "orchestrator_reply",
-								squadId: this.squadId,
-								taskId: event.taskId,
-								agentName: event.agentName,
-								message: text,
-							});
-						}
-					}
-
-					// Track usage
-					if (msg.usage) {
-						store.updateTaskUsage(this.squadId, event.taskId, {
-							inputTokens: msg.usage.input || 0,
-							outputTokens: msg.usage.output || 0,
-							cost: msg.usage.cost?.total || 0,
-							turns: 1,
-						});
-					}
-				}
+			case "message_end":
+				this.onMessageEnd(event);
 				break;
-			}
+			case "tool_execution_start":
+				this.onToolExecutionStart(event);
+				break;
+			case "tool_execution_end":
+				this.onToolExecutionEnd(event);
+				break;
+			case "agent_end":
+				if (this.onAgentEnd(event)) return;
+				break;
+			case "agent_settled":
+				this.onAgentSettled(event);
+				return;
+			case "error":
+				this.onError(event);
+				break;
+		}
 
-			case "tool_execution_start": {
-				const data = event.data;
+		this.updateContext();
+	}
+
+	private onMessageEnd(event: AgentEvent): void {
+		const msg = event.data;
+		if (msg?.role === "assistant") {
+			// Extract text from assistant message
+			const text = this.extractAssistantText(msg);
+			if (text) {
+				// Route @mentions
+				this.router.processMessage(event.taskId, event.agentName, text);
+
+				// Log message
 				store.appendMessage(this.squadId, event.taskId, {
 					ts: store.now(),
 					from: event.agentName,
-					type: "tool",
-					text: data.toolName || "unknown",
-					name: data.toolName,
-					args: data.args,
+					type: "text",
+					// Persist the complete handoff. Reports can be arbitrarily long;
+					// presentation layers may viewport them, but source data must never truncate.
+					text,
 				});
 
-				this.emit({
-					type: "activity",
-					squadId: this.squadId,
-					taskId: event.taskId,
-					agentName: event.agentName,
-					message: `→ ${data.toolName}`,
-					data,
-				});
-				break;
-			}
-
-			case "tool_execution_end": {
-				// Track file modifications
-				const data = event.data;
-				if (data.toolName === "write" || data.toolName === "edit") {
-					const filePath = data.args?.path || data.args?.file_path;
-					if (filePath) {
-						this.updateModifiedFiles(event.agentName, filePath);
-					}
-				}
-				break;
-			}
-
-			case "agent_end": {
-				// Pi's low-level agent_end is not completion. AgentPool normally keeps
-				// it internal; if observed here, preserve in_progress. Only an actual
-				// child-process exit carries unexpectedExit and enters retry handling.
-				if (!event.data?.unexpectedExit) break;
-				this.handleUnexpectedAgentExit(event);
-				return;
-			}
-
-			case "agent_settled": {
-				const settledTask = store.loadTask(this.squadId, event.taskId);
-				const status = settledTask?.status;
-				if (status === "cancelled" || status === "suspended") return;
-				const settledSquad = store.loadSquad(this.squadId);
-				if (settledTask && settledSquad && !validateTaskSpecAttestation(settledSquad, settledTask)) {
-					store.updateTaskStatus(this.squadId, event.taskId, "pending", { completed: null, output: null, error: "Canonical squad spec was not fully delivered; read all chunks with squad_spec_read" });
-					store.appendMessage(this.squadId, event.taskId, { ts: store.now(), from: "system", type: "status", text: "Completion rejected: missing or invalid spec-read-attestation; reopening same task session" });
-					if (this.running) void this.reconcile();
-					this.updateContext();
-					return;
-				}
-				// A mailbox entry not acknowledged by Pi outranks this run's candidate
-				// completion. Reopen the same session so accepted-at-least-once delivery
-				// occurs before the task can become done.
-				if (store.loadPendingTaskMessages(this.squadId, event.taskId).length > 0) {
-					store.updateTaskStatus(this.squadId, event.taskId, "pending", { completed: null });
+				// A squad_message is a request/response channel, not fire-and-forget.
+				// Persist an acknowledgement marker before emitting so restart/focus
+				// changes cannot forward the same response twice.
+				if (this.hasPendingOrchestratorRequest(event.taskId)) {
 					store.appendMessage(this.squadId, event.taskId, {
 						ts: store.now(),
-						from: "system",
-						type: "status",
-						text: "Agent settled with pending durable messages; resuming the same task session",
+						from: event.agentName,
+						type: "reply",
+						to: "orchestrator",
+						text: "Response forwarded to main orchestrator",
 					});
-					if (this.running) void this.reconcile();
-					this.updateContext();
-					return;
-				}
-
-				const turnCount = event.data?.turnCount ?? 0;
-				const toolCallCount = event.data?.toolCallCount ?? 0;
-				const hasSubstantiveOutput = store.loadMessages(this.squadId, event.taskId)
-					.some((message) => message.from === event.agentName && message.type === "text" && message.text.trim().length > 0);
-				const hadMeaningfulWork = turnCount > 0 && (toolCallCount > 0 || hasSubstantiveOutput);
-				if (hadMeaningfulWork) {
-					this.handleTaskCompleted(event.taskId).then(() => this.updateContext());
-				} else {
-					this.handleUnexpectedAgentExit({
-						...event,
-						data: { ...event.data, unexpectedExit: true },
+					this.emit({
+						type: "orchestrator_reply",
+						squadId: this.squadId,
+						taskId: event.taskId,
+						agentName: event.agentName,
+						message: text,
 					});
 				}
-				return;
 			}
 
-			case "error": {
-				const errorMsg = event.data?.message || "Unknown error";
-				store.appendMessage(this.squadId, event.taskId, {
-					ts: store.now(),
-					from: "system",
-					type: "error",
-					text: errorMsg,
+			// Track usage
+			if (msg.usage) {
+				store.updateTaskUsage(this.squadId, event.taskId, {
+					inputTokens: msg.usage.input || 0,
+					outputTokens: msg.usage.output || 0,
+					cost: msg.usage.cost?.total || 0,
+					turns: 1,
 				});
-				break;
 			}
 		}
+	}
 
-		this.updateContext();
+	private onToolExecutionStart(event: AgentEvent): void {
+		const data = event.data;
+		store.appendMessage(this.squadId, event.taskId, {
+			ts: store.now(),
+			from: event.agentName,
+			type: "tool",
+			text: data.toolName || "unknown",
+			name: data.toolName,
+			args: data.args,
+		});
+
+		this.emit({
+			type: "activity",
+			squadId: this.squadId,
+			taskId: event.taskId,
+			agentName: event.agentName,
+			message: `→ ${data.toolName}`,
+			data,
+		});
+	}
+
+	private onToolExecutionEnd(event: AgentEvent): void {
+		// Track file modifications
+		const data = event.data;
+		if (data.toolName === "write" || data.toolName === "edit") {
+			const filePath = data.args?.path || data.args?.file_path;
+			if (filePath) {
+				this.updateModifiedFiles(event.agentName, filePath);
+			}
+		}
+	}
+
+	private onAgentEnd(event: AgentEvent): boolean {
+		// Pi's low-level agent_end is not completion. AgentPool normally keeps
+		// it internal; if observed here, preserve in_progress. Only an actual
+		// child-process exit carries unexpectedExit and enters retry handling.
+		if (!event.data?.unexpectedExit) return false;
+		this.handleUnexpectedAgentExit(event);
+		return true;
+	}
+
+	private onAgentSettled(event: AgentEvent): void {
+		const settledTask = store.loadTask(this.squadId, event.taskId);
+		const status = settledTask?.status;
+		if (status === "cancelled" || status === "suspended") return;
+		const settledSquad = store.loadSquad(this.squadId);
+		if (settledTask && settledSquad && !validateTaskSpecAttestation(settledSquad, settledTask)) {
+			store.updateTaskStatus(this.squadId, event.taskId, "pending", { completed: null, output: null, error: "Canonical squad spec was not fully delivered; read all chunks with squad_spec_read" });
+			store.appendMessage(this.squadId, event.taskId, { ts: store.now(), from: "system", type: "status", text: "Completion rejected: missing or invalid spec-read-attestation; reopening same task session" });
+			if (this.running) void this.reconcile();
+			this.updateContext();
+			return;
+		}
+		// A mailbox entry not acknowledged by Pi outranks this run's candidate
+		// completion. Reopen the same session so accepted-at-least-once delivery
+		// occurs before the task can become done.
+		if (store.loadPendingTaskMessages(this.squadId, event.taskId).length > 0) {
+			store.updateTaskStatus(this.squadId, event.taskId, "pending", { completed: null });
+			store.appendMessage(this.squadId, event.taskId, {
+				ts: store.now(),
+				from: "system",
+				type: "status",
+				text: "Agent settled with pending durable messages; resuming the same task session",
+			});
+			if (this.running) void this.reconcile();
+			this.updateContext();
+			return;
+		}
+
+		const turnCount = event.data?.turnCount ?? 0;
+		const toolCallCount = event.data?.toolCallCount ?? 0;
+		const hasSubstantiveOutput = store.loadMessages(this.squadId, event.taskId)
+			.some((message) => message.from === event.agentName && message.type === "text" && message.text.trim().length > 0);
+		const hadMeaningfulWork = turnCount > 0 && (toolCallCount > 0 || hasSubstantiveOutput);
+		if (hadMeaningfulWork) {
+			this.handleTaskCompleted(event.taskId).then(() => this.updateContext());
+		} else {
+			this.handleUnexpectedAgentExit({
+				...event,
+				data: { ...event.data, unexpectedExit: true },
+			});
+		}
+	}
+
+	private onError(event: AgentEvent): void {
+		const errorMsg = event.data?.message || "Unknown error";
+		store.appendMessage(this.squadId, event.taskId, {
+			ts: store.now(),
+			from: "system",
+			type: "error",
+			text: errorMsg,
+		});
 	}
 
 	private async handleTaskCompleted(taskId: string): Promise<void> {