@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/src/intercom/native-supervisor-channel.ts

@@ -22,6 +22,7 @@ export const NATIVE_SUPERVISOR_TOOL_NAME = "subagent_supervisor";
 const MAX_MESSAGE_BYTES = 64 * 1024;
 const DEFAULT_ASK_TIMEOUT_MS = 10 * 60 * 1000;
 const CHANNEL_POLL_MS = Math.min(POLL_INTERVAL_MS, 500);
+const CHANNEL_SAFETY_POLL_MS = 5000;
 const STALE_EMPTY_CHANNEL_AGE_MS = 60 * 1000;
 const STALE_EMPTY_CHANNEL_CLEANUP_INTERVAL_MS = 60 * 1000;
 
@@ -69,6 +70,13 @@ interface IntercomParams {
 	replyTo?: string;
 }
 
+type SupervisorWatch = (filename: fs.PathLike, listener: fs.WatchListener<string>) => fs.FSWatcher;
+
+interface NativeSupervisorChannelDeps {
+	platform?: NodeJS.Platform;
+	watch?: SupervisorWatch;
+}
+
 const ContactSupervisorParamsSchema = Type.Object({
 	reason: Type.String({ enum: ["need_decision", "interview_request", "progress_update"] }),
 	message: Type.Optional(Type.String()),
@@ -626,10 +634,16 @@ function buildParentIntercomTool(pending: Map<string, PendingSupervisorRequest>,
 	};
 }
 
-export function createNativeSupervisorChannel(pi: ExtensionAPI, state: SubagentState): { start: () => void; dispose: () => void; pending: Map<string, PendingSupervisorRequest> } {
+export function createNativeSupervisorChannel(pi: ExtensionAPI, state: SubagentState, deps: NativeSupervisorChannelDeps = {}): { start: () => void; dispose: () => void; pending: Map<string, PendingSupervisorRequest> } {
+	const watch = deps.watch ?? fs.watch;
 	const pending = new Map<string, PendingSupervisorRequest>();
 	const seenFiles = new Set<string>();
+	const requestWatchers = new Map<string, fs.FSWatcher>();
+	let rootWatcher: fs.FSWatcher | undefined;
 	let poller: ReturnType<typeof setInterval> | undefined;
+	let safetyPoller: ReturnType<typeof setInterval> | undefined;
+	let deferredWatcherRefresh: ReturnType<typeof setImmediate> | undefined;
+	let started = false;
 	let lastStaleCleanupAt = 0;
 
 	const registerParentTools = (): void => {
@@ -696,17 +710,101 @@ export function createNativeSupervisorChannel(pi: ExtensionAPI, state: SubagentS
 		}
 	};
 
+	const startPolling = (): void => {
+		if (poller) return;
+		poller = setInterval(poll, CHANNEL_POLL_MS);
+		poller.unref?.();
+	};
+	const startSafetyPolling = (): void => {
+		if (safetyPoller) return;
+		safetyPoller = setInterval(() => {
+			watchExistingRequestDirs();
+			poll();
+		}, CHANNEL_SAFETY_POLL_MS);
+		safetyPoller.unref?.();
+	};
+	const watchRequestDir = (requestsDir: string): void => {
+		if (requestWatchers.has(requestsDir)) return;
+		try {
+			const watcher = watch(requestsDir, () => poll());
+			watcher.on("error", () => {
+				try { watcher.close(); } catch {}
+				requestWatchers.delete(requestsDir);
+				startPolling();
+			});
+			watcher.unref?.();
+			requestWatchers.set(requestsDir, watcher);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") startPolling();
+		}
+	};
+	const watchExistingRequestDirs = (): void => {
+		let channelEntries: fs.Dirent[];
+		try {
+			channelEntries = fs.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: true });
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
+			startPolling();
+			return;
+		}
+		for (const entry of channelEntries) {
+			if (entry.isDirectory()) watchRequestDir(path.join(SUPERVISOR_CHANNEL_ROOT, entry.name, REQUESTS_DIR));
+		}
+	};
+	const scheduleWatcherRefresh = (): void => {
+		if (deferredWatcherRefresh) return;
+		deferredWatcherRefresh = setImmediate(() => {
+			deferredWatcherRefresh = undefined;
+			if (!started) return;
+			watchExistingRequestDirs();
+			poll();
+		});
+		deferredWatcherRefresh.unref?.();
+	};
+
 	return {
 		start: () => {
-			if (poller) return;
+			if (started) return;
+			started = true;
 			registerParentTools();
 			poll();
-			poller = setInterval(poll, CHANNEL_POLL_MS);
-			poller.unref?.();
+			try {
+				fs.mkdirSync(SUPERVISOR_CHANNEL_ROOT, { recursive: true });
+				if ((deps.platform ?? process.platform) === "win32") {
+					startPolling();
+					return;
+				}
+				watchExistingRequestDirs();
+				rootWatcher = watch(SUPERVISOR_CHANNEL_ROOT, () => {
+					watchExistingRequestDirs();
+					poll();
+					scheduleWatcherRefresh();
+				});
+				rootWatcher.on("error", startPolling);
+				startSafetyPolling();
+				scheduleWatcherRefresh();
+			} catch {
+				startPolling();
+			}
 		},
 		dispose: () => {
+			started = false;
+			try {
+				rootWatcher?.close();
+			} catch {
+				// Best effort during shutdown.
+			}
+			rootWatcher = undefined;
+			for (const watcher of requestWatchers.values()) {
+				try { watcher.close(); } catch {}
+			}
+			requestWatchers.clear();
 			if (poller) clearInterval(poller);
 			poller = undefined;
+			if (safetyPoller) clearInterval(safetyPoller);
+			safetyPoller = undefined;
+			if (deferredWatcherRefresh) clearImmediate(deferredWatcherRefresh);
+			deferredWatcherRefresh = undefined;
 			pending.clear();
 			seenFiles.clear();
 		},

package/dist/extensions/pi-subagents/src/missions/actions.ts

@@ -14,8 +14,10 @@ import {
 	type MissionStatus,
 	type MissionStoreConfig,
 	type MissionStoreLocation,
+	type MissionTokenBudget,
 	type MissionUpdateInput,
 } from "./types.ts";
+import { missionStatePath } from "./workflow-state.ts";
 import {
 	createMission,
 	listGlobalMissions,
@@ -32,6 +34,7 @@ export const MISSION_ACTIONS = [
 	"mission.list",
 	"mission.show",
 	"mission.update",
+	"mission.resolve-decision",
 	"mission.attach-run",
 	"mission.close",
 ] as const;
@@ -40,13 +43,17 @@ export type MissionAction = typeof MISSION_ACTIONS[number];
 
 export interface MissionLaunchInput {
 	title: string;
-	goal?: string;
+	objective?: string;
+	goal?: true;
+	budget?: MissionTokenBudget;
 	labels?: string[];
 }
 
 export interface MissionUpdateToolInput {
 	title?: string;
-	goal?: string;
+	objective?: string;
+	goal?: boolean | { paused: boolean };
+	budget?: MissionTokenBudget;
 	status?: MissionStatus;
 	summary?: string;
 	labels?: string[];
@@ -101,17 +108,27 @@ export function validateMissionLaunch(value: unknown): MissionLaunchInput {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("mission must be an object");
 	const input = value as Record<string, unknown>;
 	for (const key of Object.keys(input)) {
-		if (key !== "title" && key !== "goal" && key !== "labels") throw new Error(`mission.${key} is unknown`);
+		if (key !== "title" && key !== "summary" && key !== "objective" && key !== "goal" && key !== "budget" && key !== "labels") throw new Error(`mission.${key} is unknown`);
 	}
-	if (typeof input.title !== "string" || !input.title.trim()) throw new Error("mission.title must be a non-empty string");
-	if (input.goal !== undefined && (typeof input.goal !== "string" || !input.goal.trim())) throw new Error("mission.goal must be a non-empty string");
+	if (input.title !== undefined && input.summary !== undefined) throw new Error("mission.title and mission.summary cannot both be set");
+	const title = input.title ?? input.summary;
+	if (typeof title !== "string" || !title.trim()) throw new Error("mission.title or mission.summary must be a non-empty string");
+	if (input.objective !== undefined && (typeof input.objective !== "string" || !input.objective.trim())) throw new Error("mission.objective must be a non-empty string");
+	if (input.goal !== undefined && input.goal !== true) throw new Error("mission.goal must be true when supplied");
+	const budget = input.budget;
+	if (budget !== undefined && (!budget || typeof budget !== "object" || Array.isArray(budget) || !Number.isSafeInteger((budget as { tokens?: unknown }).tokens) || ((budget as { tokens: number }).tokens < 1))) {
+		throw new Error("mission.budget.tokens must be a positive integer");
+	}
+	if (input.goal === true && budget === undefined) throw new Error("mission.budget is required when mission.goal is true");
 	if (input.labels !== undefined && (!Array.isArray(input.labels) || input.labels.some((label) => typeof label !== "string" || !label.trim()))) {
 		throw new Error("mission.labels must contain only non-empty strings");
 	}
 	return {
-		title: input.title.trim(),
-		...(typeof input.goal === "string" ? { goal: input.goal.trim() } : {}),
-		...(Array.isArray(input.labels) ? { labels: input.labels as string[] } : {}),
+		title: title.trim(),
+		...(typeof input.objective === "string" ? { objective: input.objective.trim() } : {}),
+		...(input.goal === true ? { goal: true as const } : {}),
+		...(budget !== undefined ? { budget: { tokens: (budget as { tokens: number }).tokens } } : {}),
+		...(input.labels !== undefined ? { labels: input.labels.map((label) => label.trim()) } : {}),
 	};
 }
 
@@ -161,15 +178,30 @@ function validateMissionUpdate(value: unknown): MissionUpdateInput {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("missionUpdate must be an object");
 	const input = value as Record<string, unknown>;
 	for (const key of Object.keys(input)) {
-		if (!["title", "goal", "status", "summary", "labels", "artifacts", "receipts", "decisions"].includes(key)) throw new Error(`missionUpdate.${key} is unknown`);
+		if (!["title", "objective", "goal", "budget", "status", "summary", "labels", "artifacts", "receipts", "decisions"].includes(key)) throw new Error(`missionUpdate.${key} is unknown`);
 	}
 	const update: MissionUpdateInput = {};
-	for (const field of ["title", "goal", "summary"] as const) {
+	for (const field of ["title", "objective", "summary"] as const) {
 		const candidate = input[field];
 		if (candidate === undefined) continue;
 		if (typeof candidate !== "string" || !candidate.trim()) throw new Error(`missionUpdate.${field} must be a non-empty string`);
 		update[field] = candidate.trim();
 	}
+	if (input.goal !== undefined) {
+		if (typeof input.goal === "boolean") update.goal = input.goal ? { status: "active" } : false;
+		else {
+			if (!input.goal || typeof input.goal !== "object" || Array.isArray(input.goal) || typeof (input.goal as { paused?: unknown }).paused !== "boolean" || Object.keys(input.goal).some((key) => key !== "paused")) {
+				throw new Error("missionUpdate.goal must be boolean or { paused: boolean }");
+			}
+			update.goal = { status: (input.goal as { paused: boolean }).paused ? "paused" : "active" };
+		}
+	}
+	if (input.budget !== undefined) {
+		if (!input.budget || typeof input.budget !== "object" || Array.isArray(input.budget) || !Number.isSafeInteger((input.budget as { tokens?: unknown }).tokens) || (input.budget as { tokens: number }).tokens < 1) {
+			throw new Error("missionUpdate.budget.tokens must be a positive integer");
+		}
+		update.budget = { tokens: (input.budget as { tokens: number }).tokens };
+	}
 	if (input.status !== undefined) update.status = validateStatus(input.status, "missionUpdate.status");
 	if (input.labels !== undefined) {
 		if (!Array.isArray(input.labels) || input.labels.some((label) => typeof label !== "string" || !label.trim())) throw new Error("missionUpdate.labels must contain only non-empty strings");
@@ -234,7 +266,11 @@ function refreshLinkedRunStatus(location: MissionStoreLocation, record: MissionR
 	if (updates.length === 0) return { record, warnings };
 	const merged = record.runs.map((run) => updates.find((update) => update.runId === run.runId && update.childIndex === run.childIndex) ?? run);
 	const states = merged.map((run) => run.status);
-	const status: MissionStatus = states.some((state) => state === "queued" || state === "running" || state === "active")
+	const status: MissionStatus = record.status === "completed" || record.status === "failed" || record.status === "cancelled"
+		? record.status
+		: record.goal && !states.some((state) => state === "queued" || state === "running" || state === "active")
+		? "active"
+		: states.some((state) => state === "queued" || state === "running" || state === "active")
 		? "active"
 		: states.some((state) => state === "paused")
 			? "waiting"
@@ -253,18 +289,30 @@ function formatMission(record: MissionRecord): string {
 		`Mission: ${record.id}`,
 		`Title: ${record.title}`,
 		`Status: ${record.status}`,
-		`Goal: ${record.goal}`,
+		`Objective: ${record.objective}`,
 		`Updated: ${record.updatedAt}`,
 	];
+	if (record.goal && record.budget) lines.push(`Goal mode: ${record.goal.status}`, `Budget: ${record.usage?.tokens ?? 0}/${record.budget.tokens} tokens`);
 	if (record.summary) lines.push(`Summary: ${record.summary}`);
 	if (record.labels?.length) lines.push(`Labels: ${record.labels.join(", ")}`);
 	if (record.runs.length) {
 		lines.push("Runs:");
 		for (const run of record.runs) lines.push(`  ${run.runId} (${run.mode}${run.status ? `, ${run.status}` : ""})${run.asyncDir ? ` — ${run.asyncDir}` : ""}`);
 	}
+	if (record.workflowChildren.length) {
+		lines.push("Workflow children:");
+		for (const child of record.workflowChildren) {
+			const identity = child.runId ? `${child.key} (${child.runId})` : child.key;
+			const heartbeat = child.heartbeat ? `; heartbeat ${child.heartbeat.status ?? child.status}${child.heartbeat.phase ? `/${child.heartbeat.phase}` : ""} at ${child.heartbeat.updatedAt}` : "";
+			const recovery = child.sessionPath ? `; session ${child.sessionPath}` : child.artifactPaths.length ? `; artifacts ${child.artifactPaths.length}` : "";
+			lines.push(`  ${identity}: ${child.status}${child.agent ? ` — ${child.agent}` : ""}${child.phase ? ` [${child.phase}]` : ""}; updated ${child.updatedAt}${heartbeat}${recovery}`);
+		}
+	}
 	if (record.decisions.length) {
 		lines.push("Decisions:");
-		for (const decision of record.decisions) lines.push(`  ${decision.id}: ${decision.status} — ${decision.title}`);
+		for (const decision of record.decisions) {
+			lines.push(`  ${decision.id}: ${decision.status} — ${decision.title}${decision.resolution ? `; resolution: ${decision.resolution}` : ""}`);
+		}
 	}
 	if (record.artifacts.length) {
 		lines.push("Artifacts:");
@@ -291,7 +339,9 @@ export function handleMissionAction(
 		const mission = validateMissionLaunch(params.mission);
 		const record = createMission(location, {
 			title: mission.title,
-			goal: mission.goal ?? mission.title,
+			objective: mission.objective ?? mission.title,
+			...(mission.goal === true ? { goal: true as const } : {}),
+			...(mission.budget ? { budget: mission.budget } : {}),
 			status: params.missionStatus ? validateStatus(params.missionStatus, "missionStatus") : "planned",
 			...(mission.labels ? { labels: mission.labels } : {}),
 			...(ctx.currentSessionId ? { ownerSessionId: ctx.currentSessionId } : {}),
@@ -313,13 +363,17 @@ export function handleMissionAction(
 		const listed = listMissions(location);
 		const lines = listed.records.length === 0
 			? ["No project missions."]
-			: listed.records.map((record) => `${record.id}  ${record.status}  ${record.title}  ${record.updatedAt}`);
+			: listed.records.map((record) => {
+				const open = record.decisions.filter((decision) => decision.status === "open").length;
+				const resolved = record.decisions.length - open;
+				return `${record.id}  ${record.status}  ${record.title}  ${record.updatedAt}${record.decisions.length ? `  decisions: ${open} open, ${resolved} resolved` : ""}`;
+			});
 		if (listed.warnings.length) lines.push("", ...listed.warnings.map((warning) => `Warning: ${warning}`));
 		return textResult(lines.join("\n"), { mode: "management", results: [], missions: { records: listed.records, warnings: listed.warnings } });
 	}
 	if (action === "mission.show") {
 		const refreshed = refreshLinkedRunStatus(location, readMission(location, requireMissionId(params)));
-		const lines = [formatMission(refreshed.record)];
+		const lines = [formatMission(refreshed.record), `State: ${missionStatePath(location, refreshed.record.id)}`];
 		if (refreshed.warnings.length) lines.push("", ...refreshed.warnings.map((warning) => `Warning: ${warning}`));
 		return textResult(lines.join("\n"), {
 			mode: "management",
@@ -334,6 +388,13 @@ export function handleMissionAction(
 		const record = updateMission(location, requireMissionId(params), validateMissionUpdate(params.missionUpdate));
 		return textResult(`Updated mission ${record.id}.\n\n${formatMission(record)}`, { mode: "management", results: [], missionId: record.id, missionPath: pathFor(record.id), mission: record });
 	}
+	if (action === "mission.resolve-decision") {
+		const missionId = requireMissionId(params);
+		const decisionId = validateMissionId(params.id, "id");
+		if (typeof params.summary !== "string" || !params.summary.trim()) throw new Error("mission.resolve-decision requires a non-empty summary");
+		const record = updateMission(location, missionId, { resolveDecision: { id: decisionId, resolution: params.summary.trim() } });
+		return textResult(`Resolved decision ${decisionId} for mission ${record.id}.\n\n${formatMission(record)}`, { mode: "management", results: [], missionId: record.id, missionPath: pathFor(record.id), mission: record });
+	}
 	if (action === "mission.attach-run") {
 		const missionId = requireMissionId(params);
 		const runId = params.runId ?? params.id;

package/dist/extensions/pi-subagents/src/missions/goal-driver.ts

@@ -0,0 +1,162 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { RetainedChild } from "../runs/background/retained-children.ts";
+import type { ControlEvent } from "../shared/types.ts";
+import { listMissions, readMission, updateMission } from "./store.ts";
+import type { MissionRecord, MissionRunLink, MissionStoreLocation } from "./types.ts";
+import { missionStatePath } from "./workflow-state.ts";
+
+const TERMINAL_MISSION_STATUSES = new Set(["completed", "failed", "cancelled"]);
+const ACTIVE_RUN_STATUSES = new Set(["queued", "running", "active"]);
+const MAX_ACTION_LENGTH = 180;
+
+export interface GoalContinuationNotice {
+	missionId: string;
+	message: string;
+	event: ControlEvent;
+}
+
+function bounded(value: string): string {
+	const normalized = value.replace(/\s+/g, " ").trim();
+	return normalized.length > MAX_ACTION_LENGTH ? `${normalized.slice(0, MAX_ACTION_LENGTH - 1)}…` : normalized;
+}
+
+function tokenUsage(value: unknown): number | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const total = (value as { total?: unknown }).total;
+	return Number.isSafeInteger(total) && (total as number) >= 0 ? total as number : undefined;
+}
+
+function readLinkedRun(run: MissionRunLink): MissionRunLink {
+	if (!run.asyncDir) return run;
+	const statusPath = path.join(run.asyncDir, "status.json");
+	if (!fs.existsSync(statusPath)) return run;
+	const status = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as Record<string, unknown>;
+	if (typeof status.state !== "string" || !status.state.trim()) throw new Error(`Linked run status '${statusPath}' is missing state`);
+	const tokens = tokenUsage(status.totalTokens)
+		?? (Array.isArray(status.steps)
+			? status.steps.reduce((total, step) => {
+				if (!step || typeof step !== "object") return total;
+				return total + (tokenUsage((step as { tokens?: unknown }).tokens) ?? 0);
+			}, 0)
+			: undefined);
+	return {
+		...run,
+		status: status.state,
+		...(!ACTIVE_RUN_STATUSES.has(status.state) && !run.completedAt ? { completedAt: new Date().toISOString() } : {}),
+		...(tokens !== undefined ? { usage: { tokens } } : {}),
+	};
+}
+
+function refreshGoalMission(location: MissionStoreLocation, record: MissionRecord): MissionRecord {
+	const runs = record.runs.map(readLinkedRun);
+	const changed = runs.some((run, index) => JSON.stringify(run) !== JSON.stringify(record.runs[index]));
+	if (!changed) return record;
+	const active = runs.some((run) => run.status && ACTIVE_RUN_STATUSES.has(run.status));
+	return updateMission(location, record.id, {
+		status: active ? "active" : record.goal ? "active" : record.status,
+		addRuns: runs,
+	});
+}
+
+function readyActionFromValue(value: unknown, pathLabel = "state", depth = 0): string | undefined {
+	if (depth > 8 || !value || typeof value !== "object") return undefined;
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index += 1) {
+			const found = readyActionFromValue(value[index], `${pathLabel}[${index}]`, depth + 1);
+			if (found) return found;
+		}
+		return undefined;
+	}
+	const input = value as Record<string, unknown>;
+	for (const key of ["nextReadyAction", "nextAction"] as const) {
+		if (typeof input[key] === "string" && input[key].trim()) return bounded(input[key]);
+	}
+	if (input.status === "ready") {
+		for (const key of ["action", "task", "title", "summary"] as const) {
+			if (typeof input[key] === "string" && input[key].trim()) return bounded(input[key]);
+		}
+		return `Continue ready mission state at ${pathLabel}`;
+	}
+	for (const [key, child] of Object.entries(input)) {
+		const found = readyActionFromValue(child, `${pathLabel}.${key}`, depth + 1);
+		if (found) return found;
+	}
+	return undefined;
+}
+
+function missionStateAction(location: MissionStoreLocation, record: MissionRecord): string | undefined {
+	const statePath = missionStatePath(location, record.id);
+	if (fs.existsSync(statePath)) {
+		const action = readyActionFromValue(JSON.parse(fs.readFileSync(statePath, "utf-8")));
+		if (action) return action;
+	}
+	const decision = record.decisions.find((item) => item.status === "open");
+	if (decision) return bounded(decision.recommendation ?? `Resolve decision: ${decision.title}`);
+	return undefined;
+}
+
+function retainedResumeTarget(record: MissionRecord, retainedChildren: RetainedChild[]): RetainedChild | undefined {
+	const latestRun = record.runs.at(-1);
+	if (!latestRun) return undefined;
+	return retainedChildren.find((child) => child.runId === latestRun.runId || child.parentRunId === latestRun.runId);
+}
+
+function nextReadyAction(location: MissionStoreLocation, record: MissionRecord, retainedChildren: RetainedChild[]): string {
+	const stateAction = missionStateAction(location, record);
+	const latestRun = record.runs.at(-1);
+	const action = stateAction
+		?? (latestRun?.status === "failed" || latestRun?.status === "paused"
+			? `Inspect linked run ${latestRun.runId} and continue the mission`
+			: `Continue objective: ${record.objective}`);
+	const retained = retainedResumeTarget(record, retainedChildren);
+	return retained
+		? `Resume retained child ${retained.runId} (${retained.agent}) for: ${bounded(action)}`
+		: bounded(action);
+}
+
+export function collectGoalContinuationNotices(input: {
+	location: MissionStoreLocation;
+	ownerSessionId: string;
+	retainedChildren: RetainedChild[];
+	turnId: number;
+	now?: number;
+}): GoalContinuationNotice[] {
+	const notices: GoalContinuationNotice[] = [];
+	const seen = new Set<string>();
+	for (const listed of listMissions(input.location).records) {
+		if (listed.ownerSessionId !== input.ownerSessionId || !listed.goal || TERMINAL_MISSION_STATUSES.has(listed.status)) continue;
+		let record = refreshGoalMission(input.location, readMission(input.location, listed.id));
+		if (!record.goal || record.goal.status !== "active" || !record.budget) continue;
+		if ((record.usage?.tokens ?? 0) >= record.budget.tokens) {
+			record = updateMission(input.location, record.id, { usage: record.usage ?? { tokens: 0 } });
+			if (record.goal?.status === "budget-exhausted") continue;
+		}
+		if (record.runs.some((run) => run.status && ACTIVE_RUN_STATUSES.has(run.status))) continue;
+		if (seen.has(record.id) || !record.budget) continue;
+		seen.add(record.id);
+		const budget = record.budget.tokens;
+		const used = record.usage?.tokens ?? 0;
+		const remaining = Math.max(0, budget - used);
+		const message = [
+			`Goal mission needs attention: ${bounded(record.title)}`,
+			`Mission: ${record.id}`,
+			`Remaining budget: ${remaining} tokens (${used}/${budget} used)`,
+			`Next ready action: ${nextReadyAction(input.location, record, input.retainedChildren)}`,
+		].join("\n");
+		notices.push({
+			missionId: record.id,
+			message,
+			event: {
+				type: "needs_attention",
+				to: "needs_attention",
+				ts: input.now ?? Date.now(),
+				runId: `goal-${record.id}-turn-${input.turnId}`,
+				agent: "goal mission",
+				message,
+				reason: "idle",
+			},
+		});
+	}
+	return notices;
+}

package/dist/extensions/pi-subagents/src/missions/lifecycle.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { writePrivateAtomicJson } from "../shared/atomic-json.ts";
+import { PROMPT_REDACTED } from "../shared/utils.ts";
 import type { Details, SubagentRunMode } from "../shared/types.ts";
 import { validateMissionLaunch } from "./actions.ts";
 import type { MissionArtifact, MissionRecord, MissionRunLink, MissionRunMode, MissionStatus, MissionStoreConfig, MissionStoreLocation } from "./types.ts";
@@ -34,15 +35,17 @@ interface PersistedMissionBinding {
 	retainTerminal?: number;
 }
 
-function workflowGoal(params: MissionLaunchParams): string | undefined {
-	return params.task?.trim()
+function workflowObjective(params: MissionLaunchParams): string | undefined {
+	const objective = params.task?.trim()
 		|| params.tasks?.find((task) => task.task?.trim())?.task?.trim()
 		|| params.chain?.find((step) => step.task?.trim())?.task?.trim();
-}
-
-function conciseTitle(goal: string): string {
-	const firstLine = goal.split(/\r?\n/, 1)[0]?.trim() || goal.trim();
-	return firstLine.length > 100 ? `${firstLine.slice(0, 97)}...` : firstLine;
+	if (objective) return objective;
+	for (const step of params.chain ?? []) {
+		const parallel = Array.isArray(step.parallel) ? step.parallel : step.parallel ? [step.parallel] : [];
+		const task = parallel.find((child) => child.task?.trim())?.task?.trim();
+		if (task) return task;
+	}
+	return undefined;
 }
 
 export function prepareMissionLaunch(input: {
@@ -51,24 +54,28 @@ export function prepareMissionLaunch(input: {
 	config?: MissionStoreConfig;
 	ownerSessionId?: string;
 }): MissionLaunchBinding | undefined {
-	if (input.params.missionId && input.params.mission !== undefined) throw new Error("Use missionId or mission, not both");
+	const hasMissionId = input.params.missionId !== undefined;
+	if (hasMissionId && input.params.mission !== undefined) throw new Error("Use missionId or mission, not both");
 	if (input.params.mission === false) return undefined;
-	const goal = workflowGoal(input.params);
+	const objective = workflowObjective(input.params);
 	const missionsEnabled = input.config?.enabled !== false;
-	const shouldCreate = input.params.mission !== undefined || (missionsEnabled && goal !== undefined);
-	if (!input.params.missionId && !shouldCreate) return undefined;
+	const shouldCreate = input.params.mission !== undefined || (missionsEnabled && objective !== undefined);
+	if (!hasMissionId && !shouldCreate) return undefined;
 	const location = resolveMissionStoreLocation({ projectRoot: input.projectRoot, ...(input.config ? { config: input.config } : {}) });
-	if (input.params.missionId) {
+	if (hasMissionId) {
 		const missionId = validateMissionId(input.params.missionId);
 		readMission(location, missionId);
 		updateMission(location, missionId, { status: "active" });
 		return { missionId, location, autoCreated: false, announceInContent: true };
 	}
 	const mission = input.params.mission !== undefined ? validateMissionLaunch(input.params.mission) : undefined;
-	const title = mission?.title || conciseTitle(goal!);
+	const promptDerivedObjective = mission?.objective ?? (mission ? mission.title : objective ? PROMPT_REDACTED : undefined);
+	const title = mission?.title || PROMPT_REDACTED;
 	const record = createMission(location, {
 		title,
-		goal: mission?.goal || goal || title,
+		objective: promptDerivedObjective || title,
+		...(mission?.goal === true ? { goal: true as const } : {}),
+		...(mission?.budget ? { budget: mission.budget } : {}),
 		status: "active",
 		...(mission?.labels ? { labels: mission.labels } : {}),
 		...(input.ownerSessionId ? { ownerSessionId: input.ownerSessionId } : {}),
@@ -92,7 +99,9 @@ function runStatusForResult(result: AgentToolResult<Details>): string {
 }
 
 function missionStatusForRun(record: MissionRecord, runId: string, runStatus: string): MissionStatus {
+	if (record.status === "completed" || record.status === "failed" || record.status === "cancelled") return record.status;
 	if (runStatus === "active" || runStatus === "queued" || runStatus === "running") return "active";
+	if (record.goal) return "active";
 	if (runStatus === "paused") return "waiting";
 	const otherActive = record.runs.some((run) => run.runId !== runId && (run.status === "active" || run.status === "queued" || run.status === "running"));
 	if (otherActive) return "active";
@@ -101,6 +110,17 @@ function missionStatusForRun(record: MissionRecord, runId: string, runStatus: st
 	return "failed";
 }
 
+function usageForResult(result: AgentToolResult<Details>): { tokens: number } | undefined {
+	const tokens = result.details.results.reduce((total, child) => total + child.usage.input + child.usage.output, 0);
+	return tokens > 0 ? { tokens } : undefined;
+}
+
+function usageFromUnknown(value: unknown): { tokens: number } | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const total = (value as { total?: unknown }).total;
+	return Number.isSafeInteger(total) && (total as number) >= 0 ? { tokens: total as number } : undefined;
+}
+
 function artifactsForResult(result: AgentToolResult<Details>): MissionArtifact[] {
 	const artifacts: MissionArtifact[] = [];
 	if (result.details.asyncDir) {
@@ -137,7 +157,7 @@ function persistedBinding(binding: MissionLaunchBinding): PersistedMissionBindin
 	};
 }
 
-function writeAsyncBinding(asyncDir: string, binding: MissionLaunchBinding): void {
+export function writeMissionAsyncBinding(asyncDir: string, binding: MissionLaunchBinding): void {
 	writePrivateAtomicJson(path.join(asyncDir, MISSION_BINDING_FILE), persistedBinding(binding));
 }
 
@@ -168,6 +188,7 @@ export function attachMissionToLaunchResult(input: {
 	const runStatus = runStatusForResult(input.result);
 	const current = readMission(input.binding.location, input.binding.missionId);
 	const startedAt = new Date().toISOString();
+	const usage = usageForResult(input.result);
 	const run: MissionRunLink = {
 		runId,
 		mode: missionRunModeForResult(input.result.details.mode),
@@ -176,6 +197,7 @@ export function attachMissionToLaunchResult(input: {
 		...(input.result.details.asyncDir ? { asyncDir: input.result.details.asyncDir } : {}),
 		...(input.result.details.results.length === 1 && input.result.details.results[0]?.agent ? { agent: input.result.details.results[0].agent } : {}),
 		...(runStatus !== "active" ? { completedAt: startedAt } : {}),
+		...(usage ? { usage } : {}),
 	};
 	let mission = updateMission(input.binding.location, input.binding.missionId, {
 		status: missionStatusForRun(current, runId, runStatus),
@@ -185,7 +207,7 @@ export function attachMissionToLaunchResult(input: {
 		...(input.result.details.results.length === 1 && input.result.details.results[0]?.acceptance ? { acceptance: input.result.details.results[0].acceptance } : {}),
 	});
 	if (input.result.details.asyncDir) {
-		writeAsyncBinding(input.result.details.asyncDir, input.binding);
+		writeMissionAsyncBinding(input.result.details.asyncDir, input.binding);
 		const statusPath = path.join(input.result.details.asyncDir, "status.json");
 		if (fs.existsSync(statusPath)) {
 			try {
@@ -305,10 +327,36 @@ export function syncMissionFromAsyncCompletion(value: unknown): MissionRecord |
 		}
 	}
 	const summary = typeof event.summary === "string" && event.summary.trim() ? event.summary.slice(0, 2000) : undefined;
+	const usage = usageFromUnknown(event.totalTokens)
+		?? (Array.isArray(event.results)
+			? { tokens: event.results.reduce((total, result) => {
+				if (!result || typeof result !== "object") return total;
+				return total + (usageFromUnknown((result as { tokens?: unknown }).tokens)?.tokens ?? 0);
+			}, 0) }
+			: undefined);
+	const workflowRunId = typeof event.parentWorkflowRunId === "string" && event.parentWorkflowRunId.trim() ? event.parentWorkflowRunId.trim() : undefined;
+	const workflowKey = typeof event.workflowKey === "string" && event.workflowKey.trim() ? event.workflowKey.trim() : undefined;
+	const workflowChildStatus = runStatus === "complete" || runStatus === "completed" || event.success === true
+		? "completed"
+		: runStatus === "paused"
+			? "paused"
+			: runStatus === "stopped"
+				? "stopped"
+				: "failed";
+	const workflowChildTerminal = !["running", "queued", "active", "paused"].includes(workflowChildStatus);
 	return updateMission(binding.location, binding.missionId, {
 		status: missionStatusForRun(current, runId, runStatus),
-		addRuns: [{ runId, mode: typeof event.mode === "string" && ["single", "parallel", "chain"].includes(event.mode) ? event.mode as SubagentRunMode : "external", asyncDir: event.asyncDir, status: runStatus, completedAt }],
+		addRuns: [{ runId, mode: typeof event.mode === "string" && ["single", "parallel", "chain", "workflow"].includes(event.mode) ? event.mode as SubagentRunMode : "external", asyncDir: event.asyncDir, status: runStatus, completedAt, ...(usage && usage.tokens > 0 ? { usage } : {}) }],
 		addArtifacts: artifacts,
+		...(workflowRunId && workflowKey ? { upsertWorkflowChildren: [{
+			workflowRunId,
+			key: workflowKey,
+			runId,
+			status: workflowChildStatus,
+			artifactPaths: artifacts.map((artifact) => artifact.path),
+			...(workflowChildTerminal ? { completedAt } : {}),
+			heartbeat: { status: workflowChildStatus, ...(summary ? { message: summary } : {}) },
+		}] } : {}),
 		...(summary ? { summary } : {}),
 	});
 }