open-multi-agent-kit 0.90.9 → 0.92.0

package/examples/extensions/subagent/deadline-budget.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "vitest";
+import {
+	allocateAttemptBudget,
+	createExecutionBudget,
+	estimateTaskDemand,
+	getDeadlineProfile,
+	planTaskShards,
+	recommendAttemptCutoff,
+	remainingExecutionMs,
+	updateDeadlineProfiles,
+} from "./deadline-budget.ts";
+
+describe("subagent dual budget planning", () => {
+	it("shards an explicit action list when token and wall-clock demand exceed one attempt", () => {
+		const task = [
+			"Upgrade the runtime:",
+			"1. Inspect the provider boundary.",
+			"2. Add typed deadline metadata.",
+			"3. Implement checkpoint persistence.",
+			"4. Add bounded resume prompts.",
+			"5. Run fixture tests.",
+			"6. Review process cleanup.",
+		].join("\n");
+		const demand = estimateTaskDemand(task);
+		const shards = planTaskShards(task, demand, {
+			attemptCutoffMs: 180_000,
+			maxTaskShards: 3,
+			maxTokensPerShard: 40,
+		});
+
+		expect(demand.workUnits).toBeGreaterThanOrEqual(6);
+		expect(shards).toHaveLength(3);
+		expect(shards.flatMap((shard) => shard.units)).toEqual([
+			"Inspect the provider boundary.",
+			"Add typed deadline metadata.",
+			"Implement checkpoint persistence.",
+			"Add bounded resume prompts.",
+			"Run fixture tests.",
+			"Review process cleanup.",
+		]);
+		expect(shards.every((shard) => shard.task.includes("Do only this execution shard"))).toBe(true);
+	});
+
+	it("recognizes explicit CJK numbered actions without relying on English verbs", () => {
+		const task = [
+			"런타임 업그레이드:",
+			"1. 프로세스 경계를 분석한다.",
+			"2. 체크포인트 재개를 구현한다.",
+			"3. fixture 테스트를 실행한다.",
+		].join("\n");
+		const demand = estimateTaskDemand(task);
+		const shards = planTaskShards(task, demand, {
+			attemptCutoffMs: 100_000,
+			maxTaskShards: 3,
+			maxTokensPerShard: 20,
+		});
+
+		expect(demand.actionUnits).toEqual([
+			"프로세스 경계를 분석한다.",
+			"체크포인트 재개를 구현한다.",
+			"fixture 테스트를 실행한다.",
+		]);
+		expect(shards.length).toBeGreaterThan(1);
+	});
+
+	it("keeps an indivisible task as one shard even when it is expensive", () => {
+		const task = "Investigate and fix the runtime without repeating completed side effects.";
+		const demand = estimateTaskDemand(task);
+		const shards = planTaskShards(task, demand, {
+			attemptCutoffMs: 1,
+			maxTaskShards: 3,
+			maxTokensPerShard: 1,
+		});
+
+		expect(shards).toEqual([{ id: "shard-1", index: 0, task, units: [task] }]);
+	});
+
+	it("reserves cleanup time and divides a sequential deadline among pending work", () => {
+		const budget = createExecutionBudget({
+			nowMs: 1_000,
+			hardDeadlineMs: 900,
+			cleanupReserveMs: 100,
+			maxResumeAttempts: 1,
+			maxTaskShards: 3,
+		});
+
+		expect(remainingExecutionMs(budget, 1_250)).toBe(650);
+		expect(
+			allocateAttemptBudget({
+				budget,
+				nowMs: 1_250,
+				pendingSequentialTasks: 2,
+				pendingShards: 1,
+				recommendedCutoffMs: 1_000,
+				minimumAttemptMs: 1,
+			}),
+		).toEqual({ cutoffMs: 275, taskDeadlineAtMs: 1_525, usableMs: 550 });
+	});
+});
+
+describe("provider/model deadline learning", () => {
+	it("learns completion and cutoff history independently per provider and model", () => {
+		let db = updateDeadlineProfiles(undefined, {
+			provider: "openai-codex",
+			model: "gpt-5.6",
+			outcome: "completed",
+			elapsedMs: 120_000,
+			estimatedTokens: 2_000,
+			workUnits: 2,
+		});
+		db = updateDeadlineProfiles(db, {
+			provider: "openai-codex",
+			model: "gpt-5.6",
+			outcome: "cutoff",
+			elapsedMs: 600_000,
+			estimatedTokens: 2_000,
+			workUnits: 2,
+		});
+		db = updateDeadlineProfiles(db, {
+			provider: "anthropic",
+			model: "claude-sonnet",
+			outcome: "completed",
+			elapsedMs: 40_000,
+			estimatedTokens: 500,
+			workUnits: 1,
+		});
+
+		const codex = getDeadlineProfile(db, "openai-codex", "gpt-5.6");
+		const anthropic = getDeadlineProfile(db, "anthropic", "claude-sonnet");
+		expect(codex).toMatchObject({ samples: 2, completions: 1, cutoffs: 1 });
+		expect(anthropic).toMatchObject({ samples: 1, completions: 1, cutoffs: 0 });
+		expect(recommendAttemptCutoff(codex, { fallbackMs: 600_000, minimumMs: 1, maximumMs: 800_000 })).toBe(180_000);
+		expect(recommendAttemptCutoff(anthropic, { fallbackMs: 600_000, minimumMs: 1, maximumMs: 800_000 })).toBe(60_000);
+	});
+});

