open-multi-agent-kit 0.91.0 → 0.93.0

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/domain-profiles.ts

@@ -23,6 +23,278 @@ export interface DomainProfile {
 
 /** All domain profiles, ordered so that more specific domains precede general ones. */
 export const DOMAIN_PROFILES: readonly DomainProfile[] = [
+	// ── OMK-native elite domains (prepended — name-weighted, high specificity) ──
+
+	{
+		id: "omk-core-eng",
+		label: "OMK Core Engineering Lanes",
+		keywords: [
+			/omk-?coder/i,
+			/omk-?explorer/i,
+			/omk-?reviewer/i,
+			/omk-?tester/i,
+			/omk-?architect/i,
+			/omk-?qa\b/i,
+			/omk-?diffsurgeon/i,
+			/omk-?vision-?debugger/i,
+			/diff.?surgeon/i,
+			/vision.?debugger/i,
+			/\bcodemod\b/i,
+			/\btypecheck\b/i,
+		],
+		skillPool: [
+			"programming",
+			"debugging",
+			"ponytail",
+			"ast-grep",
+			"lsp",
+			"refactor",
+			"review-work",
+			"code-review",
+			"tdd-workflow",
+			"git-master",
+			"gstack",
+			"remove-ai-slops",
+			"ponytail-review",
+			"ponytail-audit",
+			"visual-qa",
+			"frontend",
+			"understand-anything",
+			"headroom",
+			"ulw-plan",
+			"python-testing",
+			"golang-testing",
+			"rust-testing",
+		],
+		defaultMcp: [
+			"filesystem",
+			"context7",
+			"memory",
+			"understand-anything",
+			"lean-ctx",
+			"chrome-devtools",
+			"playwright",
+			"zai-vision",
+		],
+		defaultHooks: [
+			"session-context",
+			"post-format",
+			"typecheck-after-edit",
+			"eslint-after-edit",
+			"stop-verify",
+			"branch-diff-snapshot",
+		],
+	},
+
+	{
+		id: "omk-orchestration",
+		label: "OMK Orchestration & Lanes",
+		keywords: [
+			/omk-?conductor/i,
+			/omk-?router/i,
+			/omk-?planner/i,
+			/omk-?aggregator/i,
+			/omk-?integrator/i,
+			/omk-?loopback/i,
+			/omk-?worktree/i,
+			/\bconductor\b/i,
+			/\blane.?grant/i,
+			/omk-?ontology/i,
+			/\bsubagent/i,
+			/\borchestrat/i,
+		],
+		skillPool: [
+			"adaptorch-route",
+			"adaptorch",
+			"omk-plan",
+			"ulw-plan",
+			"understand-anything",
+			"headroom",
+			"omk-loop",
+			"omk-agent-ops",
+			"omk-engineering",
+			"gstack",
+			"git-master",
+		],
+		defaultMcp: ["adaptorch", "memory", "understand-anything"],
+		defaultHooks: ["session-context", "precompact-checkpoint", "subagent-stop-audit"],
+	},
+	{
+		id: "omk-godmode-research",
+		label: "OMK Max-Capability Research",
+		keywords: [
+			/omk-?godmode/i,
+			/omk-?godmod/i,
+			/\bgodmode\b/i,
+			/offensive-?jailbreak/i,
+			/full.?spectrum/i,
+			/max-?capability/i,
+		],
+		skillPool: [
+			"omk-godmod",
+			"offensive-jailbreak",
+			"reverse-skill",
+			"programming",
+			"insane-search",
+			"debugging",
+			"security-review",
+			"omk-crawling",
+		],
+		defaultMcp: ["filesystem", "memory", "fetch", "firecrawl", "ghidra", "playwright"],
+		defaultHooks: ["session-context", "subagent-stop-audit"],
+	},
+	{
+		id: "omk-reverse",
+		label: "OMK Reverse Engineering",
+		keywords: [
+			/omk-?re\b/i,
+			/reverse-?skill/i,
+			/reverse.?engineer/i,
+			/\bdecompile/i,
+			/\bghidra\b/i,
+			/\bjadx\b/i,
+			/\bctf\b/i,
+			/\bapk\b/i,
+		],
+		skillPool: ["reverse-skill", "security-review", "programming", "insane-search", "debugging", "omk-crawling"],
+		defaultMcp: ["filesystem", "memory", "ghidra", "chrome-devtools", "playwright"],
+		defaultHooks: ["session-context", "subagent-stop-audit"],
+	},
+	{
+		id: "omk-crawl-search",
+		label: "OMK Crawl & Hard-Web Fetch",
+		keywords: [
+			/omk-?crawler/i,
+			/omk-?crawling/i,
+			/insane-?search/i,
+			/\bwaf\b/i,
+			/blocked.?url/i,
+			/web.?fetch/i,
+			/hard.?web/i,
+		],
+		skillPool: ["insane-search", "omk-crawling", "adaptorch", "headroom", "gstack"],
+		defaultMcp: ["fetch", "firecrawl", "playwright", "chrome-devtools", "memory"],
+		defaultHooks: ["session-context"],
+	},
+	{
+		id: "omk-minimalism",
+		label: "OMK Ponytail Minimalism",
+		keywords: [
+			/omk-?ponytail/i,
+			/\bponytail\b/i,
+			/\byagni\b/i,
+			/over-?engineer/i,
+			/slopcutter/i,
+			/remove-?ai-?slop/i,
+			/\bminimalism\b/i,
+		],
+		skillPool: [
+			"ponytail",
+			"ponytail-review",
+			"ponytail-audit",
+			"remove-ai-slops",
+			"refactor",
+			"programming",
+			"docs-write-concisely",
+			"polish",
+		],
+		defaultMcp: ["filesystem", "context7", "memory"],
+		defaultHooks: ["post-format", "typecheck-after-edit"],
+	},
+	{
+		id: "omk-debug-perf",
+		label: "OMK Debug & Performance",
+		keywords: [
+			/omk-?debugger/i,
+			/omk-?perf/i,
+			/omk-?tdd/i,
+			/omk-?sre/i,
+			/root-?cause/i,
+			/\bheisenbug\b/i,
+			/\bflaky\b/i,
+			/\bincident\b/i,
+			/\bbenchmark\b/i,
+			/\bhotspot\b/i,
+		],
+		skillPool: [
+			"debugging",
+			"tdd-workflow",
+			"programming",
+			"ast-grep",
+			"lsp",
+			"python-testing",
+			"golang-testing",
+			"rust-testing",
+			"refactor",
+			"ponytail",
+			"omk-loop",
+			"omk-agent-ops",
+			"gstack",
+		],
+		defaultMcp: ["filesystem", "context7", "memory", "github"],
+		defaultHooks: ["typecheck-after-edit", "post-format", "session-context"],
+	},
+	{
+		id: "omk-ship",
+		label: "OMK Release & Gstack Ship",
+		keywords: [
+			/omk-?release/i,
+			/omk-?gstack/i,
+			/\bgstack\b/i,
+			/\bchangelog\b/i,
+			/\bsemver\b/i,
+			/\bcut.?release\b/i,
+			/\bland.?pr\b/i,
+			/worktree/i,
+		],
+		skillPool: [
+			"gstack",
+			"git-master",
+			"review-work",
+			"programming",
+			"omk-agent-ops",
+			"docs-update-docs",
+			"omk-loop",
+		],
+		defaultMcp: ["filesystem", "memory", "github"],
+		defaultHooks: [
+			"release-check-before-stop",
+			"npm-audit-summary",
+			"branch-diff-snapshot",
+			"protect-secrets",
+			"stop-verify",
+			"worktree-create-guard",
+		],
+	},
+	{
+		id: "omk-docs-ui",
+		label: "OMK Docs & Frontend",
+		keywords: [
+			/omk-?docs/i,
+			/omk-?frontend/i,
+			/docs-write-concisely/i,
+			/docs-update-docs/i,
+			/\breadme\b/i,
+			/tech.?writing/i,
+			/visual-?qa/i,
+			/\ba11y\b/i,
+		],
+		skillPool: [
+			"docs-write-concisely",
+			"docs-update-docs",
+			"remove-ai-slops",
+			"polish",
+			"frontend",
+			"frontend-patterns",
+			"visual-qa",
+			"programming",
+			"ponytail",
+			"headroom",
+		],
+		defaultMcp: ["filesystem", "memory", "context7", "chrome-devtools", "playwright", "zai-vision"],
+		defaultHooks: ["post-format", "typecheck-after-edit", "eslint-after-edit", "session-context"],
+	},
+
 	{
 		id: "frontend-web",
 		label: "Frontend & Web",

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