open-multi-agent-kit 0.91.0 → 0.93.0

package/examples/extensions/subagent/checkpoint-runtime.ts

@@ -0,0 +1,198 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface CheckpointWorkspace {
+	readonly dir: string;
+	readonly filePath: string;
+}
+
+export interface AgentCheckpoint {
+	readonly version: 1;
+	readonly completed: readonly string[];
+	readonly remaining: readonly string[];
+	readonly summary: string;
+	readonly artifacts: readonly string[];
+	readonly messageCount: number;
+	readonly outputTail: string;
+	readonly lastEventAtMs: number;
+}
+
+interface CheckpointEvidence {
+	readonly messageCount: number;
+	readonly outputTail: string;
+	readonly lastEventAtMs: number;
+}
+
+interface BuildCheckpointTaskOptions {
+	readonly originalTask: string;
+	readonly shardTask: string;
+	readonly shardId: string;
+	readonly shardIndex: number;
+	readonly shardCount: number;
+	readonly attempt: number;
+	readonly cutoffMs: number;
+	readonly checkpointFilePath: string;
+	readonly checkpoint?: AgentCheckpoint;
+}
+
+const CHECKPOINT_FILE_LIMIT = 32 * 1024;
+const MAX_LIST_ITEMS = 24;
+const MAX_ITEM_CHARS = 512;
+
+export async function createCheckpointWorkspace(prefix: string): Promise<CheckpointWorkspace> {
+	const dir = await fs.promises.mkdtemp(prefix);
+	const filePath = path.join(dir, "checkpoint.json");
+	await writeCheckpoint(filePath, createEmptyCheckpoint());
+	return { dir, filePath };
+}
+
+export async function removeCheckpointWorkspace(workspace: CheckpointWorkspace): Promise<void> {
+	await fs.promises.rm(workspace.dir, { recursive: true, force: true });
+}
+
+export async function writeCheckpoint(filePath: string, checkpoint: AgentCheckpoint): Promise<void> {
+	const serialized = JSON.stringify({
+		version: 1,
+		completed: checkpoint.completed,
+		remaining: checkpoint.remaining,
+		summary: checkpoint.summary,
+		artifacts: checkpoint.artifacts,
+	});
+	await fs.promises.writeFile(filePath, serialized, { encoding: "utf8", mode: 0o600 });
+}
+
+export async function readCheckpoint(filePath: string, evidence: CheckpointEvidence): Promise<AgentCheckpoint> {
+	let parsed: unknown;
+	try {
+		const pathStats = await fs.promises.lstat(filePath);
+		if (!pathStats.isFile() || pathStats.isSymbolicLink()) return withEvidence(createEmptyCheckpoint(), evidence);
+		const handle = await fs.promises.open(filePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+		try {
+			const stats = await handle.stat();
+			if (stats.size > CHECKPOINT_FILE_LIMIT) return withEvidence(createEmptyCheckpoint(), evidence);
+			parsed = JSON.parse(await handle.readFile("utf8"));
+		} finally {
+			await handle.close();
+		}
+	} catch {
+		return withEvidence(createEmptyCheckpoint(), evidence);
+	}
+	if (!isRecord(parsed) || parsed.version !== 1) return withEvidence(createEmptyCheckpoint(), evidence);
+	return withEvidence(
+		{
+			version: 1,
+			completed: readStringList(parsed.completed),
+			remaining: readStringList(parsed.remaining),
+			summary: readString(parsed.summary, 2_000),
+			artifacts: readStringList(parsed.artifacts),
+			messageCount: 0,
+			outputTail: "",
+			lastEventAtMs: 0,
+		},
+		evidence,
+	);
+}
+
+export function buildCheckpointTask(options: BuildCheckpointTaskOptions): string {
+	const prior = options.checkpoint;
+	const currentTask =
+		prior !== undefined && prior.remaining.length > 0
+			? [
+					"Only unresolved checkpoint units:",
+					...prior.remaining.map((unit, index) => `${index + 1}. ${boundedTail(unit, 512)}`),
+				].join("\n")
+			: boundedTail(options.shardTask, 3_500);
+	const priorSection = prior
+		? [
+				"Resume checkpoint:",
+				`- Completed: ${formatList(prior.completed)}`,
+				`- Remaining: ${formatList(prior.remaining)}`,
+				`- Summary: ${boundedTail(prior.summary, 1_500) || "(none)"}`,
+				`- Artifacts: ${formatList(prior.artifacts)}`,
+				`- Last streamed evidence: ${boundedTail(prior.outputTail, 2_500) || "(none)"}`,
+			]
+		: ["No prior checkpoint exists for this shard."];
+	return [
+		"[OMK deadline/checkpoint execution contract]",
+		`Execution shard: ${options.shardId} (${options.shardIndex + 1}/${options.shardCount}), attempt ${options.attempt}.`,
+		`This attempt has about ${options.cutoffMs}ms. Work in small, complete semantic units.`,
+		`After each completed unit, overwrite ${options.checkpointFilePath} with JSON:`,
+		'{"version":1,"completed":["..."],"remaining":["..."],"summary":"...","artifacts":["..."]}',
+		"Only checkpoint work that is actually complete. Keep each field concise.",
+		"On resume, inspect the current workspace first. Do not repeat completed side effects or rerun expensive discovery already evidenced below.",
+		...priorSection,
+		"",
+		"Original logical task (context only):",
+		boundedTail(options.originalTask, 2_500),
+		"",
+		"Current shard:",
+		currentTask,
+		"Return a self-contained result for this shard.",
+	].join("\n");
+}
+
+export function checkpointMadeProgress(before: AgentCheckpoint | undefined, after: AgentCheckpoint): boolean {
+	if (before === undefined) {
+		return after.messageCount > 0 || after.completed.length > 0 || after.summary !== "" || after.outputTail !== "";
+	}
+	return (
+		after.messageCount > before.messageCount ||
+		after.outputTail !== before.outputTail ||
+		after.summary !== before.summary ||
+		!arrayEquals(after.completed, before.completed) ||
+		!arrayEquals(after.remaining, before.remaining) ||
+		!arrayEquals(after.artifacts, before.artifacts)
+	);
+}
+
+export function boundedTail(value: string, maxChars: number): string {
+	if (value.length <= maxChars) return value;
+	return `[...${value.length - maxChars} earlier chars omitted...]\n${value.slice(-maxChars)}`;
+}
+
+export function createEmptyCheckpoint(): AgentCheckpoint {
+	return {
+		version: 1,
+		completed: [],
+		remaining: [],
+		summary: "",
+		artifacts: [],
+		messageCount: 0,
+		outputTail: "",
+		lastEventAtMs: 0,
+	};
+}
+
+function withEvidence(checkpoint: AgentCheckpoint, evidence: CheckpointEvidence): AgentCheckpoint {
+	return {
+		...checkpoint,
+		messageCount: Math.max(0, evidence.messageCount),
+		outputTail: boundedTail(evidence.outputTail, 4_000),
+		lastEventAtMs: Math.max(0, evidence.lastEventAtMs),
+	};
+}
+
+function readStringList(value: unknown): string[] {
+	if (!Array.isArray(value)) return [];
+	return value
+		.filter((item): item is string => typeof item === "string")
+		.map((item) => readString(item, MAX_ITEM_CHARS))
+		.filter((item) => item !== "")
+		.slice(0, MAX_LIST_ITEMS);
+}
+
+function readString(value: unknown, maxChars: number): string {
+	return typeof value === "string" ? value.trim().slice(0, maxChars) : "";
+}
+
+function formatList(values: readonly string[]): string {
+	return values.length === 0 ? "(none)" : values.map((value) => boundedTail(value, 256)).join("; ");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function arrayEquals(left: readonly string[], right: readonly string[]): boolean {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}

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 });
+	});
+});