package/examples/extensions/subagent/deadline-budget.ts

@@ -0,0 +1,242 @@
+export type DeadlineSampleOutcome = "completed" | "cutoff" | "aborted" | "failed";
+
+export interface TaskDemand {
+	readonly estimatedTokens: number;
+	readonly workUnits: number;
+	readonly predictedMs: number;
+	readonly actionUnits: readonly string[];
+}
+
+export interface TaskShard {
+	readonly id: string;
+	readonly index: number;
+	readonly task: string;
+	readonly units: readonly string[];
+}
+
+export interface ExecutionBudget {
+	readonly startedAtMs: number;
+	readonly hardDeadlineMs: number;
+	readonly deadlineAtMs: number;
+	readonly cleanupReserveMs: number;
+	readonly maxResumeAttempts: number;
+	readonly maxTaskShards: number;
+}
+
+export interface DeadlineProfileSample {
+	readonly provider: string;
+	readonly model: string;
+	readonly outcome: DeadlineSampleOutcome;
+	readonly elapsedMs: number;
+	readonly estimatedTokens: number;
+	readonly workUnits: number;
+}
+
+export interface DeadlineProfile {
+	readonly provider: string;
+	readonly model: string;
+	readonly samples: number;
+	readonly completions: number;
+	readonly cutoffs: number;
+	readonly aborts: number;
+	readonly failures: number;
+	readonly ewmaElapsedMs: number;
+	readonly ewmaMsPerWorkUnit: number;
+	readonly completedDurationsMs: readonly number[];
+	readonly cutoffDurationsMs: readonly number[];
+}
+
+export interface DeadlineProfileDb {
+	readonly version: 1;
+	readonly profiles: Readonly<Record<string, DeadlineProfile>>;
+}
+
+interface CreateExecutionBudgetOptions {
+	readonly nowMs?: number;
+	readonly hardDeadlineMs: number;
+	readonly cleanupReserveMs: number;
+	readonly maxResumeAttempts: number;
+	readonly maxTaskShards: number;
+}
+
+interface PlanTaskShardsOptions {
+	readonly attemptCutoffMs: number;
+	readonly maxTaskShards: number;
+	readonly maxTokensPerShard: number;
+}
+
+interface AllocateAttemptBudgetOptions {
+	readonly budget: ExecutionBudget;
+	readonly nowMs?: number;
+	readonly pendingSequentialTasks: number;
+	readonly pendingShards: number;
+	readonly recommendedCutoffMs: number;
+	readonly minimumAttemptMs: number;
+}
+
+interface RecommendCutoffOptions {
+	readonly fallbackMs: number;
+	readonly minimumMs: number;
+	readonly maximumMs: number;
+}
+
+const EXPLICIT_ACTION_LINE = /^\s*(?:\d+[.)]|\[[ xX]\])\s+(.+?)\s*$/;
+const BULLET_ACTION_LINE = /^\s*[-*+]\s+(.+?)\s*$/;
+const ACTION_VERB =
+	/^(?:inspect|add|implement|create|fix|test|run|review|analy[sz]e|verify|update|refactor|migrate|remove|investigate|write|read|document|build|check)\b/i;
+const MAX_PROFILE_SAMPLES = 24;
+const PROFILE_ALPHA = 0.25;
+
+export function estimateTokens(text: string): number {
+	return Math.max(1, Math.ceil(Buffer.byteLength(text, "utf8") / 4));
+}
+
+export function estimateTaskDemand(task: string): TaskDemand {
+	const actionUnits = task
+		.split(/\r?\n/)
+		.map(extractActionUnit)
+		.filter((line): line is string => line !== undefined);
+	const estimatedTokens = estimateTokens(task);
+	const pathSignals = new Set(task.match(/(?:\.?\.?\/)?[\w.-]+(?:\/[\w.-]+)+/g) ?? []).size;
+	const verificationSignals = (task.match(/\b(?:test|typecheck|build|lint|review|verify)\b/gi) ?? []).length;
+	const workUnits = Math.max(1, actionUnits.length, Math.min(12, pathSignals + verificationSignals));
+	const predictedMs = 45_000 + workUnits * 75_000 + Math.min(120_000, estimatedTokens * 20);
+	return { estimatedTokens, workUnits, predictedMs, actionUnits };
+}
+
+export function planTaskShards(task: string, demand: TaskDemand, options: PlanTaskShardsOptions): TaskShard[] {
+	if (demand.actionUnits.length < 2) return [{ id: "shard-1", index: 0, task, units: [task] }];
+	const tokenShards = Math.ceil(demand.estimatedTokens / Math.max(1, options.maxTokensPerShard));
+	const timeShards = Math.ceil(demand.predictedMs / Math.max(1, options.attemptCutoffMs));
+	const shardCount = Math.min(options.maxTaskShards, demand.actionUnits.length, Math.max(1, tokenShards, timeShards));
+	if (shardCount === 1) return [{ id: "shard-1", index: 0, task, units: demand.actionUnits }];
+
+	const shards: TaskShard[] = [];
+	for (let index = 0; index < shardCount; index++) {
+		const start = Math.floor((index * demand.actionUnits.length) / shardCount);
+		const end = Math.floor(((index + 1) * demand.actionUnits.length) / shardCount);
+		const units = demand.actionUnits.slice(start, end);
+		const current = units.map((unit, unitIndex) => `${unitIndex + 1}. ${unit}`).join("\n");
+		shards.push({
+			id: `shard-${index + 1}`,
+			index,
+			units,
+			task: [
+				"Original task context:",
+				task,
+				"",
+				`Do only this execution shard (${index + 1}/${shardCount}):`,
+				current,
+				"Do not execute later shards; leave them for the runtime scheduler.",
+			].join("\n"),
+		});
+	}
+	return shards;
+}
+
+export function createExecutionBudget(options: CreateExecutionBudgetOptions): ExecutionBudget {
+	const startedAtMs = options.nowMs ?? Date.now();
+	const hardDeadlineMs = Math.max(1, Math.floor(options.hardDeadlineMs));
+	return {
+		startedAtMs,
+		hardDeadlineMs,
+		deadlineAtMs: startedAtMs + hardDeadlineMs,
+		cleanupReserveMs: Math.max(0, Math.floor(options.cleanupReserveMs)),
+		maxResumeAttempts: Math.max(0, Math.floor(options.maxResumeAttempts)),
+		maxTaskShards: Math.max(1, Math.floor(options.maxTaskShards)),
+	};
+}
+
+export function remainingExecutionMs(budget: ExecutionBudget, nowMs = Date.now()): number {
+	return Math.max(0, budget.deadlineAtMs - nowMs);
+}
+
+export function allocateAttemptBudget(options: AllocateAttemptBudgetOptions): {
+	readonly cutoffMs: number;
+	readonly taskDeadlineAtMs: number;
+	readonly usableMs: number;
+} {
+	const nowMs = options.nowMs ?? Date.now();
+	const usableMs = Math.max(0, remainingExecutionMs(options.budget, nowMs) - options.budget.cleanupReserveMs);
+	const taskShareMs = Math.floor(usableMs / Math.max(1, options.pendingSequentialTasks));
+	const shardShareMs = Math.floor(taskShareMs / Math.max(1, options.pendingShards));
+	const cutoffMs = Math.max(0, Math.min(options.recommendedCutoffMs, shardShareMs));
+	return {
+		cutoffMs: cutoffMs >= options.minimumAttemptMs ? cutoffMs : 0,
+		taskDeadlineAtMs: nowMs + taskShareMs,
+		usableMs,
+	};
+}
+
+export function profileKey(provider: string, model: string): string {
+	return `${provider.trim() || "unknown"}/${model.trim() || "default"}`;
+}
+
+export function getDeadlineProfile(
+	db: DeadlineProfileDb | undefined,
+	provider: string,
+	model: string,
+): DeadlineProfile | undefined {
+	return db?.profiles[profileKey(provider, model)];
+}
+
+export function updateDeadlineProfiles(
+	db: DeadlineProfileDb | undefined,
+	sample: DeadlineProfileSample,
+): DeadlineProfileDb {
+	const key = profileKey(sample.provider, sample.model);
+	const previous = db?.profiles[key];
+	const elapsedMs = Math.max(1, Math.floor(sample.elapsedMs));
+	const workUnits = Math.max(1, sample.workUnits);
+	const next: DeadlineProfile = {
+		provider: sample.provider,
+		model: sample.model,
+		samples: (previous?.samples ?? 0) + 1,
+		completions: (previous?.completions ?? 0) + Number(sample.outcome === "completed"),
+		cutoffs: (previous?.cutoffs ?? 0) + Number(sample.outcome === "cutoff"),
+		aborts: (previous?.aborts ?? 0) + Number(sample.outcome === "aborted"),
+		failures: (previous?.failures ?? 0) + Number(sample.outcome === "failed"),
+		ewmaElapsedMs: ewma(previous?.ewmaElapsedMs, elapsedMs),
+		ewmaMsPerWorkUnit: ewma(previous?.ewmaMsPerWorkUnit, elapsedMs / workUnits),
+		completedDurationsMs: appendBounded(
+			previous?.completedDurationsMs,
+			sample.outcome === "completed" ? elapsedMs : undefined,
+		),
+		cutoffDurationsMs: appendBounded(
+			previous?.cutoffDurationsMs,
+			sample.outcome === "cutoff" ? elapsedMs : undefined,
+		),
+	};
+	return { version: 1, profiles: { ...(db?.profiles ?? {}), [key]: next } };
+}
+
+export function recommendAttemptCutoff(profile: DeadlineProfile | undefined, options: RecommendCutoffOptions): number {
+	const completed = percentile(profile?.completedDurationsMs ?? [], 0.9);
+	const cutoff = percentile(profile?.cutoffDurationsMs ?? [], 0.25);
+	const candidates = [options.fallbackMs];
+	if (completed !== undefined) candidates.push(Math.round(completed * 1.5));
+	if (cutoff !== undefined) candidates.push(Math.round(cutoff * 0.75));
+	return Math.max(options.minimumMs, Math.min(options.maximumMs, ...candidates));
+}
+
+function extractActionUnit(line: string): string | undefined {
+	const explicit = line.match(EXPLICIT_ACTION_LINE)?.[1]?.trim();
+	if (explicit) return explicit;
+	const bullet = line.match(BULLET_ACTION_LINE)?.[1]?.trim();
+	return bullet && ACTION_VERB.test(bullet) ? bullet : undefined;
+}
+
+function ewma(previous: number | undefined, value: number): number {
+	return Math.round(previous === undefined ? value : previous * (1 - PROFILE_ALPHA) + value * PROFILE_ALPHA);
+}
+
+function appendBounded(previous: readonly number[] | undefined, value: number | undefined): number[] {
+	if (value === undefined) return [...(previous ?? [])];
+	return [...(previous ?? []), value].slice(-MAX_PROFILE_SAMPLES);
+}
+
+function percentile(values: readonly number[], ratio: number): number | undefined {
+	if (values.length === 0) return undefined;
+	const sorted = [...values].sort((left, right) => left - right);
+	return sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * ratio))];
+}

