ultimate-pi 0.16.0 → 0.18.0

package/.pi/extensions/lib/harness-subagent-auth.ts

@@ -1,23 +1,32 @@
 /**
  * Resolve concrete LLM credentials for harness subagent subprocesses.
  *
- * Parent sessions often use `router/auto` (pi-model-router). Subagents run with
+ * Parent sessions often use `router/<profile>` (pi-model-router). Subagents run with
  * `--no-extensions`, so they cannot use the logical router provider — they need
  * a real provider/model plus that provider's API key.
+ *
+ * Session-locked routing: subprocess model is chosen once from agent system prompt
+ * complexity (same analysis as parent session lock), not from per-turn parent tier.
  */
 
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { resolveTierFromPrompt } from "../../../vendor/pi-model-router/extensions/routing.js";
+import type {
+	RouterProfile,
+	RouterTier,
+	RoutingRule,
+} from "../../../vendor/pi-model-router/extensions/types.js";
 import type { AgentConfig } from "../../../vendor/pi-subagents/src/agents.js";
 
 const ROUTER_SENTINEL_KEY = "pi-model-router";
 const SENTINEL_API_KEYS = new Set([ROUTER_SENTINEL_KEY, "<authenticated>"]);
 
-type RouterTier = "high" | "medium" | "low";
-
 interface ModelRouterJson {
 	defaultProfile?: string;
-	profiles?: Record<string, Partial<Record<RouterTier, { model?: string }>>>;
+	phaseBias?: number;
+	rules?: RoutingRule[];
+	profiles?: Record<string, RouterProfile>;
 }
 
 export function isUsableApiKey(key: string | undefined): key is string {
@@ -35,7 +44,34 @@ export function parseModelRef(
 	return { provider, modelId };
 }
 
-export function thinkingToRouterTier(thinking?: string): RouterTier {
+/** Planning subagents that should prefer low/medium router tier for latency. */
+const ROUTINE_PLANNING_AGENT_PATHS = new Set([
+	"harness/planning/plan-evaluator",
+	"harness/planning/plan-adversary",
+	"harness/planning/review-integrator",
+	"harness/planning/hypothesis-validator",
+	"harness/planning/sprint-contract-auditor",
+	"harness/planning/planning-context",
+	"harness/planning/scout-structure",
+	"harness/planning/scout-semantic",
+	"harness/planning/decompose",
+	"harness/planning/hypothesis",
+	"harness/planning/stack-research",
+	"harness/planning/plan-validator",
+]);
+
+export function isRoutinePlanningAgent(agentName: string): boolean {
+	return ROUTINE_PLANNING_AGENT_PATHS.has(agentName);
+}
+
+export function thinkingToRouterTier(
+	thinking?: string,
+	agentName?: string,
+): RouterTier {
+	if (agentName && isRoutinePlanningAgent(agentName)) {
+		if (thinking === "high" || thinking === "xhigh") return "medium";
+		return "low";
+	}
 	if (thinking === "high" || thinking === "xhigh") return "high";
 	if (thinking === "off" || thinking === "minimal" || thinking === "low") {
 		return "low";
@@ -43,6 +79,64 @@ export function thinkingToRouterTier(thinking?: string): RouterTier {
 	return "medium";
 }
 
+function loadModelRouterConfig(cwd: string): ModelRouterJson | undefined {
+	const path = join(cwd, ".pi", "model-router.json");
+	if (!existsSync(path)) return undefined;
+	try {
+		return JSON.parse(readFileSync(path, "utf8")) as ModelRouterJson;
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveRouterProfileEntry(
+	config: ModelRouterJson,
+	profileId: string,
+): { profileId: string; profile: RouterProfile } | undefined {
+	const profiles = config.profiles;
+	if (!profiles) return undefined;
+	const candidates = [
+		profileId,
+		config.defaultProfile ?? "auto",
+		"auto",
+		"opencode-go",
+	];
+	const seen = new Set<string>();
+	for (const id of candidates) {
+		if (!id || seen.has(id)) continue;
+		seen.add(id);
+		const profile = profiles[id];
+		if (profile?.high?.model && profile.medium?.model && profile.low?.model) {
+			return { profileId: id, profile };
+		}
+	}
+	return undefined;
+}
+
+/** Tier from agent system prompt (+ optional task line) for session model lock. */
+export function resolveSubagentRouterTier(
+	cwd: string,
+	profileId: string,
+	agent: AgentConfig,
+	taskSnippet?: string,
+): RouterTier {
+	const config = loadModelRouterConfig(cwd);
+	if (config) {
+		const entry = resolveRouterProfileEntry(config, profileId);
+		if (entry) {
+			return resolveTierFromPrompt(
+				agent.systemPrompt ?? "",
+				taskSnippet?.trim() ?? "",
+				entry.profileId,
+				entry.profile,
+				config.rules,
+				config.phaseBias ?? 0.5,
+			);
+		}
+	}
+	return thinkingToRouterTier(agent.thinking, agent.name);
+}
+
 /** Map router profile tier → concrete `provider/model` from `.pi/model-router.json`. */
 export function resolveRouterConcreteModelRef(
 	cwd: string,
@@ -51,19 +145,10 @@ export function resolveRouterConcreteModelRef(
 ): string | undefined {
 	const path = join(cwd, ".pi", "model-router.json");
 	if (!existsSync(path)) return undefined;
-	let raw: ModelRouterJson;
-	try {
-		raw = JSON.parse(readFileSync(path, "utf8")) as ModelRouterJson;
-	} catch {
-		return undefined;
-	}
-	const profiles = raw.profiles;
-	if (!profiles) return undefined;
-	const profile =
-		profiles[profileId] ??
-		profiles[raw.defaultProfile ?? "auto"] ??
-		profiles.auto;
-	const model = profile?.[tier]?.model;
+	const raw = loadModelRouterConfig(cwd);
+	if (!raw) return undefined;
+	const entry = resolveRouterProfileEntry(raw, profileId);
+	const model = entry?.profile[tier]?.model;
 	return typeof model === "string" && model.includes("/") ? model : undefined;
 }
 
@@ -83,6 +168,7 @@ export function resolveConcreteSubagentModel(
 	cwd: string,
 	parentModel: { provider: string; id: string } | undefined,
 	agent: AgentConfig,
+	taskSnippet?: string,
 ): ConcreteSubagentModel | undefined {
 	if (agent.model && !agent.model.startsWith("router/")) {
 		const parsed = parseModelRef(agent.model);
@@ -109,7 +195,7 @@ export function resolveConcreteSubagentModel(
 		agentIsRouter && agent.model
 			? agent.model.slice("router/".length)
 			: (parentModel?.id ?? "auto");
-	const tier = thinkingToRouterTier(agent.thinking);
+	const tier = resolveSubagentRouterTier(cwd, profileId, agent, taskSnippet);
 	const concrete = resolveRouterConcreteModelRef(cwd, profileId, tier);
 	if (!concrete) return undefined;
 	const parsed = parseModelRef(concrete);

package/.pi/extensions/lib/harness-subagent-policy.ts

@@ -2,6 +2,11 @@
  * Per-agent tool policy for harness/* subagents (defense in depth with frontmatter).
  */
 
+import {
+	evaluateContextModeMutation,
+	isMutatingBash,
+} from "../../lib/harness-context-mode-policy.js";
+import type { HarnessPhase } from "../../lib/harness-run-context.js";
 import {
 	isSubmitToolName,
 	SUBMIT_TOOLS_BY_AGENT,
@@ -24,6 +29,9 @@ export type HarnessAgentKind =
 
 const MUTATING_TOOLS = new Set(["write", "edit"]);
 
+/** Planning agents must use submit_* → canonical artifacts/*.yaml, not JSON dumps. */
+const PLANNING_ARTIFACT_JSON_WRITE = /artifacts\/[^\s'"`;]+\.json\b/i;
+
 const PLANNING_BASH_DENY_PATTERNS = [
 	/\bgraphify\s+update\b/i,
 	/\bgraphify\s+extract\b/i,
@@ -37,21 +45,6 @@ const PLANNING_BASH_DENY_PATTERNS = [
 	/\buv\s+tool\s+install\b.*cocoindex/i,
 ];
 
-const BASH_MUTATION_PATTERNS = [
-	/\brm\s+-/i,
-	/\bmv\s+/i,
-	/\bcp\s+/i,
-	/\btouch\s+/i,
-	/\bmkdir\s+/i,
-	/\btee\s+/i,
-	/\bgit\s+(add|commit|push|reset|checkout|merge|rebase|cherry-pick|apply)\b/i,
-	/\bnpm\s+(install|uninstall|ci)\b/i,
-	/\bpnpm\s+(add|install|remove)\b/i,
-	/\byarn\s+(add|install|remove)\b/i,
-	/\bsed\s+-i\b/i,
-	/\bperl\s+-i\b/i,
-];
-
 const READ_ONLY_KINDS = new Set<HarnessAgentKind>([
 	"planner",
 	"evaluator",
@@ -92,10 +85,6 @@ export function classifyHarnessAgent(agentType: string): HarnessAgentKind {
 	}
 }
 
-function isMutatingBash(command: string): boolean {
-	return BASH_MUTATION_PATTERNS.some((pattern) => pattern.test(command));
-}
-
 export function isHarnessPackageAgent(agentType: string): boolean {
 	return agentType.startsWith("harness/");
 }
@@ -174,6 +163,17 @@ export function evaluateHarnessSubagentToolCall(
 
 	if (toolName === "bash") {
 		const command = String(input?.command ?? "");
+		if (
+			kind === "planner" &&
+			command &&
+			PLANNING_ARTIFACT_JSON_WRITE.test(command)
+		) {
+			return {
+				action: "block",
+				reason:
+					"harness-subagent-policy: artifacts must be YAML only — use submit_* (e.g. submit_hypothesis_brief → artifacts/hypothesis.yaml), not bash writes to .json.",
+			};
+		}
 		if (command && isMutatingBash(command)) {
 			return {
 				action: "block",
@@ -193,6 +193,24 @@ export function evaluateHarnessSubagentToolCall(
 		}
 	}
 
+	const ctxPhase =
+		(harnessSubagentPhaseHint(agentType) as HarnessPhase | null) ?? "plan";
+	const ctxDecision = evaluateContextModeMutation(
+		toolName,
+		input ?? {},
+		ctxPhase,
+		{ aborted: false, readOnlyAgent: true },
+	);
+	if (ctxDecision.blocked) {
+		return {
+			action: "block",
+			reason: ctxDecision.reason.replace(
+				/^policy-gate:/,
+				"harness-subagent-policy:",
+			),
+		};
+	}
+
 	return { action: "allow" };
 }
 

package/.pi/extensions/lib/harness-subagent-precheck.ts

@@ -6,8 +6,11 @@ import {
 	type AgentConfig,
 	agentAllowsMutatingTools,
 } from "../../../vendor/pi-subagents/src/agents.js";
-import type { HarnessPhase } from "../../lib/harness-run-context.js";
-import { inferHarnessPhase } from "../../lib/harness-run-context.js";
+import {
+	type HarnessPhase,
+	inferHarnessPhase,
+} from "../../lib/harness-run-context.js";
+import { validateHarnessSpawnTopology } from "./harness-spawn-topology.js";
 import { classifyHarnessAgent } from "./harness-subagent-policy.js";
 
 export interface SubagentTaskRef {
@@ -19,6 +22,11 @@ export interface PrecheckResult {
 	message?: string;
 }
 
+export interface PrecheckOptions {
+	projectRoot?: string;
+	runId?: string | null;
+}
+
 function collectAgents(params: {
 	agent?: string;
 	tasks?: SubagentTaskRef[];
@@ -40,7 +48,7 @@ function resolveAgent(
 	return agents.find((a) => a.name === name);
 }
 
-export function precheckHarnessSubagentSpawn(
+export async function precheckHarnessSubagentSpawn(
 	params: {
 		agent?: string;
 		tasks?: SubagentTaskRef[];
@@ -49,7 +57,8 @@ export function precheckHarnessSubagentSpawn(
 	},
 	agents: AgentConfig[],
 	phase: HarnessPhase,
-): PrecheckResult {
+	opts?: PrecheckOptions,
+): Promise<PrecheckResult> {
 	const names = collectAgents(params);
 	const mutating = names.filter((n) => {
 		const cfg = resolveAgent(agents, n);
@@ -67,7 +76,17 @@ export function precheckHarnessSubagentSpawn(
 		};
 	}
 
-	if ((params.tasks?.length ?? 0) > 1 && mutating.length > 1) {
+	const parallelEvalAdversary =
+		(params.tasks?.length ?? 0) === 2 &&
+		params.tasks?.some((t) => t.agent === "harness/evaluator") &&
+		params.tasks?.some((t) => t.agent === "harness/adversary") &&
+		phase === "evaluate";
+
+	if (
+		(params.tasks?.length ?? 0) > 1 &&
+		mutating.length > 1 &&
+		!parallelEvalAdversary
+	) {
 		return {
 			ok: false,
 			message:
@@ -76,12 +95,19 @@ export function precheckHarnessSubagentSpawn(
 		};
 	}
 
+	const parallelTaskCount = params.tasks?.length ?? (params.agent ? 1 : 0);
+	const topology = await validateHarnessSpawnTopology(names, phase, {
+		parallelTaskCount,
+		projectRoot: opts?.projectRoot,
+		runId: opts?.runId,
+	});
+	if (!topology.ok) {
+		return topology;
+	}
+
 	for (const name of names) {
 		if (!name.startsWith("harness/")) continue;
-		const kind = classifyHarnessAgent(name);
-		if (kind === "planner" && phase !== "plan") {
-			// allowed — planning agents can run in plan only ideally
-		}
+		classifyHarnessAgent(name);
 	}
 
 	return { ok: true };

package/.pi/extensions/lib/harness-subagent-submit-pipeline.ts

@@ -2,8 +2,8 @@
  * Shared write pipeline for harness subagent submit tools.
  */
 
-import { mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { mkdir, readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
 import { validateAgainstHarnessSchema } from "../../lib/harness-schema-validate.js";
 import { resolveGuardedRunDir } from "../../lib/harness-subagent-submit-path.js";
 import { writeYamlFile } from "../../lib/harness-yaml.js";
@@ -24,6 +24,54 @@ export interface SubmitPipelineResult {
 	human_required?: boolean;
 }
 
+export async function loadSubmitDocument(opts: {
+	projectRoot: string;
+	runDir: string;
+	document?: Record<string, unknown>;
+	source_path?: string;
+}): Promise<
+	| { ok: true; document: Record<string, unknown> }
+	| { ok: false; validation_errors: string[] }
+> {
+	if (opts.document && typeof opts.document === "object") {
+		return { ok: true, document: opts.document };
+	}
+	const rel = opts.source_path?.trim();
+	if (!rel) {
+		return {
+			ok: false,
+			validation_errors: ["submit_* requires document or source_path"],
+		};
+	}
+	const abs = resolve(opts.runDir, rel.replace(/^\//, ""));
+	if (!abs.startsWith(resolve(opts.runDir))) {
+		return {
+			ok: false,
+			validation_errors: [
+				"source_path must stay under the active run directory",
+			],
+		};
+	}
+	try {
+		const raw = await readFile(abs, "utf-8");
+		const { parse } = await import("yaml");
+		const doc = parse(raw) as Record<string, unknown>;
+		if (!doc || typeof doc !== "object") {
+			return {
+				ok: false,
+				validation_errors: ["source_path did not parse to an object"],
+			};
+		}
+		return { ok: true, document: doc };
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		return {
+			ok: false,
+			validation_errors: [`source_path read failed: ${msg}`],
+		};
+	}
+}
+
 export async function executeSubmitPipeline(opts: {
 	projectRoot: string;
 	specsDir: string;
@@ -56,6 +104,22 @@ export async function executeSubmitPipeline(opts: {
 	await mkdir(dirname(absPath), { recursive: true });
 	await writeYamlFile(absPath, opts.document);
 
+	if (opts.spec.toolName === "submit_executor_handoff") {
+		const rollback = opts.document.rollback_refs;
+		if (rollback && typeof rollback === "object" && !Array.isArray(rollback)) {
+			const rollbackPath = join(
+				runResolved.runDir,
+				"artifacts",
+				"executor-rollback.yaml",
+			);
+			await mkdir(dirname(rollbackPath), { recursive: true });
+			await writeYamlFile(rollbackPath, {
+				schema_version: "1.0.0",
+				...(rollback as Record<string, unknown>),
+			});
+		}
+	}
+
 	let laneResult: ApplyDebateLaneResult | undefined;
 	if (opts.spec.debateLane) {
 		laneResult = await applyDebateLaneFromDoc({

package/.pi/extensions/lib/harness-subagent-submit-registry.ts

@@ -22,6 +22,12 @@ function roundPath(prefix: string, doc: Record<string, unknown>): string {
 }
 
 export const SUBMIT_TOOL_SPECS: readonly SubmitToolSpec[] = [
+	{
+		toolName: "submit_planning_context",
+		agents: ["harness/planning/planning-context"],
+		schemaFile: "plan-planning-context.schema.json",
+		artifactPath: "artifacts/planning-context.yaml",
+	},
 	{
 		toolName: "submit_scout_findings",
 		agents: [
@@ -42,13 +48,16 @@ export const SUBMIT_TOOL_SPECS: readonly SubmitToolSpec[] = [
 	},
 	{
 		toolName: "submit_decomposition_brief",
-		agents: ["harness/planning/decompose"],
+		agents: ["harness/planning/decompose", "harness/planning/plan-synthesizer"],
 		schemaFile: "plan-decomposition-brief.schema.json",
 		artifactPath: "artifacts/decomposition.yaml",
 	},
 	{
 		toolName: "submit_hypothesis_brief",
-		agents: ["harness/planning/hypothesis"],
+		agents: [
+			"harness/planning/hypothesis",
+			"harness/planning/plan-synthesizer",
+		],
 		schemaFile: "plan-hypothesis-brief.schema.json",
 		artifactPath: "artifacts/hypothesis.yaml",
 	},
@@ -66,7 +75,10 @@ export const SUBMIT_TOOL_SPECS: readonly SubmitToolSpec[] = [
 	},
 	{
 		toolName: "submit_execution_plan_brief",
-		agents: ["harness/planning/execution-plan-author"],
+		agents: [
+			"harness/planning/execution-plan-author",
+			"harness/planning/plan-synthesizer",
+		],
 		schemaFile: "plan-execution-plan-brief.schema.json",
 		artifactPath: "artifacts/execution-plan-draft.yaml",
 	},
@@ -129,6 +141,12 @@ export const SUBMIT_TOOL_SPECS: readonly SubmitToolSpec[] = [
 		artifactPath: "artifacts/human-required.yaml",
 		humanRequired: true,
 	},
+	{
+		toolName: "submit_sentrux_manifest_proposal",
+		agents: ["harness/sentrux-steward"],
+		schemaFile: "sentrux-manifest-proposal.schema.json",
+		artifactPath: "artifacts/sentrux-manifest-proposal.yaml",
+	},
 ] as const;
 
 export const SUBMIT_TOOLS_BY_AGENT: Readonly<

package/.pi/extensions/lib/harness-subagents-bridge.ts

@@ -13,6 +13,11 @@ import {
 	type HarnessSubagentsOptions,
 	type SpawnAuthForward,
 } from "../../../vendor/pi-subagents/src/subagents.js";
+import {
+	getLatestRunContext,
+	getRunIdFromSession,
+	type HarnessPhase,
+} from "../../lib/harness-run-context.js";
 import { parseSpawnContextFromTask } from "../../lib/harness-spawn-parse.js";
 import { harnessSubagentSubmitExtensionPath } from "../harness-subagent-submit.js";
 import { refreshHarnessCocoindexIndex } from "./harness-cocoindex-refresh.js";
@@ -35,6 +40,51 @@ import {
 
 const spawnBudget = createSpawnBudgetState();
 let lastSessionId = "harness";
+let spawnGroupCounter = 0;
+type PendingSpawnTelemetry = {
+	harness_run_id: string;
+	run_id: string;
+	harness_plan_id: string;
+	harness_phase: HarnessPhase;
+	agent_ids: string[];
+	spawn_group_id: string;
+};
+let pendingSpawnTelemetry: PendingSpawnTelemetry | null = null;
+
+function collectHarnessAgentIds(params: Record<string, unknown>): string[] {
+	const out = new Set<string>();
+	const maybe = params as {
+		agent?: string;
+		chain?: Array<{ agent?: string }>;
+		tasks?: Array<{ agent?: string }>;
+		aggregator?: { agent?: string };
+	};
+	if (typeof maybe.agent === "string" && maybe.agent.startsWith("harness/")) {
+		out.add(maybe.agent);
+	}
+	for (const item of maybe.chain ?? []) {
+		if (typeof item?.agent === "string" && item.agent.startsWith("harness/")) {
+			out.add(item.agent);
+		}
+	}
+	for (const item of maybe.tasks ?? []) {
+		if (typeof item?.agent === "string" && item.agent.startsWith("harness/")) {
+			out.add(item.agent);
+		}
+	}
+	if (
+		typeof maybe.aggregator?.agent === "string" &&
+		maybe.aggregator.agent.startsWith("harness/")
+	) {
+		out.add(maybe.aggregator.agent);
+	}
+	return Array.from(out.values()).sort();
+}
+
+function nextSpawnGroupId(sessionId: string): string {
+	spawnGroupCounter += 1;
+	return `${sessionId}-${Date.now()}-${spawnGroupCounter}`;
+}
 
 async function resolveHarnessSpawnAuth(
 	ctx: ExtensionContext,
@@ -68,32 +118,6 @@ export function createHarnessSubagentsExtension(
 		resolveSubprocessEnv: (task, agent) => {
 			if (!agent.name.startsWith("harness/")) return undefined;
 			const ctx = parseSpawnContextFromTask(task);
-			// #region agent log
-			fetch(
-				"http://127.0.0.1:7928/ingest/a5d40896-34cb-4f12-97db-df7ada0b22f0",
-				{
-					method: "POST",
-					headers: {
-						"Content-Type": "application/json",
-						"X-Debug-Session-Id": "2ca12b",
-					},
-					body: JSON.stringify({
-						sessionId: "2ca12b",
-						hypothesisId: "H1",
-						location: "harness-subagents-bridge.ts:resolveSubprocessEnv",
-						message: "parsed spawn context for subprocess env",
-						data: {
-							agent: agent.name,
-							hasCtx: Boolean(ctx?.run_id),
-							run_id: ctx?.run_id ?? null,
-							run_dir: ctx?.run_dir ?? null,
-							taskPrefix: task.slice(0, 160),
-						},
-						timestamp: Date.now(),
-					}),
-				},
-			).catch(() => {});
-			// #endregion
 			if (!ctx?.run_id) return undefined;
 			return {
 				HARNESS_RUN_ID: ctx.run_id,
@@ -111,16 +135,23 @@ export function createHarnessSubagentsExtension(
 			const { harnessCount } = countHarnessAgentsInRequest(
 				params as Parameters<typeof countHarnessAgentsInRequest>[0],
 			);
+			pendingSpawnTelemetry = null;
 			if (harnessCount > 0) {
 				const budget = checkHarnessSpawnBudget(spawnBudget, harnessCount);
 				if (!budget.ok) {
 					return { ok: false, message: budget.message };
 				}
-				const phase = inferPhaseForPrecheck(ctx.sessionManager.getEntries());
-				const pre = precheckHarnessSubagentSpawn(
+				const entries = ctx.sessionManager.getEntries();
+				const runCtx = getLatestRunContext(entries);
+				const phase = inferPhaseForPrecheck(entries);
+				const pre = await precheckHarnessSubagentSpawn(
 					params as Parameters<typeof precheckHarnessSubagentSpawn>[0],
 					agents,
 					phase,
+					{
+						projectRoot: ctx.cwd,
+						runId: runCtx?.run_id ?? null,
+					},
 				);
 				if (!pre.ok) {
 					return { ok: false, message: pre.message };
@@ -133,6 +164,18 @@ export function createHarnessSubagentsExtension(
 						return { ok: false, message: refreshMsg };
 					}
 				}
+				const runId =
+					runCtx?.run_id ??
+					getRunIdFromSession(entries, lastSessionId) ??
+					lastSessionId;
+				pendingSpawnTelemetry = {
+					harness_run_id: runId,
+					run_id: runId,
+					harness_plan_id: runCtx?.plan_id ?? "plan-unknown",
+					harness_phase: phase,
+					agent_ids: collectHarnessAgentIds(params as Record<string, unknown>),
+					spawn_group_id: nextSpawnGroupId(lastSessionId),
+				};
 			}
 			return { ok: true };
 		},
@@ -142,6 +185,16 @@ export function createHarnessSubagentsExtension(
 			captureHarnessEvent(lastSessionId, "harness_subagent_spawned", {
 				active_after: spawnBudget.active,
 				spawn_count: harnessCount,
+				harness_run_id: pendingSpawnTelemetry?.harness_run_id ?? lastSessionId,
+				run_id: pendingSpawnTelemetry?.run_id ?? lastSessionId,
+				harness_plan_id:
+					pendingSpawnTelemetry?.harness_plan_id ?? "plan-unknown",
+				harness_phase: pendingSpawnTelemetry?.harness_phase ?? "plan",
+				agent_ids: pendingSpawnTelemetry?.agent_ids ?? [],
+				agent_count: pendingSpawnTelemetry?.agent_ids.length ?? harnessCount,
+				spawn_group_id:
+					pendingSpawnTelemetry?.spawn_group_id ??
+					nextSpawnGroupId(lastSessionId),
 			});
 		},
 		onSpawnEnd: (harnessCount) => {
@@ -154,7 +207,17 @@ export function createHarnessSubagentsExtension(
 				mode,
 				duration_ms: durationMs,
 				agent_count: agents.length,
+				agent_ids: agents,
+				harness_run_id: pendingSpawnTelemetry?.harness_run_id ?? lastSessionId,
+				run_id: pendingSpawnTelemetry?.run_id ?? lastSessionId,
+				harness_plan_id:
+					pendingSpawnTelemetry?.harness_plan_id ?? "plan-unknown",
+				harness_phase: pendingSpawnTelemetry?.harness_phase ?? "plan",
+				spawn_group_id:
+					pendingSpawnTelemetry?.spawn_group_id ??
+					nextSpawnGroupId(lastSessionId),
 			});
+			pendingSpawnTelemetry = null;
 		},
 	};