open-multi-agent-kit 0.78.0

package/dist/goal/persistence.js

@@ -0,0 +1,134 @@
+import { mkdir, readFile, writeFile, readdir, rename, unlink, } from "fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
+const INACTIVE_STATUSES = ["done", "failed", "cancelled", "closed"];
+function safePath(basePath, inputPath) {
+    if (isAbsolute(inputPath)) {
+        throw new Error(`GoalPersister: absolute paths are not allowed: ${inputPath}`);
+    }
+    const full = resolve(join(basePath, inputPath));
+    const rel = relative(basePath, full);
+    if (rel.startsWith("..") || rel === "..") {
+        throw new Error(`GoalPersister: path traversal detected: ${inputPath}`);
+    }
+    return full;
+}
+function goalDir(basePath, goalId) {
+    const sanitized = goalId.replace(/[^a-zA-Z0-9_.-]/g, "");
+    if (sanitized !== goalId || sanitized.length === 0 || sanitized.length > 128) {
+        throw new Error(`Invalid goalId: ${goalId}`);
+    }
+    return safePath(basePath, sanitized);
+}
+function atomicWrite(filePath, content) {
+    return new Promise((resolve, reject) => {
+        const tempPath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+        mkdir(dirname(filePath), { recursive: true })
+            .then(() => writeFile(tempPath, content, "utf-8"))
+            .then(() => rename(tempPath, filePath))
+            .then(() => resolve())
+            .catch(async (err) => {
+            try {
+                await unlink(tempPath);
+            }
+            catch {
+                // ignore cleanup error
+            }
+            reject(err);
+        });
+    });
+}
+export function createGoalPersister(basePath = ".omk/goals") {
+    return {
+        async load(goalId) {
+            const filePath = join(goalDir(basePath, goalId), "goal.json");
+            try {
+                const content = await readFile(filePath, "utf-8");
+                const parsed = JSON.parse(content);
+                if (!parsed || typeof parsed !== "object") {
+                    console.warn(`GoalPersister: corrupt JSON for ${goalId} — not an object`);
+                    return null;
+                }
+                const obj = parsed;
+                if (obj.schemaVersion !== 1) {
+                    console.warn(`GoalPersister: unsupported schemaVersion for ${goalId}: ${obj.schemaVersion}`);
+                    return null;
+                }
+                return parsed;
+            }
+            catch (err) {
+                if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+                    return null;
+                }
+                console.warn(`GoalPersister: failed to load ${goalId}: ${err instanceof Error ? err.message : String(err)}`);
+                return null;
+            }
+        },
+        async save(spec) {
+            spec.updatedAt = new Date().toISOString();
+            const dir = goalDir(basePath, spec.goalId);
+            await mkdir(dir, { recursive: true });
+            const filePath = join(dir, "goal.json");
+            await atomicWrite(filePath, JSON.stringify(spec, null, 2));
+        },
+        async list() {
+            try {
+                const entries = await readdir(basePath, { withFileTypes: true });
+                const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+                const withMtime = await Promise.all(dirs.map(async (id) => {
+                    const spec = await this.load(id);
+                    return { id, updatedAt: spec?.updatedAt ?? "1970-01-01T00:00:00.000Z" };
+                }));
+                return withMtime
+                    .filter((g) => g.updatedAt !== "1970-01-01T00:00:00.000Z")
+                    .sort((a, b) => {
+                    const timeDiff = b.updatedAt.localeCompare(a.updatedAt);
+                    return timeDiff !== 0 ? timeDiff : b.id.localeCompare(a.id);
+                })
+                    .map((g) => g.id);
+            }
+            catch {
+                return [];
+            }
+        },
+        async loadEvidence(goalId) {
+            const filePath = join(goalDir(basePath, goalId), "evidence.json");
+            try {
+                const content = await readFile(filePath, "utf-8");
+                return JSON.parse(content);
+            }
+            catch {
+                return [];
+            }
+        },
+        async saveEvidence(goalId, evidence) {
+            const dir = goalDir(basePath, goalId);
+            await mkdir(dir, { recursive: true });
+            const filePath = join(dir, "evidence.json");
+            await atomicWrite(filePath, JSON.stringify(evidence, null, 2));
+        },
+        async appendHistory(goalId, entry) {
+            const dir = goalDir(basePath, goalId);
+            await mkdir(dir, { recursive: true });
+            const filePath = join(dir, "history.jsonl");
+            const line = JSON.stringify(entry) + "\n";
+            await writeFile(filePath, line, { flag: "a", encoding: "utf-8" });
+        },
+        async loadLatestActive() {
+            try {
+                const entries = await readdir(basePath, { withFileTypes: true });
+                const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+                const specs = await Promise.all(dirs.map(async (id) => {
+                    const spec = await this.load(id);
+                    return { id, spec };
+                }));
+                const active = specs
+                    .filter((s) => s.spec !== null && !INACTIVE_STATUSES.includes(s.spec.status))
+                    .sort((a, b) => b.spec.updatedAt.localeCompare(a.spec.updatedAt));
+                return active[0]?.spec ?? null;
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}

package/dist/goal/prompt-digest.d.ts

@@ -0,0 +1,13 @@
+export interface PromptDigestOptions {
+    maxKeywords?: number;
+    maxPhrases?: number;
+}
+/**
+ * Render a compact, non-verbatim reference for a user prompt or goal.
+ *
+ * Goal-followup prompts should carry enough context for Kimi to infer the next
+ * action without re-sending the user's original input as the next prompt.
+ */
+export declare function renderPromptDigest(title: string, value: string | undefined, options?: PromptDigestOptions): string;
+export declare function promptDigestFingerprint(value: string): string;
+export declare function extractPromptKeywords(value: string, maxKeywords?: number): string[];

package/dist/goal/prompt-digest.js

@@ -0,0 +1,111 @@
+import { createHash } from "crypto";
+const DEFAULT_MAX_KEYWORDS = 14;
+const DEFAULT_MAX_PHRASES = 2;
+const TOKEN_PATTERN = /[\p{L}\p{N}_-]+/gu;
+const STOPWORDS = new Set([
+    "the",
+    "and",
+    "for",
+    "with",
+    "that",
+    "this",
+    "from",
+    "into",
+    "should",
+    "must",
+    "have",
+    "been",
+    "were",
+    "are",
+    "was",
+    "not",
+    "use",
+    "using",
+    "하다",
+    "해서",
+    "하면",
+    "그리고",
+    "으로",
+    "에서",
+    "에게",
+    "좀",
+    "현재",
+    "일단",
+]);
+/**
+ * Render a compact, non-verbatim reference for a user prompt or goal.
+ *
+ * Goal-followup prompts should carry enough context for Kimi to infer the next
+ * action without re-sending the user's original input as the next prompt.
+ */
+export function renderPromptDigest(title, value, options = {}) {
+    const normalized = normalizePromptText(value ?? "");
+    if (!normalized)
+        return "";
+    const keywords = extractPromptKeywords(normalized, options.maxKeywords ?? DEFAULT_MAX_KEYWORDS);
+    const intentSketch = sketchPromptIntent(normalized, options.maxPhrases ?? DEFAULT_MAX_PHRASES);
+    return [
+        `${title}:`,
+        `- digest: ${promptDigestFingerprint(normalized)}`,
+        `- keywords: ${keywords.length > 0 ? keywords.join(", ") : "none"}`,
+        `- intent sketch: ${intentSketch.length > 0 ? intentSketch.join(" / ") : "context unavailable"}`,
+        `- verbatim source: omitted to prevent input replay; synthesize from evidence and state.`,
+    ].join("\n");
+}
+export function promptDigestFingerprint(value) {
+    return createHash("sha256")
+        .update(normalizePromptText(value))
+        .digest("hex")
+        .slice(0, 12);
+}
+export function extractPromptKeywords(value, maxKeywords = DEFAULT_MAX_KEYWORDS) {
+    const seen = new Set();
+    const tokens = normalizePromptText(value).toLocaleLowerCase().match(TOKEN_PATTERN) ?? [];
+    const result = [];
+    for (const token of tokens) {
+        if (token.length < 2)
+            continue;
+        if (/^\d+$/u.test(token))
+            continue;
+        if (STOPWORDS.has(token))
+            continue;
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        result.push(token);
+        if (result.length >= maxKeywords)
+            break;
+    }
+    return result;
+}
+function sketchPromptIntent(value, maxPhrases) {
+    const phrases = [];
+    const clauses = normalizePromptText(value)
+        .split(/[.!?;\n]+/u)
+        .map((part) => part.trim())
+        .filter(Boolean);
+    for (const clause of clauses) {
+        const clauseKeywords = extractPromptKeywords(clause, 7);
+        if (clauseKeywords.length === 0)
+            continue;
+        phrases.push(clauseKeywords.join(" "));
+        if (phrases.length >= maxPhrases)
+            break;
+    }
+    return phrases;
+}
+function normalizePromptText(value) {
+    return redactPromptSecrets(value
+        .normalize("NFKC")
+        .replace(/\s+/g, " ")
+        .trim());
+}
+function redactPromptSecrets(value) {
+    return value
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]{12,}/gi, "Bearer [REDACTED_TOKEN]")
+        .replace(/sk-[A-Za-z0-9_-]{16,}/g, "[REDACTED_API_KEY]")
+        .replace(/(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{16,}/g, "[REDACTED_GITHUB_TOKEN]")
+        .replace(/AKIA[0-9A-Z]{16}/g, "[REDACTED_AWS_KEY]")
+        .replace(/[A-Z][A-Z0-9_]*(?:SECRET|TOKEN|KEY|PASSWORD)\s*=\s*[^\s`'"]{6,}/g, "[REDACTED_ENV_SECRET]")
+        .replace(/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, "[REDACTED_PRIVATE_KEY]");
+}

package/dist/goal/scoring.d.ts

@@ -0,0 +1,2 @@
+import type { GoalEvidence, GoalScore, GoalSpec } from "../contracts/goal.js";
+export declare function scoreGoal(goal: GoalSpec, evidence: GoalEvidence[]): GoalScore;

package/dist/goal/scoring.js

@@ -0,0 +1,69 @@
+export function scoreGoal(goal, evidence) {
+    const evidenceByCriterion = latestEvidenceByCriterion(evidence);
+    const requiredCriteria = goal.successCriteria.filter((c) => c.requirement === "required");
+    const optionalCriteria = goal.successCriteria.filter((c) => c.requirement === "optional");
+    let requiredPassed = 0;
+    let requiredFailed = 0;
+    for (const criterion of requiredCriteria) {
+        const ev = evidenceByCriterion.get(criterion.id);
+        if (ev?.passed) {
+            requiredPassed++;
+        }
+        else if (ev && !ev.passed) {
+            requiredFailed++;
+        }
+    }
+    let optionalWeightedSum = 0;
+    let optionalWeightTotal = 0;
+    for (const criterion of optionalCriteria) {
+        const ev = evidenceByCriterion.get(criterion.id);
+        optionalWeightTotal += criterion.weight;
+        if (ev?.passed) {
+            optionalWeightedSum += criterion.weight;
+        }
+    }
+    const optionalScore = optionalWeightTotal > 0 ? optionalWeightedSum / optionalWeightTotal : 0;
+    // Quality gate: all artifact gates must pass
+    const artifactEvidence = [...evidenceByCriterion.values()].filter((e) => e.criterionId.startsWith("artifact:"));
+    const qualityGatePassed = artifactEvidence.length === 0 || artifactEvidence.every((e) => e.passed);
+    let overall;
+    if (requiredFailed > 0) {
+        overall = "fail";
+    }
+    else if (requiredPassed < requiredCriteria.length) {
+        overall = "incomplete";
+    }
+    else if (!qualityGatePassed) {
+        overall = "fail";
+    }
+    else if (requiredPassed === requiredCriteria.length && optionalScore >= 0.5) {
+        overall = "pass";
+    }
+    else if (requiredPassed === requiredCriteria.length) {
+        overall = "pass";
+    }
+    else {
+        overall = "incomplete";
+    }
+    return {
+        requiredTotal: requiredCriteria.length,
+        requiredPassed,
+        optionalScore: Math.round(optionalScore * 100) / 100,
+        qualityGatePassed,
+        overall,
+    };
+}
+function latestEvidenceByCriterion(evidence) {
+    const latest = new Map();
+    for (const ev of evidence) {
+        const previous = latest.get(ev.criterionId);
+        if (!previous || evidenceCheckedAt(ev) >= evidenceCheckedAt(previous)) {
+            latest.set(ev.criterionId, ev);
+        }
+    }
+    return latest;
+}
+function evidenceCheckedAt(evidence) {
+    const timestamp = Date.parse(evidence.checkedAt);
+    return Number.isFinite(timestamp) ? timestamp : Number.NEGATIVE_INFINITY;
+}

package/dist/goal/wake-policy.d.ts

@@ -0,0 +1,26 @@
+export interface WakeTrigger {
+    type: "time" | "run-failed" | "evidence-missing" | "file-changed" | "browser-feedback" | "manual";
+    interval?: string;
+    paths?: string[];
+    action: "continue" | "replan" | "verify" | "ask-human" | "close";
+}
+export interface WakePolicy {
+    schemaVersion: 1;
+    goalId: string;
+    wakeTriggers: WakeTrigger[];
+    budgets: {
+        maxIterations: number;
+        maxWallClockHours: number;
+        maxDailyCostUsd: number;
+        maxConsecutiveFailures: number;
+    };
+    approval: {
+        write: "auto" | "interactive";
+        shell: "auto" | "interactive";
+        publish: "auto" | "block";
+        secrets: "auto" | "block";
+    };
+}
+export declare function loadWakePolicy(goalId: string): Promise<WakePolicy | null>;
+export declare function saveWakePolicy(policy: WakePolicy): Promise<void>;
+export declare function createDefaultWakePolicy(goalId: string): WakePolicy;

package/dist/goal/wake-policy.js

@@ -0,0 +1,58 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { getProjectRoot } from "../util/fs.js";
+function getWakePolicyPath(goalId) {
+    const root = getProjectRoot();
+    return join(root, ".omk", "goals", goalId, "wake-policy.json");
+}
+export async function loadWakePolicy(goalId) {
+    const path = getWakePolicyPath(goalId);
+    try {
+        const content = await readFile(path, "utf-8");
+        const parsed = JSON.parse(content);
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        const obj = parsed;
+        if (obj.schemaVersion !== 1) {
+            return null;
+        }
+        return parsed;
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+            return null;
+        }
+        console.warn(`Failed to load wake policy for ${goalId}: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+export async function saveWakePolicy(policy) {
+    const path = getWakePolicyPath(policy.goalId);
+    await mkdir(join(getProjectRoot(), ".omk", "goals", policy.goalId), { recursive: true });
+    await writeFile(path, JSON.stringify(policy, null, 2), "utf-8");
+}
+export function createDefaultWakePolicy(goalId) {
+    return {
+        schemaVersion: 1,
+        goalId,
+        wakeTriggers: [
+            { type: "time", interval: "6h", action: "continue" },
+            { type: "run-failed", action: "replan" },
+            { type: "evidence-missing", action: "continue" },
+            { type: "manual", action: "continue" },
+        ],
+        budgets: {
+            maxIterations: 10,
+            maxWallClockHours: 24,
+            maxDailyCostUsd: 5,
+            maxConsecutiveFailures: 3,
+        },
+        approval: {
+            write: "interactive",
+            shell: "interactive",
+            publish: "block",
+            secrets: "block",
+        },
+    };
+}

package/dist/harness/create-harness-task-runner.d.ts

@@ -0,0 +1,43 @@
+import type { TaskRunner } from "../contracts/orchestration.js";
+import type { OmkRuntimeScope } from "../contracts/worker-context.js";
+import { type ProviderBackedTaskRunnerOptions } from "../providers/provider-runtime.js";
+import type { ProviderPolicy } from "../providers/types.js";
+import { type RuntimeBackedTaskRunnerOptions } from "../runtime/runtime-backed-task-runner.js";
+export type HarnessTaskRunnerMode = "chat" | "run" | "parallel";
+type RuntimeBackedFactory = (options: RuntimeBackedTaskRunnerOptions) => Promise<TaskRunner>;
+type ProviderBackedFactory = (options: ProviderBackedTaskRunnerOptions) => Promise<TaskRunner>;
+export interface HarnessTaskRunnerProviderOptions {
+    agentFile?: string;
+    promptPrefix?: string;
+    mcpScope?: OmkRuntimeScope;
+    skillsScope?: OmkRuntimeScope;
+    hooksScope?: OmkRuntimeScope;
+    mcpNames?: string[];
+    skillNames?: string[];
+    hookNames?: string[];
+    toolNames?: string[];
+    model?: string;
+    eventRunDir?: string;
+    deepseekPromptPrefix?: string;
+    allowDeepSeekAdvisoryFileNodes?: boolean;
+    fallbackChain?: string[];
+    providerBackedOptions?: Omit<ProviderBackedTaskRunnerOptions, "cwd" | "providerPolicy" | "kimi"> & {
+        kimi?: ProviderBackedTaskRunnerOptions["kimi"];
+    };
+}
+export interface HarnessTaskRunnerOptions {
+    root: string;
+    runId: string;
+    mode: HarnessTaskRunnerMode;
+    providerPolicy: ProviderPolicy;
+    env?: Record<string, string>;
+    useRuntimeBacked?: boolean;
+    runtimeOptions?: Partial<Pick<RuntimeBackedTaskRunnerOptions, "runtimePolicy" | "defaultRuntime" | "fallbackChain" | "goal" | "onOutput">>;
+    providerOptions?: HarnessTaskRunnerProviderOptions;
+    factories?: {
+        runtimeBacked?: RuntimeBackedFactory;
+        providerBacked?: ProviderBackedFactory;
+    };
+}
+export declare function createHarnessTaskRunner(options: HarnessTaskRunnerOptions): Promise<TaskRunner>;
+export {};

package/dist/harness/create-harness-task-runner.js

@@ -0,0 +1,56 @@
+import { createProviderBackedTaskRunner, } from "../providers/provider-runtime.js";
+import { createRuntimeBackedTaskRunner, } from "../runtime/runtime-backed-task-runner.js";
+export async function createHarnessTaskRunner(options) {
+    const env = {
+        ...(options.env ?? {}),
+        OMK_RUN_ID: options.runId,
+    };
+    if (options.useRuntimeBacked === true || options.mode === "chat") {
+        const factory = options.factories?.runtimeBacked ?? createRuntimeBackedTaskRunner;
+        return factory({
+            cwd: options.root,
+            env,
+            runId: options.runId,
+            runtimePolicy: options.runtimeOptions?.runtimePolicy ?? options.providerPolicy,
+            defaultRuntime: options.runtimeOptions?.defaultRuntime,
+            fallbackChain: options.runtimeOptions?.fallbackChain,
+            goal: options.runtimeOptions?.goal,
+            onOutput: options.runtimeOptions?.onOutput,
+        });
+    }
+    const providerOptions = options.providerOptions ?? {};
+    const providerEnv = {
+        ...env,
+        ...(providerOptions.model ? { OMK_PROVIDER_MODEL: providerOptions.model } : {}),
+    };
+    const factory = options.factories?.providerBacked ?? createProviderBackedTaskRunner;
+    return factory({
+        ...(providerOptions.providerBackedOptions ?? {}),
+        cwd: options.root,
+        providerPolicy: options.providerPolicy,
+        eventRunDir: providerOptions.eventRunDir ?? providerOptions.providerBackedOptions?.eventRunDir,
+        deepseekPromptPrefix: providerOptions.deepseekPromptPrefix ?? providerOptions.providerBackedOptions?.deepseekPromptPrefix,
+        allowDeepSeekAdvisoryFileNodes: providerOptions.allowDeepSeekAdvisoryFileNodes
+            ?? providerOptions.providerBackedOptions?.allowDeepSeekAdvisoryFileNodes,
+        fallbackChain: providerOptions.fallbackChain ?? providerOptions.providerBackedOptions?.fallbackChain,
+        kimi: {
+            ...(providerOptions.providerBackedOptions?.kimi ?? {}),
+            cwd: providerOptions.providerBackedOptions?.kimi?.cwd ?? options.root,
+            timeout: providerOptions.providerBackedOptions?.kimi?.timeout ?? 0,
+            agentFile: providerOptions.agentFile ?? providerOptions.providerBackedOptions?.kimi?.agentFile,
+            promptPrefix: providerOptions.promptPrefix ?? providerOptions.providerBackedOptions?.kimi?.promptPrefix,
+            mcpScope: providerOptions.mcpScope ?? providerOptions.providerBackedOptions?.kimi?.mcpScope ?? "project",
+            skillsScope: providerOptions.skillsScope ?? providerOptions.providerBackedOptions?.kimi?.skillsScope ?? "project",
+            hooksScope: providerOptions.hooksScope ?? providerOptions.providerBackedOptions?.kimi?.hooksScope ?? "project",
+            roleAgentFiles: providerOptions.providerBackedOptions?.kimi?.roleAgentFiles ?? true,
+            mcpNames: providerOptions.mcpNames ?? providerOptions.providerBackedOptions?.kimi?.mcpNames ?? [],
+            skillNames: providerOptions.skillNames ?? providerOptions.providerBackedOptions?.kimi?.skillNames ?? [],
+            hookNames: providerOptions.hookNames ?? providerOptions.providerBackedOptions?.kimi?.hookNames ?? [],
+            toolNames: providerOptions.toolNames ?? providerOptions.providerBackedOptions?.kimi?.toolNames ?? [],
+            env: {
+                ...(providerOptions.providerBackedOptions?.kimi?.env ?? {}),
+                ...providerEnv,
+            },
+        },
+    });
+}

package/dist/harness/execute-harness-run.d.ts

@@ -0,0 +1,34 @@
+import type { ApprovalPolicy, RunResult, RunState, TaskRunner, TaskResult } from "../contracts/orchestration.js";
+import type { EnvMergeTraceEntry, EnvMergeTraceSource } from "../contracts/worker-context.js";
+import type { Dag, DagNode } from "../orchestration/dag.js";
+import type { EnsemblePolicy } from "../orchestration/ensemble.js";
+import { type StatePersister } from "../orchestration/state-persister.js";
+export interface ExecuteHarnessRunInput {
+    root: string;
+    runId: string;
+    dag: Dag;
+    runner: TaskRunner;
+    env?: Record<string, string>;
+    workers: number;
+    approvalPolicy: ApprovalPolicy;
+    timeoutPreset?: string;
+    nodeTimeoutMs?: number;
+    runTimeoutMs?: number;
+    heartbeatIntervalMs?: number;
+    signal?: AbortSignal;
+    persister?: StatePersister;
+    eventRunDir?: string;
+    ensemble?: false | EnsemblePolicy;
+    resumeFromState?: RunState;
+    onStateChange?: (state: RunState) => void;
+    onNodeStart?: (node: DagNode) => void;
+    onNodeComplete?: (node: DagNode, result: TaskResult) => void;
+}
+export declare function mergeEnvWithTrace(sources: Array<{
+    source: EnvMergeTraceSource;
+    env: Record<string, string>;
+}>): {
+    env: Record<string, string>;
+    trace: EnvMergeTraceEntry[];
+};
+export declare function executeHarnessRun(input: ExecuteHarnessRunInput): Promise<RunResult>;

package/dist/harness/execute-harness-run.js

@@ -0,0 +1,109 @@
+import { join } from "node:path";
+import { createExecutor } from "../orchestration/executor.js";
+import { createStatePersister } from "../orchestration/state-persister.js";
+import { envFromWorkerManifest } from "../runtime/worker-manifest.js";
+function contextWithBaseEnv(context, env) {
+    const mcpConfigFile = env.OMK_MCP_CONFIG_FILE;
+    if (!context || !mcpConfigFile || context.worker.toolPlane.mcpConfigFile)
+        return context;
+    return {
+        ...context,
+        worker: {
+            ...context.worker,
+            toolPlane: {
+                ...context.worker.toolPlane,
+                mcpConfigFile,
+            },
+        },
+    };
+}
+function withHarnessEnv(runner, env) {
+    if (!env || Object.keys(env).length === 0)
+        return runner;
+    return {
+        ...(runner.onThinking ? { onThinking: runner.onThinking } : {}),
+        run(node, nodeEnv, signal, context) {
+            const nextContext = contextWithBaseEnv(context, env);
+            const merged = mergeEnvWithTrace([
+                { source: "base", env },
+                { source: "node", env: nodeEnv },
+                { source: "worker-manifest", env: nextContext ? envFromWorkerManifest(nextContext.worker) : {} },
+            ]);
+            return runner.run(node, merged.env, signal, appendEnvMergeTrace(nextContext, merged.trace));
+        },
+        ...(runner.fork
+            ? {
+                fork(onThinking) {
+                    return withHarnessEnv(runner.fork?.(onThinking) ?? runner, env);
+                },
+            }
+            : {}),
+    };
+}
+export function mergeEnvWithTrace(sources) {
+    const env = {};
+    const trace = [];
+    for (const { source, env: sourceEnv } of sources) {
+        for (const [key, next] of Object.entries(sourceEnv)) {
+            const previous = env[key];
+            if (next === "" && previous) {
+                trace.push({ key, previous, next, source, action: "preserve-non-empty" });
+                continue;
+            }
+            if (next === "" && previous === undefined) {
+                trace.push({ key, next, source, action: "drop-empty" });
+                continue;
+            }
+            env[key] = next;
+            trace.push({
+                key,
+                previous,
+                next,
+                source,
+                action: previous === undefined ? "set" : "overwrite",
+            });
+        }
+    }
+    return { env, trace };
+}
+function appendEnvMergeTrace(context, envMergeTrace) {
+    if (!context)
+        return context;
+    return {
+        ...context,
+        diagnostics: {
+            ...context.diagnostics,
+            envMergeTrace,
+        },
+    };
+}
+export async function executeHarnessRun(input) {
+    const executor = createExecutor({
+        persister: input.persister ?? createStatePersister(join(input.root, ".omk", "runs")),
+        ensemble: input.ensemble ?? false,
+        signal: input.signal,
+        resumeFromState: input.resumeFromState,
+        eventRunDir: input.eventRunDir,
+    });
+    if (input.onStateChange)
+        executor.onStateChange(input.onStateChange);
+    if (input.onNodeStart && executor.onNodeStart)
+        executor.onNodeStart(input.onNodeStart);
+    if (input.onNodeComplete && executor.onNodeComplete)
+        executor.onNodeComplete(input.onNodeComplete);
+    const runOptions = {
+        runId: input.runId,
+        workers: input.workers,
+        approvalPolicy: input.approvalPolicy,
+        worktreeRoot: input.root,
+    };
+    if (input.timeoutPreset !== undefined)
+        runOptions.timeoutPreset = input.timeoutPreset;
+    if (input.nodeTimeoutMs !== undefined)
+        runOptions.nodeTimeoutMs = input.nodeTimeoutMs;
+    if (input.runTimeoutMs !== undefined)
+        runOptions.runTimeoutMs = input.runTimeoutMs;
+    if (input.heartbeatIntervalMs !== undefined)
+        runOptions.heartbeatIntervalMs = input.heartbeatIntervalMs;
+    return executor.execute(input.dag, withHarnessEnv(input.runner, input.env), runOptions);
+}