package/examples/extensions/subagent/deadline-profile-store.test.ts

@@ -0,0 +1,72 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { DeadlineProfileStore } from "./deadline-profile-store.ts";
+
+const cleanupPaths: string[] = [];
+
+afterEach(async () => {
+	await Promise.all(cleanupPaths.splice(0).map((entry) => fs.promises.rm(entry, { force: true, recursive: true })));
+});
+
+describe("DeadlineProfileStore", () => {
+	it("persists provider/model cutoff history across dispatcher processes", async () => {
+		const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omk-deadline-profile-"));
+		cleanupPaths.push(dir);
+		const filePath = path.join(dir, "profiles.json");
+		const first = new DeadlineProfileStore(filePath);
+		await first.record({
+			provider: "openai-codex",
+			model: "gpt-5.6",
+			outcome: "cutoff",
+			elapsedMs: 500,
+			estimatedTokens: 100,
+			workUnits: 2,
+		});
+
+		const reloaded = new DeadlineProfileStore(filePath);
+		expect(await reloaded.profileFor("openai-codex", "gpt-5.6")).toMatchObject({ samples: 1, cutoffs: 1 });
+	});
+
+	it("serializes concurrent samples without losing updates", async () => {
+		const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omk-deadline-concurrent-"));
+		cleanupPaths.push(dir);
+		const filePath = path.join(dir, "profiles.json");
+		const stores = [new DeadlineProfileStore(filePath), new DeadlineProfileStore(filePath)];
+		await Promise.all(
+			Array.from({ length: 8 }, (_, index) =>
+				stores[index % stores.length].record({
+					provider: "anthropic",
+					model: "claude-sonnet",
+					outcome: "completed",
+					elapsedMs: 100 + index,
+					estimatedTokens: 10,
+					workUnits: 1,
+				}),
+			),
+		);
+
+		const reloaded = new DeadlineProfileStore(filePath);
+		expect(await reloaded.profileFor("anthropic", "claude-sonnet")).toMatchObject({ samples: 8, completions: 8 });
+	});
+
+	it("recovers from malformed history without exposing untyped data", async () => {
+		const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omk-deadline-corrupt-"));
+		cleanupPaths.push(dir);
+		const filePath = path.join(dir, "profiles.json");
+		await fs.promises.writeFile(filePath, "{not-json", "utf8");
+		const store = new DeadlineProfileStore(filePath);
+
+		expect(await store.profileFor("unknown", "default")).toBeUndefined();
+		await store.record({
+			provider: "unknown",
+			model: "default",
+			outcome: "failed",
+			elapsedMs: 20,
+			estimatedTokens: 5,
+			workUnits: 1,
+		});
+		expect(JSON.parse(await fs.promises.readFile(filePath, "utf8"))).toMatchObject({ version: 1 });
+	});
+});

package/examples/extensions/subagent/deadline-profile-store.ts

@@ -0,0 +1,172 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+	type DeadlineProfile,
+	type DeadlineProfileDb,
+	type DeadlineProfileSample,
+	getDeadlineProfile,
+	updateDeadlineProfiles,
+} from "./deadline-budget.ts";
+
+const MAX_PROFILE_FILE_BYTES = 1024 * 1024;
+const MAX_PROFILE_ENTRIES = 1_000;
+const LOCK_RETRY_COUNT = 200;
+const LOCK_RETRY_MS = 10;
+const STALE_LOCK_MS = 30_000;
+
+export class DeadlineProfileLockError extends Error {
+	constructor(filePath: string) {
+		super(`Timed out acquiring deadline profile lock for ${filePath}`);
+		this.name = "DeadlineProfileLockError";
+	}
+}
+
+export class DeadlineProfileStore {
+	private readonly filePath: string;
+	private db: DeadlineProfileDb = emptyDb();
+	private mutationTail: Promise<void> = Promise.resolve();
+
+	constructor(filePath: string) {
+		this.filePath = filePath;
+	}
+
+	async profileFor(provider: string, model: string): Promise<DeadlineProfile | undefined> {
+		await this.mutationTail;
+		this.db = await readDb(this.filePath);
+		return getDeadlineProfile(this.db, provider, model);
+	}
+
+	async record(sample: DeadlineProfileSample): Promise<DeadlineProfile> {
+		let recorded: DeadlineProfile | undefined;
+		const operation = this.mutationTail.then(async () => {
+			await withProfileLock(this.filePath, async () => {
+				this.db = updateDeadlineProfiles(await readDb(this.filePath), sample);
+				recorded = getDeadlineProfile(this.db, sample.provider, sample.model);
+				if (recorded === undefined) throw new Error("Deadline profile update did not produce a profile");
+				await writeAtomically(this.filePath, JSON.stringify(this.db));
+			});
+		});
+		this.mutationTail = operation.catch(() => undefined);
+		await operation;
+		if (recorded === undefined) throw new Error("Deadline profile update did not complete");
+		return recorded;
+	}
+}
+
+async function withProfileLock<T>(filePath: string, operation: () => Promise<T>): Promise<T> {
+	const lockPath = `${filePath}.lock`;
+	await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+	for (let attempt = 0; attempt < LOCK_RETRY_COUNT; attempt++) {
+		try {
+			await fs.promises.mkdir(lockPath);
+			try {
+				return await operation();
+			} finally {
+				await fs.promises.rm(lockPath, { recursive: true, force: true });
+			}
+		} catch (error) {
+			if (!isAlreadyExists(error)) throw error;
+			await removeStaleLock(lockPath);
+			await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+		}
+	}
+	throw new DeadlineProfileLockError(filePath);
+}
+
+async function removeStaleLock(lockPath: string): Promise<void> {
+	try {
+		const stats = await fs.promises.stat(lockPath);
+		if (Date.now() - stats.mtimeMs > STALE_LOCK_MS) {
+			await fs.promises.rm(lockPath, { recursive: true, force: true });
+		}
+	} catch {
+		return;
+	}
+}
+
+function isAlreadyExists(error: unknown): boolean {
+	return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+
+async function readDb(filePath: string): Promise<DeadlineProfileDb> {
+	try {
+		const handle = await fs.promises.open(filePath, "r");
+		try {
+			const stats = await handle.stat();
+			if (stats.size > MAX_PROFILE_FILE_BYTES) return emptyDb();
+			return parseDb(JSON.parse(await handle.readFile("utf8")));
+		} finally {
+			await handle.close();
+		}
+	} catch {
+		return emptyDb();
+	}
+}
+
+async function writeAtomically(filePath: string, content: string): Promise<void> {
+	await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+	const tempPath = `${filePath}.${process.pid}.${process.hrtime.bigint()}.tmp`;
+	try {
+		await fs.promises.writeFile(tempPath, content, { encoding: "utf8", mode: 0o600 });
+		await fs.promises.rename(tempPath, filePath);
+	} finally {
+		await fs.promises.rm(tempPath, { force: true });
+	}
+}
+
+function parseDb(value: unknown): DeadlineProfileDb {
+	if (!isRecord(value) || value.version !== 1 || !isRecord(value.profiles)) return emptyDb();
+	const profiles: Record<string, DeadlineProfile> = Object.create(null);
+	for (const [key, raw] of Object.entries(value.profiles).slice(0, MAX_PROFILE_ENTRIES)) {
+		const parsed = parseProfile(raw);
+		if (parsed !== undefined) profiles[key] = parsed;
+	}
+	return { version: 1, profiles };
+}
+
+function parseProfile(value: unknown): DeadlineProfile | undefined {
+	if (!isRecord(value) || typeof value.provider !== "string" || typeof value.model !== "string") return undefined;
+	const samples = readCount(value.samples);
+	const completions = readCount(value.completions);
+	const cutoffs = readCount(value.cutoffs);
+	const aborts = readCount(value.aborts);
+	const failures = readCount(value.failures);
+	const ewmaElapsedMs = readCount(value.ewmaElapsedMs);
+	const ewmaMsPerWorkUnit = readCount(value.ewmaMsPerWorkUnit);
+	if ([samples, completions, cutoffs, aborts, failures, ewmaElapsedMs, ewmaMsPerWorkUnit].includes(undefined)) {
+		return undefined;
+	}
+	return {
+		provider: value.provider.slice(0, 256),
+		model: value.model.slice(0, 256),
+		samples: samples ?? 0,
+		completions: completions ?? 0,
+		cutoffs: cutoffs ?? 0,
+		aborts: aborts ?? 0,
+		failures: failures ?? 0,
+		ewmaElapsedMs: ewmaElapsedMs ?? 0,
+		ewmaMsPerWorkUnit: ewmaMsPerWorkUnit ?? 0,
+		completedDurationsMs: readDurations(value.completedDurationsMs),
+		cutoffDurationsMs: readDurations(value.cutoffDurationsMs),
+	};
+}
+
+function readCount(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : undefined;
+}
+
+function readDurations(value: unknown): number[] {
+	if (!Array.isArray(value)) return [];
+	return value
+		.map(readCount)
+		.filter((duration): duration is number => duration !== undefined && duration > 0)
+		.slice(-24);
+}
+
+function emptyDb(): DeadlineProfileDb {
+	return { version: 1, profiles: {} };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/examples/extensions/subagent/fixtures/fake-omk-json.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+process.stdout.write(
+	`${JSON.stringify({
+		type: "message_end",
+		message: {
+			role: "assistant",
+			content: [{ type: "text", text: "fixture subagent completed" }],
+			provider: "fixture-provider",
+			model: "fixture-model",
+		},
+	})}\n`,
+);

package/examples/extensions/subagent/fixtures/hanging-process-tree.mjs

@@ -0,0 +1,40 @@
+import { spawn } from "node:child_process";
+
+const normalOrphan = process.argv.includes("--normal-orphan");
+
+if (!process.argv.includes("--parent-exits") && !normalOrphan) {
+	process.on("SIGTERM", () => {
+		// Exercise the managed runner's SIGKILL escalation path.
+	});
+}
+
+// The grandchild ignores SIGTERM so the managed runner must escalate to
+// SIGKILL. It writes "ready" on its stdout (piped back to this parent) only
+// AFTER installing its SIGTERM handler. The parent waits for that signal
+// before exiting or settling into its keep-alive loop, so the runner never
+// signals the process group while the grandchild is still in its startup
+// window (a fresh `node -e` process needs ~50-100ms before its first JS line
+// runs). Without this handshake a SIGTERM can land before the handler is
+// installed, killing the grandchild via the default handler and making the
+// SIGKILL escalation (cleanup.killSent) a timing race.
+const grandchild = spawn(
+	process.execPath,
+	["-e", "process.on('SIGTERM', () => {}); process.stdout.write('ready'); setInterval(() => {}, 1000)"],
+	{
+		stdio: ["ignore", "pipe", "ignore"],
+	},
+);
+
+process.stdout.write(`${JSON.stringify({ grandchildPid: grandchild.pid })}\n`);
+
+const startMain = () => {
+	if (normalOrphan) setTimeout(() => process.exit(0), 20);
+	else setInterval(() => {}, 1000);
+};
+
+let started = false;
+grandchild.stdout.on("data", () => {
+	if (started) return;
+	started = true;
+	startMain();
+});